def setUpTestData(cls):
super().setUpTestData()
cls.user = UserFactory(is_superuser=True, is_staff=True)
# admin user to see the admin site
cls.admin_user = UserFactory(email="*****@*****.**",
is_staff=True,
is_superuser=True)
def test_destroy_load_no_permission(self):
# users without permissions cannot delete in-process loading data
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, "abcdef"])
self.client.force_login(UserFactory())
response = self.client.delete(url)
assert response.status_code == status.HTTP_403_FORBIDDEN
def test_update_load_no_permission(self):
# users without permissions cannot update in-process loading data
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, "abcdef"])
self.client.force_login(UserFactory())
response = self.client.patch(url, format="multipart")
assert response.status_code == status.HTTP_403_FORBIDDEN
def test_solr_removed_user_forwards():
user = UserFactory.build()
with patch("main.signals.user_removed") as signal:
# forward happens when cache_deleting_key is called
signals.cache_deleting_key(type(user), user)
signals.removed_user(type(user), user, using="default")
signal.send.assert_called_once()
def setUpClass(cls):
# doing this as classmethod to avoid doing multiple collection creations
super().setUpClass()
cls.admin = UserFactory.build(is_superuser=True)
cls.collection = solr.StudySearch(ident=cls.admin)
# create a new collection, instead of sending to main collection
cls.collection.create_collection()
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.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 test_StudySearch_acl_admin():
# superusers should get no restrictions
admin = UserFactory.build(is_superuser=True)
search = solr.StudySearch(ident=admin)
read, write = search.build_acl_filter()
assert read == ""
assert write == "id:*"
def test_ice_admin_create_user(self):
user = UserFactory()
admin_ice = AdminRegistry()
with admin_ice.login():
created_id = admin_ice.create_user(user)
found_id = admin_ice.get_user_id(user)
assert created_id == found_id
def test_get_with_readonly(self):
user = UserFactory()
self.study.userpermission_set.update_or_create(
permission_type=models.StudyPermission.READ, user=user)
self.client.force_login(user)
response = self.client.get(self.url)
assert response.status_code == status.HTTP_403_FORBIDDEN
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()
# 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 setUpTestData(cls):
super().setUpTestData()
cls.user1 = UserFactory()
cls.campaign = factory.CampaignFactory()
cls.detail_url = reverse("campaign:detail", kwargs={"slug": cls.campaign.slug})
membership = factory.CampaignMembershipFactory(campaign=cls.campaign)
cls.study = membership.study
cls.study_url = reverse("main:detail", kwargs={"slug": cls.study.slug})
def test_study_contact_extra_with_user():
contact = UserFactory.build()
study = factory.StudyFactory.build(contact_extra=None, contact=contact)
assert study.contact_extra is None
core.study_contact_extra(models.Study, study, raw=False, using="default")
# check extra field set to non-empty string
assert isinstance(study.contact_extra, str)
assert len(study.contact_extra) > 0
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()
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()
# admin user to see the admin site
cls.admin_user = UserFactory(email="*****@*****.**",
is_staff=True,
is_superuser=True)
# create a Branding instance to test admin action
models.Branding.objects.create()
def test_get_with_write(self):
user = UserFactory()
self.study.userpermission_set.update_or_create(
permission_type=models.StudyPermission.WRITE, user=user)
self.client.force_login(user)
response = self.client.get(self.url)
assert response.status_code == status.HTTP_200_OK
self.assertTemplateUsed(response, "edd/load/wizard.html")
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_post_DescribeView_readonly(self):
other_user = UserFactory()
self.study.userpermission_set.update_or_create(
permission_type=models.StudyPermission.READ, user=other_user)
self.client.force_login(other_user)
url = reverse("main:describe:describe", kwargs=self.study_kwargs)
response = self.client.post(url)
self.assertEqual(response.status_code, codes.forbidden)
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 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 test_with_write_permission(self):
"""Ensure that a study can be written by a user with write permissions."""
study = factory.StudyFactory()
user = UserFactory()
models.UserPermission.objects.create(
study=study,
permission_type=models.StudyPermission.WRITE,
user=user)
assert study.user_can_read(user)
assert study.user_can_write(user)
def test_acl(self):
user = UserFactory()
# patch the normal user to the collection ident
self.collection.ident = user
# verify the ACLs
read, write = self.collection.build_acl_filter()
self.assertIn("OR", read)
self.assertIn("OR", write)
# restore the usual user
self.collection.ident = self.admin
def test_with_read_permission(self):
"""Ensure that a study can be read by a user with read permissions."""
study = factory.StudyFactory()
user = UserFactory()
models.UserPermission.objects.create(
study=study,
permission_type=models.StudyPermission.READ,
user=user)
assert study.user_can_read(user)
assert not study.user_can_write(user)
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 _add_groups_permission(self):
other_user = UserFactory()
group1 = GroupFactory()
group2 = GroupFactory()
other_user.groups.add(group1)
other_user.groups.add(group2)
self.study.grouppermission_set.create(
group=group1, permission_type=models.StudyPermission.WRITE)
self.study.grouppermission_set.create(
group=group2, permission_type=models.StudyPermission.WRITE)
return other_user
def test_with_group_write_permission(self):
study = factory.StudyFactory()
user = UserFactory()
group = GroupFactory()
user.groups.add(group)
models.GroupPermission.objects.create(
study=study,
permission_type=models.StudyPermission.WRITE,
group=group)
assert study.user_can_read(user)
assert study.user_can_write(user)
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()
