def test_resolve_broad_type_multiple(self):
broad = factory.CategoryFactory()
tr = TypeResolver(self.user, broad)
main_factory.MeasurementTypeFactory(type_name="foobar")
main_factory.MeasurementTypeFactory(type_name="foobar")
with pytest.raises(ValidationError):
tr.lookup_type("foobar")
def test_resolve_generic_type_multiple(self):
generic = factory.CategoryFactory(
type_group=models.MeasurementType.Group.GENERIC)
tr = TypeResolver(self.user, generic)
main_factory.MeasurementTypeFactory(type_name="foobar")
main_factory.MeasurementTypeFactory(type_name="foobar")
with pytest.raises(ValidationError):
tr.lookup_type("foobar")
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 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 _create_gcms_replace_function(cls, protocol):
# *.series.json files need some hard-coded IDs
# this makes a function to insert them
measurement_type = factory.MeasurementTypeFactory(type_name="Limonene")
def replace(item):
item.update(protocol_id=protocol.id, measurement_id=measurement_type.id)
return item
return replace
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_resolve_with_multiple_existing_values(self):
# setup
assay_A = main_factory.AssayFactory(line=self.BW1,
protocol=self.protocol)
assay_B = main_factory.AssayFactory(line=self.BW1,
protocol=self.protocol)
hours = models.MeasurementUnit.objects.get(unit_name="hours")
na = models.MeasurementUnit.objects.get(unit_name="n/a")
mtype = main_factory.MeasurementTypeFactory()
measurement_A = main_factory.MeasurementFactory(assay=assay_A,
measurement_type=mtype,
x_units=hours,
y_units=na)
measurement_B = main_factory.MeasurementFactory(assay=assay_B,
measurement_type=mtype,
x_units=hours,
y_units=na)
# making multiple existing points for same type at same time
main_factory.ValueFactory(measurement=measurement_A, x=[24])
main_factory.ValueFactory(measurement=measurement_A, x=[24])
main_factory.ValueFactory(measurement=measurement_A, x=[24])
main_factory.ValueFactory(measurement=measurement_B, x=[24])
main_factory.ValueFactory(measurement=measurement_B, x=[24])
main_factory.ValueFactory(measurement=measurement_B, x=[24])
mpr = list(
self._generate_measurement_product(
names=[assay_A.name, assay_B.name],
types=[mtype.type_name],
points=[[[24], [1]]],
))
parsed = ParseResult(
series_data=mpr,
record_src="row",
any_time=True,
has_all_times=True,
)
resolver, type_resolver = self._make_resolvers(parsed)
# exec
context = resolver.resolve(type_resolver)
# asserts
assert context == {
"conflicted_from_import": 2,
"conflicted_from_study": 6,
"file_has_times": True,
"file_has_units": True,
"importId": self.load.request,
"loa_pks": {assay_A.pk, assay_B.pk},
"matched_assays": True,
"totalPages": 1,
"total_vals": 2,
"use_assay_times": False,
}
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)}
