def _test_get_deed_or_license_path(self, data):
for (
version,
license_code,
jurisdiction_code,
language_code,
expected_deed_path,
expected_deed_symlinks,
expected_license_path,
expected_license_symlinks,
) in data:
license = LicenseFactory(
license_code=license_code,
version=version,
jurisdiction_code=jurisdiction_code,
)
legalcode = LegalCodeFactory(license=license,
language_code=language_code)
self.assertEqual(
[expected_deed_path, expected_deed_symlinks],
legalcode.get_file_and_links("deed"),
)
self.assertEqual(
[expected_license_path, expected_license_symlinks],
legalcode.get_file_and_links("legalcode"),
)
def test_translated(self):
bylicense30ported = LicenseFactory(license_code="by-nc",
version="3.0",
jurisdiction_code="ar")
bylicense30unported = LicenseFactory(license_code="by-nc",
version="3.0",
jurisdiction_code="")
bylicense40 = LicenseFactory(license_code="by-nc",
version="4.0",
jurisdiction_code="")
cc0v1license = LicenseFactory(license_code="CC0",
version="1.0",
jurisdiction_code="")
should_be_translated = [
LegalCodeFactory(license=bylicense40),
LegalCodeFactory(license=cc0v1license),
]
should_not_be_translated = [
LegalCodeFactory(license=bylicense30ported),
LegalCodeFactory(license=bylicense30unported),
]
self.assertCountEqual(should_be_translated,
list(LegalCode.objects.translated()))
self.assertCountEqual(
should_not_be_translated,
set(LegalCode.objects.all()) - set(LegalCode.objects.translated()),
)
def test_get_translation_object(self):
# get_translation_object on the model calls the i18n.utils.get_translation_object.
legalcode = LegalCodeFactory(license__version="4.0",
license__license_code="by-sa",
language_code="de")
with mock.patch("licenses.models.get_translation_object") as mock_djt:
legalcode.get_translation_object()
mock_djt.assert_called_with(domain="by-sa_40",
django_language_code="de")
def test_get_pofile(self):
legalcode = LegalCodeFactory()
test_pofile = polib.POFile()
test_translation_filename = "/dev/null"
with mock.patch.object(LegalCode, "translation_filename") as mock_tf:
mock_tf.return_value = test_translation_filename
with mock.patch.object(polib, "pofile") as mock_pofile:
mock_pofile.return_value = test_pofile
result = legalcode.get_pofile()
mock_pofile.assert_called_with("", encoding="utf-8")
self.assertEqual(test_pofile, result)
def test_get_metadata(self):
license = LicenseFactory(
**{
"license_code": "by-nc",
"version": "3.0",
"title_english": "The Title",
"jurisdiction_code": "xyz",
"permits_derivative_works": False,
"permits_reproduction": False,
"permits_distribution": True,
"permits_sharing": True,
"requires_share_alike": True,
"requires_notice": True,
"requires_attribution": True,
"requires_source_code": True,
"prohibits_commercial_use": True,
"prohibits_high_income_nation_use": False,
})
LegalCodeFactory(license=license, language_code="pt")
LegalCodeFactory(license=license, language_code="en")
data = license.get_metadata()
expected_data = {
"jurisdiction": "xyz",
"license_code": "by-nc",
"permits_derivative_works": False,
"permits_distribution": True,
"permits_reproduction": False,
"permits_sharing": True,
"prohibits_commercial_use": True,
"prohibits_high_income_nation_use": False,
"requires_attribution": True,
"requires_notice": True,
"requires_share_alike": True,
"requires_source_code": True,
"title_english": "The Title",
"translations": {
"en": {
"deed": "/licenses/by-nc/3.0/xyz/",
"license": "/licenses/by-nc/3.0/xyz/legalcode",
"title": "The Title",
},
"pt": {
"deed": "/licenses/by-nc/3.0/xyz/deed.pt",
"license": "/licenses/by-nc/3.0/xyz/legalcode.pt",
"title": "The Title",
},
},
"version": "3.0",
}
self.assertEqual(expected_data, data)
def test_valid(self):
bylicense30ported = LicenseFactory(license_code="by-nc",
version="3.0",
jurisdiction_code="ar")
bylicense30unported = LicenseFactory(license_code="by-nc",
version="3.0",
jurisdiction_code="")
nonbylicense30ported = LicenseFactory(license_code="xyz",
version="3.0",
jurisdiction_code="ar")
nonbylicense30unported = LicenseFactory(license_code="xyz",
version="3.0",
jurisdiction_code="")
bylicense40 = LicenseFactory(license_code="by-nc",
version="4.0",
jurisdiction_code="")
nonbylicense40 = LicenseFactory(license_code="xyz",
version="4.0",
jurisdiction_code="")
cc0v1license = LicenseFactory(license_code="CC0",
version="1.0",
jurisdiction_code="")
noncc0v1license = LicenseFactory(license_code="xyz",
version="1.0",
jurisdiction_code="")
# Test valid()
should_be_valid = [
LegalCodeFactory(license=bylicense30ported),
LegalCodeFactory(license=bylicense30unported),
LegalCodeFactory(license=bylicense40),
LegalCodeFactory(license=cc0v1license),
]
should_not_be_valid = [
LegalCodeFactory(license=nonbylicense30ported),
LegalCodeFactory(license=nonbylicense30unported),
LegalCodeFactory(license=nonbylicense40),
LegalCodeFactory(license=noncc0v1license),
]
self.assertCountEqual(should_be_valid, list(LegalCode.objects.valid()))
self.assertCountEqual(
should_not_be_valid,
set(LegalCode.objects.all()) - set(LegalCode.objects.valid()),
)
# Test validgroups()
self.assertCountEqual(
should_be_valid,
list(LegalCode.objects.validgroups()["by4.0"]) +
list(LegalCode.objects.validgroups()["by3.0"]) +
list(LegalCode.objects.validgroups()["zero1.0"]),
)
self.assertCountEqual(
should_not_be_valid,
set(LegalCode.objects.all()) - set(
list(LegalCode.objects.validgroups()["by4.0"]) +
list(LegalCode.objects.validgroups()["by3.0"]) +
list(LegalCode.objects.validgroups()["zero1.0"])),
)
def test_upload_messages_non_english_resource_exists(self):
# non-English because it's not the source messages and is handled
# differently
license = LicenseFactory(license_code="by-nd", version="4.0")
legalcode = LegalCodeFactory(license=license, language_code="fr")
test_resources = [
{
"slug": license.resource_slug,
}
]
test_pofile = mock.MagicMock()
with mpo(self.helper, "get_transifex_resources") as mock_gtr:
mock_gtr.return_value = test_resources
with mp("licenses.transifex.get_pofile_content") as mock_gpc:
mock_gpc.return_value = "not really"
with mpo(self.helper, "update_translations") as mock_ut:
self.helper.upload_messages_to_transifex(
legalcode, test_pofile
)
mock_gtr.assert_called_with()
mock_gpc.assert_called_with(test_pofile)
mock_ut.assert_called_with(
"by-nd_40",
"fr",
"/trans/repo/legalcode/fr/LC_MESSAGES/by-nd_40.po",
"not really",
)
def test_upload_messages_english_resource_exists(self):
# English because it's the source messages and is handled differently
license = LicenseFactory(license_code="by-nd", version="4.0")
legalcode = LegalCodeFactory(
license=license,
language_code=DEFAULT_LANGUAGE_CODE,
)
test_resources = [
{
"slug": license.resource_slug,
}
]
test_pofile = polib.POFile()
with mpo(self.helper, "get_transifex_resources") as mock_gtr:
mock_gtr.return_value = test_resources
with mp("licenses.transifex.get_pofile_content") as mock_gpc:
mock_gpc.return_value = "not really"
with mpo(self.helper, "update_source_messages") as mock_usm:
self.helper.upload_messages_to_transifex(
legalcode, test_pofile
)
mock_gtr.assert_called_with()
mock_gpc.assert_called_with(test_pofile)
mock_usm.assert_called_with(
"by-nd_40",
"/trans/repo/legalcode/en/LC_MESSAGES/by-nd_40.po",
"not really",
)
def test_stats(self):
language_code = "es"
lc1 = LegalCodeFactory(language_code=language_code)
tb = TranslationBranchFactory(language_code=language_code,
legalcodes=[lc1])
class MockPofile(list):
def untranslated_entries(self):
return [1, 2, 3, 4, 5]
def translated_entries(self):
return [1, 2, 3]
mock_pofile = MockPofile()
with mock.patch.object(LegalCode, "get_pofile") as mock_get_pofile:
mock_get_pofile.return_value = mock_pofile
stats = tb.stats
self.assertEqual(
{
"percent_messages_translated": 37,
"number_of_total_messages": 8,
"number_of_translated_messages": 3,
"number_of_untranslated_messages": 5,
},
stats,
)
def test_translation_filename(self):
data = [
# ("expected", license_code, version, jurisdiction, language),
("/foo/legalcode/de/LC_MESSAGES/by-sa_03.po", "by-sa", "0.3", "",
"de"),
(
"/foo/legalcode/de/LC_MESSAGES/by-sa_03_xx.po",
"by-sa",
"0.3",
"xx",
"de",
),
]
for expected, license_code, version, jurisdiction, language in data:
with self.subTest(expected):
license = LicenseFactory(
license_code=license_code,
version=version,
jurisdiction_code=jurisdiction,
)
self.assertEqual(
expected,
LegalCodeFactory(
license=license,
language_code=language).translation_filename(),
)
def test_str(self):
LegalCodeFactory()
legal_code = LegalCode.objects.first()
self.assertEqual(
str(legal_code),
f"LegalCode<{legal_code.language_code}, {str(legal_code.license)}>",
)
def test_get_legalcode_for_language_code(self):
license = LicenseFactory()
lc_pt = LegalCodeFactory(license=license, language_code="pt")
lc_en = LegalCodeFactory(license=license, language_code="en")
with override(language="pt"):
result = license.get_legalcode_for_language_code(None)
self.assertEqual(lc_pt.id, result.id)
result = license.get_legalcode_for_language_code("pt")
self.assertEqual(lc_pt.id, result.id)
result = license.get_legalcode_for_language_code("en")
self.assertEqual(lc_en.id, result.id)
with self.assertRaises(LegalCode.DoesNotExist):
license.get_legalcode_for_language_code("en_us")
result = license.get_legalcode_for_language_code("en-us")
self.assertEqual(lc_en.id, result.id)
def test_has_english(self):
license = LicenseFactory()
lc_fr = LegalCodeFactory(license=license, language_code="fr")
self.assertFalse(lc_fr.has_english())
lc_en = LegalCodeFactory(license=license, language_code="en")
self.assertTrue(lc_fr.has_english())
self.assertTrue(lc_en.has_english())
def test_handle_updated_translation_branch(self):
helper = TransifexHelper()
dummy_repo = DummyRepo("/trans/repo")
result = helper.handle_updated_translation_branch(dummy_repo, [])
self.assertIsNone(result)
legalcode1 = LegalCodeFactory(
license__version="4.0",
license__license_code="by-nc",
language_code="fr",
)
legalcode2 = LegalCodeFactory(
license__version="4.0",
license__license_code="by-nd",
language_code="fr",
)
with mp("licenses.transifex.setup_local_branch") as mock_setup, mpo(
helper, "update_branch_for_legalcode"
) as mock_update_branch, mp(
"licenses.transifex.call_command"
) as mock_call_command, mp(
"licenses.transifex.commit_and_push_changes"
) as mock_commit:
# setup_local_branch
# update_branch_for_legalcode
# commit_and_push_changes
# branch_object.save()
result = helper.handle_updated_translation_branch(
dummy_repo, [legalcode1, legalcode2]
)
self.assertIsNone(result)
mock_setup.assert_called_with(dummy_repo, legalcode1.branch_name())
# Should have published static files for this branch
expected = [
mock.call("publish", branch_name=legalcode1.branch_name()),
]
self.assertEqual(expected, mock_call_command.call_args_list)
trb = TranslationBranch.objects.get()
expected = [
mock.call(dummy_repo, legalcode1, trb),
mock.call(dummy_repo, legalcode2, trb),
]
self.assertEqual(expected, mock_update_branch.call_args_list)
mock_commit.assert_called_with(
dummy_repo, "Translation changes from Transifex.", "", push=True
)
def test_license_deed_view_cc0(self):
lc = LegalCodeFactory(
license__license_code="CC0",
license__version="1.0",
language_code="en",
)
url = lc.deed_url
rsp = self.client.get(url)
self.assertEqual(200, rsp.status_code)
def test_branch_name(self):
legalcode = LegalCodeFactory(license__version="4.0",
license__license_code="by-sa",
language_code="de")
self.assertEqual("cc4-de", legalcode.branch_name())
legalcode = LegalCodeFactory(license__version="3.5",
license__license_code="other",
language_code="de")
self.assertEqual("other-35-de", legalcode.branch_name())
legalcode = LegalCodeFactory(
license__version="3.5",
license__license_code="other",
language_code="de",
license__jurisdiction_code="xyz",
)
self.assertEqual("other-35-de-xyz", legalcode.branch_name())
def test_license_deed_view_code_version_jurisdiction(self):
# "<code:license_code>/<version:version>/<jurisdiction:jurisdiction>/"
lc = LegalCodeFactory(
license__license_code="by-sa",
license__version="3.0",
license__jurisdiction_code="es",
language_code="es",
)
url = lc.deed_url
rsp = self.client.get(url)
self.assertEqual(200, rsp.status_code)
def test_view_license_plain_text(self):
for language_code in ["es", "ar", DEFAULT_LANGUAGE_CODE]:
lc = LegalCodeFactory(license__version="4.0", language_code=language_code)
url = lc.plain_text_url
rsp = self.client.get(url)
self.assertEqual(
'text/plain; charset="utf-8"', rsp._headers["content-type"][1]
)
self.assertEqual(200, rsp.status_code)
self.assertGreater(len(rsp.content.decode()), 0)
lc = LegalCodeFactory(
license__version="3.0",
language_code="fr",
license__license_code="by",
license__jurisdiction_code="ch",
)
url = lc.plain_text_url
rsp = self.client.get(url)
self.assertEqual('text/plain; charset="utf-8"', rsp._headers["content-type"][1])
self.assertEqual(200, rsp.status_code)
self.assertGreater(len(rsp.content.decode()), 0)
def test_handle_legalcodes_with_updated_translations(self):
helper = TransifexHelper()
dummy_repo = DummyRepo("/trans/repo")
# No legalcodes, shouldn't call anything or return anything
result = helper.handle_legalcodes_with_updated_translations(
dummy_repo, []
)
self.assertEqual([], result)
# legalcodes for two branches
legalcode1 = LegalCodeFactory(
license__version="4.0",
license__license_code="by-nc",
language_code="fr",
)
legalcode2 = LegalCodeFactory(
license__version="4.0",
license__license_code="by-nd",
language_code="de",
)
with mpo(helper, "handle_updated_translation_branch") as mock_handle:
result = helper.handle_legalcodes_with_updated_translations(
dummy_repo, [legalcode1, legalcode2]
)
self.assertEqual(
[legalcode1.branch_name(), legalcode2.branch_name()], result
)
self.assertEqual(
[
mock.call(dummy_repo, [legalcode1]),
mock.call(dummy_repo, [legalcode2]),
],
mock_handle.call_args_list,
)
def test_plain_text_url(self):
lc = LegalCodeFactory(
license__license_code="by",
license__version="4.0",
license__jurisdiction_code="",
language_code="en",
)
lc1 = LegalCodeFactory(
license__license_code="by",
license__version="4.0",
license__jurisdiction_code="",
language_code="fr",
)
lc2 = LegalCodeFactory(
license__license_code="by",
license__version="4.0",
license__jurisdiction_code="",
language_code="ar",
)
self.assertEqual(lc.plain_text_url, f"{lc.license_url}/index.txt")
self.assertEqual(lc1.plain_text_url, f"{lc1.license_url}.txt")
self.assertEqual(lc2.plain_text_url, f"{lc2.license_url}.txt")
def test_view_license_identifying_jurisdiction_default_language(self):
language_code = "de"
lc = LegalCodeFactory(
license__version="3.0",
language_code=language_code,
license__jurisdiction_code="de",
)
url = lc.license_url
rsp = self.client.get(url)
self.assertEqual(200, rsp.status_code)
self.assertTemplateUsed(rsp, "legalcode_page.html")
self.assertTemplateUsed(rsp, "includes/legalcode_30_ported_license.html")
context = rsp.context
self.assertContains(rsp, f'''lang="{language_code}"''')
self.assertEqual(lc, context["legalcode"])
def test_view_license(self):
for language_code in ["es", "ar", DEFAULT_LANGUAGE_CODE]:
lc = LegalCodeFactory(license__version="4.0", language_code=language_code)
url = lc.license_url
rsp = self.client.get(url)
self.assertEqual(200, rsp.status_code)
self.assertTemplateUsed(rsp, "legalcode_page.html")
self.assertTemplateUsed(rsp, "includes/legalcode_40_license.html")
context = rsp.context
self.assertEqual(lc, context["legalcode"])
self.assertContains(rsp, f'''lang="{language_code}"''')
if language_code == "es":
self.assertContains(rsp, '''dir="ltr"''')
elif language_code == "ar":
self.assertContains(rsp, '''dir="rtl"''')
def test_license_deed_view_code_version_jurisdiction_language(self):
license = LicenseFactory(
license_code="by-nc", jurisdiction_code="es", version="3.0"
)
language_code = "fr"
lc = LegalCodeFactory(license=license, language_code=language_code)
# "<code:license_code>/<version:version>/<jurisdiction:jurisdiction>/deed.<lang:target_lang>"
url = lc.deed_url
# Mock 'get_translation_object' because we have no 3.0 translations imported yet
# and we can't use 4.0 to test jurisdictions.
translation_object = DjangoTranslation(language="fr")
with mock.patch.object(LegalCode, "get_translation_object") as mock_gto:
mock_gto.return_value = translation_object
rsp = self.client.get(url)
self.assertEqual(200, rsp.status_code)
def test_translation_domain(self):
data = [
# ("expected", "license_code", "version", "jurisdiction", "language")
("by-sa_30", "by-sa", "3.0", "", "fr"),
("by-sa_30_xx", "by-sa", "3.0", "xx", "fr"),
]
for expected, license_code, version, jurisdiction, language in data:
with self.subTest(expected):
legalcode = LegalCodeFactory(
license__license_code=license_code,
license__version=version,
license__jurisdiction_code=jurisdiction,
language_code=language,
)
self.assertEqual(expected, legalcode.translation_domain)
def test_tx_upload_messages(self):
legalcode = LegalCodeFactory(language_code=DEFAULT_LANGUAGE_CODE)
license = legalcode.license
test_pofile = polib.POFile()
with mock.patch.object(
license, "get_legalcode_for_language_code") as mock_glflc:
mock_glflc.return_value = legalcode
with mock.patch.object(
TransifexHelper,
"upload_messages_to_transifex") as mock_umtt:
with mock.patch.object(LegalCode,
"get_pofile") as mock_get_pofile:
mock_get_pofile.return_value = test_pofile
license.tx_upload_messages()
mock_glflc.assert_called_with("en")
mock_umtt.assert_called_with(legalcode=legalcode)
def test_upload_messages_to_transifex_no_resource_yet_not_english(self):
# Must be english or we can't create the resource
# If we try this with a non-english language and there's no resource,
# we should get an error.
legalcode = LegalCodeFactory(language_code="es")
test_pofile = polib.POFile()
with mpo(self.helper, "get_transifex_resources") as mock_gtr:
mock_gtr.return_value = []
with mpo(legalcode, "get_pofile") as mock_gpwem:
mock_gpwem.return_value = test_pofile
with self.assertRaisesMessage(ValueError, "Must upload English first"):
self.helper.upload_messages_to_transifex(legalcode)
mock_gtr.assert_called_with()
mock_gpwem.assert_called_with()
def test_view_license_with_jurisdiction_without_language_specified(self):
lc = LegalCodeFactory(
license__version="3.0",
language_code="de",
license__jurisdiction_code="de",
)
url = reverse(
"licenses_default_language_with_jurisdiction",
kwargs=dict(
version="3.0", jurisdiction="de", license_code=lc.license.license_code
),
)
rsp = self.client.get(url)
self.assertEqual(200, rsp.status_code)
self.assertTemplateUsed(rsp, "legalcode_page.html")
self.assertTemplateUsed(rsp, "includes/legalcode_30_ported_license.html")
context = rsp.context
self.assertContains(rsp, '''lang="de"''')
self.assertEqual(lc, context["legalcode"])
def test_upload_messages_to_transifex_no_resource_yet(self):
# English so we can create the resource
license = LicenseFactory(license_code="by-nd", version="4.0")
legalcode = LegalCodeFactory(
license=license,
language_code=DEFAULT_LANGUAGE_CODE,
)
pofile_content = """
msgid ""
msgstr ""
"Project-Id-Version: by-nd-4.0\n"
"Language: en\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
msgid "license_medium"
msgstr "Attribution-NoDerivatives 4.0 International"
"""
english_pofile = polib.pofile(pofile=pofile_content)
with mpo(self.helper, "get_transifex_resources") as mock_gtr:
mock_gtr.return_value = []
with mpo(self.helper, "create_resource") as mock_create_resource:
with mpo(legalcode, "get_pofile") as mock_gpwem:
mock_gpwem.return_value = english_pofile
with mp(
"licenses.transifex.get_pofile_content"
) as mock_gpc:
mock_gpc.return_value = "not really"
self.helper.upload_messages_to_transifex(legalcode)
mock_create_resource.assert_called_with(
"by-nd_40",
"CC BY-ND 4.0",
"/trans/repo/legalcode/en/LC_MESSAGES/by-nd_40.po",
"not really",
)
mock_gpwem.assert_called_with()
mock_gtr.assert_called_with()
def test_get_english_pofile(self):
legalcode = LegalCodeFactory(language_code="es")
legalcode_en = LegalCodeFactory(license=legalcode.license,
language_code=DEFAULT_LANGUAGE_CODE)
test_pofile = polib.POFile()
with mock.patch.object(License,
"get_legalcode_for_language_code") as mock_glfl:
mock_glfl.return_value = legalcode_en
with mock.patch.object(legalcode_en, "get_pofile") as mock_gp:
mock_gp.return_value = test_pofile
self.assertEqual(test_pofile, legalcode.get_english_pofile())
self.assertEqual(test_pofile,
legalcode_en.get_english_pofile())
mock_glfl.assert_called_with(DEFAULT_LANGUAGE_CODE)
mock_gp.assert_called_with()
def test_update_branch_for_legalcode(self):
helper = TransifexHelper()
dummy_repo = DummyRepo("/trans/repo")
legalcode = LegalCodeFactory(
license__version="4.0",
license__license_code="by-nc",
language_code="fr",
)
helper._stats = {
legalcode.license.resource_slug: {
legalcode.language_code: {
"translated": {
"last_activity": now().isoformat(),
}
}
}
}
trb = TranslationBranch.objects.create(
branch_name=legalcode.branch_name(),
version=legalcode.license.version,
language_code=legalcode.language_code,
complete=False,
)
content = b"wxyz"
# transifex_get_pofile_content
# save_content_as_pofile_and_mofile
with mpo(
helper, "transifex_get_pofile_content"
) as mock_get_content, mp(
"licenses.transifex.save_content_as_pofile_and_mofile"
) as mock_save:
mock_get_content.return_value = content
mock_save.return_value = [legalcode.translation_filename()]
result = helper.update_branch_for_legalcode(
dummy_repo, legalcode, trb
)
self.assertIsNone(result)
mock_get_content.assert_called_with(
legalcode.license.resource_slug, legalcode.language_code
)
mock_save.assert_called_with(legalcode.translation_filename(), content)
self.assertEqual({legalcode}, set(trb.legalcodes.all()))
relpath = os.path.relpath(
legalcode.translation_filename(),
settings.TRANSLATION_REPOSITORY_DIRECTORY,
)
dummy_repo.index.add.assert_called_with([relpath])
