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_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_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_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 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_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 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_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, [])
