Changes to test glossaries to fix issues with parallelized tests.

- Test glossary deletion is now managed with context managers or finally clauses, rather than deleting all test glossaries at test begin.
- Test glossary names include UUIDs.

Author: daniel-jones-dev

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Deprecated
 ### Removed
 ### Fixed
+* Fix issues with parallelized tests by changing how test glossaries are created and deleted.
 ### Security
 
 

tests/conftest.py

@@ -7,7 +7,8 @@
 import pathlib
 from pydantic import BaseSettings
 import pytest
-from typing import Optional
+from typing import Callable, Optional
+from typing_extensions import Protocol
 import uuid
 
 
@@ -32,9 +33,6 @@ class Config:
         env_prefix = "DEEPL_"
 
 
-glossary_name_prefix = "deepl-python-test-glossary: "
-
-
 @pytest.fixture
 def config():
     return Config()
@@ -148,21 +146,118 @@ def translator_with_random_auth_key(server):
     return _make_translator(server, auth_key=str(uuid.uuid1()))
 
 
-def remove_test_glossaries(translator):
-    glossaries = translator.list_glossaries()
-    for glossary in glossaries:
-        if glossary.name.startswith(glossary_name_prefix):
-            translator.delete_glossary(glossary)
+@pytest.fixture
+def cleanup_matching_glossaries(translator):
+    """
+    Fixture function to remove all glossaries from the server matching the
+    given predicate. Can be used, for example, to remove all glossaries with a
+    matching name.
+
+    Usage example:
+        def test_example(cleanup_matching_glossaries):
+            ...
+            cleanup_matching_glossaries(
+                lambda glossary: glossary.name.startswith("test ")
+            )
+    """
+
+    def do_cleanup(predicate: Callable[[deepl.GlossaryInfo], bool]):
+        glossaries = translator.list_glossaries()
+        for glossary in glossaries:
+            if predicate(glossary):
+                try:
+                    translator.delete_glossary(glossary)
+                except deepl.DeepLException:
+                    pass
+
+    return do_cleanup
+
+
+class ManagedGlossary:
+    """
+    Utility content-manager class to create a test glossary and ensure its
+    deletion at the end of a test.
+    """
+
+    def __init__(
+        self,
+        translator: deepl.Translator,
+        glossary_name: str,
+        source_lang,
+        target_lang,
+        entries: dict,
+    ):
+        self._translator = translator
+        self._created_glossary = translator.create_glossary(
+            glossary_name, source_lang, target_lang, entries
+        )
+
+    def __enter__(self) -> deepl.GlossaryInfo:
+        return self._created_glossary
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        try:
+            self._translator.delete_glossary(
+                self._created_glossary.glossary_id
+            )
+        except deepl.DeepLException:
+            pass
+
+
+class CreateManagedGlossaryFunc(Protocol):
+    """Helper class for type hints."""
+
+    def __call__(
+        self,
+        source_lang: str = "EN",
+        target_lang: str = "DE",
+        entries: Optional[dict] = None,
+        glossary_name_suffix: str = "",
+    ) -> ManagedGlossary:
+        pass
 
 
 @pytest.fixture
-def glossary_name(translator, request) -> str:
-    """Returns a suitable glossary name to be used in the test"""
-    # Remove all test glossaries from the server
-    remove_test_glossaries(translator)
+def glossary_manager(translator, glossary_name) -> CreateManagedGlossaryFunc:
+    """
+    Fixture function that may be used to create context-managed test
+    glossaries, named using the current test. May be called multiple times in
+    a test to create multiple glossaries, ideally with a different suffix for
+    each glossary.
+
+    Usage example:
+        def test_example(glossary_manager):
+            with glossary_manager(
+                entries={"a": "b"}, glossary_name_suffix="1"
+            ) as glossary1:
+                ...
+    """
+
+    def create_managed_glossary(
+        source_lang: str = "EN",
+        target_lang: str = "DE",
+        entries: Optional[dict] = None,
+        glossary_name_suffix: str = "",
+    ):
+        if not entries:
+            entries = {"Hello": "Hallo"}
+        return ManagedGlossary(
+            translator,
+            f"{glossary_name}{glossary_name_suffix}",
+            source_lang,
+            target_lang,
+            entries,
+        )
+
+    return create_managed_glossary
+
 
