Add additional unit tests for DB models, meta/lang testing, template tags, and views

Author: geekygirlsarah

web/tests/test_db_models.py

@@ -0,0 +1,37 @@
+from django.test import TestCase
+from web.models import SiteVisit, LookupData
+
+class TestDbModels(TestCase):
+    def test_site_visit_creation(self):
+        visit = SiteVisit.objects.create(
+            url="http://example.com",
+            user_agent="Mozilla/5.0",
+            referer="http://google.com"
+        )
+        self.assertIsNotNone(visit.id)
+        self.assertEqual(visit.url, "http://example.com")
+        self.assertEqual(visit.user_agent, "Mozilla/5.0")
+        self.assertEqual(visit.referer, "http://google.com")
+        self.assertIsNotNone(visit.date_time)
+
+    def test_lookup_data_creation(self):
+        visit = SiteVisit.objects.create(
+            url="http://example.com",
+            user_agent="Mozilla/5.0",
+            referer="http://google.com"
+        )
+        lookup = LookupData.objects.create(
+            language1="python",
+            version1="3",
+            language2="javascript",
+            version2="es6",
+            structure="data_types",
+            site_visit=visit
+        )
+        self.assertIsNotNone(lookup.id)
+        self.assertEqual(lookup.language1, "python")
+        self.assertEqual(lookup.version1, "3")
+        self.assertEqual(lookup.language2, "javascript")
+        self.assertEqual(lookup.version2, "es6")
+        self.assertEqual(lookup.structure, "data_types")
+        self.assertEqual(lookup.site_visit, visit)

web/tests/test_models.py

@@ -144,15 +144,54 @@ def test_language_get_concept_code(self):
         self.assertEqual(language.concept_code("concept3"), "")
         self.assertEqual(language.concept_code("concept4"), "line1\nline2")
 
-    def test_language_get_concept_comment(self):
-        """test Language#get_concept_comment"""
-        language = self.dummy_language
-
-        # Test unknown concept
-        self.assertEqual(language.concept_comment("12345"), "")
-
-        # Test known concept
-        self.assertEqual(language.concept_comment("concept1"), "")
-        self.assertEqual(language.concept_comment("concept2"), "My comment")
-        self.assertEqual(language.concept_comment("concept3"), "")
-        self.assertEqual(language.concept_comment("concept4"), "")
+    def test_language_versions(self):
+        """test Language#versions"""
+        language = Language("python", "Python")
+        versions = language.versions()
+        self.assertGreater(len(versions), 0)
+        self.assertIn("3", versions)
+
+    def test_language_load_filled_concepts(self):
+        """test Language#load_filled_concepts"""
+        language = Language("python", "Python")
+        # Python 3 has data_types structure
+        response = language.load_filled_concepts("data_types", "3")
+        response_json = json.loads(response)
+        self.assertEqual(response_json["meta"]["language"], "python")
+        self.assertEqual(response_json["meta"]["structure"], "data_types")
+        self.assertIn("concepts", response_json)
+        # Check if some basic concept exists
+        self.assertIn("boolean", response_json["concepts"])
+
+    def test_language_load_comparison(self):
+        """test Language#load_comparison"""
+        language = Language("python", "Python")
+        response = language.load_comparison("data_types", "javascript", "ECMAScript 2023", "3")
+        response_json = json.loads(response)
+        self.assertEqual(response_json["meta"]["language_1"], "python")
+        self.assertEqual(response_json["meta"]["language_2"], "javascript")
+        self.assertIn("concepts1", response_json)
+        self.assertIn("concepts2", response_json)
+
+    def test_metainfo_language_methods(self):
+        """test MetaInfo language related methods"""
+        self.assertEqual(self.metainfo.language_name("python"), "Python")
+        lang = self.metainfo.language("python")
+        self.assertIsInstance(lang, Language)
+        self.assertEqual(lang.key, "python")
+
+    def test_metainfo_load_languages(self):
+        """test MetaInfo#load_languages"""
+        structure = self.metainfo.structure("data_types")
+        langs = self.metainfo.load_languages([("python", "3"), ("javascript", "ECMAScript 2023")], structure)
+        self.assertEqual(len(langs), 2)
+        self.assertEqual(langs[0].key, "python")
+        self.assertEqual(langs[1].key, "javascript")
+
+    def test_metainfo_load_languages_missing_structure(self):
+        """test MetaInfo#load_languages with missing structure"""
+        from web.models import MissingStructureError
+        structure = self.metainfo.structure("data_types")
+        with self.assertRaises(MissingStructureError):
+            # python 3 definitely has data_types, but let's try something that doesn't exist
+            self.metainfo.load_languages([("python", "non_existent_version")], structure)

web/tests/test_templatetags.py

@@ -0,0 +1,17 @@
+from django.test import TestCase
+from django.template import Context, Template
+
+class TestTemplateTags(TestCase):
+    def test_concept_card_tag(self):
+        template = Template(
+            "{% load templatetags %}"
+            "{% concept_card code comment %}"
+        )
+        context = Context({
+            'code': 'print("Hello")',
+            'comment': 'A simple print statement'
+        })
+        rendered = template.render(context)
+        
+        self.assertIn('print("Hello")', rendered)
+        self.assertIn('A simple print statement', rendered)

web/tests/test_views.py

@@ -269,4 +269,36 @@ def test_single_concept_view_valid_language_version(self):
         self.assertIn('meta', response_data)
         self.assertIn('concepts', response_data)
 
+    def test_api_compare_valid(self):
+        """Test api_compare with valid languages and versions"""
+        url = reverse('api.compare', kwargs={
+            'structure_key': 'data_types',
+            'lang1': 'python',
+            'version1': '3',
+            'lang2': 'javascript',
+            'version2': 'ECMAScript 2009'
+        })
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        response_data = response.json()
+        self.assertIn('meta', response_data)
+        self.assertIn('concepts1', response_data)
+        self.assertIn('concepts2', response_data)
+        self.assertEqual(response_data['meta']['language_1'], 'python')
+        self.assertEqual(response_data['meta']['language_2'], 'javascript')
+
+    def test_concepts_view_valid_params(self):
+        """Test concepts view with valid parameters that should return 200"""
+        url = reverse('index') + '?concept=data_types&lang=python%3B3&lang=javascript%3BECMAScript%202023'
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        self.assertTemplateUsed(response, 'concepts.html')
+
+    def test_concepts_view_legacy_params(self):
+        """Test concepts view with legacy lang1/lang2 parameters"""
+        url = reverse('compare') + '?concept=data_types&lang1=python%3B3&lang2=javascript%3BECMAScript%202023'
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        self.assertTemplateUsed(response, 'concepts.html')
+