skelet/core/tests.py

from django.test import TestCase
from django.db import IntegrityError
from django.core.exceptions import ValidationError

from wagtail.models import Page

from core.models import (
    Language,
    Framework,
    DatabaseOption,
    SkeletonFeature,
    SkeletonProjectPage,
    ArticlePage,
)


class LanguageTests(TestCase):
    def test_create_language(self):
        lang = Language.objects.create(name="Python", slug="python")
        self.assertEqual(lang.name, "Python")
        self.assertEqual(str(lang), "Python")

    def test_slug_unique(self):
        Language.objects.create(name="Python", slug="python")
        with self.assertRaises(IntegrityError):
            Language.objects.create(name="Python3", slug="python")


class FrameworkTests(TestCase):
    def test_create_framework(self):
        fw = Framework.objects.create(name="Django", slug="django")
        self.assertEqual(fw.name, "Django")
        self.assertEqual(str(fw), "Django")

    def test_slug_unique(self):
        Framework.objects.create(name="Django", slug="django")
        with self.assertRaises(IntegrityError):
            Framework.objects.create(name="Django2", slug="django")


class DatabaseOptionTests(TestCase):
    def test_create_database_option(self):
        db = DatabaseOption.objects.create(name="PostgreSQL", slug="postgresql")
        self.assertEqual(db.name, "PostgreSQL")
        self.assertEqual(str(db), "PostgreSQL")

    def test_slug_unique(self):
        DatabaseOption.objects.create(name="PostgreSQL", slug="postgresql")
        with self.assertRaises(IntegrityError):
            DatabaseOption.objects.create(name="PostgreSQL2", slug="postgresql")


class SkeletonFeatureTests(TestCase):
    def test_create_skeleton_feature(self):
        feat = SkeletonFeature.objects.create(name="Docker", slug="docker")
        self.assertEqual(feat.name, "Docker")
        self.assertEqual(str(feat), "Docker")

    def test_slug_unique(self):
        SkeletonFeature.objects.create(name="Docker", slug="docker")
        with self.assertRaises(IntegrityError):
            SkeletonFeature.objects.create(name="Docker2", slug="docker")


class SkeletonProjectPageTests(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.lang = Language.objects.create(name="Python", slug="python")

    def test_valid_project_full_clean(self):
        root = Page.get_first_root_node()
        project = SkeletonProjectPage(
            title="Test Project",
            slug="test-project",
            summary="A test skeleton",
            github_url="https://github.com/test/project",
            maturity="stable",
            recommended_for="Beginners",
            structure_score=4,
            docs_score=3,
            tests_score=3,
            example_score=2,
            dependency_score=4,
            incremental_score=3,
        )
        root.add_child(instance=project)
        project.languages.add(self.lang)
        try:
            project.full_clean()
        except ValidationError as e:
            self.fail(f"full_clean() raised ValidationError: {e}")

    def test_score_above_5_raises_validation_error(self):
        root = Page.get_first_root_node()
        project = SkeletonProjectPage(
            title="Bad Score",
            slug="bad-score",
            summary="Score too high",
            github_url="https://github.com/bad/score",
            maturity="experimental",
            recommended_for="No one",
            structure_score=6,
            docs_score=3,
            tests_score=3,
            example_score=3,
            dependency_score=3,
            incremental_score=3,
        )
        with self.assertRaises(ValidationError):
            root.add_child(instance=project)

    def test_total_score_equals_sum_of_six_scores(self):
        project = SkeletonProjectPage(
            title="Score Test",
            slug="score-test",
            summary="Testing total",
            github_url="https://github.com/test/scores",
            maturity="mature",
            recommended_for="Testing",
            structure_score=4,
            docs_score=3,
            tests_score=2,
            example_score=5,
            dependency_score=1,
            incremental_score=4,
        )
        self.assertEqual(project.total_score, 19)


class ArticlePageTests(TestCase):
    def test_create_article_with_related_project(self):
        root = Page.get_first_root_node()
        lang = Language.objects.create(name="Go", slug="go")

        project = SkeletonProjectPage(
            title="Related Project",
            slug="related-project",
            summary="A related project",
            github_url="https://github.com/test/related",
            maturity="stable",
            recommended_for="Testing",
            structure_score=3,
            docs_score=3,
            tests_score=3,
            example_score=3,
            dependency_score=3,
            incremental_score=3,
        )
        root.add_child(instance=project)
        project.languages.add(lang)

        article = ArticlePage(
            title="Test Article",
            slug="test-article",
            body="<p>Article body content.</p>",
        )
        root.add_child(instance=article)
        article.related_projects.add(project)

        self.assertEqual(article.related_projects.count(), 1)
        self.assertEqual(article.related_projects.first().title, "Related Project")