def test_post_default_form_use_view(self):
self._create_entity_data("entityuseview")
self.assertTrue(EntityData.exists(self.testdata, "entityuseview"))
f = default_view_form_data(
entity_id="entityuseview",
action="view",
use_view="_view/Type_view",
)
f.pop('entity_id', None)
u = entitydata_edit_url("view",
"testcoll",
"testtype",
"entityuseview",
view_id="Default_view")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
v = TestHostUri + entitydata_edit_url("view",
"testcoll",
"testtype",
entity_id="entityuseview",
view_id="Type_view")
c = continuation_url_param("/testsite/c/testcoll/d/testtype/")
self.assertIn(v, r['location'])
self.assertIn(c, r['location'])
self._check_entity_data_values("entityuseview")
return
def test_post_edit_entity_new_type(self):
self._create_entity_data("entityedittype")
e1 = self._check_entity_data_values("entityedittype")
self.assertFalse(RecordType.exists(self.testcoll, "newtype"))
newtype = RecordType.create(self.testcoll, "newtype",
recordtype_create_values("newtype"))
newtypedata = RecordTypeData(self.testcoll, "newtype")
self.assertTrue(RecordType.exists(self.testcoll, "newtype"))
self.assertFalse(RecordTypeData.exists(self.testcoll, "newtype"))
# Now post edit form submission with new type id
f = default_view_form_data(entity_id="entityedittype",
orig_id="entityedittype",
type_id="newtype",
orig_type="testtype",
action="edit")
u = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="entityedittype")
r = self.client.post(u, f)
# log.info("***********\n"+r.content)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
# Check that new record type data now exists, and that new record exists and old does not
self.assertTrue(RecordTypeData.exists(self.testcoll, "newtype"))
self.assertFalse(EntityData.exists(self.testdata, "entityedittype"))
self.assertTrue(EntityData.exists(newtypedata, "entityedittype"))
self._check_entity_data_values("entityedittype", type_id="newtype")
return
def test_post_edit_entity_enum_type_new(self):
self._create_entity_data("entitynewtype")
e1 = self._check_entity_data_values("entitynewtype")
f = default_view_form_data(entity_id="entitynewtype",
action="edit",
update="Updated entity",
new_enum="entity_type__new_edit")
u = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="entitynewtype",
view_id="Default_view")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
# v = entitydata_edit_url("new", "testcoll", "_type", view_id="Type_view")
v = entitydata_edit_url("edit",
"testcoll",
"_type",
"testtype",
view_id="Type_view")
w = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="entitynewtype",
view_id="Default_view")
c = continuation_url_param(w)
self.assertIn(TestHostUri + v, r['location'])
self.assertIn(c, r['location'])
self._check_entity_data_values("entitynewtype",
update="Updated entity")
return
def test_post_new_entity_new_type(self):
self.assertFalse(EntityData.exists(self.testdata, "entitynewtype"))
f = default_view_form_data(entity_id="entitynewtype",
action="new",
update="Updated entity",
new_type="New type")
u = entitydata_edit_url("new",
"testcoll",
"testtype",
view_id="Default_view")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
v = TestHostUri + entitydata_edit_url(
"new", "testcoll", "_type", view_id="Type_view")
w = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="entitynewtype",
view_id="Default_view")
c = continuation_url_param(w)
self.assertIn(v, r['location'])
self.assertIn(c, r['location'])
self._check_entity_data_values("entitynewtype",
update="Updated entity")
return
def test_image_rename(self):
# This test that entity renaming also copies over an attachment
# Upload image
self.test_image_edit_field()
# Rename entity
f = default_view_form_data(type_id="testimgtype",
orig_id="test1",
entity_id="test_new",
action="edit")
u = entitydata_edit_url("edit",
"testcoll",
"testimgtype",
entity_id="test1",
view_id="testimgview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Read back and compare renamed entity resource
siteobj = open(self.imagepath, "rb")
testobj = self.test_img_type_info.get_fileobj("test_new", "img_field",
"annal:Image",
"image/jpeg", "rb")
self.assertTrue(siteobj.read() == testobj.read(),
"Renamed entity image != original")
return
def test_post_edit_entity_invalid_id(self):
self._create_entity_data("edittype")
self._check_entity_data_values("edittype")
# Form post with ID malformed
f = default_view_form_data(entity_id="!badentity",
orig_id="edittype",
action="edit")
u = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="edittype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<h3>Problem with entity identifier</h3>")
# Test context for re-rendered form
expect_context = default_view_context_data(
entity_id="!badentity",
orig_id="edittype",
action="edit",
type_ref="_type/testtype",
type_choices=self.type_ids,
record_type="/testsite/c/testcoll/d/_type/testtype/")
self.assertDictionaryMatch(context_bind_fields(r.context),
expect_context)
# Check stored entity is unchanged
self._check_entity_data_values("edittype")
return
def test_dup_field_update(self):
# Create entity with duplicate fields
self._create_entity_data("entitydupfield")
self._check_entity_data_values(
"entitydupfield", type_id="testtype", update="Entity",
comment2="Comment field 2",
comment3="Comment field 3"
)
# Post form data to update entity
u = entitydata_edit_url(
"edit", "testcoll", "testtype",
entity_id="entitydupfield",
view_id="DupField_view"
)
f = default_view_form_data(
entity_id="entitydupfield",
type_id="testtype",
coll_id="testcoll",
action="edit", update="Updated Entity"
)
f = entitydata_form_add_field(f, "Entity_comment", 2, "Update comment 2")
f = entitydata_form_add_field(f, "Entity_comment", 3, "Update comment 3")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Test resulting entity value
self._check_entity_data_values(
"entitydupfield", type_id="testtype", update="Updated Entity",
comment2="Update comment 2",
comment3="Update comment 3"
)
return
def test_post_view_entity_copy(self):
self._create_entity_data("entityview")
f = default_view_form_data(entity_id="entityview",
action="view",
copy="Copy")
u = entitydata_edit_url("view",
"testcoll",
"testtype",
entity_id="entityview",
view_id="Default_view")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e = TestHostUri + entitydata_edit_url("copy",
"testcoll",
"testtype",
entity_id="entityview",
view_id="Default_view")
l = continuation_url_param(
entitydata_list_type_url("testcoll", "testtype"))
c = continuation_url_param(u, prev_cont=l)
self.assertIn(e, r['location'])
self.assertIn(c, r['location'])
return
def test_post_default_form_use_view_no_login(self):
self.client.logout()
f = default_view_form_data(
entity_id="entityuseview",
action="view",
use_view="_view/Type_view",
)
u = entity_url("testcoll", "testtype", "entity1")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
return
def test_post_new_entity(self):
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
f = default_view_form_data(entity_id="newentity", action="new")
u = entitydata_edit_url("new", "testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
# Check new entity data created
self._check_entity_data_values("newentity")
return
def test_post_new_entity_enum_type_new_no_login(self):
self.client.logout()
f = default_view_form_data(entity_id="entitynewtype",
action="new",
update="Updated entity",
new_enum="entity_type__new_edit")
u = entitydata_edit_url("new",
"testcoll",
"testtype",
view_id="Default_view")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 401)
self.assertEqual(r.reason_phrase, "Unauthorized")
return
def test_reference_uploaded_resource(self):
# Create uploaded resource (see previous test)
with open(self.filepath) as fp:
f = default_view_form_data(type_id="testupltype",
entity_id="test1",
action="edit")
f['upl_field'] = fp # Upload file with submission
u = entitydata_edit_url("view",
"testcoll",
"testupltype",
entity_id="test1",
view_id="testuplfileview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Display resource with reference
u = entitydata_edit_url("view",
"testcoll",
"testreftype",
entity_id="test1",
view_id="testrefview")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Check display context
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
self.assertEqual(f1.field_value, "test_ref_entity test1 label")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
self.assertEqual(f2.field_value, "test_ref_entity test1 comment")
f3 = context_view_field(r.context, 3, 0)
basepath = TestBasePath + "/c/testcoll/d/testupltype/"
# print "\n*****\n"+repr(context_view_field(r.context, i, 0).target_value)+"\n*****\n"
self.assertEqual(f3.field_id, "Test_reference")
self.assertEqual(f3.field_value, "testupltype/test1")
self.assertEqual(f3.field_value_link, basepath + "test1/")
self.assertEqual(f3.target_value['upload_name'], "upl_field")
self.assertEqual(f3.target_value['resource_name'], "upl_field.md")
self.assertEqual(f3.target_value['resource_type'], "text/markdown")
self.assertEqual(f3.target_value['uploaded_file'], "testdatafile.md")
self.assertEqual(f3.target_value['uploaded_size'], 137)
self.assertEqual(f3.target_value_link, basepath + "test1/upl_field.md")
return
def test_post_new_entity_cancel(self):
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
f = default_view_form_data(entity_id="newentity",
action="new",
cancel="Cancel")
u = entitydata_edit_url("new", "testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
# Check that new record type still does not exist
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
return
def test_post_copy_inherited_entity_no_access(self):
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
self.assertFalse(EntityData.exists(self.testsubdata, "entity2"))
f = default_view_form_data(action="copy",
entity_id="entity2", type_id="testtype", coll_id="testsubcoll",
orig_coll="testcoll"
)
u = entitydata_edit_url(action="copy",
coll_id="testsubcoll", type_id="testtype", entity_id="entity2",
view_id="Default_view"
)
r = self.client.post(u, f)
self.assertEqual(r.status_code, 403)
self.assertEqual(r.reason_phrase, "Forbidden")
# Check that no new data exists
self.assertFalse(EntityData.exists(self.testsubdata, "entity2"))
return
def test_image_edit(self):
# This test that entity editing leaves attachment intact
# Upload image
self.test_image_edit_field()
# Edit entity
f = default_view_form_data(type_id="testimgtype",
entity_id="test1",
action="edit",
update="Updated")
u = entitydata_edit_url("edit",
"testcoll",
"testimgtype",
entity_id="test1",
view_id="testimgview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Retrieve updated form
r = self.client.get(u)
# Test context
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
self.assertEqual(f1.field_value, "Updated testcoll/testimgtype/test1")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
f3 = context_view_field(r.context, 3, 0)
self.assertEqual(f3.field_id, "Test_image")
self.assertDictionaryMatch(f3.field_value, test_image_field_value())
# Read back and compare entity resource
siteobj = open(self.imagepath, "rb")
testobj = self.test_img_type_info.get_fileobj("test1", "img_field",
"annal:Image",
"image/jpeg", "rb")
self.assertTrue(siteobj.read() == testobj.read(),
"Edited entity image != original")
return
def test_post_copy_entity_missing_id(self):
f = default_view_form_data(action="copy",
entity_id="",
orig_id="entity1")
u = entitydata_edit_url("copy",
"testcoll",
"testtype",
entity_id="entity1")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<h3>Problem with entity identifier</h3>")
expect_context = default_view_context_data(action="copy",
orig_id="entity1",
type_ref="",
type_choices=self.type_ids)
self.assertDictionaryMatch(context_bind_fields(r.context),
expect_context)
return
def test_post_edit_entity(self):
self._create_entity_data("entityedit")
self._check_entity_data_values("entityedit")
f = default_view_form_data(entity_id="entityedit",
action="edit",
update="Updated entity")
u = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="entityedit")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
self._check_entity_data_values("entityedit", update="Updated entity")
return
def test_post_new_entity_missing_id(self):
f = default_view_form_data(action="new", entity_id="")
u = entitydata_edit_url("new", "testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<h3>Problem with entity identifier</h3>")
# Test context
expect_context = default_view_context_data(coll_id="testcoll",
type_id="testtype",
entity_id="",
orig_id="orig_entity_id",
type_ref="",
type_choices=self.type_ids,
action="new")
self.assertEqual(len(r.context['fields']), 3) # 4 fields over 3 rows
self.assertDictionaryMatch(context_bind_fields(r.context),
expect_context)
return
def test_post_copy_inherited_entity(self):
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
self.assertFalse(EntityData.exists(self.testsubdata, "entity2"))
f = default_view_form_data(action="copy",
entity_id="entity2", type_id="testtype", coll_id="testsubcoll",
orig_coll="testcoll"
)
u = entitydata_edit_url(action="copy",
coll_id="testsubcoll", type_id="testtype", entity_id="entity2",
view_id="Default_view"
)
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertIn(self.continuation_url, r['location'])
# Check that new data exists
self.assertTrue(EntityData.exists(self.testsubdata, "entity2"))
return
def test_reference_imported_resource(self):
# Create imported resource (see previous test)
f = default_view_form_data(
entity_id="test1", type_id="testimptype", action="edit",
do_import="imp_field__import"
)
f['imp_field'] = self.fileuri
u = entitydata_edit_url(
"edit", "testcoll", "testimptype", entity_id="test1", view_id="testimpview"
)
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Display resource with reference
u = entitydata_edit_url(
"view", "testcoll", "testreftype", entity_id="test1", view_id="testrefview"
)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Check display context
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
self.assertEqual(f1.field_value, "test_ref_entity test1 label")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
self.assertEqual(f2.field_value, "test_ref_entity test1 comment")
f3 = context_view_field(r.context, 3, 0)
basepath = TestBasePath + "/c/testcoll/d/testimptype/"
self.assertEqual(f3.field_id, "Test_reference")
self.assertEqual(f3.field_value, "testimptype/test1")
self.assertEqual(f3.field_value_link, basepath+"test1/")
self.assertEqual(f3.target_value['import_name'], "imp_field")
self.assertEqual(f3.target_value['resource_name'], "imp_field.md")
self.assertEqual(f3.target_value['resource_type'], "text/markdown")
self.assertEqual(f3.target_value_link, basepath+"test1/imp_field.md")
return
def test_image_edit_field(self):
# Upload to an image view field
with open(self.imagepath) as fp:
f = default_view_form_data(type_id="testimgtype",
entity_id="test1",
action="edit")
f['img_field'] = fp # Upload file with submission
u = entitydata_edit_url("edit",
"testcoll",
"testimgtype",
entity_id="test1",
view_id="testimgview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Read back and compare entity resource just created
siteobj = open(self.imagepath, "rb")
testobj = self.test_img_type_info.get_fileobj("test1", "img_field",
"annal:Image",
"image/jpeg", "rb")
self.assertTrue(siteobj.read() == testobj.read(),
"Referenced image != original")
# Retrieve updated form
r = self.client.get(u)
# Test context
# print "@@ "+context_field_map(r.context)
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
f3 = context_view_field(r.context, 3, 0)
self.assertEqual(f3.field_id, "Test_image")
self.assertDictionaryMatch(f3.field_value, test_image_field_value())
return
def test_post_edit_entity_cancel(self):
self._create_entity_data("edittype")
self._check_entity_data_values("edittype")
# Post from cancelled edit form
f = default_view_form_data(entity_id="edittype",
action="edit",
cancel="Cancel",
update="Updated entity")
u = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="edittype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
# Check that target record type still does not exist and unchanged
self._check_entity_data_values("edittype")
return
def test_post_edit_entity_new_id(self):
self._create_entity_data("entityeditid1")
e1 = self._check_entity_data_values("entityeditid1")
# Now post edit form submission with different values and new id
f = default_view_form_data(entity_id="entityeditid2",
orig_id="entityeditid1",
action="edit")
u = entitydata_edit_url("edit",
"testcoll",
"testtype",
entity_id="entityeditid1")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
# Check that new record type exists and old does not
self.assertFalse(EntityData.exists(self.testdata, "entityeditid1"))
self._check_entity_data_values("entityeditid2")
return
def test_new_entity_default_type(self):
# Checks logic related to creating a new recorddata entity in collection
# for type defined in site data
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
f = default_view_form_data(entity_id="newentity",
type_id="Default_type",
action="new")
u = entitydata_edit_url("new", "testcoll", "Default_type")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "Default_type"))
# Check new entity data created
self._check_entity_data_values(
"newentity",
type_id="Default_type",
type_uri="annal:Default_type",
update_dict={'@type': ['annal:Default_type', 'annal:EntityData']})
return
def test_upload_image_resource(self):
# See https://docs.djangoproject.com/en/1.7/topics/testing/tools/#django.test.Client.post
with open(self.imagepath) as fp:
f = default_view_form_data(type_id="testupltype",
entity_id="test1",
action="edit")
f['upl_field'] = fp # Upload file with submission
u = entitydata_edit_url("edit",
"testcoll",
"testupltype",
entity_id="test1",
view_id="testuplimageview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Retrieve updated form
r = self.client.get(u)
# Test context
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
f3 = context_view_field(r.context, 3, 0)
self.assertEqual(f3.field_id, "Test_upload_image")
self.assertDictionaryMatch(f3.field_value,
test_upload_image_field_value())
# Read back and compare entity resource just created
siteobj = open(self.imagepath, "rb")
testobj = self.test_upl_type_info.get_fileobj("test1", "upl_field",
"annal:Image",
"image/jpeg", "rb")
self.assertTrue(siteobj.read() == testobj.read(),
"Uploaded image != original")
# self.assertEqual(siteobj.read(), testobj.read())
return
def test_post_default_form_default_view(self):
# Set default entity view, then ensure collection view redirects to it
self._create_entity_data("entitydefaultview")
f = default_view_form_data(
entity_id="entitydefaultview",
action="view",
default_view="default_view",
)
f.pop('entity_id', None)
u = entitydata_edit_url(action="view",
view_id="Default_view",
coll_id="testcoll",
type_id="testtype",
entity_id="entitydefaultview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
v = TestHostUri + u
self.assertIn(v, r['location'])
ih = "info_head=" + make_quoted_message(message.ACTION_COMPLETED)
im = "info_message=" + make_quoted_message(
message.DEFAULT_VIEW_UPDATED,
view_id="Default_view",
entity_id="entitydefaultview")
self.assertIn(ih, r['location'])
self.assertIn(im, r['location'])
# Get collection root and check redirect to entity view
u2 = collection_view_url(coll_id="testcoll")
r2 = self.client.get(u2)
self.assertEqual(r2.status_code, 302)
self.assertEqual(r2.reason_phrase, "FOUND")
self.assertEqual(r2.content, "")
v2 = TestHostUri + entitydata_edit_url(coll_id="testcoll",
view_id="Default_view",
type_id="testtype",
entity_id="entitydefaultview")
self.assertEqual(v2, r2['location'])
return
def test_new_entity_new_type(self):
# Checks logic for creating an entity which may require creation of new recorddata
# Create new type
self.assertFalse(RecordType.exists(self.testcoll, "newtype"))
f = type_view_form_data(
action="new",
coll_id="testcoll",
type_entity_id="newtype",
)
u = entitydata_edit_url("new",
"testcoll",
type_id="_type",
view_id="Type_view")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "_type"))
self.assertTrue(RecordType.exists(self.testcoll, "newtype"))
# Create new entity
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
f = default_view_form_data(entity_id="newentity",
type_id="newtype",
action="new")
u = entitydata_edit_url("new", "testcoll", "newtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(
r['location'],
TestHostUri + entitydata_list_type_url("testcoll", "newtype"))
# Check new entity data created
self._check_entity_data_values("newentity", type_id="newtype")
return
def test_import_resource(self):
f = default_view_form_data(
entity_id="test1", type_id="testimptype", action="edit",
do_import="imp_field__import"
)
f['imp_field'] = self.fileuri
u = entitydata_edit_url(
"edit", "testcoll", "testimptype", entity_id="test1", view_id="testimpview"
)
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertMatch(r['location'], TestHostUri+u)
# Read back form following redirect
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
f3 = context_view_field(r.context, 3, 0)
self.assertEqual(f3.field_id, "Test_import")
self.assertDictionaryMatch(f3.field_value, test_import_field_value())
# Read back and compare entity resource just created
siteobj = open(TestBaseDir+"/README.md", "rb")
testobj = self.test_imp_type_info.get_fileobj(
"test1", "imp_field", "annal:Richtext", "text/markdown", "rb"
)
self.assertEqual(siteobj.read(), testobj.read())
return
def test_inherited_image_edit(self):
# This tests that editing an inherited image creartes a new copy in the
# inheriting collection.
# Upload image
self.test_image_edit_field()
# Create collection inheriting uploaded image
testsubcoll = create_test_coll_inheriting(base_coll_id="testcoll",
coll_id="testsubcoll",
type_id="testtype")
# create_test_user(testsubcoll, "testuser", "testpassword")
user_permissions = ["VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"]
user_id = "testuser"
user_perms = testsubcoll.create_user_permissions(
user_id, "mailto:%s@%s" % (user_id, TestHost), "Test User",
"User %s: permissions for %s in collection %s" %
(user_id, "Test User", testsubcoll.get_id()), user_permissions)
# Get editing form
u = entitydata_edit_url("edit",
"testsubcoll",
"testimgtype",
entity_id="test1",
view_id="testimgview")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# log.info(r.content) #@@
hi1 = """<input type="hidden" name="orig_id" value="test1" />"""
hi2 = """<input type="hidden" name="orig_type" value="testimgtype" />"""
hi3 = """<input type="hidden" name="orig_coll" value="testcoll" />"""
hi4 = """<input type="hidden" name="action" value="edit" />"""
hi5 = """<input type="hidden" name="view_id" value="testimgview" />"""
self.assertContains(r, hi1, html=True)
self.assertContains(r, hi2, html=True)
self.assertContains(r, hi3, html=True)
self.assertContains(r, hi4, html=True)
self.assertContains(r, hi5, html=True)
# Edit entity
f = default_view_form_data(coll_id="testsubcoll",
type_id="testimgtype",
entity_id="test1",
orig_coll="testcoll",
action="edit",
update="Updated")
u = entitydata_edit_url("edit",
"testsubcoll",
"testimgtype",
entity_id="test1",
view_id="testimgview")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
# Retrieve updated form
r = self.client.get(u)
# Test context
self.assertEqual(len(r.context['fields']), 4)
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0.field_id, "Entity_id")
self.assertEqual(f0.field_value, "test1")
f1 = context_view_field(r.context, 1, 0)
self.assertEqual(f1.field_id, "Entity_label")
self.assertEqual(f1.field_value,
"Updated testsubcoll/testimgtype/test1")
f2 = context_view_field(r.context, 2, 0)
self.assertEqual(f2.field_id, "Entity_comment")
f3 = context_view_field(r.context, 3, 0)
self.assertEqual(f3.field_id, "Test_image")
self.assertDictionaryMatch(f3.field_value, test_image_field_value())
# Read back and compare entity resource
inherited_test_img_type_info = EntityTypeInfo(testsubcoll,
"testimgtype",
create_typedata=True)
siteobj = open(self.imagepath, "rb")
testobj = inherited_test_img_type_info.get_fileobj(
"test1", "img_field", "annal:Image", "image/jpeg", "rb")
self.assertTrue(siteobj.read() == testobj.read(),
"Edited entity image != original")
