def test_init(self, well_fac):
kw = well_fac.init_kw
well = Well.create_from_rack_and_position(**kw)
assert well.rack.barcode == kw['rack'].barcode
assert well.position == kw['position']
check_attributes(well, kw)
assert well.slug == well.position.label
def test_init(self, request, planned_liquid_transfer_fac_name, hash_value):
planned_liquid_transfer_fac = \
request.getfuncargvalue(planned_liquid_transfer_fac_name)
plt = planned_liquid_transfer_fac()
check_attributes(plt, planned_liquid_transfer_fac.init_kw)
assert plt.get_hash_value(**planned_liquid_transfer_fac.init_kw) \
== hash_value
def test_init(self, rack_shape_fac):
kw = rack_shape_fac.init_kw
kw['number_rows'] = 8
kw['number_columns'] = 12
rs = rack_shape_fac(**kw)
check_attributes(rs, kw)
assert rs.size == 96
def test_init(self, request, planned_liquid_transfer_fac_name, hash_value):
planned_liquid_transfer_fac = \
request.getfuncargvalue(planned_liquid_transfer_fac_name)
plt = planned_liquid_transfer_fac()
check_attributes(plt, planned_liquid_transfer_fac.init_kw)
assert plt.get_hash_value(**planned_liquid_transfer_fac.init_kw) \
== hash_value
def test_init_from_rack_and_position(self, tube_fac,
tube_rack, rack_position11):
kw = tube_fac.init_kw
kw['rack'] = tube_rack
kw['position'] = rack_position11
tube = Tube.create_from_rack_and_position(**kw)
check_attributes(tube, kw)
assert not tube.slug is None
assert tube.position == kw['position']
def test_init(self, request, fac_name):
fac = request.getfuncargvalue(fac_name)
rs = fac()
check_attributes(rs, fac.init_kw)
if fac_name == 'plate_specs_fac':
assert not rs.has_tubes
else:
assert rs.has_tubes
assert len(rs.tube_specs) == 0
def test_init(self, request, fac_name, key, planned_fac_name):
fac = request.getfuncargvalue(fac_name)
elt = fac()
check_attributes(elt, fac.init_kw)
kw = fac.init_kw
pfac = request.getfuncargvalue(planned_fac_name)
kw[key] = pfac()
with pytest.raises(ValueError):
fac(**kw)
def test_init(self, request, fac_name, key, planned_fac_name):
fac = request.getfuncargvalue(fac_name)
elt = fac()
check_attributes(elt, fac.init_kw)
kw = fac.init_kw
pfac = request.getfuncargvalue(planned_fac_name)
kw[key] = pfac()
with pytest.raises(ValueError):
fac(**kw)
def test_tube_specs_tube_factory(self, tube_specs, item_status_managed):
# Need status *and* barcode.
with pytest.raises(TypeError):
tube_specs.create_tube(item_status_managed)
barcode = '1111111111'
tube = tube_specs.create_tube(item_status_managed, barcode)
attributes = dict(specs=tube_specs,
status=item_status_managed,
barcode=barcode)
check_attributes(tube, attributes)
def _test_init(self, attrs=None, abstract_class=False):
if attrs is None:
attrs = self._get_data()
if abstract_class:
self.assert_raises(NotImplementedError, self.entity_class, **attrs)
else:
entity = self.entity_class(**attrs) #pylint: disable=E1102
self.assert_is_not_none(entity)
self.assert_true(isinstance(entity, self.entity_class))
check_attributes(entity, attrs)
return entity
def _test_init(self, attrs=None, abstract_class=False):
if attrs is None:
attrs = self._get_data()
if abstract_class:
self.assert_raises(NotImplementedError, self.entity_class, **attrs)
else:
entity = self.entity_class(**attrs) #pylint: disable=E1102
self.assert_is_not_none(entity)
self.assert_true(isinstance(entity, self.entity_class))
check_attributes(entity, attrs)
return entity
def test_init(self, request, iso_fac_name):
iso_fac = request.getfuncargvalue(iso_fac_name)
iso = iso_fac()
check_attributes(iso, iso_fac.init_kw)
assert len(iso.iso_stock_racks) == 0
assert len(iso.iso_sector_stock_racks) == 0
assert len(iso.iso_preparation_plates) == 0
assert len(iso.iso_aliquot_plates) == 0
if iso_fac_name == 'stock_sample_creation_iso_fac':
assert len(iso.iso_sector_preparation_plates) == 0
else:
assert len(iso.final_plates) == 0
assert iso.slug == slug_from_string(iso.label)
def test_init(self, request, iso_fac_name):
iso_fac = request.getfuncargvalue(iso_fac_name)
iso = iso_fac()
check_attributes(iso, iso_fac.init_kw)
assert len(iso.iso_stock_racks) == 0
assert len(iso.iso_sector_stock_racks) == 0
assert len(iso.iso_preparation_plates) == 0
assert len(iso.iso_aliquot_plates) == 0
if iso_fac_name == 'stock_sample_creation_iso_fac':
assert len(iso.iso_sector_preparation_plates) == 0
else:
assert len(iso.final_plates) == 0
assert iso.slug == slug_from_string(iso.label)
def test_init(self, request, fac_name, specs_fac_name, rack_position_fac):
specs = request.getfuncargvalue(specs_fac_name)
fac = request.getfuncargvalue(fac_name)
kw = fac.init_kw
kw['specs'] = specs
rack = fac(**kw)
check_attributes(rack, kw)
if fac_name == 'plate_fac':
assert len(rack.containers) == 96
pos = rack_position_fac(row_index=5, column_index=5)
well = rack.container_positions[pos]
assert well.position.row_index == 5
assert well.position.column_index == 5
assert well.rack is rack
else:
assert len(rack.containers) == 0
def test_init(self, gene_fac):
gene = gene_fac()
assert gene.slug == slug_from_string(gene.accession)
check_attributes(gene, gene_fac.init_kw)
def test_init(self, molecule_design_library_fac):
mdl = molecule_design_library_fac()
check_attributes(mdl, molecule_design_library_fac.init_kw)
assert len(mdl.library_plates) == 0
def test_init(self, request, iso_plate_fac_name):
iso_plate_fac = request.getfuncargvalue(iso_plate_fac_name)
ip = iso_plate_fac()
check_attributes(ip, iso_plate_fac.init_kw)
def test_init(self, tube_transfer_worklist_fac):
ttwl = tube_transfer_worklist_fac()
check_attributes(ttwl, tube_transfer_worklist_fac.init_kw)
def test_init(self, device_fac):
device = device_fac()
check_attributes(device, device_fac.init_kw)
assert not device.slug is None
assert len(device.locations) == 0
def test_init(self, lab_iso_request_fac, kw):
_kw = lab_iso_request_fac.init_kw
_kw.update(kw)
lir = lab_iso_request_fac(**_kw)
check_attributes(lir, _kw)
assert len(lir.isos) == 0
def test_init(self, tube_specs_fac):
kw = tube_specs_fac.init_kw
tube_specs = TubeSpecs(**kw)
check_attributes(tube_specs, kw)
def test_init(self, experiment_design_fac):
exp_dsgn = experiment_design_fac()
check_attributes(exp_dsgn, experiment_design_fac.init_kw)
def test_init_floating(self, tube_fac):
tube = tube_fac()
check_attributes(tube, tube_fac.init_kw)
assert not tube.slug is None
def test_init(self, barcoded_location_fac):
bl = barcoded_location_fac()
check_attributes(bl, barcoded_location_fac.init_kw)
assert bl.rack is None
assert bl.slug == slug_from_string(bl.name)
def test_init(self, container_location_fac):
kw = container_location_fac.init_kw
cl = TubeLocation(**kw)
check_attributes(cl, kw)
def test_init(self, well_specs_fac):
kw = well_specs_fac.init_kw
well_specs = WellSpecs(**kw)
check_attributes(well_specs, kw)
def test_init(self, request, fac_name):
fac = request.getfuncargvalue(fac_name)
md = fac()
check_attributes(md, fac.init_kw)
def test_init(self, request, iso_plate_fac_name):
iso_plate_fac = request.getfuncargvalue(iso_plate_fac_name)
ip = iso_plate_fac()
check_attributes(ip, iso_plate_fac.init_kw)
def test_init(self, experiment_design_rack_fac):
exp_dr = experiment_design_rack_fac()
check_attributes(exp_dr, experiment_design_rack_fac.init_kw)
def test_init(self, stock_sample_creation_iso_request_fac):
ssir = stock_sample_creation_iso_request_fac()
check_attributes(ssir, stock_sample_creation_iso_request_fac.init_kw)
def test_init(self, experiment_metadata_fac):
em = experiment_metadata_fac()
check_attributes(em, experiment_metadata_fac.init_kw)
def test_init(self, user_fac):
user = user_fac()
check_attributes(user, user_fac.init_kw)
assert user.slug == slug_from_string(user.directory_user_id)
def test_init(self, stock_sample_creation_iso_request_fac):
ssir = stock_sample_creation_iso_request_fac()
check_attributes(ssir, stock_sample_creation_iso_request_fac.init_kw)
def test_init(self, device_type_fac):
dev_type = device_type_fac()
check_attributes(dev_type, device_type_fac.init_kw)
assert not dev_type.slug is None
assert len(dev_type.devices) == 0
def test_init(self, species_fac):
spec = species_fac()
check_attributes(spec, species_fac.init_kw)
assert spec.slug == slug_from_string(spec.common_name)
def test_init(self, item_status_fac):
its = item_status_fac()
check_attributes(its, item_status_fac.init_kw)
assert its.slug == slug_from_string(its.name)
def test_init(self, molecule_type_fac):
mt = molecule_type_fac()
check_attributes(mt, molecule_type_fac.init_kw)
assert mt.slug == slug_from_string(mt.name)
def test_init(self, tube_transfer_fac):
tt = tube_transfer_fac()
check_attributes(tt, tube_transfer_fac.init_kw)
def test_init(self, organization_fac):
org = organization_fac()
check_attributes(org, organization_fac.init_kw)
assert org.slug == slug_from_string(org.name)
def test_init(self, library_plate_fac):
lp = library_plate_fac()
check_attributes(lp, library_plate_fac.init_kw)
def test_init(self, sample_molecule_fac):
sm = sample_molecule_fac()
check_attributes(sm, sample_molecule_fac.init_kw)
def test_init(self, project_fac):
proj = project_fac()
check_attributes(proj, project_fac.init_kw)
assert proj.slug == slug_from_string(proj.label)
def test_init(self, stock_sample_fac):
sspl = stock_sample_fac()
check_attributes(sspl, stock_sample_fac.init_kw)
def test_init(self, request, stock_rack_fac_name):
stock_rack_fac = request.getfuncargvalue(stock_rack_fac_name)
sr = stock_rack_fac()
check_attributes(sr, stock_rack_fac.init_kw)
def test_init(self, molecule_fac):
mol = molecule_fac()
check_attributes(mol, molecule_fac.init_kw)
def test_init(self, lab_iso_request_fac, kw):
_kw = lab_iso_request_fac.init_kw
_kw.update(kw)
lir = lab_iso_request_fac(**_kw)
check_attributes(lir, _kw)
assert len(lir.isos) == 0
def test_init(self, user_preferences_fac):
up = user_preferences_fac()
check_attributes(up, user_preferences_fac.init_kw)
assert up.slug == slug_from_string("%s_%s"
% (up.user.username, up.app_name))
def test_init(self, experiment_fac):
exp = experiment_fac()
check_attributes(exp, experiment_fac.init_kw)
assert len(exp.experiment_racks) == 0
def test_init(self, molecule_design_pool_set_fac):
mdps = molecule_design_pool_set_fac()
check_attributes(mdps, molecule_design_pool_set_fac.init_kw)
