arkindex-base-worker 0.3.7rc4__py3-none-any.whl → 0.5.0a1__py3-none-any.whl

tests/test_elements_worker/test_worker.py

@@ -1,89 +1,573 @@
 import json
+import logging
 import sys
+from argparse import Namespace
+from uuid import UUID
 
 import pytest
-from apistar.exceptions import ErrorResponse
 
-from arkindex_worker.cache import CachedElement
+from arkindex.exceptions import ErrorResponse
+from arkindex_worker.cache import (
+    SQL_VERSION,
+    CachedElement,
+    create_version_table,
+    init_cache_db,
+)
+from arkindex_worker.models import Element
 from arkindex_worker.worker import ActivityState, ElementsWorker
+from arkindex_worker.worker.dataset import DatasetState
+from arkindex_worker.worker.process import ProcessMode
+from tests import PROCESS_ID
 
 from . import BASE_API_CALLS
 
-TEST_VERSION_ID = "test_123"
-TEST_SLUG = "some_slug"
 
+def test_database_arg(mocker, mock_elements_worker, tmp_path):
+    database_path = tmp_path / "my_database.sqlite"
+    init_cache_db(database_path)
+    create_version_table()
+
+    mocker.patch(
+        "arkindex_worker.worker.base.argparse.ArgumentParser.parse_args",
+        return_value=Namespace(
+            element=["volumeid", "pageid"],
+            verbose=False,
+            elements_list=None,
+            database=database_path,
+            dev=False,
+            set=[],
+        ),
+    )
+
+    worker = ElementsWorker(support_cache=True)
+    worker.configure()
+
+    assert worker.use_cache is True
+    assert worker.cache_path == database_path
+
+
+def test_database_arg_cache_missing_version_table(
+    mocker, mock_elements_worker, tmp_path
+):
+    database_path = tmp_path / "my_database.sqlite"
+    database_path.touch()
+
+    mocker.patch(
+        "arkindex_worker.worker.base.argparse.ArgumentParser.parse_args",
+        return_value=Namespace(
+            element=["volumeid", "pageid"],
+            verbose=False,
+            elements_list=None,
+            database=database_path,
+            dev=False,
+            set=[],
+        ),
+    )
+
+    worker = ElementsWorker(support_cache=True)
+    with pytest.raises(
+        AssertionError,
+        match=f"The SQLite database {database_path} does not have the correct cache version, it should be {SQL_VERSION}",
+    ):
+        worker.configure()
 
-def test_get_worker_version(fake_dummy_worker):
-    api_client = fake_dummy_worker.api_client
 
-    response = {"worker": {"slug": TEST_SLUG}}
+def test_readonly(responses, mock_elements_worker):
+    """Test readonly worker does not trigger any API calls"""
+
+    # Setup the worker as read-only
+    mock_elements_worker.worker_run_id = None
+    assert mock_elements_worker.is_read_only is True
 
-    api_client.add_response("RetrieveWorkerVersion", response, id=TEST_VERSION_ID)
+    out = mock_elements_worker.update_activity("1234-deadbeef", ActivityState.Processed)
 
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        res = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+    # update_activity returns False in very specific cases
+    assert out is True
+    assert len(responses.calls) == len(BASE_API_CALLS)
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS
 
-    assert res == response
-    assert fake_dummy_worker._worker_version_cache[TEST_VERSION_ID] == response
 
+def test_get_elements_elements_list_arg_wrong_type(
+    monkeypatch, tmp_path, mock_elements_worker
+):
+    elements_path = tmp_path / "elements.json"
+    elements_path.write_text("{}")
 
-def test_get_worker_version__uses_cache(fake_dummy_worker):
-    api_client = fake_dummy_worker.api_client
+    monkeypatch.setenv("TASK_ELEMENTS", str(elements_path))
+    worker = ElementsWorker()
+    worker.configure()
 
-    response = {"worker": {"slug": TEST_SLUG}}
+    with pytest.raises(AssertionError, match="Elements list must be a list"):
+        worker.get_elements()
 
