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

tests/test_elements_worker/test_metadata.py

@@ -259,7 +259,7 @@ def test_create_metadata_cached_element(responses, mock_elements_worker_with_cac
         ],
     ],
 )
-def test_create_metadatas(responses, mock_elements_worker, metadata_list):
+def test_create_metadata_bulk(responses, mock_elements_worker, metadata_list):
     element = Element({"id": "12341234-1234-1234-1234-123412341234"})
     responses.add(
         responses.POST,
@@ -280,7 +280,7 @@ def test_create_metadatas(responses, mock_elements_worker, metadata_list):
         },
     )
 
-    created_metadata_list = mock_elements_worker.create_metadatas(
+    created_metadata_list = mock_elements_worker.create_metadata_bulk(
         element, metadata_list
     )
 
@@ -327,7 +327,7 @@ def test_create_metadatas(responses, mock_elements_worker, metadata_list):
         ],
     ],
 )
-def test_create_metadatas_cached_element(
+def test_create_metadata_bulk_cached_element(
     responses, mock_elements_worker_with_cache, metadata_list
 ):
     element = CachedElement.create(
@@ -352,7 +352,7 @@ def test_create_metadatas_cached_element(
         },
     )
 
-    created_metadata_list = mock_elements_worker_with_cache.create_metadatas(
+    created_metadata_list = mock_elements_worker_with_cache.create_metadata_bulk(
         element, metadata_list
     )
 
@@ -386,7 +386,7 @@ def test_create_metadatas_cached_element(
 
 
 @pytest.mark.parametrize("wrong_element", [None, "not_element_type", 1234, 12.5])
-def test_create_metadatas_wrong_element(mock_elements_worker, wrong_element):
+def test_create_metadata_bulk_wrong_element(mock_elements_worker, wrong_element):
     wrong_metadata_list = [
         {"type": MetaType.Text, "name": "fake_name", "value": "fake_value"}
     ]
@@ -394,13 +394,13 @@ def test_create_metadatas_wrong_element(mock_elements_worker, wrong_element):
         AssertionError,
         match="element shouldn't be null and should be of type Element or CachedElement",
     ):
-        mock_elements_worker.create_metadatas(
-            element=wrong_element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=wrong_element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_type", [None, "not_metadata_type", 1234, 12.5])
-def test_create_metadatas_wrong_type(mock_elements_worker, wrong_type):
+def test_create_metadata_bulk_wrong_type(mock_elements_worker, wrong_type):
     element = Element({"id": "12341234-1234-1234-1234-123412341234"})
     wrong_metadata_list = [
         {"type": wrong_type, "name": "fake_name", "value": "fake_value"}
@@ -408,13 +408,13 @@ def test_create_metadatas_wrong_type(mock_elements_worker, wrong_type):
     with pytest.raises(
         AssertionError, match="type shouldn't be null and should be of type MetaType"
     ):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_name", [None, 1234, 12.5, [1, 2, 3, 4]])
-def test_create_metadatas_wrong_name(mock_elements_worker, wrong_name):
+def test_create_metadata_bulk_wrong_name(mock_elements_worker, wrong_name):
     element = Element({"id": "fake_element_id"})
     wrong_metadata_list = [
         {"type": MetaType.Text, "name": wrong_name, "value": "fake_value"}
@@ -422,13 +422,13 @@ def test_create_metadatas_wrong_name(mock_elements_worker, wrong_name):
     with pytest.raises(
         AssertionError, match="name shouldn't be null and should be of type str"
     ):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_value", [None, [1, 2, 3, 4]])
-def test_create_metadatas_wrong_value(mock_elements_worker, wrong_value):
+def test_create_metadata_bulk_wrong_value(mock_elements_worker, wrong_value):
     element = Element({"id": "fake_element_id"})
     wrong_metadata_list = [
         {"type": MetaType.Text, "name": "fake_name", "value": wrong_value}
@@ -439,13 +439,13 @@ def test_create_metadatas_wrong_value(mock_elements_worker, wrong_value):
             "value shouldn't be null and should be of type (str or float or int)"
         ),
     ):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
 @pytest.mark.parametrize("wrong_entity", [[1, 2, 3, 4], 1234, 12.5])
-def test_create_metadatas_wrong_entity(mock_elements_worker, wrong_entity):
+def test_create_metadata_bulk_wrong_entity(mock_elements_worker, wrong_entity):
     element = Element({"id": "fake_element_id"})
     wrong_metadata_list = [
         {
@@ -456,12 +456,12 @@ def test_create_metadatas_wrong_entity(mock_elements_worker, wrong_entity):
         }
     ]
     with pytest.raises(AssertionError, match="entity_id should be None or a str"):
-        mock_elements_worker.create_metadatas(
-            element=element, metadatas=wrong_metadata_list
+        mock_elements_worker.create_metadata_bulk(
+            element=element, metadata_list=wrong_metadata_list
         )
 
 
-def test_create_metadatas_api_error(responses, mock_elements_worker):
+def test_create_metadata_bulk_api_error(responses, mock_elements_worker):
     element = Element({"id": "12341234-1234-1234-1234-123412341234"})
     metadata_list = [
         {
@@ -478,7 +478,7 @@ def test_create_metadatas_api_error(responses, mock_elements_worker):
     )
 
     with pytest.raises(ErrorResponse):
-        mock_elements_worker.create_metadatas(element, metadata_list)
+        mock_elements_worker.create_metadata_bulk(element, metadata_list)
 
     assert len(responses.calls) == len(BASE_API_CALLS) + 5
     assert [
@@ -508,14 +508,23 @@ def test_create_metadatas_api_error(responses, mock_elements_worker):
     ]
 
 
+def test_list_element_metadata_wrong_load_parents(fake_dummy_worker):
+    element = Element({"id": "element_id"})
+    with pytest.raises(AssertionError, match="load_parents should be of type bool"):
+        fake_dummy_worker.list_element_metadata(
+            element=element,
+            load_parents="not bool",
+        )
+
+
 def test_list_element_metadata(fake_dummy_worker):
     element = Element({"id": "element_id"})
     fake_dummy_worker.api_client.add_response(
         "ListElementMetaData",
         id=element.id,
-        response={"id": "metadata_id"},
+        response=[{"id": "metadata_id"}],
     )
-    assert fake_dummy_worker.list_element_metadata(element) == {"id": "metadata_id"}
+    assert fake_dummy_worker.list_element_metadata(element) == [{"id": "metadata_id"}]
 
     assert len(fake_dummy_worker.api_client.history) == 1
     assert len(fake_dummy_worker.api_client.responses) == 0
@@ -527,11 +536,28 @@ def test_list_element_metadata_cached_element(mock_elements_worker_with_cache):
     mock_elements_worker_with_cache.api_client.add_response(
         "ListElementMetaData",
         id="element_id",
-        response={"id": "metadata_id"},
+        response=[{"id": "metadata_id"}],
     )
-    assert mock_elements_worker_with_cache.list_element_metadata(element) == {
-        "id": "metadata_id"
-    }
+    assert mock_elements_worker_with_cache.list_element_metadata(element) == [
+        {"id": "metadata_id"}
+    ]
 
     assert len(mock_elements_worker_with_cache.api_client.history) == 1
     assert len(mock_elements_worker_with_cache.api_client.responses) == 0
+
+
+def test_list_element_metadata_with_load_parents(fake_dummy_worker):
+    element = Element({"id": "element_id"})
+    fake_dummy_worker.api_client.add_response(
+        "ListElementMetaData",
+        id=element.id,
+        load_parents=True,
+        response=[{"id": "metadata_id"}, {"id": "parent_metadata_id"}],
+    )
+    assert fake_dummy_worker.list_element_metadata(element, load_parents=True) == [
+        {"id": "metadata_id"},
+        {"id": "parent_metadata_id"},
+    ]
+
+    assert len(fake_dummy_worker.api_client.history) == 1
+    assert len(fake_dummy_worker.api_client.responses) == 0

tests/test_elements_worker/test_training.py

@@ -179,6 +179,41 @@ def test_validate_model_version_not_created(mock_training_worker):
         mock_training_worker.validate_model_version(hash="a", size=1, archive_hash="b")
 
 
+@pytest.mark.parametrize("status_code", [403, 500])
+def test_validate_model_version_catch_errors(
+    mocker, mock_training_worker, caplog, status_code
+):
+    mocker.patch(
+        "arkindex_worker.worker.base.BaseWorker.request.retry.retry", return_value=False
+    )
+
+    mock_training_worker.model_version = {"id": "model_version_id"}
+    args = {
+        "hash": "hash",
+        "archive_hash": "archive_hash",
+        "size": 30,
+    }
+    mock_training_worker.api_client.add_error_response(
+        "ValidateModelVersion",
+        id="model_version_id",
+        status_code=status_code,
+        body=args,
+    )
+
+    mock_training_worker.validate_model_version(**args)
+    assert mock_training_worker.model_version == {"id": "model_version_id"}
+    assert [
+        (level, message)
+        for module, level, message in caplog.record_tuples
+        if module == "arkindex_worker"
+    ] == [
+        (
+            logging.WARNING,
+            "An error occurred while validating model version model_version_id, please check its status.",
+        ),
+    ]
+
+
 @pytest.mark.parametrize("deletion_failed", [True, False])
 def test_validate_model_version_hash_conflict(
     mock_training_worker, default_model_version, caplog, deletion_failed

tests/test_elements_worker/test_transcriptions.py

@@ -1711,11 +1711,29 @@ def test_list_transcriptions_wrong_recursive(mock_elements_worker):
         )
 
 
-def test_list_transcriptions_wrong_worker_version(mock_elements_worker):
+def test_list_transcriptions_wrong_worker_run(mock_elements_worker):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(
-        AssertionError, match="worker_version should be of type str or bool"
+        AssertionError, match="worker_run should be of type str or bool"
+    ):
+        mock_elements_worker.list_transcriptions(
+            element=elt,
+            worker_run=1234,
+        )
+
+
+def test_list_transcriptions_wrong_worker_version(mock_elements_worker):
+    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="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+        ),
+        pytest.raises(
+            AssertionError, match="worker_version should be of type str or bool"
+        ),
     ):
         mock_elements_worker.list_transcriptions(
             element=elt,
@@ -1723,11 +1741,30 @@ def test_list_transcriptions_wrong_worker_version(mock_elements_worker):
         )
 
 
-def test_list_transcriptions_wrong_bool_worker_version(mock_elements_worker):
+def test_list_transcriptions_wrong_bool_worker_run(mock_elements_worker):
     elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
 
     with pytest.raises(
-        AssertionError, match="if of type bool, worker_version can only be set to False"
+        AssertionError, match="if of type bool, worker_run can only be set to False"
+    ):
+        mock_elements_worker.list_transcriptions(
+            element=elt,
+            worker_run=True,
+        )
+
+
+def test_list_transcriptions_wrong_bool_worker_version(mock_elements_worker):
+    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="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+        ),
+        pytest.raises(
+            AssertionError,
+            match="if of type bool, worker_version can only be set to False",
+        ),
     ):
         mock_elements_worker.list_transcriptions(
             element=elt,
@@ -1784,6 +1821,7 @@ def test_list_transcriptions(responses, mock_elements_worker):
             "text": "hey",
             "confidence": 0.42,
             "worker_version_id": "56785678-5678-5678-5678-567856785678",
+            "worker_run_id": "56785678-5678-5678-5678-567856785678",
             "element": None,
         },
         {
@@ -1791,6 +1829,7 @@ def test_list_transcriptions(responses, mock_elements_worker):
             "text": "it's",
             "confidence": 0.42,
             "worker_version_id": "56785678-5678-5678-5678-567856785678",
+            "worker_run_id": "56785678-5678-5678-5678-567856785678",
             "element": None,
         },
         {
@@ -1798,6 +1837,7 @@ def test_list_transcriptions(responses, mock_elements_worker):
             "text": "me",
             "confidence": 0.42,
             "worker_version_id": "56785678-5678-5678-5678-567856785678",
+            "worker_run_id": "56785678-5678-5678-5678-567856785678",
             "element": None,
         },
     ]
@@ -1836,6 +1876,7 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
             "text": "hey",
             "confidence": 0.42,
             "worker_version_id": None,
+            "worker_run_id": None,
             "element": None,
         }
     ]
@@ -1850,8 +1891,50 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
         },
     )
 
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        for idx, transcription in enumerate(
+            mock_elements_worker.list_transcriptions(element=elt, worker_version=False)
+        ):
+            assert transcription == trans[idx]
+
+    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        (
+            "GET",
+            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_version=False",
+        ),
+    ]
+
+
+def test_list_transcriptions_manual_worker_run(responses, mock_elements_worker):
+    elt = Element({"id": "12341234-1234-1234-1234-123412341234"})
+    trans = [
+        {
+            "id": "0000",
+            "text": "hey",
+            "confidence": 0.42,
+            "worker_version_id": None,
+            "worker_run_id": None,
+            "element": None,
+        }
+    ]
+    responses.add(
+        responses.GET,
+        "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_run=False",
+        status=200,
+        json={
+            "count": 1,
+            "next": None,
+            "results": trans,
+        },
+    )
+
     for idx, transcription in enumerate(
-        mock_elements_worker.list_transcriptions(element=elt, worker_version=False)
+        mock_elements_worker.list_transcriptions(element=elt, worker_run=False)
     ):
         assert transcription == trans[idx]
 
