Scraper

"""
File contains test for the scraper tool
"""
from unittest import TestCase
from datetime import datetime, timedelta, tzinfo
from logging import Logger
from pytz import timezone
from rss_tool.scraper import Scraper


class TestScraper(TestCase):
    """
    Class containing all tests for the scraper tool
    """

    base = {
        "title": "Bacon ipsum dolor amet capicola",
        "description": "alcatra venison hamburger shoulder filet mignon",
        "items": ["https://baconipsum.com/"],
        "last_updated": datetime(2020, 6, 10, 14, 52, 0),
    }

    tz: tzinfo = timezone('Europe/Amsterdam')

    def test_class_initialized(self):
        """Testing to see if class inits as expected"""
        scraper = Scraper()

        self.assertIsInstance(scraper, Scraper)
        self.assertIsNotNone(scraper.get_class_logger())
        self.assertIsNotNone(scraper.get_default_url())
        self.assertIsNotNone(scraper.get_default_response())
        self.assertIsNotNone(scraper.get_time_zone())

    def test_scrape_default(self):
        """Testing to see if default scrape works as expected"""
        scraper = Scraper()
        data = scraper.scrape()

        self.assertIsNotNone(data)
        self.assertGreater(len(data.keys()), 0)
        self.assertEqual(self.base.keys(), data.keys())

    def test_scrape_bad_input(self):
        """Testing to see if bad scrape works as expected"""
        scraper = Scraper()

        data = scraper.scrape("httttttp://www.nu.nl/rss/Algemeen")

        self.assertEqual(data["items"], [])

    def test_scrape_good_input(self):
        """Testing to see if good scrape works as expected"""
        scraper = Scraper()
        result_one = scraper.scrape(url="http://www.nu.nl/rss/Algemeen")
        result_two = scraper.scrape(
            url="https://feeds.feedburner.com/tweakers/mixed"
        )

        self.assertIsNotNone(result_one)
        self.assertGreater(len(result_one.keys()), 0)
        self.assertEqual(self.base.keys(), result_one.keys())

        self.assertIsNotNone(result_two)
        self.assertGreater(len(result_two.keys()), 0)
        self.assertEqual(self.base.keys(), result_two.keys())

    def test_scrape_with_datetime(self):
        """Testing to see if scraper datetime parsing works as expected"""
        scraper = Scraper()
        right_now = datetime.now().astimezone(self.tz)
        result_past = scraper.scrape(
            newer_than=right_now - timedelta(hours=6)
        )
        result_present = scraper.scrape(newer_than=right_now)
        result_future = scraper.scrape(
            newer_than=(right_now + timedelta(hours=6))
        )

        # Past
        self.assertGreater(result_past["items"].__len__(), 0)
        self.assertGreater(len(result_past.keys()), 0)
        self.assertEqual(self.base.keys(), result_past.keys())
        # Present
        self.assertGreaterEqual(result_present["items"].__len__(), 0)
        self.assertGreater(len(result_present.keys()), 0)
        self.assertEqual(self.base.keys(), result_present.keys())
        # Future
        self.assertEqual(result_future["items"].__len__(), 0)
        self.assertGreater(len(result_future.keys()), 0)
        self.assertEqual(self.base.keys(), result_future.keys())

    def test_internal_parse(self):
        """Testing to see if internal parsing works as expected"""
        scraper = Scraper()

        result_one = scraper.scrape()  # Default url used
        result_two = scraper.scrape(
            url="https://feeds.feedburner.com/tweakers/mixed"
        )

        self.assertIsNotNone(result_one)
        self.assertGreater(len(result_one.keys()), 0)

        self.assertIsNotNone(result_two)
        self.assertGreater(len(result_two.keys()), 0)

    def test_getters(self):
        """Testing to see if getters works as expected"""
        scraper = Scraper()

        result_logger = scraper.get_class_logger()
        result_default_url = scraper.get_default_url()
        result_default_respose = scraper.get_default_response()
        result_time_zone = scraper.get_time_zone()

        self.assertIsInstance(result_logger, Logger)
        self.assertIsInstance(result_default_url, str)
        self.assertIsInstance(result_default_respose, dict)
        self.assertIsInstance(result_time_zone, tzinfo)
        self.assertEqual(result_time_zone, self.tz)