-    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)
+def test_get_elements_elements_list_arg_empty_list(
+    monkeypatch, tmp_path, mock_elements_worker
+):
+    elements_path = tmp_path / "elements.json"
+    elements_path.write_text("[]")
 
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        response_2 = fake_dummy_worker.get_worker_version(TEST_VERSION_ID)
+    monkeypatch.setenv("TASK_ELEMENTS", str(elements_path))
+    worker = ElementsWorker()
+    worker.configure()
 
-    assert response_1 == response
-    assert response_1 == response_2
+    with pytest.raises(AssertionError, match="No elements in elements list"):
+        worker.get_elements()
 
-    # assert that only one call to the API
-    assert len(api_client.history) == 1
-    assert not api_client.responses
 
+def test_get_elements_elements_list_arg_missing_id(
+    monkeypatch, tmp_path, mock_elements_worker
+):
+    elements_path = tmp_path / "elements.json"
+    elements_path.write_text(json.dumps([{"type": "volume"}]))
 
-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"},
-    }
+    monkeypatch.setenv("TASK_ELEMENTS", str(elements_path))
+    worker = ElementsWorker()
+    worker.configure()
 
-    with pytest.deprecated_call(match="WorkerVersion usage is deprecated."):
-        slug = fake_dummy_worker.get_worker_version_slug(TEST_VERSION_ID)
-    assert slug == "mock_slug"
+    elt_list = worker.get_elements()
 
+    assert elt_list == []
 
-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"),
+
+def test_get_elements_elements_list_arg_not_uuid(
+    monkeypatch, tmp_path, mock_elements_worker
+):
+    elements_path = tmp_path / "elements.json"
+    elements_path.write_text(
+        json.dumps(
+            [
+                {"id": "volumeid", "type": "volume"},
+                {"id": "pageid", "type": "page"},
+                {"id": "actid", "type": "act"},
+                {"id": "surfaceid", "type": "surface"},
+            ]
+        )
+    )
+
+    monkeypatch.setenv("TASK_ELEMENTS", str(elements_path))
+    worker = ElementsWorker()
+    worker.configure()
+
+    with pytest.raises(
+        Exception,
+        match="These element IDs are invalid: volumeid, pageid, actid, surfaceid",
     ):
-        fake_dummy_worker.get_worker_version_slug(None)
+        worker.get_elements()
+
+
+def test_get_elements_elements_list_arg(monkeypatch, tmp_path, mock_elements_worker):
+    elements_path = tmp_path / "elements.json"
+    elements_path.write_text(
+        json.dumps(
+            [
+                {"id": "11111111-1111-1111-1111-111111111111", "type": "volume"},
+                {"id": "22222222-2222-2222-2222-222222222222", "type": "page"},
+                {"id": "33333333-3333-3333-3333-333333333333", "type": "act"},
+            ]
+        )
+    )
 
+    monkeypatch.setenv("TASK_ELEMENTS", str(elements_path))
+    worker = ElementsWorker()
+    worker.configure()
 
-def test_readonly(responses, mock_elements_worker):
-    """Test readonly worker does not trigger any API calls"""
+    elt_list = worker.get_elements()
 
-    # Setup the worker as read-only
-    mock_elements_worker.worker_run_id = None
-    assert mock_elements_worker.is_read_only is True
+    assert elt_list == [
+        "11111111-1111-1111-1111-111111111111",
+        "22222222-2222-2222-2222-222222222222",
+        "33333333-3333-3333-3333-333333333333",
+    ]
 
-    out = mock_elements_worker.update_activity("1234-deadbeef", ActivityState.Processed)
 
