def test_readonly_searchable(self, test_value, expected_title):
"""Test filtration by readonly attribute"""
with factories.single_commit():
factories.SystemFactory(title="readonly system", readonly=True)
factories.SystemFactory(title="non readonly system")
self.client.get("/login")
actual_systems = self.simple_query(
"System", expression=["readonly", "=", test_value])
self.assertEqual([s.get("title") for s in actual_systems],
[expected_title])
def test_readonly_unset_by_role(self, role_name, expected_readonly):
"""Test setting Read-only to false under {}."""
role_obj = all_models.Role.query.filter(
all_models.Role.name == role_name).one()
with factories.single_commit():
user = factories.PersonFactory()
system = factories.SystemFactory(readonly=True)
rbac_factories.UserRoleFactory(role=role_obj, person=user)
system.add_person_with_role_name(user, "Admin")
system_slug = system.slug
user_id = user.id
response = self.import_data(
OrderedDict([
("object_type", "System"),
("Code*", system_slug),
("Read-only", "no"),
]),
person=all_models.Person.query.get(user_id))
expected_warning = {
"System": {
"row_warnings": {
errors.NON_ADMIN_ACCESS_ERROR.format(
line=3, object_type="System", column_name="Read-only")
}
}
} if expected_readonly else {}
self._check_csv_response(response, expected_warning)
obj = all_models.System.query.filter_by(slug=system_slug).first()
self.assertEqual(obj.readonly, expected_readonly)
def test_system_unmap_on_update(self, readonly, rel_obj_type):
"""Test unmapping on update System with readonly={0}"""
rel_factory = factories.get_model_factory(rel_obj_type)
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=readonly)
obj_id = obj.id
rel_obj = rel_factory()
rel_obj_id = rel_obj.id
factories.RelationshipFactory(source=obj, destination=rel_obj)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("unmap:{}".format(rel_obj_type), rel_obj.slug),
])
response = self.import_data(data)
self._check_csv_response(response, {})
obj = get_model("System").query.get(obj_id)
rel_obj = get_model(rel_obj_type).query.get(rel_obj_id)
rel = all_models.Relationship.find_related(obj, rel_obj)
self.assertIsNone(rel)
def test_readonly_system_not_deleted(self):
"""Test System with readonly=True can be deleted"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=True)
obj_id = obj.id
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Delete", "yes"),
])
response = self.import_data(data)
self._check_csv_response(
response, {
"System": {
"row_warnings": {
errors.READONLY_ACCESS_WARNING.format(
line=3, columns="'Delete'"),
},
}
})
obj = get_model("System").query.get(obj_id)
self.assertIsNotNone(obj)
def test_system_not_updated_as_admin(self):
"""Test readonly System not updated by admin"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=True)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Title", "b"),
])
response = self.import_data(data)
self._check_csv_response(
response, {
"System": {
"row_warnings": {
errors.READONLY_ACCESS_WARNING.format(
line=3, columns="'Title'"),
},
}
})
obj = get_model("System").query.one()
self.assertEqual(obj.readonly, True)
self.assertEqual(obj.title, 'a')
def test_system_not_updated(self, new, exp_ignored_columns):
"""Test readonly System not updated if new={0}"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=True)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Title", "b"),
])
if new is not None:
data["Read-only"] = new
response = self.import_data(data)
self._check_csv_response(response, {
"System": {
"row_warnings": {
errors.READONLY_ACCESS_WARNING.format(
line=3, columns=exp_ignored_columns),
},
}
})
obj = get_model("System").query.one()
self.assertEqual(obj.readonly, True)
self.assertEqual(obj.title, 'a')
def test_user_cannot_get_readonly_value_without_perms(self, new):
"""Test readonly System not updated if new={0!r} and user has no perms
This test ensures that user without permission for the object
cannot obtain value for flag readonly
"""
role_obj = all_models.Role.query.filter(
all_models.Role.name == "Creator").one()
with factories.single_commit():
person = factories.PersonFactory()
person_id = person.id
rbac_factories.UserRoleFactory(role=role_obj, person=person)
obj = factories.SystemFactory(title='a', readonly=True)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Title", "b"),
])
if new is not _NOT_SPECIFIED:
data["Read-only"] = new
response = self.import_data(
data, person=all_models.Person.query.get(person_id))
exp_csv_responsse = {
"System": {
"row_errors": {
errors.PERMISSION_ERROR.format(line=3),
},
}
}
if new is not _NOT_SPECIFIED:
exp_csv_responsse['System']['row_warnings'] = {
errors.NON_ADMIN_ACCESS_ERROR.format(
line=3,
object_type="System",
column_name="Read-only",
),
}
self._check_csv_response(response, exp_csv_responsse)
obj = get_model("System").query.one()
self.assertEqual(obj.readonly, True)
self.assertEqual(obj.title, 'a')
def test_export_system(self):
"""Test exporting of System objects."""
factories.SystemFactory()
search_request = [{
"object_name": "System",
"fields": "all",
"filters": {
"expression": {}
}
}]
response = self.export_parsed_csv(search_request)
self.assertEqual(len(response["System"]), 1)
self.assertNotIn("Read-only", response["System"][0])
self.assertNotIn("readonly", response["System"][0])
def test_system_update_and_unset_readonly_as_admin(self):
"""Test System readonly unset and title updated by admin in same import"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=True)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Title", "b"),
("Read-Only", "no"),
])
response = self.import_data(data)
self._check_csv_response(response, {})
obj = get_model("System").query.one()
self.assertEqual(obj.readonly, False)
self.assertEqual(obj.title, 'b')
def test_system_update_to_readonly_as_admin(self, new, expected):
"""Test System readonly={1} if new={0}"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=False)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Title", "b"),
])
if new is not None:
data["Read-only"] = new
response = self.import_data(data)
self._check_csv_response(response, {})
obj = get_model("System").query.one()
self.assertEqual(obj.readonly, expected)
def test_system_add_comments_on_update(self, readonly, comments,
exp_comments):
"""Test Comment creation {1} on update System with readonly={0}"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=readonly)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Comments", ';;'.join(comments)),
])
response = self.import_data(data)
self._check_csv_response(response, {})
obj = get_model("System").query.one()
created_comments = set(comment.description
for comment in obj.related_objects(['Comment']))
self.assertEqual(created_comments, set(exp_comments))
def test_system_readonly_invalid_on_update(self):
"""Test System readonly=False on update with invalid data"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=False)
data = OrderedDict([("object_type", "System"), ("Code*", obj.slug),
("Title", "b"), ("Read-only", "qwerty")])
response = self.import_data(data)
self._check_csv_response(
response, {
"System": {
"row_warnings": {
errors.WRONG_VALUE.format(line=3,
column_name="Read-only")
},
}
})
obj = get_model("System").query.one()
self.assertFalse(obj.readonly)
def test_readonly_system_not_deleted_without_user_perms(self):
"""Test System with readonly=True can be deleted
This test ensures that user without permission for the object
cannot obtain value for flag readonly
"""
role_obj = all_models.Role.query.filter(
all_models.Role.name == "Creator").one()
with factories.single_commit():
person = factories.PersonFactory()
person_id = person.id
rbac_factories.UserRoleFactory(role=role_obj, person=person)
obj = factories.SystemFactory(title='a', readonly=True)
obj_id = obj.id
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Delete", "yes"),
])
response = self.import_data(
data,
person=all_models.Person.query.get(person_id)
)
self._check_csv_response(response, {
"System": {
"row_errors": {
"Line 3: Delete column is temporary disabled, please "
"use web interface to delete current object.",
errors.PERMISSION_ERROR.format(line=3),
},
}
})
obj = get_model("System").query.get(obj_id)
self.assertIsNotNone(obj)
def test_readonly_update_by_role(self, role, old_readonly, new_readonly):
"""Test updating readonly attribute from {1} to {2}."""
role_obj = all_models.Role.query.filter(
all_models.Role.name == role
).one()
with factories.single_commit():
user = factories.PersonFactory()
system = factories.SystemFactory(readonly=old_readonly)
rbac_factories.UserRoleFactory(role=role_obj, person=user)
system.add_person_with_role_name(user, "Admin")
response = self.import_data(OrderedDict([
("object_type", "System"),
("Code*", system.slug),
("Admin", user.email),
("Read-only", new_readonly),
]), person=user)
expected_message = {
"System": {
"row_warnings": {
errors.NON_ADMIN_ACCESS_ERROR.format(
line=3,
column_name="Read-only",
object_type="System",
)
}
}
} if role != "Administrator" else {}
self._check_csv_response(response, expected_message)
obj = all_models.System.query.get(system.id)
self.assertEqual(
obj.readonly,
new_readonly if role == "Administrator" else old_readonly
)
def test_system_add_document_on_update(self, readonly, exp_set):
"""Test Reference URL set on update System with readonly={0}"""
with factories.single_commit():
obj = factories.SystemFactory(title='a', readonly=readonly)
data = OrderedDict([
("object_type", "System"),
("Code*", obj.slug),
("Reference URL", "aa"),
])
if exp_set:
dct = {}
else:
dct = {
"System": {
"row_warnings": {
errors.READONLY_ACCESS_WARNING.format(
line=3, columns="'Reference URL'"),
},
}
}
response = self.import_data(data)
self._check_csv_response(response, dct)
obj = get_model("System").query.one()
docs = obj.documents_reference_url
if exp_set:
self.assertEqual(len(docs), 1)
doc = docs[0]
self.assertEqual(doc.link, "aa")
else:
self.assertEqual(len(docs), 0)
