def test_users_list_with_study(self): study = factory.StudyFactory() url = reverse("rest:users-list") self.client.force_login(self.admin) response = self.client.get(url, {"in_study": study.slug}) self._check_status(response, status.HTTP_200_OK) assert "count" in response.data
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 _writable_study(self): study = factory.StudyFactory() study.userpermission_set.update_or_create( permission_type=edd_models.StudyPermission.WRITE, user=self.user, ) return study
def test_combinatorial_metadata_parsing(self): """ Tests parsing of combinatorial assay metadata from an Experiment Description file, e.g. as used in the Skyline workflow for proteomics. """ ed_file = factory.test_file_path( "experiment_description/advanced.xlsx") study = factory.StudyFactory() # creating *AFTER* setup of testing database records cache = ExperimentDescriptionContext() importer = CombinatorialCreationImporter(study, self.testuser, cache) parser = ExperimentDescFileParser(cache, importer) parsed: List[CombinatorialDescriptionInput] = parser.parse_excel( ed_file) combo_input: CombinatorialDescriptionInput = parsed[0] time_meta_type = models.MetadataType.system("Time") self.assertDictEqual( combo_input.protocol_to_combinatorial_meta_dict, { self.targeted_proteomics.pk: { time_meta_type.pk: [8.0, 24.0] }, self.metabolomics.pk: { time_meta_type.pk: [4.0, 6.0] }, }, )
def test_single_valued_metadata_parsing(self): """ Tests parsing of single-valued (non-combinatorial) assay metadata from an Experiment Description file, e.g. as used in the Skyline workflow for proteomics. """ lines_iter = iter( ("Line Name, Targeted Proteomics Time", "A, 2h", "B, 5h")) study = factory.StudyFactory() # creating *AFTER* setup of testing database records cache = ExperimentDescriptionContext() importer = CombinatorialCreationImporter(study, self.testuser, cache) parser = ExperimentDescFileParser(cache, importer) parsed: List[CombinatorialDescriptionInput] = parser.parse_csv( lines_iter) time_meta_type = models.MetadataType.system("Time") self.assertDictEqual( parsed[0].protocol_to_assay_metadata, {self.targeted_proteomics.pk: { time_meta_type.pk: 2.0 }}, ) self.assertDictEqual( parsed[1].protocol_to_assay_metadata, {self.targeted_proteomics.pk: { time_meta_type.pk: 5.0 }}, )
def test_metadata_types_list_in_study(self): study = factory.StudyFactory() url = reverse("rest:metadata_types-list") self.client.force_login(self.admin) response = self.client.get(url, {"in_study": study.slug}) self._check_status(response, status.HTTP_200_OK) assert response.data["count"] == 0
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() cls.study = factory.StudyFactory() cls.study_kwargs = {"slug": cls.study.slug} cls.study.userpermission_set.update_or_create( permission_type=models.StudyPermission.WRITE, user=cls.user)
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.read_only_group = GroupFactory() cls.write_only_group = GroupFactory() cls.superuser = UserFactory(is_superuser=True) cls.unprivileged_user = UserFactory() cls.readonly_user = UserFactory() cls.write_user = UserFactory() cls.group_readonly_user = UserFactory() cls.group_readonly_user.groups.add(cls.read_only_group) cls.group_write_user = UserFactory() cls.group_write_user.groups.add(cls.write_only_group) cls.staff_user = UserFactory(is_staff=True) cls.staff_user.user_permissions.add( *load_permissions(models.Study, "add_study", "change_study", "delete_study") ) cls.study = factory.StudyFactory() cls.study.userpermission_set.create( user=cls.readonly_user, permission_type=models.StudyPermission.READ ) cls.study.userpermission_set.create( user=cls.write_user, permission_type=models.StudyPermission.WRITE ) cls.study.grouppermission_set.create( group=cls.read_only_group, permission_type=models.StudyPermission.READ ) cls.study.grouppermission_set.create( group=cls.write_only_group, permission_type=models.StudyPermission.WRITE )
def test_advanced_experiment_description_xlsx(self): strain, _ = models.Strain.objects.get_or_create(name="JW0111") # creating *AFTER* setup of testing database records cache = ExperimentDescriptionContext() cache.strains_by_pk = {strain.pk: strain} advanced_experiment_def_xlsx = factory.test_file_path( "experiment_description/advanced.xlsx") study = factory.StudyFactory() importer = CombinatorialCreationImporter(study, self.testuser, cache) parser = ExperimentDescFileParser(cache, importer) parsed = parser.parse_excel(advanced_experiment_def_xlsx) self.assertEqual(len(parsed), 1, "Expected a single set of parsed input") # TODO: following two calls should go away self._map_input_strains(parsed, cache, {"JBx_002078": strain}) importer._query_related_object_context(parsed) result = parsed[0].populate_study(study, importer.cache, ExperimentDescriptionOptions()) self.assertFalse(importer.errors, "Import generated errors") self.assertFalse(importer.warnings, "Import generated warnings") for line in result.lines_created: self.assertEqual(line.description, "Description blah blah") self.assertEqual(line.assay_set.count(), 4)
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.target_study = factory.StudyFactory() cls.target_study.userpermission_set.create( user=cls.user, permission_type=models.StudyPermission.WRITE) # define expected lines for PCAP files CREATE_PCAP_LINES(cls.target_study)
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory() # initialize study cls.study = factory.StudyFactory() cls.study.userpermission_set.update_or_create( permission_type=models.StudyPermission.READ, user=cls.user) factory.create_fake_exportable_study(cls.study)
def test_basic_json(self): """ A simplified integration test that exercises much of the EDD code responsible for combinatorial line creation based on a simplified input, creating replicates for a single line with some metadata using a known strain. Test inputs in this example roughly correspond to the sample experiment description file attached to EDD-380. Testing the full code path for EDD's experiment description file support requires having a corresponding ICE deployment to use as part of the test, so it's not addressed here. """ meta = factory.MetadataTypeFactory(for_context=models.MetadataType.LINE) # Create strains for this test strain, _ = models.Strain.objects.get_or_create(name="JW0111") control = models.MetadataType.system("Control") # creating *AFTER* setup of testing database records cache = ExperimentDescriptionContext() cache.strains_by_pk = {strain.pk: strain} # define test input test_input = { "name_elements": {"elements": ["_custom_1", "replicate_num"]}, "custom_name_elts": {"_custom_1": "181-aceF"}, "replicate_count": 3, "combinatorial_line_metadata": {}, "common_line_metadata": { str(meta.pk): "LB", str(control.pk): False, str(cache.strains_mtype.pk): [str(strain.uuid)], }, } study = factory.StudyFactory() importer = CombinatorialCreationImporter(study, self.testuser, cache) parser = JsonInputParser(cache, importer) parsed = parser.parse(json.dumps(test_input)) self.assertEqual(len(parsed), 1, "Expected a single set of parsed input") # TODO: following two calls should go away self._map_input_strains(parsed, cache, {str(strain.uuid): strain}) importer._query_related_object_context(parsed) result = parsed[0].populate_study( study, importer.cache, ExperimentDescriptionOptions() ) self.assertFalse(importer.errors, "Import generated errors") self.assertFalse(importer.warnings, "Import generated warnings") expected_line_names = ["181-aceF-R1", "181-aceF-R2", "181-aceF-R3"] expected_meta = {meta.pk: "LB"} for line in result.lines_created: self.assertIn(line.name, expected_line_names) self.assertFalse(line.control) strains_list = list(line.strains.values_list("id", flat=True)) self.assertEqual(strains_list, [strain.pk]) # because of replicate, the expected metadata is a subset of actual assert {*expected_meta.items()}.issubset({*line.metadata.items()})
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 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 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 test_update_load_wrong_study(self): # updating loading data on the wrong study is not OK wrong = main_factory.StudyFactory() load = LoadRequest(study_uuid=wrong.uuid) load.store() url = rest_reverse("rest:study_load-detail", args=[self.study.pk, load.request]) payload = self._build_common_payload() self.client.force_login(self.user) response = self.client.patch(url, payload, format="multipart") assert response.status_code == status.HTTP_400_BAD_REQUEST
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 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 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_upload_links_admin(self): admin_study = factory.StudyFactory() admin_study.userpermission_set.update_or_create( permission_type=models.StudyPermission.WRITE, user=self.admin_ice_user ) response = self._run_upload(self.entry_ids, admin_study, self.admin_ice_user) # should return OK from upload self.assertEqual(response.status_code, codes.ok, response.content) # there should be 10 strains on the study self.assertEqual( models.Strain.objects.filter(line__study=admin_study).distinct().count(), 10 )
def test_add_remove_experiment_link(self): with self.registry.login(self.admin_ice_user): study = factory.StudyFactory() study_url = f"https://edd.example.org/s/{study.slug}/" entry = self.registry.get_entry(self.entry_ids[3]) entry.add_link(study.name, study_url) # verify link exists on a given entry found_links = list(entry.list_links()) assert len(found_links) == 1 # verify that removal works for link in found_links: entry.remove_link(link[0]) found_links = list(entry.list_links()) assert len(found_links) == 0
def test_upload_links_none(self): none_study = factory.StudyFactory() none_study.userpermission_set.update_or_create( permission_type=models.StudyPermission.WRITE, user=self.none_ice_user ) # should return 400 error on uploading admin-only strains response = self._run_upload(self.entry_ids, none_study, self.none_ice_user) self.assertEqual(response.status_code, codes.bad_request, response.content) # should return 400 error on uploading reader-only strains response = self._run_upload(self.entry_ids[:5], none_study, self.none_ice_user) self.assertEqual(response.status_code, codes.bad_request) # there should be 0 strains on the study self.assertEqual( models.Strain.objects.filter(line__study=none_study).distinct().count(), 0 )
def test_add_remove_experiment_link(self): admin_auth = HmacAuth("edd", self.admin_ice_user.email) ice = IceApi(admin_auth) ice.write_enabled = True study = factory.StudyFactory() study_url = f"https://edd.example.org/s/{study.slug}/" for entry_id in self.db_ids: ice.add_experiment_link(entry_id, study.name, study_url) # verify link exists on a given entry found_links = list(ice.fetch_experiment_links(self.db_ids[3])) self.assertEqual(len(found_links), 1) # verify that removal works ice.unlink_entry_from_study(self.db_ids[3], study_url) found_links = list(ice.fetch_experiment_links(self.db_ids[3])) self.assertEqual(len(found_links), 0)
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_upload_links_reader(self): reader_study = factory.StudyFactory() reader_study.userpermission_set.update_or_create( permission_type=models.StudyPermission.WRITE, user=self.read_ice_user) # should return 500 error on uploading admin-only strains # skip testing this until ICE-90 is resolved # response = self._run_upload(self.part_ids, reader_study, self.read_ice_user) # self.assertEqual(response.status_code, codes.server_error) # should return OK on uploading readable strains response = self._run_upload(self.part_ids[:5], reader_study, self.read_ice_user) self.assertEqual(response.status_code, codes.ok) # there should be 5 strains on the study self.assertEqual( models.Strain.objects.filter( line__study=reader_study).distinct().count(), 5)
def setUpTestData(cls): super().setUpTestData() # create a test user and give it permission to write to the study User = get_user_model() cls.write_user = User.objects.create(username='******') cls.unprivileged_user = User.objects.create( username='******') cls.user_write_study = main_factory.StudyFactory( name='User-writeable study') permissions = cls.user_write_study.userpermission_set permissions.update_or_create( permission_type=edd_models.UserPermission.WRITE, user=cls.write_user) cls.url = reverse('edd.rest:study-imports-detail', kwargs={ 'study_pk': cls.user_write_study.pk, 'pk': 15 })