def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.study = main_factory.StudyFactory() cls.study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) cls.protocol = main_factory.ProtocolFactory()
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 test_legacy_import_adds_entry(self): study = self._writable_study() protocol = factory.ProtocolFactory() measurement_type = factory.MeasurementTypeFactory() import_id = factory.fake.uuid4() storage = ImportBroker() storage.set_context(import_id, {}) storage.add_page( import_id, [ { "assay_id": "named_or_new", "assay_name": "bar", "compartment": "0", "data": [[12, 34]], "kind": "std", "line_id": "new", "line_name": "foo", "measurement_id": measurement_type.pk, "measurement_name": measurement_type.type_name, "protocol_id": protocol.pk, "units_id": "1", }, ], ) import_table_task.s(study.id, self.user.id, import_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 _build_measurements(cls, measurement_id, category, line, metabolite, values): protocol = factory.ProtocolFactory(categorization=category) assay = factory.AssayFactory(line=line, protocol=protocol) measurement = factory.MeasurementFactory( id=measurement_id, assay=assay, measurement_type=metabolite ) for x, y in values: factory.ValueFactory(measurement=measurement, x=[x], y=[y])
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.study = factory.StudyFactory() cls.study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) cls.protocol = factory.ProtocolFactory() cls.measurement_type = factory.MeasurementTypeFactory()
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() cls.study = factory.StudyFactory() cls.study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) cls.protocol = factory.ProtocolFactory() cls.category = CategoryFactory() cls.layout = LayoutFactory()
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.protocol = factory.ProtocolFactory() cls.study = factory.StudyFactory() cls.study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) cls.arcA = factory.LineFactory(study=cls.study, name="arcA") cls.mtype = factory.MeasurementTypeFactory() cls.x_unit = factory.UnitFactory() cls.y_unit = factory.UnitFactory()
def test_gcms_import_task(self): task_uuid = uuid.uuid4() base = "ImportData_PCAP_GCMS.csv" context = self._build_import_context(base, task_uuid) # not using one of the default bootstrap protocols! protocol = factory.ProtocolFactory() context.update(masterProtocol=protocol.id) # not using default bootstrap measurements either self._replace_series_item_values = self._create_gcms_replace_function(protocol) # now run the task self._run_task(base, task_uuid, context) # cleanup del self._replace_series_item_values self.assertEqual(self._assay_count(), 30) self.assertEqual(self._measurement_count(), 30) self.assertEqual(self._value_count(), 30)
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 setUpTestData(cls): super().setUpTestData() # run imports to have some data to validate exports import_shim = ImportDataTestsMixin() cls.target_study = factory.StudyFactory() cls.user = UserFactory() cls.target_study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE ) import_shim.target_study = cls.target_study import_shim.user = cls.user # define expected lines for PCAP files CREATE_PCAP_LINES(cls.target_study) # run the imports, so we have data to export # import the first task1 = uuid.uuid4() base1 = "ImportData_PCAP_GCMS.csv" context = import_shim._build_import_context(base1, task1) # not using one of the default bootstrap protocols! protocol = factory.ProtocolFactory() context.update(masterProtocol=protocol.id) # not using default bootstrap measurements either replace = PCAPImportDataTests._create_gcms_replace_function(protocol) import_shim._replace_series_item_values = replace # then run task import_shim._run_task(base1, task1, context) del import_shim._replace_series_item_values # import the second task2 = uuid.uuid4() base2 = "ImportData_PCAP_OD.xlsx" context = import_shim._build_import_context(base2, task2) import_shim._run_task(base2, task2, context) # import the third task3 = uuid.uuid4() base3 = "ImportData_PCAP_Proteomics.csv" context = import_shim._build_import_context(base3, task3) import_shim._run_task(base3, task3, context)
def setUpTestData(cls): super().setUpTestData() cls.testuser = UserFactory() cls.metabolomics = factory.ProtocolFactory(name="Metabolomics") cls.targeted_proteomics = factory.ProtocolFactory( name="Targeted Proteomics")