def test_multilingual_article(db): """ Factory helper should create an original article with its required translations. """ ping = CategoryFactory(slug="ping") pong = CategoryFactory(slug="pong") # Create an article with a FR and DE translations. Also try to create # Deutsch translations twice, but "multilingual_article" is safe on unique # language. created = multilingual_article( slug="cheese", langs=["fr", "de", "de"], fill_categories=[ping, pong], contents={"fr": { "slug": "fromage", "fill_categories": [ping], }}, ) # Original slug is correct assert created["original"].slug == "cheese" # There is two related translations assert (len(created["translations"]) == 2) is True # Required translations have been create assert ("fr" in created["translations"]) is True assert ("de" in created["translations"]) is True # French translation have its own slug assert created["translations"]["fr"].slug == "fromage" # deutsch translation inherit from original slug assert created["translations"]["de"].slug == "cheese" # Check original categories original_categories = queryset_values(created["original"].categories.all()) assert original_categories == [ { "slug": "ping", "language": "en" }, { "slug": "pong", "language": "en" }, ] # Check french translation categories fr_categories = queryset_values( created["translations"]["fr"].categories.all()) assert fr_categories == [ { "slug": "ping", "language": "en" }, ]
def test_category_managers(db): """ Category manager should be able to correctly filter on language. """ # Simple category on default language without translations CategoryFactory(slug="foobar") # Original category on different language than 'settings.LANGUAGE_CODE' and # with a translation for 'settings.LANGUAGE_CODE' lang. multilingual_category( slug="musique", language="fr", langs=["en"], contents={ "en": { "slug": "music", } }, ) # A category with a french translation inheriting original slug multilingual_category( slug="food", langs=["fr"], ) # A category with french translation with its own slug and deutsch # translation inheriting original slug multilingual_category( slug="recipe", langs=["fr", "de"], contents={ "fr": { "slug": "recette", } }, ) # Use default language as configured in settings assert queryset_values(Category.objects.get_for_lang()) == [ {"slug": "foobar", "language": "en"}, {"slug": "food", "language": "en"}, {"slug": "music", "language": "en"}, {"slug": "recipe", "language": "en"}, ] # For french language assert queryset_values(Category.objects.get_for_lang("fr")) == [ {"slug": "food", "language": "fr"}, {"slug": "musique", "language": "fr"}, {"slug": "recette", "language": "fr"}, ] # For deutsch language assert queryset_values(Category.objects.get_for_lang("de")) == [ {"slug": "recipe", "language": "de"}, ]
def test_article_creation(db): """ Factory should correctly create a new object without any errors. """ ping = CategoryFactory(slug="ping") pong = CategoryFactory(slug="pong") # Just a dummy article dummy = ArticleFactory(slug="dummy", language="fr") # Article with some relation article = ArticleFactory( slug="foo", fill_categories=[ping, pong], fill_related=[dummy], ) assert article.slug == "foo" # Check related categories results = queryset_values( article.categories.all() ) assert results == [ {"slug": "ping", "language": "en"}, {"slug": "pong", "language": "en"}, ] # Check related articles results = queryset_values( article.related.all() ) assert results == [ {"slug": "dummy", "language": "fr"}, ] # Check for reverse relation results = queryset_values( dummy.relations.all() ) assert results == [ {"slug": "foo", "language": "en"}, ] # Ensure 'related' is not symmetrical assert dummy.related.count() == 0 # Ensure no random relations are created when not specifically # required from "fill_****" methods article = ArticleFactory(slug="bar") assert article.authors.count() == 0 assert article.categories.count() == 0 assert article.related.count() == 0
def test_article_creation(db): """ Factory should correctly create a new object without any errors. """ ping = CategoryFactory(slug="ping") pong = CategoryFactory(slug="pong") article = ArticleFactory( slug="foo", fill_categories=[ping, pong], ) assert article.slug == "foo" # Check related categories results = queryset_values(article.categories.all()) assert results == [ { "slug": "ping", "language": "en" }, { "slug": "pong", "language": "en" }, ] # Ensure no random categories are created when specifically required article = ArticleFactory(slug="bar", fill_categories=False) assert article.categories.count() == 0
def test_article_managers(db): """ Article manager should be able to correctly filter on language and publication. """ now = timezone.now() yesterday = now - datetime.timedelta(days=1) tomorrow = now + datetime.timedelta(days=1) # Today 5min sooner to avoid shifting with pytest and factory delays today = now - datetime.timedelta(minutes=5) # Single language only common_kwargs = { "publish_date": today.date(), "publish_time": today.time(), "fill_authors": False, "fill_categories": False, } ArticleFactory(slug="english", language="en", **common_kwargs) ArticleFactory(slug="french", language="fr", **common_kwargs) ArticleFactory(slug="deutsch", language="de", **common_kwargs) # Explicitely non published ArticleFactory(slug="niet", status=STATUS_DRAFT, **common_kwargs) # English and French multilingual_article( slug="banana", langs=["fr"], publish_date=today.date(), publish_time=today.time(), fill_authors=False, fill_categories=False, ) # English and Deutsch translation multilingual_article( slug="burger", langs=["de"], publish_date=today.date(), publish_time=today.time(), fill_authors=False, fill_categories=False, ) # Original Deutsch and French translation multilingual_article( slug="wurst", language="de", langs=["fr"], publish_date=today.date(), publish_time=today.time(), fill_authors=False, fill_categories=False, ) # All languages and available for publication multilingual_article( slug="cheese", langs=["fr", "de"], publish_date=today.date(), publish_time=today.time(), fill_authors=False, fill_categories=False, ) multilingual_article( slug="yesterday", langs=["fr", "de"], publish_date=yesterday.date(), publish_time=yesterday.time(), fill_authors=False, fill_categories=False, ) # All lang and publish ends tomorrow, still available for publication multilingual_article( slug="shortlife-today", langs=["fr", "de"], publish_date=today.date(), publish_time=today.time(), publish_end=tomorrow, fill_authors=False, fill_categories=False, ) # All lang but not available for publication multilingual_article( slug="tomorrow", langs=["fr", "de"], publish_date=tomorrow.date(), publish_time=tomorrow.time(), fill_authors=False, fill_categories=False, ) multilingual_article( slug="invalid-yesterday", langs=["fr", "de"], publish_date=today.date(), publish_time=today.time(), publish_end=yesterday, fill_authors=False, fill_categories=False, ) # Check all english articles assert Article.objects.get_for_lang().count() == 9 # Check all french articles assert Article.objects.get_for_lang("fr").count() == 8 # Check all french articles assert Article.objects.get_for_lang("de").count() == 8 # Check all published assert Article.objects.get_published().count() == 18 # Check all unpublished assert Article.objects.get_unpublished().count() == 7 # Check all english published q_en_published = Article.objects.get_for_lang().get_published() assert queryset_values(q_en_published) == [ { "slug": "banana", "language": "en" }, { "slug": "burger", "language": "en" }, { "slug": "cheese", "language": "en" }, { "slug": "english", "language": "en" }, { "slug": "shortlife-today", "language": "en" }, { "slug": "yesterday", "language": "en" }, ] # Check all french published q_fr_published = Article.objects.get_for_lang("fr").get_published() assert queryset_values(q_fr_published) == [ { "slug": "banana", "language": "fr" }, { "slug": "cheese", "language": "fr" }, { "slug": "french", "language": "fr" }, { "slug": "shortlife-today", "language": "fr" }, { "slug": "wurst", "language": "fr" }, { "slug": "yesterday", "language": "fr" }, ] # Check all deutsch published q_de_published = Article.objects.get_for_lang("de").get_published() assert queryset_values(q_de_published) == [ { "slug": "burger", "language": "de" }, { "slug": "cheese", "language": "de" }, { "slug": "deutsch", "language": "de" }, { "slug": "shortlife-today", "language": "de" }, { "slug": "wurst", "language": "de" }, { "slug": "yesterday", "language": "de" }, ]
def test_category_get_by_lang(db): """ Demonstrate how we can get categories for original language and translations. """ created_foobar = CategoryFactory(slug="foobar") created_omelette = multilingual_category( slug="food", langs=["fr"], ) created_cheese = multilingual_category( slug="recipe", langs=["fr", "de"], contents={"fr": { "slug": "recette", }}, ) # Get full total all languages mixed and without any filtering assert queryset_values(Category.objects.all()) == [ { "slug": "foobar", "language": "en" }, { "slug": "food", "language": "en" }, { "slug": "food", "language": "fr" }, { "slug": "recette", "language": "fr" }, { "slug": "recipe", "language": "de" }, { "slug": "recipe", "language": "en" }, ] # Get available categories for a required language assert Category.objects.filter(language="en").count() == 3 assert Category.objects.filter(language="fr").count() == 2 assert Category.objects.filter(language="de").count() == 1 # Get only originals results = Category.objects.filter(original__isnull=True) assert queryset_values(results) == [ { "slug": "foobar", "language": "en" }, { "slug": "food", "language": "en" }, { "slug": "recipe", "language": "en" }, ] # Get only translations results = Category.objects.filter(original__isnull=False) assert queryset_values(results) == [ { "slug": "food", "language": "fr" }, { "slug": "recette", "language": "fr" }, { "slug": "recipe", "language": "de" }, ] # Get translations from original assert created_foobar.category_set.all().count() == 0 assert created_omelette["original"].category_set.all().count() == 1 assert created_cheese["original"].category_set.all().count() == 2
def test_author_manager(db): """ Author manager should be able to get all author which have published articles and Author method "published_articles" should return all published articles for an Author object. """ now = timezone.now() tomorrow = now + datetime.timedelta(days=1) # Today 5min sooner to avoid shifting with pytest and factory delays today = now - datetime.timedelta(minutes=5) # Some authors picsou = AuthorFactory(username="******") donald = AuthorFactory(username="******") flairsou = AuthorFactory(username="******") # Some articles ArticleFactory( slug="Klondike", publish_date=today.date(), publish_time=today.time(), fill_authors=[picsou], ) ArticleFactory( slug="DuckCity", publish_date=today.date(), publish_time=today.time(), fill_authors=[picsou, donald], ) ArticleFactory( slug="Tomorrow", publish_date=tomorrow.date(), publish_time=tomorrow.time(), fill_authors=[donald], ) # Check for author which have published articles q_authors_published = Author.lotus_objects.get_published() data = queryset_values(q_authors_published, names=["username"], orders=["username"]) assert data == [{"username": "******"}, {"username": "******"}] # Check for published articles for each author assert queryset_values(flairsou.articles.get_published()) == [] assert queryset_values(donald.articles.get_published()) == [ { "language": "en", "slug": "DuckCity" }, ] assert queryset_values(picsou.articles.get_published()) == [ { "language": "en", "slug": "DuckCity" }, { "language": "en", "slug": "Klondike" }, ]