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"
},
]