add some tests

Author: fspv

test/base.py

@@ -1,10 +1,47 @@
 import os
-from typing import Optional
+from typing import Any, Optional
 
 import leetcode.api.default_api
 import leetcode.api_client
 import leetcode.configuration
 
+def validate_stat_status_pair(stat_status_pair: Any) -> None:
+    assert isinstance(stat_status_pair, leetcode.StatStatusPair)
+    assert isinstance(stat_status_pair.difficulty, leetcode.Difficulty)
+    assert isinstance(stat_status_pair.difficulty.level, int)
+    assert isinstance(stat_status_pair.frequency, float)
+    assert isinstance(stat_status_pair.is_favor, bool)
+    assert isinstance(stat_status_pair.paid_only, bool)
+    assert isinstance(stat_status_pair.stat, leetcode.Stat)
+    if stat_status_pair.status is not None:
+        assert isinstance(stat_status_pair.status, str)
+
+    assert isinstance(stat_status_pair.stat.frontend_question_id, int)
+    assert isinstance(stat_status_pair.stat.is_new_question, bool)
+    if stat_status_pair.stat.question__article__live is not None:
+        assert isinstance(stat_status_pair.stat.question__article__live, bool)
+    if stat_status_pair.stat.question__article__slug is not None:
+        assert isinstance(stat_status_pair.stat.question__article__slug, str)
+    assert isinstance(stat_status_pair.stat.question__hide, bool)
+    assert isinstance(stat_status_pair.stat.question__title, str)
+    assert isinstance(stat_status_pair.stat.question__title_slug, str)
+    assert isinstance(stat_status_pair.stat.question_id, int)
+    assert isinstance(stat_status_pair.stat.total_acs, int)
+    assert isinstance(stat_status_pair.stat.total_submitted, int)
+
+def validate_problems(problems: Any, category_slug: str) -> None:
+    assert isinstance(problems, leetcode.Problems)
+    assert isinstance(problems.ac_easy, int)
+    assert isinstance(problems.ac_hard, int)
+    assert isinstance(problems.ac_medium, int)
+    assert problems.category_slug == category_slug
+    assert isinstance(problems.num_solved, int)
+    assert isinstance(problems.num_total, int)
+    assert isinstance(problems.stat_status_pairs, list)
+
+    for stat_status_pair in problems.stat_status_pairs:
+        validate_stat_status_pair(stat_status_pair)
+
 
 class BaseTest:
     _api_instance_containter: Optional[leetcode.api.default_api.DefaultApi] = None

test/test_default_api.py

@@ -12,41 +12,120 @@
 
 from __future__ import absolute_import
 
+from time import sleep
 import unittest
+from leetcode.models.interpretation import Interpretation
+from leetcode.models.submission_id import SubmissionId
+import test.base
 
 import leetcode
 from leetcode.api.default_api import DefaultApi  # noqa: E501
 from leetcode.rest import ApiException
 
 
-class TestDefaultApi(unittest.TestCase):
-    """DefaultApi unit test stubs"""
-
-    def setUp(self):
-        self.api = DefaultApi()  # noqa: E501
+class TestDefaultApi(test.base.BaseTest):
+    def test_api_problems_topic_get(self):
+        result = self._api_instance.api_problems_topic_get(topic="algorithms")
+        test.base.validate_problems(result, "algorithms")
 
-    def tearDown(self):
-        pass
+        result = self._api_instance.api_problems_topic_get(topic="nonexistent")
+        test.base.validate_problems(result, "nonexistent")
 
-    def test_api_problems_topic_get(self):
-        """Test case for api_problems_topic_get"""
-        pass
+        try:
+            self._api_instance.api_problems_topic_get(topic="")
+            assert False
+        except ApiException as e:
+            assert e.status == 404
 
     def test_graphql_post(self):
-        """Test case for graphql_post"""
         pass
 
     def test_problems_problem_interpret_solution_post(self):
-        """Test case for problems_problem_interpret_solution_post"""
-        pass
+        code = """
+        class Solution:
+            def twoSum(self, nums, target):
+                print("stdout")
+                return [1]
+        """
+        test_submission = leetcode.TestSubmission(
+            data_input="[2,7,11,15]\n9",
+            typed_code=code,
+            question_id=1,
+            test_mode=False,
+            lang="python",
+        )
+
+        result = self._api_instance.problems_problem_interpret_solution_post(
+                problem="two-sum",
+                body=test_submission,
+        )
+
+        assert isinstance(result, Interpretation)
 
-    def test_problems_problem_submit_post(self):
-        """Test case for problems_problem_submit_post"""
-        pass
 
