def CREATE_PCAP_LINES(study): # generate line objects for PCAP tutorial first = ("A", "B", "2X") second = ("H", "L", "M") third = ("h", "l", "m") combos = itertools.product(first, second, third) for i, (a, b, c) in enumerate(combos, start=1000): factory.LineFactory(study=study, id=i, name=f"{a}-{b}{c}") for j, d in enumerate(third, start=i + 1): factory.LineFactory(study=study, id=j, name=f"BL-M{d}")
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.target_study = main_factory.StudyFactory() cls.target_study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) cls.BW1 = main_factory.LineFactory(study=cls.target_study, name="BW1") cls.arcA = main_factory.LineFactory(study=cls.target_study, name="arcA") cls.target_kwargs = {"slug": cls.target_study.slug} cls.protocol = main_factory.ProtocolFactory()
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.target_study = factory.StudyFactory() cls.target_study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) # TODO: IDs are hard-coded in the *.post.*.json files # measurement ID of Optical Density is set to 1 in bootstrap factory.LineFactory(id=998, study=cls.target_study, name="BW1") factory.LineFactory(id=999, study=cls.target_study, name="arcA") factory.MetaboliteFactory(id=898, type_name="D-Glucose") factory.MetaboliteFactory(id=899, type_name="Acetate")
def test_resolve_with_duplicate_lines(self): # setup main_factory.LineFactory(study=self.target_study, name="BW1") main_factory.LineFactory(study=self.target_study, name="arcA") mpr = list(self._generate_measurement_product()) parsed = ParseResult( series_data=mpr, record_src="row", any_time=True, has_all_times=True, ) resolver, type_resolver = self._make_resolvers(parsed) # exec + assert with pytest.raises(exceptions.DuplicateLineError): resolver.resolve(type_resolver)
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.protocol = main_factory.ProtocolFactory() cls.target_study = main_factory.StudyFactory() cls.target_study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) cls.BW1 = main_factory.LineFactory(study=cls.target_study, name="BW1") cls.arcA = main_factory.LineFactory(study=cls.target_study, name="arcA") cls.mtype = main_factory.MeasurementTypeFactory() cls.x_unit = main_factory.UnitFactory() cls.y_unit = main_factory.UnitFactory()
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() # initialize study for worklist cls.study = factory.StudyFactory() cls.study.userpermission_set.update_or_create( permission_type=models.StudyPermission.READ, user=cls.user) # initialize protocol for worklist cls.protocol = factory.ProtocolFactory(name="potato") # initialize twenty lines in the study, 1-base index cls.lines = [ factory.LineFactory(name=f"L{i}", study=cls.study) for i in range(1, 21) ] # initialize 3x assays on lines 6, 8, 10, 12, 14 (1-base) # assays at times 12, 24, 36 time = models.MetadataType.system("Time") cls.assays = [ factory.AssayFactory( line=cls.lines[line], metadata={time.pk: 12 * i}, name=f"{cls.lines[line].name}-A{i}", protocol=cls.protocol, ) for line in range(5, 14, 2) for i in range(1, 4) ]
def test_simple_import(self): """Test an import where everything is already resolved.""" line = factory.LineFactory(study=self.target_study) protocol = factory.ProtocolFactory() assay = factory.AssayFactory(line=line, protocol=protocol) mtype = factory.MetaboliteFactory() unit = factory.UnitFactory() # no measurements exist before import self.assertEqual( models.Measurement.objects.filter( study_id=self.target_study.pk).count(), 0) self._set_permission(permission_type=models.StudyPermission.WRITE) run = TableImport(self.target_study, self.user) added, updated = run.import_series_data([{ "line_id": line.id, "assay_id": assay.id, "measurement_id": mtype.id, "comp_id": models.Measurement.Compartment.UNKNOWN, "units_id": unit.id, "metadata": {}, "data": [[0, 0]], }]) # after the self-reported add/update are correct self.assertEqual(added, 1) self.assertEqual(updated, 0) # and the counts are correct self.assertEqual( models.Measurement.objects.filter( study_id=self.target_study.pk).count(), 1)
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.target_study = factory.StudyFactory() cls.target_study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE ) # IDs are hard-coded in FBA files in main/tests/files line1 = factory.LineFactory(id=998, study=cls.target_study, name="BW1") met1 = factory.MetaboliteFactory(id=898, type_name="D-Glucose") met2 = factory.MetaboliteFactory(id=899, type_name="Acetate") # optical density already defined in bootstrap od = models.MeasurementType.objects.get( uuid="d7510207-5beb-4d56-a54d-76afedcf14d0" ) values = zip(cls.TIMES, cls.GLUCOSE_VALUES) cls._build_measurements( 1000, models.Protocol.CATEGORY_HPLC, line1, met1, values ) values = zip(cls.TIMES, cls.ACETATE_VALUES) cls._build_measurements( 1001, models.Protocol.CATEGORY_HPLC, line1, met2, values ) values = zip(cls.TIMES, cls.OD_VALUES) cls._build_measurements(1002, models.Protocol.CATEGORY_OD, line1, od, values) factory.SBMLTemplateFactory(id=666, uuid=uuid.uuid4())
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() # initialize study for worklist study = factory.StudyFactory() study.userpermission_set.update_or_create( permission_type=models.StudyPermission.READ, user=cls.user) line = factory.LineFactory(study=study) cls.payload = {"lineId": [line.id]}
def _setup_study_with_data_for_export(self): # create study and line with 30 assays # each assay with one measurement having one value self.study = factory.StudyFactory() self.line = factory.LineFactory(study=self.study) for _i in range(30): assay = factory.AssayFactory(line=self.line) measurement = factory.MeasurementFactory(assay=assay) factory.ValueFactory(measurement=measurement)
def test_disable_line_adds_entry(self): study = self._writable_study() line = factory.LineFactory(study=study) url = reverse("main:lines", kwargs={"slug": study.slug}) form = {"action": "disable_confirm", "lineId": [line.id]} self.client.post(url, data=form, follow=True) qs = self._find_log(event=StudyLog.Event.DESCRIBED, study=study) assert qs.count() == 1 sl = qs.get() assert sl.detail == {"count": -1}
def setUpTestData(cls): super().setUpTestData() User = get_user_model() cls.admin = User.objects.get(username="******") # create study and line with 30 assays # each assay with one measurement having one value cls.study = factory.StudyFactory() cls.line = factory.LineFactory(study=cls.study) for _i in range(30): assay = factory.AssayFactory(line=cls.line) measurement = factory.MeasurementFactory(assay=assay) factory.ValueFactory(measurement=measurement)
def test_clone_multiple_line_adds_entry(self): study = self._writable_study() to_clone = 4 lines = [factory.LineFactory(study=study) for _ in range(to_clone)] url = reverse("main:lines", kwargs={"slug": study.slug}) form = {"action": "clone", "lineId": [line.id for line in lines]} self.client.post(url, data=form, follow=True) qs = self._find_log(event=StudyLog.Event.DESCRIBED, study=study) assert qs.count() == 1 sl = qs.get() assert sl.detail == {"count": to_clone}
def setUpTestData(cls): super().setUpTestData() cls.readonly_user = UserFactory() cls.study = factory.StudyFactory() cls.study.userpermission_set.create( user=cls.readonly_user, permission_type=models.StudyPermission.READ) cls.strains = [ factory.StrainFactory(), factory.StrainFactory(), factory.StrainFactory(), ] for i in range(10): line = factory.LineFactory(study=cls.study) line.strains.add(cls.strains[i % len(cls.strains)])
def test_wizard_import_adds_entry(self): study = self._writable_study() line = factory.LineFactory(study=study) protocol = factory.ProtocolFactory() measurement_type = factory.MeasurementTypeFactory() x_unit = factory.UnitFactory() y_unit = factory.UnitFactory() broker = ImportBroker() load = LoadRequest( protocol_uuid=protocol.uuid, status=LoadRequest.Status.READY, study_uuid=study.uuid, x_units_name=x_unit.unit_name, y_units_name=y_unit.unit_name, ) # storing the LoadRequest in backend will allow transitions load.store() # minimal data to load into study broker.set_context( load.request, { "loa_pks": {line.pk}, "matched_assays": False, "use_assay_times": False }, ) broker.add_page( load.request, [{ "compartment": edd_models.Measurement.Compartment.UNKNOWN, "data": [[[12], [42]]], "format": edd_models.Measurement.Format.SCALAR, "line_id": line.pk, "measurement_id": measurement_type.pk, "x_unit_id": x_unit.pk, "y_unit_id": y_unit.pk, }], ) wizard_execute_loading.s(load.request, self.user.id).apply() qs = self._find_log(event=StudyLog.Event.IMPORTED, study=study) assert qs.count() == 1 sl = qs.get() assert sl.detail == {"count": 1, "protocol": str(protocol.uuid)}
def test_lines_list_replicate_grouping(self): # create three new lines with matching replicate IDs replicate_type = models.MetadataType.system("Replicate") replicate_id = "abcd-fake-replicate-uuid" for _ in range(3): factory.LineFactory(study=self.study, metadata={replicate_type.pk: replicate_id}) # query lines, with big page size and replicate grouping flag set url = reverse("rest:lines-list") self.client.force_login(self.readonly_user) response = self.client.get(url, { "in_study": self.study.slug, "page_size": 50, "replicates": "yes" }) self._check_status(response, status.HTTP_200_OK) # replicates only count as one more item in page assert response.data["count"] == 11 # replicates have individual records in page assert len(response.data["results"]) == 13