498 lines
18 KiB
Python
498 lines
18 KiB
Python
from django.test import TestCase, override_settings
|
|
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 ScenarioPaginationTests(PageTreeMixin, TestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.setUpPageTree()
|
|
cls.lang = Language.objects.create(name="Python", slug="python")
|
|
for i in range(21):
|
|
project = SkeletonProjectPage(
|
|
title=f"Pagination Project {i+1}",
|
|
slug=f"pagination-project-{i+1}",
|
|
summary=f"Project {i+1} for pagination test",
|
|
github_url="https://github.com/test/pagination",
|
|
maturity="stable",
|
|
recommended_for="Testing",
|
|
structure_score=3, docs_score=3, tests_score=3,
|
|
example_score=3, dependency_score=3, incremental_score=3,
|
|
)
|
|
cls.project_index.add_child(instance=project)
|
|
project.languages.add(cls.lang)
|
|
project.scenarios.add(cls.scenario)
|
|
project.save()
|
|
|
|
def test_first_page_has_20_items(self):
|
|
resp = self.client.get(self.scenario.url)
|
|
self.assertEqual(resp.status_code, 200)
|
|
self.assertContains(resp, "Pagination Project 1")
|
|
self.assertContains(resp, "Pagination Project 20")
|
|
self.assertNotContains(resp, "Pagination Project 21")
|
|
|
|
def test_second_page_has_1_item(self):
|
|
resp = self.client.get(f"{self.scenario.url}?page=2")
|
|
self.assertEqual(resp.status_code, 200)
|
|
self.assertNotContains(resp, "Pagination Project 1")
|
|
self.assertContains(resp, "Pagination Project 21")
|
|
|
|
def test_invalid_page_falls_back_to_first(self):
|
|
resp = self.client.get(f"{self.scenario.url}?page=abc")
|
|
self.assertEqual(resp.status_code, 200)
|
|
self.assertContains(resp, "Pagination Project 1")
|
|
|
|
|
|
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)
|
|
|
|
def test_combined_filters_return_200(self):
|
|
resp = self.client.get(
|
|
"/projects/?language=python&framework=django&min_score=18&q=Django"
|
|
)
|
|
self.assertEqual(resp.status_code, 200)
|
|
self.assertContains(resp, "Django Project")
|
|
self.assertNotContains(resp, "Go Project")
|
|
|
|
def test_combined_filters_no_results_returns_empty_state(self):
|
|
resp = self.client.get(
|
|
"/projects/?language=go&framework=django&min_score=18"
|
|
)
|
|
self.assertEqual(resp.status_code, 200)
|
|
self.assertContains(resp, "No projects match")
|
|
|
|
|
|
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")
|
|
|
|
|
|
class SEOTests(PageTreeMixin, TestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.setUpPageTree()
|
|
cls.lang = Language.objects.create(name="Rust", slug="rust")
|
|
|
|
def test_homepage_meta_description(self):
|
|
resp = self.client.get("/")
|
|
self.assertContains(resp, '<meta name="description"')
|
|
|
|
def test_homepage_canonical(self):
|
|
resp = self.client.get("/")
|
|
self.assertContains(resp, 'rel="canonical"')
|
|
|
|
def test_project_detail_meta_description(self):
|
|
project = SkeletonProjectPage(
|
|
title="SEO Project",
|
|
slug="seo-project",
|
|
summary="An SEO test project with detailed description for testing meta tags.",
|
|
github_url="https://github.com/test/seo",
|
|
maturity="stable",
|
|
recommended_for="Testing meta tags",
|
|
structure_score=4, docs_score=4, 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()
|
|
|
|
resp = self.client.get(project.url)
|
|
self.assertContains(resp, '<meta name="description"')
|
|
self.assertContains(resp, "SEO test project")
|
|
self.assertContains(resp, 'rel="canonical"')
|
|
|
|
def test_sitemap_returns_200(self):
|
|
resp = self.client.get("/sitemap.xml")
|
|
self.assertEqual(resp.status_code, 200)
|
|
|
|
@override_settings(PLAUSIBLE_DOMAIN="skelet.example.com")
|
|
def test_analytics_script_when_domain_set(self):
|
|
resp = self.client.get("/")
|
|
self.assertContains(resp, "plausible.io")
|
|
self.assertContains(resp, "skelet.example.com")
|
|
|
|
def test_external_link_click_tracking(self):
|
|
resp = self.client.get("/")
|
|
self.assertContains(resp, "Outbound Link")
|
|
self.assertContains(resp, "link.hostname") |