-    # update_activity returns False in very specific cases
-    assert out is True
-    assert len(responses.calls) == len(BASE_API_CALLS)
-    assert [
-        (call.request.method, call.request.url) for call in responses.calls
-    ] == BASE_API_CALLS
+def test_get_elements_element_arg_not_uuid(mocker, mock_elements_worker):
+    mocker.patch(
+        "arkindex_worker.worker.base.argparse.ArgumentParser.parse_args",
+        return_value=Namespace(
+            element=["volumeid", "pageid"],
+            config={},
+            verbose=False,
+            elements_list=None,
+            database=None,
+            dev=True,
+            set=[],
+        ),
+    )
+
+    worker = ElementsWorker()
+    worker.configure()
+
+    with pytest.raises(
+        Exception, match="These element IDs are invalid: volumeid, pageid"
+    ):
+        worker.get_elements()
+
+
+def test_get_elements_element_arg(mocker, mock_elements_worker):
+    mocker.patch(
+        "arkindex_worker.worker.base.argparse.ArgumentParser.parse_args",
+        return_value=Namespace(
+            element=[
+                "11111111-1111-1111-1111-111111111111",
+                "22222222-2222-2222-2222-222222222222",
+            ],
+            config={},
+            verbose=False,
+            elements_list=None,
+            database=None,
+            dev=True,
+            set=[],
+        ),
+    )
+
+    worker = ElementsWorker()
+    worker.configure()
+
+    elt_list = worker.get_elements()
+
+    assert elt_list == [
+        "11111111-1111-1111-1111-111111111111",
+        "22222222-2222-2222-2222-222222222222",
+    ]
+
+
+def test_get_elements_dataset_set_arg(responses, mocker, mock_elements_worker):
+    mocker.patch(
+        "arkindex_worker.worker.base.argparse.ArgumentParser.parse_args",
+        return_value=Namespace(
+            element=[],
+            config={},
+            verbose=False,
+            elements_list=None,
+            database=None,
+            dev=True,
+            set=[(UUID("11111111-1111-1111-1111-111111111111"), "train")],
+        ),
+    )
+
+    # Mock RetrieveDataset call
+    responses.add(
+        responses.GET,
+        "http://testserver/api/v1/datasets/11111111-1111-1111-1111-111111111111/",
+        status=200,
+        json={
+            "id": "11111111-1111-1111-1111-111111111111",
+            "name": "My dataset",
+            "description": "A dataset about cats.",
+            "sets": ["train", "dev", "test"],
+            "state": DatasetState.Complete.value,
+        },
+        content_type="application/json",
+    )
+
+    # Mock ListSetElements call
+    element = {
+        "id": "22222222-2222-2222-2222-222222222222",
+        "type": "page",
+        "name": "1",
+        "corpus": {
+            "id": "11111111-1111-1111-1111-111111111111",
+        },
+        "thumbnail_url": "http://example.com",
+        "zone": {
+            "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+            "polygon": [[0, 0], [0, 0], [0, 0]],
+            "image": {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "path": "string",
+                "width": 0,
+                "height": 0,
+                "url": "http://example.com",
+                "s3_url": "string",
+                "status": "checked",
+                "server": {
+                    "display_name": "string",
+                    "url": "http://example.com",
+                    "max_width": 2147483647,
+                    "max_height": 2147483647,
+                },
+            },
+            "url": "http://example.com",
+        },
+        "rotation_angle": 0,
+        "mirrored": False,
+        "created": "2019-08-24T14:15:22Z",
+        "classes": [
+            {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "ml_class": {
+                    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                    "name": "string",
+                },
+                "state": "pending",
+                "confidence": 0,
+                "high_confidence": True,
+                "worker_run": {
+                    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                    "summary": "string",
+                },
+            }
+        ],
+        "metadata": [
+            {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "type": "text",
+                "name": "string",
+                "value": "string",
+                "dates": [{"type": "exact", "year": 0, "month": 1, "day": 1}],
+            }
+        ],
+        "transcriptions": [
+            {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "text": "string",
+                "confidence": 0,
+                "orientation": "horizontal-lr",
+                "worker_run": {
+                    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                    "summary": "string",
+                },
+            }
+        ],
+        "has_children": True,
+        "worker_run": {
+            "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+            "summary": "string",
+        },
+        "confidence": 1,
+    }
+    responses.add(
+        responses.GET,
+        "http://testserver/api/v1/datasets/11111111-1111-1111-1111-111111111111/elements/?set=train&with_count=true",
+        status=200,
+        json={
+            "next": None,
+            "previous": None,
+            "results": [
+                {
+                    "set": "train",
+                    "element": element,
+                }
+            ],
+            "count": 1,
+        },
+        content_type="application/json",
+    )
+
+    worker = ElementsWorker()
+    worker.configure()
+
+    elt_list = worker.get_elements()
+
+    assert elt_list == [
+        Element(**element),
+    ]
+
+
+def test_get_elements_dataset_set_api(responses, mocker, mock_elements_worker):
+    # Mock ListProcessSets call
+    responses.add(
+        responses.GET,
+        "http://testserver/api/v1/process/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeffff/sets/",
+        status=200,
+        json={
+            "next": None,
+            "previous": None,
+            "results": [
+                {
+                    "id": "33333333-3333-3333-3333-333333333333",
+                    "dataset": {"id": "11111111-1111-1111-1111-111111111111"},
+                    "set_name": "train",
+                }
+            ],
+            "count": 1,
+        },
+        content_type="application/json",
+    )
+
+    # Mock ListSetElements call
+    element = {
+        "id": "22222222-2222-2222-2222-222222222222",
+        "type": "page",
+        "name": "1",
+        "corpus": {
+            "id": "11111111-1111-1111-1111-111111111111",
+        },
+        "thumbnail_url": "http://example.com",
+        "zone": {
+            "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+            "polygon": [[0, 0], [0, 0], [0, 0]],
+            "image": {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "path": "string",
+                "width": 0,
+                "height": 0,
+                "url": "http://example.com",
+                "s3_url": "string",
+                "status": "checked",
+                "server": {
+                    "display_name": "string",
+                    "url": "http://example.com",
+                    "max_width": 2147483647,
+                    "max_height": 2147483647,
+                },
+            },
+            "url": "http://example.com",
+        },
+        "rotation_angle": 0,
+        "mirrored": False,
+        "created": "2019-08-24T14:15:22Z",
+        "classes": [
+            {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "ml_class": {
+                    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                    "name": "string",
+                },
+                "state": "pending",
+                "confidence": 0,
+                "high_confidence": True,
+                "worker_run": {
+                    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                    "summary": "string",
+                },
+            }
+        ],
+        "metadata": [
+            {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "type": "text",
+                "name": "string",
+                "value": "string",
+                "dates": [{"type": "exact", "year": 0, "month": 1, "day": 1}],
+            }
+        ],
+        "transcriptions": [
+            {
+                "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                "text": "string",
+                "confidence": 0,
+                "orientation": "horizontal-lr",
+                "worker_run": {
+                    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+                    "summary": "string",
+                },
+            }
+        ],
+        "has_children": True,
+        "worker_run": {
+            "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
+            "summary": "string",
+        },
+        "confidence": 1,
+    }
+    responses.add(
+        responses.GET,
+        "http://testserver/api/v1/datasets/11111111-1111-1111-1111-111111111111/elements/?set=train&with_count=true",
+        status=200,
+        json={
+            "next": None,
+            "previous": None,
+            "results": [
+                {
+                    "set": "train",
+                    "element": element,
+                }
+            ],
+            "count": 1,
+        },
+        content_type="application/json",
+    )
+
+    # Update ProcessMode to Dataset
+    mock_elements_worker.process_information["mode"] = ProcessMode.Dataset
+
+    elt_list = mock_elements_worker.get_elements()
+
+    assert elt_list == [
+        Element(**element),
+    ]
+
+
+def test_get_elements_both_args_error(mocker, mock_elements_worker, tmp_path):
+    elements_path = tmp_path / "elements.json"
+    elements_path.write_text(
+        json.dumps(
+            [
+                {"id": "volumeid", "type": "volume"},
+                {"id": "pageid", "type": "page"},
+                {"id": "actid", "type": "act"},
+                {"id": "surfaceid", "type": "surface"},
+            ]
+        )
+    )
+    mocker.patch(
+        "arkindex_worker.worker.base.argparse.ArgumentParser.parse_args",
+        return_value=Namespace(
+            element=["anotherid", "againanotherid"],
+            verbose=False,
+            elements_list=elements_path.open(),
+            database=None,
+            dev=False,
+            set=[],
+        ),
+    )
+
+    worker = ElementsWorker()
+    worker.configure()
+
+    with pytest.raises(
+        AssertionError, match="elements-list and element CLI args shouldn't be both set"
+    ):
+        worker.get_elements()
+
+
+def test_get_elements_export_process(mock_elements_worker, responses):
+    responses.add(
+        responses.GET,
+        f"http://testserver/api/v1/process/{PROCESS_ID}/elements/?page_size=500&with_count=true&with_image=False",
+        status=200,
+        json={
+            "count": 2,
+            "next": None,
+            "results": [
+                {
+                    "id": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+                    "type_id": "baaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+                    "name": "element 1",
+                    "confidence": 1,
+                    "image_id": None,
+                    "image_width": None,
+                    "image_height": None,
+                    "image_url": None,
+                    "polygon": None,
+                    "rotation_angle": 0,
+                    "mirrored": False,
+                },
+                {
+                    "id": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaa0",
+                    "type_id": "baaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+                    "name": "element 2",
+                    "confidence": 1,
+                    "image_id": None,
+                    "image_width": None,
+                    "image_height": None,
+                    "image_url": None,
+                    "polygon": None,
+                    "rotation_angle": 0,
+                    "mirrored": False,
+                },
+            ],
+        },
+    )
+    mock_elements_worker.process_information["mode"] = "export"
+    assert set(mock_elements_worker.get_elements()) == {
+        "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+        "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaa0",
+    }
 
 
 @pytest.mark.usefixtures("_mock_worker_run_api")
