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 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 ScenarioPageTests(PageTreeMixin, TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.setUpPageTree()
        cls.lang = Language.objects.create(name="Python", slug="python")

    def test_scenario_page_with_projects(self):
        project = SkeletonProjectPage(
            title="Scenario Project",
            slug="scenario-project",
            summary="A project in this scenario",
            github_url="https://github.com/test/sproject",
            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)
        project.save()

        response = self.client.get(self.scenario.url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Scenario Project")

    def test_empty_scenario_page(self):
        ScenarioPage.objects.create(
            title="Empty Scenario",
            slug="empty-scenario",
            path=self.scenario_index.path + "9999",
            depth=self.scenario_index.depth + 1,
        )
        response = self.client.get("/scenarios/empty-scenario/")
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Nothing here yet")


class ProjectFilterTests(PageTreeMixin, TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.setUpPageTree()
        cls.lang_py = Language.objects.create(name="Python", slug="python")
        cls.lang_go = Language.objects.create(name="Go", slug="go")
        cls.fw_dj = Framework.objects.create(name="Django", slug="django")
        cls.db_pg = DatabaseOption.objects.create(name="PostgreSQL", slug="postgresql")

        cls.proj_a = SkeletonProjectPage(
            title="Django Project",
            slug="django-project",
            summary="A Django project for testing",
            github_url="https://github.com/test/django",
            maturity="stable",
            recommended_for="Testing",
            structure_score=5, docs_score=5, tests_score=5,
            example_score=5, dependency_score=5, incremental_score=5,
        )
        cls.project_index.add_child(instance=cls.proj_a)
        cls.proj_a.languages.add(cls.lang_py)
        cls.proj_a.frameworks.add(cls.fw_dj)
        cls.proj_a.databases.add(cls.db_pg)
        cls.proj_a.scenarios.add(cls.scenario)
        cls.proj_a.save()

        cls.proj_b = SkeletonProjectPage(
            title="Go Project",
            slug="go-project",
            summary="A Go project for testing",
            github_url="https://github.com/test/go",
            maturity="experimental",
            recommended_for="Testing",
            structure_score=1, docs_score=1, tests_score=1,
            example_score=1, dependency_score=1, incremental_score=1,
        )
        cls.project_index.add_child(instance=cls.proj_b)
        cls.proj_b.languages.add(cls.lang_go)
        cls.proj_b.scenarios.add(cls.scenario)
        cls.proj_b.save()

    def test_language_filter(self):
        resp = self.client.get("/projects/?language=python")
        self.assertContains(resp, "Django Project")
        self.assertNotContains(resp, "Go Project")

    def test_min_score_filter(self):
        resp = self.client.get("/projects/?min_score=18")
        self.assertContains(resp, "Django Project")
        self.assertNotContains(resp, "Go Project")

    def test_keyword_search(self):
        resp = self.client.get("/projects/?q=Django")
        self.assertContains(resp, "Django Project")
        self.assertNotContains(resp, "Go Project")

    def test_invalid_params_ignored(self):
        resp = self.client.get("/projects/?min_score=abc&page=xyz")
        self.assertEqual(resp.status_code, 200)


class SkeletonProjectDetailTests(PageTreeMixin, TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.setUpPageTree()
        cls.lang = Language.objects.create(name="Ruby", slug="ruby")

    def test_detail_shows_scores_and_recommendation(self):
        project = SkeletonProjectPage(
            title="Detail Test",
            slug="detail-test",
            summary="Testing detail page",
            github_url="https://github.com/test/detail",
            maturity="stable",
            recommended_for="Developers who need structure",
            structure_score=4, docs_score=3, tests_score=3,
            example_score=4, dependency_score=3, incremental_score=4,
        )
        self.project_index.add_child(instance=project)
        project.languages.add(self.lang)
        project.scenarios.add(self.scenario)
        project.save()

        resp = self.client.get(project.url)
        self.assertContains(resp, "Detail Test")
        self.assertContains(resp, "21/30")
        self.assertContains(resp, "Developers who need structure")

    def test_sponsored_badge(self):
        project = SkeletonProjectPage(
            title="Sponsored Project",
            slug="sponsored-project",
            summary="A sponsored test",
            github_url="https://github.com/test/sponsored",
            maturity="experimental",
            recommended_for="Sponsored users",
            structure_score=2, docs_score=2, tests_score=2,
            example_score=2, dependency_score=2, incremental_score=2,
            is_sponsored=True,
        )
        self.project_index.add_child(instance=project)
        project.languages.add(self.lang)
        project.scenarios.add(self.scenario)
        project.save()

        resp = self.client.get(project.url)
        self.assertContains(resp, "Sponsored")


class ArticleDetailTests(PageTreeMixin, TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.setUpPageTree()
        cls.lang = Language.objects.create(name="Rust", slug="rust")

    def test_article_links_to_project(self):
        project = SkeletonProjectPage(
            title="Linked Project",
            slug="linked-project",
            summary="Project linked from article",
            github_url="https://github.com/test/linked",
            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)
        project.save()

        article = ArticlePage(
            title="Review Article",
            slug="review-article",
            body="<p>About the linked project.</p>",
        )
        self.article_index.add_child(instance=article)
        article.related_projects.add(project)
        article.save()

        resp = self.client.get(article.url)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, "/projects/linked-project/")


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