def setUp(self):
super(ParticipantSummaryDaoTest, self).setUp(use_mysql=True)
self.dao = ParticipantSummaryDao()
self.order_dao = BiobankOrderDao()
self.measurement_dao = PhysicalMeasurementsDao()
self.participant_dao = ParticipantDao()
self.no_filter_query = Query([], None, 2, None)
self.one_filter_query = Query(
[FieldFilter("participantId", Operator.EQUALS, 1)], None, 2, None)
self.two_filter_query = Query([
FieldFilter("participantId", Operator.EQUALS, 1),
FieldFilter("hpoId", Operator.EQUALS, PITT_HPO_ID)
], None, 2, None)
self.ascending_biobank_id_query = Query([], OrderBy("biobankId", True),
2, None)
self.descending_biobank_id_query = Query([],
OrderBy("biobankId",
False), 2, None)
self.enrollment_status_order_query = Query([],
OrderBy(
"enrollmentStatus",
True), 2, None)
self.hpo_id_order_query = Query([], OrderBy("hpoId", True), 2, None)
self.first_name_order_query = Query([], OrderBy("firstName", True), 2,
None)
def _make_biobank_order(self, **kwargs):
"""Makes a new BiobankOrder (same values every time) with valid/complete defaults.
Kwargs pass through to BiobankOrder constructor, overriding defaults.
"""
participant_id = kwargs['participantId']
for k, default_value in (
('biobankOrderId', u'1'), ('created', clock.CLOCK.now()),
('sourceSiteId', 1), ('sourceUsername', u'*****@*****.**'),
('collectedSiteId', 1), ('collectedUsername', u'*****@*****.**'),
('processedSiteId', 1), ('processedUsername', u'*****@*****.**'),
('finalizedSiteId', 2), ('finalizedUsername',
u'*****@*****.**'), ('version', 1),
('identifiers',
[BiobankOrderIdentifier(system=u'a', value=u'c')]), ('samples', [
BiobankOrderedSample(test=u'1SAL2',
description=u'description',
processingRequired=True)
]), ('dvOrders',
[BiobankDVOrder(participantId=participant_id, version=1)])):
if k not in kwargs:
kwargs[k] = default_value
biobank_order = BiobankOrderDao().insert(BiobankOrder(**kwargs))
return biobank_order
def generate_samples(fraction_missing):
"""Creates fake sample CSV data in GCS.
Args:
fraction_missing: This many samples which exist as BiobankStoredSamples will not have rows
generated in the fake CSV.
"""
bucket_name = config.getSetting(config.BIOBANK_SAMPLES_BUCKET_NAME)
now = clock.CLOCK.now()
file_name = '/%s/fake_%s.csv' % (bucket_name,
now.strftime(INPUT_CSV_TIME_FORMAT))
num_rows = 0
sample_id_start = random.randint(1000000, 10000000)
with cloudstorage_api.open(file_name, mode='w') as dest:
writer = csv.writer(dest, delimiter="\t")
writer.writerow(_HEADERS)
biobank_order_dao = BiobankOrderDao()
with biobank_order_dao.session() as session:
rows = biobank_order_dao.get_ordered_samples_sample(
session, 1 - fraction_missing, _BATCH_SIZE)
for biobank_id, collected_time, test in rows:
if collected_time is None:
logging.warning(
'biobank_id=%s test=%s skipped (collected=%s)',
biobank_id, test, collected_time)
continue
minutes_delta = random.randint(
0, _MAX_MINUTES_BETWEEN_SAMPLE_COLLECTED_AND_CONFIRMED)
confirmed_time = collected_time + datetime.timedelta(
minutes=minutes_delta)
writer.writerow([
sample_id_start + num_rows,
None, # no parent
confirmed_time.strftime(_TIME_FORMAT),
to_client_biobank_id(biobank_id),
test,
confirmed_time.strftime(_TIME_FORMAT),
'KIT'
]) # reuse confirmed time as created time
num_rows += 1
participant_dao = ParticipantDao()
with participant_dao.session() as session:
rows = participant_dao.get_biobank_ids_sample(
session, _PARTICIPANTS_WITH_ORPHAN_SAMPLES, _BATCH_SIZE)
for biobank_id, sign_up_time in rows:
minutes_delta = random.randint(
0, _MAX_MINUTES_BETWEEN_PARTICIPANT_CREATED_AND_CONFIRMED)
confirmed_time = sign_up_time + datetime.timedelta(
minutes=minutes_delta)
tests = random.sample(BIOBANK_TESTS,
random.randint(1, len(BIOBANK_TESTS)))
for test in tests:
writer.writerow([
sample_id_start + num_rows, None,
confirmed_time.strftime(_TIME_FORMAT),
to_client_biobank_id(biobank_id), test,
confirmed_time.strftime(_TIME_FORMAT), 'KIT'
])
num_rows += 1
logging.info("Generated %d samples in %s.", num_rows, file_name)
def test_dv_order_sample_update(self):
"""
Test Biobank Direct Volunteer order
"""
participant = self.participant_dao.insert(Participant())
self.summary_dao.insert(self.participant_summary(participant))
created_ts = datetime.datetime(2019, 03, 22, 18, 30, 45)
confirmed_ts = datetime.datetime(2019, 03, 23, 12, 13, 00)
bo = self._make_biobank_order(participantId=participant.participantId)
BiobankOrderDao().insert(bo)
boi = bo.identifiers[0]
bss = BiobankStoredSample(biobankStoredSampleId=u'23523523',
biobankId=participant.biobankId,
test=u'1SAL2',
created=created_ts,
biobankOrderIdentifier=boi.value,
confirmed=confirmed_ts)
with self.participant_dao.session() as session:
session.add(bss)
ps = self.summary_dao.get(participant.participantId)
self.assertIsNone(ps.sampleStatusDV1SAL2)
self.assertIsNone(ps.sampleStatusDV1SAL2Time)
self.summary_dao.update_from_biobank_stored_samples()
ps = self.summary_dao.get(participant.participantId)
self.assertEqual(ps.sampleStatus1SAL2, SampleStatus.RECEIVED)
self.assertEqual(ps.sampleStatus1SAL2Time, confirmed_ts)
def test_generate_samples(self):
participant_id = self.send_post('Participant', {})['participantId']
self.send_consent(participant_id)
self.send_post(
'Participant/%s/BiobankOrder' % participant_id,
load_biobank_order_json(
from_client_participant_id(participant_id)))
# Sanity check that the orders were created correctly.
bo_dao = BiobankOrderDao()
self.assertEquals(1, bo_dao.count())
order = bo_dao.get_all()[0]
self.assertEquals(
11, len(bo_dao.get_with_children(order.biobankOrderId).samples))
self.send_post('DataGen', {
'create_biobank_samples': True,
'samples_missing_fraction': 0.0
})
upsert_from_latest_csv(
) # Run the (usually offline) Biobank CSV import job.
self.assertEquals(11, BiobankStoredSampleDao().count())
ps = ParticipantSummaryDao().get(
from_client_participant_id(participant_id))
self.assertEquals(SampleStatus.RECEIVED, ps.samplesToIsolateDNA)
self.assertEquals(10, ps.numBaselineSamplesArrived)
def test_read_from_csv_file(self):
participant = self.participant_dao.insert(Participant(participantId=123, biobankId=1234))
self.summary_dao.insert(self.participant_summary(participant))
bo = self._make_biobank_order(participantId=participant.participantId, biobankOrderId='123',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345678')])
BiobankOrderDao().insert(bo)
participant2 = self.participant_dao.insert(Participant(participantId=124, biobankId=1235))
self.summary_dao.insert(self.participant_summary(participant2))
bo2 = self._make_biobank_order(participantId=participant2.participantId, biobankOrderId='124',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345679')])
BiobankOrderDao().insert(bo2)
participant3 = self.participant_dao.insert(Participant(participantId=125, biobankId=1236))
self.summary_dao.insert(self.participant_summary(participant3))
bo3 = self._make_biobank_order(participantId=participant3.participantId, biobankOrderId='125',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345680')])
BiobankOrderDao().insert(bo3)
samples_file = test_data.open_genomic_set_file('Genomic-Test-Set-test-1.csv')
input_filename = 'cloud%s.csv' % self._naive_utc_to_naive_central(clock.CLOCK.now()).strftime(
genomic_set_file_handler.INPUT_CSV_TIME_FORMAT)
self._write_cloud_csv(input_filename, samples_file)
genomic_set_file_handler.read_genomic_set_from_bucket()
set_dao = GenomicSetDao()
obj = set_dao.get_all()[0]
self.assertEqual(obj.genomicSetName, 'name_xxx')
self.assertEqual(obj.genomicSetCriteria, 'criteria_xxx')
self.assertEqual(obj.genomicSetVersion, 1)
member_dao = GenomicSetMemberDao()
items = member_dao.get_all()
for item in items:
self.assertIn(item.participantId, [123, 124, 125])
self.assertIn(item.biobankOrderId, ['123', '124', '125'])
self.assertIn(item.biobankId, ['1234', '1235', '1236'])
self.assertIn(item.biobankOrderClientId, ['12345678', '12345679', '12345680'])
self.assertEqual(item.genomicSetId, 1)
self.assertIn(item.genomeType, ['aou_wgs', 'aou_array'])
self.assertIn(item.nyFlag, [0, 1])
self.assertIn(item.sexAtBirth, ['F', 'M'])
def calculate_distinct_visits(self,
pid,
finalized_time,
id_,
amendment=False):
""" Participants may get PM or biobank samples on same day. This should be considered as
a single visit in terms of program payment to participant.
return Boolean: true if there has not been an order on same date."""
from dao.biobank_order_dao import BiobankOrderDao
from dao.physical_measurements_dao import PhysicalMeasurementsDao
day_has_order, day_has_measurement = False, False
existing_orders = BiobankOrderDao().get_biobank_orders_for_participant(
pid)
ordered_samples = BiobankOrderDao(
).get_ordered_samples_for_participant(pid)
existing_measurements = PhysicalMeasurementsDao(
).get_measuremnets_for_participant(pid)
order_id_to_finalized_date = {
sample.biobankOrderId: sample.finalized.date()
for sample in ordered_samples if sample.finalized
}
if existing_orders and finalized_time:
for order in existing_orders:
order_finalized_date = order_id_to_finalized_date.get(
order.biobankOrderId)
if order_finalized_date == finalized_time.date() and order.biobankOrderId != id_ and \
order.orderStatus != BiobankOrderStatus.CANCELLED:
day_has_order = True
elif order.biobankOrderId == id_ and order.orderStatus == BiobankOrderStatus.AMENDED:
day_has_order = True
elif not finalized_time and amendment:
day_has_order = True
if existing_measurements and finalized_time:
for measurement in existing_measurements:
if not measurement.finalized:
continue
if measurement.finalized.date() == finalized_time.date() and measurement.physicalMeasurementsId\
!= id_:
day_has_measurement = True
is_distinct_visit = not (day_has_order or day_has_measurement)
return is_distinct_visit
def test_to_json(self):
order = self._make_biobank_order()
order_json = BiobankOrderDao().to_client_json(order)
expected_order_json = load_biobank_order_json(
self.participant.participantId)
for key in ('createdInfo', 'collectedInfo', 'processedInfo',
'finalizedInfo'):
self.assertEquals(expected_order_json[key], order_json.get(key))
def setUp(self):
super(BiobankOrderApiTest, self).setUp(use_mysql=True)
self.participant = Participant(participantId=123, biobankId=555)
self.participant_dao = ParticipantDao()
self.participant_dao.insert(self.participant)
self.summary_dao = ParticipantSummaryDao()
self.bio_dao = BiobankOrderDao()
self.path = ('Participant/%s/BiobankOrder' %
to_client_participant_id(self.participant.participantId))
def setUp(self):
super(PhysicalMeasurementsDaoTest, self).setUp()
self.participant = Participant(participantId=1, biobankId=2)
ParticipantDao().insert(self.participant)
self.dao = PhysicalMeasurementsDao()
self.participant_summary_dao = ParticipantSummaryDao()
self.measurement_json = json.dumps(load_measurement_json(self.participant.participantId,
TIME_1.isoformat()))
self.biobank = BiobankOrderDao()
def setUp(self):
super(BigQuerySyncDaoTest, self).setUp(use_mysql=True,
with_consent_codes=True)
self.dao = ParticipantDao()
with self.dao.session() as session:
self.site = session.query(Site).filter(
Site.googleGroup == 'hpo-site-monroeville').first()
self.hpo = session.query(HPO).filter(HPO.name == 'PITT').first()
with clock.FakeClock(self.TIME_1):
self.participant = Participant(participantId=123, biobankId=555)
self.participant.hpoId = self.hpo.hpoId
self.participant.siteId = self.site.siteId
self.dao.insert(self.participant)
ps = ParticipantSummary(
participantId=123,
biobankId=555,
firstName='john',
lastName='doe',
withdrawalStatus=WithdrawalStatus.NOT_WITHDRAWN,
suspensionStatus=SuspensionStatus.NOT_SUSPENDED)
ps.hpoId = self.hpo.hpoId
ps.siteId = self.site.siteId
self.summary = ParticipantSummaryDao().insert(ps)
self.pm_json = json.dumps(
load_measurement_json(self.participant.participantId,
self.TIME_1.isoformat()))
self.pm = PhysicalMeasurementsDao().insert(
self._make_physical_measurements())
with clock.FakeClock(self.TIME_2):
self.dao = BiobankOrderDao()
self.bio_order = BiobankOrderDao().insert(
self._make_biobank_order(
participantId=self.participant.participantId))
def test_from_json(self):
ParticipantSummaryDao().insert(
self.participant_summary(self.participant))
order_json = load_biobank_order_json(self.participant.participantId)
order = BiobankOrderDao().from_client_json(
order_json, participant_id=self.participant.participantId)
self.assertEquals(1, order.sourceSiteId)
self.assertEquals('*****@*****.**', order.sourceUsername)
self.assertEquals(1, order.collectedSiteId)
self.assertEquals('*****@*****.**', order.collectedUsername)
self.assertEquals(1, order.processedSiteId)
self.assertEquals('*****@*****.**', order.processedUsername)
self.assertEquals(2, order.finalizedSiteId)
self.assertEquals('*****@*****.**', order.finalizedUsername)
def insert_biobank_order(self, pid, resource):
obj = BiobankOrder()
obj.participantId = long(pid)
obj.created = clock.CLOCK.now()
obj.created = datetime.datetime.now()
obj.orderStatus = BiobankOrderStatus.UNSET
obj.biobankOrderId = resource['biobankOrderId']
test = self.get(resource['id'])
obj.dvOrders = [test]
bod = BiobankOrderDao()
obj.samples = [
BiobankOrderedSample(test='1SAL2',
processingRequired=False,
description=u'salivary pilot kit')
]
self._add_identifiers_and_main_id(obj, ObjectView(resource))
bod.insert(obj)
def test_from_json(self):
ParticipantSummaryDao().insert(self.participant_summary(self.participant))
order_json = load_biobank_order_json(self.participant.participantId)
order = BiobankOrderDao().from_client_json(order_json,
participant_id=self.participant.participantId)
self.assertEquals(1, order.sourceSiteId)
self.assertEquals('*****@*****.**', order.sourceUsername)
self.assertEquals(1, order.collectedSiteId)
self.assertEquals('*****@*****.**', order.collectedUsername)
self.assertEquals(1, order.processedSiteId)
self.assertEquals('*****@*****.**', order.processedUsername)
self.assertEquals(2, order.finalizedSiteId)
self.assertEquals('*****@*****.**', order.finalizedUsername)
# testing finalized_time
samples_finalized_time = None
for sample in order_json['samples']:
samples_finalized_time = parse_date(sample['finalized'])
break
self.assertEquals(samples_finalized_time, order.finalizedTime)
def __init__(self):
super(BiobankOrderApi, self).__init__(BiobankOrderDao(),
get_returns_children=True)
def setUp(self):
super(MySqlReconciliationTest, self).setUp(use_mysql=True)
self.participant_dao = ParticipantDao()
self.summary_dao = ParticipantSummaryDao()
self.order_dao = BiobankOrderDao()
self.sample_dao = BiobankStoredSampleDao()
def test_create_and_upload_biobank_manifest_file(self):
participant = self.participant_dao.insert(Participant(participantId=123, biobankId=123))
self.summary_dao.insert(self.participant_summary(participant))
bo = self._make_biobank_order(participantId=participant.participantId, biobankOrderId='123',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345678')])
BiobankOrderDao().insert(bo)
participant2 = self.participant_dao.insert(Participant(participantId=124, biobankId=124))
self.summary_dao.insert(self.participant_summary(participant2))
bo2 = self._make_biobank_order(participantId=participant2.participantId, biobankOrderId='124',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345679')])
BiobankOrderDao().insert(bo2)
participant3 = self.participant_dao.insert(Participant(participantId=125, biobankId=125))
self.summary_dao.insert(self.participant_summary(participant3))
bo3 = self._make_biobank_order(participantId=participant3.participantId, biobankOrderId='125',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345680')])
BiobankOrderDao().insert(bo3)
genomic_set = self._create_fake_genomic_set('fake_genomic_set_name',
'fake_genomic_set_criteria',
'Genomic-Test-Set-v12019-04-05-00-30-10.CSV')
self._create_fake_genomic_member(genomic_set.id, participant.participantId, bo.biobankOrderId,
participant.biobankId, bo.identifiers[0].value,
validation_status=GenomicValidationStatus.VALID,
sex_at_birth='F', genome_type='aou_array', ny_flag='Y')
self._create_fake_genomic_member(genomic_set.id, participant2.participantId, bo2.biobankOrderId,
participant2.biobankId, bo2.identifiers[0].value,
validation_status=GenomicValidationStatus.INVALID_AGE,
sex_at_birth='M', genome_type='aou_array', ny_flag='N')
self._create_fake_genomic_member(genomic_set.id, participant3.participantId, bo3.biobankOrderId,
participant3.biobankId, bo3.identifiers[0].value,
validation_status=GenomicValidationStatus.INVALID_CONSENT,
sex_at_birth='F', genome_type='aou_wgs', ny_flag='Y')
now = clock.CLOCK.now()
genomic_biobank_menifest_handler\
.create_and_upload_genomic_biobank_manifest_file(genomic_set.id, now)
bucket_name = config.getSetting(config.BIOBANK_SAMPLES_BUCKET_NAME)
# convert UTC to CDT
now_cdt_str = _UTC.localize(now).astimezone(_US_CENTRAL).replace(tzinfo=None) \
.strftime(_OUTPUT_CSV_TIME_FORMAT)
class ExpectedCsvColumns(object):
VALUE = 'value'
BIOBANK_ID = 'biobank_id'
SEX_AT_BIRTH = 'sex_at_birth'
GENOME_TYPE = 'genome_type'
NY_FLAG = 'ny_flag'
REQUEST_ID = 'request_id'
PACKAGE_ID = 'package_id'
ALL = (VALUE, SEX_AT_BIRTH, GENOME_TYPE, NY_FLAG, REQUEST_ID, PACKAGE_ID)
expected_result_filename = 'rdr_fake_sub_folder/Genomic-Manifest-AoU-1-v1' + \
now_cdt_str + '.CSV'
path = '/' + bucket_name + '/' + expected_result_filename
csv_file = cloudstorage_api.open(path)
csv_reader = csv.DictReader(csv_file, delimiter=',')
missing_cols = set(ExpectedCsvColumns.ALL) - set(csv_reader.fieldnames)
self.assertEqual(len(missing_cols), 0)
rows = list(csv_reader)
self.assertEqual(rows[0][ExpectedCsvColumns.VALUE], '12345678')
self.assertEqual(rows[0][ExpectedCsvColumns.BIOBANK_ID], '123')
self.assertEqual(rows[0][ExpectedCsvColumns.SEX_AT_BIRTH], 'F')
self.assertEqual(rows[0][ExpectedCsvColumns.GENOME_TYPE], 'aou_array')
self.assertEqual(rows[0][ExpectedCsvColumns.NY_FLAG], 'Y')
self.assertEqual(rows[1][ExpectedCsvColumns.VALUE], '12345679')
self.assertEqual(rows[1][ExpectedCsvColumns.BIOBANK_ID], '124')
self.assertEqual(rows[1][ExpectedCsvColumns.SEX_AT_BIRTH], 'M')
self.assertEqual(rows[1][ExpectedCsvColumns.GENOME_TYPE], 'aou_array')
self.assertEqual(rows[1][ExpectedCsvColumns.NY_FLAG], 'N')
self.assertEqual(rows[2][ExpectedCsvColumns.VALUE], '12345680')
self.assertEqual(rows[2][ExpectedCsvColumns.BIOBANK_ID], '125')
self.assertEqual(rows[2][ExpectedCsvColumns.SEX_AT_BIRTH], 'F')
self.assertEqual(rows[2][ExpectedCsvColumns.GENOME_TYPE], 'aou_wgs')
self.assertEqual(rows[2][ExpectedCsvColumns.NY_FLAG], 'Y')
def test_create_genomic_set_result_file(self):
participant = self.participant_dao.insert(Participant(participantId=123, biobankId=123))
self.summary_dao.insert(self.participant_summary(participant))
bo = self._make_biobank_order(participantId=participant.participantId, biobankOrderId='123',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345678')])
BiobankOrderDao().insert(bo)
participant2 = self.participant_dao.insert(Participant(participantId=124, biobankId=124))
self.summary_dao.insert(self.participant_summary(participant2))
bo2 = self._make_biobank_order(participantId=participant2.participantId, biobankOrderId='124',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345679')])
BiobankOrderDao().insert(bo2)
participant3 = self.participant_dao.insert(Participant(participantId=125, biobankId=125))
self.summary_dao.insert(self.participant_summary(participant3))
bo3 = self._make_biobank_order(participantId=participant3.participantId, biobankOrderId='125',
identifiers=[BiobankOrderIdentifier(
system=u'https://www.pmi-ops.org', value=u'12345680')])
BiobankOrderDao().insert(bo3)
genomic_set = self._create_fake_genomic_set('fake_genomic_set_name',
'fake_genomic_set_criteria',
'Genomic-Test-Set-v12019-04-05-00-30-10.CSV')
self._create_fake_genomic_member(genomic_set.id, participant.participantId, bo.biobankOrderId,
participant.biobankId, bo.identifiers[0].value,
validation_status=GenomicValidationStatus.VALID,
sex_at_birth='F', genome_type='aou_array', ny_flag='Y')
self._create_fake_genomic_member(genomic_set.id, participant2.participantId, bo2.biobankOrderId,
participant2.biobankId, bo2.identifiers[0].value,
validation_status=GenomicValidationStatus.INVALID_AGE,
sex_at_birth='M', genome_type='aou_array', ny_flag='N')
self._create_fake_genomic_member(genomic_set.id, participant3.participantId, bo3.biobankOrderId,
participant3.biobankId, bo3.identifiers[0].value,
validation_status=GenomicValidationStatus.INVALID_CONSENT,
sex_at_birth='F', genome_type='aou_wgs', ny_flag='Y')
genomic_set_file_handler.create_genomic_set_status_result_file(genomic_set.id)
expected_result_filename = 'Genomic-Test-Set-v12019-04-05-00-30-10-Validation-Result.CSV'
bucket_name = config.getSetting(config.GENOMIC_SET_BUCKET_NAME)
path = '/' + bucket_name + '/' + expected_result_filename
csv_file = cloudstorage_api.open(path)
csv_reader = csv.DictReader(csv_file, delimiter=',')
class ResultCsvColumns(object):
"""Names of CSV columns that we read from the genomic set upload."""
GENOMIC_SET_NAME = 'genomic_set_name'
GENOMIC_SET_CRITERIA = 'genomic_set_criteria'
PID = 'pid'
BIOBANK_ORDER_ID = 'biobank_order_id'
NY_FLAG = 'ny_flag'
SEX_AT_BIRTH = 'sex_at_birth'
GENOME_TYPE = 'genome_type'
STATUS = 'status'
INVALID_REASON = 'invalid_reason'
ALL = (GENOMIC_SET_NAME, GENOMIC_SET_CRITERIA, PID, BIOBANK_ORDER_ID, NY_FLAG, SEX_AT_BIRTH,
GENOME_TYPE, STATUS, INVALID_REASON)
missing_cols = set(ResultCsvColumns.ALL) - set(csv_reader.fieldnames)
self.assertEqual(len(missing_cols), 0)
rows = list(csv_reader)
self.assertEqual(len(rows), 3)
self.assertEqual(rows[0][ResultCsvColumns.GENOMIC_SET_NAME], 'fake_genomic_set_name')
self.assertEqual(rows[0][ResultCsvColumns.GENOMIC_SET_CRITERIA], 'fake_genomic_set_criteria')
self.assertEqual(rows[0][ResultCsvColumns.STATUS], 'valid')
self.assertEqual(rows[0][ResultCsvColumns.INVALID_REASON], '')
self.assertEqual(rows[0][ResultCsvColumns.PID], '123')
self.assertEqual(rows[0][ResultCsvColumns.BIOBANK_ORDER_ID], '123')
self.assertEqual(rows[0][ResultCsvColumns.NY_FLAG], 'Y')
self.assertEqual(rows[0][ResultCsvColumns.GENOME_TYPE], 'aou_array')
self.assertEqual(rows[0][ResultCsvColumns.SEX_AT_BIRTH], 'F')
self.assertEqual(rows[1][ResultCsvColumns.GENOMIC_SET_NAME], 'fake_genomic_set_name')
self.assertEqual(rows[1][ResultCsvColumns.GENOMIC_SET_CRITERIA], 'fake_genomic_set_criteria')
self.assertEqual(rows[1][ResultCsvColumns.STATUS], 'invalid')
self.assertEqual(rows[1][ResultCsvColumns.INVALID_REASON], 'INVALID_AGE')
self.assertEqual(rows[1][ResultCsvColumns.PID], '124')
self.assertEqual(rows[1][ResultCsvColumns.BIOBANK_ORDER_ID], '124')
self.assertEqual(rows[1][ResultCsvColumns.NY_FLAG], 'N')
self.assertEqual(rows[1][ResultCsvColumns.GENOME_TYPE], 'aou_array')
self.assertEqual(rows[1][ResultCsvColumns.SEX_AT_BIRTH], 'M')
self.assertEqual(rows[2][ResultCsvColumns.GENOMIC_SET_NAME], 'fake_genomic_set_name')
self.assertEqual(rows[2][ResultCsvColumns.GENOMIC_SET_CRITERIA], 'fake_genomic_set_criteria')
self.assertEqual(rows[2][ResultCsvColumns.STATUS], 'invalid')
self.assertEqual(rows[2][ResultCsvColumns.INVALID_REASON], 'INVALID_CONSENT')
self.assertEqual(rows[2][ResultCsvColumns.PID], '125')
self.assertEqual(rows[2][ResultCsvColumns.BIOBANK_ORDER_ID], '125')
self.assertEqual(rows[2][ResultCsvColumns.NY_FLAG], 'Y')
self.assertEqual(rows[2][ResultCsvColumns.GENOME_TYPE], 'aou_wgs')
self.assertEqual(rows[2][ResultCsvColumns.SEX_AT_BIRTH], 'F')
def setUp(self): super(BiobankOrderDaoTest, self).setUp(use_mysql=True) self.participant = Participant(participantId=123, biobankId=555) ParticipantDao().insert(self.participant) self.dao = BiobankOrderDao()