@@ -114,43 +598,6 @@ def test_activities_dev_mode(mocker):
     assert worker.store_activity is False
 
 
-@pytest.mark.usefixtures("_mock_worker_run_api")
-def test_update_call(responses, mock_elements_worker):
-    """Test an update call with feature enabled triggers an API call"""
-    responses.add(
-        responses.PUT,
-        "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
-        status=200,
-        json={
-            "element_id": "1234-deadbeef",
-            "process_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeffff",
-            "state": "processed",
-        },
-    )
-
-    out = mock_elements_worker.update_activity("1234-deadbeef", ActivityState.Processed)
-
-    # Check the response received by worker
-    assert out is 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 + [
-        (
-            "PUT",
-            "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
-        ),
-    ]
-
-    # Check the request sent by worker
-    assert json.loads(responses.calls[-1].request.body) == {
-        "element_id": "1234-deadbeef",
-        "process_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeffff",
-        "state": "processed",
-    }
-
-
 @pytest.mark.usefixtures("_mock_activity_calls")
 @pytest.mark.parametrize(
     ("process_exception", "final_state"),
@@ -239,7 +686,7 @@ def test_run_cache(monkeypatch, mocker, mock_elements_worker_with_cache):
 
 
 def test_start_activity_conflict(
-    monkeypatch, responses, mocker, mock_elements_worker_with_list
+    monkeypatch, responses, mock_elements_worker_with_list, caplog
 ):
     # Disable second configure call from run()
     monkeypatch.setattr(mock_elements_worker_with_list, "configure", lambda: None)
@@ -254,9 +701,6 @@ def test_start_activity_conflict(
             content="Either this activity does not exists or this state is not allowed.",
         ),
     )
