def setUp(self): init_annalist_test_site() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") self.testcoll1 = Collection(self.testsite, "testcoll1") self.testcoll2 = Collection(self.testsite, "testcoll2") self.fieldcache = CollectionFieldCache() self.field1 = RecordField(self.testcoll1, "field1") self.field1.set_values( recordfield_create_values(field_id="field1", property_uri="test:field1", superproperty_uris=[] ) ) self.field11 = RecordField(self.testcoll1, "field11") self.field11.set_values( recordfield_create_values(field_id="field11", property_uri="test:field11", superproperty_uris=["test:field1"] ) ) self.field111 = RecordField(self.testcoll1, "field111") self.field111.set_values( recordfield_create_values(field_id="field111", property_uri="test:field111", superproperty_uris=["test:field11"] ) ) self.field2 = RecordField(self.testcoll1, "field2") self.field2.set_values( recordfield_create_values(field_id="field2", property_uri="test:field2", superproperty_uris=[] ) ) return
def create_subproperty_field_view_entity(self): # Create test field using superproperty self.test_sup_field = RecordField.create(self.testcoll, "Test_sup_field", { ANNAL.CURIE.type: "annal:Field" , RDFS.CURIE.label: "Field using superproperty URI" , RDFS.CURIE.comment: "Field using superproperty URI" , ANNAL.CURIE.field_render_type: "_enum_render_type/Text" , ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct" , ANNAL.CURIE.field_entity_type: "test:testtype" , ANNAL.CURIE.placeholder: "(Test_sup_field)" , ANNAL.CURIE.property_uri: "test:superprop_uri" , ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }) self.assertTrue(self.test_sup_field is not None) # Create test field using subproperty and declaring superproperty self.test_sub_field = RecordField.create(self.testcoll, "Test_sub_field", { ANNAL.CURIE.type: "annal:Field" , RDFS.CURIE.label: "Field using superproperty URI" , RDFS.CURIE.comment: "Field using superproperty URI" , ANNAL.CURIE.field_render_type: "_enum_render_type/Text" , ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct" , ANNAL.CURIE.field_entity_type: "test:testtype" , ANNAL.CURIE.placeholder: "(Test_sub_field)" , ANNAL.CURIE.property_uri: "test:subprop_uri" , ANNAL.CURIE.superproperty_uri: [{"@id": "test:superprop_uri"}] , ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }) self.assertTrue(self.test_sub_field is not None) # Create test view using superproperty self.test_view = RecordView.create(self.testcoll, "testview", { ANNAL.CURIE.type: "annal:View" , ANNAL.CURIE.uri: "test:view" , RDFS.CURIE.label: "Test view label" , RDFS.CURIE.comment: "Test view comment" , ANNAL.CURIE.view_entity_type: "test:testtype" , ANNAL.CURIE.view_fields: [ { ANNAL.CURIE.field_id: layout.FIELD_TYPEID+"/Entity_id" , ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" } , { ANNAL.CURIE.field_id: layout.FIELD_TYPEID+"/Test_sup_field" , ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" } ] }) self.assertTrue(self.test_view is not None) # Create test entity using subproperty self.testentity_data = EntityData.create(self.testdata, "testentity", entitydata_create_values( "testentity", type_id="testtype", type_uri="test:testtype", extra_fields={"test:subprop_uri": "Test field value"} ) ) self.assertTrue(self.testentity_data is not None) return
def field_description_from_view_field(collection, field, view_context=None, group_ids_seen=[]): """ Returns a field description value created using information from a field reference in a view description record (i.e. a dictionary containing a field id value and optional field property URI and placement values. (The optional values, if not provided, are obtained from the referenced field description) collection is a collection from which data is being rendered. field is a dictionary with the field description from a view or list description, containing a field id and placement values. view_context is a dictionary of additional values that may be used in assembling values to be used when rendering the field. In particular, a copy of the view description record provides context for some enumeration type selections. group_ids_seen group ids expanded so far, to check for recursive reference. """ #@@TODO: for resilience, revert this when all tests pass? # field_id = field.get(ANNAL.CURIE.field_id, "Field_id_missing") # Field ID slug in URI #@@ field_id = extract_entity_id(field[ANNAL.CURIE.field_id]) recordfield = RecordField.load(collection, field_id, altscope="all") if recordfield is None: log.warning("Can't retrieve definition for field %s" % (field_id)) recordfield = RecordField.load(collection, "Field_missing", altscope="all") # If field references group, pull in group details group_ref = extract_entity_id(recordfield.get(ANNAL.CURIE.group_ref, None)) if group_ref: group_view = RecordGroup.load(collection, group_ref, altscope="all") if not group_view: log.error("Group %s used in field %s" % (group_ref, field_id)) # log.error("".join(traceback.format_stack())) # ex_type, ex, tb = sys.exc_info() # traceback.print_tb(tb) # raise EntityNotFound_Error("Group %s used in field %s"%(group_ref, field_id)) else: group_view = None # If present, `field_property` and `field_placement` override values in the field dexcription return FieldDescription(collection, recordfield, view_context=view_context, field_property=field.get(ANNAL.CURIE.property_uri, None), field_placement=field.get( ANNAL.CURIE.field_placement, None), group_view=group_view, group_ids_seen=group_ids_seen)
def setUp(self): init_annalist_test_site() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") self.testcoll1 = Collection(self.testsite, "testcoll1") self.testcoll2 = Collection(self.testsite, "testcoll2") self.fieldcache = CollectionFieldCache() self.field1 = RecordField(self.testcoll1, "field1") self.field1.set_values( recordfield_create_values(field_id="field1", property_uri="test:field1", superproperty_uris=[])) self.field11 = RecordField(self.testcoll1, "field11") self.field11.set_values( recordfield_create_values(field_id="field11", property_uri="test:field11", superproperty_uris=["test:field1"])) self.field111 = RecordField(self.testcoll1, "field111") self.field111.set_values( recordfield_create_values(field_id="field111", property_uri="test:field111", superproperty_uris=["test:field11"])) self.field2 = RecordField(self.testcoll1, "field2") self.field2.set_values( recordfield_create_values(field_id="field2", property_uri="test:field2", superproperty_uris=[])) return
def field_description_from_view_field(collection, field, view_context=None): """ Returns a field description value created using information from a field reference in a view description record (i.e. a dictionary containing a field id value and optional field property URI and placement values. (The optional values, if not provided, are obtained from the referenced field descriptionb) collection is a collection from which data is being rendered. field is a dictionary with the field description from a view or list description, containing a field id and placement values. view_context is a dictionary of additional values that may be used in assembling values to be used when rendering the field. In particular, a copy of the view description record provides context for some enumeration type selections. """ #@@TODO: for resilience, revert this when all tests pass? # field_id = field.get(ANNAL.CURIE.field_id, "Field_id_missing") # Field ID slug in URI #@@ field_id = field[ANNAL.CURIE.field_id] recordfield = RecordField.load(collection, field_id, collection._parentsite) if recordfield is None: log.warning("Can't retrieve definition for field %s" % (field_id)) recordfield = RecordField.load(collection, "Field_missing", collection._parentsite) field_property = (field.get(ANNAL.CURIE.property_uri, None) or recordfield.get(ANNAL.CURIE.property_uri, "")) field_placement = get_placement_classes( field.get(ANNAL.CURIE.field_placement, None) or recordfield.get(ANNAL.CURIE.field_placement, "")) # If field references group, pull in field details group_ref = recordfield.get(ANNAL.CURIE.group_ref, None) if group_ref: group_view = RecordGroup.load(collection, group_ref, collection._parentsite) if not group_view: raise EntityNotFound_Error("Group %s used in field %s" % (group_ref, field_id)) else: group_view = None return FieldDescription(collection, recordfield, view_context=view_context, field_property=field.get(ANNAL.CURIE.property_uri, None), field_placement=field.get( ANNAL.CURIE.field_placement, None), group_view=group_view)
def setUp(self): init_annalist_test_site() init_annalist_test_coll() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") # Populate collection with linked record types, views and lists self.testsrc_type = RecordType.create(self.testcoll, "testsrc_type", testsrc_type_create_values) self.testtgt_type = RecordType.create(self.testcoll, "testtgt_type", testtgt_type_create_values) self.testsrc_view = RecordView.create(self.testcoll, "testsrc_view", testsrc_view_create_values) self.testtgt_view = RecordView.create(self.testcoll, "testtgt_view", testtgt_view_create_values) self.testsrc_list = RecordList.create(self.testcoll, "testsrc_list", testsrc_list_create_values) self.testtgt_list = RecordList.create(self.testcoll, "testtgt_list", testtgt_list_create_values) self.testtgtref_field = RecordField.create(self.testcoll, "testtgtref_field", testtgtref_field_create_values) self.no_options = [ FieldChoice('', label="(no options)") ] self.tgt_options = ( [ FieldChoice("testtgt_type/"+v, label="testtgt_entity %s label"%v, link=entity_url("testcoll", "testtgt_type", v)) for v in ["testtgt1", "testtgt2"] ]) # Create data records for testing: self.testtgt_type_info = EntityTypeInfo(self.testcoll, "testtgt_type", create_typedata=True) self.testsrc_type_info = EntityTypeInfo(self.testcoll, "testsrc_type", create_typedata=True) for tgt_id in ("testtgt1", "testtgt2"): self.testtgt_type_info.create_entity(tgt_id, testtgt_entity_create_values(tgt_id)) for src_id, tgt_ref in (("testsrc1", "testtgt1"), ("testsrc2", "testtgt2")): self.testsrc_type_info.create_entity(src_id, testsrc_entity_create_values(src_id, tgt_ref)) # 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 setUp(self): self.filepath = "%s/README.md"%TestBaseDir self.fileuri = "file://"+self.filepath self.imagepath = "%s/test-image.jpg"%TestBaseDir self.imageuri = "file://"+self.filepath init_annalist_test_site() init_annalist_test_coll() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") # Populate collection with record type, view and field self.test_ref_type = RecordType.create( self.testcoll, "testreftype", test_image_ref_type_create_values ) self.test_ref_view = RecordView.create( self.testcoll, "testrefview", test_image_ref_view_create_values ) self.test_ref_field = RecordField.create( self.testcoll, "Test_image_ref", test_image_ref_field_create_values ) # Create data records for testing image references: self.test_ref_type_info = EntityTypeInfo( self.testcoll, "testreftype", create_typedata=True ) self.test_ref_type_info.create_entity("test1", test_ref_entity_create_values(self.imageuri)) # 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 setUp(self): self.fileuri = "file://%s/README.md"%TestBaseDir init_annalist_test_site() init_annalist_test_coll() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") # Populate collection with linked record types, views and lists self.test_imp_type = RecordType.create( self.testcoll, "testimptype", test_import_type_create_values ) self.test_imp_view = RecordView.create( self.testcoll, "testimpview", test_import_view_create_values ) self.test_imp_field = RecordField.create( self.testcoll, "Test_import", test_import_field_create_values ) self.test_ref_type = RecordType.create( self.testcoll, "testreftype", test_reference_type_create_values ) self.test_ref_view = RecordView.create( self.testcoll, "testrefview", test_reference_view_create_values ) self.test_ref_field = RecordField.create( self.testcoll, "Test_reference", test_reference_field_create_values ) # Create data records for testing import and references: self.test_imp_type_info = EntityTypeInfo( self.testcoll, "testimptype", create_typedata=True ) for entity_id in ("test1", "test2"): self.test_imp_type_info.create_entity( entity_id, test_imp_entity_create_values(entity_id) ) self.test_ref_type_info = EntityTypeInfo( self.testcoll, "testreftype", create_typedata=True ) for entity_id in ("test1", "test2"): self.test_ref_type_info.create_entity( entity_id, test_ref_entity_create_values(entity_id) ) # 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 field_description_from_view_field(collection, field, view_context=None, group_ids_seen=[]): """ Returns a field description value created using information from a field reference in a view description record (i.e. a dictionary containing a field id value and optional field property URI and placement values. (The optional values, if not provided, are obtained from the referenced field description) collection is a collection from which data is being rendered. field is a dictionary with the field description from a view or list description, containing a field id and placement values. view_context is a dictionary of additional values that may be used in assembling values to be used when rendering the field. In particular, a copy of the view description record provides context for some enumeration type selections. group_ids_seen group ids expanded so far, to check for recursive reference. """ #@@TODO: for resilience, revert this when all tests pass? # field_id = field.get(ANNAL.CURIE.field_id, "Field_id_missing") # Field ID slug in URI #@@ field_id = extract_entity_id(field[ANNAL.CURIE.field_id]) recordfield = RecordField.load(collection, field_id, altscope="all") if recordfield is None: log.warning("Can't retrieve definition for field %s"%(field_id)) recordfield = RecordField.load(collection, "Field_missing", altscope="all") # If field references group, pull in group details group_ref = extract_entity_id(recordfield.get(ANNAL.CURIE.group_ref, None)) if group_ref: group_view = RecordGroup.load(collection, group_ref, altscope="all") if not group_view: log.error("Group %s used in field %s"%(group_ref, field_id)) # log.error("".join(traceback.format_stack())) # ex_type, ex, tb = sys.exc_info() # traceback.print_tb(tb) # raise EntityNotFound_Error("Group %s used in field %s"%(group_ref, field_id)) else: group_view = None # If present, `field_property` and `field_placement` override values in the field dexcription return FieldDescription( collection, recordfield, view_context=view_context, field_property=field.get(ANNAL.CURIE.property_uri, None), field_placement=field.get(ANNAL.CURIE.field_placement, None), group_view=group_view, group_ids_seen=group_ids_seen )
def cache_get_field(self, field_id): """ Retrieve field from cache. Returns field entity if found, otherwise None. """ #@@ field_cache.get_field(self, field_id) t = field_cache.get_field(self, field_id) # Was it previously created but not cached? if not t and RecordField.exists(self, field_id, altscope="all"): msg = ( "Collection.get_field %s present but not cached for collection %s"% (field_id, self.get_id()) ) log.warning(msg) t = RecordField.load(self, field_id, altscope="all") field_cache.set_field(self, t) return t
def cache_get_field(self, field_id): """ Retrieve field from cache. Returns field entity if found, otherwise None. """ field_cache.get_field(self, field_id) t = field_cache.get_field(self, field_id) # Was it previously created but not cached? if not t and RecordField.exists(self, field_id, altscope="all"): msg = ( "Collection.get_field %s present but not cached for collection %s"% (field_id, self.get_id()) ) log.warning(msg) t = RecordField.load(self, field_id, altscope="all") field_cache.set_field(self, t) return t
def remove_field(self, field_id): """ Remove identified field description field_id local identifier for the field to remove. Returns None on success, or a non-False status code if the field is not removed. """ s = RecordField.remove(self, field_id) return s
def _create_refimg_image_field(self): refimg_image_field = RecordField.create(self.testcoll, "Test_image", { "annal:type": "annal:Field" , "rdfs:label": "View image field" , "rdfs:comment": "In view mode, displays an image." , "annal:field_render_type": "RefImage" , "annal:field_value_mode": "Value_direct" , "annal:field_value_type": "annal:Image" , "annal:field_entity_type": "test:img_type" , "annal:placeholder": "(view image field)" , "annal:property_uri": "test:image" , "annal:field_placement": "small:0,12;medium:0,6" }) return refimg_image_field
def _create_refimg_comment_field(self): refimg_comment_field = RecordField.create(self.testcoll, "Test_comment", { "annal:type": "annal:Field" , "rdfs:label": "View comment field" , "rdfs:comment": "In view mode, displays a comment." , "annal:field_render_type": "Markdown" , "annal:field_value_mode": "Value_direct" , "annal:field_value_type": "annal:Richtext" , "annal:field_entity_type": "test:img_type" , "annal:placeholder": "(view comment field)" , "annal:field_placement": "small:0,12;medium:0,6" , "annal:property_uri": "rdfs:comment" }) return refimg_comment_field
def add_field(self, field_id, field_meta): """ Add a new or updated record field to the current collection field_id identifier for the new field, as a string with a form that is valid as URI path segment. field_meta a dictionary providing additional information about the field to be created. Returns a RecordField object for the newly created field. """ log.debug("Collection.add_field %s in %s"%(field_id, self.get_id())) f = RecordField.create(self, field_id, field_meta) return f
def test_field_comment_tooltip(self): """ Test migration of field without tooltip """ # Create field definition self.test_field = RecordField.create(self.testcoll, test_field_id, test_field_tooltip_create_values) # Apply migration to collection migrate_coll_data(self.testcoll) # Read field definition and check for inline field list field_data = self.check_entity_values( "_field", test_field_id, check_values=test_field_tooltip_migrated_values) return
def setUp(self): init_annalist_test_site() init_annalist_test_coll() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") # Populate collection with linked record types, views and lists self.testsrc_type = RecordType.create(self.testcoll, "testsrc_type", testsrc_type_create_values) self.testtgt_type = RecordType.create(self.testcoll, "testtgt_type", testtgt_type_create_values) self.testsrc_view = RecordView.create(self.testcoll, "testsrc_view", testsrc_view_create_values) self.testtgt_view = RecordView.create(self.testcoll, "testtgt_view", testtgt_view_create_values) self.testsrc_list = RecordList.create(self.testcoll, "testsrc_list", testsrc_list_create_values) self.testtgt_list = RecordList.create(self.testcoll, "testtgt_list", testtgt_list_create_values) self.testtgtref_field = RecordField.create( self.testcoll, "testtgtref_field", testtgtref_field_create_values) self.no_options = [FieldChoice('', label="(no options)")] self.tgt_options = ([ FieldChoice("testtgt_type/" + v, label="testtgt_entity %s label" % v, link=entity_url("testcoll", "testtgt_type", v)) for v in ["testtgt1", "testtgt2"] ]) # Create data records for testing: self.testtgt_type_info = EntityTypeInfo(self.testcoll, "testtgt_type", create_typedata=True) self.testsrc_type_info = EntityTypeInfo(self.testcoll, "testsrc_type", create_typedata=True) for tgt_id in ("testtgt1", "testtgt2"): self.testtgt_type_info.create_entity( tgt_id, testtgt_entity_create_values(tgt_id)) for src_id, tgt_ref in (("testsrc1", "testtgt1"), ("testsrc2", "testtgt2")): self.testsrc_type_info.create_entity( src_id, testsrc_entity_create_values(src_id, tgt_ref)) # 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 _create_rptref_field(self, label_add=None, label_delete=None): rptref_field = RecordField.create( self.testcoll, "Test_rptref_field", { "annal:type": "annal:Field", "rdfs:label": "Repeat image reference", "rdfs:comment": "Repeat image reference field comment", "annal:field_render_type": "RepeatGroupRow", "annal:field_value_mode": "Value_direct", "annal:field_value_type": "annal:Field_group", "annal:placeholder": "(repeat image field)", "annal:property_uri": "test:rpt_image", "annal:field_placement": "small:0,12", "annal:group_ref": "Test_rptref_group" }) self.assertTrue(rptref_field is not None) return rptref_field
def _create_ref_type_field(self, entity_type="test:testtypes"): ref_type_field = RecordField.create(self.testcoll, "Test_ref_type_field", { "annal:type": "annal:Field" , "rdfs:label": "Type reference" , "rdfs:comment": "Type reference field comment" , "annal:field_render_type": "Enum_render_type/Enum_choice" , "annal:field_value_mode": "Enum_value_mode/Value_direct" , "annal:field_entity_type": "test:ref_type" , "annal:placeholder": "(ref type field)" , "annal:property_uri": "test:ref_type" , "annal:field_placement": "small:0,12;medium:0,6" , "annal:field_ref_type": "_type/testtypes" , "annal:field_ref_restriction": "[test:turi] subtype %s"%entity_type , "annal:field_entity_type": entity_type }) self.assertTrue(ref_type_field is not None) return ref_type_field
def get_field_uri_jsonld_context(self, fid, get_field_context): """ Access field description, and return field property URI and appropriate property description for JSON-LD context. If there is no corresponding field description, returns (None, None) If no context should be generated for the field URI, returns (uri, None) """ f = RecordField.load(self, fid, altscope="all") if f is None: return (None, None) # @@debugging@@ # if fid in ["Entity_id", "List_id"]: # print "@@ %s field %r"%(fid, f) # print "@@ %s context %r"%(fid, get_field_context(f)) return (f[ANNAL.CURIE.property_uri], get_field_context(f))
def _create_testrepeatfield(self, label_add=None, label_delete=None): testrepeatfield = RecordField.create(self.testcoll, "testrepeatfield", { "annal:type": "annal:Field" , "rdfs:label": "Test repeat field label" , "rdfs:comment": "Test repeat field comment" , "annal:field_render_type": "RepeatGroupRow" , "annal:field_value_type": "annal:Field_group" , "annal:field_entity_type": "test:testtype" , "annal:placeholder": "(test repeat field)" , "annal:property_uri": "test:repeat_fields" , "annal:field_placement": "small:0,12" , "annal:group_ref": "testrepeatgroup" , "annal:repeat_label_add": label_add , "annal:repeat_label_delete": label_delete }) self.assertTrue(testrepeatfield is not None) return testrepeatfield
def _create_testrepeatfield(self, label_add=None, label_delete=None): testrepeatfield = RecordField.create( self.testcoll, "testrepeatfield", { "annal:type": "annal:Field", "rdfs:label": "Test repeat field label", "rdfs:comment": "Test repeat field comment", "annal:field_render_type": "RepeatGroupRow", "annal:field_value_type": "annal:Field_group", "annal:field_entity_type": "test:testtype", "annal:placeholder": "(test repeat field)", "annal:property_uri": "test:repeat_fields", "annal:field_placement": "small:0,12", "annal:group_ref": "testrepeatgroup", "annal:repeat_label_add": label_add, "annal:repeat_label_delete": label_delete }) self.assertTrue(testrepeatfield is not None) return testrepeatfield
def _create_refimg_field(self, label_add=None, label_delete=None): refimg_field = RecordField.create( self.testcoll, "Test_refimg_field", { "annal:type": "annal:Field", "rdfs:label": "Image reference", "rdfs:comment": "Image reference field comment", "annal:field_render_type": "RefMultifield", "annal:field_value_mode": "Value_entity", "annal:field_value_type": "annal:Field_group", "annal:field_entity_type": "test:img_type", "annal:placeholder": "(ref image field)", "annal:property_uri": "test:ref_image", "annal:field_placement": "small:0,12;medium:0,6", "annal:group_ref": "Test_refimg_group", "annal:field_ref_type": "img_type" }) self.assertTrue(refimg_field is not None) return refimg_field
def _create_ref_type_field(self, entity_type="test:testtypes"): ref_type_field = RecordField.create( self.testcoll, "Test_ref_type_field", { "annal:type": "annal:Field", "rdfs:label": "Type reference", "rdfs:comment": "Type reference field comment", "annal:field_render_type": "Enum_render_type/Enum_choice", "annal:field_value_mode": "Enum_value_mode/Value_direct", "annal:field_entity_type": "test:ref_type", "annal:placeholder": "(ref type field)", "annal:property_uri": "test:ref_type", "annal:field_placement": "small:0,12;medium:0,6", "annal:field_ref_type": "_type/testtypes", "annal:field_ref_restriction": "[test:turi] subtype %s" % entity_type, "annal:field_entity_type": entity_type }) self.assertTrue(ref_type_field is not None) return ref_type_field
def get_field_uri_jsonld_context(self, fid, get_field_context): """ Access field description, and return field property URI and appropriate property description for JSON-LD context. Returns a triple consisting of the field property URI, the context information to be generated for the field, and a list of any field references contained directly within the field definition (as opposed to a field group reference) If there is no corresponding field description, returns (None, None, None) If no context should be generated for the field URI, returns (uri, None, field_list) The field list returned is 'None' if there is no contained list of fields. """ f = RecordField.load(self, fid, altscope="all") if f is None: return (None, None, None) field_list = f.get(ANNAL.CURIE.field_fields, None) return (f[ANNAL.CURIE.property_uri], get_field_context(f), field_list)
def test_field_fieldgroup_references(self): """ Test migration of field group references in field definitions """ # Create field group self.test_group = RecordGroup_migration.create( self.testcoll, test_group_id, test_group_create_values) # Create field definition referencing field group self.test_field = RecordField.create(self.testcoll, test_field_id, test_field_group_create_values) # Apply migration to collection migrate_coll_data(self.testcoll) # Read field definition and check for inline field list field_data = self.check_entity_values( "_field", test_field_id, check_values=test_field_group_migrated_values) self.assertNotIn("annal:group_ref", field_data) self.check_entity_does_not_exist("_group", test_group_id) return
def get_field(self, field_id): """ Retrieve identified field description field_id local identifier for the field to retrieve. returns a RecordField object for the identified field, or None. """ if not valid_id(field_id, reserved_ok=True): msg = "Collection %s get_field(%s) invalid id"%(self.get_id(), field_id) log.error(msg) # Construct and return a placeholder field ph_meta = ( { RDFS.CURIE.label: "(field error)" , ANNAL.CURIE.field_render_type: "_enum_render_type/Placeholder" , ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct" , ANNAL.CURIE.field_placement: "small:0,12" , ANNAL.CURIE.placeholder: "(Invalid field id: '%s')"%(field_id,) }) f = RecordField._child_init(self, "_placeholder") f.set_values(ph_meta) return f return self.cache_get_field(field_id)
def create_subproperty_field_view_entity(self): # Create test field using superproperty self.test_sup_field = RecordField.create( self.testcoll, "Test_sup_field", { ANNAL.CURIE.type: "annal:Field", RDFS.CURIE.label: "Field using superproperty URI", RDFS.CURIE.comment: "Field using superproperty URI", ANNAL.CURIE.field_render_type: "_enum_render_type/Text", ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct", ANNAL.CURIE.field_entity_type: "test:testtype", ANNAL.CURIE.placeholder: "(Test_sup_field)", ANNAL.CURIE.property_uri: "test:superprop_uri", ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }) self.assertTrue(self.test_sup_field is not None) # Create test field using subproperty and declaring superproperty self.test_sub_field = RecordField.create( self.testcoll, "Test_sub_field", { ANNAL.CURIE.type: "annal:Field", RDFS.CURIE.label: "Field using superproperty URI", RDFS.CURIE.comment: "Field using superproperty URI", ANNAL.CURIE.field_render_type: "_enum_render_type/Text", ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct", ANNAL.CURIE.field_entity_type: "test:testtype", ANNAL.CURIE.placeholder: "(Test_sub_field)", ANNAL.CURIE.property_uri: "test:subprop_uri", ANNAL.CURIE.superproperty_uri: [{ "@id": "test:superprop_uri" }], ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }) self.assertTrue(self.test_sub_field is not None) # Create test view using superproperty self.test_view = RecordView.create( self.testcoll, "testview", { ANNAL.CURIE.type: "annal:View", ANNAL.CURIE.uri: "test:view", RDFS.CURIE.label: "Test view label", RDFS.CURIE.comment: "Test view comment", ANNAL.CURIE.view_entity_type: "test:testtype", ANNAL.CURIE.view_fields: [{ ANNAL.CURIE.field_id: layout.FIELD_TYPEID + "/Entity_id", ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }, { ANNAL.CURIE.field_id: layout.FIELD_TYPEID + "/Test_sup_field", ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }] }) self.assertTrue(self.test_view is not None) # Create test entity using subproperty self.testentity_data = EntityData.create( self.testdata, "testentity", entitydata_create_values( "testentity", type_id="testtype", type_uri="test:testtype", extra_fields={"test:subprop_uri": "Test field value"})) self.assertTrue(self.testentity_data is not None) return
def setUp(self): self.filepath = "%s/testdatafile.md"%TestBaseDir self.fileuri = "file://"+self.filepath self.imagepath = "%s/test-image.jpg"%TestBaseDir self.imageuri = "file://"+self.imagepath init_annalist_test_site() init_annalist_test_coll() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") # Populate collection with linked record types, views and lists # Types self.test_upl_type = RecordType.create( self.testcoll, "testupltype", test_upload_type_create_values ) self.test_ref_type = RecordType.create( self.testcoll, "testreftype", test_reference_type_create_values ) self.test_image_type = RecordType.create( self.testcoll, "testimgtype", test_image_type_create_values ) # Views self.test_upl_file_view = RecordView.create( self.testcoll, "testuplfileview", test_upload_file_view_create_values ) self.test_upl_image_view = RecordView.create( self.testcoll, "testuplimageview", test_upload_image_view_create_values ) self.test_ref_file_view = RecordView.create( self.testcoll, "testrefview", test_reference_view_create_values ) self.test_ref_image_view = RecordView.create( self.testcoll, "testimgrefview", test_image_ref_view_create_values ) self.test_image_view = RecordView.create( self.testcoll, "testimgview", test_image_view_create_values ) # Fields self.test_upl_file_field = RecordField.create( self.testcoll, "Test_upload_file", test_upload_file_field_create_values ) self.test_upl_image_field = RecordField.create( self.testcoll, "Test_upload_image", test_upload_image_field_create_values ) self.test_ref_file_field = RecordField.create( self.testcoll, "Test_reference", test_reference_field_create_values ) self.test_ref_image_field = RecordField.create( self.testcoll, "Test_image_ref", test_image_ref_field_create_values ) self.test_image_field = RecordField.create( self.testcoll, "Test_image", test_image_field_create_values ) # Create data records for testing import and references: test_entity_ids = ("test1", "test2") test_entity_ids = ("test1",) self.test_upl_type_info = EntityTypeInfo( self.testcoll, "testupltype", create_typedata=True ) for entity_id in test_entity_ids: self.test_upl_type_info.create_entity( entity_id, test_imp_entity_create_values(entity_id) ) self.test_ref_type_info = EntityTypeInfo( self.testcoll, "testreftype", create_typedata=True ) for entity_id in test_entity_ids: self.test_ref_type_info.create_entity( entity_id, test_ref_entity_create_values(entity_id) ) self.test_img_type_info = EntityTypeInfo( self.testcoll, "testimgtype", create_typedata=True ) for entity_id in test_entity_ids: self.test_img_type_info.create_entity( entity_id, test_img_entity_create_values(entity_id) ) # 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 coll_field(coll, field_id): """ Return identified field in collection, or None """ return RecordField.load(coll, field_id, altscope="all")
class CollectionFieldCacheTest(AnnalistTestCase): """ Tests for collection field and superproperty cache classes. """ def setUp(self): init_annalist_test_site() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") self.testcoll1 = Collection(self.testsite, "testcoll1") self.testcoll2 = Collection(self.testsite, "testcoll2") self.fieldcache = CollectionFieldCache() self.field1 = RecordField(self.testcoll1, "field1") self.field1.set_values( recordfield_create_values(field_id="field1", property_uri="test:field1", superproperty_uris=[] ) ) self.field11 = RecordField(self.testcoll1, "field11") self.field11.set_values( recordfield_create_values(field_id="field11", property_uri="test:field11", superproperty_uris=["test:field1"] ) ) self.field111 = RecordField(self.testcoll1, "field111") self.field111.set_values( recordfield_create_values(field_id="field111", property_uri="test:field111", superproperty_uris=["test:field11"] ) ) self.field2 = RecordField(self.testcoll1, "field2") self.field2.set_values( recordfield_create_values(field_id="field2", property_uri="test:field2", superproperty_uris=[] ) ) return def create_field_record(self, coll, field_entity): return RecordField.create(coll, field_entity.get_id(), field_entity.get_values()) def create_test_field_entities(self): # Create records in collection data self.create_field_record(self.testcoll1, self.field1) self.create_field_record(self.testcoll1, self.field11) self.create_field_record(self.testcoll1, self.field111) self.create_field_record(self.testcoll1, self.field2) # Add all records to cache self.fieldcache.set_field(self.testcoll1, self.field1) self.fieldcache.set_field(self.testcoll1, self.field11) self.fieldcache.set_field(self.testcoll1, self.field111) self.fieldcache.set_field(self.testcoll1, self.field2) # Check cache content self.expect_site_field_ids = get_site_fields() self.expect_coll_field_ids = ( { "field1", "field11", "field111", "field2" } ) self.expect_all_field_ids = set.union(self.expect_site_field_ids, self.expect_coll_field_ids) retrieve_field_ids = set(f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1)) self.assertEqual(retrieve_field_ids, self.expect_coll_field_ids) return def tearDown(self): resetSitedata(scope="collections") return def get_coll_field(self, coll, field_id): return self.fieldcache.get_field(coll, field_id) def get_coll_field_uri(self, coll, field_id): return self.get_coll_field(coll, field_id).get_property_uri() def get_coll_uri_field(self, coll, property_uri): return self.fieldcache.get_field_from_uri(coll, property_uri) def get_coll_uri_id(self, coll, property_uri): return self.get_coll_uri_field(coll, property_uri).get_id() def get_coll_property_uris(self, coll): return { f.get_property_uri() for f in self.fieldcache.get_all_fields(coll) } # Start of tests def test_empty_cache(self): self.assertEqual(set(self.fieldcache.get_all_fields(self.testcoll1)), set()) self.assertEqual(set(self.fieldcache.get_all_fields(self.testcoll2)), set()) return def test_singleton_cache(self): self.assertEqual(self.get_coll_property_uris(self.testcoll1), set()) self.create_field_record(self.testcoll1, self.field1) # NOTE: the 'set_field' call also causes cache initialization of all fields, # including the created field record which is discovered on disk, and the subsequent # set_field call returns 'False'. self.assertFalse(self.fieldcache.set_field(self.testcoll1, self.field1)) self.assertFalse(self.fieldcache.set_field(self.testcoll1, self.field1)) self.assertEqual(self.get_coll_field_uri(self.testcoll1, "field1"), "test:field1") self.assertEqual(self.get_coll_field(self.testcoll1, "field2"), None) self.assertEqual(self.get_coll_uri_id(self.testcoll1, "test:field1"), "field1") self.assertEqual(self.get_coll_uri_field(self.testcoll1, "test:field2"), None) self.assertEqual(self.get_coll_property_uris(self.testcoll1), {"test:field1"}) self.assertEqual(self.get_coll_property_uris(self.testcoll2), set()) return def test_empty_cache_2(self): self.fieldcache.set_field(self.testcoll1, self.field1) self.assertIsNotNone(self.fieldcache.remove_field(self.testcoll1, "field1")) self.assertIsNone(self.fieldcache.remove_field(self.testcoll1, "field1")) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll1)), []) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll2)), []) return def test_flush_cache(self): self.fieldcache.set_field(self.testcoll1, self.field1) self.assertTrue(self.fieldcache.flush_cache(self.testcoll1)) self.assertIsNone(self.fieldcache.remove_field(self.testcoll1, "field1")) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll1)), []) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll2)), []) self.assertTrue(self.fieldcache.flush_cache(self.testcoll1)) self.assertFalse(self.fieldcache.flush_cache(self.testcoll1)) return def test_get_fields_by_uri(self): self.create_test_field_entities() self.assertEqual(self.fieldcache.get_field_from_uri(self.testcoll1, "test:field1").get_id(), "field1") self.assertEqual(self.fieldcache.get_field_from_uri(self.testcoll1, "test:field11").get_id(), "field11") self.assertEqual(self.fieldcache.get_field_from_uri(self.testcoll1, "test:field111").get_id(), "field111") self.assertEqual(self.fieldcache.get_field_from_uri(self.testcoll1, "test:field2").get_id(), "field2") return def test_get_all_fields_scope_coll(self): self.create_test_field_entities() field_ids = set(f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1)) self.assertEqual(field_ids, self.expect_coll_field_ids) field_ids = set(f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1)) self.assertEqual(field_ids, self.expect_coll_field_ids) return def test_get_all_fields_scope_all(self): self.create_test_field_entities() field_ids = set( f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1, altscope="all") ) self.assertEqual(field_ids, self.expect_all_field_ids) return def test_get_superproperty_fields(self): self.create_test_field_entities() def get_superproperty_uris(property_uri): sf_entities = self.fieldcache.get_superproperty_fields(self.testcoll1, property_uri) sp_uris = [ sf.get_property_uri() for sf in sf_entities ] return set(sp_uris) self.assertEqual(get_superproperty_uris("test:field1"), set()) self.assertEqual(get_superproperty_uris("test:field11"), {"test:field1"}) self.assertEqual(get_superproperty_uris("test:field111"), {"test:field1", "test:field11"}) self.assertEqual(get_superproperty_uris("test:field2"), set({})) return def test_get_subproperty_fields(self): self.create_test_field_entities() def get_subproperty_uris(property_uri): sf_entities = self.fieldcache.get_subproperty_fields(self.testcoll1, property_uri) sp_uris = [ sf.get_property_uri() for sf in sf_entities ] return set(sp_uris) self.assertEqual(get_subproperty_uris("test:field1"), {"test:field11", "test:field111"}) self.assertEqual(get_subproperty_uris("test:field11"), {"test:field111"}) self.assertEqual(get_subproperty_uris("test:field111"), set()) self.assertEqual(get_subproperty_uris("test:field2"), set()) return def test_update_superproperty(self): self.create_test_field_entities() def get_superproperty_uris(property_uri): sf_entities = self.fieldcache.get_superproperty_fields(self.testcoll1, property_uri) sp_uris = [ sf.get_property_uri() for sf in sf_entities ] return set(sp_uris) self.assertEqual(get_superproperty_uris("test:field1"), set()) self.assertEqual(get_superproperty_uris("test:field11"), {"test:field1"}) self.assertEqual(get_superproperty_uris("test:field111"), {"test:field1", "test:field11"}) self.assertEqual(get_superproperty_uris("test:field2"), set()) # Update super/sub-type self.fieldcache.remove_field(self.testcoll1, "field11") self.fieldcache.set_field(self.testcoll1, self.field11) # Re-check supertypes self.assertEqual(get_superproperty_uris("test:field1"), set()) self.assertEqual(get_superproperty_uris("test:field11"), {"test:field1"}) self.assertEqual(get_superproperty_uris("test:field111"), {"test:field1", "test:field11"}) self.assertEqual(get_superproperty_uris("test:field2"), set()) return def test_update_subproperty(self): self.create_test_field_entities() def get_subproperty_uris(property_uri): sf_entities = self.fieldcache.get_subproperty_fields(self.testcoll1, property_uri) sp_uris = [ sf.get_property_uri() for sf in sf_entities ] return set(sp_uris) self.assertEqual(get_subproperty_uris("test:field1"), {"test:field11", "test:field111"}) self.assertEqual(get_subproperty_uris("test:field11"), {"test:field111"}) self.assertEqual(get_subproperty_uris("test:field111"), set()) self.assertEqual(get_subproperty_uris("test:field2"), set()) # Update super/sub-property self.fieldcache.remove_field(self.testcoll1, "field11") self.fieldcache.set_field(self.testcoll1, self.field11) # Re-check subproperties self.assertEqual(get_subproperty_uris("test:field1"), {"test:field11", "test:field111"}) self.assertEqual(get_subproperty_uris("test:field11"), {"test:field111"}) self.assertEqual(get_subproperty_uris("test:field111"), set()) self.assertEqual(get_subproperty_uris("test:field2"), set()) return
def create_field_record(self, coll, field_entity): return RecordField.create(coll, field_entity.get_id(), field_entity.get_values())
def create_subproperty_list_field_view_entity(self): # Create list field using superproperty self.test_sup_list = RecordField.create(self.testcoll, "Test_sup_list", { ANNAL.CURIE.type: "annal:Field" , RDFS.CURIE.label: "List using superproperty URI" , RDFS.CURIE.comment: "List using superproperty URI" , ANNAL.CURIE.field_render_type: "_enum_render_type/Group_Seq_Row" , ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct" , ANNAL.CURIE.field_value_type: "annal:Test_sup_list" , ANNAL.CURIE.field_entity_type: "test:testtype" , ANNAL.CURIE.placeholder: "(Test_sup_list)" , ANNAL.CURIE.property_uri: "test:superprop_list_uri" , ANNAL.CURIE.field_placement: "small:0,12" , ANNAL.CURIE.field_fields: [ { ANNAL.CURIE.field_id: "_field/Test_sup_field" , ANNAL.CURIE.field_placement: "small:0,12" } ] , ANNAL.CURIE.repeat_label_add: "Add sup entity" , ANNAL.CURIE.repeat_label_delete: "Remove sup entity" }) self.assertTrue(self.test_sup_list is not None) # Create list field using subproperty and declaring superproperty self.test_sub_list = RecordField.create(self.testcoll, "Test_sub_list", { ANNAL.CURIE.type: "annal:Field" , RDFS.CURIE.label: "List using superproperty URI" , RDFS.CURIE.comment: "List using superproperty URI" , ANNAL.CURIE.field_render_type: "_enum_render_type/Group_Seq_Row" , ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct" , ANNAL.CURIE.field_value_type: "annal:Test_sub_list" , ANNAL.CURIE.field_entity_type: "test:testtype" , ANNAL.CURIE.placeholder: "(Test_sub_list)" , ANNAL.CURIE.property_uri: "test:subprop_list_uri" , ANNAL.CURIE.superproperty_uri: [{"@id": "test:superprop_list_uri"}] , ANNAL.CURIE.field_placement: "small:0,12" , ANNAL.CURIE.field_fields: [ { ANNAL.CURIE.field_id: "_field/Test_sub_field" , ANNAL.CURIE.field_placement: "small:0,12" } ] , ANNAL.CURIE.repeat_label_add: "Add sub entity" , ANNAL.CURIE.repeat_label_delete: "Remove sub entity" }) self.assertTrue(self.test_sub_list is not None) # Create test view using superproperty self.test_view = RecordView.create(self.testcoll, "testlistview", { ANNAL.CURIE.type: "annal:View" , ANNAL.CURIE.uri: "test:listview" , RDFS.CURIE.label: "Test listview label" , RDFS.CURIE.comment: "Test listview comment" , ANNAL.CURIE.view_entity_type: "test:testtype" , ANNAL.CURIE.view_fields: [ { ANNAL.CURIE.field_id: layout.FIELD_TYPEID+"/Entity_id" , ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" } , { ANNAL.CURIE.field_id: layout.FIELD_TYPEID+"/Test_sup_list" , ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" } ] }) self.assertTrue(self.test_view is not None) # Create test entity using list and item subproperty URIs self.testlistentity_data = EntityData.create(self.testdata, "testlistentity", entitydata_create_values( "testlistentity", type_id="testtype", type_uri="test:testtype", extra_fields= { "test:subprop_list_uri": [ { "test:subprop_uri": "Test field 1 value"} , { "test:subprop_uri": "Test field 2 value"} ] } ) ) self.assertTrue(self.testlistentity_data is not None) return
def coll_type(coll, type_id): """ Return identified type in collection, or None """ return RecordField.load(coll, field_id, altscope="all")
class CollectionFieldCacheTest(AnnalistTestCase): """ Tests for collection field and superproperty cache classes. """ def setUp(self): init_annalist_test_site() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") self.testcoll1 = Collection(self.testsite, "testcoll1") self.testcoll2 = Collection(self.testsite, "testcoll2") self.fieldcache = CollectionFieldCache() self.field1 = RecordField(self.testcoll1, "field1") self.field1.set_values( recordfield_create_values(field_id="field1", property_uri="test:field1", superproperty_uris=[])) self.field11 = RecordField(self.testcoll1, "field11") self.field11.set_values( recordfield_create_values(field_id="field11", property_uri="test:field11", superproperty_uris=["test:field1"])) self.field111 = RecordField(self.testcoll1, "field111") self.field111.set_values( recordfield_create_values(field_id="field111", property_uri="test:field111", superproperty_uris=["test:field11"])) self.field2 = RecordField(self.testcoll1, "field2") self.field2.set_values( recordfield_create_values(field_id="field2", property_uri="test:field2", superproperty_uris=[])) return def create_field_record(self, coll, field_entity): return RecordField.create(coll, field_entity.get_id(), field_entity.get_values()) def create_test_field_entities(self): # Create records in collection data self.create_field_record(self.testcoll1, self.field1) self.create_field_record(self.testcoll1, self.field11) self.create_field_record(self.testcoll1, self.field111) self.create_field_record(self.testcoll1, self.field2) # Add all records to cache self.fieldcache.set_field(self.testcoll1, self.field1) self.fieldcache.set_field(self.testcoll1, self.field11) self.fieldcache.set_field(self.testcoll1, self.field111) self.fieldcache.set_field(self.testcoll1, self.field2) # Check cache content self.expect_site_field_ids = get_site_fields() self.expect_coll_field_ids = ({ "field1", "field11", "field111", "field2" }) self.expect_all_field_ids = set.union(self.expect_site_field_ids, self.expect_coll_field_ids) retrieve_field_ids = set( f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1)) self.assertEqual(retrieve_field_ids, self.expect_coll_field_ids) return def tearDown(self): resetSitedata(scope="collections") return def get_coll_field(self, coll, field_id): return self.fieldcache.get_field(coll, field_id) def get_coll_field_uri(self, coll, field_id): return self.get_coll_field(coll, field_id).get_property_uri() def get_coll_uri_field(self, coll, property_uri): return self.fieldcache.get_field_from_uri(coll, property_uri) def get_coll_uri_id(self, coll, property_uri): return self.get_coll_uri_field(coll, property_uri).get_id() def get_coll_property_uris(self, coll): return { f.get_property_uri() for f in self.fieldcache.get_all_fields(coll) } # Start of tests def test_empty_cache(self): self.assertEqual(set(self.fieldcache.get_all_fields(self.testcoll1)), set()) self.assertEqual(set(self.fieldcache.get_all_fields(self.testcoll2)), set()) return def test_singleton_cache(self): self.assertEqual(self.get_coll_property_uris(self.testcoll1), set()) self.create_field_record(self.testcoll1, self.field1) # NOTE: the 'set_field' call also causes cache initialization of all fields, # including the created field record which is discovered on disk, and the subsequent # set_field call returns 'False'. self.assertFalse(self.fieldcache.set_field(self.testcoll1, self.field1)) self.assertFalse(self.fieldcache.set_field(self.testcoll1, self.field1)) self.assertEqual(self.get_coll_field_uri(self.testcoll1, "field1"), "test:field1") self.assertEqual(self.get_coll_field(self.testcoll1, "field2"), None) self.assertEqual(self.get_coll_uri_id(self.testcoll1, "test:field1"), "field1") self.assertEqual( self.get_coll_uri_field(self.testcoll1, "test:field2"), None) self.assertEqual(self.get_coll_property_uris(self.testcoll1), {"test:field1"}) self.assertEqual(self.get_coll_property_uris(self.testcoll2), set()) return def test_empty_cache_2(self): self.fieldcache.set_field(self.testcoll1, self.field1) self.assertIsNotNone( self.fieldcache.remove_field(self.testcoll1, "field1")) self.assertIsNone( self.fieldcache.remove_field(self.testcoll1, "field1")) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll1)), []) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll2)), []) return def test_flush_cache(self): self.fieldcache.set_field(self.testcoll1, self.field1) self.assertTrue(self.fieldcache.flush_cache(self.testcoll1)) self.assertIsNone( self.fieldcache.remove_field(self.testcoll1, "field1")) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll1)), []) self.assertEqual(list(self.fieldcache.get_all_fields(self.testcoll2)), []) self.assertTrue(self.fieldcache.flush_cache(self.testcoll1)) self.assertFalse(self.fieldcache.flush_cache(self.testcoll1)) return def test_get_fields_by_uri(self): self.create_test_field_entities() self.assertEqual( self.fieldcache.get_field_from_uri(self.testcoll1, "test:field1").get_id(), "field1") self.assertEqual( self.fieldcache.get_field_from_uri(self.testcoll1, "test:field11").get_id(), "field11") self.assertEqual( self.fieldcache.get_field_from_uri(self.testcoll1, "test:field111").get_id(), "field111") self.assertEqual( self.fieldcache.get_field_from_uri(self.testcoll1, "test:field2").get_id(), "field2") return def test_get_all_fields_scope_coll(self): self.create_test_field_entities() field_ids = set( f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1)) self.assertEqual(field_ids, self.expect_coll_field_ids) field_ids = set( f.get_id() for f in self.fieldcache.get_all_fields(self.testcoll1)) self.assertEqual(field_ids, self.expect_coll_field_ids) return def test_get_all_fields_scope_all(self): self.create_test_field_entities() field_ids = set(f.get_id() for f in self.fieldcache.get_all_fields( self.testcoll1, altscope="all")) self.assertEqual(field_ids, self.expect_all_field_ids) return def test_get_superproperty_fields(self): self.create_test_field_entities() def get_superproperty_uris(property_uri): sf_entities = self.fieldcache.get_superproperty_fields( self.testcoll1, property_uri) sp_uris = [sf.get_property_uri() for sf in sf_entities] return set(sp_uris) self.assertEqual(get_superproperty_uris("test:field1"), set()) self.assertEqual(get_superproperty_uris("test:field11"), {"test:field1"}) self.assertEqual(get_superproperty_uris("test:field111"), {"test:field1", "test:field11"}) self.assertEqual(get_superproperty_uris("test:field2"), set({})) return def test_get_subproperty_fields(self): self.create_test_field_entities() def get_subproperty_uris(property_uri): sf_entities = self.fieldcache.get_subproperty_fields( self.testcoll1, property_uri) sp_uris = [sf.get_property_uri() for sf in sf_entities] return set(sp_uris) self.assertEqual(get_subproperty_uris("test:field1"), {"test:field11", "test:field111"}) self.assertEqual(get_subproperty_uris("test:field11"), {"test:field111"}) self.assertEqual(get_subproperty_uris("test:field111"), set()) self.assertEqual(get_subproperty_uris("test:field2"), set()) return def test_update_superproperty(self): self.create_test_field_entities() def get_superproperty_uris(property_uri): sf_entities = self.fieldcache.get_superproperty_fields( self.testcoll1, property_uri) sp_uris = [sf.get_property_uri() for sf in sf_entities] return set(sp_uris) self.assertEqual(get_superproperty_uris("test:field1"), set()) self.assertEqual(get_superproperty_uris("test:field11"), {"test:field1"}) self.assertEqual(get_superproperty_uris("test:field111"), {"test:field1", "test:field11"}) self.assertEqual(get_superproperty_uris("test:field2"), set()) # Update super/sub-type self.fieldcache.remove_field(self.testcoll1, "field11") self.fieldcache.set_field(self.testcoll1, self.field11) # Re-check supertypes self.assertEqual(get_superproperty_uris("test:field1"), set()) self.assertEqual(get_superproperty_uris("test:field11"), {"test:field1"}) self.assertEqual(get_superproperty_uris("test:field111"), {"test:field1", "test:field11"}) self.assertEqual(get_superproperty_uris("test:field2"), set()) return def test_update_subproperty(self): self.create_test_field_entities() def get_subproperty_uris(property_uri): sf_entities = self.fieldcache.get_subproperty_fields( self.testcoll1, property_uri) sp_uris = [sf.get_property_uri() for sf in sf_entities] return set(sp_uris) self.assertEqual(get_subproperty_uris("test:field1"), {"test:field11", "test:field111"}) self.assertEqual(get_subproperty_uris("test:field11"), {"test:field111"}) self.assertEqual(get_subproperty_uris("test:field111"), set()) self.assertEqual(get_subproperty_uris("test:field2"), set()) # Update super/sub-property self.fieldcache.remove_field(self.testcoll1, "field11") self.fieldcache.set_field(self.testcoll1, self.field11) # Re-check subproperties self.assertEqual(get_subproperty_uris("test:field1"), {"test:field11", "test:field111"}) self.assertEqual(get_subproperty_uris("test:field11"), {"test:field111"}) self.assertEqual(get_subproperty_uris("test:field111"), set()) self.assertEqual(get_subproperty_uris("test:field2"), set()) return
def setUp(self): self.filepath = "%s/testdatafile.md" % TestBaseDir self.fileuri = "file://" + self.filepath self.imagepath = "%s/test-image.jpg" % TestBaseDir self.imageuri = "file://" + self.imagepath init_annalist_test_site() init_annalist_test_coll() self.testsite = Site(TestBaseUri, TestBaseDir) self.testcoll = Collection(self.testsite, "testcoll") # Populate collection with linked record types, views and lists # Types self.test_upl_type = RecordType.create(self.testcoll, "testupltype", test_upload_type_create_values) self.test_ref_type = RecordType.create( self.testcoll, "testreftype", test_reference_type_create_values) self.test_image_type = RecordType.create( self.testcoll, "testimgtype", test_image_type_create_values) # Views self.test_upl_file_view = RecordView.create( self.testcoll, "testuplfileview", test_upload_file_view_create_values) self.test_upl_image_view = RecordView.create( self.testcoll, "testuplimageview", test_upload_image_view_create_values) self.test_ref_file_view = RecordView.create( self.testcoll, "testrefview", test_reference_view_create_values) self.test_ref_image_view = RecordView.create( self.testcoll, "testimgrefview", test_image_ref_view_create_values) self.test_image_view = RecordView.create( self.testcoll, "testimgview", test_image_view_create_values) # Fields self.test_upl_file_field = RecordField.create( self.testcoll, "Test_upload_file", test_upload_file_field_create_values) self.test_upl_image_field = RecordField.create( self.testcoll, "Test_upload_image", test_upload_image_field_create_values) self.test_ref_file_field = RecordField.create( self.testcoll, "Test_reference", test_reference_field_create_values) self.test_ref_image_field = RecordField.create( self.testcoll, "Test_image_ref", test_image_ref_field_create_values) self.test_image_field = RecordField.create( self.testcoll, "Test_image", test_image_field_create_values) # Create data records for testing import and references: test_entity_ids = ("test1", "test2") test_entity_ids = ("test1", ) self.test_upl_type_info = EntityTypeInfo(self.testcoll, "testupltype", create_typedata=True) for entity_id in test_entity_ids: self.test_upl_type_info.create_entity( entity_id, test_imp_entity_create_values(entity_id)) self.test_ref_type_info = EntityTypeInfo(self.testcoll, "testreftype", create_typedata=True) for entity_id in test_entity_ids: self.test_ref_type_info.create_entity( entity_id, test_ref_entity_create_values(entity_id)) self.test_img_type_info = EntityTypeInfo(self.testcoll, "testimgtype", create_typedata=True) for entity_id in test_entity_ids: self.test_img_type_info.create_entity( entity_id, test_img_entity_create_values(entity_id)) # 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 create_subproperty_list_field_view_entity(self): # Create list field using superproperty self.test_sup_list = RecordField.create( self.testcoll, "Test_sup_list", { ANNAL.CURIE.type: "annal:Field", RDFS.CURIE.label: "List using superproperty URI", RDFS.CURIE.comment: "List using superproperty URI", ANNAL.CURIE.field_render_type: "_enum_render_type/Group_Seq_Row", ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct", ANNAL.CURIE.field_value_type: "annal:Test_sup_list", ANNAL.CURIE.field_entity_type: "test:testtype", ANNAL.CURIE.placeholder: "(Test_sup_list)", ANNAL.CURIE.property_uri: "test:superprop_list_uri", ANNAL.CURIE.field_placement: "small:0,12", ANNAL.CURIE.field_fields: [{ ANNAL.CURIE.field_id: "_field/Test_sup_field", ANNAL.CURIE.field_placement: "small:0,12" }], ANNAL.CURIE.repeat_label_add: "Add sup entity", ANNAL.CURIE.repeat_label_delete: "Remove sup entity" }) self.assertTrue(self.test_sup_list is not None) # Create list field using subproperty and declaring superproperty self.test_sub_list = RecordField.create( self.testcoll, "Test_sub_list", { ANNAL.CURIE.type: "annal:Field", RDFS.CURIE.label: "List using superproperty URI", RDFS.CURIE.comment: "List using superproperty URI", ANNAL.CURIE.field_render_type: "_enum_render_type/Group_Seq_Row", ANNAL.CURIE.field_value_mode: "_enum_value_mode/Value_direct", ANNAL.CURIE.field_value_type: "annal:Test_sub_list", ANNAL.CURIE.field_entity_type: "test:testtype", ANNAL.CURIE.placeholder: "(Test_sub_list)", ANNAL.CURIE.property_uri: "test:subprop_list_uri", ANNAL.CURIE.superproperty_uri: [{ "@id": "test:superprop_list_uri" }], ANNAL.CURIE.field_placement: "small:0,12", ANNAL.CURIE.field_fields: [{ ANNAL.CURIE.field_id: "_field/Test_sub_field", ANNAL.CURIE.field_placement: "small:0,12" }], ANNAL.CURIE.repeat_label_add: "Add sub entity", ANNAL.CURIE.repeat_label_delete: "Remove sub entity" }) self.assertTrue(self.test_sub_list is not None) # Create test view using superproperty self.test_view = RecordView.create( self.testcoll, "testlistview", { ANNAL.CURIE.type: "annal:View", ANNAL.CURIE.uri: "test:listview", RDFS.CURIE.label: "Test listview label", RDFS.CURIE.comment: "Test listview comment", ANNAL.CURIE.view_entity_type: "test:testtype", ANNAL.CURIE.view_fields: [{ ANNAL.CURIE.field_id: layout.FIELD_TYPEID + "/Entity_id", ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }, { ANNAL.CURIE.field_id: layout.FIELD_TYPEID + "/Test_sup_list", ANNAL.CURIE.field_placement: "small:0,12;medium:0,6" }] }) self.assertTrue(self.test_view is not None) # Create test entity using list and item subproperty URIs self.testlistentity_data = EntityData.create( self.testdata, "testlistentity", entitydata_create_values("testlistentity", type_id="testtype", type_uri="test:testtype", extra_fields={ "test:subprop_list_uri": [{ "test:subprop_uri": "Test field 1 value" }, { "test:subprop_uri": "Test field 2 value" }] })) self.assertTrue(self.testlistentity_data is not None) return