import unittest
import mock

import context
from steam_review_scraper import steam, db_common

import json
import datetime


class SteamGameInfoTest(unittest.TestCase):
    def setUp(self):
        self.appid = 000000
        
        json_data = json.dumps({
            self.appid : {"data" : {"name" : "Test App", "steam_appid" : self.appid}}
        })

        self.app_mock = mock.Mock()
        self.app_mock.getcode.return_value = 200
        self.app_mock.read.return_value = json_data

    @mock.patch("urllib.urlopen")
    def test_get_game_info(self, urlopen_mock):
        check_dict = {"name" : "Test App", "steam_appid" : self.appid}

        self.app_mock.getcode.return_value = 200
        urlopen_mock.return_value = self.app_mock

        ret_dict = steam.get_steam_game_info(self.appid)

        self.assertDictEqual(ret_dict, check_dict)

    @mock.patch("urllib.urlopen")
    def test_response_code_fail(self, urlopen_mock):
        self.app_mock.getcode.return_value = 400
        urlopen_mock.return_value = self.app_mock

        self.assertRaises(
            steam.ConnectionError,
            steam.get_steam_game_info,
            self.appid
        )


class ReviewsFromApiTest(unittest.TestCase):
    def setUp(self):
        self.appid = 000000
        self.data = {
            "timestamp_created": 1583849466,
            "language": "english",
            "author":
                {"steamid": "76561198366048868",
                "playtime_forever": 471,
                "last_played": 1583984022,
                "num_reviews": 1,
                "num_games_owned": 8,
                "playtime_last_two_weeks": 471
            },
            "review": "Great game!!",
            "comment_count": 0,
            "received_for_free": False,
            "voted_up": True,
            "recommendationid": "64812883",
            "weighted_vote_score": 0,
            "votes_up": 0,
            "steam_purchase": True,
            "timestamp_updated": 1583849466,
            "written_during_early_access": False,
            "votes_funny": 0
        }
        self.review_mock = mock.Mock()
        self.review_mock.getcode.return_value = 200

    @mock.patch("urllib.urlopen")
    def test_review_count(self, urlopen_mock):
        review_count = 5
        reviews = [self.data for _ in range(review_count)]
        self.review_mock.read.return_value = json.dumps(
            {
                "reviews": reviews,
                "cursor": "*",
                "query_summary": {"total_reviews": review_count}
            })
        urlopen_mock.return_value = self.review_mock
        result = steam.get_reviews_from_api(self.appid)
        self.assertEqual(len(result[0]), review_count)

    @mock.patch("urllib.urlopen")
    def test_response_code_fail(self, urlopen_mock):
        reviews = [self.data]
        review_count = len(reviews)
        self.review_mock.getcode.return_value = 400
        self.review_mock.read.return_value = json.dumps(
            {
                "reviews": reviews,
                "cursor": "*",
                "query_summary": {"total_reviews": review_count}
            })
        urlopen_mock.return_value = self.review_mock
        self.assertRaises(
            steam.ConnectionError,
            steam.get_reviews_from_api,
            self.appid
        )

    @mock.patch("urllib.urlopen")
    def test_review_content(self, urlopen_mock):
        reviews = [self.data]
        self.review_mock.read.return_value = json.dumps(
            {
                "reviews": reviews,
                "cursor": "*",
                "query_summary": {"total_reviews": len(reviews)}
            })
        urlopen_mock.return_value = self.review_mock
        result = steam.get_reviews_from_api(self.appid)
        steam_review = result[0][0]

        self.assertEqual(steam_review.user_name, self.data["author"]["steamid"])
        self.assertEqual(steam_review.helpful_amount, self.data["votes_up"])
        self.assertEqual(
            steam_review.date_updated,
            datetime.datetime.fromtimestamp(self.data["timestamp_updated"])
        )

    @mock.patch("urllib.urlopen")
    def test_language_filtered(self, urlopen_mock):
        reviews = [self.data]
        self.review_mock.read.return_value = json.dumps(
            {
                "reviews": reviews,
                "cursor": "*",
                "query_summary": {"total_reviews": len(reviews)}
            })
        urlopen_mock.return_value = self.review_mock

        result = steam.get_reviews_from_api(self.appid, languages=["french"])

        self.assertIsNotNone(result[0])
        self.assertFalse(result[0])


class RemoveDeletedReviewsTest(unittest.TestCase):
    def setUp(self):
        self.appid = 000000
        self.test_conn = db_common.create_database(":memory:")
        self.insertDummyData()

    def insertDummyData(self):
        columns = [
            "id",
            "recommended",
            "review_url",
            "date_posted",
            "steam_appid",
            "lang_key",
            "entry_updated"
        ]
        item1 = (1, True, "", 10, self.appid, "english", 5)
        item2 = (2, False, "", 10, self.appid, "french", 9)
        item3 = (3, True, "", 10, self.appid, "english", 10)
        item4 = (4, True, "", 10, 200000, "english", 15)
        data = [item1, item2, item3, item4]
        self.test_conn.executemany(
            "INSERT INTO {0} ({1}) VALUES ({2})".format(
                db_common.db_definition.TABLE_STEAM_REVIEWS,
                ", ".join(columns),
                ", ".join(["?"] * len(columns)),
                ), data)

    def get_db_count(self):
        return db_common.get_review_count(self.appid)

    @mock.patch("sqlite3.connect")
    def test_delete_single(self, conn_mock):
        conn_mock.return_value = self.test_conn
        compare_time = 8
        steam.remove_deleted_reviews(self.appid, compare_time)
        self.assertEqual(self.get_db_count(), 2)

    @mock.patch("sqlite3.connect")
    def test_delete_multiple(self, conn_mock):
        conn_mock.return_value = self.test_conn
        compare_time = 10
        steam.remove_deleted_reviews(self.appid, compare_time)
        self.assertEqual(self.get_db_count(), 1)

    @mock.patch("sqlite3.connect")
    def test_delete_none(self, conn_mock):
        conn_mock.return_value = self.test_conn
        compare_time = 4
        steam.remove_deleted_reviews(self.appid, compare_time)
        self.assertEqual(self.get_db_count(), 3)


if __name__ == '__main__':
    unittest.main()