def test_global_memory_superuser(self):
self.user.is_superuser = True
self.user.save()
self.test_memory(
"Number of entries on the whole platform",
False,
kwargs={"manage": "manage"},
)
# Download all entries
response = self.client.get(
reverse("memory-download", kwargs={"manage": "manage"}),
{
"format": "json",
"kind": "all"
},
)
validate(response.json(), load_schema("weblate-memory.schema.json"))
# Download shared entries
response = self.client.get(
reverse("memory-download", kwargs={"manage": "manage"}),
{
"format": "json",
"kind": "shared"
},
)
validate(response.json(), load_schema("weblate-memory.schema.json"))
def import_json(self, request, fileobj, origin=None, **kwargs):
content = fileobj.read()
try:
data = json.loads(force_str(content))
except ValueError as error:
report_error(cause="Failed to parse memory")
raise MemoryImportError(
_("Failed to parse JSON file: {!s}").format(error))
try:
validate(data, load_schema("weblate-memory.schema.json"))
except ValidationError as error:
report_error(cause="Failed to validate memory")
raise MemoryImportError(
_("Failed to parse JSON file: {!s}").format(error))
found = 0
lang_cache = {}
for entry in data:
try:
self.update_entry(
source_language=Language.objects.get_by_code(
entry["source_language"], lang_cache),
target_language=Language.objects.get_by_code(
entry["target_language"], lang_cache),
source=entry["source"],
target=entry["target"],
origin=origin,
**kwargs,
)
found += 1
except Language.DoesNotExist:
continue
return found
def test_global_memory_superuser(self):
self.user.is_superuser = True
self.user.save()
self.test_memory("Number of uploaded shared entries", False, prefix="manage-")
# Download all entries
response = self.client.get(
reverse("manage-memory-download"),
{"format": "json", "kind": "all"},
)
validate(response.json(), load_schema("weblate-memory.schema.json"))
# Download shared entries
response = self.client.get(
reverse("manage-memory-download"),
{"format": "json", "kind": "shared"},
)
validate(response.json(), load_schema("weblate-memory.schema.json"))
def test_backup():
"""Test memory schema being valid."""
validate(
{
"metadata": {
"version": "4.13",
"server": "Weblate",
"domain": "weblate.example.com",
"timestamp": "2021-11-18T18:53:54.862Z",
},
"project": {
"name": "Hello",
"slug": "hello",
"web": "https://weblate.org/",
"instructions": "",
"set_language_team": False,
"use_shared_tm": False,
"contribute_shared_tm": False,
"access_control": 0,
"translation_review": False,
"source_review": False,
"enable_hooks": False,
"language_aliases": "",
},
"labels": [],
},
load_schema("weblate-backup.schema.json"),
)
def test_memory(self,
match="Number of your entries",
fail=False,
**kwargs):
response = self.client.get(reverse("memory", **kwargs))
self.assertContains(response, match)
# Test upload
response = self.upload_file("memory.tmx", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "File processed")
# Test download
response = self.client.get(reverse("memory-download", **kwargs))
validate(response.json(), load_schema("weblate-memory.schema.json"))
# Test download
response = self.client.get(reverse("memory-download", **kwargs),
{"format": "tmx"})
self.assertContains(response, "<tmx")
response = self.client.get(reverse("memory-download", **kwargs),
{"format": "json"})
validate(response.json(), load_schema("weblate-memory.schema.json"))
# Test invalid upload
response = self.upload_file("cs.json", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Failed to parse JSON file")
# Test invalid upload
response = self.upload_file("memory-broken.json", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Failed to parse JSON file")
# Test invalid upload
response = self.upload_file("memory-invalid.json", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Failed to parse JSON file")
def test_userdata(self):
response = self.client.post(reverse("userdata"))
self.assertContains(response, "basic")
# Add more languages
self.user.profile.languages.add(Language.objects.get(code="pl"))
self.user.profile.secondary_languages.add(Language.objects.get(code="de"))
self.user.profile.secondary_languages.add(Language.objects.get(code="uk"))
response = self.client.post(reverse("userdata"))
self.assertContains(response, '"pl"')
self.assertContains(response, '"de"')
validate(response.json(), load_schema("weblate-userdata.schema.json"))
def test_memory_newline():
"""Test memory entry containing newlines."""
validate(
[
{
"source": "Error reading config file {filename!r}:\n{error_msg}",
"target": "Fehler der Konfigurationsdatei {filename!r}:\n{error_msg}",
"source_language": "en",
"target_language": "de",
"origin": "myproject/mycomponent",
"category": 10000004,
}
],
load_schema("weblate-memory.schema.json"),
)
def test_dump_command(self):
add_document()
output = StringIO()
call_command("dump_memory", stdout=output)
data = json.loads(output.getvalue())
validate(data, load_schema("weblate-memory.schema.json"))
self.assertEqual(
data,
[{
"source_language": "en",
"target_language": "cs",
"source": "Hello",
"target": "Ahoj",
"origin": "test",
"category": CATEGORY_FILE,
}],
)
def test_userdata():
"""Test user data schema being valid."""
validate(
{
"basic": {
"username": "******",
"full_name": "Weblate Admin",
"email": "*****@*****.**",
"date_joined": "2019-11-18T18:53:54.862Z",
},
"profile": {
"language": "cs",
"suggested": 1,
"translated": 24,
"uploaded": 1,
"hide_completed": False,
"secondary_in_zen": True,
"hide_source_secondary": False,
"editor_link": "",
"translate_mode": 0,
"zen_mode": 0,
"special_chars": "\u00a0 ",
"dashboard_view": 1,
"dashboard_component_list": None,
"languages": ["cs", "vi"],
"secondary_languages": ["sk"],
"watched": ["weblate"],
},
"auditlog": [
{
"address": "127.0.0.1",
"user_agent": "PC / Linux / Firefox 70.0",
"timestamp": "2019-11-18T18:58:30.845Z",
"activity": "login",
},
],
},
load_schema("weblate-userdata.schema.json"),
)
def test_memory(
self, match="Number of your entries", fail=False, prefix: str = "", **kwargs
):
# Test wipe without confirmation
response = self.client.get(reverse(f"{prefix}memory-delete", **kwargs))
self.assertRedirects(response, reverse(f"{prefix}memory", **kwargs))
response = self.client.post(reverse(f"{prefix}memory-delete", **kwargs))
self.assertRedirects(response, reverse(f"{prefix}memory", **kwargs))
# Test list
response = self.client.get(reverse(f"{prefix}memory", **kwargs))
self.assertContains(response, match)
# Test upload
response = self.upload_file("memory.tmx", prefix=prefix, **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "File processed")
# Test download
response = self.client.get(reverse(f"{prefix}memory-download", **kwargs))
validate(response.json(), load_schema("weblate-memory.schema.json"))
# Test download
response = self.client.get(
reverse(f"{prefix}memory-download", **kwargs), {"format": "tmx"}
)
self.assertContains(response, "<tmx")
response = self.client.get(
reverse(f"{prefix}memory-download", **kwargs),
{"format": "tmx", "origin": "memory.tmx"},
)
self.assertContains(response, "<tmx")
response = self.client.get(
reverse(f"{prefix}memory-download", **kwargs), {"format": "json"}
)
validate(response.json(), load_schema("weblate-memory.schema.json"))
# Test wipe
count = Memory.objects.count()
response = self.client.post(
reverse(f"{prefix}memory-delete", **kwargs),
{"confirm": "1", "origin": "invalid"},
follow=True,
)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Entries deleted")
self.assertEqual(count, Memory.objects.count())
response = self.client.post(
reverse(f"{prefix}memory-delete", **kwargs),
{"confirm": "1"},
follow=True,
)
self.assertContains(response, "Entries deleted")
self.assertGreater(count, Memory.objects.count())
# Test invalid upload
response = self.upload_file("cs.json", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Failed to parse JSON file")
# Test invalid upload
response = self.upload_file("memory-broken.json", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Failed to parse JSON file")
# Test invalid upload
response = self.upload_file("memory-invalid.json", **kwargs)
if fail:
self.assertContains(response, "Permission Denied", status_code=403)
else:
self.assertContains(response, "Failed to parse JSON file")
def test_load():
"""Test schema loading."""
schema = load_schema("weblate-memory.schema.json")
assert isinstance(schema, dict)
def test_memory():
"""Test memory schema being valid."""
validate([], load_schema("weblate-memory.schema.json"))
