refactor(tests): processor using default config

Author: gmcrocetti

tests/functional/test_utilities_batch.py

@@ -1,12 +1,13 @@
 from typing import Callable
 
 import pytest
+from botocore.config import Config
 from botocore.stub import Stubber
 
 from aws_lambda_powertools.utilities.batch import PartialSQSProcessor, partial_sqs_processor
 
 
-@pytest.fixture
+@pytest.fixture(scope="module")
 def sqs_event_factory() -> Callable:
     def factory(body: str):
         return {
@@ -24,7 +25,7 @@ def factory(body: str):
     return factory
 
 
-@pytest.fixture
+@pytest.fixture(scope="module")
 def record_handler() -> Callable:
     def handler(record):
         body = record["body"]
@@ -35,11 +36,20 @@ def handler(record):
     return handler
 
 
-def test_partial_sqs_processor_context_with_failure(sqs_event_factory, record_handler):
+@pytest.fixture(scope="module")
+def config() -> Config:
+    return Config(region_name="us-east-1")
+
+
+@pytest.fixture(scope="function")
+def partial_processor(config) -> PartialSQSProcessor:
+    return PartialSQSProcessor(config=config)
+
+
+def test_partial_sqs_processor_context_with_failure(sqs_event_factory, record_handler, partial_processor):
     """
     Test processor with one failing record
     """
-    processor = PartialSQSProcessor()
 
     fail_record = sqs_event_factory("fail")
     success_record = sqs_event_factory("success")
@@ -48,10 +58,10 @@ def test_partial_sqs_processor_context_with_failure(sqs_event_factory, record_ha
 
     response = {"Successful": [{"Id": fail_record["messageId"]}], "Failed": []}
 
-    with Stubber(processor.client) as stubber:
+    with Stubber(partial_processor.client) as stubber:
         stubber.add_response("delete_message_batch", response)
 
-        with processor(records, record_handler) as ctx:
+        with partial_processor(records, record_handler) as ctx:
             result = ctx.process()
 
         stubber.assert_no_pending_responses()
@@ -62,19 +72,17 @@ def test_partial_sqs_processor_context_with_failure(sqs_event_factory, record_ha
     ]
 
 
-def test_partial_sqs_processor_context_only_success(sqs_event_factory, record_handler):
+def test_partial_sqs_processor_context_only_success(sqs_event_factory, record_handler, partial_processor):
     """
     Test processor without failure
     """
 
-    processor = PartialSQSProcessor()
-
     first_record = sqs_event_factory("success")
     second_record = sqs_event_factory("success")
 
     records = [first_record, second_record]
 
-    with processor(records, record_handler) as ctx:
+    with partial_processor(records, record_handler) as ctx:
         result = ctx.process()
 
     assert result == [
@@ -83,35 +91,31 @@ def test_partial_sqs_processor_context_only_success(sqs_event_factory, record_ha
     ]
 
 
-def test_partial_sqs_processor_context_multiple_calls(sqs_event_factory, record_handler):
+def test_partial_sqs_processor_context_multiple_calls(sqs_event_factory, record_handler, partial_processor):
     """
     Test processor without failure
     """
 
-    processor = PartialSQSProcessor()
-
     first_record = sqs_event_factory("success")
     second_record = sqs_event_factory("success")
 
     records = [first_record, second_record]
 
-    with processor(records, record_handler) as ctx:
+    with partial_processor(records, record_handler) as ctx:
         ctx.process()
 
-    with processor([first_record], record_handler) as ctx:
+    with partial_processor([first_record], record_handler) as ctx:
         ctx.process()
 
-    assert processor.success_messages == [first_record]
+    assert partial_processor.success_messages == [first_record]
 
 
-def test_partial_sqs_processor_middleware_with_default(sqs_event_factory, record_handler):
+def test_partial_sqs_processor_middleware_with_default(sqs_event_factory, record_handler, partial_processor):
     """
     Test middleware with default partial processor
     """
 
-    processor = PartialSQSProcessor()
-
-    @partial_sqs_processor(record_handler=record_handler, processor=processor)
+    @partial_sqs_processor(record_handler=record_handler, processor=partial_processor)
     def lambda_handler(event, context):
         return True
 
@@ -120,7 +124,7 @@ def lambda_handler(event, context):
     event = {"Records": [sqs_event_factory("fail"), sqs_event_factory("success")]}
     response = {"Successful": [{"Id": fail_record["messageId"]}], "Failed": []}
 
-    with Stubber(processor.client) as stubber:
+    with Stubber(partial_processor.client) as stubber:
         stubber.add_response("delete_message_batch", response)
 
         result = lambda_handler(event, {})
@@ -130,7 +134,7 @@ def lambda_handler(event, context):
     assert result is True
 
 
-def test_partial_sqs_processor_middleware_with_custom(capsys, sqs_event_factory, record_handler):
+def test_partial_sqs_processor_middleware_with_custom(capsys, sqs_event_factory, record_handler, config):
     """
     Test middle with custom partial processor
     """
@@ -140,7 +144,7 @@ def failure_handler(self, record, exception):
             print("Oh no ! It's a failure.")
             return super().failure_handler(record, exception)
 
-    processor = CustomProcessor()
+    processor = CustomProcessor(config=config)
 
     @partial_sqs_processor(record_handler=record_handler, processor=processor)
     def lambda_handler(event, context):

tests/unit/test_utilities_batch.py

@@ -1,9 +1,10 @@
 import pytest
+from botocore.config import Config
 
 from aws_lambda_powertools.utilities.batch import PartialSQSProcessor
 
 
-@pytest.fixture(scope="module")
+@pytest.fixture(scope="function")
 def sqs_event():
     return {
         "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
@@ -18,47 +19,57 @@ def sqs_event():
     }
 
 
-def test_partial_sqs_get_queue_url_with_records(mocker, sqs_event):
+@pytest.fixture(scope="module")
+def config() -> Config:
+    return Config(region_name="us-east-1")
+
+
+@pytest.fixture(scope="function")
+def partial_sqs_processor(config) -> PartialSQSProcessor:
+    return PartialSQSProcessor(config=config)
+
+
+def test_partial_sqs_get_queue_url_with_records(mocker, sqs_event, partial_sqs_processor):
     expected_url = "https://queue.amazonaws.com/123456789012/my-queue"
 
     records_mock = mocker.patch.object(PartialSQSProcessor, "records", create=True, new_callable=mocker.PropertyMock)
     records_mock.return_value = [sqs_event]
 
-    result = PartialSQSProcessor().get_queue_url()
+    result = partial_sqs_processor.get_queue_url()
     assert result == expected_url
 
 
-def test_partial_sqs_get_queue_url_without_records():
-    assert PartialSQSProcessor().get_queue_url() is None
+def test_partial_sqs_get_queue_url_without_records(partial_sqs_processor):
+    assert partial_sqs_processor.get_queue_url() is None
 
 
-def test_partial_sqs_get_entries_to_clean_with_success(mocker, sqs_event):
+def test_partial_sqs_get_entries_to_clean_with_success(mocker, sqs_event, partial_sqs_processor):
     expected_entries = [{"Id": sqs_event["messageId"], "ReceiptHandle": sqs_event["receiptHandle"]}]
 
     success_messages_mock = mocker.patch.object(
         PartialSQSProcessor, "success_messages", new_callable=mocker.PropertyMock
     )
     success_messages_mock.return_value = [sqs_event]
 
-    result = PartialSQSProcessor().get_entries_to_clean()
+    result = partial_sqs_processor.get_entries_to_clean()
 
     assert result == expected_entries
 
 
-def test_partial_sqs_get_entries_to_clean_without_success(mocker):
+def test_partial_sqs_get_entries_to_clean_without_success(mocker, partial_sqs_processor):
     expected_entries = []
 
     success_messages_mock = mocker.patch.object(
         PartialSQSProcessor, "success_messages", new_callable=mocker.PropertyMock
     )
     success_messages_mock.return_value = []
 
-    result = PartialSQSProcessor().get_entries_to_clean()
+    result = partial_sqs_processor.get_entries_to_clean()
 
     assert result == expected_entries
 
 
-def test_partial_sqs_process_record_success(mocker):
+def test_partial_sqs_process_record_success(mocker, partial_sqs_processor):
     expected_value = mocker.sentinel.expected_value
 
     success_result = mocker.sentinel.success_result
@@ -67,15 +78,15 @@ def test_partial_sqs_process_record_success(mocker):
     handler_mock = mocker.patch.object(PartialSQSProcessor, "handler", create=True, return_value=success_result)
     success_handler_mock = mocker.patch.object(PartialSQSProcessor, "success_handler", return_value=expected_value)
 
-    result = PartialSQSProcessor()._process_record(record)
+    result = partial_sqs_processor._process_record(record)
 
     handler_mock.assert_called_once_with(record)
     success_handler_mock.assert_called_once_with(record, success_result)
 
     assert result == expected_value
 
 
-def test_partial_sqs_process_record_failure(mocker):
+def test_partial_sqs_process_record_failure(mocker, partial_sqs_processor):
     expected_value = mocker.sentinel.expected_value
 
     failure_result = Exception()
@@ -84,42 +95,39 @@ def test_partial_sqs_process_record_failure(mocker):
     handler_mock = mocker.patch.object(PartialSQSProcessor, "handler", create=True, side_effect=failure_result)
     failure_handler_mock = mocker.patch.object(PartialSQSProcessor, "failure_handler", return_value=expected_value)
 
-    result = PartialSQSProcessor()._process_record(record)
+    result = partial_sqs_processor._process_record(record)
 
     handler_mock.assert_called_once_with(record)
     failure_handler_mock.assert_called_once_with(record, failure_result)
 
     assert result == expected_value
 
 
-def test_partial_sqs_prepare(mocker):
-    processor = PartialSQSProcessor()
-
-    success_messages_mock = mocker.patch.object(processor, "success_messages", spec=list)
-    failed_messages_mock = mocker.patch.object(processor, "fail_messages", spec=list)
+def test_partial_sqs_prepare(mocker, partial_sqs_processor):
+    success_messages_mock = mocker.patch.object(partial_sqs_processor, "success_messages", spec=list)
+    failed_messages_mock = mocker.patch.object(partial_sqs_processor, "fail_messages", spec=list)
 
-    processor._prepare()
+    partial_sqs_processor._prepare()
 
     success_messages_mock.clear.assert_called_once()
     failed_messages_mock.clear.assert_called_once()
 
 
-def test_partial_sqs_clean(monkeypatch, mocker):
-    processor = PartialSQSProcessor()
+def test_partial_sqs_clean(monkeypatch, mocker, partial_sqs_processor):
     records = [mocker.sentinel.record]
 
-    monkeypatch.setattr(processor, "fail_messages", records)
-    monkeypatch.setattr(processor, "success_messages", records)
+    monkeypatch.setattr(partial_sqs_processor, "fail_messages", records)
+    monkeypatch.setattr(partial_sqs_processor, "success_messages", records)
 
     queue_url_mock = mocker.patch.object(PartialSQSProcessor, "get_queue_url")
     entries_to_clean_mock = mocker.patch.object(PartialSQSProcessor, "get_entries_to_clean")
 
     queue_url_mock.return_value = mocker.sentinel.queue_url
     entries_to_clean_mock.return_value = mocker.sentinel.entries_to_clean
 
-    client_mock = mocker.patch.object(processor, "client", autospec=True)
+    client_mock = mocker.patch.object(partial_sqs_processor, "client", autospec=True)
 
-    processor._clean()
+    partial_sqs_processor._clean()
 
     client_mock.delete_message_batch.assert_called_once_with(
         QueueUrl=mocker.sentinel.queue_url, Entries=mocker.sentinel.entries_to_clean