@@ -1861,7 +1944,7 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
     ] == BASE_API_CALLS + [
         (
             "GET",
-            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_version=False",
+            "http://testserver/api/v1/element/12341234-1234-1234-1234-123412341234/transcriptions/?worker_run=False",
         ),
     ]
 
@@ -1895,16 +1978,26 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
                 "66666666-6666-6666-6666-666666666666",
             ),
         ),
-        # Filter on element and worker_version should give first transcription
+        # Filter on element and worker run should give the first transcription
         (
             {
                 "element": CachedElement(
                     id="11111111-1111-1111-1111-111111111111", type="page"
                 ),
-                "worker_version": "56785678-5678-5678-5678-567856785678",
+                "worker_run": "56785678-5678-5678-5678-567856785678",
             },
             ("11111111-1111-1111-1111-111111111111",),
         ),
+        # Filter on element, manual worker run should give the sixth transcription
+        (
+            {
+                "element": CachedElement(
+                    id="11111111-1111-1111-1111-111111111111", type="page"
+                ),
+                "worker_run": False,
+            },
+            ("66666666-6666-6666-6666-666666666666",),
+        ),
         # Filter recursively on element should give all transcriptions inserted
         (
             {
@@ -1922,33 +2015,70 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
                 "66666666-6666-6666-6666-666666666666",
             ),
         ),
