def test_generate_certificate(self, mock_requests): """ Test generate certificate """ DojotAPI.generate_certificate(self.jwt, self.csr) DojotAPI.call_api.assert_called_once_with(mock_requests.post, self.args)
def test_revoke_certificate(self, mock_requests): """ Should revoke the certificate correctly. """ DojotAPI.revoke_certificate(self.jwt, self.crt['fingerprint']) DojotAPI.call_api.assert_called_once_with(mock_requests.delete, self.args, False)
def test_revoke_certificate_exception(self, mock_requests): """ Should not generate cert, because rose an exception. """ DojotAPI.call_api.side_effect = APICallError() with self.assertRaises(Exception) as context: DojotAPI.revoke_certificate(self.jwt, self.crt['fingerprint']) self.assertIsNotNone(context.exception) self.assertIsInstance(context.exception, APICallError) DojotAPI.call_api.assert_called_once_with(mock_requests.delete, self.args, False)
def test_generate_certificate_exception(self, mock_requests): """ Should not generate the cert, because rose an exception. """ DojotAPI.call_api.side_effect = APICallError() with self.assertRaises(Exception) as context: DojotAPI.generate_certificate(self.jwt, self.csr) self.assertIsNotNone(context.exception) self.assertIsInstance(context.exception, APICallError) DojotAPI.call_api.assert_called_once_with(mock_requests.post, self.args)
def create_devices(self): """ Create the devices in Dojot. Returns a list with device IDs. """ try: template_id = DojotAPI.create_template(self.jwt) DojotAPI.create_devices(self.jwt, template_id, self.parser_args.devices, self.parser_args.batch) except Exception as exception: LOGGER.error(str(exception))
def test_successfully_delete_templates(self, mock_requests): """ Should successfully delete templates. """ args = { "url": "{0}/template".format(MOCK_CONFIG['dojot']['url']), "headers": { "Authorization": "Bearer {0}".format(self.jwt), }, } DojotAPI.delete_templates(self.jwt) DojotAPI.call_api.assert_called_once() DojotAPI.call_api.assert_called_with(mock_requests.delete, args, False)
def test_successfully_create_template(self, mock_requests): """ Should successfully create the template. """ DojotAPI.call_api.return_value = {"template": {"id": 1}} args = { "url": "{0}/template".format(MOCK_CONFIG['dojot']['url']), "headers": { "Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.jwt), }, "data": json.dumps({ "label": "CargoContainer", "attrs": [ { "label": "timestamp", "type": "dynamic", "value_type": "integer" }, ] }), } template_id = DojotAPI.create_template(self.jwt) DojotAPI.call_api.assert_called_once_with(mock_requests.post, args) self.assertEqual(template_id, 1)
def test_successfully_divide_loads_low_n(self): """ Should successfully divide the load - n < batch. """ loads = DojotAPI.divide_loads(2, 4) self.assertEqual(loads, [2])
def test_successfully_create_device(self, mock_requests): """ Should successfully create the device. """ DojotAPI.call_api.return_value = {"devices": [{"id": 1}]} args = { "url": "{0}/device".format(MOCK_CONFIG['dojot']['url']), "headers": { "Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.jwt), }, "data": json.dumps({ "templates": [self.template_id], "attrs": {}, "label": self.label, }), } device_id = DojotAPI.create_device(self.jwt, self.template_id, self.label) DojotAPI.call_api.assert_called_once_with(mock_requests.post, args) self.assertEqual(device_id, 1)
def test_should_get_response_after_retry(self, mock_requests, mock_gevent): """ Should successfully receive a response from a POST call in the second call. """ mock_requests.post = MagicMock() mock_requests.post.return_value.raise_for_status = MagicMock( side_effect=[Exception(), None] ) mock_requests.post.return_value.json = PropertyMock(return_value={"return": "testReturn"}) args = { "url": "testURL", "data": "\"testJson\": \"testData\"", "headers": "testHeader" } res = DojotAPI.call_api(mock_requests.post, args) self.assertEqual(mock_requests.post.call_count, 2) mock_requests.post.assert_has_calls([ mock.call(**args), mock.call(**args), ], any_order=True) mock_gevent.sleep.assert_called_once_with(5.0) self.assertEqual(res, {"return": "testReturn"})
def test_should_not_get_response(self, mock_requests, mock_gevent): """ Should not receive a response from a POST call - exceptions rose. """ mock_requests.post = MagicMock() mock_requests.post.return_value.raise_for_status = MagicMock(side_effect=Exception()) args = { "url": "testURL", "data": "\"testJson\": \"testData\"", "headers": "testHeader" } res = None with self.assertRaises(APICallError) as context: res = DojotAPI.call_api(mock_requests.post, args) self.assertIsNotNone(context.exception) self.assertIsInstance(context.exception, APICallError) self.assertEqual(mock_requests.post.call_count, 2) mock_requests.post.assert_has_calls([ mock.call(**args), mock.call(**args), ], any_order=True) self.assertEqual(mock_gevent.sleep.call_count, 2) mock_gevent.sleep.assert_has_calls([mock.call(5.0), mock.call(5.0)]) self.assertIsNone(res)
def test_successfully_divide_loads_odd(self): """ Should successfully divide the load - odd case (last load is different). """ loads = DojotAPI.divide_loads(5, 2) self.assertEqual(loads, [2, 2, 1])
def generate_certificate(self) -> str: """ Generate the certificates. Returns the pem certificate. """ return DojotAPI.generate_certificate(self.jwt, self.csr["pem"])
def test_successfully_divide_loads_even(self): """ Should successfully divide the load - even case (all loads are the same). """ loads = DojotAPI.divide_loads(4, 2) self.assertEqual(loads, [2, 2])
def test_should_not_get_response_limit_calls(self, mock_requests, mock_gevent): """ Should not receive a response from a POST call - limit of calls to the API. """ mock_requests.post = MagicMock() mock_requests.post.return_value.status_code = 429 mock_requests.post.return_value.raise_for_status = \ MagicMock(side_effect=requests.exceptions.HTTPError()) args = { "url": "testURL", "data": "\"testJson\": \"testData\"", "headers": "testHeader" } res = None with self.assertRaises(SystemExit) as context: res = DojotAPI.call_api(mock_requests.post, args) self.assertIsNotNone(context.exception) self.assertIsInstance(context.exception, SystemExit) mock_requests.post.assert_called_once_with(**args) mock_gevent.sleep.assert_not_called() self.assertIsNone(res)
def test_successfully_create_one_device_one_batch(self, mock_requests): """ Should successfully create one device in one batch. """ DojotAPI.divide_loads.return_value = [1] self.args["data"] = json.dumps({ "templates": [self.template_id], "attrs": {}, "label": "CargoContainer_0" }) DojotAPI.create_devices(self.jwt, self.template_id, 1, 1) DojotAPI.divide_loads.assert_called_once_with(1, 1) self.assertEqual(DojotAPI.divide_loads.return_value, [1]) DojotAPI.call_api.assert_called_once_with(mock_requests.post, self.args, False)
def run(self): """ Runs the commands for each parser. """ if self.parser_args.topic == "cert": self.jwt = DojotAPI.get_jwt() self.cert_commands() elif self.parser_args.topic == "dojot": self.jwt = DojotAPI.get_jwt() if self.parser_args.dojot == "create": self.dojot_create_commands() if self.parser_args.dojot == "clear": self.dojot_clear_commands() elif self.parser_args.topic == "redis": self.redis_commands()
def test_retrieve_ca_cert(self, mock_requests): """ Should retrieve the CA certificate correctly. """ DojotAPI.call_api.return_value = {"caPem": "testPem"} res = DojotAPI.retrieve_ca_cert(self.jwt) self.assertEqual(res, "testPem") DojotAPI.call_api.assert_called_once_with(mock_requests.get, self.args)
def cert_commands(self): """ Certificate creation commands. """ if self.parser_args.remove and os.path.exists( CONFIG['security']['cert_dir']): LOGGER.info("Removing certificates...") # We don't remove the cert directory because it can be mounted as a volume and it will # throw the 'Resource busy' error, we remove everything inside it instead for path in glob.glob( os.path.join(CONFIG['security']['cert_dir'], '*')): if os.path.isfile(path): os.remove(path) if os.path.isdir(path): shutil.rmtree(path) LOGGER.info("... Removed certificates") LOGGER.info("Creating certificates directories...") revoke_dir = os.path.join(CONFIG['security']['cert_dir'], CONFIG['security']['revoke_cert_dir']) renew_dir = os.path.join(CONFIG['security']['cert_dir'], CONFIG['security']['renew_cert_dir']) os.makedirs(renew_dir, exist_ok=True) os.makedirs(revoke_dir, exist_ok=True) LOGGER.info("... Created certificates directories") if self.parser_args.devices is not None: if self.parser_args.processes > self.parser_args.devices: LOGGER.error( "The number of certificates must be greather than the number of processes!" ) sys.exit(1) # Generating the random IDs ids = [ str(uuid.uuid4().hex) for _ in range(self.parser_args.devices) ] # Begins the certificate generation for random devices IDs self.generate_certs(ids) if self.parser_args.ids is not None: # Begins the certificate generation self.generate_certs(self.parser_args.ids) if self.parser_args.dojot: devices_ids = DojotAPI.get_devices(self.jwt) self.generate_certs(devices_ids) # Exports the certificates' files self.export_certs() # Retrieving the CA certificate self.retrieve_ca_cert() # Mapping the certificates self.map_device_ids()
def test_successfully_create_two_devices_two_batches(self, mock_requests): """ Should successfully create two devices in two batches. """ DojotAPI.divide_loads.return_value = [1, 1] self.args["data"] = json.dumps({ "templates": [self.template_id], "attrs": {}, "label": "CargoContainer_1" }) DojotAPI.create_devices(self.jwt, self.template_id, 2, 2) DojotAPI.divide_loads.assert_called_once_with(2, 2) self.assertEqual(DojotAPI.divide_loads.return_value, [1, 1]) self.assertEqual(DojotAPI.call_api.call_count, 2) DojotAPI.call_api.assert_has_calls([ mock.call(mock_requests.post, self.args, False), mock.call(mock_requests.post, self.args, False) ])
def get_template_id(self): """ Retrieves the test template ID from the database or create a new one. """ template_id = self.mapped.get('template_id').decode('utf-8') if template_id == "-1": jwt = self.get_jwt() template_id = DojotAPI.create_template(jwt) self.mapped.set('template_id', template_id) return template_id
def get_jwt(self): """ Retrieves the JWT from the dadtabase or create a new one. """ jwt = self.mapped.get('jwt') if jwt: return jwt.decode('utf-8') jwt = DojotAPI.get_jwt() self.mapped.setex('jwt', CONFIG['locust']['redis']['jwt_expire_time'], jwt) return jwt
def test_successfully_get_devices(self, mock_requests): """ Should successfully get devices. """ DojotAPI.call_api.side_effect = [{ "devices": [{"id": 0}, {"id": 1}], "pagination": { "total": 2 } }, [0], [1]] devices = DojotAPI.get_devices("testJWT") self.assertEqual(DojotAPI.call_api.call_count, 3) DojotAPI.call_api.assert_called_with(mock_requests.get, ANY) self.assertEqual(devices, [0, 1])
def test_successfully_no_devices(self, mock_requests): """ Should successfully get an empty list of devices. """ DojotAPI.call_api.return_value = { "devices": [], "pagination": { "total": 0 } } devices = DojotAPI.get_devices("testJWT") DojotAPI.call_api.assert_called_once() DojotAPI.call_api.assert_called_with(mock_requests.get, ANY) self.assertEqual(devices, [])
def get_device_id(self): """ Get the device ID. """ device_id = None if CONFIG['dojot']['env']: jwt = self.get_jwt() template_id = self.get_template_id() device_id = DojotAPI.create_device( jwt, template_id, "CargoContainer_{0}".format(str(uuid4()).replace("-", ""))) else: device_id = str(uuid4()).replace("-", "") return device_id
def test_should_get_response(self, mock_requests, mock_gevent): """ Should successfully receive a response from a POST call. """ mock_requests.post = MagicMock() mock_requests.post.return_value.json = PropertyMock(return_value={"return": "testReturn"}) args = { "url": "testURL", "data": "\"testJson\": \"testData\"", "headers": "testHeader" } res = DojotAPI.call_api(mock_requests.post, args) mock_requests.post.assert_called_once_with(**args) mock_gevent.sleep.assert_not_called() mock_requests.post.return_value.json.assert_called_once() self.assertEqual(res, {"return": "testReturn"})
def test_should_not_return_json(self, mock_requests, mock_gevent): """ Should successfully make a POST call but do not return a JSON. """ mock_requests.post = MagicMock() mock_requests.post.return_value.json = PropertyMock(return_value={"return": "testReturn"}) args = { "url": "testURL", "data": "\"testJson\": \"testData\"", "headers": "testHeader" } res = DojotAPI.call_api(mock_requests.post, args, False) mock_requests.post.assert_called_once_with(**args) mock_gevent.sleep.assert_not_called() mock_requests.post.return_value.json.assert_not_called() self.assertIsNone(res)
def redis_commands(self): """ Redis commands execution. """ if self.parser_args.restore: self.restore_db_state() elif self.parser_args.clear: self.clear_db() self.restore_db_state() elif self.parser_args.map: self.map_device_ids() elif self.parser_args.export: # Retrieve JWT token self.jwt = DojotAPI.get_jwt() # Exports the certificates' files self.export_certs() # Retrieving the CA certificate self.retrieve_ca_cert()
def test_successfully_get_jwt(self, mock_requests): """ Should successfully get a JWT from Dojot. """ args = { "url": "{0}/auth".format(MOCK_CONFIG['dojot']['url']), "data": json.dumps({ "username": MOCK_CONFIG['dojot']['user'], "passwd": MOCK_CONFIG['dojot']['passwd'], }), "headers": { "Accept": "application/json", "Content-Type": "application/json" }, } DojotAPI.call_api.return_value = {"jwt": "testJWT"} jwt = DojotAPI.get_jwt() DojotAPI.call_api.assert_called_once() DojotAPI.call_api.assert_called_with(mock_requests.post, args) self.assertEqual(jwt, "testJWT")
def delete_templates(self, ) -> None: """ Deletes all devices. """ DojotAPI.delete_templates(self.jwt)