def test_create_asset_tracker_event(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock test_dict = json.dumps({ 'asset': 'AirIntake', 'event': 'Ingest', 'service': 'PT100_In1', 'plugin': 'PT100' }) undecoded_data_mock.decode.return_value = test_dict response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.create_asset_tracker_event(test_dict) assert json.loads(test_dict) == ret_value response_patch.assert_called_once_with() args, kwargs = request_patch.call_args_list[0] assert 'POST' == kwargs['method'] assert '/fledge/track' == kwargs['url'] assert test_dict == json.loads(kwargs['body'])
def test_get_asset_tracker_event(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock test_dict = { "track": [{ "asset": "sinusoid", "fledge": "Fledge", "plugin": "sinusoid", "service": "sine", "timestamp": "2018-08-21 16:58:45.118", "event": "Ingest" }] } undecoded_data_mock.decode.return_value = json.dumps(test_dict) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.get_asset_tracker_events() response_patch.assert_called_once_with() request_patch.assert_called_once_with(method='GET', url='/fledge/track') assert test_dict == ret_value
def test_get_asset_tracker_event_client_err(self, status_code, host): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps({'track': []}) response_mock.status = status_code response_mock.reason = 'this is the reason' with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.get_asset_tracker_events() assert excinfo.type is client_exceptions.MicroserviceManagementClientError assert 1 == log_error.call_count msg = '{} error code: %d, Reason: %s'.format(host) log_error.assert_called_once_with(msg, status_code, 'this is the reason') response_patch.assert_called_once_with() request_patch.assert_called_once_with(method='GET', url='/fledge/track')
def test_register_interest_status_client_err(self, status_code, host): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) response_mock.status = status_code response_mock.reason = 'this is the reason' with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.register_interest('cat', 'msid') assert excinfo.type is client_exceptions.MicroserviceManagementClientError assert 1 == log_error.call_count msg = '{} error code: %d, Reason: %s'.format(host) log_error.assert_called_once_with(msg, status_code, 'this is the reason') response_patch.assert_called_once_with() request_patch.assert_called_once_with( body='{"category": "cat", "service": "msid"}', method='POST', url='/fledge/interest')
def test_delete_configuration_item_exception(self, status_code, host): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock response_mock.status = status_code response_mock.reason = 'this is the reason' with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.delete_configuration_item("TEST", "blah") assert excinfo.type is client_exceptions.MicroserviceManagementClientError assert 1 == log_error.call_count msg = '{} error code: %d, Reason: %s'.format(host) log_error.assert_called_once_with(msg, status_code, 'this is the reason') response_patch.assert_called_once_with() request_patch.assert_called_once_with( method='DELETE', url='/fledge/service/category/TEST/blah/value')
def test_register_service_no_id(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps({'notid': 'bla'}) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "exception") as log_exc: with pytest.raises(Exception) as excinfo: ms_mgt_client.register_service({}) assert excinfo.type is KeyError assert 1 == log_exc.call_count log_exc.assert_called_once_with( 'Could not register the microservice, From request %s, Reason: %s', '{}', "'id'") response_patch.assert_called_once_with() request_patch.assert_called_once_with(body='{}', method='POST', url='/fledge/service')
def test_get_configuration_item(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock test_dict = { 'type': 'integer', 'description': 'Timeout for a response from any given micro-service. (must be greater than 0)', 'value': '1', 'default': '1' } undecoded_data_mock.decode.return_value = json.dumps(test_dict) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.get_configuration_item( "SMNTR", "ping_timeout") assert test_dict == ret_value response_patch.assert_called_once_with() request_patch.assert_called_once_with( method='GET', url='/fledge/service/category/SMNTR/ping_timeout')
def test_unregister_interest_no_id(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps({'notid': 'bla'}) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.unregister_interest('someid') assert excinfo.type is KeyError assert 1 == log_error.call_count log_error.assert_called_once_with( 'Could not unregister interest for %s, Reason: %s', 'someid', "'id'", exc_info=True) response_patch.assert_called_once_with() request_patch.assert_called_once_with(method='DELETE', url='/fledge/interest/someid')
def test_get_services_no_services(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps( {'notservices': 'bla'}) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.get_services('foo', 'bar') assert excinfo.type is KeyError assert 1 == log_error.call_count log_error.assert_called_once_with( 'Could not find the micro-service for requested url %s, Reason: %s', '/fledge/service?name=foo&type=bar', "'services'", exc_info=True) response_patch.assert_called_once_with() request_patch.assert_called_once_with( method='GET', url='/fledge/service?name=foo&type=bar')
def test_create_asset_tracker_event_exception(self, status_code, host): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() test_dict = json.dumps({ 'asset': 'AirIntake', 'event': 'Ingest', 'service': 'PT100_In1', 'plugin': 'PT100' }) undecoded_data_mock.decode.return_value = test_dict response_mock.read.return_value = undecoded_data_mock response_mock.status = status_code response_mock.reason = 'this is the reason' with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.create_asset_tracker_event(test_dict) assert excinfo.type is client_exceptions.MicroserviceManagementClientError assert 1 == log_error.call_count msg = '{} error code: %d, Reason: %s'.format(host) log_error.assert_called_once_with(msg, status_code, 'this is the reason') response_patch.assert_called_once_with() args, kwargs = request_patch.call_args_list[0] assert 'POST' == kwargs['method'] assert '/fledge/track' == kwargs['url'] assert test_dict == json.loads(kwargs['body'])
def test_create_configuration_category_exception(self, status_code, host): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() test_dict = json.dumps({ 'key': 'TEST', 'description': 'description', 'value': { 'ping_timeout': { 'type': 'integer', 'description': 'Timeout for a response from any given micro-service. (must be greater than 0)', 'value': '1', 'default': '1' }, 'sleep_interval': { 'type': 'integer', 'description': 'The time (in seconds) to sleep between health checks. (must be greater than 5)', 'value': '5', 'default': '5' } } }) undecoded_data_mock.decode.return_value = test_dict response_mock.read.return_value = undecoded_data_mock response_mock.status = status_code response_mock.reason = 'this is the reason' with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with patch.object(_logger, "error") as log_error: with pytest.raises(Exception) as excinfo: ms_mgt_client.create_configuration_category(test_dict) assert excinfo.type is client_exceptions.MicroserviceManagementClientError assert 1 == log_error.call_count msg = '{} error code: %d, Reason: %s'.format(host) log_error.assert_called_once_with(msg, status_code, 'this is the reason') response_patch.assert_called_once_with() args, kwargs = request_patch.call_args_list[0] assert 'POST' == kwargs['method'] assert '/fledge/service/category' == kwargs['url'] assert json.loads(test_dict) == json.loads(kwargs['body'])
def test_unregister_interest_good_id(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps({'id': 'bla'}) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ms_mgt_client.unregister_interest('someid') response_patch.assert_called_once_with() request_patch.assert_called_once_with(method='DELETE', url='/fledge/interest/someid')
def __init__(self): """ All processes must have these three command line arguments passed: --address [core microservice management host] --port [core microservice management port] --name [process name] """ self._start_time = time.time() try: parser = SilentArgParse() parser.add_argument("--name", required=True) parser.add_argument("--address", required=True) parser.add_argument("--port", required=True, type=int) namespace, args = parser.parse_known_args() self._name = getattr(namespace, 'name') self._core_management_host = getattr(namespace, 'address') self._core_management_port = getattr(namespace, 'port') r = range(1, 65536) if self._core_management_port not in r: raise ArgumentParserError("Invalid Port: {}".format( self._core_management_port)) for item in args: if item.startswith('--'): kv = item.split('=') if len(kv) == 2: if len(kv[1].strip()) == 0: raise ArgumentParserError( "Invalid value {} for optional arg {}".format( kv[1], kv[0])) except ArgumentParserError as ex: _logger.error("Arg parser error: %s", str(ex)) raise self._core_microservice_management_client = MicroserviceManagementClient( self._core_management_host, self._core_management_port) self._readings_storage_async = ReadingsStorageClientAsync( self._core_management_host, self._core_management_port) self._storage_async = StorageClientAsync(self._core_management_host, self._core_management_port)
def test_create_configuration_category(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock test_dict = json.dumps({ 'key': 'TEST', 'description': 'description', 'value': { 'ping_timeout': { 'type': 'integer', 'description': 'Timeout for a response from any given micro-service. (must be greater than 0)', 'value': '1', 'default': '1' }, 'sleep_interval': { 'type': 'integer', 'description': 'The time (in seconds) to sleep between health checks. (must be greater than 5)', 'value': '5', 'default': '5' } } }) undecoded_data_mock.decode.return_value = test_dict response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.create_configuration_category( test_dict) assert json.loads(test_dict) == ret_value response_patch.assert_called_once_with() args, kwargs = request_patch.call_args_list[0] assert 'POST' == kwargs['method'] assert '/fledge/service/category' == kwargs['url'] assert json.loads(test_dict) == json.loads(kwargs['body'])
def test_get_services_good(self, name, _type, url): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps( {'services': 'bla'}) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.get_services(name, _type) response_patch.assert_called_once_with() request_patch.assert_called_once_with(method='GET', url=url) assert {'services': 'bla'} == ret_value
def test_register_service_good_id(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock undecoded_data_mock.decode.return_value = json.dumps({'id': 'bla'}) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.register_service({'keys': 'vals'}) response_patch.assert_called_once_with() request_patch.assert_called_once_with(body='{"keys": "vals"}', method='POST', url='/fledge/service') assert {'id': 'bla'} == ret_value
def test_delete_configuration_item(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) response_mock = MagicMock(type=HTTPResponse) undecoded_data_mock = MagicMock() response_mock.read.return_value = undecoded_data_mock test_dict = {'value': ''} undecoded_data_mock.decode.return_value = json.dumps(test_dict) response_mock.status = 200 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: ret_value = ms_mgt_client.delete_configuration_item( "TEST", "blah") assert test_dict == ret_value response_patch.assert_called_once_with() request_patch.assert_called_once_with( method='DELETE', url='/fledge/service/category/TEST/blah/value')
async def test_read_config(self, mocker): # GIVEN Ingest.storage_async = MagicMock(spec=StorageClientAsync) Ingest.readings_storage_async = MagicMock( spec=ReadingsStorageClientAsync) mocker.patch.object(MicroserviceManagementClient, "__init__", return_value=None) create_cfg = mocker.patch.object(MicroserviceManagementClient, "create_configuration_category", return_value=None) get_cfg = mocker.patch.object(MicroserviceManagementClient, "get_configuration_category", return_value=get_cat( Ingest.default_config)) mocker.patch.object(MicroserviceManagementClient, "create_child_category", return_value=None) Ingest._parent_service = MagicMock( _core_microservice_management_client=MicroserviceManagementClient( )) # WHEN await Ingest._read_config() # THEN assert 1 == create_cfg.call_count assert 1 == get_cfg.call_count new_config = get_cat(Ingest.default_config) assert Ingest._readings_buffer_size == int( new_config['readings_buffer_size']['value']) assert Ingest._max_concurrent_readings_inserts == \ int(new_config['max_concurrent_readings_inserts']['value']) assert Ingest._readings_insert_batch_size == int( new_config['readings_insert_batch_size']['value']) assert Ingest._readings_insert_batch_timeout_seconds == \ int(new_config['readings_insert_batch_timeout_seconds']['value']) assert Ingest._max_readings_insert_batch_connection_idle_seconds == \ int(new_config['max_readings_insert_batch_connection_idle_seconds']['value']) assert Ingest._max_readings_insert_batch_reconnect_wait_seconds == \ int(new_config['max_readings_insert_batch_reconnect_wait_seconds']['value'])
async def test_read_config_filter(self, mocker): # GIVEN mock_config = { "filter": { "type": "JSON", "default": "{\"pipeline\": [\"scale\"]}", "description": "Filter pipeline", "value": "{\"pipeline\": [\"scale\"]}" }, "dataPointsPerSec": { "order": "2", "description": "Data points per second", "displayName": "Data points per second", "type": "integer", "default": "1", "value": "1" }, "assetName": { "order": "1", "description": "Name of Asset", "displayName": "Asset name", "type": "string", "default": "sinusoid", "value": "sinusoid" }, "plugin": { "description": "Sinusoid Plugin", "type": "string", "default": "sinusoid", "readonly": "true", "value": "sinusoid" } } Ingest.storage_async = MagicMock(spec=StorageClientAsync) Ingest.readings_storage_async = MagicMock( spec=ReadingsStorageClientAsync) mocker.patch.object(MicroserviceManagementClient, "__init__", return_value=None) create_cfg = mocker.patch.object(MicroserviceManagementClient, "create_configuration_category", return_value=None) get_cfg = mocker.patch.object(MicroserviceManagementClient, "get_configuration_category", return_value=get_cat( Ingest.default_config)) mocker.patch.object(MicroserviceManagementClient, "create_child_category", return_value=None) Ingest._parent_service = MagicMock( _core_microservice_management_client=MicroserviceManagementClient( ), _name="test") Ingest._parent_service.config = mock_config log_warning = mocker.patch.object(ingest._LOGGER, "warning") # WHEN await Ingest._read_config() # THEN assert 1 == log_warning.call_count calls = [ call( 'South Service [%s] does not support the use of a filter pipeline.', 'test') ] log_warning.assert_has_calls(calls, any_order=True)
class FledgeProcess(ABC): """ FledgeProcess for all non-core python processes. All processes will inherit from FledgeProcess and must implement pure virtual method run() """ _core_management_host = None """ string containing core's micro-service management host """ _core_management_port = None """ int containing core's micro-service management port """ _name = None """ name of process """ _core_microservice_management_client = None """ MicroserviceManagementClient instance """ _readings_storage_async = None """ fledge.common.storage_client.storage_client.ReadingsStorageClientAsync """ _storage_async = None """ async fledge.common.storage_client.storage_client.StorageClientAsync """ _start_time = None """ time at which this python process started """ def __init__(self): """ All processes must have these three command line arguments passed: --address [core microservice management host] --port [core microservice management port] --name [process name] """ self._start_time = time.time() try: parser = SilentArgParse() parser.add_argument("--name", required=True) parser.add_argument("--address", required=True) parser.add_argument("--port", required=True, type=int) namespace, args = parser.parse_known_args() self._name = getattr(namespace, 'name') self._core_management_host = getattr(namespace, 'address') self._core_management_port = getattr(namespace, 'port') r = range(1, 65536) if self._core_management_port not in r: raise ArgumentParserError("Invalid Port: {}".format( self._core_management_port)) for item in args: if item.startswith('--'): kv = item.split('=') if len(kv) == 2: if len(kv[1].strip()) == 0: raise ArgumentParserError( "Invalid value {} for optional arg {}".format( kv[1], kv[0])) except ArgumentParserError as ex: _logger.error("Arg parser error: %s", str(ex)) raise self._core_microservice_management_client = MicroserviceManagementClient( self._core_management_host, self._core_management_port) self._readings_storage_async = ReadingsStorageClientAsync( self._core_management_host, self._core_management_port) self._storage_async = StorageClientAsync(self._core_management_host, self._core_management_port) # pure virtual method run() to be implemented by child class @abstractmethod def run(self): pass def get_services_from_core(self, name=None, _type=None): return self._core_microservice_management_client.get_services( name, _type) def register_service_with_core(self, service_registration_payload): """ Register a microservice with core Keyword Arguments: service_registration_payload -- json format dictionary Return Values: Argument value (as a string) None (if argument was not passed) Known Exceptions: HTTPError """ return self._core_microservice_management_client.register_service( service_registration_payload) def unregister_service_with_core(self, microservice_id): """ Unregister a microservice with core Keyword Arguments: microservice_id (uuid as a string) """ return self._core_microservice_management_client.unregister_service( microservice_id) def register_interest_with_core(self): # cat name # callback module # self.microservice_id raise NotImplementedError def unregister_interest_with_core(self): # cat name # self.microservice_id raise NotImplementedError def get_configuration_categories(self): """ :return: """ return self._core_microservice_management_client.get_configuration_category( ) def get_configuration_category(self, category_name=None): """ :param category_name: :return: """ return self._core_microservice_management_client.get_configuration_category( category_name) def get_configuration_item(self, category_name, config_item): """ :param category_name: :param config_item: :return: """ return self._core_microservice_management_client.get_configuration_item( category_name, config_item) def create_configuration_category(self, category_data): """ :param category_data: :return: """ return self._core_microservice_management_client.create_configuration_category( category_data) def update_configuration_item(self, category_name, config_item): """ :param category_name: :param config_item: :return: """ return self._core_microservice_management_client.update_configuration_item( category_name, config_item) def delete_configuration_item(self, category_name, config_item): """ :param category_name: :param config_item: :return: """ return self._core_microservice_management_client.delete_configuration_item( category_name, config_item)
async def test_stop(self, mocker): class mock_stat: def __init__(self): pass async def register(self, key, desc): return None async def mock_create(storage): return mock_stat() # GIVEN mocker.patch.object(StorageClientAsync, "__init__", return_value=None) mocker.patch.object(ReadingsStorageClientAsync, "__init__", return_value=None) log_exception = mocker.patch.object(ingest._LOGGER, "exception") mocker.patch.object(MicroserviceManagementClient, "__init__", return_value=None) create_cfg = mocker.patch.object(MicroserviceManagementClient, "create_configuration_category", return_value=None) get_cfg = mocker.patch.object(MicroserviceManagementClient, "get_configuration_category", return_value=get_cat( Ingest.default_config)) mocker.patch.object(MicroserviceManagementClient, "get_asset_tracker_events", return_value={'track': []}) mocker.patch.object(MicroserviceManagementClient, "create_child_category", return_value=None) mocker.patch.object(statistics, "create_statistics", return_value=mock_create(None)) parent_service = MagicMock( _core_microservice_management_client=MicroserviceManagementClient( )) mocker.patch.object(Ingest, "_write_statistics", return_value=mock_coro()) mocker.patch.object(Ingest, "_insert_readings", return_value=mock_coro()) # WHEN await Ingest.start(parent=parent_service) await asyncio.sleep(1) await Ingest.stop() # THEN assert 1 == create_cfg.call_count assert 1 == get_cfg.call_count assert Ingest._stop is True assert Ingest._started is False assert Ingest._insert_readings_wait_tasks is None assert Ingest._insert_readings_tasks is None assert Ingest._readings_lists is None assert Ingest._readings_list_batch_size_reached is None assert Ingest._readings_list_not_empty is None assert Ingest._readings_lists_not_full is None assert 0 == log_exception.call_count
def test_constructor(self): microservice_management_host = 'host1' microservice_management_port = 1 ms_mgt_client = MicroserviceManagementClient( microservice_management_host, microservice_management_port) assert hasattr(ms_mgt_client, '_management_client_conn')