-        # Filter recursively on element and worker_version should give four transcriptions
+        # Filter recursively on element and element_type should give three transcriptions
         (
             {
                 "element": CachedElement(
                     id="11111111-1111-1111-1111-111111111111", type="page"
                 ),
-                "worker_version": "90129012-9012-9012-9012-901290129012",
+                "element_type": "something_else",
                 "recursive": True,
             },
             (
                 "22222222-2222-2222-2222-222222222222",
-                "33333333-3333-3333-3333-333333333333",
                 "44444444-4444-4444-4444-444444444444",
                 "55555555-5555-5555-5555-555555555555",
             ),
         ),
-        # Filter recursively on element and element_type should give three transcriptions
+    ],
+)
+def test_list_transcriptions_with_cache(
+    responses, mock_elements_worker_with_cache, filters, expected_ids
+):
+    # Check we have 5 elements already present in database
+    assert CachedTranscription.select().count() == 6
+
+    # Query database through cache
+    transcriptions = mock_elements_worker_with_cache.list_transcriptions(**filters)
+    assert transcriptions.count() == len(expected_ids)
+    for transcription, expected_id in zip(
+        transcriptions.order_by(CachedTranscription.id), expected_ids, strict=True
+    ):
+        assert transcription.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_transcriptions")
+@pytest.mark.parametrize(
+    ("filters", "expected_ids"),
+    [
+        # Filter on element and worker_version should give first transcription
         (
             {
                 "element": CachedElement(
                     id="11111111-1111-1111-1111-111111111111", type="page"
                 ),
-                "element_type": "something_else",
+                "worker_version": "56785678-5678-5678-5678-567856785678",
+            },
+            ("11111111-1111-1111-1111-111111111111",),
+        ),
+        # Filter recursively on element and worker_version should give four transcriptions
+        (
+            {
+                "element": CachedElement(
+                    id="11111111-1111-1111-1111-111111111111", type="page"
+                ),
+                "worker_version": "90129012-9012-9012-9012-901290129012",
                 "recursive": True,
             },
             (
                 "22222222-2222-2222-2222-222222222222",
+                "33333333-3333-3333-3333-333333333333",
                 "44444444-4444-4444-4444-444444444444",
                 "55555555-5555-5555-5555-555555555555",
             ),
@@ -1965,14 +2095,17 @@ def test_list_transcriptions_manual_worker_version(responses, mock_elements_work
         ),
     ],
 )
-def test_list_transcriptions_with_cache(
+def test_list_transcriptions_with_cache_deprecation(
     responses, mock_elements_worker_with_cache, filters, expected_ids
 ):
     # Check we have 5 elements already present in database
     assert CachedTranscription.select().count() == 6
 
-    # Query database through cache
-    transcriptions = mock_elements_worker_with_cache.list_transcriptions(**filters)
+    with pytest.deprecated_call(
+        match="`worker_version` usage is deprecated. Consider using `worker_run` instead."
+    ):
+        # Query database through cache
+        transcriptions = mock_elements_worker_with_cache.list_transcriptions(**filters)
     assert transcriptions.count() == len(expected_ids)
     for transcription, expected_id in zip(
         transcriptions.order_by(CachedTranscription.id), expected_ids, strict=True

tests/test_elements_worker/test_worker.py

@@ -20,7 +20,8 @@ def test_get_worker_version(fake_dummy_worker):
 
     api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
 
-    res = fake_dummy_worker.get_worker_version(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
@@ -33,8 +34,11 @@ def test_get_worker_version__uses_cache(fake_dummy_worker):
 
     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)
+    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
@@ -51,12 +55,17 @@ def test_get_worker_version_slug(mocker, fake_dummy_worker):
         "worker": {"slug": "mock_slug"},
     }
 
-    slug = fake_dummy_worker.get_worker_version_slug(TEST_VERSION_ID)
+    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):
-    with pytest.raises(ValueError, match="No worker version ID"):
+    # 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)
 
 
@@ -301,7 +310,7 @@ def test_start_activity_error(
         ),
     ]
     assert logger.error.call_args_list == [
-        mocker.call("Ran on 1 elements: 0 completed, 1 failed")
+        mocker.call("Ran on 1 element: 0 completed, 1 failed")
     ]
 
 
