arkindex-base-worker 0.3.6rc4__py3-none-any.whl → 0.3.7__py3-none-any.whl

tests/test_elements_worker/test_elements.py

@@ -428,19 +428,7 @@ def test_create_sub_element_wrong_name(mock_elements_worker):
 def test_create_sub_element_wrong_polygon(mock_elements_worker):
     elt = Element({"zone": None})
 
-    with pytest.raises(
-        AssertionError, match="polygon shouldn't be null and should be of type list"
-    ):
-        mock_elements_worker.create_sub_element(
-            element=elt,
-            type="something",
-            name="0",
-            polygon=None,
-        )
-
-    with pytest.raises(
-        AssertionError, match="polygon shouldn't be null and should be of type list"
-    ):
+    with pytest.raises(AssertionError, match="polygon should be None or a list"):
         mock_elements_worker.create_sub_element(
             element=elt,
             type="something",
@@ -504,6 +492,42 @@ def test_create_sub_element_wrong_confidence(mock_elements_worker, confidence):
         )
 
 
+@pytest.mark.parametrize(
+    ("image", "error_type", "error_message"),
+    [
+        (1, AssertionError, "image should be None or string"),
+        ("not a uuid", ValueError, "image is not a valid uuid."),
+    ],
+)
+def test_create_sub_element_wrong_image(
+    mock_elements_worker, image, error_type, error_message
+):
+    with pytest.raises(error_type, match=re.escape(error_message)):
+        mock_elements_worker.create_sub_element(
+            element=Element({"zone": None}),
+            type="something",
+            name="blah",
+            polygon=[[0, 0], [0, 10], [10, 10], [10, 0], [0, 0]],
+            image=image,
+        )
+
+
+def test_create_sub_element_wrong_image_and_polygon(mock_elements_worker):
+    with pytest.raises(
+        AssertionError,
+        match=re.escape(
+            "An image or a parent with an image is required to create an element with a polygon."
+        ),
+    ):
+        mock_elements_worker.create_sub_element(
+            element=Element({"zone": None}),
+            type="something",
+            name="blah",
+            polygon=[[0, 0], [0, 10], [10, 10], [10, 0], [0, 0]],
+            image=None,
+        )
+
+
 def test_create_sub_element_api_error(responses, mock_elements_worker):
     elt = Element(
         {
@@ -580,7 +604,7 @@ def test_create_sub_element(responses, mock_elements_worker, slim_output):
     assert json.loads(responses.calls[-1].request.body) == {
         "type": "something",
         "name": "0",
-        "image": "22222222-2222-2222-2222-222222222222",
+        "image": None,
         "corpus": "11111111-1111-1111-1111-111111111111",
         "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
         "parent": "12341234-1234-1234-1234-123412341234",
@@ -625,7 +649,7 @@ def test_create_sub_element_confidence(responses, mock_elements_worker):
     assert json.loads(responses.calls[-1].request.body) == {
         "type": "something",
         "name": "0",
-        "image": "22222222-2222-2222-2222-222222222222",
+        "image": None,
         "corpus": "11111111-1111-1111-1111-111111111111",
         "polygon": [[1, 1], [2, 2], [2, 1], [1, 2]],
         "parent": "12341234-1234-1234-1234-123412341234",
@@ -1217,6 +1241,94 @@ def test_create_elements_integrity_error(
     assert list(CachedElement.select()) == []
 
 
+@pytest.mark.parametrize(
+    ("params", "error_message"),
+    [
+        (
+            {"parent": None, "child": None},
+            "parent shouldn't be null and should be of type Element",
+        ),
+        (
+            {"parent": "not an element", "child": None},
+            "parent shouldn't be null and should be of type Element",
+        ),
+        (
+            {"parent": Element(zone=None), "child": None},
+            "child shouldn't be null and should be of type Element",
+        ),
+        (
+            {"parent": Element(zone=None), "child": "not an element"},
+            "child shouldn't be null and should be of type Element",
+        ),
+    ],
+)
+def test_create_element_parent_invalid_params(
+    mock_elements_worker, params, error_message
+):
+    with pytest.raises(AssertionError, match=re.escape(error_message)):
+        mock_elements_worker.create_element_parent(**params)
+
+
+def test_create_element_parent_api_error(responses, mock_elements_worker):
+    parent = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    child = Element({"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/element/497f6eca-6276-4993-bfeb-53cbbbba6f08/parent/12341234-1234-1234-1234-123412341234/",
+        status=500,
+    )
+
+    with pytest.raises(ErrorResponse):
+        mock_elements_worker.create_element_parent(
+            parent=parent,
+            child=child,
+        )
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + 5
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        # We retry 5 times the API call
+        (
+            "POST",
+            "http://testserver/api/v1/element/497f6eca-6276-4993-bfeb-53cbbbba6f08/parent/12341234-1234-1234-1234-123412341234/",
+        ),
+    ] * 5
+
+
+def test_create_element_parent(responses, mock_elements_worker):
+    parent = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    child = Element({"id": "497f6eca-6276-4993-bfeb-53cbbbba6f08"})
+    responses.add(
+        responses.POST,
+        "http://testserver/api/v1/element/497f6eca-6276-4993-bfeb-53cbbbba6f08/parent/12341234-1234-1234-1234-123412341234/",
+        status=200,
+        json={
+            "parent": "12341234-1234-1234-1234-123412341234",
+            "child": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+        },
+    )
+
+    created_element_parent = mock_elements_worker.create_element_parent(
+        parent=parent,
+        child=child,
+    )
+
+    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/element/497f6eca-6276-4993-bfeb-53cbbbba6f08/parent/12341234-1234-1234-1234-123412341234/",
+        ),
+    ]
+    assert created_element_parent == {
+        "parent": "12341234-1234-1234-1234-123412341234",
+        "child": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+    }
+
+
 @pytest.mark.parametrize(
     ("payload", "error"),
     [
@@ -1658,13 +1770,11 @@ def test_list_element_children_wrong_with_metadata(mock_elements_worker):
 @pytest.mark.parametrize(
     ("param", "value"),
     [
-        ("worker_version", 1234),
         ("worker_run", 1234),
-        ("transcription_worker_version", 1234),
         ("transcription_worker_run", 1234),
     ],
 )
-def test_list_element_children_wrong_worker_version(mock_elements_worker, param, value):
+def test_list_element_children_wrong_worker_run(mock_elements_worker, param, value):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(AssertionError, match=f"{param} should be of type str or bool"):
@@ -1674,16 +1784,39 @@ def test_list_element_children_wrong_worker_version(mock_elements_worker, param,
         )
 
 
+@pytest.mark.parametrize(
+    ("param", "alternative", "value"),
+    [
+        ("worker_version", "worker_run", 1234),
+        ("transcription_worker_version", "transcription_worker_run", 1234),
+    ],
+)
+def test_list_element_children_wrong_worker_version(
+    mock_elements_worker, param, alternative, value
+):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(
+            match=f"`{param}` usage is deprecated. Consider using `{alternative}` instead."
+        ),
+        pytest.raises(AssertionError, match=f"{param} should be of type str or bool"),
+    ):
+        mock_elements_worker.list_element_children(
+            element=elt,
+            **{param: value},
+        )
+
+
 @pytest.mark.parametrize(
     "param",
     [
-        "worker_version",
         "worker_run",
-        "transcription_worker_version",
         "transcription_worker_run",
     ],
 )
-def test_list_element_children_wrong_bool_worker_version(mock_elements_worker, param):
+def test_list_element_children_wrong_bool_worker_run(mock_elements_worker, param):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(
@@ -1695,6 +1828,33 @@ def test_list_element_children_wrong_bool_worker_version(mock_elements_worker, p
         )
 
 
+@pytest.mark.parametrize(
+    ("param", "alternative"),
+    [
+        ("worker_version", "worker_run"),
+        ("transcription_worker_version", "transcription_worker_run"),
+    ],
+)
+def test_list_element_children_wrong_bool_worker_version(
+    mock_elements_worker, param, alternative
+):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(
+            match=f"`{param}` usage is deprecated. Consider using `{alternative}` instead."
+        ),
+        pytest.raises(
+            AssertionError, match=f"if of type bool, {param} can only be set to False"
+        ),
+    ):
+        mock_elements_worker.list_element_children(
+            element=elt,
+            **{param: True},
+        )
+
+
 def test_list_element_children_api_error(responses, mock_elements_worker):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
     responses.add(
@@ -1830,10 +1990,15 @@ def test_list_element_children_manual_worker_version(responses, mock_elements_wo
         },
     )
 
-    for idx, child in enumerate(
-        mock_elements_worker.list_element_children(element=elt, worker_version=False)
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
     ):
-        assert child == expected_children[idx]
+        for idx, child in enumerate(
+            mock_elements_worker.list_element_children(
+                element=elt, worker_version=False
+            )
+        ):
+            assert child == expected_children[idx]
 
     assert len(responses.calls) == len(BASE_API_CALLS) + 1
     assert [
@@ -1926,56 +2091,84 @@ def test_list_element_children_with_cache_unhandled_param(
             },
             ("22222222-2222-2222-2222-222222222222",),
         ),
-        # Filter on element and worker version should give first two elements
+        # Filter on element and worker run should give second
         (
             {
                 "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
-                "worker_version": "56785678-5678-5678-5678-567856785678",
+                "worker_run": "56785678-5678-5678-5678-567856785678",
             },
-            (
-                "11111111-1111-1111-1111-111111111111",
-                "22222222-2222-2222-2222-222222222222",
-            ),
+            ("22222222-2222-2222-2222-222222222222",),
         ),
-        # Filter on element, type something and worker version should give first
+        # Filter on element, manual worker run should give first and third
         (
             {
                 "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
-                "type": "something",
-                "worker_version": "56785678-5678-5678-5678-567856785678",
+                "worker_run": False,
             },
-            ("11111111-1111-1111-1111-111111111111",),
+            (
+                "11111111-1111-1111-1111-111111111111",
+                "33333333-3333-3333-3333-333333333333",
+            ),
         ),
-        # Filter on element, manual worker version should give third
+    ],
+)
+def test_list_element_children_with_cache(
+    responses,
+    mock_elements_worker_with_cache,
+    filters,
+    expected_ids,
+):
+    # Check we have 5 elements already present in database
+    assert CachedElement.select().count() == 5
+
+    # Query database through cache
+    elements = mock_elements_worker_with_cache.list_element_children(**filters)
+    assert elements.count() == len(expected_ids)
+    for child, expected_id in zip(elements.order_by("id"), expected_ids, strict=True):
+        assert child.id == UUID(expected_id)
+
+    # Check the worker never hits the API for elements
+    assert len(responses.calls) == len(BASE_API_CALLS)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS
+
+
+@pytest.mark.usefixtures("_mock_cached_elements")
+@pytest.mark.parametrize(
+    ("filters", "expected_ids"),
+    [
+        # Filter on element and worker version
         (
             {
                 "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
-                "worker_version": False,
+                "worker_version": "56785678-5678-5678-5678-567856785678",
             },
-            ("33333333-3333-3333-3333-333333333333",),
+            (
+                "11111111-1111-1111-1111-111111111111",
+                "22222222-2222-2222-2222-222222222222",
+            ),
         ),
-        # Filter on element and worker run should give second
+        # Filter on element, type double_page and worker version
         (
             {
                 "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
-                "worker_run": "56785678-5678-5678-5678-567856785678",
+                "type": "page",
+                "worker_version": "56785678-5678-5678-5678-567856785678",
             },
             ("22222222-2222-2222-2222-222222222222",),
         ),
-        # Filter on element, manual worker run should give first and third
+        # Filter on element, manual worker version
         (
             {
                 "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
-                "worker_run": False,
+                "worker_version": False,
             },
-            (
-                "11111111-1111-1111-1111-111111111111",
-                "33333333-3333-3333-3333-333333333333",
-            ),
+            ("33333333-3333-3333-3333-333333333333",),
         ),
     ],
 )
-def test_list_element_children_with_cache(
+def test_list_element_children_with_cache_deprecation(
     responses,
     mock_elements_worker_with_cache,
     filters,
@@ -1984,8 +2177,11 @@ def test_list_element_children_with_cache(
     # Check we have 5 elements already present in database
     assert CachedElement.select().count() == 5
 
-    # Query database through cache
-    elements = mock_elements_worker_with_cache.list_element_children(**filters)
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        # Query database through cache
+        elements = mock_elements_worker_with_cache.list_element_children(**filters)
     assert elements.count() == len(expected_ids)
     for child, expected_id in zip(elements.order_by("id"), expected_ids, strict=True):
         assert child.id == UUID(expected_id)
@@ -2106,13 +2302,11 @@ def test_list_element_parents_wrong_with_metadata(mock_elements_worker):
 @pytest.mark.parametrize(
     ("param", "value"),
     [
-        ("worker_version", 1234),
         ("worker_run", 1234),
-        ("transcription_worker_version", 1234),
         ("transcription_worker_run", 1234),
     ],
 )
-def test_list_element_parents_wrong_worker_version(mock_elements_worker, param, value):
+def test_list_element_parents_wrong_worker_run(mock_elements_worker, param, value):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(AssertionError, match=f"{param} should be of type str or bool"):
@@ -2122,16 +2316,39 @@ def test_list_element_parents_wrong_worker_version(mock_elements_worker, param,
         )
 
 
+@pytest.mark.parametrize(
+    ("param", "alternative", "value"),
+    [
+        ("worker_version", "worker_run", 1234),
+        ("transcription_worker_version", "transcription_worker_run", 1234),
+    ],
+)
+def test_list_element_parents_wrong_worker_version(
+    mock_elements_worker, param, alternative, value
+):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(
+            match=f"`{param}` usage is deprecated. Consider using `{alternative}` instead."
+        ),
+        pytest.raises(AssertionError, match=f"{param} should be of type str or bool"),
+    ):
+        mock_elements_worker.list_element_parents(
+            element=elt,
+            **{param: value},
+        )
+
+
 @pytest.mark.parametrize(
     "param",
     [
-        "worker_version",
         "worker_run",
-        "transcription_worker_version",
         "transcription_worker_run",
     ],
 )
-def test_list_element_parents_wrong_bool_worker_version(mock_elements_worker, param):
+def test_list_element_parents_wrong_bool_worker_run(mock_elements_worker, param):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(
@@ -2143,6 +2360,33 @@ def test_list_element_parents_wrong_bool_worker_version(mock_elements_worker, pa
         )
 
 
+@pytest.mark.parametrize(
+    ("param", "alternative"),
+    [
+        ("worker_version", "worker_run"),
+        ("transcription_worker_version", "transcription_worker_run"),
+    ],
+)
+def test_list_element_parents_wrong_bool_worker_version(
+    mock_elements_worker, param, alternative
+):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+
+    # WARNING: pytest.deprecated_call must be placed BEFORE pytest.raises, otherwise `match` argument won't be checked
+    with (
+        pytest.deprecated_call(
+            match=f"`{param}` usage is deprecated. Consider using `{alternative}` instead."
+        ),
+        pytest.raises(
+            AssertionError, match=f"if of type bool, {param} can only be set to False"
+        ),
+    ):
+        mock_elements_worker.list_element_parents(
+            element=elt,
+            **{param: True},
+        )
+
+
 def test_list_element_parents_api_error(responses, mock_elements_worker):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
     responses.add(
@@ -2278,10 +2522,13 @@ def test_list_element_parents_manual_worker_version(responses, mock_elements_wor
         },
     )
 
-    for idx, parent in enumerate(
-        mock_elements_worker.list_element_parents(element=elt, worker_version=False)
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
     ):
-        assert parent == expected_parents[idx]
+        for idx, parent in enumerate(
+            mock_elements_worker.list_element_parents(element=elt, worker_version=False)
+        ):
+            assert parent == expected_parents[idx]
 
     assert len(responses.calls) == len(BASE_API_CALLS) + 1
     assert [
@@ -2370,6 +2617,50 @@ def test_list_element_parents_with_cache_unhandled_param(
             },
             "12341234-1234-1234-1234-123412341234",
         ),
+        # Filter on element and worker run
+        (
+            {
+                "element": CachedElement(id="22222222-2222-2222-2222-222222222222"),
+                "worker_run": "56785678-5678-5678-5678-567856785678",
+            },
+            "12341234-1234-1234-1234-123412341234",
+        ),
+        # Filter on element, manual worker run
+        (
+            {
+                "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
+                "worker_run": False,
+            },
+            "99999999-9999-9999-9999-999999999999",
+        ),
+    ],
+)
+def test_list_element_parents_with_cache(
+    responses,
+    mock_elements_worker_with_cache,
+    filters,
+    expected_id,
+):
+    # Check we have 5 elements already present in database
+    assert CachedElement.select().count() == 5
+
+    # Query database through cache
+    elements = mock_elements_worker_with_cache.list_element_parents(**filters)
+    assert elements.count() == 1
+    for parent in elements.order_by("id"):
+        assert parent.id == UUID(expected_id)
+
+    # Check the worker never hits the API for elements
+    assert len(responses.calls) == len(BASE_API_CALLS)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS
+
+
+@pytest.mark.usefixtures("_mock_cached_elements")
+@pytest.mark.parametrize(
+    ("filters", "expected_id"),
+    [
         # Filter on element and worker version
         (
             {
@@ -2395,25 +2686,9 @@ def test_list_element_parents_with_cache_unhandled_param(
             },
             "99999999-9999-9999-9999-999999999999",
         ),
-        # Filter on element and worker run
-        (
-            {
-                "element": CachedElement(id="22222222-2222-2222-2222-222222222222"),
-                "worker_run": "56785678-5678-5678-5678-567856785678",
-            },
-            "12341234-1234-1234-1234-123412341234",
-        ),
-        # Filter on element, manual worker run
-        (
-            {
-                "element": CachedElement(id="12341234-1234-1234-1234-123412341234"),
-                "worker_run": False,
-            },
-            "99999999-9999-9999-9999-999999999999",
-        ),
     ],
 )
-def test_list_element_parents_with_cache(
+def test_list_element_parents_with_cache_deprecation(
     responses,
     mock_elements_worker_with_cache,
     filters,
@@ -2422,8 +2697,11 @@ def test_list_element_parents_with_cache(
     # Check we have 5 elements already present in database
     assert CachedElement.select().count() == 5
 
-    # Query database through cache
-    elements = mock_elements_worker_with_cache.list_element_parents(**filters)
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        # Query database through cache
+        elements = mock_elements_worker_with_cache.list_element_parents(**filters)
     assert elements.count() == 1
     for parent in elements.order_by("id"):
         assert parent.id == UUID(expected_id)

tests/test_elements_worker/test_entities.py

@@ -708,7 +708,7 @@ def test_create_transcription_entity_with_confidence_with_cache(
     ]
 
 
-def test_list_transcription_entities(fake_dummy_worker):
+def test_list_transcription_entities_deprecation(fake_dummy_worker):
     transcription = Transcription({"id": "fake_transcription_id"})
     worker_version = "worker_version_id"
     fake_dummy_worker.api_client.add_response(
@@ -717,8 +717,28 @@ def test_list_transcription_entities(fake_dummy_worker):
         worker_version=worker_version,
         response={"id": "entity_id"},
     )
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        assert fake_dummy_worker.list_transcription_entities(
+            transcription, worker_version=worker_version
+        ) == {"id": "entity_id"}
+
+    assert len(fake_dummy_worker.api_client.history) == 1
+    assert len(fake_dummy_worker.api_client.responses) == 0
+
+
+def test_list_transcription_entities(fake_dummy_worker):
+    transcription = Transcription({"id": "fake_transcription_id"})
+    worker_run = "worker_run_id"
+    fake_dummy_worker.api_client.add_response(
+        "ListTranscriptionEntities",
+        id=transcription.id,
+        worker_run=worker_run,
+        response={"id": "entity_id"},
+    )
     assert fake_dummy_worker.list_transcription_entities(
-        transcription, worker_version
+        transcription, worker_run=worker_run
     ) == {"id": "entity_id"}
 
     assert len(fake_dummy_worker.api_client.history) == 1