def test_add_user_duplicate_name(self):
"""Ensure duplicate group names are not allowed."""
add_sample_group('Sample Group One', access_scheme='public')
duplicate_group = SampleGroup(
name='Sample Group One',
analysis_result=AnalysisResultMeta().save(),
access_scheme='public',
)
db.session.add(duplicate_group)
self.assertRaises(IntegrityError, db.session.commit)
def create_sample_group():
"""Create unique sample for index i."""
sample_group = add_sample_group(name='SampleGroup01')
ranks = create_ranks()
BetaDiversityToolResult(sample_group_uuid=sample_group.id,
data=ranks).save()
return sample_group
def test_add_duplicate_sample_group(self, auth_headers, *_):
"""Ensure failure for non-unique Sample Group name."""
group_name = 'The Most Sampled of Groups'
add_sample_group(name=group_name)
with self.client:
response = self.client.post(
'/api/v1/sample_groups',
headers=auth_headers,
data=json.dumps(dict(name=group_name, )),
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 400)
self.assertIn('error', data['status'])
self.assertEqual('Sample Group with that name already exists.',
data['message'])
def test_add_sample_group(self):
"""Ensure sample group model is created correctly."""
group = add_sample_group('Sample Group One', access_scheme='public')
self.assertTrue(group.id)
self.assertEqual(group.name, 'Sample Group One')
self.assertEqual(group.access_scheme, 'public')
self.assertTrue(group.created_at)
def generic_add_group_tool_test(self, result, model_cls): # pylint: disable=invalid-name
"""Ensure tool result model is created correctly."""
sample_group = add_sample_group(name='SMPL_01')
result.sample_group_uuid = sample_group.id
result.save()
fetch_result = model_cls.objects.get(sample_group_uuid=sample_group.id)
self.assertTrue(fetch_result is not None)
def generic_test_upload_group(self, result_cls, payload, tool_result_name):
"""Ensure a raw Sample Group tool result can be uploaded."""
sample_group = add_sample_group(name=f'GRP_{tool_result_name}')
group_uuid = str(sample_group.id)
endpoint = f'/api/v1/sample_groups/{group_uuid}/{tool_result_name}'
self.help_test_upload(endpoint, payload)
# Reload object to ensure tool result was stored properly
tool_result = result_cls.objects.get(sample_group_uuid=group_uuid)
self.assertTrue(tool_result)
def test_collate_samples(self):
"""Ensure collate_samples task works."""
sample1_data = {'name': 'Sample01', KRAKEN_NAME: create_kraken()}
sample2_data = {'name': 'Sample02', KRAKEN_NAME: create_kraken()}
sample1 = Sample(**sample1_data).save()
sample2 = Sample(**sample2_data).save()
sample_group = add_sample_group(name='SampleGroup01')
sample_group.samples = [sample1, sample2]
db.session.commit()
samples = [sample.fetch_safe() for sample in [sample1, sample2]]
result = collate_samples.delay(KRAKEN_NAME, ['taxa'], samples).get()
self.assertIn('Sample01', result)
self.assertIn('Sample02', result)
self.assertIn('taxa', result['Sample01'])
self.assertIn('taxa', result['Sample02'])
def test_add_samples_to_group(self, auth_headers, *_):
"""Ensure samples can be added to a sample group."""
sample_group = add_sample_group(name='A Great Name')
sample = add_sample(name='SMPL_01')
endpoint = f'/api/v1/sample_groups/{str(sample_group.id)}/samples'
with self.client:
response = self.client.post(
endpoint,
headers=auth_headers,
data=json.dumps(dict(sample_uuids=[str(sample.uuid)], )),
content_type='application/json',
)
self.assertEqual(response.status_code, 200)
data = json.loads(response.data.decode())
self.assertIn('success', data['status'])
self.assertIn(sample.uuid, sample_group.sample_ids)
def generic_run_group_test(self, sample_builder, module, group_builder=None):
"""Check that we can run a wrangler on a set of samples."""
wrangler = module.get_wrangler()
endpt = module.name()
if group_builder is not None:
sample_group = group_builder()
samples = []
else:
sample_group = add_sample_group(name='SampleGroup01')
samples = [sample_builder(i) for i in range(6)]
sample_group.samples = samples
db.session.commit()
wrangler.help_run_sample_group(sample_group, samples, module).get()
analysis_result = sample_group.analysis_result
self.assertIn(endpt, analysis_result)
wrangled = getattr(analysis_result, endpt).fetch()
self.assertEqual(wrangled.status, 'S')
def test_get_single_sample_groups(self):
"""Ensure get single group behaves correctly."""
group = add_sample_group(name='Sample Group One')
group_uuid = str(group.id)
with self.client:
response = self.client.get(
f'/api/v1/sample_groups/{group_uuid}',
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertIn('Sample Group One',
data['data']['sample_group']['name'])
self.assertIn('public',
data['data']['sample_group']['access_scheme'])
self.assertTrue('created_at' in data['data']['sample_group'])
self.assertIn('success', data['status'])
def test_single_organization_sample_groups(self):
"""Ensure getting sample groups for an organization behaves correctly."""
sample_group = add_sample_group('Pilot Sample Group')
organization = add_organization('Test Organization', '*****@*****.**')
organization.sample_groups = [sample_group]
db.session.commit()
uuid = str(organization.id)
with self.client:
response = self.client.get(
f'/api/v1/organizations/{uuid}/sample_groups',
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertTrue(len(data['data']['sample_groups']) == 1)
self.assertTrue('name' in data['data']['sample_groups'][0])
self.assertIn('success', data['status'])
def test_add_samples(self):
"""Ensure that samples can be added to SampleGroup."""
sample_group = add_sample_group('Sample Group One',
access_scheme='public')
sample_one = Sample(name='SMPL_01', metadata={
'subject_group': 1
}).save()
sample_two = Sample(name='SMPL_02', metadata={
'subject_group': 4
}).save()
sample_group.samples = [sample_one, sample_two]
db.session.commit()
self.assertEqual(len(sample_group.sample_ids), 2)
self.assertIn(sample_one.uuid, sample_group.sample_ids)
self.assertIn(sample_two.uuid, sample_group.sample_ids)
samples = sample_group.samples
self.assertEqual(len(samples), 2)
self.assertIn(sample_one, samples)
self.assertIn(sample_two, samples)
def prepare_middleware_test(self): # pylint: disable=no-self-use
"""Prepare database for middleware test."""
def create_sample(i):
"""Create unique sample for index i."""
data = create_ancestry()
args = {
'name': f'AncestrySample{i}',
'metadata': {
'foobar': f'baz{i}'
},
TOOL_MODULE_NAME: data,
}
return Sample(**args).save()
sample_group = add_sample_group(name='Ancestry Sample Group')
sample_group.samples = [create_sample(i) for i in range(6)]
db.session.commit()
return sample_group
def test_run_sample_group(self):
"""Ensure run_sample_group produces correct results."""
def create_sample(i):
"""Create unique sample for index i."""
metadata = {'foobar': f'baz{i}'}
return Sample(name=f'Sample{i}',
metadata=metadata,
microbe_census=create_microbe_census()).save()
sample_group = add_sample_group(name='SampleGroup01')
samples = [create_sample(i) for i in range(10)]
sample_group.samples = samples
db.session.commit()
AGSWrangler.help_run_sample_group(sample_group, samples,
AGSDisplayModule).get()
analysis_result = sample_group.analysis_result
self.assertIn('average_genome_size', analysis_result)
average_genome_size = analysis_result.average_genome_size.fetch()
self.assertEqual(average_genome_size.status, 'S')
def test_get_single_sample_group_samples(self): # pylint: disable=invalid-name
"""Ensure get samples for sample group behaves correctly."""
group = add_sample_group(name='Sample Group One')
sample00 = add_sample(name='SMPL_00')
sample01 = add_sample(name='SMPL_01')
group.samples = [sample00, sample01]
db.session.commit()
with self.client:
response = self.client.get(
f'/api/v1/sample_groups/{str(group.id)}/samples',
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertIn('success', data['status'])
self.assertIn('samples', data['data'])
self.assertEqual(len(data['data']['samples']), 2)
self.assertTrue(
any(s['name'] == 'SMPL_00' for s in data['data']['samples']))
self.assertTrue(
any(s['name'] == 'SMPL_01' for s in data['data']['samples']))
def test_get_group_uuid_from_name(self):
"""Ensure get sample uuid behaves correctly."""
sample_group_name = 'Sample Group One'
group = add_sample_group(name=sample_group_name)
sample_group_uuid = str(group.id)
sample00 = add_sample(name='SMPL_00')
sample01 = add_sample(name='SMPL_01')
group.samples = [sample00, sample01]
db.session.commit()
with self.client:
response = self.client.get(
f'/api/v1/sample_groups/getid/{sample_group_name}',
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertIn('success', data['status'])
self.assertEqual(sample_group_uuid,
data['data']['sample_group_uuid'])
self.assertEqual(sample_group_name,
data['data']['sample_group_name'])
def test_add_sample(self, auth_headers, *_):
"""Ensure a new sample can be added to the database."""
sample_name = 'Exciting Research Starts Here'
sample_group = add_sample_group(name='A Great Name')
with self.client:
response = self.client.post(
f'/api/v1/samples',
headers=auth_headers,
data=json.dumps(
dict(
name=sample_name,
sample_group_uuid=str(sample_group.id),
)),
content_type='application/json',
)
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertIn('success', data['status'])
self.assertIn('uuid', data['data']['sample'])
self.assertEqual(sample_name, data['data']['sample']['name'])
sample_uuid = UUID(data['data']['sample']['uuid'])
self.assertIn(sample_uuid, sample_group.sample_ids)
def test_run_sample_group(self):
"""Ensure run_sample_group produces correct results."""
def create_sample(i):
"""Create unique sample for index i."""
metadata = {'foobar': f'baz{i}'}
sample_data = {
'name': f'Sample{i}',
'metadata': metadata,
KRAKEN_NAME: create_kraken(),
KRAKENHLL_NAME: create_krakenhll(),
METAPHLAN2_NAME: create_metaphlan2(),
}
return Sample(**sample_data).save()
sample_group = add_sample_group(name='SampleGroup01')
samples = [create_sample(i) for i in range(6)]
sample_group.samples = samples
db.session.commit()
SampleSimilarityWrangler.help_run_sample_group(
sample_group, samples, SampleSimilarityDisplayModule).get()
analysis_result = sample_group.analysis_result
self.assertIn('sample_similarity', analysis_result)
sample_similarity = analysis_result.sample_similarity.fetch()
self.assertEqual(sample_similarity.status, 'S')
def test_sample_group_analysis_result(self): # pylint: disable=invalid-name
"""Ensure sample group's analysis result can be accessed."""
analysis_result = AnalysisResultMeta().save()
sample_group = add_sample_group('Sample Group One',
analysis_result=analysis_result)
self.assertEqual(sample_group.analysis_result, analysis_result)
