def test_store_get_template_file_class(po_directory, templates): project = ProjectDBFactory(source_language=templates) tp = TranslationProjectFactory(language=templates, project=project) format_registry = formats.get() foo_filetype = format_registry.register("foo", "foo", template_extension="bar") tp.project.filetypes.add(foo_filetype) store = Store.objects.create(name="mystore.bar", translation_project=tp, parent=tp.directory) # oh no! not recognised by ttk with pytest.raises(ValueError): store.syncer.file_class class CustomFormatClass(object): pass @provider(format_classes) def format_class_provider(**kwargs): return dict(foo=CustomFormatClass) assert store.syncer.file_class == CustomFormatClass format_classes.disconnect(format_class_provider)
def test_tp_tool_bad(po_directory, tp0, templates, english, no_templates_tps): other_project = ProjectDBFactory(source_language=english) other_tp = TranslationProjectFactory( project=other_project, language=LanguageDBFactory()) tp_tool = TPTool(tp0.project) with pytest.raises(ValueError): tp_tool.check_tp(other_tp) with pytest.raises(ValueError): tp_tool.set_parents(tp0.directory, other_tp.directory) with pytest.raises(ValueError): tp_tool.set_parents(other_tp.directory, tp0.directory) with pytest.raises(ValueError): tp_tool.move(other_tp, templates) with pytest.raises(ValueError): tp_tool.clone(other_tp, templates) with pytest.raises(ValueError): # cant set tp to a language if a tp already exists tp_tool.move( tp0, Language.objects.get(code="language1")) with pytest.raises(ValueError): # cant clone tp to a language if a tp already exists tp_tool.clone( tp0, Language.objects.get(code="language1"))
def test_add_store_bad(po_directory, english): """Try to create a store_fs by pootle_path for a non existent project """ project0 = Project.objects.get(code="project0") project = ProjectDBFactory(source_language=english) # project doesnt exist with pytest.raises(ValidationError): StoreFS.objects.create(pootle_path="/en/project0_BAD/example.po", path="/some/fs/example.po") # pootle_path must match project_code with pytest.raises(ValidationError): StoreFS.objects.create(project=project0, pootle_path="/en/%s/en.po" % project.code, path="/locales/en.po") # need both pootle_path and fs_path - somehow with pytest.raises(ValidationError): StoreFS.objects.create(project=project0, pootle_path="/language0/%s/en.po" % project0.code) with pytest.raises(ValidationError): StoreFS.objects.create(project=project0, path="/locales/en.po") store = setup_store("/language0/project0/en.po") with pytest.raises(ValidationError): StoreFS.objects.create(store=store, pootle_path=store.pootle_path)
def test_tp_tool_clone_project_same_lang(tp0, english): new_proj = ProjectDBFactory(source_language=english) tp_tool = TPTool(tp0.project) _test_tp_match( tp0, tp_tool.clone(tp0, tp0.language, new_proj), new_proj)
def setup_disabled_project(self): from pytest_pootle.factories import (DirectoryFactory, ProjectDBFactory, TranslationProjectFactory) from pootle.core.contextmanagers import keep_data from pootle_format.models import Format from pootle_language.models import Language with keep_data(): source_language = Language.objects.get(code="en") project = ProjectDBFactory(code="disabled_project0", fullname="Disabled Project 0", source_language=source_language) project.filetypes.add(Format.objects.get(name="po")) project.disabled = True project.save() language = Language.objects.get(code="language0") tp = TranslationProjectFactory(project=project, language=language) tp_dir = tp.directory tp_dir.obsolete = False tp_dir.save() self._add_stores(tp, n=(1, 1)) subdir0 = DirectoryFactory(name="subdir0", parent=tp.directory, tp=tp) self._add_stores(tp, n=(1, 1), parent=subdir0)
def test_data_tp(english): """Test that you cant add a duplicate file extension """ tp = TranslationProjectFactory( project=ProjectDBFactory(source_language=english), language=LanguageDBFactory()) assert (repr(tp.data) == '<TPData: %s>' % tp.pootle_path)
def tp_checker_tests(request, english, checkers): from pytest_pootle.factories import ProjectDBFactory checker_name = checkers project = ProjectDBFactory(checkstyle=checker_name, source_language=english) return (checker_name, project)
def test_project_fs_instance_bad(english): # needs a Project with pytest.raises(TypeError): FSPlugin() project = ProjectDBFactory(source_language=english) # project is not configured with pytest.raises(NotConfiguredError): FSPlugin(project) with pytest.raises(ValidationError): project.config["pootle_fs.fs_type"] = "foo" project.config["pootle_fs.fs_type"] = "localfs" with pytest.raises(NotConfiguredError): FSPlugin(project) project.config["pootle_fs.fs_url"] = "/bar" default_receivers = fs_plugins.receivers[:] default_cache = fs_plugins.sender_receivers_cache.copy() @provider(fs_plugins, sender=Project) def provide_fs_plugin(**kwargs): return dict(dummyfs=DummyFSPlugin) project.config["pootle_fs.fs_type"] = "dummyfs" fs_plugins.receivers = default_receivers fs_plugins.sender_receivers_cache = default_cache with pytest.raises(MissingPluginError): FSPlugin(project)
def test_add_store_fs_by_path(english): """Add a store_fs for pootle_path """ project = ProjectDBFactory(source_language=english) language = LanguageDBFactory() tp = TranslationProjectFactory(project=project, language=language) store = StoreDBFactory( translation_project=tp, parent=tp.directory, name="example_store.po") conf = config.get(tp.project.__class__, instance=tp.project) conf.set_config("pootle_fs.fs_type", "localfs") conf.set_config("pootle_fs.fs_url", "foo") fs_path = "/some/fs/example_store.po" pootle_path = store.pootle_path store_fs = StoreFS.objects.create( pootle_path=pootle_path, path=fs_path) assert store_fs.project == project assert store_fs.store == store assert store_fs.pootle_path == pootle_path assert store_fs.path == fs_path assert store_fs.last_sync_hash is None assert store_fs.last_sync_mtime is None assert store_fs.last_sync_revision is None
def test_lang_mapper_project_config(po_directory, english): project = ProjectDBFactory(source_language=english) project_config = ObjectConfig(project) # upstream_code="en_US", pootle_code="en" project_config["pootle.core.lang_mapping"] = dict(en_US="en") project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper["en_US"] == english assert mapper.get_pootle_code("en_US") == "en" assert mapper.get_upstream_code("en") == "en_US" assert "en_US" in mapper # as en_US is mapped to pootle's en its not valid as upstream code assert mapper.get_upstream_code("en_US") is None # as en is mapped to en_US its not valid as a pootle_code assert mapper.get_pootle_code("en") is None assert "en" not in mapper # we can swap codes project_config["pootle.core.lang_mapping"] = dict(language0="en", en="language0") mapper = lang_mapper.get(project.__class__, instance=project) project.config.reload() language0 = Language.objects.get(code="language0") assert mapper["en"] == language0 assert mapper["language0"] == english assert mapper.get_pootle_code("en") == "language0" assert mapper.get_pootle_code("language0") == "en" assert mapper.get_upstream_code("en") == "language0" assert mapper.get_upstream_code("language0") == "en"
def test_project_fs_instance_bad(english): # needs a Project with pytest.raises(TypeError): FSPlugin() project = ProjectDBFactory(source_language=english) # project is not configured with pytest.raises(NotConfiguredError): FSPlugin(project) project.config["pootle_fs.fs_type"] = "foo" with pytest.raises(NotConfiguredError): FSPlugin(project) project.config["pootle_fs.fs_type"] = None project.config["pootle_fs.fs_url"] = "bar" with pytest.raises(NotConfiguredError): FSPlugin(project) project.config["pootle_fs.fs_type"] = "foo" with pytest.raises(MissingPluginError): FSPlugin(project) @provider(fs_plugins, sender=Project) def provide_fs_plugin(**kwargs): return dict(dummyfs=DummyFSPlugin) with pytest.raises(MissingPluginError): FSPlugin(project)
def test_data_tp_checks(english): """Test that you cant add a duplicate file extension """ tp = TranslationProjectFactory( project=ProjectDBFactory(source_language=english), language=LanguageDBFactory()) check_data = TPChecksData.objects.create(tp=tp) assert (repr(check_data) == '<TPChecksData: %s>' % tp.pootle_path)
def test_plugin_instance(english): project = ProjectDBFactory(source_language=english) project.config["pootle_fs.fs_type"] = "hg" project.config["pootle_fs.fs_url"] = "bar" project.config["pootle_fs.translation_paths"] = DEFAULT_TRANSLATION_PATHS hg_plugin = FSPlugin(project) assert hg_plugin.project == hg_plugin.plugin.project == project assert hg_plugin.is_cloned is False
def test_store_get_or_create_templates(po_directory, templates): project = ProjectDBFactory(source_language=templates) tp = TranslationProjectFactory(language=templates, project=project) po = Format.objects.get(name="po") store = Store.objects.get_or_create(name="mystore.pot", translation_project=tp, parent=tp.directory)[0] assert store.filetype == po assert store.is_template
def test_fs_state_instance(settings, english): settings.POOTLE_FS_PATH = "/tmp/foo/" project = ProjectDBFactory(source_language=english) plugin = DummyPlugin(project) state = ProjectFSState(plugin) assert state.project == project assert state.states == FS_STATE.keys() assert (str(state) == ( "<ProjectFSState(<DummyPlugin(%s)>): Nothing to report>" % project.fullname))
def test_fs_cmd_bad_project(project_fs, capsys, english): with pytest.raises(CommandError): call_command("fs", "state", "BAD_PROJECT_CODE") with pytest.raises(CommandError): call_command("fs", "BAD_SUBCOMMAND", "project0") with pytest.raises(CommandError): call_command("fs", "state", ProjectDBFactory(source_language=english).code)
def setup_terminology(self): from pytest_pootle.factories import (ProjectDBFactory, TranslationProjectFactory) from pootle_language.models import Language source_language = Language.objects.get(code="en") terminology = ProjectDBFactory(code="terminology", checkstyle="terminology", fullname="Terminology", source_language=source_language) for language in Language.objects.all(): TranslationProjectFactory(project=terminology, language=language)
def tp_checker_tests(request, english, checkers): from pytest_pootle.factories import ProjectDBFactory checker_name = checkers project = ProjectDBFactory(checkstyle=checker_name, source_language=english) def _remove_project_directory(): shutil.rmtree(project.get_real_path()) request.addfinalizer(_remove_project_directory) return (checker_name, project)
def test_lang_mapper_bad_preset(po_directory, english, caplog): project = ProjectDBFactory(source_language=english) mapper = lang_mapper.get(project.__class__, instance=project) assert mapper.lang_mappings == {} project_config = ObjectConfig(project) project_config["pootle.core.use_lang_mapping_presets"] = [ "PRESET_DOES_NOT_EXIST" ] project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper.lang_mappings == {} assert ("Unrecognised lang mapping preset" in ''.join([l.message for l in caplog.records]))
def setup_site_matrix(self): from pytest_pootle.factories import ProjectDBFactory, LanguageDBFactory from pootle_language.models import Language # add 2 languages for i in range(0, 2): LanguageDBFactory() source_language = Language.objects.get(code="en") for i in range(0, 2): # add 2 projects ProjectDBFactory(source_language=source_language)
def test_data_tp(english): """Test that you cant add a duplicate file extension """ from pytest_pootle.factories import ( LanguageDBFactory, ProjectDBFactory, TranslationProjectFactory) tp = TranslationProjectFactory( project=ProjectDBFactory(source_language=english), language=LanguageDBFactory()) data = TPData.objects.create(tp=tp) assert ( repr(data) == '<TPData: %s>' % tp.pootle_path)
def test_lang_mapper_no_config(po_directory, english): project = ProjectDBFactory(source_language=english) mapper = lang_mapper.get(project.__class__, instance=project) # lang exists and its valid assert mapper["en"] == english assert mapper.get_pootle_code("en") == "en" assert mapper.get_upstream_code("en") == "en" assert "en" in mapper # The lang doesnt exist but its not excluded assert mapper["en_FOO"] is None assert mapper.get_pootle_code("en_FOO") == "en_FOO" assert mapper.get_upstream_code("en_FOO") == "en_FOO" assert "en_FOO" not in mapper
def setup_site_matrix(self): from pytest_pootle.factories import ProjectDBFactory, LanguageDBFactory from pootle_format.models import Format from pootle_language.models import Language # add 2 languages for i_ in range(0, 2): LanguageDBFactory() source_language = Language.objects.get(code="en") po = Format.objects.get(name="po") for i_ in range(0, 2): # add 2 projects project = ProjectDBFactory(source_language=source_language) project.filetypes.add(po)
def test_tp_create_with_none_treestyle(po_directory, english, templates, settings): project = ProjectDBFactory(source_language=english, treestyle='pootle_fs') language = LanguageDBFactory() TranslationProjectFactory(language=templates, project=project) tp = TranslationProject.objects.create(project=project, language=language) assert not tp.abs_real_path assert not os.path.exists( os.path.join(settings.POOTLE_TRANSLATION_DIRECTORY, project.code)) tp.save() assert not tp.abs_real_path assert not os.path.exists( os.path.join(settings.POOTLE_TRANSLATION_DIRECTORY, project.code))
def moz_env(post_db_setup, _django_cursor_wrapper, ios_pootle_file): from django.conf import settings from pytest_pootle.factories import (ProjectDBFactory, StoreDBFactory, TranslationProjectFactory) from pootle_fs.models import ProjectFS from pootle_language.models import Language with _django_cursor_wrapper: ios_project = ProjectDBFactory( source_language=Language.objects.get(code="en"), code="ios", localfiletype="xliff") ios_tp = TranslationProjectFactory( project=ios_project, language=Language.objects.get(code="language0")) ios_store = StoreDBFactory(parent=ios_tp.directory, translation_project=ios_tp, name="firefox-ios.xliff") ios_bytes = io.BytesIO(ios_pootle_file.encode("utf8")) ios_store.update(getclass(ios_bytes)(ios_bytes.read())) fs_dir = tempfile.mkdtemp() settings.POOTLE_FS_PATH = fs_dir repo_path = os.path.join(fs_dir, "__moz_ios_src__") Repo.init(repo_path, bare=True) with tmp_git(repo_path) as (tmp_repo_path, tmp_repo): config_file = os.path.join(tmp_repo_path, ".pootle.ini") with open(config_file, "w") as ini: config = ("[default]\n" "serializers = ios\n" "deserializers = ios\n" "translation_path = <lang>/<filename>.xliff") ini.write(config) tmp_repo.index.add([".pootle.ini"]) tmp_repo.index.commit("Add Pootle configuration") tmp_repo.remotes.origin.push("master:master") ios_fs = ProjectFS.objects.create(project=ios_project, fs_type="git", url=repo_path) ios_plugin = ios_fs.plugin ios_plugin.add_translations()
def project_fs_empty(english, tmpdir, settings): from pytest_pootle.factories import ProjectDBFactory from pootle_fs.utils import FSPlugin project = ProjectDBFactory(source_language=english, code="project_fs_empty") settings.POOTLE_FS_WORKING_PATH = str(tmpdir) repo_path = os.path.join(str(tmpdir), "__src__") if not os.path.exists(repo_path): os.mkdir(repo_path) project.config["pootle_fs.fs_type"] = "localfs" project.config["pootle_fs.fs_url"] = repo_path project.config["pootle_fs.translation_mappings"] = { "default": "/<language_code>/<dir_path>/<filename>.<ext>" } return FSPlugin(project)
def test_add_store_bad_path(po_directory, english): """Try to create a store_fs where pootle_path and store.pootle_path dont match. """ fs_path = "/some/fs/example.po" project = ProjectDBFactory(source_language=english) language = LanguageDBFactory() tp = TranslationProjectFactory(project=project, language=language) tp.project.config["pootle_fs.fs_type"] = "localfs" tp.project.config["pootle_fs.fs_url"] = "/foo" store = StoreDBFactory(translation_project=tp, parent=tp.directory, name="example_store.po") with pytest.raises(ValidationError): StoreFS.objects.create(store=store, pootle_path="/some/other/path.po", path=fs_path)
def test_lang_mapper_preset_config(po_directory, english): project = ProjectDBFactory(source_language=english) project_config = ObjectConfig(project) site_config = SiteConfig() # add the preset site_config["pootle.core.lang_mapping_presets"] = dict(preset_1=dict( en_US="en")) # project not configured yet tho mapper = lang_mapper.get(project.__class__, instance=project) assert mapper["en_US"] is None assert mapper["en"] == english # configure project to use preset project_config["pootle.core.use_lang_mapping_presets"] = ["preset_1"] project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper["en_US"] == english assert mapper["en"] is None
def setup_terminology(self): from pytest_pootle.factories import ( ProjectDBFactory, StoreDBFactory, TranslationProjectFactory, UnitDBFactory ) from pootle_language.models import Language source_language = Language.objects.get(code="en") terminology = ProjectDBFactory(code="terminology", checkstyle="terminology", fullname="Terminology", source_language=source_language) for language in Language.objects.exclude(code='en'): tp = TranslationProjectFactory(project=terminology, language=language) store = StoreDBFactory(translation_project=tp, name='terminology.po') store.save() for i_ in range(0, 1): UnitDBFactory(store=store)
def test_format_set_tp_filetype(po_directory, english, language0, po2): project = ProjectDBFactory(source_language=english) filetypes = project.filetype_tool registry = formats.get() lang_tp = TranslationProjectFactory(language=language0, project=project) store = Store.objects.create(name="mystore.po", translation_project=lang_tp, parent=lang_tp.directory) filetypes.add_filetype(po2) filetypes.set_tp_filetype(lang_tp, po2) store = Store.objects.get(pk=store.pk) assert store.filetype == po2 assert store.name.endswith(".po2") po3 = registry.register("special_po_3", "po3", template_extension="pot") filetypes.add_filetype(po3) filetypes.set_tp_filetype(lang_tp, po3) store = Store.objects.get(pk=store.pk) assert store.filetype == po3 assert store.name.endswith(".po3")