def test_retrieve_report_metadata_missing_blood_ref(self, mock_sqlalchemy): mock_sqlalchemy.or_ = Mock() mock_session = Mock() mock_session.query = Mock() mock_session.query().filter().all = Mock(side_effect=[[], []]) self.assertRaises(ValueError, metadata.retrieve_report_metadata, "03098121", "03098849", mock_session, self.id2addresses)
def test_retrieve_report_metadata_double_tumor_ref(self, mock_sqlalchemy): mock_sqlalchemy.or_ = Mock() mock_session = Mock() mock_session.query = Mock() mock_session.query().filter().all = Mock(side_effect=[["dummy"], ["dummy1", "dummy2"]]) self.assertRaises(ValueError, metadata.retrieve_report_metadata, "03098121", "03098849", mock_session, self.id2addresses)
def test_query_database_no_barcode_attributes(self, mock_sqlalchemy): mock_sqlalchemy.or_ = Mock() mock_referral_type = Mock() mock_session = Mock() mock_session.query = Mock() mock_session.query().filter().all = Mock(side_effect=[["dummy"]]) self.assertRaises(ValueError, metadata.query_database, "03098121", mock_referral_type, mock_session)
def test_query_database_one_hit(self, mock_sqlalchemy): mock_sqlalchemy.or_ = Mock() mock_referral_type = Mock() mock_referral_type.barcode1 = "03098121" mock_session = Mock() mock_session.query = Mock() mock_session.query().filter().all = Mock(side_effect=[["dummy"]]) output = metadata.query_database("03098121", mock_referral_type, mock_session) self.assertEqual(output, "dummy")
def test_get_df_handles_dttm_col(self): form_data = {'dummy': 123} query_obj = {'granularity': 'day'} results = Mock() results.query = Mock() results.status = Mock() results.error_message = Mock() datasource = Mock() datasource.type = 'table' datasource.query = Mock(return_value=results) mock_dttm_col = Mock() datasource.get_col = Mock(return_value=mock_dttm_col) test_viz = viz.BaseViz(datasource, form_data) test_viz.df_metrics_to_num = Mock() test_viz.get_fillna_for_columns = Mock(return_value=0) results.df = pd.DataFrame(data={DTTM_ALIAS: ['1960-01-01 05:00:00']}) datasource.offset = 0 mock_dttm_col = Mock() datasource.get_col = Mock(return_value=mock_dttm_col) mock_dttm_col.python_date_format = 'epoch_ms' result = test_viz.get_df(query_obj) print(result) import logging logging.info(result) pd.testing.assert_series_equal( result[DTTM_ALIAS], pd.Series([datetime(1960, 1, 1, 5, 0)], name=DTTM_ALIAS), ) mock_dttm_col.python_date_format = None result = test_viz.get_df(query_obj) pd.testing.assert_series_equal( result[DTTM_ALIAS], pd.Series([datetime(1960, 1, 1, 5, 0)], name=DTTM_ALIAS), ) datasource.offset = 1 result = test_viz.get_df(query_obj) pd.testing.assert_series_equal( result[DTTM_ALIAS], pd.Series([datetime(1960, 1, 1, 6, 0)], name=DTTM_ALIAS), ) datasource.offset = 0 results.df = pd.DataFrame(data={DTTM_ALIAS: ['1960-01-01']}) mock_dttm_col.python_date_format = '%Y-%m-%d' result = test_viz.get_df(query_obj) pd.testing.assert_series_equal( result[DTTM_ALIAS], pd.Series([datetime(1960, 1, 1, 0, 0)], name=DTTM_ALIAS), )
def test_retrieve_report_metadata_mismatching_ids(self, mock_sqlalchemy): mock_sqlalchemy.or_ = Mock() mock_session = Mock() mock_session.query = Mock() mock_blood_ref = Mock() mock_blood_ref.pnr = "1212121212" mock_tissue_ref = Mock() mock_tissue_ref.pnr = "1212121213" mock_session.query().filter().all = Mock(side_effect=[[mock_blood_ref], [mock_tissue_ref]]) self.assertRaises(ValueError, metadata.retrieve_report_metadata, "03098121", "03098849", mock_session, self.id2addresses)
def test_report_customers_by_products(self): """ Unit test to customers grouped by product report. """ # Mock sale model and products models salesList = [] keys = [2, 1, 3, 2, 1] for x in keys: sale = Mock(spec_set=saleModel.SaleModel()) sale.product = Mock(spec_set=productModel.ProductModel()) sale.product.key = Mock(spec_set=ndb.Key('ProductModel', x)) sale.product.key.id = Mock(return_value=x) sale.product.key.get = Mock(return_value=sale.product) salesList.append(sale) # Mock customers models keys = [{'id': '1', 'name': 'Test1'}, {'id': '2', 'name': 'Test2'}] for sale in salesList: sale.customer = Mock(spec_set=customerModel.CustomerModel()) customer = keys[randint(0, 1)] sale.customer.key = Mock( spec_set=ndb.Key('CustomerModel', customer['id'])) sale.customer.key.id = Mock(return_value=customer['id']) sale.customer.key.get = Mock(return_value=customer) sale.customer.name = PropertyMock(return_value=customer['name']) # Mock fetch method mockSale = Mock(spec_set=saleModel.SaleModel()) mockSale.query = Mock(spec=mockSale.query) mockSale.query().fetch = MagicMock(return_value=salesList) # Set get_sales_query to return query mocked saleModel.get_sales_query = MagicMock(return_value=mockSale.query()) # Call report_customers_by_product method result = saleModel.report_customers_by_products() # Must have lenght == 3 self.assertEqual(len(result), 3) # The result must be: # Product 1 => 2 Customers # Product 2 => 2 Customers # Product 3 => 1 Customer self.assertEqual(len(result[0]['customers']), 2) self.assertEqual(len(result[1]['customers']), 2) self.assertEqual(len(result[2]['customers']), 1) # And the products must be ordered self.assertEqual(result[0]['product'].key.id(), 1) self.assertEqual(result[1]['product'].key.id(), 2) self.assertEqual(result[2]['product'].key.id(), 3)
def test_get_df_handles_dttm_col(self): datasource = Mock() datasource.type = 'table' datasource.offset = 1 mock_dttm_col = Mock() mock_dttm_col.python_date_format = 'epoch_ms' datasource.get_col = Mock(return_value=mock_dttm_col) form_data = {'dummy': 123} query_obj = {'granularity': 'day'} results = Mock() results.query = Mock() results.status = Mock() results.error_message = Mock() df = Mock() df.columns = [DTTM_ALIAS] f_datetime = datetime(1960, 1, 1, 5, 0) df.__getitem__ = Mock(return_value=pd.Series([f_datetime])) df.__setitem__ = Mock() df.replace = Mock() df.fillna = Mock() results.df = df results.df.empty = False datasource.query = Mock(return_value=results) test_viz = viz.BaseViz(datasource, form_data) test_viz.df_metrics_to_num = Mock() test_viz.get_fillna_for_columns = Mock(return_value=0) test_viz.get_df(query_obj) mock_call = df.__setitem__.mock_calls[0] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertFalse(mock_call[1][1].empty) self.assertEqual(mock_call[1][1][0], f_datetime) mock_call = df.__setitem__.mock_calls[1] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertEqual(mock_call[1][1][0].hour, 6) self.assertEqual(mock_call[1][1].dtype, 'datetime64[ns]') mock_dttm_col.python_date_format = 'utc' test_viz.get_df(query_obj) mock_call = df.__setitem__.mock_calls[2] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertFalse(mock_call[1][1].empty) self.assertEqual(mock_call[1][1][0].hour, 7) mock_call = df.__setitem__.mock_calls[3] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertEqual(mock_call[1][1][0].hour, 6) self.assertEqual(mock_call[1][1].dtype, 'datetime64[ns]') mock_call = df.__setitem__.mock_calls[4] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertEqual(mock_call[1][1][0].hour, 7) self.assertEqual(mock_call[1][1].dtype, 'datetime64[ns]')
def test_report_products_by_customers(self): """ Unit test to products grouped by customers report. """ # Mock sale model and products models salesList = [] keys = [2, 1, 3, 2, 1] for x in keys: sale = Mock(spec_set=saleModel.SaleModel()) sale.customer = Mock(spec_set=customerModel.CustomerModel()) sale.customer.key = Mock(spec_set=ndb.Key('CustomerModel', x)) sale.customer.key.id = Mock(return_value=x) sale.customer.key.get = Mock(return_value=sale.customer) salesList.append(sale) # Mock products models keys = [2, 3, 1] for sale in salesList: sale.product = Mock(spec_set=productModel.ProductModel()) key_id = keys[randint(0, 2)] sale.product.key = Mock( spec_set=ndb.Key('ProductModel', key_id)) sale.product.key.id = Mock(return_value=key_id) sale.product.key.get = Mock(return_value=sale.product) # Mock fetch method mockSale = Mock(spec_set=saleModel.SaleModel()) mockSale.query = Mock(spec=mockSale.query) mockSale.query().fetch = MagicMock(return_value=salesList) # Set get_sales_query to return query mocked saleModel.get_sales_query = MagicMock(return_value=mockSale.query()) # Call report_customers_by_product method result = saleModel.report_products_by_customers() # Must have lenght == 3 self.assertEqual(len(result), 3) # The result must be: # Customer 1 => 2 Customers # Customer 2 => 2 Customers # Customer 3 => 1 Customer self.assertEqual(len(result[0]['products']), 2) self.assertEqual(len(result[1]['products']), 2) self.assertEqual(len(result[2]['products']), 1) # And the customers must be ordered self.assertEqual(result[0]['customer'].key.id(), 1) self.assertEqual(result[1]['customer'].key.id(), 2) self.assertEqual(result[2]['customer'].key.id(), 3)
def test_report_products_by_customers(self): """ Unit test to products grouped by customers report. """ # Mock sale model and products models salesList = [] keys = [2, 1, 3, 2, 1] for x in keys: sale = Mock(spec_set=saleModel.SaleModel()) sale.customer = Mock(spec_set=customerModel.CustomerModel()) sale.customer.key = Mock(spec_set=ndb.Key('CustomerModel', x)) sale.customer.key.id = Mock(return_value=x) sale.customer.key.get = Mock(return_value=sale.customer) salesList.append(sale) # Mock products models keys = [2, 3, 1] for sale in salesList: sale.product = Mock(spec_set=productModel.ProductModel()) key_id = keys[randint(0, 2)] sale.product.key = Mock(spec_set=ndb.Key('ProductModel', key_id)) sale.product.key.id = Mock(return_value=key_id) sale.product.key.get = Mock(return_value=sale.product) # Mock fetch method mockSale = Mock(spec_set=saleModel.SaleModel()) mockSale.query = Mock(spec=mockSale.query) mockSale.query().fetch = MagicMock(return_value=salesList) # Set get_sales_query to return query mocked saleModel.get_sales_query = MagicMock(return_value=mockSale.query()) # Call report_customers_by_product method result = saleModel.report_products_by_customers() # Must have lenght == 3 self.assertEqual(len(result), 3) # The result must be: # Customer 1 => 2 Customers # Customer 2 => 2 Customers # Customer 3 => 1 Customer self.assertEqual(len(result[0]['products']), 2) self.assertEqual(len(result[1]['products']), 2) self.assertEqual(len(result[2]['products']), 1) # And the customers must be ordered self.assertEqual(result[0]['customer'].key.id(), 1) self.assertEqual(result[1]['customer'].key.id(), 2) self.assertEqual(result[2]['customer'].key.id(), 3)
def test_get_df_returns_empty_df(self): datasource = Mock() datasource.type = 'table' form_data = {'dummy': 123} query_obj = {'granularity': 'day'} results = Mock() results.query = Mock() results.status = Mock() results.error_message = None results.df = pd.DataFrame() datasource.query = Mock(return_value=results) test_viz = viz.BaseViz(datasource, form_data) result = test_viz.get_df(query_obj) self.assertEqual(type(result), pd.DataFrame) self.assertTrue(result.empty)
def test_unicode_input(self): query = Mock() unicode_payload = u'árvíztűrő tükörfúrógép' for answerer in answerers: query.query = u'{} {}'.format(answerer.keywords[0], unicode_payload) self.assertTrue(isinstance(answerer.answer(query), list))
def get_datasource_mock(self): datasource = Mock() results = Mock() results.query = Mock() results.status = Mock() results.error_message = None results.df = pd.DataFrame() datasource.type = 'table' datasource.query = Mock(return_value=results) mock_dttm_col = Mock() datasource.get_col = Mock(return_value=mock_dttm_col) datasource.query = Mock(return_value=results) datasource.database = Mock() datasource.database.db_engine_spec = Mock() datasource.database.db_engine_spec.mutate_expression_label = lambda x: x return datasource
def test_run(self, *mocks): eddaclient = Mock() eddaclient._since = 500 def ret_list(args): return [ {'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': '500', 'tags': [{'key': 'service_name', 'value': 'conversion'}, {'key': 'started_by', 'value': 'john'}]}, {'imageId': 'ami-1', 'instanceId': 'b', 'launchTime': '2000', 'tags': [{'key': 'service_name', 'value': 'router'}]}, {'imageId': 'ami-2', 'instanceId': 'c', 'launchTime': '400'}] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.clean = Mock(return_value=m) self.plugin.init(eddaclient, self.config, {'first_seen': {"ami-1": 1000, "ami-2": 400}}) real = self.plugin.run() expected = [ {'id': 'ami-1', 'plugin_name': 'ami', 'details': [ ('a', 500, [{'service_name': 'conversion'}, {'started_by': 'john'}]), ('b', 2000, [{'service_name': 'router'}])]} ] self.assertEqual(expected, real) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')]) self.assertEqual(self.plugin.status, {'first_seen': {'ami-1': 500, 'ami-2': 400}})
def test_run(self, *mocks): eddaclient = Mock() eddaclient._since = 200 def ret_list(args): return [ {"imageId": "ami-1", "instanceId": "a", "launchTime": 400, "tags": [{"key": "Name", "value": "tag1"}]}, { "imageId": "ami-2", "instanceId": "b", "launchTime": 600, "tags": [{"key": "service_name", "value": "foo"}], }, { "imageId": "ami-3", "instanceId": "c", "launchTime": 800, "tags": [{"key": "Name", "value": "tag1"}, {"key": "service_name", "value": "foo"}], }, ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.clean = Mock(return_value=m) self.plugin.init(eddaclient, Mock(), {}) # run the tested method self.assertEqual(self.plugin.run(), [{"details": ["n/a"], "id": "a", "plugin_name": "missingtag"}]) m.query.assert_has_calls([call("/api/v2/view/instances;_expand")])
def test_run(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() eddaclient._since = 500 def ret_list(args): return [ {'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': 400, "tags": [{"key": "Name", "value": "tag1"}]}, {'imageId': 'ami-2', 'instanceId': 'b', 'launchTime': 600, "tags": [{"key": "service_name", "value": "foo"}]}, {'imageId': 'ami-3', 'instanceId': 'c', 'launchTime': 800, "tags": [{"key": "Name", "value": "tag1"}, {"key": "service_name", "value": "foo"}]}, ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.clean = Mock(return_value=m) self.plugin.init(eddaclient, Mock(), {}, instance_enricher) # run the tested method result = self.plugin.run() self.assertEqual(1, len(result)) result = result[0] self.assertEqual("foo", result["id"]) self.assertEqual(2, len(result["details"])) self.assertIn("b", [d["instanceId"] for d in result["details"]]) self.assertIn("c", [d["instanceId"] for d in result["details"]]) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')])
def test_ignore_tags(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() eddaclient._since = 500 def ret_list(args): return [{ 'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': 400, "tags": [{ "key": "Name", "value": "tag1" }] }, { 'imageId': 'ami-2', 'instanceId': 'b', 'launchTime': 600, "tags": [{ "key": "service_name", "value": "testapp" }] }] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.clean = Mock(return_value=m) self.plugin.init(eddaclient, Mock(), {}, instance_enricher) # run the tested method result = self.plugin.run() self.assertEqual(0, len(result)) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')])
def test_search(): """ Test search via a mock """ # Mock the database object db = Mock() searcher = textsearcher.TextSearcher(db) # Verify connect has been called with no arguments db.connect.assert_called_with() # Setup searcher searcher.setup(cache=True, max_items=100) # Verify configure called on db with correct parameter searcher.db.configure.assert_called_with(max_items=100) canned_results = [('Python is wonderful', 0.4), ('I like Python', 0.8), ('Python is easy', 0.5), ('Python can be learnt in an afternoon!', 0.3)] db.query = MagicMock(return_value=canned_results) # Mock the results data keyword, num = 'python', 3 data = searcher.get_results(keyword, num=num) searcher.db.query.assert_called_with(keyword) # Verify data results = sorted(canned_results, key=operator.itemgetter(1), reverse=True)[:num] assert data == results
def test_old_query_params_except_offset(self): uri = Mock() uri.query = "foo=bar&spam=ham" result = [] helpers._get_old_query_params_except_offset(result, uri) self.assertEqual(result, ["foo=bar", "spam=ham"])
def test_old_query_params_except_offset_with_equals(self): uri = Mock() uri.query = "foo=spam=ham&offset=bar" result = [] helpers._get_old_query_params_except_offset(result, uri) self.assertEqual(result, ["foo=spam%3Dham"])
def test_skipped_service(self): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() eddaclient.query = Mock( return_value=[{ 'imageId': 'ami-1', 'instanceId': 'b', 'launchTime': '2000', 'tags': [{ 'key': 'service_name', 'value': 'jenkins' }] }]) uncleaned_eddaclient = Mock() uncleaned_eddaclient.soft_clean = Mock(return_value=eddaclient) uncleaned_eddaclient._since = 500 self.plugin.init(uncleaned_eddaclient, self.config, {'first_seen': {}}, instance_enricher) real = self.plugin.run() expected = [] self.assertEqual(expected, real) eddaclient.query.assert_has_calls( [call('/api/v2/view/instances;_expand')])
def test_run(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() eddaclient._since = 500 def ret_list(args): return [ {'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': '500', 'tags': [{'key': 'service_name', 'value': 'conversion'}, {'key': 'started_by', 'value': 'john'}]}, {'imageId': 'ami-1', 'instanceId': 'b', 'launchTime': '2000', 'tags': [{'key': 'service_name', 'value': 'router'}]}, {'imageId': 'ami-2', 'instanceId': 'c', 'launchTime': '400'}] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.soft_clean = Mock(return_value=m) self.plugin.init(eddaclient, self.config, {'first_seen': {"ami-1": 1000, "ami-2": 400}}, instance_enricher) result = self.plugin.run() self.assertEqual(1, len(result)) result = result[0] self.assertEqual('ami-1', result['id']) self.assertEqual(2, len(result['details'])) self.assertIn('a', [d['instanceId'] for d in result['details']]) self.assertIn('b', [d['instanceId'] for d in result['details']]) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')]) self.assertEqual(self.plugin.status, {'first_seen': {'ami-1': 500, 'ami-2': 400}})
def test_run(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() eddaclient._since = 500 def ret_list(args): return [{ 'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': '500', 'tags': [{ 'key': 'service_name', 'value': 'conversion' }, { 'key': 'started_by', 'value': 'john' }] }, { 'imageId': 'ami-1', 'instanceId': 'b', 'launchTime': '2000', 'tags': [{ 'key': 'service_name', 'value': 'router' }] }, { 'imageId': 'ami-2', 'instanceId': 'c', 'launchTime': '400' }] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.soft_clean = Mock(return_value=m) self.plugin.init(eddaclient, self.config, {'first_seen': { "ami-1": 1000, "ami-2": 400 }}, instance_enricher) result = self.plugin.run() self.assertEqual(1, len(result)) result = result[0] self.assertEqual('ami-1', result['id']) self.assertEqual(2, len(result['details'])) self.assertIn('a', [d['instanceId'] for d in result['details']]) self.assertIn('b', [d['instanceId'] for d in result['details']]) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')]) self.assertEqual(self.plugin.status, {'first_seen': { 'ami-1': 500, 'ami-2': 400 }})
def test_run(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() eddaclient._since = 200 def ret_list(args): return [ { 'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': 400, "tags": [{ "key": "Name", "value": "tag1" }] }, { 'imageId': 'ami-2', 'instanceId': 'b', 'launchTime': 600, "tags": [{ "key": "service_name", "value": "foo" }] }, { 'imageId': 'ami-3', 'instanceId': 'c', 'launchTime': 800, "tags": [{ "key": "Name", "value": "tag1" }, { "key": "service_name", "value": "foo" }] }, ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.clean = Mock(return_value=m) self.plugin.init(eddaclient, Mock(), {}, instance_enricher) # run the tested method result = self.plugin.run() self.assertEqual(1, len(result)) result = result[0] self.assertEqual( "tag1", result["id"] ) # service_type became the new id, which in this case is the Name tag self.assertEqual(1, len(result["details"])) self.assertIn("instanceId", result["details"][0]) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')])
def mock_sql(): mock_sql_query = Mock(spec_set=['_execute_sql', 'query', 'as_sql']) mock_sql_query._execute_sql = Mock() mock_sql_query.query = NonCallableMock(spec_set=['model']) mock_sql_query.query.model = Mock() query_string = 'SELECT * from table_name' mock_sql_query.as_sql = Mock(return_value=(query_string, ())) return mock_sql_query, query_string
def test_failed_assoc_lookup(self): session = Mock() session.query = MockQuery() server_url = "http://test.net" store = SFOpenIDStore(session) returned = store.getAssociation(server_url) self.assertTrue(returned is None)
def test_badwords(self): db = Mock() db.query = Mock(return_value=[{ 'kill_words' : 'asshole other dirty words', 'warn_words' : 'jerk kinda bad stuff', }]) self.assertEqual(censor.badwords(db, "asshole"), 2) self.assertEqual(censor.badwords(db, "jerk"), 1) self.assertEqual(censor.badwords(db, "unicorn"), 0)
def test_badwords(self): db = Mock() db.query = Mock(return_value=[{ 'kill_words': 'asshole other dirty words', 'warn_words': 'jerk kinda bad stuff', }]) self.assertEqual(censor.badwords(db, "asshole"), 2) self.assertEqual(censor.badwords(db, "jerk"), 1) self.assertEqual(censor.badwords(db, "unicorn"), 0)
def test_run(self, *mocks): eddaclient = Mock() eddaclient._since = 500 def ret_list(args): return [ { 'imageId': 'ami-1', 'instanceId': 'a', 'launchTime': 400, "tags": [{ "key": "Name", "value": "tag1" }] }, { 'imageId': 'ami-2', 'instanceId': 'b', 'launchTime': 600, "tags": [{ "key": "service_name", "value": "foo" }] }, { 'imageId': 'ami-3', 'instanceId': 'c', 'launchTime': 800, "tags": [{ "key": "Name", "value": "tag1" }, { "key": "service_name", "value": "foo" }] }, ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.clean = Mock(return_value=m) self.plugin.init(eddaclient, Mock(), {}) # run the tested method self.assertEqual(self.plugin.run(), [{ 'id': 'foo', 'plugin_name': 'newtag', 'details': ['b, c'] }]) m.query.assert_has_calls([call('/api/v2/view/instances;_expand')])
def test_use_nonce_success(self): server_url = "http://test.net" timestamp = int(time.time()) salt = "asdfgadfgj" session = Mock() session.query = MockQuery() store = SFOpenIDStore(session) use_nonce = store.useNonce(server_url, timestamp, salt) self.assertEqual(use_nonce, True)
def test__update_query_in_push__push_without_query__push_updated_with_query( self, mock_get_query): # Arrange push = Mock() push.query = {} # Act AsyncAlertsStartedCampaign()._update_query_in_push(push) # Assert self.assertDictEqual(push.query, {"regions": "BR,AR", "games": "1"})
def test_get_df_returns_empty_df(self): datasource = Mock() datasource.type = 'table' mock_dttm_col = Mock() mock_dttm_col.python_date_format = Mock() datasource.get_col = Mock(return_value=mock_dttm_col) form_data = {'dummy': 123} query_obj = {'granularity': 'day'} results = Mock() results.query = Mock() results.status = Mock() results.error_message = None results.df = Mock() results.df.empty = True datasource.query = Mock(return_value=results) test_viz = viz.BaseViz(datasource, form_data) result = test_viz.get_df(query_obj) self.assertEqual(type(result), pd.DataFrame) self.assertTrue(result.empty) self.assertEqual(test_viz.error_message, 'No data.') self.assertEqual(test_viz.status, utils.QueryStatus.FAILED)
def test_run(self, *mocks): eddaclient = Mock() def ret_list(args): return [{"groupId": "sg-1", "groupName": "group1", "ipPermissions": [ {"fromPort": 22, "ipProtocol": "tcp", "ipRanges": ["0.0.0.0/0"], "toPort":22}, {"fromPort": 0, "ipProtocol": "icmp", "ipRanges": ["0.0.0.0/0"], "toPort": -1}]}, {"groupId": "sg-2", "groupName": "group2", "ipPermissions": [ {"fromPort": 139, "ipProtocol": "tcp", "ipRanges": ["0.0.0.0/0"], "toPort":139}]}, {"groupId": "sg-3", "groupName": "empty group"} ] def ret_machines(args): return [ {'imageId': 'ami-1', 'instanceId': 'a', 'publicIpAddress': '1.1.1.1', "tags": [], "securityGroups": [{"groupId": "sg-1", "groupName": "group1"}]}, {'imageId': 'ami-1', 'instanceId': 'b', 'publicIpAddress': '2.1.1.1', "tags": [ {"key": "Name", "value": "tag1"}], 'securityGroups': [ {"groupId": "sg-2", "groupName": "group2"}, {"groupId": "sg-1", "groupName": "group1"}]}, {'imageId': 'ami-2', 'instanceId': 'c', 'publicIpAddress': '3.1.1.1', "tags": [], 'securityGroups': []}, {'imageId': 'ami-3', 'instanceId': 'd', 'publicIpAddress': '4.1.1.1', "tags": [], 'securityGroups': [{"groupId": "sg-4", "groupName": "group4"}]} ] m1 = Mock() m1.query = Mock(side_effect=ret_list) eddaclient.updateonly = Mock(return_value=m1) eddaclient.query = Mock(side_effect=ret_machines) self.plugin.init(eddaclient, self.config, {}) # run the tested method self.assertEqual(self.plugin.run(), [{'id': 'sg-2 (group2)', 'plugin_name': 'secgroups', 'details': [ {'fromPort': 139, 'ipRanges': ['0.0.0.0/0'], 'toPort': 139, 'ipProtocol': 'tcp', 'port_open': True, 'machines': ['b (2.1.1.1): tag1']}]}]) m1.query.assert_has_calls([call('/api/v2/aws/securityGroups;_expand')]) eddaclient.query.assert_has_calls([call('/api/v2/view/instances;_expand')])
def test_remove_association_fail_url(self): server_url = "http://test.net" lifetime = 60 * 60 * 24 * 5 # 5 days in seconds issued = time.mktime(datetime.datetime.now().timetuple()) assoc1 = Association("http://test.com", 'asdf', 'aflasdkf', issued, lifetime, 'HMAC-SHA1') session = Mock() session.query = MockQuery(store=[assoc1]) store = SFOpenIDStore(session) returned = store.removeAssociation(server_url, handle='asdf') self.assertEqual(returned, False)
def test_retrieve_report_metadata_valid_inputs(self, get_addresses, mock_sqlalchemy): get_addresses = Mock(return_value="dummyAddresses") mock_sqlalchemy.or_ = Mock() mock_session = Mock() mock_session.query = Mock() mock_blood_ref = Mock() mock_blood_ref.pnr = "1212121212" mock_blood_ref.crid = "1111111" mock_blood_ref.collection_date = "2016-01-01" mock_tissue_ref = Mock() mock_tissue_ref.pnr = "1212121212" mock_tissue_ref.crid = "2222222" mock_tissue_ref.collection_date = "2016-01-01" mock_session.query().filter().all = Mock(side_effect=[[mock_blood_ref], [mock_tissue_ref]]) out_dict = metadata.retrieve_report_metadata("03098121", "03098849", mock_session, self.id2addresses) self.assertEqual(out_dict["personnummer"], "1212121212") self.assertEqual(out_dict["blood_sample_ID"], "03098121") self.assertEqual(out_dict["blood_sample_date"], "2016-01-01") self.assertEqual(out_dict["tumor_sample_ID"], "03098849")
def test_empty_status(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() def ret_list(args): return [ {'keyName': 'keyName1', 'instanceId': 'a', 'privateIpAddress': '10.1.1.1', 'publicIpAddress': '1.1.1.1', "tags": [{"key": "Name", "value": "tag1"}, {'a': 'b'}], 'launchTime': 1 * 3600000}, {'keyName': 'keyName2', 'instanceId': 'b', 'privateIpAddress': '10.1.1.2', 'publicIpAddress': '2.1.1.1', "tags": [{"key": "service_name", "value": "foo"}], 'launchTime': 1 * 3600000}, {'keyName': 'keyName3', 'instanceId': 'c', 'privateIpAddress': '10.1.1.3', 'publicIpAddress': '3.1.1.1', 'launchTime': 1 * 3600000}, {'keyName': 'keyName4', 'instanceId': 'd', 'privateIpAddress': '10.1.1.4', 'publicIpAddress': '4.1.1.1', 'launchTime': 1 * 3600000}, {'keyName': 'keyName5', 'instanceId': 'e', 'privateIpAddress': 'null', 'publicIpAddress': 'null', 'launchTime': 1 * 3600000}, {'keyName': 'keyName6', 'instanceId': 'f', 'privateIpAddress': None, 'publicIpAddress': None, 'launchTime': 1 * 3600000} ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.soft_clean = Mock(return_value=m) eddaclient._since = 3 * 3600000 eddaclient._until = 4 * 3600000 + 1 def chef_list(*args, **kwargs): return [ {'name': 'ec2 alive', 'automatic': {'cloud': {'public_ipv4': '1.1.1.1', 'provider': 'ec2'}}}, {'name': 'non-ec2 but cloud host alive', 'automatic': {'cloud': {'public_ipv4': '2.1.1.1'}}}, {'name': 'ec2 host dead', 'automatic': {'cloud': {'public_ipv4': '255.1.1.1', 'provider': 'ec2'}}}, {'name': 'non-ec2 host', 'automatic': {'ipaddress': '5.1.1.1'}}, ] with patch('plugins.chef.Search', side_effect=chef_list) as MockClass: self.plugin.init(eddaclient, self.config, {}, instance_enricher) alerts = list(self.plugin.do_run()) non_chef_alerts = [i for i in alerts if i['plugin_name'] == 'non_chef'] chef_managed_alerts = [i for i in alerts if i['plugin_name'] == 'chef_managed'] # there are two reportable instances, 3.1.1.1 and 4.1.1.1 self.assertEqual(2, len(non_chef_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "3.1.1.1" for a in non_chef_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "4.1.1.1" for a in non_chef_alerts)) self.assertEqual(3, len(chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "1.1.1.1" for a in chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "2.1.1.1" for a in chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "5.1.1.1" for a in chef_managed_alerts))
def test_empty_status(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() def ret_list(args): return [ {'keyName': 'keyName1', 'instanceId': 'a', 'privateIpAddress': '10.1.1.1', 'publicIpAddress': '1.1.1.1', "tags": [{"key": "Name", "value": "tag1"}, {'a': 'b'}], 'launchTime': 1 * 3600000}, {'keyName': 'keyName2', 'instanceId': 'b', 'privateIpAddress': '10.1.1.2', 'publicIpAddress': '2.1.1.1', "tags": [{"key": "service_name", "value": "foo"}], 'launchTime': 1 * 3600000}, {'keyName': 'keyName3', 'instanceId': 'c', 'privateIpAddress': '10.1.1.3', 'publicIpAddress': '3.1.1.1', 'launchTime': 1 * 3600000}, {'keyName': 'keyName4', 'instanceId': 'd', 'privateIpAddress': '10.1.1.4', 'publicIpAddress': '4.1.1.1', 'launchTime': 1 * 3600000}, {'keyName': 'keyName5', 'instanceId': 'e', 'privateIpAddress': 'null', 'publicIpAddress': 'null', 'launchTime': 1 * 3600000}, {'keyName': 'keyName6', 'instanceId': 'f', 'privateIpAddress': None, 'publicIpAddress': None, 'launchTime': 1 * 3600000} ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.soft_clean = Mock(return_value=m) eddaclient._since = 3 * 3600000 eddaclient._until = 4 * 3600000 + 1 chef_result_list = [ self.wrap_chef_result({'name': 'ec2 alive', 'cloud_public_ipv4': '1.1.1.1', 'cloud_provider': 'ec2'}), self.wrap_chef_result({'name': 'non-ec2 but cloud host alive', 'cloud_public_ipv4': '2.1.1.1'}), self.wrap_chef_result({'name': 'ec2 host dead', 'cloud_public_ipv4': '255.1.1.1', 'cloud_provider': 'ec2'}), self.wrap_chef_result({'name': 'non-ec2 host', 'ipaddress': '5.1.1.1'}), self.wrap_chef_result(None) ] with patch('plugins.chef.ChefAPI', return_value=MagicMock(request=MagicMock(side_effect=chef_result_list))): self.plugin.init(eddaclient, self.config, {}, instance_enricher) alerts = list(self.plugin.do_run()) non_chef_alerts = [i for i in alerts if i['plugin_name'] == 'non_chef'] chef_managed_alerts = [i for i in alerts if i['plugin_name'] == 'chef_managed'] # there are two reportable instances, 3.1.1.1 and 4.1.1.1 self.assertEqual(2, len(non_chef_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "3.1.1.1" for a in non_chef_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "4.1.1.1" for a in non_chef_alerts)) self.assertEqual(3, len(chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "1.1.1.1" for a in chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "2.1.1.1" for a in chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "5.1.1.1" for a in chef_managed_alerts))
def test_returning_association(self): session = Mock() server_url = "http://test.net" lifetime = 60 * 60 * 24 * 5 # 5 days in seconds issued = time.mktime(datetime.datetime.now().timetuple()) assoc = Association(server_url, 'asdf', 'aflasdkf', issued, lifetime, 'HMAC-SHA1') session.query = MockQuery(store=[assoc]) store = SFOpenIDStore(session) returned = store.getAssociation(server_url) for attr in ('handle', 'secret', 'issued', 'lifetime', 'assoc_type'): self.assertEqual(getattr(returned, attr), getattr(assoc, attr))
def test_skipped_service(self): eddaclient = Mock() eddaclient.query = Mock(return_value=[ {'imageId': 'ami-1', 'instanceId': 'b', 'launchTime': '2000', 'tags': [{'key': 'service_name', 'value': 'jenkins'}]}]) uncleaned_eddaclient = Mock() uncleaned_eddaclient.clean = Mock(return_value=eddaclient) uncleaned_eddaclient._since = 500 self.plugin.init(uncleaned_eddaclient, self.config, {'first_seen': {}}) real = self.plugin.run() expected = [] self.assertEqual(expected, real) eddaclient.query.assert_has_calls([call('/api/v2/view/instances;_expand')])
def test_nonempty_status(self, *mocks): instance_enricher = InstanceEnricher(Mock()) eddaclient = Mock() def ret_list(args): return [ {'keyName': 'keyName1', 'instanceId': 'a', 'privateIpAddress': '10.1.1.1', 'publicIpAddress': '1.1.1.1', "tags": [{"key": "Name", "value": "tag1"}, {'a': 'b'}], 'launchTime': 6 * 3600000 + 1}, {'keyName': 'keyName2', 'instanceId': 'b', 'privateIpAddress': '10.1.1.2', 'publicIpAddress': '2.1.1.1', "tags": [{"key": "service_name", "value": "foo"}], 'launchTime': 7 * 3600000 + 1}, {'keyName': 'keyName3', 'instanceId': 'c', 'privateIpAddress': '10.1.1.3', 'publicIpAddress': '3.1.1.1', 'launchTime': 8 * 3600000 + 1}, {'keyName': 'keyName4', 'instanceId': 'd', 'privateIpAddress': '10.1.1.4', 'publicIpAddress': '4.1.1.1', 'launchTime': 9 * 3600000 + 1}, {'instanceId': 'e', 'privateIpAddress': 'x', 'publicIpAddress': 'x', 'launchTime': 10 * 3600000 + 1}, {'instanceId': 'f', 'privateIpAddress': 'x', 'publicIpAddress': 'x', 'launchTime': 11 * 3600000 + 1}, ] m = Mock() m.query = Mock(side_effect=ret_list) eddaclient.soft_clean = Mock(return_value=m) eddaclient._since = 10 * 3600000 eddaclient._until = 11 * 3600000 def chef_list(*args, **kwargs): return [ {'name': 'host0', 'automatic': {'cloud': {'public_ipv4': '4.1.1.1'}}}, {'name': 'host1', 'automatic': {'cloud': {'public_ipv4': '6.1.1.1'}}}, {'name': 'host2', 'automatic': {'cloud': {'public_ipv4': '7.1.1.1'}}}, ] with patch('plugins.chef.Search', side_effect=chef_list) as MockClass: self.plugin.init(eddaclient, self.config, {"first_seen": {'f': 8}}, instance_enricher) alerts = list(self.plugin.do_run()) non_chef_alerts = [i for i in alerts if i['plugin_name'] == 'non_chef'] chef_managed_alerts = [i for i in alerts if i['plugin_name'] == 'chef_managed'] self.assertEqual(2, len(alerts)) # there is one problematic node (2.1.1.1) self.assertEqual(1, len(non_chef_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "2.1.1.1" for a in non_chef_alerts)) # there is one chef managed node (4.1.1.1) self.assertEqual(1, len(chef_managed_alerts)) self.assertTrue(any(a["details"][0]["publicIpAddress"] == "4.1.1.1" for a in chef_managed_alerts))
def test_expired_assoc_cleanup(self): server_url = "http://test.net" day = 60 * 60 * 24 issued = time.mktime(datetime.datetime(2010, 1, 20).timetuple()) storage = [] for i in xrange(0, 10): lifetime = day + i new_assoc = Association(server_url, 'asdf', 'afla', issued, lifetime, 'HMAC-SHA1') storage.append(new_assoc) session = Mock() session.query = MockQuery(store=storage) store = SFOpenIDStore(session) store.cleanupAssociations() self.assertEqual(session.query._store, [])