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 home.models import HomePage

from core.models import (
    Language,
    Framework,
    DatabaseOption,
    SkeletonFeature,
    ScenarioIndexPage,
    ScenarioPage,
    ProjectIndexPage,
    SkeletonProjectPage,
    ArticleIndexPage,
    ArticlePage,
)


class LanguageTests(TestCase):
    def test_create_language(self):
        lang = Language.objects.create(name="Python", slug="python")
        self.assertEqual(lang.name, "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")

    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")

    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")

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


class PageTreeMixin:
    @classmethod
    def setUpPageTree(cls):
        cls.home = HomePage.objects.get(slug="home")

        cls.scenario_index = ScenarioIndexPage(title="Scenarios", slug="scenarios")
        cls.home.add_child(instance=cls.scenario_index)
        cls.scenario = ScenarioPage(title="SaaS", slug="saas")
        cls.scenario_index.add_child(instance=cls.scenario)

        cls.project_index = ProjectIndexPage(title="Projects", slug="projects")
        cls.home.add_child(instance=cls.project_index)

        cls.article_index = ArticleIndexPage(title="Articles", slug="articles")
        cls.home.add_child(instance=cls.article_index)


class SkeletonProjectPageTests(PageTreeMixin, TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.setUpPageTree()
        cls.lang = Language.objects.create(name="Python", slug="python")
        cls.lang2 = Language.objects.create(name="JavaScript", slug="javascript")
        cls.fw = Framework.objects.create(name="Django", slug="django")

    def _make_project(self, **kwargs):
        defaults = {
            "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,
        }
        defaults.update(kwargs)
        project = SkeletonProjectPage(**defaults)
        self.project_index.add_child(instance=project)
        return project

    def test_valid_project_full_clean(self):
        project = self._make_project()
        project.languages.add(self.lang)
        project.scenarios.add(self.scenario)
        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):
        with self.assertRaises(ValidationError):
            self._make_project(structure_score=6)

    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)

    def test_missing_scenarios_raises_error(self):
        project = self._make_project()
        project.languages.add(self.lang)
        with self.assertRaises(ValidationError):
            project.full_clean()

    def test_missing_languages_raises_error(self):
        project = self._make_project()
        project.scenarios.add(self.scenario)
        with self.assertRaises(ValidationError):
            project.full_clean()

    def test_all_m2m_set_passes(self):
        project = self._make_project()
        project.languages.add(self.lang)
        project.scenarios.add(self.scenario)
        project.frameworks.add(self.fw)
        try:
            project.full_clean()
        except ValidationError:
            self.fail("full_clean() should pass with all M2M set")

    def test_m2m_persists_after_save_and_reload(self):
        project = self._make_project()
        project.languages.add(self.lang)
        project.scenarios.add(self.scenario)
        project.save()

        reloaded = SkeletonProjectPage.objects.get(pk=project.pk)
        self.assertGreaterEqual(reloaded.scenarios.count(), 1)
        self.assertGreaterEqual(reloaded.languages.count(), 1)


class ArticlePageTests(PageTreeMixin, TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.setUpPageTree()
        cls.lang = Language.objects.create(name="Go", slug="go")

    def test_create_article_with_related_project(self):
        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,
        )
        self.project_index.add_child(instance=project)
        project.languages.add(self.lang)
        project.scenarios.add(self.scenario)

        article = ArticlePage(
            title="Test Article",
            slug="test-article",
            body="<p>Article body content.</p>",
        )
        self.article_index.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")