+@pytest.fixture
+def glossary_name(request) -> str:
+    """Returns a suitable glossary name to be used in the test"""
     test_name = request.node.name
-    return f"{glossary_name_prefix}{test_name}"
+    new_uuid = str(uuid.uuid1())
+    return f"deepl-python-test-glossary: {test_name} {new_uuid}"
 
 
 @pytest.fixture
@@ -201,21 +296,6 @@ def output_document_path(tmpdir):
     return path
 
 
-def create_glossary(
-    translator,
-    glossary_name,
-    *,
-    source_lang="EN",
-    target_lang="DE",
-    entries: Optional[dict] = None,
-) -> deepl.GlossaryInfo:
-    if entries is None:
-        entries = {"Hallo": "Hello"}
-    return translator.create_glossary(
-        glossary_name, source_lang, target_lang, entries
-    )
-
-
 # Decorate test functions with "@needs_mock_server" to skip them if a real
 #  server is used
 needs_mock_server = pytest.mark.skipif(

tests/test_cli.py

@@ -188,7 +188,9 @@ def test_glossary_no_subcommand(runner):
     assert "subcommand is required" in result.output
 
 
-def test_glossary_create(runner, glossary_name, tmpdir):
+def test_glossary_create(
+    runner, glossary_name, tmpdir, cleanup_matching_glossaries
+):
     name_cli = f"{glossary_name}-cli"
     name_stdin = f"{glossary_name}-stdin"
     name_file = f"{glossary_name}-file"
@@ -198,85 +200,120 @@ def test_glossary_create(runner, glossary_name, tmpdir):
     file = tmpdir / "glossary_entries"
     file.write(entries_tsv)
 
-    result = runner.invoke(
-        deepl.__main__,
-        f'-vv glossary create --name "{name_cli}" --from DE --to EN '
-        f"{entries_cli}",
-    )
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    result = runner.invoke(
-        deepl.__main__,
-        f'-vv glossary create --name "{name_stdin}" --from DE --to EN -',
-        input=entries_tsv,
-    )
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    result = runner.invoke(
-        deepl.__main__,
-        f'-vv glossary create --name "{name_file}" --from DE --to EN '
-        f"--file {file}",
-    )
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-
-    result = runner.invoke(deepl.__main__, f"-vv glossary list")
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    assert name_cli in result.output
-    assert name_stdin in result.output
-    assert name_file in result.output
-
-    # Cannot use --file option together with entries
-    result = runner.invoke(
-        deepl.__main__,
-        f'-vv glossary create --name "{name_file}" --from DE --to EN '
-        f"--file {file} {entries_cli}",
-    )
-    assert result.exit_code == 1, f"exit: {result.exit_code}\n {result.output}"
-    assert "--file argument" in result.output
-
-
-def test_glossary_get(translator, runner, glossary_name):
-    created_id = create_glossary(translator, glossary_name).glossary_id
-
-    result = runner.invoke(deepl.__main__, f"-vv glossary get {created_id}")
-    print(result.output)
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    assert glossary_name in result.output
-
-
-def test_glossary_list(translator, runner, glossary_name):
-    suffix_list = ["1", "2", "3"]
-    for suffix in suffix_list:
-        create_glossary(translator, glossary_name + suffix)
-
-    result = runner.invoke(deepl.__main__, f"-vv glossary list")
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    for suffix in suffix_list:
-        assert f"{glossary_name}{suffix}" in result.output
-
-
-def test_glossary_entries(translator, runner, glossary_name):
+    try:
+        result = runner.invoke(
+            deepl.__main__,
+            f'-vv glossary create --name "{name_cli}" --from DE --to EN '
+            f"{entries_cli}",
+        )
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        result = runner.invoke(
+            deepl.__main__,
+            f'-vv glossary create --name "{name_stdin}" --from DE --to EN -',
+            input=entries_tsv,
+        )
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        result = runner.invoke(
+            deepl.__main__,
+            f'-vv glossary create --name "{name_file}" --from DE --to EN '
+            f"--file {file}",
+        )
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+
+        result = runner.invoke(deepl.__main__, f"-vv glossary list")
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        assert name_cli in result.output
+        assert name_stdin in result.output
+        assert name_file in result.output
+
+        # Cannot use --file option together with entries
+        result = runner.invoke(
+            deepl.__main__,
+            f'-vv glossary create --name "{name_file}" --from DE --to EN '
+            f"--file {file} {entries_cli}",
+        )
+        assert (
+            result.exit_code == 1
+        ), f"exit: {result.exit_code}\n {result.output}"
+        assert "--file argument" in result.output
+
+    finally:
+        cleanup_matching_glossaries(
+            lambda glossary: glossary.name in [name_file, name_cli, name_stdin]
+        )
+
+
+def test_glossary_get(translator, runner, glossary_manager):
+    with glossary_manager() as created_glossary:
+        created_id = created_glossary.glossary_id
+
+        result = runner.invoke(
+            deepl.__main__, f"-vv glossary get {created_id}"
+        )
+        print(result.output)
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        assert created_id in result.output
+        assert created_glossary.name in result.output
+
+
+def test_glossary_list(translator, runner, glossary_manager):
+    with glossary_manager(glossary_name_suffix="1") as g1, glossary_manager(
+        glossary_name_suffix="2"
+    ) as g2, glossary_manager(glossary_name_suffix="3") as g3:
+        glossary_list = [g1, g2, g3]
+
+        result = runner.invoke(deepl.__main__, f"-vv glossary list")
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        for glossary in glossary_list:
+            assert glossary.name in result.output
+
+
+def test_glossary_entries(translator, runner, glossary_manager):
     entries = {"Hallo": "Hello", "Maler": "Artist"}
-    created_id = create_glossary(
-        translator, glossary_name, entries=entries
-    ).glossary_id
-
-    result = runner.invoke(
-        deepl.__main__, f"-vv glossary entries {created_id}"
-    )
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    for source, target in entries.items():
-        assert f"{source}\t{target}" in result.output
-
-
-def test_glossary_delete(translator, runner, glossary_name):
-    created_id = create_glossary(translator, glossary_name).glossary_id
-    result = runner.invoke(deepl.__main__, f"glossary list")
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    assert created_id in result.output
-
-    # Remove the created glossary
-    result = runner.invoke(deepl.__main__, f'glossary delete "{created_id}"')
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-
-    result = runner.invoke(deepl.__main__, f"glossary list")
-    assert result.exit_code == 0, f"exit: {result.exit_code}\n {result.output}"
-    assert created_id not in result.output
+    with glossary_manager(entries=entries) as created_glossary:
+        created_id = created_glossary.glossary_id
+
+        result = runner.invoke(
+            deepl.__main__, f"-vv glossary entries {created_id}"
+        )
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        for source, target in entries.items():
+            assert f"{source}\t{target}" in result.output
+
+
+def test_glossary_delete(translator, runner, glossary_manager):
+    with glossary_manager() as created_glossary:
+        created_id = created_glossary.glossary_id
+        result = runner.invoke(deepl.__main__, f"glossary list")
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        assert created_id in result.output
+
+        # Remove the created glossary
+        result = runner.invoke(
+            deepl.__main__, f'glossary delete "{created_id}"'
+        )
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+
+        result = runner.invoke(deepl.__main__, f"glossary list")
+        assert (
+            result.exit_code == 0
+        ), f"exit: {result.exit_code}\n {result.output}"
+        assert created_id not in result.output