def _match(self, stats): expect(stats.summary).not_to(be_none) expect(stats.units).not_to(be_none) if stats.summary.min: expect(stats.summary.max).to(be_above_or_equal(stats.summary.min)) # Work around jitter_ipdv stat, which can be negative if stats.summary.min > 0: expect(stats.summary.total).to(be_above(0)) expect(stats.summary.max).to(be_above(0)) if stats.summary.min != stats.summary.max: expect(stats.summary.std_dev).to(be_above_or_equal(0)) return True, ['is valid non zero summary statistic']
def _match(self, counters): expect(counters).to(be_a(client.models.PacketAnalyzerFlowCounters)) expect(counters.frame_count).not_to(be_none) # Check optional summary statistics if counters.frame_count > 0: if counters.frame_length: expect(counters.frame_length).to( be_valid_non_zero_summary_statistic) if counters.latency: expect( counters.latency).to(be_valid_non_zero_summary_statistic) if counters.sequence: total = (counters.sequence.duplicate + counters.sequence.late + counters.sequence.reordered + counters.sequence.in_order) expect(total).to(equal(counters.frame_count)) if counters.frame_count > 1: if counters.interarrival: expect(counters.interarrival).to( be_valid_non_zero_summary_statistic) if counters.jitter_ipdv: expect(counters.jitter_ipdv).to( be_valid_non_zero_summary_statistic) if counters.jitter_rfc: expect(counters.jitter_rfc).to( be_valid_non_zero_summary_statistic) # 0 < timestamp_first <= timestamp_last expect(counters.timestamp_last).to( be_above(counters.timestamp_first)) duration = counters.timestamp_last - counters.timestamp_first expect(duration).to(be_above_or_equal(datetime.timedelta(0))) return True, ['is valid packet analyzer flow counter']
def _match(self, result): expect(result).to(be_a(client.models.PacketAnalyzerFlowDigestResult)) if result.centroids: for i in range(len(result.centroids) - 1): left = result.centroids[i] right = result.centroids[i + 1] expect(int(right.mean)).to(be_above_or_equal(int(left.mean))) return True, ['is valid packet analyzer flow digest result']
def _match(self, config): expect(config).to(be_a(client.models.PacketGeneratorConfig)) if (config.flow_count): expect(config.flow_count).to(be_above_or_equal(1)) expect(config.duration).to(be_valid_traffic_duration) expect(config.load).to(be_valid_traffic_load) expect(config.traffic).not_to(be_empty) for definition in config.traffic: expect(definition).to(be_valid_traffic_definition) return True, ['is valid packet generator config']
def _match(self, length): expect(length).to(be_a(client.models.TrafficLength)) has_property = False if (length.fixed): expect(length.fixed).to(be_above_or_equal(64)) has_property = True if (length.list): expect(length.list).not_to(be_empty) for l in length.list: expect(l).to(be_above_or_equal(64)) has_property = True if (length.sequence): expect(length.sequence).to( be_a(client.models.TrafficLengthSequence)) expect(length.sequence.count).to(be_above(0)) expect(length.sequence.start).to(be_above_or_equal(64)) has_property = True expect(has_property).to(be_true) return True, ['is valid traffic length']
def test_add_recipients_to_existing_message(self, recipients): message = Message( connection=self.connection, collector_id=self.collector_id, message_id=self.message_id, ) with HTTMock(self.mock.recipient_add): response = message.recipients(recipients) expect(response["succeeded"]).to(have_length(be_above_or_equal(1)))
def test_create_new_message_and_add_a_recipients(self, recipients): message = Message(connection=self.connection, collector_id=self.collector_id, config=self.config) with HTTMock(MessagesMock(self.config).create): message.create() with HTTMock(self.mock.recipient_add): response = message.recipients(recipients) expect(response["succeeded"]).to(have_length(be_above_or_equal(1)))
def _post_users(self, client, data_trust_id, token_generator): ''' Helper function that creates (and tests creating) a several Users. ''' headers = { 'content-type': 'application/json', 'authorization': f'bearer {token_generator.get_token(client)}' } for user in USERS: user['data_trust_id'] = data_trust_id response = client.post('/users', data=json.dumps(user), headers=headers) response_data = response.json expect(response.status_code).to(be(201)) response = client.get('/users', headers=headers) expect(len(response.json['response'])).to(be_above_or_equal(3))
def test_scope_api(self, client, token_generator): # Common headers go in this dict headers = {'content-type': 'application/json', 'authorization': f'bearer {token_generator.get_token(client)}'} response = client.get('/scopes', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) print(f'******** {response.json}') expect(len(response_data['response'])).to(equal(0)) # POST some new scoeps scope_ids = [] for scope in SCOPES: response = client.post('/scopes', data=json.dumps(scope), headers=headers) expect(response.status_code).to(be(201)) scope_ids.append(response.json['response'][0]['id']) # PATCH the first scope patched_scope = { 'scope': SCOPES[0]['scope'].capitalize() } response = client.patch(f'/scopes/{scope_ids[0]}', data=json.dumps(patched_scope), headers=headers) expect(response.status_code).to(be(200)) # Repost the second scope with PUT response = client.put(f'/scopes/{scope_ids[1]}', data=json.dumps(SCOPES[1]), headers=headers) expect(response.status_code).to(be(200)) # Raise a 4xx status code if a scope is duplicated response = client.post(f'/scopes/{scope_ids[2]}') expect(response.status_code).to(be_above_or_equal(400)) # Delete all scopes for id in scope_ids: response = client.delete(f'/scopes/{id}', headers=headers) expect(response.status_code).to(be(200)) response = client.get('/scopes', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data['response'])).to(equal(0))
def post_users(users, client, token): # def post_users(users, client, organization_id, token_generator): ''' Helper function that creates (and tests creating) a collection of Users. ''' headers = { 'content-type': 'application/json', 'authorization': f'bearer {token}' } user_ids = [] for user in users: user['active'] = True response = client.post('/users', data=json.dumps(user), headers=headers) expect(response.status_code).to(equal(201)) user_ids.append(response.json['response'][0]['id']) expect(len(user_ids)).to(be_above_or_equal(len(users))) return user_ids
def test_ge_is_false_if_other_is_not_empty_fake(self): expect(EmptyFake()).not_to(be_above_or_equal(42))
def test_ge_is_true_if_other_is_empty_fake(self): expect(EmptyFake()).to(be_above_or_equal(EmptyFake()))
def test_data_trust_api(self, client, token_generator): # Common headers go in this dict headers = {'content-type': 'application/json', 'authorization': f'bearer {token_generator.get_token(client)}'} # Database should have pre-populated data trust at the beginning response: Response = client.get('/data_trusts', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data['response'])).to(equal(1)) # POST a new data trust request_body = { 'data_trust_name': 'BrightHive Test Data Trust' } response = client.post( '/data_trusts', data=json.dumps(request_body), headers=headers) expect(response.status_code).to(be(201)) response_data = response.json data_trust_id = response_data['response'][0]['id'] # GET all response: Response = client.get('/data_trusts', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data['response'])).to(be_above_or_equal(1)) # Attempt to POST the same data trust response = client.post( '/data_trusts', data=json.dumps(request_body), headers=headers) expect(response.status_code).to(be_above_or_equal(400)) # GET the data trust by ID response = client.get( '/data_trusts/{}'.format(data_trust_id), headers=headers) expect(response.status_code).to(be(200)) # Create a new data trust request_body['data_trust_name'] = 'BrightHive Test Data Trust 2' response = client.post( '/data_trusts', data=json.dumps(request_body), headers=headers) expect(response.status_code).to(be(201)) response_data = response.json data_trust_id_2 = response_data['response'][0]['id'] expect(data_trust_id).not_to(equal(data_trust_id_2)) # Attempt to name both data trusts the same response = client.put('/data_trusts/{}'.format(data_trust_id), data=json.dumps(request_body), headers=headers) expect(response.status_code).to(be_above_or_equal(400)) response = client.patch('/data_trusts/{}'.format(data_trust_id), data=json.dumps(request_body), headers=headers) expect(response.status_code).to(be_above_or_equal(400)) # Rename data trust 2 with a PUT new_name = str(reversed(request_body['data_trust_name'])) request_body['data_trust_name'] = new_name response = client.put('/data_trusts/{}'.format(data_trust_id_2), data=json.dumps(request_body), headers=headers) expect(response.status_code).to(equal(200)) # Rename data trust 2 with a PATCH new_name = str(reversed(request_body['data_trust_name'])) request_body['data_trust_name'] = new_name response = client.patch('/data_trusts/{}'.format(data_trust_id_2), data=json.dumps(request_body), headers=headers) expect(response.status_code).to(equal(200)) # DELETE the data trusts response = client.delete( '/data_trusts/{}'.format(data_trust_id), headers=headers) response = client.delete( '/data_trusts/{}'.format(data_trust_id_2), headers=headers) expect(response.status_code).to(be(200))
def test_user_api(self, client, token_generator): # Common headers go in this dict headers = { 'content-type': 'application/json', 'authorization': f'bearer {token_generator.get_token(client)}' } # Database should be empty at the beginning response: Response = client.get('/data_trusts', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data['response'])).to(be_above_or_equal(1)) response = client.get('/users', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data['response'])).to(equal(1)) # Populate database with a data trust and users data_trust_id = self._post_data_trust(client, token_generator) self._post_users(client, data_trust_id, token_generator) # GET all users response = client.get('/users', headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data['response'])).to(be_above_or_equal(3)) added_users = response_data['response'] # Attempt to POST an existing user response = client.post('/users', data=json.dumps(USERS[0]), headers=headers) expect(response.status_code).to(be_above_or_equal(400)) # Get all users by ID for user in added_users: response = client.get('/users/{}'.format(user['id']), headers=headers) expect(response.status_code).to(be(200)) # Rename a user with a PATCH user_id = added_users[0]['id'] new_name = str(reversed(added_users[0]['firstname'])) single_field_update = {'firstname': new_name} response = client.patch('/users/{}'.format(user_id), data=json.dumps(single_field_update), headers=headers) expect(response.status_code).to(equal(200)) # Rename a user with a PUT, expect to fail because not all fields specified response = client.put('/users/{}'.format(user_id), data=json.dumps(single_field_update), headers=headers) expect(response.status_code).to(equal(422)) # Rename a user with a PUT, providing the entire object added_users[0]['firstname'] = new_name added_users[0]['password'] = '******' if not added_users[0]['telephone']: added_users[0]['telephone'] = 'N/A' response = client.put('/users/{}'.format(user_id), data=json.dumps(added_users[0]), headers=headers) expect(response.status_code).to(equal(200)) # DELETE the data trusts and by extension delete the users response = client.delete('/data_trusts/{}'.format(data_trust_id), headers=headers) expect(response.status_code).to(equal(200)) # Ensure users have been deleted by the deletion of the data trust associated with them. response = client.get('/users', headers=headers) expect(response.status_code).to(be(200)) response_data = response.json expect(len(response_data['response'])).to(equal(1))
expect((ok, res)).to(be_successful_api_call) expect(res).to(have_key("events", be_empty)) with it("is able to retrieve the last event only"): ok, res = self.client.get_events(limit=1) expect((ok, res)).to(be_successful_api_call) expect(res).to(have_key("events", have_len(1))) with it("is able to retrieve the events from the last day"): to_s = datetime.now() from_s = to_s - timedelta(weeks=2) ok, res = self.client.get_events(from_s=from_s, to_s=to_s) expect((ok, res)).to(be_successful_api_call) expect(res).to(have_key("events", have_len(be_above_or_equal(1)))) with context("but the from and to parameters are incorrectly specified"): with it("returns an error if any of the parameters is specified but not the other" ): t = datetime.now() - timedelta(weeks=2) ok1, res1 = self.client.get_events(from_s=t) ok2, res2 = self.client.get_events(to_s=t) expect((ok1, res1)).not_to(be_successful_api_call) expect((ok2, res2)).not_to(be_successful_api_call) expect(res1).to( equal("only one of 'from_s' or 'to_s' has been specified, " "both are required when filtering by time")) expect(res2).to( equal("only one of 'from_s' or 'to_s' has been specified, "
def test_user_api(self, client, token_generator): # Common headers go in this dict headers = { "content-type": "application/json", "authorization": f"bearer {token_generator.get_token(client)}", } response = client.get("/users", headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data["response"])).to(equal(1)) # Populate database with users post_users(USERS, client, token_generator.get_token(client)) # GET all users response = client.get("/users", headers=headers) response_data = response.json expect(response.status_code).to(be(200)) expect(len(response_data["response"])).to(be_above_or_equal(3)) added_users = response_data["response"] # Store ID for all users since we will break the data. added_user_ids = [] for user in added_users: added_user_ids.append(user["id"]) # Attempt to POST an existing user response = client.post("/users", data=json.dumps(USERS[0]), headers=headers) expect(response.status_code).to(be_above_or_equal(400)) # Get all users by ID for user in added_users: response = client.get("/users/{}".format(user["id"]), headers=headers) expect(response.status_code).to(be(200)) # Update a user with a PATCH user_id = added_users[len(added_users) - 1]["id"] new_person_id = str( reversed(added_users[len(added_users) - 1]["person_id"])) single_field_update = {"person_id": new_person_id} response = client.patch( "/users/{}".format(user_id), data=json.dumps(single_field_update), headers=headers, ) expect(response.status_code).to(equal(200)) # Rename a user with a PUT, expect to fail because not all fields specified response = client.put( "/users/{}".format(user_id), data=json.dumps(single_field_update), headers=headers, ) expect(response.status_code).to(equal(422)) # Rename a user with a PUT, providing the entire object user_to_update = added_users[len(added_users) - 1] user_to_update["password"] = "******" user_to_update.pop("role", None) user_to_update.pop("date_created", None) user_to_update.pop("id", None) user_to_update.pop("date_last_updated", None) response = client.put( "/users/{}".format(user_id), data=json.dumps(user_to_update), headers=headers, ) expect(response.status_code).to(equal(200)) # Delete users for user_id in added_user_ids: response = client.delete(f"/users/{user_id}", headers=headers) expect(response.status_code).to(be(200))