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