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