-    from arkindex_worker.worker import logger
-
-    logger.info = mocker.MagicMock()
 
     mock_elements_worker_with_list.run()
 
@@ -270,14 +714,15 @@ def test_start_activity_conflict(
             "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
         ),
     ]
-    assert logger.info.call_args_list[:2] == [
-        mocker.call("Processing page Test Page n°1 (1234-deadbeef) (1/1)"),
-        mocker.call("Skipping element 1234-deadbeef as it was already processed"),
+    assert [(record.levelno, record.message) for record in caplog.records] == [
+        (logging.INFO, "Processing page Test Page n°1 (1234-deadbeef) (1/1)"),
+        (logging.INFO, "Skipping element 1234-deadbeef as it was already processed"),
+        (logging.INFO, "Ran on 1 element: 1 completed, 0 failed"),
     ]
 
 
 def test_start_activity_error(
-    monkeypatch, responses, mocker, mock_elements_worker_with_list
+    monkeypatch, responses, mock_elements_worker_with_list, caplog
 ):
     # Disable second configure call from run()
     monkeypatch.setattr(mock_elements_worker_with_list, "configure", lambda: None)
@@ -286,11 +731,8 @@ def test_start_activity_error(
     responses.add(
         responses.PUT,
         "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
-        body=Exception("A wild Petilil appears !"),
+        body=Exception("A wild Petilil appears!"),
     )
-    from arkindex_worker.worker import logger
-
-    logger.error = mocker.MagicMock()
 
     with pytest.raises(SystemExit):
         mock_elements_worker_with_list.run()
@@ -309,205 +751,48 @@ def test_start_activity_error(
             "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
         ),
     ]
-    assert logger.error.call_args_list == [
-        mocker.call("Ran on 1 element: 0 completed, 1 failed")
-    ]
-
-
-@pytest.mark.parametrize(
-    (
-        "wk_version_config",
-        "wk_version_user_config",
-        "frontend_user_config",
-        "model_config",
-        "expected_config",
-    ),
-    [
-        ({}, {}, {}, {}, {}),
-        # Keep parameters from worker version configuration
-        ({"parameter": 0}, {}, {}, {}, {"parameter": 0}),
-        # Keep parameters from worker version configuration + user_config defaults
+    assert [(record.levelno, record.message) for record in caplog.records] == [
+        (logging.INFO, "Processing page Test Page n°1 (1234-deadbeef) (1/1)"),
         (
-            {"parameter": 0},
-            {
-                "parameter2": {
-                    "type": "int",
-                    "title": "Lambda",
-                    "default": 0,
-                    "required": False,
-                }
-            },
-            {},
-            {},
-            {"parameter": 0, "parameter2": 0},
+            logging.WARNING,
+            "Failed running worker on element 1234-deadbeef: Exception('A wild Petilil appears!')",
         ),
-        # Keep parameters from worker version configuration + user_config no defaults
-        (
-            {"parameter": 0},
-            {
-                "parameter2": {
-                    "type": "int",
-                    "title": "Lambda",
-                    "required": False,
-                }
-            },
-            {},
-            {},
-            {"parameter": 0},
-        ),
-        # Keep parameters from worker version configuration but user_config defaults overrides
-        (
-            {"parameter": 0},
-            {
-                "parameter": {
-                    "type": "int",
-                    "title": "Lambda",
-                    "default": 1,
-                    "required": False,
-                }
-            },
-            {},
-            {},
-            {"parameter": 1},
-        ),
-        # Keep parameters from worker version configuration + frontend config
-        (
-            {"parameter": 0},
-            {},
-            {"parameter2": 0},
-            {},
-            {"parameter": 0, "parameter2": 0},
-        ),
-        # Keep parameters from worker version configuration + frontend config overrides
-        ({"parameter": 0}, {}, {"parameter": 1}, {}, {"parameter": 1}),
-        # Keep parameters from worker version configuration + model config
-        (
-            {"parameter": 0},
-            {},
-            {},
-            {"parameter2": 0},
-            {"parameter": 0, "parameter2": 0},
-        ),
-        # Keep parameters from worker version configuration + model config overrides
-        ({"parameter": 0}, {}, {}, {"parameter": 1}, {"parameter": 1}),
-        # Keep parameters from worker version configuration + user_config default + model config overrides
-        (
-            {"parameter": 0},
-            {
-                "parameter": {
-                    "type": "int",
-                    "title": "Lambda",
-                    "default": 1,
-                    "required": False,
-                }
-            },
-            {},
-            {"parameter": 2},
-            {"parameter": 2},
-        ),
-        # Keep parameters from worker version configuration + model config + frontend config overrides
-        ({"parameter": 0}, {}, {"parameter": 2}, {"parameter": 1}, {"parameter": 2}),
-        # Keep parameters from worker version configuration + user_config default + model config + frontend config overrides all
-        (
-            {"parameter": 0},
-            {
-                "parameter": {
-                    "type": "int",
-                    "title": "Lambda",
-                    "default": 1,
-                    "required": False,
-                }
-            },
-            {"parameter": 3},
-            {"parameter": 2},
-            {"parameter": 3},
-        ),
-    ],
-)
-def test_worker_config_multiple_source(
-    monkeypatch,
-    responses,
-    wk_version_config,
-    wk_version_user_config,
-    frontend_user_config,
-    model_config,
-    expected_config,
-):
-    # Compute WorkerRun info
-    payload = {
-        "id": "56785678-5678-5678-5678-567856785678",
-        "parents": [],
-        "worker_version": {
-            "id": "12341234-1234-1234-1234-123412341234",
-            "configuration": {
-                "docker": {"image": "python:3"},
-                "configuration": wk_version_config,
-                "secrets": [],
-                "user_configuration": wk_version_user_config,
-            },
-            "revision": {
-                "hash": "deadbeef1234",
-                "name": "some git revision",
-            },
-            "docker_image": "python:3",
-            "docker_image_name": "python:3",
-            "state": "created",
-            "worker": {
-                "id": "deadbeef-1234-5678-1234-worker",
-                "name": "Fake worker",
-                "slug": "fake_worker",
-                "type": "classifier",
-            },
-        },
-        "configuration": {
-            "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
-            "name": "Configuration entered by user",
-            "configuration": frontend_user_config,
-        },
-        "model_version": {
-            "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,
-            "id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeffff",
-            "state": "running",
-            "mode": "workers",
-            "corpus": "11111111-1111-1111-1111-111111111111",
-            "use_cache": False,
-            "activity_state": "ready",
-            "model_id": None,
-            "train_folder_id": None,
-            "validation_folder_id": None,
-            "test_folder_id": None,
-        },
-        "summary": "Worker Fake worker @ 123412",
-    }
+        (logging.ERROR, "Ran on 1 element: 0 completed, 1 failed"),
+    ]
+
 
+@pytest.mark.usefixtures("_mock_worker_run_api")
+def test_update_activity(responses, mock_elements_worker):
+    """Test an update call with feature enabled triggers an API call"""
     responses.add(
-        responses.GET,
-        "http://testserver/api/v1/process/workers/56785678-5678-5678-5678-567856785678/",
+        responses.PUT,
+        "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
         status=200,
-        body=json.dumps(payload),
-        content_type="application/json",
+        json={
+            "element_id": "1234-deadbeef",
+            "process_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeffff",
+            "state": "processed",
+        },
     )
 
-    # Create and configure a worker
-    monkeypatch.setattr(sys, "argv", ["worker"])
-    worker = ElementsWorker()
-    worker.configure()
+    out = mock_elements_worker.update_activity("1234-deadbeef", ActivityState.Processed)
 
-    # Do what people do with a model configuration
-    if worker.model_configuration:
-        worker.config.update(worker.model_configuration)
+    # Check the response received by worker
+    assert out is True
 
-    if worker.user_configuration:
-        worker.config.update(worker.user_configuration)
+    assert len(responses.calls) == len(BASE_API_CALLS) + 1
+    assert [
+        (call.request.method, call.request.url) for call in responses.calls
+    ] == BASE_API_CALLS + [
+        (
+            "PUT",
+            "http://testserver/api/v1/workers/versions/56785678-5678-5678-5678-567856785678/activity/",
+        ),
+    ]
 
-    # Check final config
-    assert worker.config == expected_config
+    # Check the request sent by worker
+    assert json.loads(responses.calls[-1].request.body) == {
+        "element_id": "1234-deadbeef",
+        "process_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeffff",
+        "state": "processed",
+    }