diff --git a/shared/datastore/tests/integration/base_crud_test.py b/shared/datastore/tests/integration/base_crud_test.py index dda9ee2..723ffc7 100644 --- a/shared/datastore/tests/integration/base_crud_test.py +++ b/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 - received_data = get( - client=minio_client, - bucket_name=bucket_name, + # ARRANGE + data, _, object_name = data_in_minio + # ACT + 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 - delete( - client=minio_client, - bucket_name=bucket_name, + # ARRANGE + _, _, object_name = data_in_minio + # ACT + datastore._delete( object_name=object_name, ) + # ASSERT with pytest.raises(minio.error.S3Error): - _ = get( - client=minio_client, - bucket_name=bucket_name, + _ = datastore._get( object_name=object_name, ) def test_should_put_data( - minio_client, + datastore: Datastore, data, ): - # prepare variables - minio_bucket_name = str(os.getenv('MINIO_BUCKET_NAME')) + # ARRANGE minio_object_name = str(os.getenv('MINIO_OBJECT_NAME')) buffer = BytesIO(data) - put( - client=minio_client, + # ACT + datastore._put( + object_name=minio_object_name, buffer=buffer, - bucket_name=minio_bucket_name, - object_name=minio_object_name, ) - received_data = get( - client=minio_client, - bucket_name=minio_bucket_name, + received_data = datastore._get( 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 - put( - client=minio_client, + # ARRANGE + buffer, _, object_name = data_in_minio + # ACT + datastore._put( + object_name=object_name, buffer=buffer, - bucket_name=bucket_name, - object_name=object_name, ) - received_data = get( - client=minio_client, - bucket_name=bucket_name, + received_data = datastore._get( object_name=object_name, ) + # ASSERT assert same_data(received_data, buffer) diff --git a/shared/datastore/tests/integration/conftest.py b/shared/datastore/tests/integration/conftest.py index 342ebae..741fb25 100644 --- a/shared/datastore/tests/integration/conftest.py +++ b/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( - endpoint=minio_endpoint, - access_key=minio_access_key, - secret_key=minio_secret_key, - secure=False, - ) + datastore_client = Datastore() + datastore_client.connect() + assert datastore_client._client is not None # ensure bucket exists - if not client.bucket_exists(bucket_name=minio_bucket_name): - client.make_bucket(bucket_name=minio_bucket_name) + if not datastore_client._client.bucket_exists(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): - client.remove_object( + for obj in datastore_client._client.list_objects( + 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) - assert not client.bucket_exists(bucket_name=minio_bucket_name) + datastore_client._client.remove_bucket(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, - data, + datastore: Datastore, + 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 -# def image_in_minio( -# image: Image.Image, -# ) -> tuple(Image.Image, str): -# # +@pytest.fixture +def image_in_minio( + datastore: Datastore, + 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 -# yield image, object_name -# # cleanup +@pytest.fixture +def model() -> Iterator[torch.nn.Module]: + # 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, + ) diff --git a/shared/datastore/tests/integration/connect_test.py b/shared/datastore/tests/integration/connect_test.py index 25b5aaf..ea5868e 100644 --- a/shared/datastore/tests/integration/connect_test.py +++ b/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() - assert isinstance(client, Minio) + with Datastore() as ds: + assert isinstance(ds._client, Minio) diff --git a/shared/datastore/tests/integration/image_crud_test.py b/shared/datastore/tests/integration/image_crud_test.py index e91c9a0..c3b0dbb 100644 --- a/shared/datastore/tests/integration/image_crud_test.py +++ b/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( -# image_in_minio, -# ): -# image, object_name = image_in_minio -# client = connect_minio() -# received_image = get_image( -# client=client, -# object_name=object_name, -# ) -# assert isinstance(image, Image.Image) -# assert received_image == image +def test_should_get_image( + datastore: Datastore, + image_in_minio: tuple[Image.Image, str], +): + # ARRANGE + image, object_name = image_in_minio + # ACT + received_image = datastore.get_image( + object_name=object_name, + ) + # ASSERT + assert isinstance(image, Image.Image) + assert same_image(image, received_image) -# def test_should_put_image( -# image, -# ): -# client = connect_minio() -# object_name = put_image( -# client=client, -# image=image, -# ) -# assert isinstance(object_name, str) -# assert len(object_name) > 0 -# received_image = get_image( -# client=client, -# object_name=object_name, -# ) -# assert same_image(received_image, image) +def test_should_put_image( + datastore: Datastore, + image: Image.Image, +): + # ARRANGE + object_name = datastore.put_image( + image=image, + ) + assert isinstance(object_name, str) + assert len(object_name) > 0 + # ACT + received_image = datastore.get_image( + object_name=object_name, + ) + # ASSERT + assert same_image(image, received_image) -# def test_should_update_image( -# image_in_minio, -# ): -# image, object_name = image_in_minio -# client = connect_minio() -# object_name = put_image( -# client=client, -# image=image, -# ) -# assert isinstance(object_name, str) -# assert len(object_name) > 0 -# received_image = get_image( -# client=client, -# object_name=object_name, -# ) -# assert received_image == image +def test_should_update_image( + datastore: Datastore, + image_in_minio: tuple[Image.Image, str], +): + # ARRANGE + image, object_name = image_in_minio + object_name = datastore.put_image( + image=image, + ) + assert isinstance(object_name, str) + assert len(object_name) > 0 + # ACT + received_image = datastore.get_image( + object_name=object_name, + ) + # ASSERT + assert same_image(image, received_image) + + +if __name__ == '__main__': + pytest.main() diff --git a/shared/datastore/tests/integration/model_crud_test.py b/shared/datastore/tests/integration/model_crud_test.py index a5e126a..2f41472 100644 --- a/shared/datastore/tests/integration/model_crud_test.py +++ b/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( -# model_in_minio, -# ): -# 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 +from model.src.models import VisualCommunicationModel +from shared.datastore import Datastore -# def test_should_put_model( -# model, -# ): -# client = connect_minio() -# object_name = put_model( -# client=client, -# model=model, -# ) -# assert isinstance(object_name, str) -# assert len(object_name) > 0 -# received_model = get_model( -# client=client, -# object_name=object_name, -# ) -# assert received_model == model +def same_model( + model_a: Module, + model_b: Module, +) -> bool: + """Check if two models are the same class, have the same number of + parameters and contain the same weights.""" + assert isinstance(model_a, Module) + assert isinstance(model_b, Module) + # compare model classes + assert type(model_a) is type(model_b) + # compare number of parameters + params_a = list(model_a.parameters()) + params_b = list(model_b.parameters()) + if len(params_a) != len(params_b): + 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( -# model_in_minio, -# ): -# model, object_name = model_in_minio -# client = connect_minio() -# object_name = put_model( -# client=client, -# model=model, -# ) -# assert isinstance(object_name, str) -# assert len(object_name) > 0 -# received_model = get_model( -# client=client, -# object_name=object_name, -# ) -# assert received_model == model +def test_should_get_model( + datastore: Datastore, + model_in_minio: tuple[Module, str], +): + # ARRANGE + model, object_name = model_in_minio + # 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_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) diff --git a/shared/datastore/tests/unit/connect_minio_test.py b/shared/datastore/tests/unit/connect_minio_test.py deleted file mode 100644 index 508ac60..0000000 --- a/shared/datastore/tests/unit/connect_minio_test.py +++ /dev/null @@ -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() diff --git a/shared/datastore/tests/unit/datastore_minio_test.py b/shared/datastore/tests/unit/datastore_minio_test.py new file mode 100644 index 0000000..2ce55c3 --- /dev/null +++ b/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, + ) diff --git a/shared/datastore/tests/unit/delete_test.py b/shared/datastore/tests/unit/delete_test.py deleted file mode 100644 index 06c902d..0000000 --- a/shared/datastore/tests/unit/delete_test.py +++ /dev/null @@ -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, - ) diff --git a/shared/datastore/tests/unit/get_image_test.py b/shared/datastore/tests/unit/get_image_test.py deleted file mode 100644 index ab72324..0000000 --- a/shared/datastore/tests/unit/get_image_test.py +++ /dev/null @@ -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, - ) diff --git a/shared/datastore/tests/unit/get_model_test.py b/shared/datastore/tests/unit/get_model_test.py deleted file mode 100644 index 0ba1f76..0000000 --- a/shared/datastore/tests/unit/get_model_test.py +++ /dev/null @@ -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, - ) diff --git a/shared/datastore/tests/unit/get_test.py b/shared/datastore/tests/unit/get_test.py deleted file mode 100644 index 056f2da..0000000 --- a/shared/datastore/tests/unit/get_test.py +++ /dev/null @@ -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, - ) diff --git a/shared/datastore/tests/unit/put_image_test.py b/shared/datastore/tests/unit/put_image_test.py deleted file mode 100644 index e971478..0000000 --- a/shared/datastore/tests/unit/put_image_test.py +++ /dev/null @@ -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, - ) diff --git a/shared/datastore/tests/unit/put_model_test.py b/shared/datastore/tests/unit/put_model_test.py deleted file mode 100644 index 790e839..0000000 --- a/shared/datastore/tests/unit/put_model_test.py +++ /dev/null @@ -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, - ) diff --git a/shared/datastore/tests/unit/put_test.py b/shared/datastore/tests/unit/put_test.py deleted file mode 100644 index b0c8501..0000000 --- a/shared/datastore/tests/unit/put_test.py +++ /dev/null @@ -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, - )