class AlphaPlottingAltTestCase(MockedJsonifyTestCase):
jsonify_to_patch = [
'microsetta_public_api.api.plotting.jsonify',
'microsetta_public_api.utils._utils.jsonify',
]
def setUp(self):
super().setUp()
faith_pd_values = [1, 2, 3, 4]
faith_pd_index = ['s01', 's02', 's04', 's05']
shannon_values = [7.24, 9.05, 8.25]
shannon_index = ['s01', 's02', 'sOther']
metadata = MockMetadataElement(
pd.DataFrame(
{
'age_cat': ['30s', '40s', '50s', '30s', '30s'],
'num_var': [3, 4, 5, 6, 7],
},
index=['s01', 's02', 's04', 's05', 'sOther']))
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({
'__metadata__':
metadata,
'__alpha__':
AlphaElement({
'faith_pd':
pd.Series(faith_pd_values, index=faith_pd_index),
'shannon':
pd.Series(shannon_values, index=shannon_index),
})
}),
'dataset2':
DictElement({
'__metadata__': metadata,
}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.plotting.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def test_simple_plot(self):
response, code = plot_alpha_filtered_alt(dataset='dataset1',
alpha_metric='faith_pd')
self.assertEqual(200, code)
def test_simple_plot_with_vertline_for_sample_id(self):
response, code = plot_alpha_filtered_alt(dataset='dataset1',
alpha_metric='faith_pd',
sample_id='s01')
self.assertEqual(200, code)
def atomic_update_resources(resource):
# create a new element to store the data in
element = DictElement()
element.update(resource)
visitor = Q2Visitor()
element.accept(visitor)
# after data has been loaded by the q2 visitor, update resources_alt
# so that it is accessible.
# Updating resources_alt from another element means the server will
# not show the skeleton of any unloaded data to the client
resources_alt.update(element)
class BetaTests(MockedJsonifyTestCase):
jsonify_to_patch = [
'microsetta_public_api.api.diversity.beta.jsonify',
'microsetta_public_api.utils._utils.jsonify',
]
def setUp(self):
super().setUp()
neighbors = pd.DataFrame([['s2', 's3', 's4'], ['s1', 's3', 's4'],
['s1', 's2', 's4'], ['s1', 's2', 's3']],
columns=['k0', 'k1', 'k2'],
index=['s1', 's2', 's3', 's4'])
neighbors.index.name = 'sample_id'
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement(
{'__neighbors__': BetaElement({'unifrac': neighbors})}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.diversity.beta.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def tearDown(self):
self.res_patcher.stop()
super().tearDown()
def test_k_nearest(self):
results, code = k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=1,
sample_id='s1')
self.assertCountEqual(json.loads(results), ['s2'])
results, code = k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=2,
sample_id='s2')
self.assertCountEqual(json.loads(results), ['s1', 's3'])
def test_k_nearest_unknown_dataset(self):
with self.assertRaises(UnknownResource):
k_nearest(dataset='dne',
beta_metric='unifrac',
k=2,
sample_id='s2')
def test_k_nearest_unknown_metric(self):
with self.assertRaises(UnknownMetric):
k_nearest(dataset='dataset1',
beta_metric='unifork',
k=2,
sample_id='s2')
def test_k_nearest_unknown_id(self):
with self.assertRaises(UnknownID):
k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=2,
sample_id='s2-dne')
def test_k_nearest_invalid_k(self):
with self.assertRaises(InvalidParameter):
k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=724,
sample_id='s2')
class AlphaAltTests(MockedJsonifyTestCase):
jsonify_to_patch = [
'microsetta_public_api.api.diversity.alpha.jsonify',
'microsetta_public_api.utils._utils.jsonify',
]
def setUp(self):
super().setUp()
faith_pd_values = [1, 2, 3, 4]
faith_pd_index = ['s01', 's02', 's04', 's05']
shannon_values = [7.24, 9.05, 8.25]
shannon_index = ['s01', 's02', 'sOther']
metadata = MockMetadataElement(
pd.DataFrame(
{
'age_cat': ['30s', '40s', '50s', '30s', '30s'],
'num_var': [3, 4, 5, 6, 7],
},
index=['s01', 's02', 's04', 's05', 'sOther']))
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({
'__metadata__':
metadata,
'__alpha__':
AlphaElement({
'faith_pd':
pd.Series(faith_pd_values, index=faith_pd_index),
'shannon':
pd.Series(shannon_values, index=shannon_index),
})
}),
'dataset2':
DictElement({
'__metadata__': metadata,
}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.diversity.alpha.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def tearDown(self):
self.res_patcher.stop()
super().tearDown()
def test_availalbe_metrics_alt(self):
response, code = available_metrics_alpha_alt('dataset1')
avail = json.loads(response)
self.assertEqual(200, code)
self.assertDictEqual(avail, {'alpha_metrics': ['faith_pd', 'shannon']})
with self.assertRaises(UnknownResource):
# check for dataset that exists but has no alpha
available_metrics_alpha_alt('dataset2')
with self.assertRaises(UnknownResource):
# check for dataset that does not exist
available_metrics_alpha_alt('dataset3')
def test_get_alpha_alt(self):
faith_pd, code1 = get_alpha_alt('dataset1', 's01', 'faith_pd')
shannon, code2 = get_alpha_alt('dataset1', 's02', 'shannon')
faith_pd_value = json.loads(faith_pd)
shannon_value = json.loads(shannon)
self.assertEqual(faith_pd_value['data'], 1)
self.assertEqual(200, code1)
self.assertEqual(shannon_value['data'], 9.05)
self.assertEqual(200, code2)
def test_get_alpha_alt_404(self):
with self.assertRaisesRegex(UnknownResource, 'dataset3'):
get_alpha_alt('dataset3', 's03', 'faith_pd')
with self.assertRaisesRegex(UnknownResource, '__alpha__'):
get_alpha_alt('dataset2', 's03', 'faith_pd')
def test_alpha_group_alt(self):
request = {'sample_ids': ['s01', 's04']}
response, code = alpha_group_alt(request,
'dataset1',
'faith_pd',
return_raw=True)
self.assertEqual(code, 200)
obs = json.loads(response)
self.assertDictEqual({'s01': 1, 's04': 3}, obs['alpha_diversity'])
def test_alpha_group_alt_404_sample_id(self):
request = {'sample_ids': ['s01', 'dne']}
with self.assertRaises(UnknownID):
alpha_group_alt(request, 'dataset1', 'faith_pd', return_raw=True)
def test_alpha_group_alt_404_metric(self):
request = {'sample_ids': ['s01', 's04']}
with self.assertRaises(UnknownResource):
alpha_group_alt(request, 'dataset1', 'bad-metric', return_raw=True)
def test_alpha_group_alt_filter_metadata_OR(self):
post_body = {
'sample_ids': [
's04',
],
'metadata_query': {
"condition":
"AND",
"rules": [
{
"id": "age_cat",
"field": "age_cat",
"operator": "equal",
"value": "30s",
},
],
},
'condition': "OR",
}
response, code = alpha_group_alt(post_body,
'dataset1',
'faith_pd',
return_raw=True)
obs = json.loads(response)
self.assertEqual(code, 200)
sample_ids = obs['alpha_diversity'].keys()
self.assertCountEqual(['s01', 's04', 's05'], sample_ids)
def test_alpha_exists_single_alt(self):
response, code = exists_single_alt('dataset1', 'faith_pd', 's01')
self.assertEqual(code, 200)
obs = json.loads(response)
self.assertTrue(obs)
response, code = exists_single_alt('dataset1', 'faith_pd', 's-dne')
self.assertEqual(code, 200)
obs = json.loads(response)
self.assertFalse(obs)
response, code = exists_single_alt('dataset1', 'shannon', 's03')
self.assertEqual(code, 200)
obs = json.loads(response)
self.assertFalse(obs)
def test_alpha_exists_single_alt_errors(self):
with self.assertRaises(UnknownResource):
exists_single_alt('dataset2', 'shannon', 's03')
with self.assertRaises(UnknownResource):
exists_single_alt('dataset1', 'dne-metric', 's03')
def test_alpha_exists_group_alt(self):
body = ['s01', 's03', 's04']
response, code = exists_group_alt(body, 'dataset1', 'faith_pd')
self.assertEqual(code, 200)
obs = json.loads(response)
self.assertListEqual(obs, [True, False, True])
def test_alpha_exists_group_alt_errors(self):
body = ['s01', 's03', 's04']
with self.assertRaises(UnknownResource):
exists_group_alt(body, 'dataset2', 'faith_pd')
with self.assertRaises(UnknownResource):
exists_group_alt(body, 'dataset1', 'dne-metric')
class BetaTests(MockedJsonifyTestCase):
jsonify_to_patch = [
'microsetta_public_api.api.diversity.beta.jsonify',
'microsetta_public_api.utils._utils.jsonify',
]
def setUp(self):
super().setUp()
dm_values = [[0, 1, 2, 3], [1, 0, 3, 4], [2, 3, 0, 5], [3, 4, 5, 0]]
ids = ['s1', 's2', 's3', 's4']
dm = DistanceMatrix(
dm_values,
ids=ids,
)
self.resources = DictElement({
'datasets':
DictElement({
'dataset1':
DictElement({'__beta__': BetaElement({'unifrac': dm})}),
}),
})
self.resources.accept(TrivialVisitor())
self.res_patcher = patch(
'microsetta_public_api.api.diversity.beta.get_resources')
self.mock_resources = self.res_patcher.start()
self.mock_resources.return_value = self.resources
def tearDown(self):
self.res_patcher.stop()
super().tearDown()
def test_k_nearest(self):
results, code = k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=1,
sample_id='s1')
self.assertCountEqual(json.loads(results), ['s2'])
results, code = k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=2,
sample_id='s2')
self.assertCountEqual(json.loads(results), ['s1', 's3'])
def test_k_nearest_unknown_dataset(self):
with self.assertRaises(UnknownResource):
k_nearest(dataset='dne',
beta_metric='unifrac',
k=2,
sample_id='s2')
def test_k_nearest_unknown_metric(self):
with self.assertRaises(UnknownMetric):
k_nearest(dataset='dataset1',
beta_metric='unifork',
k=2,
sample_id='s2')
def test_k_nearest_unknown_id(self):
with self.assertRaises(UnknownID):
k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=2,
sample_id='s2-dne')
def test_k_nearest_invalid_k(self):
with self.assertRaises(InvalidParameter):
k_nearest(dataset='dataset1',
beta_metric='unifrac',
k=724,
sample_id='s2')