updated tests to match new interface

shared/datastore/tests/integration/base_crud_test.py

@@ -7,7 +7,7 @@ from io import BytesIO
 import minio
 import pytest
 
-from shared.datastore import delete, get, put
+from shared.datastore import Datastore
 
 
 def same_data(
@@ -39,77 +39,72 @@ def same_data(
 
 
 def test_should_get_data(
-    minio_client,
+    datastore: Datastore,
     data_in_minio,
 ):
-    data, bucket_name, object_name = data_in_minio
+    # ARRANGE
-    received_data = get(
+    data, _, object_name = data_in_minio
-        client=minio_client,
+    # ACT
-        bucket_name=bucket_name,
+    received_data = datastore._get(
         object_name=object_name,
     )
-
+    # ASSERT
     assert isinstance(data, BytesIO)
     assert same_data(data, received_data)
 
 
 def test_should_delete_data(
-    minio_client,
+    datastore: Datastore,
     data_in_minio,
 ):
-    _, bucket_name, object_name = data_in_minio
+    # ARRANGE
-    delete(
+    _, _, object_name = data_in_minio
-        client=minio_client,
+    # ACT
-        bucket_name=bucket_name,
+    datastore._delete(
         object_name=object_name,
     )
+    # ASSERT
     with pytest.raises(minio.error.S3Error):
-        _ = get(
+        _ = datastore._get(
-            client=minio_client,
-            bucket_name=bucket_name,
             object_name=object_name,
         )
 
 
 def test_should_put_data(
-    minio_client,
+    datastore: Datastore,
     data,
 ):
-    # prepare variables
+    # ARRANGE
-    minio_bucket_name = str(os.getenv('MINIO_BUCKET_NAME'))
     minio_object_name = str(os.getenv('MINIO_OBJECT_NAME'))
     buffer = BytesIO(data)
-    put(
+    # ACT
-        client=minio_client,
+    datastore._put(
+        object_name=minio_object_name,
         buffer=buffer,
-        bucket_name=minio_bucket_name,
-        object_name=minio_object_name,
     )
-    received_data = get(
+    received_data = datastore._get(
-        client=minio_client,
-        bucket_name=minio_bucket_name,
         object_name=minio_object_name,
     )
+    # ASSERT
     assert isinstance(received_data, BytesIO)
     assert same_data(received_data, buffer)
 
 
 def test_should_update_data(
-    minio_client,
+    datastore: Datastore,
     data_in_minio,
 ):
-    buffer, bucket_name, object_name = data_in_minio
+    # ARRANGE
-    put(
+    buffer, _, object_name = data_in_minio
-        client=minio_client,
+    # ACT
+    datastore._put(
+        object_name=object_name,
         buffer=buffer,
-        bucket_name=bucket_name,
-        object_name=object_name,
     )
-    received_data = get(
+    received_data = datastore._get(
-        client=minio_client,
-        bucket_name=bucket_name,
         object_name=object_name,
     )
+    # ASSERT
     assert same_data(received_data, buffer)
 
 

shared/datastore/tests/integration/conftest.py

@@ -3,14 +3,18 @@
 import os
 import random
 from collections.abc import Iterator
+from hashlib import md5
 from io import BytesIO
 from pathlib import Path
 
 import pytest
+import torch
 from dotenv import load_dotenv
-from minio import Minio
 from PIL import Image
 
+from model.src.models import VisualCommunicationModel
+from shared.datastore import Datastore
+
 env_var_map = {
     'MINIO_BUCKET_NAME': 'test-bucket',
     'MINIO_OBJECT_NAME': '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX',
@@ -39,35 +43,34 @@ def populate_env(
 
 
 @pytest.fixture(scope='session')
-def minio_client(
+def datastore(
     populate_env,
-) -> Iterator[Minio]:
+) -> Iterator[Datastore]:
     # prepare arguments
-    minio_endpoint = str(os.getenv('MINIO_ENDPOINT'))
-    minio_access_key = str(os.getenv('MINIO_ACCESS_KEY'))
-    minio_secret_key = str(os.getenv('MINIO_SECRET_KEY'))
     minio_bucket_name = str(os.getenv('MINIO_BUCKET_NAME'))
     # connect to minio
-    client = Minio(
+    datastore_client = Datastore()
-        endpoint=minio_endpoint,
+    datastore_client.connect()
-        access_key=minio_access_key,
+    assert datastore_client._client is not None
-        secret_key=minio_secret_key,
-        secure=False,
-    )
     # ensure bucket exists
-    if not client.bucket_exists(bucket_name=minio_bucket_name):
+    if not datastore_client._client.bucket_exists(bucket_name=minio_bucket_name):
-        client.make_bucket(bucket_name=minio_bucket_name)
+        datastore_client._client.make_bucket(bucket_name=minio_bucket_name)
     # expose client
-    yield client
+    yield datastore_client
     # remove objects left behind by tests
-    for obj in client.list_objects(bucket_name=minio_bucket_name, recursive=True):
+    for obj in datastore_client._client.list_objects(
-        client.remove_object(
+        bucket_name=minio_bucket_name,
+        recursive=True,
+    ):
+        datastore_client._client.remove_object(
             bucket_name=obj.bucket_name,
             object_name=obj.object_name,
         )
     # remove bucket
-    client.remove_bucket(bucket_name=minio_bucket_name)
+    datastore_client._client.remove_bucket(bucket_name=minio_bucket_name)
-    assert not client.bucket_exists(bucket_name=minio_bucket_name)
+    assert not datastore_client._client.bucket_exists(bucket_name=minio_bucket_name)
+    # disconnect from minio
+    datastore_client.close()
 
 
 @pytest.fixture
@@ -81,9 +84,10 @@ def data() -> Iterator[bytes]:
 
 @pytest.fixture
 def data_in_minio(
-    minio_client,
+    datastore: Datastore,
-    data,
+    data: bytes,
 ) -> Iterator[tuple[BytesIO, str, str]]:
+    assert datastore._client is not None
     # prepare arguments
     minio_bucket_name = str(os.getenv('MINIO_BUCKET_NAME'))
     minio_object_name = str(os.getenv('MINIO_OBJECT_NAME'))
@@ -93,7 +97,7 @@ def data_in_minio(
     num_bytes = len(buffer.getvalue())
     buffer.seek(0)
     # send data to bucket
-    minio_client.put_object(
+    datastore._client.put_object(
         bucket_name=minio_bucket_name,
         object_name=minio_object_name,
         length=num_bytes,
@@ -102,7 +106,7 @@ def data_in_minio(
     # expose data
     yield buffer, minio_bucket_name, minio_object_name
     # clean up
-    minio_client.remove_object(
+    datastore._client.remove_object(
         bucket_name=minio_bucket_name,
         object_name=minio_object_name,
     )
@@ -116,13 +120,77 @@ def image() -> Iterator[Image.Image]:
     yield image
 
 
-# @pytest.fixture
+@pytest.fixture
-# def image_in_minio(
+def image_in_minio(
-#     image: Image.Image,
+    datastore: Datastore,
-# ) -> tuple(Image.Image, str):
+    image: Image.Image,
-#     #
+) -> Iterator[tuple[Image.Image, str]]:
+    assert datastore._client is not None
+    # prepare arguments
+    minio_bucket_name = str(os.getenv('MINIO_BUCKET_NAME'))
+    # save data to buffer
+    buffer = BytesIO()
+    image.save(buffer, 'png')
+    # get md5 of buffer
+    checksum = md5(buffer.getbuffer()).hexdigest()
+    # build object path
+    object_path = f'images/{checksum}'
+    # prepare for saving
+    num_bytes = len(buffer.getvalue())
+    buffer.seek(0)
+    # send data to bucket
+    datastore._client.put_object(
+        bucket_name=minio_bucket_name,
+        object_name=object_path,
+        length=num_bytes,
+        data=buffer,
+    )
+    # expose image and object name
+    yield image, checksum
+    # cleanup
+    datastore._client.remove_object(
+        bucket_name=minio_bucket_name,
+        object_name=object_path,
+    )
 
 
-#     # expose image and object name
+@pytest.fixture
-#     yield image, object_name
+def model() -> Iterator[torch.nn.Module]:
-#     # cleanup
+    # generate model
+    model = VisualCommunicationModel().to('cpu')
+    # expose model
+    yield model
+
+
+@pytest.fixture
+def model_in_minio(
+    datastore: Datastore,
+    model: torch.nn.Module,
+) -> Iterator[tuple[torch.nn.Module, str]]:
+    assert datastore._client is not None
+    # prepare arguments
+    minio_bucket_name = str(os.getenv('MINIO_BUCKET_NAME'))
+    # save data to buffer
+    buffer = BytesIO()
+    torch.save(model.state_dict(), buffer)
+    # get md5 of image
+    checksum = md5(buffer.getbuffer()).hexdigest()
+    # build object path
+    object_path = f'models/{checksum}'
+    # prepare for saving
+    num_bytes = len(buffer.getvalue())
+    buffer.seek(0)
+    # send data to bucket
+    datastore._client.put_object(
+        bucket_name=minio_bucket_name,
+        object_name=object_path,
+        length=num_bytes,
+        data=buffer,
+    )
+    # expose model and object name
+    yield model, checksum
+    # cleanup
+    datastore._client.remove_object(
+        bucket_name=minio_bucket_name,
+        object_name=object_path,
+    )

shared/datastore/tests/integration/connect_test.py

@@ -2,9 +2,9 @@
 
 from minio import Minio
 
-from shared.datastore import connect_minio
+from shared.datastore import Datastore
 
 
 def test_should_return_correct_type():
-    client = connect_minio()
+    with Datastore() as ds:
-    assert isinstance(client, Minio)
+        assert isinstance(ds._client, Minio)

shared/datastore/tests/integration/image_crud_test.py

@@ -1,9 +1,10 @@
 """Integration tests related to image CRUD."""
 
 import numpy as np
+import pytest
 from PIL import Image
 
-# from shared.datastore import connect_minio, get_image, put_image
+from shared.datastore import Datastore
 
 
 def same_image(
@@ -25,49 +26,57 @@ def same_image(
     return True
 
 
-# def test_should_get_image(
+def test_should_get_image(
-#     image_in_minio,
+    datastore: Datastore,
-# ):
+    image_in_minio: tuple[Image.Image, str],
-#     image, object_name = image_in_minio
+):
-#     client = connect_minio()
+    # ARRANGE
-#     received_image = get_image(
+    image, object_name = image_in_minio
-#         client=client,
+    # ACT
-#         object_name=object_name,
+    received_image = datastore.get_image(
-#     )
+        object_name=object_name,
-#     assert isinstance(image, Image.Image)
+    )
-#     assert received_image == image
+    # ASSERT
+    assert isinstance(image, Image.Image)
+    assert same_image(image, received_image)
 
 
-# def test_should_put_image(
+def test_should_put_image(
-#     image,
+    datastore: Datastore,
-# ):
+    image: Image.Image,
-#     client = connect_minio()
+):
-#     object_name = put_image(
+    # ARRANGE
-#         client=client,
+    object_name = datastore.put_image(
-#         image=image,
+        image=image,
-#     )
+    )
-#     assert isinstance(object_name, str)
+    assert isinstance(object_name, str)
-#     assert len(object_name) > 0
+    assert len(object_name) > 0
-#     received_image = get_image(
+    # ACT
-#         client=client,
+    received_image = datastore.get_image(
-#         object_name=object_name,
+        object_name=object_name,
-#     )
+    )
-#     assert same_image(received_image, image)
+    # ASSERT
+    assert same_image(image, received_image)
 
 
-# def test_should_update_image(
+def test_should_update_image(
-#     image_in_minio,
+    datastore: Datastore,
-# ):
+    image_in_minio: tuple[Image.Image, str],
-#     image, object_name = image_in_minio
+):
-#     client = connect_minio()
+    # ARRANGE
-#     object_name = put_image(
+    image, object_name = image_in_minio
-#         client=client,
+    object_name = datastore.put_image(
-#         image=image,
+        image=image,
-#     )
+    )
-#     assert isinstance(object_name, str)
+    assert isinstance(object_name, str)
-#     assert len(object_name) > 0
+    assert len(object_name) > 0
-#     received_image = get_image(
+    # ACT
-#         client=client,
+    received_image = datastore.get_image(
-#         object_name=object_name,
+        object_name=object_name,
-#     )
+    )
-#     assert received_image == image
+    # ASSERT
+    assert same_image(image, received_image)
+
+
+if __name__ == '__main__':
+    pytest.main()

shared/datastore/tests/integration/model_crud_test.py

@@ -1,52 +1,90 @@
 """Integration tests related to model CRUD."""
 
-# from torch.nn import Module
+from collections import OrderedDict
 
-# from shared.datastore import connect_minio, get_model, put_model
+from torch.nn import Module
 
-# def test_should_get_model(
+from model.src.models import VisualCommunicationModel
-#     model_in_minio,
+from shared.datastore import Datastore
-# ):
-#     model, object_name = model_in_minio
-#     client = connect_minio()
-#     received_model = get_model(
-#         client=client,
-#         object_name=object_name,
-#     )
-#     assert isinstance(model, Module)
-#     assert received_model == model
 
 
-# def test_should_put_model(
+def same_model(
-#     model,
+    model_a: Module,
-# ):
+    model_b: Module,
-#     client = connect_minio()
+) -> bool:
-#     object_name = put_model(
+    """Check if two models are the same class, have the same number of
-#         client=client,
+    parameters and contain the same weights."""
-#         model=model,
+    assert isinstance(model_a, Module)
-#     )
+    assert isinstance(model_b, Module)
-#     assert isinstance(object_name, str)
+    # compare model classes
-#     assert len(object_name) > 0
+    assert type(model_a) is type(model_b)
-#     received_model = get_model(
+    # compare number of parameters
-#         client=client,
+    params_a = list(model_a.parameters())
-#         object_name=object_name,
+    params_b = list(model_b.parameters())
-#     )
+    if len(params_a) != len(params_b):
-#     assert received_model == model
+        return False
+    # compare model weights
+    for p_a, p_b in zip(params_a, params_b):
+        if p_a.data.ne(p_b.data).sum() > 0:
+            return False
+    return True
 
 
-# def test_should_update_model(
+def test_should_get_model(
-#     model_in_minio,
+    datastore: Datastore,
-# ):
+    model_in_minio: tuple[Module, str],
-#     model, object_name = model_in_minio
+):
-#     client = connect_minio()
+    # ARRANGE
-#     object_name = put_model(
+    model, object_name = model_in_minio
-#         client=client,
+    # ACT
-#         model=model,
+    model_data = datastore.get_model(
-#     )
+        object_name=object_name,
-#     assert isinstance(object_name, str)
+    )
-#     assert len(object_name) > 0
+    assert isinstance(model_data, OrderedDict)
-#     received_model = get_model(
+    received_model = VisualCommunicationModel().to('cpu')
-#         client=client,
+    received_model.load_state_dict(model_data)
-#         object_name=object_name,
+    # ASSERT
-#     )
+    assert same_model(model, received_model)
-#     assert received_model == model
+
+
+def test_should_put_model(
+    datastore: Datastore,
+    model: Module,
+):
+    # ARRANGE
+    object_name = datastore.put_model(
+        model=model,
+    )
+    assert isinstance(object_name, str)
+    assert len(object_name) > 0
+    # ACT
+    model_data = datastore.get_model(
+        object_name=object_name,
+    )
+    assert isinstance(model_data, OrderedDict)
+    received_model = VisualCommunicationModel().to('cpu')
+    received_model.load_state_dict(model_data)
+    # ASSERT
+    assert same_model(model, received_model)
+
+
+def test_should_update_model(
+    datastore: Datastore,
+    model_in_minio: tuple[Module, str],
+):
+    # ARRANGE
+    model, object_name = model_in_minio
+    object_name = datastore.put_model(
+        model=model,
+    )
+    assert isinstance(object_name, str)
+    assert len(object_name) > 0
+    # ACT
+    model_data = datastore.get_model(
+        object_name=object_name,
+    )
+    assert isinstance(model_data, OrderedDict)
+    received_model = VisualCommunicationModel().to('cpu')
+    received_model.load_state_dict(model_data)
+    # ASSERT
+    assert same_model(model, received_model)

shared/datastore/tests/unit/connect_minio_test.py

@@ -1,33 +0,0 @@
-"""Definition of unittests for connect_minio function."""
-
-import os
-import unittest
-
-from shared.datastore import connect_minio
-
-
-class TestConnectMinio(unittest.TestCase):
-
-    def setUp(self):
-        # define relevant env vars
-        self.env_var_map = {
-            'MINIO_ENDPOINT': '192.168.1.2',
-            'MINIO_ACCESS_KEY': 'randomAccess_key',
-            'MINIO_SECRET_KEY': 'randomSecret_key',
-            'MINIO_BUCKET_NAME': 'test-bucket-name',
-        }
-        # set env vars
-        for key, val in self.env_var_map.items():
-            os.environ[key] = val
-
-    def tearDown(self):
-        # clear env vars
-        for key in self.env_var_map:
-            _ = os.environ.pop(key, default=None)
-
-    def test_should_fail_when_env_not_set(self):
-        # ensure env not set
-        self.tearDown()
-        # run test
-        with self.assertRaises(AssertionError):
-            _ = connect_minio()

shared/datastore/tests/unit/datastore_minio_test.py

@@ -0,0 +1,230 @@
+"""Definition of unittests for Datastore instantiation."""
+
+import os
+from hashlib import md5
+from io import BytesIO
+from unittest import TestCase
+from unittest.mock import ANY, MagicMock, patch
+
+from minio import Minio
+from PIL import Image
+from urllib3 import BaseHTTPResponse
+
+from shared.datastore.src.datastore_minio import DatastoreMinio
+
+
+class TestDatastoreMinioInstantiation(TestCase):
+
+    def setUp(self):
+        # define relevant env vars
+        self.env_var_map = {
+            'MINIO_ENDPOINT': '192.168.1.2',
+            'MINIO_ACCESS_KEY': 'randomAccess_key',
+            'MINIO_SECRET_KEY': 'randomSecret_key',
+            'MINIO_BUCKET_NAME': 'test-bucket-name',
+        }
+        # set env vars
+        for key, val in self.env_var_map.items():
+            os.environ[key] = val
+        # set other variables
+        self.object_name = '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX'
+        self.image = Image.new(mode='RGB', size=(480, 480))
+        self.buffer = BytesIO()
+        self.image.save(self.buffer, 'png')
+        self.num_bytes = len(self.buffer.getvalue())
+        self.checksum = md5(self.buffer.getbuffer()).hexdigest()
+
+    def tearDown(self):
+        # clear env vars
+        for key in self.env_var_map:
+            _ = os.environ.pop(key, default=None)
+
+    def test_instantiation_should_fail_when_env_not_set(self):
+        # ensure env not set
+        self.tearDown()
+        # run test
+        with self.assertRaises(OSError):
+            _ = DatastoreMinio()
+
+    @patch('shared.datastore.src.datastore_minio.Minio')
+    def test_connect_should_call_Minio_with_env_vars(self, minio_mock):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        minio_mock().bucket_exists.return_value = False
+        # ACT
+        datastore.connect()
+        # ASSERT
+        minio_mock.assert_called_with(
+            endpoint=self.env_var_map['MINIO_ENDPOINT'],
+            access_key=self.env_var_map['MINIO_ACCESS_KEY'],
+            secret_key=self.env_var_map['MINIO_SECRET_KEY'],
+            secure=False,
+        )
+        minio_mock().bucket_exists.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+        )
+        minio_mock().make_bucket.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+        )
+
+    def test_close_should_overwrite_private_variables(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock()
+        datastore._bucket_name = MagicMock()
+        assert isinstance(datastore._client, MagicMock)
+        assert isinstance(datastore._bucket_name, MagicMock)
+        # ACT
+        datastore.close()
+        # ASSERT
+        assert datastore._client is None
+        assert datastore._bucket_name is None
+
+    @patch('shared.datastore.src.datastore_minio.DatastoreMinio.connect')
+    @patch('shared.datastore.src.datastore_minio.DatastoreMinio.close')
+    def test_context_management_implemented(
+        self,
+        mocked_close_method,
+        mocked_connect_method,
+    ):
+        # ARRANGE, ACT and ASSERT
+        with DatastoreMinio() as ds:
+            mocked_connect_method.assert_called_once()
+            assert isinstance(ds, DatastoreMinio)
+        mocked_close_method.assert_called_once()
+
+    def test_should_call_put_object_with_arguments(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock(Minio)
+        datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+        self.buffer.seek(0)
+        # ACT
+        datastore._put(
+            object_name=self.object_name,
+            buffer=self.buffer,
+        )
+        # ASSERT
+        datastore._client.put_object.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+            object_name=self.object_name,
+            length=self.num_bytes,
+            data=self.buffer,
+        )
+
+    def test_should_call_get_object_with_arguments(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock(Minio)
+        datastore._client.get_object.return_value = MagicMock(
+            BaseHTTPResponse,
+            status=200,
+        )
+        # datastore._client.get_object.read.side_effect = [b'random ', b'test', b'text']
+        datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+        # ACT
+        with self.assertRaises(TypeError):  # dont care to mock even more...
+            datastore._get(
+                object_name=self.object_name,
+            )
+        # ASSERT
+        datastore._client.get_object.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+            object_name=self.object_name,
+        )
+
+    def test_should_call_remove_object_with_arguments(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock(Minio)
+        datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+        # ACT
+        datastore._delete(
+            object_name=self.object_name,
+        )
+        # ASSERT
+        datastore._client.remove_object.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+            object_name=self.object_name,
+        )
+
+    def test_put_image_should_call_put_object_with_arguments(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock(Minio)
+        datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+        object_path = f'images/{self.checksum}'
+        # ACT
+        datastore.put_image(
+            image=self.image,
+        )
+        # ASSERT
+        datastore._client.put_object.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+            object_name=object_path,
+            length=self.num_bytes,
+            data=ANY,  # saved to different buffer when converting image
+        )
+
+    def test_get_image_should_call_get_object_with_arguments(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock(Minio)
+        datastore._client.get_object.return_value = MagicMock(
+            BaseHTTPResponse,
+            status=200,
+        )
+        datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+        object_path = f'images/{self.checksum}'
+        # ACT
+        with self.assertRaises(TypeError):  # dont care to mock even more...
+            datastore.get_image(
+                object_name=self.checksum,
+            )
+        # ASSERT
+        datastore._client.get_object.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+            object_name=object_path,
+        )
+
+    # @patch('shared.datastore.src.datastore_minio.torch.serialization.save')
+    # def test_put_model_should_call_put_object_with_arguments(self, mocked_torch_fn):
+    #     # ARRANGE
+    #     datastore = DatastoreMinio()
+    #     datastore._client = MagicMock(Minio)
+    #     datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+    #     object_path = f'images/{self.checksum}'
+    #     mocked_torch_fn.return_value = None
+    #     model = MagicMock(torch.nn.Module)
+    #     # ACT
+    #     datastore.put_model(
+    #         model=model,
+    #     )
+    #     # ASSERT
+    #     datastore._client.put_object.assert_called_with(
+    #         bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+    #         object_name=object_path,
+    #         length=self.num_bytes,
+    #         data=ANY,  # saved to different buffer when converting data
+    #     )
+
+    def test_get_model_should_call_get_object_with_arguments(self):
+        # ARRANGE
+        datastore = DatastoreMinio()
+        datastore._client = MagicMock(Minio)
+        datastore._client.get_object.return_value = MagicMock(
+            BaseHTTPResponse,
+            status=200,
+        )
+        datastore._bucket_name = self.env_var_map['MINIO_BUCKET_NAME']
+        object_path = f'models/{self.checksum}'
+        # ACT
+        with self.assertRaises(TypeError):  # dont care to mock even more...
+            datastore.get_model(
+                object_name=self.checksum,
+            )
+        # ASSERT
+        datastore._client.get_object.assert_called_with(
+            bucket_name=self.env_var_map['MINIO_BUCKET_NAME'],
+            object_name=object_path,
+        )

shared/datastore/tests/unit/delete_test.py

@@ -1,61 +0,0 @@
-"""Definition of unittests for delete function."""
-
-import unittest
-from unittest.mock import Mock
-
-from minio import Minio
-
-from shared.datastore import delete
-
-
-class TestDelete(unittest.TestCase):
-
-    def setUp(self):
-        # set relevant variables
-        self.client = Mock(spec=Minio)
-        self.bucket_name = 'test-bucket'
-        self.object_name = '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX'
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_string = float(0.0)
-        self.len_0_string = ''
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            delete(
-                client=self.bad_client,
-                bucket_name=self.bucket_name,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_bucket_name(self):
-        with self.assertRaises(AssertionError):
-            delete(
-                client=self.client,
-                bucket_name=self.bad_string,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_length_bucket_name(self):
-        with self.assertRaises(AssertionError):
-            delete(
-                client=self.client,
-                bucket_name=self.len_0_string,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_object_name(self):
-        with self.assertRaises(AssertionError):
-            delete(
-                client=self.client,
-                bucket_name=self.bucket_name,
-                object_name=self.bad_string,
-            )
-
-    def test_should_fail_on_wrong_input_length_object_name(self):
-        with self.assertRaises(AssertionError):
-            delete(
-                client=self.client,
-                bucket_name=self.bucket_name,
-                object_name=self.len_0_string,
-            )

shared/datastore/tests/unit/get_image_test.py

@@ -1,63 +0,0 @@
-"""Definition of unittests for get_image function."""
-
-import os
-import unittest
-from unittest.mock import MagicMock
-
-from minio import Minio
-
-from shared.datastore import get_image
-
-
-class TestGetImage(unittest.TestCase):
-
-    def setUp(self):
-        # set relevant variables
-        self.client = MagicMock(spec=Minio)
-        self.object_name = '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX'
-        self.env_var_map = {
-            'MINIO_BUCKET_NAME': 'test-bucket',
-        }
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_string = float(0.0)
-        self.len_0_string = ''
-        # populate env
-        for key, val in self.env_var_map.items():
-            os.environ[key] = val
-
-    def tearDown(self):
-        # clean env
-        for key in self.env_var_map:
-            _ = os.environ.pop(key, default=None)
-
-    def test_should_fail_when_env_not_set(self):
-        # ensure env not set
-        self.tearDown()
-        # run test
-        with self.assertRaises(AssertionError):
-            get_image(
-                client=self.client,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            get_image(
-                client=self.bad_client,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_object_name(self):
-        with self.assertRaises(AssertionError):
-            get_image(
-                client=self.client,
-                object_name=self.bad_string,
-            )
-
-    def test_should_fail_on_wrong_input_length_object_name(self):
-        with self.assertRaises(AssertionError):
-            get_image(
-                client=self.client,
-                object_name=self.len_0_string,
-            )

shared/datastore/tests/unit/get_model_test.py

@@ -1,63 +0,0 @@
-"""Definition of unittest for get_model function."""
-
-import os
-import unittest
-from unittest.mock import MagicMock
-
-from minio import Minio
-
-from shared.datastore import get_model
-
-
-class TestGetModel(unittest.TestCase):
-
-    def setUp(self):
-        # set relevant variables
-        self.client = MagicMock(spec=Minio)
-        self.object_name = '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX'
-        self.env_var_map = {
-            'MINIO_BUCKET_NAME': 'test-bucket',
-        }
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_string = float(0.0)
-        self.len_0_string = ''
-        # populate env
-        for key, val in self.env_var_map.items():
-            os.environ[key] = val
-
-    def tearDown(self):
-        # clean env
-        for key in self.env_var_map:
-            _ = os.environ.pop(key, default=None)
-
-    def test_should_fail_when_env_not_set(self):
-        # ensure env not set
-        self.tearDown()
-        # run test
-        with self.assertRaises(AssertionError):
-            get_model(
-                client=self.client,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            get_model(
-                client=self.bad_client,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_object_name(self):
-        with self.assertRaises(AssertionError):
-            get_model(
-                client=self.client,
-                object_name=self.bad_string,
-            )
-
-    def test_should_fail_on_wrong_input_length_object_name(self):
-        with self.assertRaises(AssertionError):
-            get_model(
-                client=self.client,
-                object_name=self.len_0_string,
-            )

shared/datastore/tests/unit/get_test.py

@@ -1,60 +0,0 @@
-"""Definition of unittests for get function."""
-
-import unittest
-from unittest.mock import MagicMock
-
-from minio import Minio
-
-from shared.datastore import get
-
-
-class TestGet(unittest.TestCase):
-    def setUp(self):
-        # set relevant variables
-        self.client = MagicMock(spec=Minio)
-        self.bucket_name = 'test-bucket'
-        self.object_name = '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX'
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_string = float(0.0)
-        self.len_0_string = ''
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            get(
-                client=self.bad_client,
-                bucket_name=self.bucket_name,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_bucket_name(self):
-        with self.assertRaises(AssertionError):
-            get(
-                client=self.client,
-                bucket_name=self.bad_string,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_length_bucket_name(self):
-        with self.assertRaises(AssertionError):
-            get(
-                client=self.client,
-                bucket_name=self.len_0_string,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_object_name(self):
-        with self.assertRaises(AssertionError):
-            get(
-                client=self.client,
-                bucket_name=self.bucket_name,
-                object_name=self.bad_string,
-            )
-
-    def test_should_fail_on_wrong_input_length_object_name(self):
-        with self.assertRaises(AssertionError):
-            get(
-                client=self.client,
-                bucket_name=self.bucket_name,
-                object_name=self.len_0_string,
-            )

shared/datastore/tests/unit/put_image_test.py

@@ -1,41 +0,0 @@
-"""Definition of unittests for put_image function."""
-
-import os
-import unittest
-from unittest.mock import MagicMock
-
-from minio import Minio
-from PIL import Image
-
-from shared.datastore import put_image
-
-
-class TestPutImage(unittest.TestCase):
-
-    def setUp(self):
-        # set relevant variables
-        self.client = MagicMock(spec=Minio)
-        self.image = Image.new(mode='RGB', size=(480, 480))
-        self.env_var_map = {
-            'MINIO_BUCKET_NAME': 'test-bucket',
-        }
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_image = 'not-image-type'
-        # populate env
-        for key, val in self.env_var_map.items():
-            os.environ[key] = val
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            put_image(
-                client=self.bad_client,
-                image=self.image,
-            )
-
-    def test_should_fail_on_wrong_input_type_image(self):
-        with self.assertRaises(AssertionError):
-            put_image(
-                client=self.client,
-                image=self.bad_image,
-            )

shared/datastore/tests/unit/put_model_test.py

@@ -1,40 +0,0 @@
-"""Definition of unittests for put_model function."""
-
-import os
-import unittest
-from unittest.mock import MagicMock
-
-from minio import Minio
-from torch.nn import Module
-
-from shared.datastore import put_model
-
-
-class TestPutModel(unittest.TestCase):
-    def setUp(self):
-        # set relevant variables
-        self.client = MagicMock(spec=Minio)
-        self.model = MagicMock(spec=Module)
-        self.env_var_map = {
-            'MINIO_BUCKET_NAME': 'test-bucket',
-        }
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_model = 'not-image-type'
-        # populate env
-        for key, val in self.env_var_map.items():
-            os.environ[key] = val
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            put_model(
-                client=self.bad_client,
-                model=self.model,
-            )
-
-    def test_should_fail_on_wrong_input_type_model(self):
-        with self.assertRaises(AssertionError):
-            put_model(
-                client=self.client,
-                model=self.bad_model,
-            )

shared/datastore/tests/unit/put_test.py

@@ -1,80 +0,0 @@
-"""Definition of unittests for put function."""
-
-import unittest
-from io import BytesIO
-from unittest.mock import MagicMock
-
-from minio import Minio
-from PIL import Image
-
-from shared.datastore import put
-
-
-class TestPut(unittest.TestCase):
-    def setUp(self):
-        # set relevant variables
-        self.client = MagicMock(spec=Minio)
-        self.bucket_name = 'test-bucket'
-        self.object_name = '46KXJMFIAPVLM0TKRFZR5YPPTVJ6PJNX'
-        self.image = Image.new(mode='RGB', size=(480, 480))
-        self.buffer = BytesIO()
-        self.image.save(self.buffer, 'png')
-        # set bad arguments
-        self.bad_client = 'not-minio-type'
-        self.bad_string = float(0.0)
-        self.bad_buffer = 'not-buffer-type'
-        self.len_0_string = ''
-
-    def test_should_fail_on_wrong_input_type_client(self):
-        with self.assertRaises(AssertionError):
-            put(
-                client=self.bad_client,
-                buffer=self.buffer,
-                bucket_name=self.bucket_name,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_buffer(self):
-        with self.assertRaises(AssertionError):
-            put(
-                client=self.client,
-                buffer=self.bad_buffer,
-                bucket_name=self.bucket_name,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_bucket_name(self):
-        with self.assertRaises(AssertionError):
-            put(
-                client=self.client,
-                buffer=self.buffer,
-                bucket_name=self.bad_string,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_length_bucket_name(self):
-        with self.assertRaises(AssertionError):
-            put(
-                client=self.client,
-                buffer=self.buffer,
-                bucket_name=self.len_0_string,
-                object_name=self.object_name,
-            )
-
-    def test_should_fail_on_wrong_input_type_object_name(self):
-        with self.assertRaises(AssertionError):
-            put(
-                client=self.client,
-                buffer=self.buffer,
-                bucket_name=self.bucket_name,
-                object_name=self.bad_string,
-            )
-
-    def test_should_fail_on_wrong_input_length_object_name(self):
-        with self.assertRaises(AssertionError):
-            put(
-                client=self.client,
-                buffer=self.buffer,
-                bucket_name=self.bucket_name,
-                object_name=self.len_0_string,
-            )