def test_post_view_all_list(self):
# 'View' button on list view: change displayed list
f = entitylist_form_data("list_type", list_scope_all="all", list_id="View_list")
u = entitydata_list_type_url("testcoll", "_type", list_id="Type_list")
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_list_type_url("testcoll", "_type", list_id="View_list")
self.assertIn(v, r['location'])
self.assertNotIn("continuation_url", r['location'])
return
def list_data(self):
# requires VIEW
u = entitydata_list_type_url(coll_id="testcoll",
type_id="Default_type",
list_id="Default_list")
r = self.client.get(u)
return r
def test_get_list_no_collection(self):
u = entitydata_list_type_url("no_collection", layout.FIELD_TYPEID, list_id="Field_list")
r = self.client.get(u)
self.assertEqual(r.status_code, 404)
self.assertEqual(r.reason_phrase, "Not found")
self.assertContains(r, "Collection no_collection does not exist", status_code=404)
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 = entitydata_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_list_entity_references(self):
# List linked records - check values in listing
u = entitydata_list_type_url("testcoll",
"testsrc_type",
list_id="testsrc_list")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
entities = context_list_entities(r.context)
head_fields = context_list_head_fields(r.context)
self.assertEqual(len(entities), 2)
self.assertEqual(len(head_fields), 3)
for entc, esrc, etgt in ((entities[0], "testsrc1", "testtgt1"),
(entities[1], "testsrc2", "testtgt2")):
item_fields = context_list_item_fields(r.context, entc)
self.assertEqual(len(item_fields), 3)
self.assertEqual(entc['entity_id'], esrc)
self.assertEqual(entc['entity_type_id'], "testsrc_type")
self.assertEqual(item_fields[0].field_id, "Entity_id")
self.assertEqual(item_fields[0].field_value, esrc)
self.assertEqual(item_fields[0].field_value_link, None)
self.assertEqual(item_fields[1].field_id, "testtgtref_field")
self.assertEqual(item_fields[1].field_value, etgt)
self.assertEqual(item_fields[1].field_value_link,
"/testsite/c/testcoll/d/testtgt_type/%s/" % etgt)
self.assertEqual(item_fields[2].field_id, "Entity_label")
self.assertEqual(item_fields[2].field_value,
"testsrc_entity %s label" % esrc)
self.assertEqual(item_fields[2].field_value_link, None)
return
def list_users(self):
# requires ADMIN
u = entitydata_list_type_url(coll_id="testcoll",
type_id="_user",
list_id="Default_list")
r = self.client.get(u)
return r
def test_post_delete_type_entity(self):
testtypedelete = RecordType.create(self.testcoll, "testtypedelete", recordtype_create_values("testcoll", "testtypedelete"))
testdatadelete = RecordTypeData.create(self.testcoll, "testtypedelete", {})
f = entitylist_form_data("delete", entities=["_type/testtypedelete"])
u = entitydata_list_type_url("testcoll", "_type", list_id="Type_list")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<h3>Confirm requested action</h3>")
self.assertContains(r, "Remove record testtypedelete of type _type in collection testcoll: Are you sure?")
self.assertContains(r, 'Click "Confirm" to continue, or "Cancel" to abort operation')
self.assertContains(r,
'<input type="hidden" name="confirmed_action" value="/testsite/c/testcoll/d/_type/!delete_confirmed"/>',
html=True
)
self.assertEqual(r.context['action_description'],
'Remove record testtypedelete of type _type in collection testcoll')
self.assertEqual(r.context['confirmed_action'],
'/testsite/c/testcoll/d/_type/!delete_confirmed')
self.assertEqual(r.context['action_params'],
confirm_delete_params(button_id="entity_delete", entity_id="testtypedelete", type_id="_type", list_id="Type_list")
)
self.assertEqual(r.context['cancel_action'],
'/testsite/c/testcoll/l/Type_list/_type/')
return
def test_post_delete_type_entity(self):
f = entitylist_form_data("delete", entities=["testtype/entity1"])
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<h3>Confirm requested action</h3>")
self.assertContains(
r,
"Remove record entity1 of type testtype in collection testcoll: Are you sure?"
)
self.assertContains(
r, 'Click "Confirm" to continue, or "Cancel" to abort operation')
self.assertContains(
r,
'<input type="hidden" name="confirmed_action" value="/testsite/c/testcoll/d/testtype/!delete_confirmed"/>',
html=True)
self.assertEqual(
r.context['action_description'],
'Remove record entity1 of type testtype in collection testcoll')
self.assertEqual(r.context['confirmed_action'],
'/testsite/c/testcoll/d/testtype/!delete_confirmed')
self.assertEqual(
r.context['action_params'],
confirm_delete_params(button_id="entity_delete",
entity_id="entity1",
type_id="testtype"))
self.assertEqual(r.context['cancel_action'],
'/testsite/c/testcoll/d/testtype/')
return
def test_list_entity_references(self):
# List linked records - check values in listing
u = entitydata_list_type_url("testcoll", "testsrc_type", list_id="testsrc_list")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
entities = context_list_entities(r.context)
head_fields = context_list_head_fields(r.context)
# print "@@ context: "+repr(r.context['List_rows'])
# print "@@ head_fields: "+repr(head_fields)
self.assertEqual(len(entities), 2)
self.assertEqual(len(head_fields), 1) # One row of 3 cols..
self.assertEqual(len(head_fields[0]['row_field_descs']), 3)
entity_values = (
(entities[0], "testsrc1", "testtgt1"),
(entities[1], "testsrc2", "testtgt2")
)
for entc, esrc, etgt in entity_values:
item_fields = context_list_item_fields(r.context, entc)
self.assertEqual(len(item_fields), 3)
self.assertEqual(entc['entity_id'], esrc)
self.assertEqual(entc['entity_type_id'], "testsrc_type")
self.assertEqual(item_fields[0].field_id, "Entity_id")
self.assertEqual(item_fields[0].field_value, esrc)
self.assertEqual(item_fields[0].field_value_link, None)
self.assertEqual(item_fields[1].field_id, "testtgtref_field")
self.assertEqual(item_fields[1].field_value, "testtgt_type/"+etgt)
self.assertEqual(item_fields[1].field_value_link, "/testsite/c/testcoll/d/testtgt_type/%s/"%etgt)
self.assertEqual(item_fields[2].field_id, "Entity_label")
self.assertEqual(item_fields[2].field_value, "testsrc_entity %s label"%esrc)
self.assertEqual(item_fields[2].field_value_link, None)
return
def test_post_view_entity_edit(self):
self._create_entity_data("entityview")
f = entitydata_default_view_form_data(entity_id="entityview",
action="view",
edit="Edit")
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("edit",
"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'])
# 'http://test.example.com/testsite/c/testcoll/v/Default_view/testtype/entityview/!edit
# ?continuation_url=/testsite/c/testcoll/v/Default_view/testtype/entityview/!view
# %3Fcontinuation_url=/testsite/c/testcoll/d/testtype/'
return
def test_list_field_alias(self):
# List BibEntry fields in Default_list
u = entitydata_list_type_url("testcoll", "BibEntry_type", list_id="Default_list")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# log.info(r.content) #@@
# Test context
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], "BibEntry_type")
self.assertEqual(r.context['list_choices']['field_value'], "Default_list")
# Fields
head_fields = context_list_head_fields(r.context)
self.assertEqual(len(head_fields), 2)
# 1st field
self.assertEqual(head_fields[0]['field_id'], 'Entity_id')
self.assertEqual(head_fields[0]['field_property_uri'], "annal:id")
self.assertEqual(head_fields[0]['field_value'], "")
# 2nd field
self.assertEqual(head_fields[1]['field_id'], 'Entity_label')
self.assertEqual(head_fields[1]['field_property_uri'], "rdfs:label")
self.assertEqual(head_fields[1]['field_value'], "")
# List entities (actually, just the one)
entities = context_list_entities(r.context)
self.assertEqual(len(entities), 1)
self.assertEqual(
context_list_item_field_value(r.context, entities[0], 0),
"bibentity1"
)
self.assertEqual(
context_list_item_field_value(r.context, entities[0], 1),
self.bibentity1_data['bib:title']
)
return
def test_get_types_scope_all_list(self):
# List types in current collection and site-wide
u = entitydata_list_type_url(
"testcoll", "_type", list_id="Type_list", scope="all"
)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(r.context['title'], "Entity types - Collection testcoll")
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], "_type")
# Fields
head_fields = context_list_head_fields(r.context)
self.assertEqual(len(head_fields), 1) # One row of 2 cols..
self.assertEqual(len(head_fields[0]['row_field_descs']), 2)
# 1st field
f0 = context_view_field(r.context, 0, 0)
self.assertEqual(f0['field_id'], 'Entity_id')
self.assertEqual(f0['field_name'], 'entity_id')
# 2nd field
f1 = context_view_field(r.context, 0, 1)
self.assertEqual(f1['field_id'], 'Entity_label')
self.assertEqual(f1['field_name'], 'Entity_label')
# Entities
entities = context_list_entities(r.context)
listed_entities = { e['entity_id']: e for e in entities }
type_entities = get_site_bib_types() | {"testtype", "testtype2"}
self.assertEqual(set(listed_entities.keys()), type_entities)
return
def test_post_view_entity_copy(self):
self._create_entity_data("entityview")
f = entitydata_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 annalistuser_view_form_data(
coll_id="testcoll", user_id="testuser",
user_name="Test User",
user_uri="mailto:[email protected]",
user_permissions="VIEW CREATE UPDATE DELETE CONFIG ADMIN",
action=None, cancel=None, close=None, edit=None, copy=None,
orig_id=None
):
form_data_dict = (
{ 'entity_id': user_id
, 'orig_id': user_id
, 'User_name': user_name
, 'User_description': 'User %s: permissions for %s in collection %s'%(user_id, user_name, coll_id)
, 'User_uri': user_uri
, 'User_permissions': user_permissions
, 'orig_type': "_user"
, 'continuation_url': entitydata_list_type_url(coll_id, "_user")
})
if orig_id:
form_data_dict['orig_id'] = orig_id
if action:
form_data_dict['action'] = action
if cancel:
form_data_dict['cancel'] = "Cancel"
elif close:
form_data_dict['close'] = "Close"
elif edit:
form_data_dict['edit'] = "Edit"
elif copy:
form_data_dict['copy'] = "Copy"
else:
form_data_dict['save'] = 'Save'
return form_data_dict
def test_post_delete_type_entity(self):
f = entitylist_form_data("delete", entities=["testtype/entity1"])
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<h3>%s</h3>"%message.CONFIRM_REQUESTED_ACTION)
msg_text = make_message(message.REMOVE_ENTITY_DATA,
type_id="testtype",
id="entity1"
)
self.assertContains(r, msg_text + ": " + message.ARE_YOU_SURE)
self.assertContains(r, message.CONFIRM_OR_CANCEL)
self.assertContains(r,
'<input type="hidden" name="confirmed_action" value="/testsite/c/testcoll/d/testtype/!delete_confirmed"/>',
html=True
)
self.assertEqual(r.context['action_description'], msg_text)
self.assertEqual(r.context['confirmed_action'],
'/testsite/c/testcoll/d/testtype/!delete_confirmed')
self.assertEqual(r.context['action_params'],
confirm_delete_params(button_id="entity_delete", entity_id="entity1", type_id="testtype")
)
self.assertEqual(r.context['cancel_action'],
'/testsite/c/testcoll/d/testtype/')
return
def test_get_fields_list(self):
# List fields in current collection
u = entitydata_list_type_url("testcoll",
layout.FIELD_TYPEID,
list_id="Field_list",
scope="all",
continuation_url="/xyzzy/")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(r.context['title'],
"Field definitions - Collection testcoll")
self.assertEqual(r.context['heading'], "Field definitions")
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], layout.FIELD_TYPEID)
self.assertEqual(r.context['continuation_url'], "/xyzzy/")
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(self.list_ids))
self.assertEqual(list_choices['field_value'], "Field_list")
# Fields
field_entities = ({
('Entity_id', "EntityId", "annal:EntityRef", "Id"),
('Bib_address', "Text", "annal:Text", "Address"),
('Bib_authors', "Group_Seq", "bib:Authors", "Author(s)"),
('Bib_booktitle', "Text", "annal:Text", "Book title"),
('Entity_type', "EntityTypeId", "annal:EntityRef", "Type"),
('Entity_label', "Text", "annal:Text", "Label"),
('Field_help', "Markdown", "annal:Richtext", "Help"),
('Field_placement', "Placement", "annal:Placement",
"Position/size"),
('Field_render_type', "Enum_choice", "annal:EntityRef",
"Render type"),
('Field_value_mode', "Enum_choice", "annal:EntityRef",
"Value mode"),
('Field_value_type', "Identifier", "annal:Identifier",
"Value type"),
('Field_entity_type', "Identifier", "annal:Identifier",
"Entity type"),
('Field_default', "Text", "annal:Text", "Default value"),
('Field_typeref', "Enum_optional", "annal:EntityRef",
"Refer to type"),
('Field_restrict', "Text", "annal:Text", "Value restriction"),
('List_comment', "Markdown", "annal:Richtext", "Help"),
('List_default_type', "Enum_optional", "annal:Type",
"Default type"),
('List_default_view', "Enum_optional", "annal:View",
"Default view"),
('List_entity_type', "Identifier",
"annal:Identifier", "List entity type"),
('Type_label', "Text", "annal:Text", "Label"),
('Type_comment', "Markdown", "annal:Richtext", "Comment"),
('Type_uri', "Identifier", "annal:Identifier", "Type URI"),
('List_choice', "Enum_choice", "annal:EntityRef", "List view"),
('View_choice', "View_choice", "annal:EntityRef", "Choose view"),
('Group_field_sel', "Enum_optional", "annal:EntityRef",
"Field ref")
})
check_field_list_context_fields(self, r, field_entities)
return
def recordlist_view_form_data(coll_id="testcoll",
list_id=None,
orig_id=None,
action=None,
cancel=None,
update="RecordView"):
form_data_dict = ({
'List_type':
'List',
'List_label':
'%s list (%s/@@list_id@@)' % (update, coll_id),
'List_comment':
'%s help (%s/@@list_id@@)' % (update, coll_id)
# , 'List_type': 'List'
,
'List_default_type':
'Default_type',
'List_default_view':
'Default_view',
'List_entity_selector':
'ALL'
# List repeating fields
,
'List_repeat_fields__0__Field_id':
"Entity_id",
'List_repeat_fields__0__Field_placement':
"small:0,3",
'List_repeat_fields__1__Field_id':
"Entity_label",
'List_repeat_fields__1__Field_placement':
"small:3,9"
# Hidden fields
,
'action':
'@@TBD@@',
'view_id':
'List_view',
'orig_id':
'orig_list_id',
'orig_type':
'_list',
'continuation_url':
entitydata_list_type_url(coll_id, "_list")
})
if list_id:
form_data_dict['entity_id'] = list_id
form_data_dict['orig_id'] = list_id
form_data_dict['List_label'] = '%s %s/%s' % (update, coll_id, list_id)
form_data_dict['List_comment'] = '%s help for %s/%s' % (
update, coll_id, list_id)
if orig_id:
form_data_dict['orig_id'] = orig_id
if action:
form_data_dict['action'] = action
if cancel:
form_data_dict['cancel'] = "Cancel"
else:
form_data_dict['save'] = 'Save'
return form_data_dict
def test_post_edit_type_entity_no_login(self):
self.client.logout()
f = entitylist_form_data("edit", entities=[layout.FIELD_TYPEID+"/field1"])
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="Field_list")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 401)
self.assertEqual(r.reason_phrase, "Unauthorized")
return
def test_post_edit_type_entity_no_login(self):
self.client.logout()
f = entitylist_form_data("edit", entities=["testtype/entity1"])
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 401)
self.assertEqual(r.reason_phrase, "Unauthorized")
return
def test_post_default_list(self):
# This button makes the current list view default for the collection
f = entitylist_form_data("default_view", list_id="View_list")
u = entitydata_list_type_url("testcoll", "_type", list_id="Type_list")
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_list_type_url("testcoll", "_type", list_id="Type_list")
h = "info_head=Action%20completed"
m = "info_message=.*view.*testcoll.*Type_list"
c = continuation_url_param(collection_edit_url("testcoll"))
self.assertIn(v, r['location'])
self.assertIn(h, r['location'])
self.assertMatch(r['location'], m)
self.assertNotIn("continuation_url", r['location'])
return
def test_get_list_inherited_entities(self):
rdf_coll = install_annalist_named_coll("RDF_schema_defs")
ann_coll = install_annalist_named_coll("Annalist_schema")
testcoll = create_test_coll_inheriting("Annalist_schema")
schema_list_ids = get_site_schema_lists_linked("testcoll")
u = entitydata_list_type_url("testcoll", "Class", list_id=None, scope="all")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], "Class")
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(schema_list_ids))
self.assertEqual(list_choices['field_value'], "Classes")
# Entities
entities = context_list_entities(r.context)
self.assertEqual(len(entities), 27)
field_entities = (
{ ('Audio', 'Class', 'Audio clip' )
, ('Collection', 'Class', 'Data collection' )
, ('Default_type', 'Class', 'Default type' )
, ('Entity', 'Class', 'Entity' )
, ('EntityData', 'Class', 'EntityData' )
, ('EntityRoot', 'Class', 'Root entity' )
, ('Enum', 'Class', 'Enumerated type' )
, ('Field', 'Class', 'Field definition' )
, ('Field_group', 'Class', 'Field group' )
, ('Image', 'Class', 'Image' )
, ('List', 'Class', 'List definition' )
, ('Resource', 'Class', 'Resource' )
, ('Site', 'Class', 'Annalist site' )
, ('SiteData', 'Class', 'Site data' )
, ('Type', 'Class', 'Type definition' )
, ('Type_Data', 'Class', 'Type data' )
, ('Unknown_type', 'Class', 'Unknown type' )
, ('User', 'Class', 'User permissions' )
, ('View', 'Class', 'View definition' )
, ('Vocabulary', 'Class', 'Vocabulary namespace definition')
, ('Boolean', 'Datatype', 'Boolean' )
, ('Identifier', 'Datatype', 'Identifier' )
, ('Longtext', 'Datatype', 'Multiline text' )
, ('Placement', 'Datatype', 'Field placement' )
, ('Richtext', 'Datatype', 'Rich text' )
, ('Slug', 'Datatype', 'Local entity reference' )
, ('Text', 'Datatype', 'Text' )
})
for f in field_entities:
for eid in range(len(entities)):
item_fields = context_list_item_fields(r.context, entities[eid])
if item_fields[0]['field_value'] == f[0]:
for fid in range(3):
item_field = item_fields[fid]
check_context_list_field_value(self, item_field, f[fid])
break
else:
self.fail("Field %s not found in context"%f[0])
return
def test_post_view_search(self):
# Redisplay list with entries matching search string
f = entitylist_form_data("list_type", search="search&term", continuation_url="/xyzxy/")
u = entitydata_list_type_url("testcoll", "testtype")
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_list_type_url(
"testcoll", "testtype", list_id="Default_list"
)
c = continuation_url_param("/xyzxy/")
s = "search=search%26term"
self.assertIn(v, r['location'])
self.assertIn(c, r['location'])
self.assertIn(s, r['location'])
# Note: Search rendering tested by test_get_fields_list_search above
return
def test_post_new_type_entity(self):
f = entitylist_form_data("new")
u = entitydata_list_type_url("testcoll", "testtype")
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", "testtype", view_id="Default_view")
self.assertIn(v, r['location'])
return
def delete_user(self):
# requires ADMIN
e = self.create_user("delete_user")
u = entitydata_list_type_url(coll_id="testcoll",
type_id="_user",
list_id="Default_list")
f = annalistuser_delete_form_data(user_id="delete_user")
r = self.client.post(u, f)
# log.info(r.content)
return r
def test_post_edit_type_entity_select_none(self):
f = entitylist_form_data("edit")
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e = TestHostUri + u + "?error_head=Problem%20with%20input&error_message="
self.assertIn(e, r['location'])
return
def test_post_edit_type_entity_select_none(self):
f = entitylist_form_data("edit")
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="Field_list")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e = TestHostUri + u + "?error_head=Problem%20with%20input&error_message="
self.assertIn(e, r['location'])
return
def test_get_list_no_list(self):
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="no_list")
with SuppressLogging(logging.WARNING):
r = self.client.get(u)
self.assertEqual(r.status_code, 404)
self.assertEqual(r.reason_phrase, "Not found")
self.assertContains(r,
"Record list no_list in collection testcoll does not exist",
status_code=404
)
return
def test_post_delete_type_entity_with_values(self):
f = entitylist_form_data("delete", entities=["_type/testtype"])
u = entitydata_list_type_url("testcoll", "_type", list_id="Type_list")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
l = r['location']
self.assertIn(u, l)
self.assertIn("error_head=Problem%20with%20input", l)
self.assertIn("error_message=Cannot%20remove%20type%20testtype%20with%20existing%20values", l)
return
def test_post_view_entity_close(self):
self._create_entity_data("entityview")
f = entitydata_default_view_form_data(entity_id="entityview", action="view", close="Close")
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, "")
self.assertEqual(r['location'], TestHostUri + entitydata_list_type_url("testcoll", "testtype"))
self._check_entity_data_values("entityview")
return
def test_post_copy_type_entity_select_none(self):
f = entitylist_form_data("copy")
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e = error_head = "Problem%20with%20input&error_message=No%20data%20record%20selected%20to%20copy"
self.assertIn(TestHostUri + u, r['location'])
self.assertIn(e, r['location'])
return
def test_post_new_type_entity(self):
f = entitylist_form_data("new", list_id="Field_list")
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="Field_list")
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", layout.FIELD_TYPEID, view_id="Field_view")
c = continuation_url_param(u)
self.assertIn(v, r['location'])
self.assertIn(c, r['location'])
return
def test_get_list_select_by_type(self):
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id=None)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], layout.FIELD_TYPEID)
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(self.list_ids))
self.assertEqual(list_choices['field_value'], "Field_list")
return
def delete_data(self):
# requires DELETE
e = self.create_data("delete_entity")
u = entitydata_list_type_url(coll_id="testcoll",
type_id="Default_type",
list_id="Default_list")
f = entitydata_delete_form_data(entity_id="delete_entity")
# log.info("u %s"%u)
# log.info("f %r"%f)
r = self.client.post(u, f)
# log.info(r)
return r
def test_get_list_select_by_type(self):
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id=None)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], layout.FIELD_TYPEID)
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(self.list_ids))
self.assertEqual(list_choices['field_value'], "Field_list")
return
def test_post_close(self):
# 'Close' button on list view
c = "/xyzzy/"
f = entitylist_form_data("close", entities=["testtype/entity1", "testtype/entity2"], continuation_url=c)
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
v = TestHostUri + c
self.assertEqual(v, r['location'])
return
def test_get_fields_list(self):
# List fields in current collection
u = entitydata_list_type_url(
"testcoll", layout.FIELD_TYPEID, list_id="Field_list",
scope="all",
continuation_url="/xyzzy/"
)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# log.info(r.content) #@@
list_label = "Field definitions"
list_title = "Field definitions - Collection testcoll"
self.assertContains(r, "<title>%s</title>"%list_title, html=True)
self.assertContains(r, '<h2 class="page-heading">%s</h2>'%list_label, html=True)
# Test context
self.assertEqual(r.context['title'], list_title)
self.assertEqual(r.context['heading'], list_label)
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], layout.FIELD_TYPEID)
self.assertEqual(r.context['continuation_url'], "/xyzzy/")
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(self.list_ids))
self.assertEqual(list_choices['field_value'], "Field_list")
# Fields
field_entities = (
{ ('Entity_id', "EntityId", "annal:Slug", "Id")
, ('Coll_comment', "Markdown", "annal:Richtext", "Collection metadata")
, ('Coll_parent', "Enum_choice_opt", "annal:Slug", "Parent")
, ('Coll_software_version', "Showtext", "annal:Text", "S/W version")
, ('Entity_type', "EntityTypeId", "annal:Slug", "Type")
, ('Entity_label', "Text", "annal:Text", "Label")
, ('Field_comment', "Textarea", "annal:Longtext", "Help")
, ('Field_placement', "Placement", "annal:Placement", "Position/size")
, ('Field_render_type', "Enum_choice", "annal:Slug", "Render type")
, ('Field_value_mode', "Enum_choice", "annal:Slug", "Value mode")
, ('Field_value_type', "Identifier", "annal:Identifier", "Value type")
, ('Field_entity_type', "Identifier", "annal:Identifier", "Entity type")
, ('Field_default', "Text", "annal:Text", "Default")
, ('Field_typeref', "Enum_optional", "annal:Slug", "Refer to type")
, ('Field_restrict', "Text", "annal:Text", "Value restriction")
, ('List_comment', "Markdown", "annal:Richtext", "Help")
, ('List_default_type', "Enum_optional", "annal:Type", "Default type")
, ('List_default_view', "Enum_optional", "annal:View", "Default view")
, ('Type_label', "Text", "annal:Text", "Label")
, ('Type_comment', "Markdown", "annal:Richtext", "Comment")
, ('Type_uri', "Identifier", "annal:Identifier", "Type URI")
, ('List_choice', "Enum_choice", "annal:Slug", "List view")
, ('View_choice', "View_choice", "annal:Slug", "Choose view")
, ('Group_field_sel', "Enum_optional", "annal:Slug", "Field id")
})
check_field_list_context_fields(self, r, field_entities)
return
def user_view_form_data(
coll_id="testcoll",
user_id="testuser",
user_name="Test User",
user_uri="mailto:[email protected]",
user_permissions="VIEW CREATE UPDATE DELETE CONFIG ADMIN",
action=None,
cancel=None,
close=None,
edit=None,
copy=None,
orig_coll=None,
orig_id=None):
form_data_dict = ({
'entity_id':
user_id,
'orig_id':
user_id,
'User_name':
user_name,
'User_description':
'User %s: permissions for %s in collection %s' %
(user_id, user_name, coll_id),
'User_uri':
user_uri,
'User_permissions':
user_permissions,
'orig_type':
layout.USER_TYPEID,
'record_type':
"annal:User",
"orig_coll":
coll_id,
'continuation_url':
entitydata_list_type_url(coll_id, "_user")
})
if orig_id:
form_data_dict['orig_id'] = orig_id
if orig_coll:
form_data_dict['orig_coll'] = orig_coll
if action:
form_data_dict['action'] = action
if cancel:
form_data_dict['cancel'] = "Cancel"
elif close:
form_data_dict['close'] = "Close"
elif edit:
form_data_dict['edit'] = "Edit"
elif copy:
form_data_dict['copy'] = "Copy"
else:
form_data_dict['save'] = 'Save'
return form_data_dict
def delete_type(self):
# requires CONFIG
e = self.create_type("delete_type")
u = entitydata_list_type_url(coll_id="testcoll",
type_id="_type",
list_id="Default_list")
f = recordtype_delete_form_data(type_id="delete_type")
# log.info("u %s"%u)
# log.info("f %r"%f)
r = self.client.post(u, f)
# log.info(r.content)
return r
def recordtype_entity_view_form_data(
coll_id="testcoll",
type_id="", orig_id=None,
action=None, cancel=None, close=None, edit=None, copy=None, task=None,
update="RecordType",
type_uri=None
):
"""
Returns a request dictionary that can be used with the Django test client.
Per Django documentation, multiple values for a key are provided as a list.
See: https://docs.djangoproject.com/en/1.8/topics/testing/tools/#making-requests
"""
form_data_dict = (
{ 'Type_label': '%s data ... (%s/%s)'%(update, coll_id, type_id)
, 'Type_comment': '%s description ... (%s/%s)'%(update, coll_id, type_id)
, 'orig_id': 'orig_type_id'
, 'continuation_url': entitydata_list_type_url(coll_id, "_type")
})
if type_id is not None:
form_data_dict['entity_id'] = type_id
if type_id:
type_url = recordtype_url(coll_id=coll_id, type_id=type_id)
type_help = '%s help for %s in collection %s'%(update, type_id, coll_id)
form_data_dict['entity_id'] = type_id
form_data_dict['orig_id'] = type_id
form_data_dict['Type_label'] = '%s %s/%s'%(update, coll_id, type_id)
form_data_dict['Type_comment'] = type_help
form_data_dict['Type_uri'] = type_url or ""
form_data_dict['Type_view'] = "_view/Default_view"
form_data_dict['Type_list'] = "_list/Default_list"
form_data_dict['orig_type'] = "_type"
if orig_id:
form_data_dict['orig_id'] = orig_id
if action:
form_data_dict['action'] = action
if cancel:
form_data_dict['cancel'] = "Cancel"
elif close:
form_data_dict['close'] = "Close"
elif edit:
form_data_dict['edit'] = "Edit"
elif copy:
form_data_dict['copy'] = "Copy"
elif task:
form_data_dict[task] = task
else:
form_data_dict['save'] = "Save"
if type_uri:
form_data_dict['Type_uri'] = type_uri
form_data_dict['Type_supertype_uris__0__Type_supertype_uri'] = type_uri+"/super1"
form_data_dict['Type_supertype_uris__1__Type_supertype_uri'] = type_uri+"/super2"
return form_data_dict
def test_post_copy_type_entity_select_none(self):
f = entitylist_form_data("copy")
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="Field_list")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
c = "continuation_url"
e = error_head="Problem%20with%20input&error_message=No%20data%20record%20selected%20to%20copy"
self.assertIn(TestHostUri + u, r['location'])
self.assertNotIn(c, r['location'])
self.assertIn(e, r['location'])
return
def test_post_copy_type_entity_select_many(self):
f = entitylist_form_data(
"copy",
entities=[layout.FIELD_TYPEID+"/field1", "testtype/entity1", "testtype/entity2"]
)
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e = TestHostUri + u + "?error_head=Problem%20with%20input&error_message="
self.assertIn(e, r['location'])
return
def test_post_delete_site_entity(self):
f = entitylist_form_data("delete", entities=[layout.FIELD_TYPEID+"/Field_comment"])
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="Field_list")
# log.info("entitydata_list_all_url: %s"%u)
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e1 = TestHostUri + u + "?error_head=Problem%20with%20input&error_message="
self.assertIn(e1, r['location'])
e2 = "Cannot%20remove%20site%20built-in%20entity%20Field_comment"
self.assertIn(e2, r['location'])
return
def test_post_close_no_continuation(self):
# 'Close' button on list view with no continuation URI given in form
f = entitylist_form_data("close",
entities=["testtype/entity1", "testtype/entity2"],
continuation_url=""
)
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
v = TestHostUri + collection_view_url(coll_id="testcoll")
self.assertEqual(v, r['location'])
return
def test_post_copy_type_entity(self):
# Also tests continuation_url parameter handling
s = site_view_url()
f = entitylist_form_data("copy", entities=[layout.FIELD_TYPEID+"/field1"], continuation_url=s)
u = entitydata_list_type_url("testcoll", layout.FIELD_TYPEID, list_id="Field_list")
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("copy", "testcoll", layout.FIELD_TYPEID, "field1", view_id="Field_view")
c = continuation_url_param(u, continuation_url_param(s))
self.assertIn(v, r['location'])
self.assertIn(c, r['location'])
return
def test_post_edit_type_entity_select_many(self):
f = entitylist_form_data("edit", entities=["testtype/entity1", "testtype/entity2"])
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e1 = TestHostUri + u
e2 = "error_head=%s"%(uri_quote_param(message.INPUT_ERROR),)
e3 = "error_message="
self.assertIn(e1, r['location'])
self.assertIn(e2, r['location'])
self.assertIn(e3, r['location'])
return
def test_post_copy_type_entity_select_none(self):
f = entitylist_form_data("copy")
u = entitydata_list_type_url("testcoll", "testtype")
r = self.client.post(u, f)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
e1 = TestHostUri + u
e2 = "error_head=%s"%(uri_quote_param(message.INPUT_ERROR),)
e3 = "error_message=%s"%(uri_quote_param(message.NO_ENTITY_FOR_COPY),)
self.assertIn(e1, r['location'])
self.assertIn(e2, r['location'])
self.assertIn(e3, r['location'])
return
def test_post_new_entity(self):
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
f = entitydata_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_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 recordfield_entity_view_form_data(
field_id="", orig_id=None,
coll_id="testcoll",
field_label=None,
render_type="Text", value_mode="Value_direct",
entity_type=None, property_uri=None, value_type=None,
field_placement="",
action=None, cancel=None, task=None,
update="Field"):
# log.info("recordfield_entity_view_form_data: field_id %s"%(field_id))
form_data_dict = (
{ 'Field_label': '%s data ... (%s/%s)'%(update, coll_id, "_field")
, 'Field_comment': '%s description ... (%s/%s)'%(update, coll_id, "_field")
, 'Field_render_type': render_type
, 'Field_value_mode': value_mode
, 'orig_id': 'orig_field_id'
, 'continuation_url': entitydata_list_type_url(coll_id, "_field")
})
if field_id is not None:
form_data_dict['entity_id'] = field_id
if field_id:
field_url = recordfield_url(coll_id=coll_id, field_id=field_id)
form_data_dict['entity_id'] = field_id
form_data_dict['Field_label'] = '%s %s/%s/%s'%(update, coll_id, "_field", field_id)
form_data_dict['Field_comment'] = '%s help for %s in collection %s'%(update, field_id, coll_id)
form_data_dict['Field_uri'] = field_url
form_data_dict['Field_placement'] = field_placement
form_data_dict['orig_id'] = field_id
form_data_dict['orig_type'] = "_field"
if orig_id:
form_data_dict['orig_id'] = orig_id
if field_label:
form_data_dict['Field_label'] = field_label
form_data_dict['Field_comment'] = "Help for "+field_label
if entity_type:
form_data_dict['Field_entity_type'] = entity_type
if property_uri:
form_data_dict['Field_property'] = property_uri
if value_type:
form_data_dict['Field_value_type'] = value_type
if action:
form_data_dict['action'] = action
if cancel:
form_data_dict['cancel'] = "Cancel"
elif task:
form_data_dict[task] = task
else:
form_data_dict['save'] = 'Save'
return form_data_dict
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll",
collection_create_values("testcoll"))
self.no_options = ['(no options)']
self.continuation_url = TestHostUri + entitydata_list_type_url(
coll_id="testcoll", type_id="_list")
# Login and permissions
create_test_user(self.testcoll, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******",
password="******")
self.assertTrue(loggedin)
return
def _check_entity_list(self, type_id, expect_entities):
u = entitydata_list_type_url("testcoll", type_id)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<title>List entities - Collection testcoll</title>")
# Test context
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], type_id)
entities = context_list_entities(r.context)
self.assertEqual(len(entities), len(expect_entities))
for eid in range(len(expect_entities)):
self.assertEqual(entities[eid]['entity_type_id'], expect_entities[eid][0])
self.assertEqual(entities[eid]['entity_id'], expect_entities[eid][1])
return
def test_get_fields_list(self):
# List fields in current collection
u = entitydata_list_type_url(
"testcoll", layout.FIELD_TYPEID, list_id="Field_list", scope="all",
continuation_url="/xyzzy/"
)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
# Test context
self.assertEqual(r.context['title'], "Field definitions - Collection testcoll")
self.assertEqual(r.context['heading'], "Field definitions")
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], layout.FIELD_TYPEID)
self.assertEqual(r.context['continuation_url'], "/xyzzy/")
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(self.list_ids))
self.assertEqual(list_choices['field_value'], "Field_list")
# Fields
field_entities = (
{ ('Entity_id', "EntityId", "annal:Slug", "Id")
, ('Bib_address', "Text", "annal:Text", "Address")
, ('Bib_authors', "Group_Seq", "bib:Authors", "Author(s)")
, ('Bib_booktitle', "Text", "annal:Text", "Book title")
, ('Entity_type', "EntityTypeId", "annal:Slug", "Type")
, ('Entity_label', "Text", "annal:Text", "Label")
, ('Field_comment', "Textarea", "annal:Longtext", "Help")
, ('Field_placement', "Placement", "annal:Placement", "Position/size")
, ('Field_render_type', "Enum_choice", "annal:Slug", "Render type")
, ('Field_value_mode', "Enum_choice", "annal:Slug", "Value mode")
, ('Field_value_type', "Identifier", "annal:Identifier", "Value type")
, ('Field_entity_type', "Identifier", "annal:Identifier", "Entity type")
, ('Field_default', "Text", "annal:Text", "Default")
, ('Field_typeref', "Enum_optional", "annal:Slug", "Refer to type")
, ('Field_restrict', "Text", "annal:Text", "Value restriction")
, ('List_comment', "Markdown", "annal:Richtext", "Help")
, ('List_default_type', "Enum_optional", "annal:Type", "Default type")
, ('List_default_view', "Enum_optional", "annal:View", "Default view")
, ('List_target_type', "Identifier", "annal:Identifier", "List entity type")
, ('Type_label', "Text", "annal:Text", "Label")
, ('Type_comment', "Markdown", "annal:Richtext", "Comment")
, ('Type_uri', "Identifier", "annal:Identifier", "Type URI")
, ('List_choice', "Enum_choice", "annal:Slug", "List view")
, ('View_choice', "View_choice", "annal:Slug", "Choose view")
, ('Group_field_sel', "Enum_optional", "annal:Slug", "Field id")
})
check_field_list_context_fields(self, r, field_entities)
return
def test_post_new_entity_cancel(self):
self.assertFalse(EntityData.exists(self.testdata, "newentity"))
f = entitydata_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_view_entity_copy(self):
self._create_entity_data("entityview")
f = entitydata_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_get_fields_list_search(self):
u = entitydata_list_type_url(
"testcoll", layout.FIELD_TYPEID, list_id="Field_list", scope="all",
continuation_url="/xyzzy/",
query_params={"search": "Coll_"}
)
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
list_label = "Field definitions"
list_title = "Field definitions - Collection testcoll"
self.assertContains(r, "<title>%s</title>"%list_title, html=True)
self.assertContains(r, '<h2 class="page-heading">%s</h2>'%list_label, html=True)
# Test context
self.assertEqual(r.context['coll_id'], "testcoll")
self.assertEqual(r.context['type_id'], layout.FIELD_TYPEID)
self.assertEqual(r.context['continuation_url'], "/xyzzy/")
self.assertEqual(r.context['search_for'], "Coll_")
list_choices = r.context['list_choices']
self.assertEqual(set(list_choices.options), set(self.list_ids))
self.assertEqual(list_choices['field_value'], "Field_list")
# Fields
head_fields = context_list_head_fields(r.context)
self.assertEqual(len(head_fields), 1) # One row of 4 cols..
self.assertEqual(len(head_fields[0]['row_field_descs']), 4)
f0 = context_view_field(r.context, 0, 0)
f1 = context_view_field(r.context, 0, 1)
f2 = context_view_field(r.context, 0, 2)
f3 = context_view_field(r.context, 0, 3)
self.assertEqual(f0['field_id'], 'Entity_id')
self.assertEqual(f1['field_id'], 'Field_render_type')
self.assertEqual(f2['field_id'], 'Field_value_type')
self.assertEqual(f3['field_id'], 'Entity_label')
# Entities
entities = context_list_entities(r.context)
self.assertEqual(len(entities), 7)
field_entities = (
{ ( "Coll_comment", "Markdown", "annal:Richtext", "Collection metadata" )
, ( "Coll_default_list_id", "Showtext", "annal:Text", "Default list" )
, ( "Coll_default_view_entity", "Showtext", "annal:Text", "Default view entity" )
, ( "Coll_default_view_id", "Showtext", "annal:Text", "Default view" )
, ( "Coll_default_view_type", "Showtext", "annal:Text", "Default view type" )
, ( "Coll_parent", "Enum_choice_opt", "annal:Slug", "Parent" )
, ( "Coll_software_version", "Showtext", "annal:Text", "S/W version" )
})
check_field_list_context_fields(self, r, field_entities)
return
def test_post_copy_entity(self):
self.assertFalse(EntityData.exists(self.testdata, "copytype"))
f = default_view_form_data(entity_id="copytype", action="copy")
u = entitydata_edit_url("copy",
"testcoll",
"testtype",
entity_id="entity1")
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
self._check_entity_data_values("copytype")
return
def setUp(self):
self.testsite = init_annalist_test_site()
self.testcoll = init_annalist_test_coll()
self.testsubcoll = create_test_coll_inheriting(
base_coll_id="testcoll", coll_id="testsubcoll", type_id="testtype"
)
create_test_user(self.testcoll, "testuser", "testpassword")
create_test_user(self.testsubcoll, "testsubuser", "testpassword")
# Allow user "testuser" access in collectrion "testsubcoll"
user_permissions = ["VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"]
user_id = "testuser"
user_perms = self.testsubcoll.create_user_permissions(
user_id, "mailto:%s@%s"%(user_id, TestHost),
"Test Subuser",
"User %s: permissions for %s in collection %s"%
( user_id, "Test Subuser", self.testsubcoll.get_id() ),
user_permissions)
# Block user "testsubuser" access in collection "testcoll"
user_permissions = []
user_id = "testsubuser"
user_perms = self.testcoll.create_user_permissions(
user_id, "mailto:%s@%s"%(user_id, TestHost),
"Test Subuser",
"User %s: permissions for %s in collection %s"%
( user_id, "Test Subuser", self.testcoll.get_id() ),
user_permissions)
# Block default user access in collection "testcoll"
user_permissions = []
user_id = "_default_user_perms"
user_uri = "annal:User/_default_user_perms"
user_perms = self.testcoll.create_user_permissions(
user_id, user_uri,
"Test Subuser",
"User %s: permissions for %s in collection %s"%
( user_id, "Test Subuser", self.testcoll.get_id() ),
user_permissions)
# Create inherited entity "testcoll/testtype/entity2"
self.testdata = RecordTypeData.load(self.testcoll, "testtype")
self.testentity2 = self._create_entity_data("entity2")
self.testsubdata = RecordTypeData.load(self.testsubcoll, "testtype")
# loggedin = self.client.login(username="******", password="******")
# self.assertTrue(loggedin)
self.continuation_url = entitydata_list_type_url(
coll_id="testsubcoll", type_id="testtype"
)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(
self.testsite, "testcoll", collection_create_values("testcoll")
)
# For checking Location: header values...
self.continuation_url = TestHostUri + entitydata_list_type_url(
coll_id="testcoll", type_id=layout.USER_TYPEID
)
# Login and permissions
create_test_user(
self.testcoll, "testuser", "testpassword",
user_permissions=["VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG", "ADMIN"]
)
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
return
