arkindex_worker/worker.py

@@ -394,6 +394,65 @@ class ElementsWorker(BaseWorker):
 
         return sub_element["id"]
 
+    def create_elements(self, parent, elements):
+        """
+        Create children elements on the given element through API
+        Return the IDs of created elements
+        """
+        assert parent and isinstance(
+            parent, Element
+        ), "element shouldn't be null and should be of type Element"
+        assert elements and isinstance(
+            elements, list
+        ), "elements shouldn't be null and should be of type list"
+
+        for index, element in enumerate(elements):
+            assert isinstance(
+                element, dict
+            ), f"Element at index {index} in elements: Should be of type dict"
+
+            name = element.get("name")
+            assert name and isinstance(
+                name, str
+            ), f"Element at index {index} in elements: name shouldn't be null and should be of type str"
+
+            type = element.get("type")
+            assert type and isinstance(
+                type, str
+            ), f"Element at index {index} in elements: type shouldn't be null and should be of type str"
+
+            polygon = element.get("polygon")
+            assert polygon and isinstance(
+                polygon, list
+            ), f"Element at index {index} in elements: polygon shouldn't be null and should be of type list"
+            assert (
+                len(polygon) >= 3
+            ), f"Element at index {index} in elements: polygon should have at least three points"
+            assert all(
+                isinstance(point, list) and len(point) == 2 for point in polygon
+            ), f"Element at index {index} in elements: polygon points should be lists of two items"
+            assert all(
+                isinstance(coord, (int, float)) for point in polygon for coord in point
+            ), f"Element at index {index} in elements: polygon points should be lists of two numbers"
+
+        if self.is_read_only:
+            logger.warning("Cannot create elements as this worker is in read-only mode")
+            return
+
+        created_ids = self.api_client.request(
+            "CreateElements",
+            id=parent.id,
+            body={
+                "worker_version": self.worker_version_id,
+                "elements": elements,
+            },
+        )
+
+        for element in elements:
+            self.report.add_element(parent.id, element["type"])
+
+        return created_ids
+
     def create_transcription(self, element, text, type=None, score=None):
         """
         Create a transcription on the given element through the API.

tests/conftest.py

@@ -30,7 +30,9 @@ def cache_yaml(monkeypatch):
         # Create a unique cache key for direct YAML strings
         # and file descriptors
         if isinstance(yaml_payload, str):
-            key = hashlib.md5(yaml_payload.encode("utf-8")).hexdigest()
+            yaml_payload = yaml_payload.encode("utf-8")
+        if isinstance(yaml_payload, bytes):
+            key = hashlib.md5(yaml_payload).hexdigest()
         else:
             key = yaml_payload.name
 

tests/test_elements_worker/test_classifications.py

+# -*- coding: utf-8 -*-
+import json
+
+import pytest
+from apistar.exceptions import ErrorResponse
+
+from arkindex_worker.models import Element
+
+
+def test_get_ml_class_id_load_classes(responses, mock_elements_worker):
+    corpus_id = "12341234-1234-1234-1234-123412341234"
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/corpus/{corpus_id}/classes/",
+        status=200,
+        json={
+            "count": 1,
+            "next": None,
+            "results": [
+                {
+                    "id": "0000",
+                    "name": "good",
+                    "nb_best": 0,
+                }
+            ],
+        },
+    )
+
+    assert not mock_elements_worker.classes
+    ml_class_id = mock_elements_worker.get_ml_class_id(corpus_id, "good")
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        f"http://testserver/api/v1/corpus/{corpus_id}/classes/",
+    ]
+    assert mock_elements_worker.classes == {
+        "12341234-1234-1234-1234-123412341234": {"good": "0000"}
+    }
+    assert ml_class_id == "0000"
+
+
+def test_get_ml_class_id_inexistant_class(mock_elements_worker, responses):
+    # A missing class is now created automatically
+    corpus_id = "12341234-1234-1234-1234-123412341234"
+    mock_elements_worker.classes = {
+        "12341234-1234-1234-1234-123412341234": {"good": "0000"}
+    }
+
+    responses.add(
+        responses.POST,
+        f"http://testserver/api/v1/corpus/{corpus_id}/classes/",
+        status=201,
+        json={"id": "new-ml-class-1234"},
+    )
+
+    # Missing class at first
+    assert mock_elements_worker.classes == {
+        "12341234-1234-1234-1234-123412341234": {"good": "0000"}
+    }
+
+    ml_class_id = mock_elements_worker.get_ml_class_id(corpus_id, "bad")
+    assert ml_class_id == "new-ml-class-1234"
+
+    # Now it's available
+    assert mock_elements_worker.classes == {
+        "12341234-1234-1234-1234-123412341234": {
+            "good": "0000",
+            "bad": "new-ml-class-1234",
+        }
+    }
+
+
+def test_get_ml_class_id(mock_elements_worker):
+    corpus_id = "12341234-1234-1234-1234-123412341234"
+    mock_elements_worker.classes = {
+        "12341234-1234-1234-1234-123412341234": {"good": "0000"}
+    }
+
+    ml_class_id = mock_elements_worker.get_ml_class_id(corpus_id, "good")
+    assert ml_class_id == "0000"
+
+
+def test_get_ml_class_reload(responses, mock_elements_worker):
+    corpus_id = "12341234-1234-1234-1234-123412341234"
+
+    # Add some initial classes
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/corpus/{corpus_id}/classes/",
+        json={
+            "count": 1,
+            "next": None,
+            "results": [
+                {
+                    "id": "class1_id",
+                    "name": "class1",
+                }
+            ],
+        },
+    )
+
+    # Invalid response when trying to create class2
+    responses.add(
+        responses.POST,
+        f"http://testserver/api/v1/corpus/{corpus_id}/classes/",
+        status=400,
+        json={"non_field_errors": "Already exists"},
+    )
+
+    # Add both classes (class2 is created by another process)
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/corpus/{corpus_id}/classes/",
+        json={
+            "count": 2,
+            "next": None,
+            "results": [
+                {
+                    "id": "class1_id",
+                    "name": "class1",
+                },
+                {
+                    "id": "class2_id",
+                    "name": "class2",
+                },
+            ],
+        },
+    )
+
+    # Simply request class 2, it should be reloaded
+    assert mock_elements_worker.get_ml_class_id(corpus_id, "class2") == "class2_id"
+
+    assert len(responses.calls) == 5
+    assert mock_elements_worker.classes == {
+        corpus_id: {
+            "class1": "class1_id",
+            "class2": "class2_id",
+        }
+    }
+    assert [(call.request.method, call.request.url) for call in responses.calls] == [
+        ("GET", "http://testserver/api/v1/user/"),
+        (
+            "GET",
+            "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        ),
+        ("GET", f"http://testserver/api/v1/corpus/{corpus_id}/classes/"),
+        ("POST", f"http://testserver/api/v1/corpus/{corpus_id}/classes/"),
+        ("GET", f"http://testserver/api/v1/corpus/{corpus_id}/classes/"),
+    ]
+
+
+def test_create_classification_wrong_element(mock_elements_worker):
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=None,
+            ml_class="a_class",
+            confidence=0.42,
+            high_confidence=True,
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element="not element type",
+            ml_class="a_class",
+            confidence=0.42,
+            high_confidence=True,
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+
+def test_create_classification_wrong_ml_class(mock_elements_worker, responses):
+    elt = Element(
+        {
+            "id": "12341234-1234-1234-1234-123412341234",
+            "corpus": {"id": "11111111-1111-1111-1111-111111111111"},
+        }
+    )
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class=None,
+            confidence=0.42,
+            high_confidence=True,
+        )
+    assert str(e.value) == "ml_class shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class=1234,
+            confidence=0.42,
+            high_confidence=True,
+        )
+    assert str(e.value) == "ml_class shouldn't be null and should be of type str"
+
+    # Automatically create a missing class !
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/corpus/11111111-1111-1111-1111-111111111111/classes/",
+        status=201,
+        json={"id": "new-ml-class-1234"},
+    )
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/classifications/",
+        status=201,
+        json={"id": "new-classification-1234"},
+    )
+    mock_elements_worker.classes = {
+        "11111111-1111-1111-1111-111111111111": {"another_class": "0000"}
+    }
+    mock_elements_worker.create_classification(
+        element=elt,
+        ml_class="a_class",
+        confidence=0.42,
+        high_confidence=True,
+    )
+
+    # Check a class & classification has been created
+    for call in responses.calls:
+        print(call.request.url, call.request.body)
+
+    assert [
+        (call.request.url, json.loads(call.request.body))
+        for call in responses.calls[-2:]
+    ] == [
+        (
+            "http://testserver/api/v1/corpus/11111111-1111-1111-1111-111111111111/classes/",
+            {"name": "a_class"},
+        ),
+        (
+            "http://testserver/api/v1/classifications/",
+            {
+                "element": "12341234-1234-1234-1234-123412341234",
+                "ml_class": "new-ml-class-1234",
+                "worker_version": "12341234-1234-1234-1234-123412341234",
+                "confidence": 0.42,
+                "high_confidence": True,
+            },
+        ),
+    ]
+
+
+def test_create_classification_wrong_confidence(mock_elements_worker):
+    mock_elements_worker.classes = {
+        "11111111-1111-1111-1111-111111111111": {"a_class": "0000"}
+    }
+    elt = Element(
+        {
+            "id": "12341234-1234-1234-1234-123412341234",
+            "corpus": {"id": "11111111-1111-1111-1111-111111111111"},
+        }
+    )
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence=None,
+            high_confidence=True,
+        )
+    assert (
+        str(e.value)
+        == "confidence shouldn't be null and should be a float in [0..1] range"
+    )
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence="wrong confidence",
+            high_confidence=True,
+        )
+    assert (
+        str(e.value)
+        == "confidence shouldn't be null and should be a float in [0..1] range"
+    )
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence=0,
+            high_confidence=True,
+        )
+    assert (
+        str(e.value)
+        == "confidence shouldn't be null and should be a float in [0..1] range"
+    )
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence=2.00,
+            high_confidence=True,
+        )
+    assert (
+        str(e.value)
+        == "confidence shouldn't be null and should be a float in [0..1] range"
+    )
+
+
+def test_create_classification_wrong_high_confidence(mock_elements_worker):
+    mock_elements_worker.classes = {
+        "11111111-1111-1111-1111-111111111111": {"a_class": "0000"}
+    }
+    elt = Element(
+        {
+            "id": "12341234-1234-1234-1234-123412341234",
+            "corpus": {"id": "11111111-1111-1111-1111-111111111111"},
+        }
+    )
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence=0.42,
+            high_confidence=None,
+        )
+    assert (
+        str(e.value) == "high_confidence shouldn't be null and should be of type bool"
+    )
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence=0.42,
+            high_confidence="wrong high_confidence",
+        )
+    assert (
+        str(e.value) == "high_confidence shouldn't be null and should be of type bool"
+    )
+
+
+def test_create_classification_api_error(responses, mock_elements_worker):
+    mock_elements_worker.classes = {
+        "11111111-1111-1111-1111-111111111111": {"a_class": "0000"}
+    }
+    elt = Element(
+        {
+            "id": "12341234-1234-1234-1234-123412341234",
+            "corpus": {"id": "11111111-1111-1111-1111-111111111111"},
+        }
+    )
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/classifications/",
+        status=500,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_classification(
+            element=elt,
+            ml_class="a_class",
+            confidence=0.42,
+            high_confidence=True,
+        )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/classifications/",
+    ]
+
+
+def test_create_classification(responses, mock_elements_worker):
+    mock_elements_worker.classes = {
+        "11111111-1111-1111-1111-111111111111": {"a_class": "0000"}
+    }
+    elt = Element(
+        {
+            "id": "12341234-1234-1234-1234-123412341234",
+            "corpus": {"id": "11111111-1111-1111-1111-111111111111"},
+        }
+    )
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/classifications/",
+        status=200,
+    )
+
+    mock_elements_worker.create_classification(
+        element=elt,
+        ml_class="a_class",
+        confidence=0.42,
+        high_confidence=True,
+    )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/classifications/",
+    ]
+
+    assert json.loads(responses.calls[2].request.body) == {
+        "element": "12341234-1234-1234-1234-123412341234",
+        "ml_class": "0000",
+        "worker_version": "12341234-1234-1234-1234-123412341234",
+        "confidence": 0.42,
+        "high_confidence": True,
+    }
+
+    # Classification has been created and reported
+    assert mock_elements_worker.report.report_data["elements"][elt.id][
+        "classifications"
+    ] == {"a_class": 1}
+
+
+def test_create_classification_duplicate(responses, mock_elements_worker):
+    mock_elements_worker.classes = {
+        "11111111-1111-1111-1111-111111111111": {"a_class": "0000"}
+    }
+    elt = Element(
+        {
+            "id": "12341234-1234-1234-1234-123412341234",
+            "corpus": {"id": "11111111-1111-1111-1111-111111111111"},
+        }
+    )
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/classifications/",
+        status=400,
+        json={
+            "non_field_errors": [
+                "The fields element, worker_version, ml_class must make a unique set."
+            ]
+        },
+    )
+
+    mock_elements_worker.create_classification(
+        element=elt,
+        ml_class="a_class",
+        confidence=0.42,
+        high_confidence=True,
+    )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/classifications/",
+    ]
+
+    assert json.loads(responses.calls[2].request.body) == {
+        "element": "12341234-1234-1234-1234-123412341234",
+        "ml_class": "0000",
+        "worker_version": "12341234-1234-1234-1234-123412341234",
+        "confidence": 0.42,
+        "high_confidence": True,
+    }
+
+    # Classification has NOT been created
+    assert mock_elements_worker.report.report_data["elements"] == {}

tests/test_elements_worker/test_cli.py

+# -*- coding: utf-8 -*-
+import json
+import os
+import sys
+import tempfile
+from uuid import UUID
+
+import pytest
+
+from arkindex_worker.worker import ElementsWorker
+
+
+def test_cli_default(monkeypatch, mock_worker_version_api):
+    _, path = tempfile.mkstemp()
+    with open(path, "w") as f:
+        json.dump(
+            [
+                {"id": "volumeid", "type": "volume"},
+                {"id": "pageid", "type": "page"},
+                {"id": "actid", "type": "act"},
+                {"id": "surfaceid", "type": "surface"},
+            ],
+            f,
+        )
+
+    monkeypatch.setenv("TASK_ELEMENTS", path)
+    monkeypatch.setattr(sys, "argv", ["worker"])
+    worker = ElementsWorker()
+    worker.configure()
+
+    assert worker.args.elements_list.name == path
+    assert not worker.args.element
+    os.unlink(path)
+
+
+def test_cli_arg_elements_list_given(mocker, mock_worker_version_api):
+    _, path = tempfile.mkstemp()
+    with open(path, "w") as f:
+        json.dump(
+            [
+                {"id": "volumeid", "type": "volume"},
+                {"id": "pageid", "type": "page"},
+                {"id": "actid", "type": "act"},
+                {"id": "surfaceid", "type": "surface"},
+            ],
+            f,
+        )
+
+    mocker.patch.object(sys, "argv", ["worker", "--elements-list", path])
+    worker = ElementsWorker()
+    worker.configure()
+
+    assert worker.args.elements_list.name == path
+    assert not worker.args.element
+    os.unlink(path)
+
+
+def test_cli_arg_element_one_given_not_uuid(mocker, mock_elements_worker):
+    mocker.patch.object(sys, "argv", ["worker", "--element", "1234"])
+    worker = ElementsWorker()
+    with pytest.raises(SystemExit):
+        worker.configure()
+
+
+def test_cli_arg_element_one_given(mocker, mock_elements_worker):
+    mocker.patch.object(
+        sys, "argv", ["worker", "--element", "12341234-1234-1234-1234-123412341234"]
+    )
+    worker = ElementsWorker()
+    worker.configure()
+
+    assert worker.args.element == [UUID("12341234-1234-1234-1234-123412341234")]
+    # elements_list is None because TASK_ELEMENTS environment variable isn't set
+    assert not worker.args.elements_list
+
+
+def test_cli_arg_element_many_given(mocker, mock_elements_worker):
+    mocker.patch.object(
+        sys,
+        "argv",
+        [
+            "worker",
+            "--element",
+            "12341234-1234-1234-1234-123412341234",
+            "43214321-4321-4321-4321-432143214321",
+        ],
+    )
+    worker = ElementsWorker()
+    worker.configure()
+
+    assert worker.args.element == [
+        UUID("12341234-1234-1234-1234-123412341234"),
+        UUID("43214321-4321-4321-4321-432143214321"),
+    ]
+    # elements_list is None because TASK_ELEMENTS environment variable isn't set
+    assert not worker.args.elements_list

tests/test_elements_worker/test_entities.py

+# -*- coding: utf-8 -*-
+import json
+
+import pytest
+from apistar.exceptions import ErrorResponse
+
+from arkindex_worker.models import Element
+from arkindex_worker.worker import EntityType
+
+
+def test_create_entity_wrong_element(mock_elements_worker):
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=None,
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element="not element type",
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+
+def test_create_entity_wrong_name(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name=None,
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "name shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name=1234,
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "name shouldn't be null and should be of type str"
+
+
+def test_create_entity_wrong_type(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=None,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type EntityType"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=1234,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type EntityType"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type="not_an_entity_type",
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type EntityType"
+
+
+def test_create_entity_wrong_corpus(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus=None,
+        )
+    assert str(e.value) == "corpus shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus=1234,
+        )
+    assert str(e.value) == "corpus shouldn't be null and should be of type str"
+
+
+def test_create_entity_wrong_metas(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+            metas="wrong metas",
+        )
+    assert str(e.value) == "metas should be of type dict"
+
+
+def test_create_entity_wrong_validated(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+            validated="wrong validated",
+        )
+    assert str(e.value) == "validated should be of type bool"
+
+
+def test_create_entity_api_error(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/entity/",
+        status=500,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_entity(
+            element=elt,
+            name="Bob Bob",
+            type=EntityType.Person,
+            corpus="12341234-1234-1234-1234-123412341234",
+        )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/entity/",
+    ]
+
+
+def test_create_entity(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/entity/",
+        status=200,
+        json={"id": "12345678-1234-1234-1234-123456789123"},
+    )
+
+    entity_id = mock_elements_worker.create_entity(
+        element=elt,
+        name="Bob Bob",
+        type=EntityType.Person,
+        corpus="12341234-1234-1234-1234-123412341234",
+    )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/entity/",
+    ]
+    assert json.loads(responses.calls[2].request.body) == {
+        "name": "Bob Bob",
+        "type": "person",
+        "metas": None,
+        "validated": None,
+        "corpus": "12341234-1234-1234-1234-123412341234",
+        "worker_version": "12341234-1234-1234-1234-123412341234",
+    }
+    assert entity_id == "12345678-1234-1234-1234-123456789123"

tests/test_elements_worker/test_metadata.py

+# -*- coding: utf-8 -*-
+import json
+
+import pytest
+from apistar.exceptions import ErrorResponse
+
+from arkindex_worker.models import Element
+from arkindex_worker.worker import MetaType
+
+
+def test_create_metadata_wrong_element(mock_elements_worker):
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=None,
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element="not element type",
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "element shouldn't be null and should be of type Element"
+
+
+def test_create_metadata_wrong_type(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=None,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type MetaType"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=1234,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type MetaType"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type="not_a_metadata_type",
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "type shouldn't be null and should be of type MetaType"
+
+
+def test_create_metadata_wrong_name(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name=None,
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "name shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name=1234,
+            value="La Turbine, Grenoble 38000",
+        )
+    assert str(e.value) == "name shouldn't be null and should be of type str"
+
+
+def test_create_metadata_wrong_value(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value=None,
+        )
+    assert str(e.value) == "value shouldn't be null and should be of type str"
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value=1234,
+        )
+    assert str(e.value) == "value shouldn't be null and should be of type str"
+
+
+def test_create_metadata_wrong_entity(mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    with pytest.raises(AssertionError) as e:
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+            entity=1234,
+        )
+    assert str(e.value) == "entity should be of type str"
+
+
+def test_create_metadata_api_error(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+        status=500,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_metadata(
+            element=elt,
+            type=MetaType.Location,
+            name="Teklia",
+            value="La Turbine, Grenoble 38000",
+        )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+    ]
+
+
+def test_create_metadata(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+        status=200,
+        json={"id": "12345678-1234-1234-1234-123456789123"},
+    )
+
+    metadata_id = mock_elements_worker.create_metadata(
+        element=elt,
+        type=MetaType.Location,
+        name="Teklia",
+        value="La Turbine, Grenoble 38000",
+    )
+
+    assert len(responses.calls) == 3
+    assert [call.request.url for call in responses.calls] == [
+        "http://testserver/api/v1/user/",
+        "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/metadata/",
+    ]
+    assert json.loads(responses.calls[2].request.body) == {
+        "type": "location",
+        "name": "Teklia",
+        "value": "La Turbine, Grenoble 38000",
+        "entity": None,
+        "worker_version": "12341234-1234-1234-1234-123412341234",
+    }
+    assert metadata_id == "12345678-1234-1234-1234-123456789123"

tests/test_worker_activity.py → tests/test_elements_worker/test_worker.py

@@ -4,7 +4,8 @@ import json
 import pytest
 from apistar.exceptions import ErrorResponse
 
-from arkindex_worker.worker import ActivityState, Element
+from arkindex_worker.models import Element
+from arkindex_worker.worker import MANUAL_SLUG, ActivityState
 
 # Common API calls for all workers
 BASE_API_CALLS = [
@@ -12,6 +13,145 @@ BASE_API_CALLS = [
     "http://testserver/api/v1/workers/versions/12341234-1234-1234-1234-123412341234/",
 ]
 
+TEST_VERSION_ID = "test_123"
+TEST_SLUG = "some_slug"
+
+
+def test_get_worker_version(fake_dummy_worker):
+    api_client = fake_dummy_worker.api_client
+
+    response = {"worker": {"slug": TEST_SLUG}}
+
+    api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
+
+    res = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+
+    assert res == response
+    assert fake_dummy_worker._worker_version_cache[TEST_VERSION_ID] == response
+
+
+def test_get_worker_version__uses_cache(fake_dummy_worker):
+    api_client = fake_dummy_worker.api_client
+
+    response = {"worker": {"slug": TEST_SLUG}}
+
+    api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
+
+    response_1 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+    response_2 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+
+    assert response_1 == response
+    assert response_1 == response_2
+
+    # assert that only one call to the API
+    assert len(api_client.history) == 1
+    assert not api_client.responses
+
+
+def test_get_slug__old_style(fake_dummy_worker):
+    element = {"source": {"slug": TEST_SLUG}}
+
+    slug = fake_dummy_worker.get_ml_result_slug(element)
+
+    assert slug == TEST_SLUG
+
+
+def test_get_slug__worker_version(fake_dummy_worker):
+    api_client = fake_dummy_worker.api_client
+
+    response = {"worker": {"slug": TEST_SLUG}}
+
+    api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
+
+    element = {"worker_version": TEST_VERSION_ID}
+
+    slug = fake_dummy_worker.get_ml_result_slug(element)
+
+    assert slug == TEST_SLUG
+
+    # assert that only one call to the API
+    assert len(api_client.history) == 1
+    assert not api_client.responses
+
+
+def test_get_slug__both(fake_page_element, fake_ufcn_worker_version, fake_dummy_worker):
+    api_client = fake_dummy_worker.api_client
+
+    api_client.add_response(
+        "RetrieveWorkerVersion",
+        fake_ufcn_worker_version,
+        id=fake_ufcn_worker_version["id"],
+    )
+
+    expected_slugs = [
+        "scikit_portrait_outlier_balsac",
+        "scikit_portrait_outlier_balsac",
+        "ufcn_line_historical",
+    ]
+
+    slugs = [
+        fake_dummy_worker.get_ml_result_slug(clf)
+        for clf in fake_page_element["classifications"]
+    ]
+
+    assert slugs == expected_slugs
+    assert len(api_client.history) == 1
+    assert not api_client.responses
+
+
+def test_get_slug__transcriptions(fake_transcriptions_small, fake_dummy_worker):
+    api_client = fake_dummy_worker.api_client
+
+    version_id = "3ca4a8e3-91d1-4b78-8d83-d8bbbf487996"
+    response = {"worker": {"slug": TEST_SLUG}}
+
+    api_client.add_response("RetrieveWorkerVersion", response, id=version_id)
+
+    slug = fake_dummy_worker.get_ml_result_slug(fake_transcriptions_small["results"][0])
+
+    assert slug == TEST_SLUG
+    assert len(api_client.history) == 1
+    assert not api_client.responses
+
+
+@pytest.mark.parametrize(
+    "ml_result, expected_slug",
+    (
+        # old
+        ({"source": {"slug": "test_123"}}, "test_123"),
+        ({"source": {"slug": "test_123"}, "worker_version": None}, "test_123"),
+        ({"source": {"slug": "test_123"}, "worker_version_id": None}, "test_123"),
+        # new
+        ({"source": None, "worker_version": "foo_1"}, "mock_slug"),
+        ({"source": None, "worker_version_id": "foo_1"}, "mock_slug"),
+        ({"worker_version_id": "foo_1"}, "mock_slug"),
+        # manual
+        ({"worker_version_id": None}, MANUAL_SLUG),
+        ({"worker_version": None}, MANUAL_SLUG),
+        ({"source": None, "worker_version": None}, MANUAL_SLUG),
+    ),
+)
+def test_get_ml_result_slug__ok(mocker, fake_dummy_worker, ml_result, expected_slug):
+    fake_dummy_worker.get_worker_version_slug = mocker.MagicMock()
+    fake_dummy_worker.get_worker_version_slug.return_value = "mock_slug"
+
+    slug = fake_dummy_worker.get_ml_result_slug(ml_result)
+    assert slug == expected_slug
+
+
+@pytest.mark.parametrize(
+    "ml_result",
+    (
+        ({},),
+        ({"source": None},),
+        ({"source": {"slug": None}},),
+    ),
+)
+def test_get_ml_result_slug__fail(fake_dummy_worker, ml_result):
+    with pytest.raises(ValueError) as excinfo:
+        fake_dummy_worker.get_ml_result_slug(ml_result)
+        assert str(excinfo.value).startswith("Unable to get slug from")
+
 
 def test_defaults(responses, mock_elements_worker):
     """Test the default values from mocked calls"""