@@ -459,6 +468,10 @@ def test_worker_config_multiple_source(
             "id": "12341234-1234-1234-1234-123412341234",
             "name": "Model version 1337",
             "configuration": model_config,
+            "model": {
+                "id": "hahahaha-haha-haha-haha-hahahahahaha",
+                "name": "My model",
+            },
         },
         "process": {
             "name": None,

tests/test_image.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 import pytest
 from PIL import Image, ImageChops, ImageOps
+from requests import HTTPError
 
 from arkindex_worker.cache import CachedElement, create_tables, init_cache_db
 from arkindex_worker.image import (
@@ -19,6 +20,7 @@ from arkindex_worker.image import (
     polygon_bounding_box,
     revert_orientation,
     trim_polygon,
+    upload_image,
 )
 from arkindex_worker.models import Element
 
@@ -547,3 +549,38 @@ def test_download_image_retry_with_max(responses):
     assert list(map(attrgetter("request.url"), responses.calls)) == [full_url] * 3 + [
         max_url
     ]
+
+
+def test_upload_image_retries(responses):
+    dest_url = "https://blabla.com/iiif/2/image_path.jpg/full/full/0/default.jpg"
+    responses.add(
+        responses.PUT,
+        dest_url,
+        status=400,
+    )
+
+    image = Image.open(FULL_IMAGE).convert("RGB")
+    with pytest.raises(
+        HTTPError, match=f"400 Client Error: Bad Request for url: {dest_url}"
+    ):
+        upload_image(image, dest_url)
+
+    # We try 3 times
+    assert len(responses.calls) == 3
+    assert list(map(attrgetter("request.url"), responses.calls)) == [dest_url] * 3
+
+
+def test_upload_image(responses):
+    dest_url = "https://blabla.com/iiif/2/image_path.jpg/full/full/0/default.jpg"
+    responses.add(
+        responses.PUT,
+        dest_url,
+        status=200,
+    )
+
+    image = Image.open(FULL_IMAGE).convert("RGB")
+    resp = upload_image(image, dest_url)
+    assert resp
+
+    assert len(responses.calls) == 1
+    assert list(map(attrgetter("request.url"), responses.calls)) == [dest_url]

tests/test_utils.py

@@ -1,11 +1,33 @@
 from pathlib import Path
 
-from arkindex_worker.utils import close_delete_file, extract_tar_zst_archive
+import pytest
+
+from arkindex_worker.utils import (
+    close_delete_file,
+    extract_tar_zst_archive,
+    parse_source_id,
+)
 
 FIXTURES = Path(__file__).absolute().parent / "data"
 ARCHIVE = FIXTURES / "archive.tar.zst"
 
 
+@pytest.mark.parametrize(
+    ("source_id", "expected"),
+    [
+        (None, None),
+        ("", None),
+        (
+            "cafecafe-cafe-cafe-cafe-cafecafecafe",
+            "cafecafe-cafe-cafe-cafe-cafecafecafe",
+        ),
+        ("manual", False),
+    ],
+)
+def test_parse_source_id(source_id, expected):
+    assert parse_source_id(source_id) == expected
+
+
 def test_extract_tar_zst_archive(tmp_path):
     destination = tmp_path / "destination"
     _, archive_path = extract_tar_zst_archive(ARCHIVE, destination)