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