arkindex-base-worker 0.5.0a2__py3-none-any.whl → 0.5.0b1__py3-none-any.whl

tests/test_elements_worker/test_entity_list_and_check.py

@@ -1,6 +1,7 @@
 import pytest
 from responses import matchers
 
+from arkindex.exceptions import ErrorResponse
 from arkindex_worker.models import Transcription
 from arkindex_worker.worker.entity import MissingEntityType
 from tests import CORPUS_ID
@@ -8,67 +9,158 @@ from tests import CORPUS_ID
 from . import BASE_API_CALLS
 
 
-def test_check_required_entity_types(responses, mock_elements_worker):
-    # Set one entity type
-    mock_elements_worker.entity_types = {"person": "person-entity-type-id"}
+def test_create_entity_type_wrong_name(mock_elements_worker):
+    with pytest.raises(
+        AssertionError, match="name shouldn't be null and should be of type str"
+    ):
+        mock_elements_worker.create_entity_type(name=None)
 
-    checked_types = ["person", "new-entity"]
+    with pytest.raises(
+        AssertionError, match="name shouldn't be null and should be of type str"
+    ):
+        mock_elements_worker.create_entity_type(name=1234)
 
-    # Call to create new entity type
+
+def test_create_entity_type_api_error(responses, mock_elements_worker):
     responses.add(
         responses.POST,
         "http://testserver/api/v1/entity/types/",
-        status=200,
+        status=418,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_entity_type(name="firstname")
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [("POST", "http://testserver/api/v1/entity/types/")]
+
+
+def test_create_entity_type_already_exists(responses, mock_elements_worker):
+    assert mock_elements_worker.entity_types == {}
+
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/entity/types/",
+        status=400,
         match=[
-            matchers.json_params_matcher(
-                {
-                    "name": "new-entity",
-                    "corpus": CORPUS_ID,
-                }
-            )
+            matchers.json_params_matcher({"name": "firstname", "corpus": CORPUS_ID})
         ],
+    )
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/corpus/{CORPUS_ID}/entity-types/",
+        status=200,
         json={
-            "id": "new-entity-id",
-            "corpus": CORPUS_ID,
-            "name": "new-entity",
-            "color": "ffd1b3",
+            "count": 1,
+            "next": None,
+            "results": [
+                {"id": "lastname-id", "name": "lastname", "color": "ffd1b3"},
+                {"id": "firstname-id", "name": "firstname", "color": "ffd1b3"},
+            ],
         },
     )
 
-    mock_elements_worker.check_required_entity_types(
-        entity_types=checked_types,
-    )
+    mock_elements_worker.create_entity_type(name="firstname")
 
-    # Make sure the entity_types entry has been updated
+    assert len(responses.calls) == len(BASE_API_CALLS) + 2
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        ("POST", "http://testserver/api/v1/entity/types/"),
+        ("GET", f"http://testserver/api/v1/corpus/{CORPUS_ID}/entity-types/"),
+    ]
+
+    # Make sure the entity_types attribute has been updated
     assert mock_elements_worker.entity_types == {
-        "person": "person-entity-type-id",
-        "new-entity": "new-entity-id",
+        "lastname": "lastname-id",
+        "firstname": "firstname-id",
     }
 
+
+def test_create_entity_type(responses, mock_elements_worker):
+    assert mock_elements_worker.entity_types == {}
+
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/entity/types/",
+        status=200,
+        match=[
+            matchers.json_params_matcher({"name": "firstname", "corpus": CORPUS_ID})
+        ],
+        json={
+            "id": "firstname-id",
+            "name": "firstname",
+            "corpus": CORPUS_ID,
+            "color": "ffd1b3",
+        },
+    )
+
+    mock_elements_worker.create_entity_type(name="firstname")
+
     assert len(responses.calls) == len(BASE_API_CALLS) + 1
     assert [
         (call.request.method, call.request.url) for call in responses.calls
     ] == BASE_API_CALLS + [
-        (
-            "POST",
-            "http://testserver/api/v1/entity/types/",
-        ),
+        ("POST", "http://testserver/api/v1/entity/types/"),
     ]
 
+    # Make sure the entity_types attribute has been updated
+    assert mock_elements_worker.entity_types == {"firstname": "firstname-id"}
 
