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='/foglamp/track')
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 '/foglamp/track' == kwargs['url'] assert test_dict == json.loads(kwargs['body'])
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', '/foglamp/service?name=foo&type=bar', "'services'", exc_info=True) response_patch.assert_called_once_with() request_patch.assert_called_once_with( method='GET', url='/foglamp/service?name=foo&type=bar')
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 '/foglamp/track' == kwargs['url'] assert test_dict == json.loads(kwargs['body'])
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='/foglamp/service')
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='/foglamp/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: self._core_management_host = self.get_arg_value("--address") self._core_management_port = self.get_arg_value("--port") self._name = self.get_arg_value("--name") except ArgumentParserError: raise if self._core_management_host is None: raise ValueError("--address is not specified") elif self._core_management_port is None: raise ValueError("--port is not specified") elif self._name is None: raise ValueError("--name is not specified") 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_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='/foglamp/service/category/TEST/blah/value')
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='/foglamp/service/category/SMNTR/ping_timeout')
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", "foglamp": "FogLAMP", "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='/foglamp/track') assert test_dict == ret_value
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='/foglamp/interest')
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 '/foglamp/service/category' == kwargs['url'] assert json.loads(test_dict) == json.loads(kwargs['body'])
def test_register_service_status_client_err(self, status_code): 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 pytest.raises( client_exceptions.MicroserviceManagementClientError ) as excinfo: ms_mgt_client.register_service({})
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 pytest.raises(KeyError) as excinfo: ms_mgt_client.register_service({})
def test_unregister_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.unregister_service('someid') request_patch.assert_called_once_with(method='DELETE', url='/foglamp/service/someid')
def test_unregister_interest_client_err(self, status_code): 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 = status_code with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with pytest.raises( client_exceptions.MicroserviceManagementClientError ) as excinfo: ret_value = ms_mgt_client.unregister_interest('someid')
def test_delete_configuration_item_exception(self, status_code): 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 with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with pytest.raises( client_exceptions.MicroserviceManagementClientError ) as excinfo: ret_value = ms_mgt_client.delete_configuration_item( "TEST", "blah")
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) request_patch.assert_called_once_with(method='GET', url=url) assert ret_value == {'services': 'bla'}
def test_create_configuration_category_keep_original(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 = { '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' } }, 'keep_original_items': True } 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.create_configuration_category( test_dict) response_patch.assert_called_once_with() request_patch.assert_called_once_with(method='POST', url='/foglamp/service/category', body=test_dict) assert ret_value == test_dict
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 '/foglamp/service/category' == kwargs['url'] assert json.loads(test_dict) == json.loads(kwargs['body'])
def test_register_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: ret_value = ms_mgt_client.register_interest('cat', 'msid') request_patch.assert_called_once_with( body='{"category": "cat", "service": "msid"}', method='POST', url='/foglamp/interest') assert ret_value == {'id': 'bla'}
def test_create_configuration_category_exception(self, status_code): 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 = { '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' } }, 'keep_original_items': False } undecoded_data_mock.decode.return_value = json.dumps(test_dict) response_mock.read.return_value = undecoded_data_mock response_mock.status = status_code with patch.object(HTTPConnection, 'request') as request_patch: with patch.object(HTTPConnection, 'getresponse', return_value=response_mock) as response_patch: with pytest.raises( client_exceptions.MicroserviceManagementClientError ) as excinfo: ret_value = ms_mgt_client.create_configuration_category( test_dict)
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") request_patch.assert_called_once_with( method='DELETE', url='/foglamp/service/category/TEST/blah/value') assert ret_value == test_dict
async def test_start(self, mocker): # GIVEN mocker.patch.object(StorageClient, "__init__", return_value=None) mocker.patch.object(ReadingsStorageClient, "__init__", return_value=None) log_warning = mocker.patch.object(ingest._LOGGER, "warning") 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)) 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(core_mgt_host=None, core_mgt_port=None, parent=parent_service) # THEN assert 1 == create_cfg.call_count assert 1 == get_cfg.call_count assert Ingest._stop is False assert Ingest._started is True assert Ingest._readings_list_size == int( Ingest._readings_buffer_size / (Ingest._max_concurrent_readings_inserts)) assert Ingest._last_insert_time is 0 assert Ingest._max_concurrent_readings_inserts == len( Ingest._insert_readings_tasks) assert Ingest._max_concurrent_readings_inserts == len( Ingest._insert_readings_wait_tasks) assert Ingest._max_concurrent_readings_inserts == len( Ingest._readings_list_batch_size_reached) assert Ingest._max_concurrent_readings_inserts == len( Ingest._readings_list_not_empty) assert Ingest._max_concurrent_readings_inserts == len( Ingest._readings_lists) assert 0 == log_warning.call_count
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)
async def test_stop(self, mocker): # GIVEN mocker.patch.object(StorageClient, "__init__", return_value=None) mocker.patch.object(ReadingsStorageClient, "__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)) 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(core_mgt_host=None, core_mgt_port=None, 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
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'])
class FoglampProcess(ABC): """ FoglampProcess for all non-core python processes. All processes will inherit from FoglampProcess 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 """ foglamp.common.storage_client.storage_client.ReadingsStorageClientAsync """ _storage_async = None """ async foglamp.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: self._core_management_host = self.get_arg_value("--address") self._core_management_port = self.get_arg_value("--port") self._name = self.get_arg_value("--name") except ArgumentParserError: raise if self._core_management_host is None: raise ValueError("--address is not specified") elif self._core_management_port is None: raise ValueError("--port is not specified") elif self._name is None: raise ValueError("--name is not specified") 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_arg_value(self, argument_name): """ Parses command line arguments for a single argument of name argument_name. Returns the value of the argument specified or None if argument was not specified. Keyword Arguments: argument_name -- name of command line argument to retrieve value for Return Values: Argument value (as a string) None (if argument was not passed) Side Effects: None Known Exceptions: ArgumentParserError """ parser = SilentArgParse() return parser.silent_arg_parse(argument_name) 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')