-    def test_submissions_detail_id_check_get(self):
-        """Test case for submissions_detail_id_check_get"""
-        pass
+    def test_problems_problem_submit_post(self):
+        code = """
+        class Solution:
+            def twoSum(self, nums, target):
+                print("stdout")
+                return [1]
+        """
+
+        submission = leetcode.Submission(
+            judge_type="large",
+            typed_code=code,
+            question_id=1,
+            test_mode=False,
+            lang="python",
+        )
+        submission_id = self._api_instance.problems_problem_submit_post(
+            problem="two-sum", body=submission
+        )
+        assert isinstance(submission_id, SubmissionId)
+
+
+        sleep(5)  # FIXME: should probably be a busy-waiting loop
+
+        submission_result = self._api_instance.submissions_detail_id_check_get(
+            id=submission_id.submission_id
+        )
+        # assert isinstance(
+        #     submission_result,
+        #     leetcode.SubmissionResult,
+        # ) or isinstance(
+        #     submission_result,
+        #     leetcode.TestSubmissionResult,
+        # )
+
+        # if isinstance(submission_result, leetcode.SubmissionResult):
+        #     assert isinstance(submission_result.compare_result, str)
+        #     assert isinstance(submission_result.std_output, str)
+        #     assert isinstance(submission_result.last_testcase, str)
+        #     assert isinstance(submission_result.expected_output, str)
+        #     assert isinstance(submission_result.input_formatted, str)
+        #     assert isinstance(submission_result.input, str)
+        #     # Missing or incorrect fields
+        #     # task_name: str
+        #     # finished: bool
+        # elif isinstance(submission_result, leetcode.TestSubmissionResult):
+        #     assert isinstance(submission_result.code_answer, list)
+        #     assert isinstance(submission_result.correct_answer, bool)
+        #     assert isinstance(submission_result.expected_status_code, int)
+        #     assert isinstance(submission_result.expected_lang, str)
+        #     assert isinstance(submission_result.expected_run_success, bool)
+        #     assert isinstance(submission_result.expected_status_runtime, str)
+        #     assert isinstance(submission_result.expected_memory, int)
+        #     assert isinstance(submission_result.expected_code_answer, list)
+        #     assert isinstance(submission_result.expected_code_output, list)
+        #     assert isinstance(submission_result.expected_elapsed_time, int)
+        #     assert isinstance(submission_result.expected_task_finish_time, int)
+
+    # def test_submissions_detail_id_check_get(self):
+    #     try:
+    #         self._api_instance.submissions_detail_id_check_get(id="nonexistent")
+    #         assert False
+    #     except ApiException as e:
+    #         assert e.status == 404
 
 
 if __name__ == "__main__":

test/test_difficulty.py

@@ -13,13 +13,14 @@
 from __future__ import absolute_import
 
 import unittest
+import test.base
 
 import leetcode
 from leetcode.models.difficulty import Difficulty  # noqa: E501
 from leetcode.rest import ApiException
 
 
-class TestDifficulty(unittest.TestCase):
+class TestDifficulty(test.base.BaseTest):
     """Difficulty unit test stubs"""
 
     def setUp(self):
@@ -29,9 +30,6 @@ def tearDown(self):
         pass
 
     def testDifficulty(self):
-        """Test Difficulty"""
-        # FIXME: construct object with mandatory attributes with example values
-        # model = leetcode.models.difficulty.Difficulty()  # noqa: E501
         pass
 
 

test/test_graphql_request_get_question_detail.py

@@ -101,7 +101,8 @@ def test_request(self) -> None:
         assert question.title == "Two Sum"
         assert question.title_slug == "two-sum"
         assert question.frequency == 0.0
-        assert question.freq_bar > 0
+        if question.freq_bar is not None: # only available for premium users
+            assert question.freq_bar > 0
         assert len(question.content) > 10
         assert question.translated_title is None
         assert question.is_paid_only is False
@@ -124,12 +125,13 @@ def test_request(self) -> None:
         assert question.topic_tags[0].translated_name is None
         assert len(topic_tag.typename) > 0
 
-        tag_stat = list(json.loads(question.company_tag_stats).values())[0][0]
+        if question.company_tag_stats is not None: # only available for premium users
+            tag_stat = list(json.loads(question.company_tag_stats).values())[0][0]
 
-        assert tag_stat["taggedByAdmin"] in (True, False)
-        assert len(tag_stat["name"]) > 0
-        assert len(tag_stat["slug"]) > 0
-        assert tag_stat["timesEncountered"] > 0
+            assert tag_stat["taggedByAdmin"] in (True, False)
+            assert len(tag_stat["name"]) > 0
+            assert len(tag_stat["slug"]) > 0
+            assert tag_stat["timesEncountered"] > 0
 
         code_snippet = question.code_snippets[0]
 
@@ -169,7 +171,7 @@ def test_request(self) -> None:
         assert question.has_solution in (True, False)
         assert question.has_video_solution in (True, False)
 
-        assert question.status in ("ac", "not_started", "tried")
+        assert question.status in ("ac", "not_started", "tried", None)
 
         assert len(question.sample_test_case) > 0
 

test/test_graphql_request_problemset_question_list.py

@@ -125,7 +125,8 @@ def test_request(self) -> None:
         assert question.bound_topic_id is None
         assert question.title is not None
         assert question.frequency == 0.0
-        assert question.freq_bar > 0
+        if question.freq_bar is not None: # only available for premium users
+            assert question.freq_bar > 0
         assert len(question.content) > 10
         assert question.translated_title is None
         assert question.is_paid_only in (True, False)
@@ -146,12 +147,13 @@ def test_request(self) -> None:
         assert question.topic_tags[0].translated_name is None
         assert len(topic_tag.typename) > 0
 
-        tag_stat = list(json.loads(question.company_tag_stats).values())[0][0]
+        if question.company_tag_stats is not None: # only available for premium users
+            tag_stat = list(json.loads(question.company_tag_stats).values())[0][0]
 
-        assert tag_stat["taggedByAdmin"] in (True, False)
-        assert len(tag_stat["name"]) > 0
-        assert len(tag_stat["slug"]) > 0
-        assert tag_stat["timesEncountered"] > 0
+            assert tag_stat["taggedByAdmin"] in (True, False)
+            assert len(tag_stat["name"]) > 0
+            assert len(tag_stat["slug"]) > 0
+            assert tag_stat["timesEncountered"] > 0
 
         code_snippet = question.code_snippets[0]
 
@@ -176,7 +178,9 @@ def test_request(self) -> None:
         assert len(code_definition["text"]) > 0
         assert len(code_definition["defaultCode"]) > 0
 
-        assert [len(hint) > 0 for hint in question.hints]
+        # TODO: check if the field has disappeared or if this is just a premium
+        # feature
+        # assert [len(hint) > 0 for hint in question.hints]
 
         question.solution