-def test_check_required_entity_types_no_creation_allowed(
+
+def test_check_required_entity_types_wrong_entity_types(mock_elements_worker):
+    with pytest.raises(
+        AssertionError,
+        match="entity_types shouldn't be null and should be of type list",
+    ):
+        mock_elements_worker.check_required_entity_types(entity_types=None)
+
+    with pytest.raises(
+        AssertionError,
+        match="entity_types shouldn't be null and should be of type list",
+    ):
+        mock_elements_worker.check_required_entity_types(entity_types=1234)
+
+    with pytest.raises(
+        AssertionError,
+        match="Entity type at index 1 in entity_types: Should be of type str",
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["firstname", 1234]
+        )
+
+
+def test_check_required_entity_types_wrong_create_missing(mock_elements_worker):
+    with pytest.raises(
+        AssertionError,
+        match="create_missing shouldn't be null and should be of type bool",
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["firstname"], create_missing=None
+        )
+
+    with pytest.raises(
+        AssertionError,
+        match="create_missing shouldn't be null and should be of type bool",
+    ):
+        mock_elements_worker.check_required_entity_types(
+            entity_types=["firstname"], create_missing=1234
+        )
+
+
+def test_check_required_entity_types_do_not_create_missing(
     responses, mock_elements_worker
 ):
     # Set one entity type
-    mock_elements_worker.entity_types = {"person": "person-entity-type-id"}
-
-    checked_types = ["person", "new-entity"]
+    mock_elements_worker.entity_types = {"lastname": "lastname-id"}
 
     with pytest.raises(
-        MissingEntityType, match="Entity type `new-entity` was not in the corpus."
+        MissingEntityType, match="Entity type `firstname` was not in the corpus."
     ):
         mock_elements_worker.check_required_entity_types(
-            entity_types=checked_types, create_missing=False
+            entity_types=["lastname", "firstname"], create_missing=False
         )
 
     assert len(responses.calls) == len(BASE_API_CALLS)
@@ -77,6 +169,47 @@ def test_check_required_entity_types_no_creation_allowed(
     ] == BASE_API_CALLS
 
 
+def test_check_required_entity_types(responses, mock_elements_worker):
+    # Set one entity type
+    mock_elements_worker.entity_types = {"lastname": "lastname-id"}
+
+    # Call to create a new entity type
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/entity/types/",
+        status=200,
+        match=[
+            matchers.json_params_matcher({"name": "firstname", "corpus": CORPUS_ID})
+        ],
+        json={
+            "id": "firstname-id",
+            "name": "firstname",
+            "corpus": CORPUS_ID,
+            "color": "ffd1b3",
+        },
+    )
+
+    mock_elements_worker.check_required_entity_types(
+        entity_types=["lastname", "firstname"], create_missing=True
+    )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        (
+            "POST",
+            "http://testserver/api/v1/entity/types/",
+        ),
+    ]
+
+    # Make sure the entity_types attribute has been updated
+    assert mock_elements_worker.entity_types == {
+        "lastname": "lastname-id",
+        "firstname": "firstname-id",
+    }
+
+
 def test_list_transcription_entities_deprecation(fake_dummy_worker):
     transcription = Transcription({"id": "fake_transcription_id"})
     worker_version = "worker_version_id"

tests/test_image.py

@@ -234,7 +234,7 @@ def test_open_image_rotate_mirror(rotation_angle, mirrored, expected_path):
 @pytest.mark.parametrize(
     ("polygon", "error"),
     [
-        # Polygon input isn't a list or tuple
+        # Polygon isn't a list or tuple
         (
             {
                 "polygon": [
@@ -252,7 +252,15 @@ def test_open_image_rotate_mirror(rotation_angle, mirrored, expected_path):
                     [99, 208],
                 ]
             },
-            "Input polygon must be a valid list or tuple of points.",
+            "Polygon must be a valid list or tuple of points.",
+        ),
+        # Polygon hasn't enough points
+        (
+            [
+                [99, 200],
+                [25, 224],
+            ],
+            "Polygon should have at least three points.",
         ),
         # Point coordinates are not integers
         (

arkindex_worker/worker/version.py

@@ -1,58 +0,0 @@
-"""
-ElementsWorker methods for worker versions.
-"""
-
-import functools
-from warnings import warn
-
-
-def worker_version_deprecation(func):
-    @functools.wraps(func)
-    def wrapper(self, *args, **kwargs):
-        warn("WorkerVersion usage is deprecated.", DeprecationWarning, stacklevel=2)
-        return func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class WorkerVersionMixin:
-    @worker_version_deprecation
-    def get_worker_version(self, worker_version_id: str) -> dict:
-        """
-        Warns:
-        ----
-        This method is **deprecated**.
-
-        Retrieve a worker version, using the [ElementsWorker][arkindex_worker.worker.ElementsWorker]'s internal cache when possible.
-
-        :param worker_version_id: ID of the worker version to retrieve.
-        :returns: The requested worker version, as returned by the ``RetrieveWorkerVersion`` API endpoint.
-        """
-        if worker_version_id is None:
-            raise ValueError("No worker version ID")
-
-        if worker_version_id in self._worker_version_cache:
-            return self._worker_version_cache[worker_version_id]
-
-        worker_version = self.api_client.request(
-            "RetrieveWorkerVersion", id=worker_version_id
-        )
-        self._worker_version_cache[worker_version_id] = worker_version
-
-        return worker_version
-
-    @worker_version_deprecation
-    def get_worker_version_slug(self, worker_version_id: str) -> str:
-        """
-        Warns:
-        ----
-        This method is **deprecated**.
-
-        Retrieve the slug of the worker of a worker version, from a worker version UUID.
-        Uses a worker version from the internal cache if possible, otherwise makes an API request.
-
-        :param worker_version_id: ID of the worker version to find a slug for.
-        :returns: Slug of the worker of this worker version.
-        """
-        worker_version = self.get_worker_version(worker_version_id)
-        return worker_version["worker"]["slug"]

tests/test_elements_worker/test_version.py

@@ -1,60 +0,0 @@
-import pytest
-
-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)
-
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        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)
-
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        response_1 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
-
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        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_worker_version_slug(mocker, fake_dummy_worker):
-    fake_dummy_worker.get_worker_version = mocker.MagicMock()
-    fake_dummy_worker.get_worker_version.return_value = {
-        "id": TEST_VERSION_ID,
-        "worker": {"slug": "mock_slug"},
-    }
-
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        slug = fake_dummy_worker.get_worker_version_slug(TEST_VERSION_ID)
-    assert slug == "mock_slug"
-
-
-def test_get_worker_version_slug_none(fake_dummy_worker):
-    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
-    with (
-        pytest.deprecated_call(match="WorkerVersion usage is deprecated."),
-        pytest.raises(ValueError, match="No worker version ID"),
-    ):
-        fake_dummy_worker.get_worker_version_slug(None)