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")
