def initialize_coll_data(src_data_dir, tgt_coll):
"""
Initialize data in the specified target collection using definitions in
the specified source directory. This is used for copying installable
data collections from the Annalist installed software into the site
data area.
returns list of error messages; an empty list indicates success.
"""
tgt_data_dir, data_file = tgt_coll._dir_path()
log.info("Copy Annalist collection data from %s to %s"%(src_data_dir, tgt_data_dir))
for sdir in layout.DATA_VOCAB_DIRS: # Don't copy user permissions
if os.path.isdir(os.path.join(src_data_dir, sdir)):
log.info("- %s -> %s"%(sdir, tgt_data_dir))
Site.replace_site_data_dir(tgt_coll, sdir, src_data_dir)
# Copy entity data to target collection.
expand_entitydata = os.path.join(src_data_dir, "entitydata" )
if os.path.isdir(expand_entitydata):
log.info("- Copy entitydata/...")
for edir in os.listdir(expand_entitydata):
if os.path.isdir(os.path.join(expand_entitydata, edir)):
log.info("- %s -> %s"%(edir, tgt_data_dir))
Site.replace_site_data_dir(tgt_coll, edir, expand_entitydata)
# Generate initial JSON-LD context data
tgt_coll.flush_all_caches()
tgt_coll.generate_coll_jsonld_context()
return []
def initialize_coll_data(src_data_dir, tgt_coll):
"""
Initialize data in the specified target collection using definitions in
the specified source directory. This is used for copying installable
data collections from the Annalist installed software into the site
data area.
returns list of error messages; an empty list indicates success.
"""
tgt_data_dir, data_file = tgt_coll._dir_path()
log.info("Copy Annalist collection data from %s to %s"%(src_data_dir, tgt_data_dir))
for sdir in layout.DATA_VOCAB_DIRS: # Don't copy user permissions
expand_sdir = os.path.join(src_data_dir, sdir)
if os.path.isdir(expand_sdir):
log.info("- %s -> %s"%(sdir, tgt_data_dir))
Site.replace_site_data_dir(tgt_coll, sdir, src_data_dir)
# Copy entity data to target collection.
#
# @TODO: This is hacky: it would be cleaner if the source directory were just
# an exact copy of what ends up in the target collection directory.
# Currently, a directory "entitydata" in the source data tree is used
# for all user data directories and entities.
# (cf. data/Annalist_schema)
#
expand_sdir = os.path.join(src_data_dir, "entitydata" )
expand_tdir = os.path.join(
tgt_data_dir, layout.META_COLL_REF+layout.COLL_ENTITYDATA_PATH
)
if os.path.isdir(expand_sdir):
log.info("- %s -> %s"%(sdir, expand_tdir))
replacetree(expand_sdir, expand_tdir)
# Generate initial JSON-LD context data
tgt_coll.generate_coll_jsonld_context()
return []
def am_createsite(annroot, userhome, options):
"""
Create Annalist empty site data.
annroot is the root directory for the Annalist software installation.
userhome is the home directory for the host system user issuing the command.
options contains options parsed from the command line.
returns 0 if all is well, or a non-zero status code.
This value is intended to be used as an exit status code
for the calling program.
"""
status = am_errors.AM_SUCCESS
sitesettings = am_get_site_settings(annroot, userhome, options)
if not sitesettings:
print("Settings not found (%s)"%(options.configuration), file=sys.stderr)
return am_errors.AM_NOSETTINGS
if len(options.args) > 0:
print(
"Unexpected arguments for %s: (%s)"%
(options.command, " ".join(options.args)),
file=sys.stderr
)
return am_errors.AM_UNEXPECTEDARGS
site_layout = layout.Layout(sitesettings.BASE_DATA_DIR)
sitebasedir = site_layout.SITE_PATH
sitebaseurl = "/annalist/" # @@TODO: figure more robust way to define this
# --- If old site exists and --force option given, remove it
if os.path.exists(os.path.join(sitebasedir, site_layout.SITEDATA_DIR)):
if options.force:
print("Removing old Annalist site at %s"%(sitebasedir))
log.info("rmtree: %s"%(sitebasedir))
removetree(sitebasedir)
else:
print(
"Old data already exists at %s (use --force or -f to overwrite)"%
(sitebasedir), file=sys.stderr
)
return am_errors.AM_EXISTS
# --- Initialize empty site data in target directory
print("Initializing Annalist site in %s"%(sitebasedir))
site = Site.create_empty_site_data(
sitebaseurl, sitebasedir,
label="Annalist site (%s configuration)"%options.configuration,
description="Annalist %s site metadata and site-wide values."%options.configuration
)
sitedata = site.site_data_collection()
Site.create_site_readme(site)
site_data_src = os.path.join(annroot, "annalist/data/sitedata") # @@TODO: more robust definition
site_data_tgt, site_data_file = sitedata._dir_path()
print("Copy Annalist site data")
print("from %s"%site_data_src)
for sdir in layout.COLL_DIRS:
print("- %s -> %s"%(sdir, site_data_tgt))
Site.replace_site_data_dir(sitedata, sdir, site_data_src)
print("Generating %s"%(site_layout.SITEDATA_CONTEXT_DIR))
sitedata.generate_coll_jsonld_context()
print("Now run 'annalist-manager initialize' to create site admin database")
return status
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.sitedata = SiteData(self.testsite)
self.testcoll = Collection(self.testsite, "testcoll")
self.layout = ({
'enum_field_placement_dir': layout.ENUM_FIELD_PLACEMENT_DIR,
'enum_list_type_dir': layout.ENUM_LIST_TYPE_DIR,
'enum_render_type_dir': layout.ENUM_RENDER_TYPE_DIR,
'enum_value_type_dir': layout.ENUM_VALUE_TYPE_DIR,
'enum_value_mode_dir': layout.ENUM_VALUE_MODE_DIR,
'field_typeid': layout.FIELD_TYPEID,
'group_typeid': layout.GROUP_TYPEID,
'list_typeid': layout.LIST_TYPEID,
'type_typeid': layout.TYPE_TYPEID,
'user_typeid': layout.USER_TYPEID,
'view_typeid': layout.VIEW_TYPEID,
'vocab_typeid': layout.VOCAB_TYPEID,
'field_dir': layout.FIELD_DIR,
'group_dir': layout.GROUP_DIR,
'list_dir': layout.LIST_DIR,
'type_dir': layout.TYPE_DIR,
'user_dir': layout.USER_DIR,
'view_dir': layout.VIEW_DIR,
'vocab_dir': layout.VOCAB_DIR
})
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.coll1 = collection_values(coll_id="coll1")
self.collnewmeta = collection_create_values(coll_id="new")
self.collnew = collection_values(coll_id="new")
return
def collbib_create_data(site):
bibcoll = Site.initialize_bib_data(site,
settings.SITE_SRC_ROOT+"/annalist/data/bibdata",
# label="Bibliographic definitions",
# description="Bibliographic definitions for testing"
)
return
def create_test_coll_inheriting(base_coll_id=None,
coll_id="testcoll",
type_id="testtype"):
"""
Similar to init_annalist_test_coll, but collection also
inherits from named collection.
"""
testsite = Site(TestBaseUri, TestBaseDir)
basecoll = Collection.load(testsite, base_coll_id)
if not basecoll:
msg = "Base collection %s not found" % base_coll_id
log.warning(msg)
assert False, msg
testcoll = Collection.create(testsite, coll_id,
collection_create_values(coll_id))
testcoll.set_alt_entities(basecoll)
testcoll._save()
testtype = RecordType.create(testcoll, type_id,
recordtype_create_values(coll_id, type_id))
testdata = RecordTypeData.create(testcoll, type_id, {})
teste = EntityData.create(
testdata, "entity1",
entitydata_create_values(testcoll, testtype, "entity1"))
testcoll.generate_coll_jsonld_context()
return testcoll
def init_annalist_named_test_coll(base_coll_id=None,
coll_id="testcoll",
type_id="testtype"):
"""
Similar to init_annalist_test_coll, but collection also installs and
inherits from named collection definitions.
"""
# @@TODO: DRY: use create_test_coll_inheriting
# @@TODO: rename: install_create_test_coll_inheriting
log.debug("init_annalist_named_test_coll")
testsite = Site(TestBaseUri, TestBaseDir)
namedcoll = install_annalist_named_coll(base_coll_id)
testcoll = Collection.create(testsite, coll_id,
collection_create_values(coll_id))
testcoll.set_alt_entities(namedcoll)
testcoll._save()
testtype = RecordType.create(testcoll, type_id,
recordtype_create_values(coll_id, type_id))
testdata = RecordTypeData.create(testcoll, type_id, {})
teste = EntityData.create(
testdata, "entity1",
entitydata_create_values(testcoll, testtype, "entity1"))
testcoll.generate_coll_jsonld_context()
return testcoll
def init_annalist_test_site():
log.debug("init_annalist_test_site")
copySitedata(
settings.SITE_SRC_ROOT+"/sampledata/testinit/"+test_layout.SITE_DIR,
settings.SITE_SRC_ROOT+"/annalist/data/sitedata",
TestBaseDir)
testsite = Site(TestBaseUri, TestBaseDir)
testsite.generate_site_jsonld_context()
# Reset id generator counters
EntityData._last_id = 0
RecordType._last_id = 0
RecordView._last_id = 0
RecordList._last_id = 0
RecordField._last_id = 0
AnnalistUser._last_id = 0
return testsite
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):
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 setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll",
collection_create_values("testcoll"))
self.testtype = RecordType.create(self.testcoll, "testtype",
recordtype_create_values("testtype"))
self.testdata = RecordTypeData.create(self.testcoll, "testtype", {})
# Create view with duplicate field id
self.viewdata = recordview_create_values(view_id="DupField_view")
recordview_values_add_field(self.viewdata,
field_id="Entity_comment",
field_placement="small:0,12")
recordview_values_add_field(self.viewdata,
field_id="Entity_comment",
field_property_uri="rdfs:comment_alt",
field_placement="small:0,12")
self.testview = RecordView.create(self.testcoll, "DupField_view",
self.viewdata)
# 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):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll",
collection_create_values("testcoll"))
self.testtype = RecordType.create(
self.testcoll, "testtype",
recordtype_create_values("testcoll", "testtype"))
self.testtype2 = RecordType.create(
self.testcoll, "testtype2",
recordtype_create_values("testcoll", "testtype2"))
self.testdata = RecordTypeData.create(self.testcoll, "testtype", {})
self.testdata2 = RecordTypeData.create(self.testcoll, "testtype2", {})
e1 = self._create_entity_data("entity1")
e2 = self._create_entity_data("entity2")
e3 = self._create_entity_data("entity3")
e4 = EntityData.create(
self.testdata2, "entity4",
entitydata_create_values("entity4", type_id="testtype2"))
self.type_ids = get_site_types_linked("testcoll")
self.type_ids.append(
FieldChoice("testtype",
label="RecordType testcoll/testtype",
link=recordtype_url("testcoll", "testtype")))
self.list_ids = get_site_lists_linked("testcoll")
# 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 init_annalist_test_site():
log.debug("init_annalist_test_site")
copySitedata(
settings.SITE_SRC_ROOT + "/sampledata/testinit/" +
test_layout.SITE_DIR,
settings.SITE_SRC_ROOT + "/annalist/data/sitedata", TestBaseDir)
testsite = Site(TestBaseUri, TestBaseDir)
testsite.generate_site_jsonld_context()
# Reset id generator counters
EntityData._last_id = 0
RecordType._last_id = 0
RecordView._last_id = 0
RecordList._last_id = 0
RecordField._last_id = 0
AnnalistUser._last_id = 0
return testsite
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection(self.testsite, "testcoll")
self.testtype = RecordType(self.testcoll, "testtype")
self.testdata = RecordTypeData(self.testcoll, "testtype")
return
def test_CreateDevelSiteData(self):
copySitedata(
settings.SITE_SRC_ROOT + "/sampledata/init/" +
test_layout.SITE_DIR,
settings.SITE_SRC_ROOT + "/annalist/sitedata", TestBaseDir)
develsite = Site("http://localhost:8000/annalist/", TestBaseDir)
coll123_create_data(develsite)
return
def collbib_create_data(site):
bibcoll = Site.initialize_bib_data(
site,
settings.SITE_SRC_ROOT + "/annalist/data/bibdata",
# label="Bibliographic definitions",
# description="Bibliographic definitions for testing"
)
return
def test_site_init(self):
s = Site(TestBaseUri, TestBaseDir)
self.assertEqual(s._entitytype, ANNAL.CURIE.Site)
self.assertEqual(s._entityfile, layout.SITE_META_FILE)
self.assertEqual(s._entityid, layout.SITEDATA_ID)
self.assertEqual(s._entityurl, TestBaseUri + "/")
self.assertEqual(s._entitydir, TestBaseDir + "/")
self.assertEqual(s._values, None)
return
def am_get_site(sitesettings):
"""
Get site object corresponding to supplied settings
"""
site_layout = Layout(sitesettings.BASE_DATA_DIR)
site_dir = site_layout.SITE_PATH
site_uri = "annalist_site:"
site = Site(site_uri, site_dir)
return site
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll",
collection_create_values("testcoll"))
# Login and permissions
create_test_user(
self.testsite.site_data_collection(),
# 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
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection(self.testsite, "testcoll")
self.coll1 = collection_values("coll1")
self.testcoll_add = collection_create_values("testcoll")
self.type1_add = recordtype_create_values("testcoll", "type1")
self.type1 = recordtype_read_values("testcoll", "type1")
self.type2_add = recordtype_create_values("testcoll", "type2")
self.type2 = recordtype_read_values("testcoll", "type2")
self.view1_add = recordview_create_values("testcoll", "view1")
self.view1 = recordview_read_values("testcoll", "view1")
self.view2_add = recordview_create_values("testcoll", "view2")
self.view2 = recordview_read_values("testcoll", "view2")
self.list1_add = recordlist_create_values("testcoll", "list1")
self.list1 = recordlist_read_values("testcoll", "list1")
self.list2_add = recordlist_create_values("testcoll", "list2")
self.list2 = recordlist_read_values("testcoll", "list2")
return
def install_annalist_named_coll(coll_id):
coll_src_dir = installable_collections[coll_id]['data_dir']
site = Site(TestBaseUri, TestBaseDir)
# Install collection now
src_dir = os.path.join(settings.SITE_SRC_ROOT, "annalist/data", coll_src_dir)
log.debug("Installing collection '%s' from data directory '%s'"%(coll_id, src_dir))
coll_metadata = installable_collections[coll_id]['coll_meta']
date_time_now = datetime.datetime.now().replace(microsecond=0)
coll_metadata[ANNAL.CURIE.comment] = (
"Initialized at %s by `annalist.tests.init_tests.install_annalist_named_coll`"%
date_time_now.isoformat()
)
coll = site.add_collection(coll_id, coll_metadata)
msgs = initialize_coll_data(src_dir, coll)
if msgs:
for msg in msgs:
log.warning(msg)
assert False, "\n".join(msgs)
return coll
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
# self.user = User.objects.create_user('testuser', '*****@*****.**', 'testpassword')
# self.user.save()
# self.client = Client(HTTP_HOST=TestHost)
# Login and permissions
create_test_user(None, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
create_user_permissions(
self.testsite.site_data_collection(), "testuser",
user_permissions=
[ "VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"
, "CREATE_COLLECTION", "DELETE_COLLECTION"
]
)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.uri = reverse("AnnalistSiteView")
self.homeuri = reverse("AnnalistHomeView")
self.profileuri = reverse("AnnalistProfileView")
# Login and permissions
create_test_user(None, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
create_user_permissions(
self.testsite.site_data_collection(), "testuser",
user_permissions=
[ "VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"
, "CREATE_COLLECTION", "DELETE_COLLECTION"
]
)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection(self.testsite, "testcoll")
# self.tokenset_context = self._make_test_context(
# ["aa", "bb", "cc"], repeat_prefix="tokprefix_"
# )
self.intvalue_context = self._make_test_context(
42, repeat_prefix="intprefix_")
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection(self.testsite, "testcoll")
self.testdata = RecordTypeData(self.testcoll, "testtype")
# 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 install_annalist_named_coll(coll_id):
coll_src_dir = installable_collections[coll_id]['data_dir']
site = Site(TestBaseUri, TestBaseDir)
# Install collection now
src_dir = os.path.join(settings.SITE_SRC_ROOT, "annalist/data",
coll_src_dir)
log.debug("Installing collection '%s' from data directory '%s'" %
(coll_id, src_dir))
coll_metadata = installable_collections[coll_id]['coll_meta']
date_time_now = datetime.datetime.now().replace(microsecond=0)
coll_metadata[ANNAL.CURIE.comment] = (
"Initialized at %s by `annalist.tests.init_tests.install_annalist_named_coll`"
% date_time_now.isoformat())
coll = site.add_collection(coll_id, coll_metadata)
msgs = initialize_coll_data(src_dir, coll)
if msgs:
for msg in msgs:
log.warning(msg)
assert False, "\n".join(msgs)
return coll
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'testpassword',
first_name="Test", last_name="User"
)
self.user.save()
self.client = Client(HTTP_HOST=TestHost)
self.uri = reverse("AnnalistProfileView")
self.homeuri = reverse("AnnalistHomeView")
return
def test_collection_init(self):
log.debug("test_collection_init: TestBaseUri %s, TestBaseDir %s"%(TestBaseUri,TestBaseDir))
s = Site(TestBaseUri, TestBaseDir)
c = Collection(s, "testcoll")
self.assertEqual(c._entitytype, ANNAL.CURIE.Collection)
self.assertEqual(c._entityfile, layout.COLL_META_REF)
self.assertEqual(c._entityref, layout.META_COLL_REF)
self.assertEqual(c._entityid, "testcoll")
self.assertEqual(c._entityurl, TestHostUri + collection_view_url(coll_id="testcoll"))
self.assertEqual(c._entitydir, collection_dir(coll_id="testcoll"))
self.assertEqual(c._values, None)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.coll1 = Collection.load(self.testsite, "coll1")
self.view_url = collection_view_url(coll_id="coll1")
self.edit_url = collection_edit_url(coll_id="coll1")
self.continuation = "?" + continuation_url_param(self.edit_url)
# Login and permissions
create_test_user(self.coll1, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
return
def setUp(self):
# Set up basic site data
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll", collection_create_values("testcoll"))
self.testtype = RecordType.create(self.testcoll, "testtype", recordtype_create_values("testtype"))
self.testdata = RecordTypeData.create(self.testcoll, "testtype", {})
# 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):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll",
collection_create_values("testcoll"))
self.user = User.objects.create_user('testuser',
'*****@*****.**',
'testpassword')
self.user.save()
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******",
password="******")
self.assertTrue(loggedin)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.coll1 = Collection.load(self.testsite, "coll1")
self.view_url = collection_view_url(coll_id="coll1")
self.edit_url = collection_edit_url(coll_id="coll1")
self.continuation = "?" + continuation_url_param(self.edit_url)
# Login and permissions
create_test_user(self.coll1, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******",
password="******")
self.assertTrue(loggedin)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll", collection_create_values("testcoll"))
# Login and permissions
create_test_user(
self.testsite.site_data_collection(),
# 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
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 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 site_create_data(site_base_uri, target_subdir):
"""
Create site data in `target_subdir`...
@@NOTE: due to the way EntityRoot is defenfensively coded, all test data is created
under settings.BASE_SITE_DIR, and the supplied 'target_subdir' parameter is ignored.
"""
# target_dir = os.path.join(settings.SAMPLEDATA_DIR, target_subdir)
target_dir = settings.BASE_SITE_DIR
site = Site.initialize_site_data(
site_base_uri, target_dir,
settings.SITE_SRC_ROOT + "/annalist/data/sitedata",
label="Annalist data notebook test site",
description="Annalist test site metadata and site-wide values."
)
return site
def site_create_data(site_base_uri, target_subdir):
"""
Create site data in `target_subdir`...
@@NOTE: due to the way EntityRoot is defenfensively coded, all test data is created
under settings.BASE_SITE_DIR, and the supplied 'target_subdir' parameter is ignored.
"""
# target_dir = os.path.join(settings.SAMPLEDATA_DIR, target_subdir)
target_dir = settings.BASE_SITE_DIR
site = Site.initialize_site_data(
site_base_uri,
target_dir,
settings.SITE_SRC_ROOT + "/annalist/data/sitedata",
label="Annalist data notebook test site",
description="Annalist test site metadata and site-wide values.")
return site
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 setUp(self):
init_annalist_test_site()
self.imagename = "test-image.jpg"
self.imagepath = "%s/%s"%(TestBaseDir, self.imagename)
self.imageuri = "file://"+self.imagepath
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll", collection_create_values("testcoll"))
self.img_type = RecordType.create(self.testcoll, "img_type", recordtype_create_values("img_type"))
self.img_data = RecordTypeData.create(self.testcoll, "img_type", {})
self.ref_type = RecordType.create(self.testcoll, "ref_type", recordtype_create_values("ref_type"))
self.ref_data = RecordTypeData.create(self.testcoll, "ref_type", {})
# 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):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
# self.user = User.objects.create_user('testuser', '*****@*****.**', 'testpassword')
# self.user.save()
# self.client = Client(HTTP_HOST=TestHost)
# Login and permissions
create_test_user(None, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
create_user_permissions(
self.testsite.site_data_collection(), "testuser",
user_permissions=
[ "VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"
, "CREATE_COLLECTION", "DELETE_COLLECTION"
]
)
return
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.uri = reverse("AnnalistSiteView")
self.homeuri = reverse("AnnalistHomeView")
self.profileuri = reverse("AnnalistProfileView")
# Login and permissions
create_test_user(None, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
create_user_permissions(
self.testsite.site_data_collection(), "testuser",
user_permissions=
[ "VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"
, "CREATE_COLLECTION", "DELETE_COLLECTION"
]
)
return
def setUp(self):
init_annalist_test_site()
init_annalist_test_coll()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection(self.testsite, "testcoll")
self.coll1 = collection_values("coll1")
self.testcoll_add = collection_create_values("testcoll")
self.type1_add = recordtype_create_values("testcoll", "type1")
self.type1 = recordtype_read_values("testcoll", "type1")
self.type2_add = recordtype_create_values("testcoll", "type2")
self.type2 = recordtype_read_values("testcoll", "type2")
self.view1_add = recordview_create_values("testcoll", "view1")
self.view1 = recordview_read_values("testcoll", "view1")
self.view2_add = recordview_create_values("testcoll", "view2")
self.view2 = recordview_read_values("testcoll", "view2")
self.list1_add = recordlist_create_values("testcoll", "list1")
self.list1 = recordlist_read_values("testcoll", "list1")
self.list2_add = recordlist_create_values("testcoll", "list2")
self.list2 = recordlist_read_values("testcoll", "list2")
return
class CollectionTest(AnnalistTestCase):
"""
Tests for Collection object interface
"""
def setUp(self):
init_annalist_test_site()
init_annalist_test_coll()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection(self.testsite, "testcoll")
self.coll1 = collection_values("coll1")
self.testcoll_add = collection_create_values("testcoll")
self.type1_add = recordtype_create_values("testcoll", "type1")
self.type1 = recordtype_read_values("testcoll", "type1")
self.type2_add = recordtype_create_values("testcoll", "type2")
self.type2 = recordtype_read_values("testcoll", "type2")
self.view1_add = recordview_create_values("testcoll", "view1")
self.view1 = recordview_read_values("testcoll", "view1")
self.view2_add = recordview_create_values("testcoll", "view2")
self.view2 = recordview_read_values("testcoll", "view2")
self.list1_add = recordlist_create_values("testcoll", "list1")
self.list1 = recordlist_read_values("testcoll", "list1")
self.list2_add = recordlist_create_values("testcoll", "list2")
self.list2 = recordlist_read_values("testcoll", "list2")
return
def tearDown(self):
# resetSitedata(scope="collections")
return
@classmethod
def tearDownClass(cls):
resetSitedata()
return
def test_CollectionTest(self):
self.assertEqual(Collection.__name__, "Collection", "Check Collection class name")
return
def test_collection_init(self):
log.debug("test_collection_init: TestBaseUri %s, TestBaseDir %s"%(TestBaseUri,TestBaseDir))
s = Site(TestBaseUri, TestBaseDir)
c = Collection(s, "testcoll")
self.assertEqual(c._entitytype, ANNAL.CURIE.Collection)
self.assertEqual(c._entityfile, layout.COLL_META_REF)
self.assertEqual(c._entityref, layout.META_COLL_REF)
self.assertEqual(c._entityid, "testcoll")
self.assertEqual(c._entityurl, TestHostUri + collection_view_url(coll_id="testcoll"))
self.assertEqual(c._entitydir, collection_dir(coll_id="testcoll"))
self.assertEqual(c._values, None)
return
def test_collection_data(self):
self.testcoll.set_values(self.testcoll_add)
cd = self.testcoll.get_values()
self.assertDictionaryMatch(cd, self.testcoll_add)
return
# User permissions
def test_get_local_user_permissions(self):
# Create local permissions
usr = AnnalistUser.create(self.testcoll, "user1", annalistuser_create_values(user_id="user1"))
# Test access to permissions defined locally in collection
ugp = self.testcoll.get_user_permissions("user1", "mailto:[email protected]")
self.assertEqual(ugp[ANNAL.CURIE.id], "user1")
self.assertEqual(ugp[ANNAL.CURIE.type_id], "_user")
self.assertEqual(ugp[RDFS.CURIE.label], "Test User")
self.assertEqual(ugp[RDFS.CURIE.comment], "User user1: permissions for Test User in collection testcoll")
self.assertEqual(ugp[ANNAL.CURIE.user_uri], "mailto:[email protected]")
self.assertEqual(ugp[ANNAL.CURIE.user_permission], ["VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG", "ADMIN"])
return
def test_get_local_user_not_defined(self):
ugp = self.testcoll.get_user_permissions("user1", "mailto:[email protected]")
self.assertIsNone(ugp)
return
def test_get_local_user_uri_mismatch(self):
usr = AnnalistUser.create(self.testcoll, "user1", annalistuser_create_values(user_id="user1"))
ugp = self.testcoll.get_user_permissions("user1", "mailto:[email protected]")
self.assertIsNone(ugp)
return
def test_get_local_user_missing_fields(self):
# E.g. what happens if user record is created through default view? Don't return value.
d = annalistuser_create_values(user_id="user1")
d.pop(ANNAL.CURIE.user_permission)
usr = AnnalistUser.create(self.testcoll, "user1", d)
ugp = self.testcoll.get_user_permissions("user1", "mailto:[email protected]")
self.assertIsNone(ugp)
return
def test_get_site_user_permissions(self):
ugp = self.testcoll.get_user_permissions("_unknown_user_perms", "annal:User/_unknown_user_perms")
self.assertEqual(ugp[ANNAL.CURIE.id], "_unknown_user_perms")
self.assertEqual(ugp[ANNAL.CURIE.type_id], "_user")
self.assertEqual(ugp[RDFS.CURIE.label], "Unknown user")
self.assertEqual(ugp[ANNAL.CURIE.user_uri], "annal:User/_unknown_user_perms")
self.assertEqual(ugp[ANNAL.CURIE.user_permission], ["VIEW"])
return
def test_get_site_user_uri_mismatch(self):
ugp = self.testcoll.get_user_permissions("_unknown_user_perms", "annal:User/_another_user")
self.assertIsNone(ugp)
return
# Record types
def test_add_type(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
typenames = { t.get_id() for t in self.testcoll.types() }
self.assertEqual(typenames, {"testtype"}|site_types)
t1 = self.testcoll.add_type("type1", self.type1_add)
t2 = self.testcoll.add_type("type2", self.type2_add)
typenames = { t.get_id() for t in self.testcoll.types() }
self.assertEqual(typenames, {"type1", "type2", "testtype"}|site_types)
return
def test_get_type(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
t1 = self.testcoll.add_type("type1", self.type1_add)
t2 = self.testcoll.add_type("type2", self.type2_add)
self.assertDictionaryMatch(self.testcoll.get_type("type1").get_values(), self.type1)
self.assertDictionaryMatch(self.testcoll.get_type("type2").get_values(), self.type2)
return
def test_remove_type(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
t1 = self.testcoll.add_type("type1", self.type1_add)
t2 = self.testcoll.add_type("type2", self.type2_add)
typenames = { t.get_id() for t in self.testcoll.types() }
self.assertEqual(typenames, {"type1", "type2", "testtype"}|site_types)
self.testcoll.remove_type("type1")
typenames = { t.get_id() for t in self.testcoll.types() }
self.assertEqual(typenames, {"type2", "testtype"}|site_types)
typenames = { t.get_id() for t in self.testcoll.types(altscope=None) }
self.assertEqual(typenames, {"type2", "testtype"})
return
def test_exists_type(self):
# Some type existence tests taking account of site data default type
self.assertTrue(RecordType.exists(self.testcoll, "testtype"))
self.assertFalse(RecordType.exists(self.testcoll, "notype"))
self.assertFalse(RecordType.exists(self.testcoll, "Default_type"))
self.assertTrue(RecordType.exists(self.testcoll, "Default_type", altscope="all"))
return
# Record views
def test_add_view(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
viewnames = { t.get_id() for t in self.testcoll.views() }
self.assertEqual(viewnames, site_views)
t1 = self.testcoll.add_view("view1", self.view1_add)
t2 = self.testcoll.add_view("view2", self.view2_add)
viewnames = { t.get_id() for t in self.testcoll.views() }
self.assertEqual(viewnames, {"view1", "view2"}|site_views)
return
def test_get_view(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
t1 = self.testcoll.add_view("view1", self.view1_add)
t2 = self.testcoll.add_view("view2", self.view2_add)
self.assertKeysMatch(self.testcoll.get_view("view1").get_values(), self.view1)
self.assertKeysMatch(self.testcoll.get_view("view2").get_values(), self.view2)
self.assertDictionaryMatch(self.testcoll.get_view("view1").get_values(), self.view1)
self.assertDictionaryMatch(self.testcoll.get_view("view2").get_values(), self.view2)
return
def test_remove_view(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
t1 = self.testcoll.add_view("view1", self.view1_add)
t2 = self.testcoll.add_view("view2", self.view2_add)
viewnames = { t.get_id() for t in self.testcoll.views() }
self.assertEqual(viewnames, {"view1", "view2"}|site_views)
self.testcoll.remove_view("view1")
viewnames = { t.get_id() for t in self.testcoll.views() }
self.assertEqual(viewnames, {"view2"}|site_views)
viewnames = { t.get_id() for t in self.testcoll.views(altscope=None) }
self.assertEqual(viewnames, {"view2"})
return
# Record lists
def test_add_list(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
listnames = { t.get_id() for t in self.testcoll.lists() }
self.assertEqual(listnames, site_lists)
t1 = self.testcoll.add_list("list1", self.list1_add)
t2 = self.testcoll.add_list("list2", self.list2_add)
listnames = { t.get_id() for t in self.testcoll.lists() }
self.assertEqual(listnames, {"list1", "list2"}|site_lists)
listnames = { t.get_id() for t in self.testcoll.lists(altscope=None) }
self.assertEqual(listnames, {"list1", "list2"})
return
def test_get_list(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
t1 = self.testcoll.add_list("list1", self.list1_add)
t2 = self.testcoll.add_list("list2", self.list2_add)
self.assertDictionaryMatch(self.testcoll.get_list("list1").get_values(), self.list1)
self.assertDictionaryMatch(self.testcoll.get_list("list2").get_values(), self.list2)
return
def test_remove_list(self):
self.testsite.add_collection("testcoll", self.testcoll_add)
t1 = self.testcoll.add_list("list1", self.list1_add)
t2 = self.testcoll.add_list("list2", self.list2_add)
listnames = { t.get_id() for t in self.testcoll.lists() }
self.assertEqual(listnames, {"list1", "list2"}|site_lists)
self.testcoll.remove_list("list1")
listnames = { t.get_id() for t in self.testcoll.lists() }
self.assertEqual(listnames, {"list2"}|site_lists)
return
# Alternative parent setting
def test_set_alt_entities_1(self):
altcoll1 = Collection(self.testsite, "altcoll1")
parents = self.testcoll.set_alt_entities(altcoll1)
parentids = [ p.get_id() for p in parents ]
self.assertEqual( parentids, ["testcoll", "altcoll1", layout.SITEDATA_ID])
return
def test_set_alt_entities_2(self):
coll_id = "altcoll1"
altcoll1 = Collection.create(self.testsite, coll_id, collection_create_values(coll_id))
parents = altcoll1.set_alt_entities(self.testcoll)
parentids = [ p.get_id() for p in parents ]
self.assertEqual( parentids, ["altcoll1", "testcoll", layout.SITEDATA_ID])
return
def test_set_alt_entities_loop(self):
altcoll1 = Collection(self.testsite, "altcoll1")
parents = self.testcoll.set_alt_entities(altcoll1)
parentids = [ p.get_id() for p in parents ]
self.assertEqual( parentids, ["testcoll", "altcoll1", layout.SITEDATA_ID])
with SuppressLogging(logging.ERROR):
with self.assertRaises(ValueError):
parents = altcoll1.set_alt_entities(self.testcoll)
return
def test_set_alt_entities_no_site(self):
altcoll1 = Collection(self.testsite, "altcoll1")
parents = self.testcoll.set_alt_entities(altcoll1)
parentids = [ p.get_id() for p in parents ]
self.assertEqual( parentids, ["testcoll", "altcoll1", layout.SITEDATA_ID])
altcoll1._altparent = None
with SuppressLogging(logging.ERROR):
with self.assertRaises(ValueError):
parents = self.testcoll.set_alt_entities(altcoll1)
return
def test_alt_parent_inherit_coll(self):
# Test inheritance of definitions from an alternative collection
# (tescoll is set up with testtype created)
coll_id = "newcoll"
newcoll = Collection.create(self.testsite, coll_id, collection_create_values(coll_id))
altparents = newcoll.set_alt_entities(self.testcoll)
parentids = [ p.get_id() for p in altparents ]
self.assertEqual(parentids, ["newcoll", "testcoll", layout.SITEDATA_ID])
self.assertTrue(RecordType.exists(newcoll, "testtype", altscope="all"))
testtype = RecordType.load(newcoll, "testtype", altscope="all")
self.assertEquals(testtype["rdfs:label"], "RecordType testcoll/testtype")
return
def test_alt_parent_inherit_site(self):
# Test inheritance of definitions from site with an alternative collection set
coll_id = "newcoll"
newcoll = Collection.create(self.testsite, coll_id, collection_create_values(coll_id))
altparents = newcoll.set_alt_entities(self.testcoll)
parentids = [ p.get_id() for p in altparents ]
self.assertEqual(parentids, ["newcoll", "testcoll", layout.SITEDATA_ID])
self.assertTrue(RecordType.exists(newcoll, "Default_type", altscope="all"))
def_type = RecordType.load(newcoll, "Default_type", altscope="all")
self.assertEquals(def_type["rdfs:label"], "Default record")
return
def test_alt_parent_inherit_user(self):
# Test inheritance of "user" scope definitions
coll_id = "newcoll"
newcoll = Collection.create(self.testsite, coll_id, collection_create_values(coll_id))
user1 = AnnalistUser.create(self.testcoll, "user1", annalistuser_create_values(user_id="user1"))
user2 = AnnalistUser.create(newcoll, "user2", annalistuser_create_values(user_id="user2"))
altparents = newcoll.set_alt_entities(self.testcoll)
parentids = [ p.get_id() for p in altparents ]
self.assertEqual(parentids, ["newcoll", "testcoll", layout.SITEDATA_ID])
self.assertFalse(AnnalistUser.exists(newcoll, "user1", altscope="user"))
self.assertTrue(AnnalistUser.exists(newcoll, "_default_user_perms", altscope="user")) # Access site data
self.assertTrue(AnnalistUser.exists(newcoll, "user2", altscope="user"))
testuser = AnnalistUser.load(newcoll, "user2", altscope="user")
self.assertEquals(testuser["rdfs:label"], "Test User")
return
class CollectionEditViewTest(AnnalistTestCase):
"""
Tests for Collection views
"""
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.coll1 = Collection.load(self.testsite, "coll1")
self.view_url = collection_view_url(coll_id="coll1")
self.edit_url = collection_edit_url(coll_id="coll1")
self.continuation = "?" + continuation_url_param(self.edit_url)
# Login and permissions
create_test_user(self.coll1, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
return
def tearDown(self):
return
@classmethod
def tearDownClass(cls):
resetSitedata()
return
def test_CollectionEditViewTest(self):
self.assertEqual(CollectionEditView.__name__, "CollectionEditView", "Check CollectionView class name")
return
def test_get_view(self):
r = self.client.get(self.view_url)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(r['location'], TestHostUri + entitydata_list_all_url(coll_id="coll1"))
return
def test_get_view_no_collection(self):
u = collection_view_url(coll_id="no_collection")
r = self.client.get(u)
self.assertEqual(r.status_code, 404)
self.assertEqual(r.reason_phrase, "Not found")
self.assertContains(r, "<p>Collection no_collection does not exist</p>", status_code=404)
return
def test_get_view_newer_version(self):
collmeta = collection_create_values(coll_id="newer_version")
self.testsite.add_collection("newer_version", collmeta, annal_ver="99.99.99")
u = collection_view_url(coll_id="newer_version")
r = self.client.get(u)
self.assertEqual(r.status_code, 500)
self.assertEqual(r.reason_phrase, "Server error")
self.assertContains(r, "created by software version 99.99.99", status_code=500)
return
def test_get_edit(self):
r = self.client.get(self.edit_url)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, "<title>Collection coll1</title>")
self.assertContains(r,
'<h2 class="page-heading">Customize collection: Collection coll1</h2>',
html=True
)
return
def test_get_edit_no_collection(self):
u = collection_edit_url(coll_id="no_collection")
r = self.client.get(u)
self.assertEqual(r.status_code, 404)
self.assertEqual(r.reason_phrase, "Not found")
return
def test_get_edit_context(self):
r = self.client.get(self.edit_url)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEquals(r.context['title'], "Collection coll1")
self.assertEquals(r.context['coll_id'], "coll1")
self.assertEquals([e.get_id() for e in r.context['types']], ["type1", "type2"])
self.assertEquals([e.get_id() for e in r.context['lists']], ["list1", "list2"])
self.assertEquals([e.get_id() for e in r.context['views']], ["view1", "view2"])
self.assertEquals(r.context['select_rows'], "6")
return
def test_post_new_type(self):
form_data = (
{ "type_new": "New"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
new_type_uri = recordtype_edit_url("new", "coll1")
self.assertEqual(r['location'], TestHostUri+new_type_uri+self.continuation)
return
def test_post_copy_type(self):
form_data = (
{ "typelist": "type1"
, "type_copy": "Copy"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
copy_type_uri = recordtype_edit_url("copy", "coll1", type_id="type1")
self.assertEqual(r['location'], TestHostUri+copy_type_uri+self.continuation)
return
def test_post_copy_type_no_selection(self):
form_data = (
{ "type_copy": "Copy"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
erroruri = self.edit_url+r"\?error_head=.*\&error_message=.*"
self.assertMatch(r['location'], TestHostUri+erroruri)
return
def test_post_edit_type(self):
form_data = (
{ "typelist": "type1"
, "type_edit": "Edit"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
edit_type_uri = recordtype_edit_url("edit", "coll1", type_id="type1")
self.assertEqual(r['location'], TestHostUri+edit_type_uri+self.continuation)
return
def test_post_edit_type_no_selection(self):
form_data = (
{ "type_edit": "Edit"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
erroruri = self.edit_url+r"\?error_head=.*\&error_message=.*"
self.assertMatch(r['location'], TestHostUri+erroruri)
return
def test_post_delete_type(self):
form_data = (
{ "typelist": "type1"
, "type_delete": "Delete"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertTemplateUsed(r, "annalist_confirm.html")
# Check confirmation form content
confirmed_action_uri = recordtype_edit_url("delete", "coll1")
self.assertContains(r, '''<form method="POST" action="'''+TestBasePath+'''/confirm/">''', status_code=200)
self.assertEqual(r.context['confirmed_action'], confirmed_action_uri)
self.assertEqual(r.context['cancel_action'], self.edit_url)
action_params = json.loads(r.context['action_params'])
self.assertEqual(action_params['type_delete'], ["Delete"])
self.assertEqual(action_params['typelist'], ["type1"])
return
def test_post_delete_type_no_selection(self):
form_data = (
{ "type_delete": "Delete"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
erroruri = self.edit_url+r"\?error_head=.*\&error_message=.*"
self.assertMatch(r['location'], TestHostUri+erroruri)
return
def test_post_migrate(self):
form_data = (
{ "migrate": "Migrate data"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
completeduri = self.edit_url+r"\?info_head=.*\&info_message=.*"
self.assertMatch(r['location'], TestHostUri+completeduri)
return
def test_post_metadata(self):
form_data = (
{ "metadata": "Collection metadata"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
metadataurl = collectiondata_view_url(coll_id="coll1", action="edit")
self.assertEqual(r['location'], TestHostUri+metadataurl+self.continuation)
return
def test_post_close(self):
form_data = (
{ "close": "Close"
})
r = self.client.post(self.edit_url, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "FOUND")
self.assertEqual(r.content, "")
self.assertEqual(r['location'], TestHostUri+site_view_url())
return
class SiteViewTest(AnnalistTestCase):
"""
Tests for Site views
"""
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.uri = reverse("AnnalistSiteView")
self.homeuri = reverse("AnnalistHomeView")
self.profileuri = reverse("AnnalistProfileView")
# Login and permissions
create_test_user(None, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
create_user_permissions(
self.testsite.site_data_collection(), "testuser",
user_permissions=
[ "VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"
, "CREATE_COLLECTION", "DELETE_COLLECTION"
]
)
return
def tearDown(self):
return
@classmethod
def setUpClass(cls):
super(SiteViewTest, cls).setUpClass()
return
@classmethod
def tearDownClass(cls):
super(SiteViewTest, cls).tearDownClass()
resetSitedata(scope="all")
return
def test_SiteViewTest(self):
self.assertEqual(SiteView.__name__, "SiteView", "Check SiteView class name")
return
def test_get(self):
# @@TODO: use reference to self.client, per
# https://docs.djangoproject.com/en/dev/topics/testing/tools/#default-test-client
r = self.client.get(self.uri)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, site_title("<title>%s</title>"))
return
def test_get_error(self):
r = self.client.get(self.uri+"?error_head=Error&error_message=Error%20presented")
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, """<h3>Error</h3>""", html=True)
self.assertContains(r, """<p class="messages">Error presented</p>""", html=True)
return
def test_get_info(self):
r = self.client.get(self.uri+"?info_head=Information&info_message=Information%20presented")
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertContains(r, """<h3>Information</h3>""", html=True)
self.assertContains(r, """<p class="messages">Information presented</p>""", html=True)
return
def test_get_home(self):
r = self.client.get(self.homeuri)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "Found")
self.assertEqual(r["location"], self.uri)
return
def test_get_no_login(self):
self.client.logout()
r = self.client.get(self.uri)
self.assertFalse(r.context["auth_create"])
self.assertFalse(r.context["auth_update"])
self.assertFalse(r.context["auth_delete"])
colls = r.context['collections']
self.assertEqual(len(colls), len(init_collection_keys))
for id in init_collections:
self.assertEqual(colls[id]["annal:id"], id)
self.assertEqual(colls[id]["annal:url"], init_collections[id]["annal:url"])
self.assertEqual(colls[id]["rdfs:label"], init_collections[id]["rdfs:label"])
# Check returned HTML (checks template logic)
# (Don't need to keep doing this as logic can be tested through context as above)
# (See: http://stackoverflow.com/questions/2257958/)
s = BeautifulSoup(r.content, "html.parser")
self.assertEqual(s.html.title.string, site_title())
homelink = s.find(class_="title-area").find(class_="name").h1.a
self.assertEqual(homelink.string, "Home")
self.assertEqual(homelink['href'], self.uri)
menuitems = s.find(class_="top-bar-section").find(class_="right").find_all("li")
self.assertEqualIgnoreWS(menuitems[0].a.string, "Login")
self.assertEqual(menuitems[0].a['href'], self.profileuri)
# Check displayed collections
trows = s.form.find_all("div", class_="tbody")
self.assertEqual(len(trows), len(init_collection_keys))
self.assertEqual(trows[0].div.div('div')[1].a.string, "_annalist_site")
self.assertEqual(trows[0].div.div('div')[1].a['href'], collection_view_url("_annalist_site"))
self.assertEqual(trows[1].div.div('div')[1].a.string, "coll1")
self.assertEqual(trows[1].div.div('div')[1].a['href'], collection_view_url("coll1"))
self.assertEqual(trows[2].div.div('div')[1].a.string, "coll2")
self.assertEqual(trows[2].div.div('div')[1].a['href'], collection_view_url("coll2"))
self.assertEqual(trows[3].div.div('div')[1].a.string, "coll3")
self.assertEqual(trows[3].div.div('div')[1].a['href'], collection_view_url("coll3"))
return
def test_get_with_login(self):
r = self.client.get(self.uri)
# Preferred way to test main view logic
self.assertTrue(r.context["auth_create"])
self.assertTrue(r.context["auth_update"])
self.assertTrue(r.context["auth_delete"])
self.assertTrue(r.context["auth_create_coll"])
self.assertTrue(r.context["auth_delete_coll"])
colls = r.context['collections']
self.assertEqual(len(colls), len(init_collection_keys))
for id in init_collections:
# First two here added in models.site.site_data()
self.assertEqual(colls[id]["id"], id)
self.assertEqual(colls[id]["url"], init_collections[id]["annal:url"])
self.assertEqual(colls[id]["annal:id"], id)
self.assertEqual(colls[id]["annal:url"], init_collections[id]["annal:url"])
self.assertEqual(colls[id]["rdfs:label"], init_collections[id]["rdfs:label"])
# Check returned HTML (checks template logic)
# (Don't need to keep doing this as logic can be tested through context as above)
# (See: http://stackoverflow.com/questions/2257958/)
s = BeautifulSoup(r.content, "html.parser")
# title and top menu
self.assertEqual(s.html.title.string, site_title())
homelink = s.find(class_="title-area").find(class_="name").h1.a
self.assertEqual(homelink.string, "Home")
self.assertEqual(homelink['href'], self.uri)
menuitems = s.find(class_="top-bar-section").find(class_="right").find_all("li")
self.assertEqualIgnoreWS(menuitems[0].a.string, "User testuser")
self.assertEqual(menuitems[0].a['href'], TestBasePath+"/profile/")
self.assertEqualIgnoreWS(menuitems[1].a.string, "Logout")
self.assertEqual(menuitems[1].a['href'], TestBasePath+"/logout/")
# Displayed colllections and check-buttons
# trows = s.form.find_all("div", class_="tbody")
trows = s.select("form > div > div > div")
self.assertEqual(len(trows), len(init_collection_keys)+4)
site_data = (
[ (1, "checkbox", "select", "_annalist_site")
, (2, "checkbox", "select", "coll1")
, (3, "checkbox", "select", "coll2")
, (4, "checkbox", "select", "coll3")
])
for i, itype, iname, ivalue in site_data:
# tcols = trows[i].find_all("div", class_="view-value")
tcols = trows[i].select("div > div > div")
self.assertEqual(tcols[0].input['type'], itype)
self.assertEqual(tcols[0].input['name'], iname)
self.assertEqual(tcols[0].input['value'], ivalue)
self.assertEqual(tcols[1].a.string, ivalue)
self.assertEqual(tcols[1].a['href'], collection_view_url(ivalue))
# buttons to view/edit/remove selected
btn_view = trows[5].select("div > input")[0]
self.assertEqual(btn_view["type"], "submit")
self.assertEqual(btn_view["name"], "view")
btn_edit = trows[5].select("div > input")[1]
self.assertEqual(btn_edit["type"], "submit")
self.assertEqual(btn_edit["name"], "edit")
btn_remove = trows[5].select("div > input")[2]
self.assertEqual(btn_remove["type"], "submit")
self.assertEqual(btn_remove["name"], "remove")
# Input fields for new collection
add_fields = trows[6].select("div > div > div")
field_id = add_fields[1].input
field_label = add_fields[2].input
self.assertEqual(field_id["type"], "text")
self.assertEqual(field_id["name"], "new_id")
self.assertEqual(field_label["type"], "text")
self.assertEqual(field_label["name"], "new_label")
# Button for new collection
btn_new = trows[7].select("div > input")[0]
self.assertEqual(btn_new["type"], "submit")
self.assertEqual(btn_new["name"], "new")
return
def test_get_site_context_resource(self):
u = reverse("AnnalistSiteResourceAccess", kwargs={"resource_ref": layout.SITE_CONTEXT_FILE})
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEqual(r["content-type"], "application/ld+json")
return
def test_get_site_image_resource(self):
self.testsite._ensure_values_loaded()
self.testsite["testimage"] = (
{ "resource_name": "test-image.jpg"
, "resource_type": "image/jpeg"
})
self.testsite._save()
u = reverse("AnnalistSiteResourceAccess", kwargs={"resource_ref": "test-image.jpg"})
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEqual(r["content-type"], "image/jpeg")
return
def test_get_site_markdown_resource(self):
self.testsite._ensure_values_loaded()
self.testsite["testdatafile"] = (
{ "resource_name": "testdatafile.md"
, "resource_type": "text/markdown"
})
self.testsite._save()
u = reverse("AnnalistSiteResourceAccess", kwargs={"resource_ref": "testdatafile.md"})
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEqual(r["content-type"], "text/markdown")
return
def test_get_site_nonexistent_resource(self):
self.testsite._ensure_values_loaded()
self.testsite["nosuchfile"] = (
{ "resource_name": "nosuch.file"
, "resource_type": "text/plain"
})
self.testsite._save()
u = reverse("AnnalistSiteResourceAccess", kwargs={"resource_ref": "nosuch.file"})
r = self.client.get(u)
self.assertEqual(r.status_code, 404)
self.assertEqual(r.reason_phrase, "Not found")
return
def test_post_add(self):
form_data = collection_new_form_data("testnew")
r = self.client.post(self.uri, form_data)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "Found")
self.assertEqual(r.content, b"")
self.assertEqual(r['location'],
TestBasePath+"/site/"
"?info_head=Action%20completed"+
"&info_message=Created%20new%20collection:%20'testnew'")
# Check site now has new colllection
r = self.client.get(self.uri)
new_collections = init_collections.copy()
new_collections["testnew"] = collection_values("testnew", hosturi=TestHostUri)
colls = r.context['collections']
for id in new_collections:
p = "[%s]"%id
# First two here added in model.site.site_data for view template
self.assertEqualPrefix(colls[id]["id"], id, p)
self.assertEqualPrefix(colls[id]["url"], new_collections[id]["annal:url"], p)
self.assertEqualPrefix(colls[id]["annal:id"], id, p)
self.assertEqualPrefix(colls[id]["annal:url"], new_collections[id]["annal:url"], p)
self.assertEqualPrefix(colls[id]["rdfs:label"], new_collections[id]["rdfs:label"], p)
# Check new collection has admin permissions for creator
new_coll = Collection(self.testsite, "testnew")
testuser_perms = new_coll.get_user_permissions("testuser", "mailto:testuser@%s"%TestHost)
expect_perms = ["VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG", "ADMIN"]
expect_descr = "User testuser: permissions for Test User in collection testnew"
self.assertEqual(testuser_perms[ANNAL.CURIE.id], "testuser")
self.assertEqual(testuser_perms[RDFS.CURIE.label], "Test User")
self.assertEqual(testuser_perms[RDFS.CURIE.comment], expect_descr)
self.assertEqual(testuser_perms[ANNAL.CURIE.user_uri], "mailto:testuser@%s"%TestHost)
self.assertEqual(testuser_perms[ANNAL.CURIE.user_permission], expect_perms)
return
def test_post_remove(self):
form_data = collection_remove_form_data(["coll1", "coll3"])
r = self.client.post(self.uri, form_data)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertTemplateUsed(r, "annalist_confirm.html")
# Returns confirmation form: check
self.assertContains(r, '''<form method="POST" action="'''+TestBasePath+'''/confirm/">''', status_code=200)
self.assertContains(r, '''<input type="submit" name="confirm" value="Confirm"/>''', html=True)
self.assertContains(r, '''<input type="submit" name="cancel" value="Cancel"/>''', html=True)
self.assertContains(r, '''<input type="hidden" name="confirmed_action" value="'''+reverse("AnnalistSiteActionView")+'''"/>''', html=True)
self.assertContains(r, '''<input type="hidden" name="cancel_action" value="'''+reverse("AnnalistSiteView")+'''"/>''', html=True)
self.assertHtmlContentElement(r.content,
tagname="input", tagattrs={"name": "action_params"},
expect_attrs=
{ "type": "hidden"
, "value":
{ "remove": ["Remove selected"]
, "new_id": [""]
, "new_label": [""]
, "select": ["coll1", "coll3"]
}
}
)
return
class CollectionDataEditViewTest(AnnalistTestCase):
"""
Tests for collection data edit view
"""
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.testcoll = Collection.create(self.testsite, "testcoll", collection_create_values("testcoll"))
# Login and permissions
create_test_user(
self.testsite.site_data_collection(),
# 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
def tearDown(self):
resetSitedata()
return
# -----------------------------------------------------------------------------
# Helpers
# -----------------------------------------------------------------------------
def _check_collection_data_values(self, coll_id=None):
"""
Helper function checks content of annalist collection data
"""
self.assertTrue(Collection.exists(self.testsite, coll_id))
t = Collection.load(self.testsite, coll_id)
self.assertEqual(t.get_id(), coll_id)
self.assertEqual(t.get_view_url_path(), collection_view_url(coll_id="testcoll"))
v = collectiondata_values(coll_id=coll_id)
self.assertDictionaryMatch(t.get_values(), v)
return t
# -----------------------------------------------------------------------------
# Form rendering and access tests
# -----------------------------------------------------------------------------
def test_get_collection_data_form_rendering(self):
u = entitydata_edit_url("new", "_annalist_site", "_coll", view_id="Collection_view")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
field_vals = default_fields(
coll_id="_annalist_site",
type_id="_coll",
entity_id="00000001",
sotware_ver=annalist.__version_data__,
tooltip1a=context_view_field(r.context, 0, 0)['field_help'],
tooltip1b=context_view_field(r.context, 0, 1)['field_help'],
tooltip2 =context_view_field(r.context, 1, 0)['field_help'],
tooltip3 =context_view_field(r.context, 2, 0)['field_help'],
tooltip4 =context_view_field(r.context, 3, 0)['field_help'],
tooltip5a=context_view_field(r.context, 4, 0)['field_help'],
tooltip5b=context_view_field(r.context, 4, 1)['field_help'],
tooltip6a=context_view_field(r.context, 5, 0)['field_help'],
tooltip6b=context_view_field(r.context, 5, 1)['field_help'],
tooltip7 =context_view_field(r.context, 6, 0)['field_help'],
)
formrow1a = """
<div class="small-12 medium-6 columns" title="%(tooltip1a)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Id</span>
</div>
<div class="%(input_classes)s">
<input type="text" size="64" name="entity_id"
placeholder="(entity id)"
value="00000001" />
</div>
</div>
</div>
"""%field_vals(width=6)
formrow1b = """
<div class="small-12 medium-6 columns" title="%(tooltip1b)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>S/W version</span>
</div>
<div class="%(input_classes)s">
<span> </span>
</div>
</div>
</div>
"""%field_vals(width=6)
formrow2 = """
<div class="small-12 columns" title="%(tooltip2)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Label</span>
</div>
<div class="%(input_classes)s">
<input type="text" size="64" name="Entity_label"
placeholder="(label)"
value="" />
</div>
</div>
</div>
"""%field_vals(width=12)
formrow3 = """
<div class="small-12 columns" title="%(tooltip3)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Comment</span>
</div>
<div class="%(input_classes)s">
<textarea cols="64" rows="6" name="Entity_comment"
class="small-rows-4 medium-rows-8"
placeholder="(description)"
>
</textarea>
</div>
</div>
</div>
"""%field_vals(width=12)
formrow4 = """
<div class="small-12 columns" title="%(tooltip4)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Parent</span>
</div>
<div class="%(input_classes)s">
<select name="Coll_parent">
<option value="" selected="selected">(site)</option>
<option value="_coll/_annalist_site">Annalist data notebook test site</option>
<option value="_coll/coll1">Collection coll1</option>
<option value="_coll/coll2">Collection coll2</option>
<option value="_coll/coll3">Collection coll3</option>
<option value="_coll/testcoll">Collection testcoll</option>
</select>
</div>
</div>
</div>
"""%field_vals(width=12)
formrow5a = """
<div class="small-12 medium-6 columns" title="%(tooltip5a)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Default list</span>
</div>
<div class="%(input_classes)s">
<span> </span>
</div>
</div>
</div>
"""%field_vals(width=6)
formrow5b = """
<div class="small-12 medium-6 columns" title="%(tooltip5b)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Default view</span>
</div>
<div class="%(input_classes)s">
<span> </span>
</div>
</div>
</div>
"""%field_vals(width=6)
formrow6a = """
<div class="small-12 medium-6 columns" title="%(tooltip6a)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Default view type</span>
</div>
<div class="%(input_classes)s">
<span> </span>
</div>
</div>
</div>
"""%field_vals(width=6)
formrow6b = """
<div class="small-12 medium-6 columns" title="%(tooltip6b)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Default view entity</span>
</div>
<div class="%(input_classes)s">
<span> </span>
</div>
</div>
</div>
"""%field_vals(width=6)
formrow7 = """
<div class="small-12 columns" title="%(tooltip7)s">
<div class="row view-value-row">
<div class="%(label_classes)s">
<span>Collection metadata</span>
</div>
<div class="%(input_classes)s">
<textarea cols="64" rows="6" name="Coll_comment"
class="small-rows-4 medium-rows-8"
placeholder="(annal:meta_comment)"
>
</textarea>
</div>
</div>
</div>
"""%field_vals(width=12)
# log.info(r.content)
self.assertContains(r, formrow1a, html=True)
self.assertContains(r, formrow1b, html=True)
self.assertContains(r, formrow2, html=True)
self.assertContains(r, formrow3, html=True)
self.assertContains(r, formrow4, html=True)
self.assertContains(r, formrow5a, html=True)
self.assertContains(r, formrow5b, html=True)
self.assertContains(r, formrow6a, html=True)
self.assertContains(r, formrow6b, html=True)
self.assertContains(r, formrow7, html=True)
return
# collection default view
def test_get_default_view(self):
u = collectiondata_url(coll_id="testcoll")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEqual(r.context['coll_id'], "_annalist_site")
self.assertEqual(r.context['type_id'], "_coll")
self.assertEqual(r.context['entity_id'], "testcoll")
self.assertEqual(r.context['orig_id'], "testcoll")
self.assertEqual(r.context['action'], "view")
self.assertEqual(r.context['continuation_url'], "")
return
# collection default view metadata access
def test_get_default_view_metadata(self):
u = collectiondata_resource_url(coll_id="testcoll")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
colldata = json.loads(r.content)
expected = (
{ "@id": "../"
, "@type": [ "annal:Collection" ]
, "@context": [ {"@base": "../d/"}, "coll_context.jsonld" ]
, "annal:id": "testcoll"
, "annal:type_id": "_coll"
, "annal:type": "annal:Collection"
, "rdfs:label": "Collection testcoll"
, "rdfs:comment": "Description of Collection testcoll"
, "annal:software_version": annalist.__version_data__
})
self.assertEqual(colldata, expected)
return
# collection named view context
def test_get_named_view(self):
u = collectiondata_view_url(coll_id="testcoll", action="view")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEqual(r.context['coll_id'], "_annalist_site")
self.assertEqual(r.context['type_id'], "_coll")
self.assertEqual(r.context['entity_id'], "testcoll")
self.assertEqual(r.context['orig_id'], "testcoll")
self.assertEqual(r.context['action'], "view")
self.assertEqual(r.context['continuation_url'], "")
return
# collection named view edit
def test_get_named_edit(self):
u = collectiondata_view_url(coll_id="testcoll", action="edit")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
self.assertEqual(r.context['coll_id'], "_annalist_site")
self.assertEqual(r.context['type_id'], "_coll")
self.assertEqual(r.context['entity_id'], "testcoll")
self.assertEqual(r.context['orig_id'], "testcoll")
self.assertEqual(r.context['action'], "edit")
self.assertEqual(r.context['continuation_url'], "")
return
# collection named view edit post update
def test_post_named_edit(self):
u = collectiondata_view_url(coll_id="testcoll", action="edit")
f = collectiondata_view_form_data(coll_id="testcoll", action="edit")
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'], TestBaseUri+"/c/_annalist_site/d/_coll/")
# Check updated collection data
self._check_collection_data_values(coll_id="testcoll")
return
# collection named view metadata access
def test_get_named_view_metadata(self):
u = collectiondata_view_resource_url(coll_id="testcoll")
r = self.client.get(u)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.reason_phrase, "OK")
colldata = json.loads(r.content)
expected = (
{ "@id": "../"
, "@type": [ "annal:Collection" ]
, "@context": [ {"@base": "../d/"}, "coll_context.jsonld" ]
, "annal:id": "testcoll"
, "annal:type_id": "_coll"
, "annal:type": "annal:Collection"
, "rdfs:label": "Collection testcoll"
, "rdfs:comment": "Description of Collection testcoll"
, "annal:software_version": annalist.__version_data__
})
self.assertEqual(colldata, expected)
return
# -----------------------------------------------------------------------------
# Form response tests
# -----------------------------------------------------------------------------
def _no_test_post_copy_coll(self):
# The main purpose of this test is to check that user permissions are saved properly
self.assertFalse(CollectionData.exists(self.testcoll, "copyuser"))
f = annalistuser_view_form_data(
action="copy", orig_id="_default_coll_perms",
user_id="copyuser",
user_name="User copyuser",
user_uri="mailto:[email protected]",
user_permissions="VIEW CREATE UPDATE DELETE"
)
u = entitydata_edit_url(
"copy", "testcoll", "_coll", entity_id="_default_coll_perms", view_id="User_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'], self.continuation_url)
# Check that new record type exists
self.assertTrue(CollectionData.exists(self.testcoll, "copyuser"))
self._check_annalist_coll_values("copyuser", ["VIEW", "CREATE", "UPDATE", "DELETE"])
return
def am_updatesite(annroot, userhome, options):
"""
Update site data, leaving user data alone
annroot is the root directory for the Annalist software installation.
userhome is the home directory for the host system user issuing the command.
options contains options parsed from the command line.
returns 0 if all is well, or a non-zero status code.
This value is intended to be used as an exit status code
for the calling program.
"""
status = am_errors.AM_SUCCESS
sitesettings = am_get_site_settings(annroot, userhome, options)
if not sitesettings:
print("Settings not found (%s)"%(options.configuration), file=sys.stderr)
return am_errors.AM_NOSETTINGS
if len(options.args) > 0:
print(
"Unexpected arguments for %s: (%s)"%
(options.command, " ".join(options.args)),
file=sys.stderr
)
return am_errors.AM_UNEXPECTEDARGS
site_layout = layout.Layout(sitesettings.BASE_DATA_DIR, sitesettings.SITE_DIR_NAME)
sitebasedir = site_layout.SITE_PATH
sitebaseurl = "/annalist/" # @@TODO: figure more robust way to define this
site = Site(sitebaseurl, site_layout.SITE_PATH)
sitedata = site.site_data_collection(test_exists=False)
if sitedata is None:
print("Initializing Annalist site metadata in %s (migrating to new layout)"%(sitebasedir))
site = Site.create_site_metadata(
sitebaseurl, sitebasedir,
label="Annalist site (%s configuration)"%options.configuration,
description="Annalist %s site metadata and site-wide values."%options.configuration
)
sitedata = site.site_data_collection()
site_data_src = os.path.join(annroot, "annalist/data/sitedata") # @@TODO: more robust definition
site_data_tgt, site_data_file = sitedata._dir_path()
# --- Migrate old site data to new site directory
# _annalist_site/
site_data_old1 = os.path.join(sitebasedir, site_layout.SITEDATA_OLD_DIR1)
old_site_metadata = os.path.join(site_data_old1, site_layout.SITE_META_FILE)
old_site_database = os.path.join(site_data_old1, site_layout.SITE_DATABASE_FILE)
old_users1 = os.path.join(site_data_old1, layout.USER_DIR_PREV)
old_vocabs1 = os.path.join(site_data_old1, layout.VOCAB_DIR_PREV)
if os.path.isfile(old_site_metadata):
print("Move old site metadata: %s -> %s"%(old_site_metadata, sitebasedir))
new_site_metadata = os.path.join(sitebasedir, site_layout.SITE_META_FILE)
os.rename(old_site_metadata, new_site_metadata)
if os.path.isfile(old_site_database):
print("Move old site database: %s -> %s"%(old_site_database, sitebasedir))
new_site_database = os.path.join(sitebasedir, site_layout.SITE_DATABASE_FILE)
os.rename(old_site_database, new_site_database)
if os.path.isdir(old_users1) or os.path.isdir(old_vocabs1):
print("Copy Annalist old user and/or vocab data from %s"%site_data_old1)
migrate_old_data(site_data_old1, layout.USER_DIR_PREV, site_data_tgt, layout.USER_DIR )
migrate_old_data(site_data_old1, layout.VOCAB_DIR_PREV, site_data_tgt, layout.VOCAB_DIR)
# c/_annalist_site/_annalist_collection/ - using new dir names
site_data_old2 = os.path.join(sitebasedir, site_layout.SITEDATA_OLD_DIR2)
old_users2 = os.path.join(site_data_old2, layout.USER_DIR)
old_vocabs2 = os.path.join(site_data_old2, layout.VOCAB_DIR)
if os.path.isdir(old_users2) or os.path.isdir(old_vocabs2):
print("Copy Annalist old user and/or vocab data from %s"%site_data_old2)
migrate_old_data(site_data_old2, layout.USER_DIR_PREV, site_data_tgt, layout.USER_DIR )
migrate_old_data(site_data_old2, layout.VOCAB_DIR_PREV, site_data_tgt, layout.VOCAB_DIR)
# --- Archive old site data so it's not visible next time
if os.path.isdir(site_data_old1):
archive_old_data(site_data_old1, "")
if os.path.isdir(site_data_old2):
archive_old_data(site_data_old2, "")
# --- Copy latest site data to target directory
print("Copy Annalist site data")
print("from %s"%site_data_src)
for sdir in layout.DATA_DIRS:
print("- %s -> %s"%(sdir, site_data_tgt))
Site.replace_site_data_dir(sitedata, sdir, site_data_src)
for sdir in (layout.USER_DIR, layout.VOCAB_DIR):
print("- %s +> %s"%(sdir, site_data_tgt))
Site.update_site_data_dir(sitedata, sdir, site_data_src)
for sdir in (layout.INFO_DIR,):
print("- %s ~> %s"%(sdir, site_data_tgt))
Site.expand_site_data_dir(sitedata, sdir, site_data_src)
for sdir in layout.COLL_DIRS_PREV:
remove_old_data(site_data_tgt, sdir)
print("Generating context for site data")
sitedata.generate_coll_jsonld_context()
# --- Copy provider data to site config provider directory
provider_dir_src = os.path.join(annroot, "annalist/data/identity_providers")
provider_dir_tgt = os.path.join(sitesettings.CONFIG_BASE, "providers")
print("Copy identity provider data:")
print("- from: %s"%(provider_dir_src,))
print("- to: %s"%(provider_dir_tgt,))
ensure_dir(provider_dir_tgt)
updatetree(provider_dir_src, provider_dir_tgt)
# --- Copy sample system configuration files to config directory
config_dir_src = os.path.join(annroot, "annalist/data/config_examples")
config_dir_tgt = os.path.join(sitesettings.CONFIG_BASE, "config")
print("Copy system configuration sample files:")
print("- from: %s"%(config_dir_src,))
print("- to: %s"%(config_dir_tgt,))
ensure_dir(config_dir_tgt)
updatetree(config_dir_src, provider_dir_tgt)
return status
class SiteTest(AnnalistTestCase):
"""
Tests for Site object interface
"""
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
self.coll1 = collection_values(coll_id="coll1")
self.collnewmeta = collection_create_values(coll_id="new")
self.collnew = collection_values(coll_id="new")
return
def tearDown(self):
resetSitedata(scope="collections")
return
@classmethod
def setUpClass(cls):
super(SiteTest, cls).setUpClass()
return
@classmethod
def tearDownClass(cls):
super(SiteTest, cls).tearDownClass()
resetSitedata(scope="all")
return
def test_SiteTest(self):
self.assertEqual(Site.__name__, "Site", "Check Site class name")
return
def test_site_init(self):
s = Site(TestBaseUri, TestBaseDir)
self.assertEqual(s._entitytype, ANNAL.CURIE.Site)
self.assertEqual(s._entityfile, layout.SITE_META_FILE)
self.assertEqual(s._entityid, layout.SITEDATA_ID)
self.assertEqual(s._entityurl, TestBaseUri + "/")
self.assertEqual(s._entitydir, TestBaseDir + "/")
self.assertEqual(s._values, None)
return
def test_site_data(self):
sd = self.testsite.site_data()
self.assertEquals(set(sd), site_data_keys)
self.assertEquals(sd["title"], site_title())
self.assertEquals(sd["rdfs:label"], site_title())
self.assertEquals(list(sd["collections"]), init_collection_keys)
self.assertDictionaryMatch(sd["collections"]["coll1"], self.coll1)
return
# User permissions
def test_get_user_permissions(self):
s = self.testsite
c = s.site_data_collection()
# Create local permissions
usr = AnnalistUser.create(
c, "user1", annalistuser_create_values(user_id="user1")
)
# Test access to permissions defined in site
ugp = s.get_user_permissions("user1", "mailto:[email protected]")
self.assertEqual(ugp[ANNAL.CURIE.id], "user1")
self.assertEqual(ugp[ANNAL.CURIE.type_id], "_user")
self.assertEqual(ugp[RDFS.CURIE.label], "Test User")
self.assertEqual(ugp[RDFS.CURIE.comment], "User user1: permissions for Test User in collection testcoll")
self.assertEqual(ugp[ANNAL.CURIE.user_uri], "mailto:[email protected]")
self.assertEqual(ugp[ANNAL.CURIE.user_permission], ["VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG", "ADMIN"])
return
def test_get_local_user_not_defined(self):
s = self.testsite
ugp = s.get_user_permissions("user1", "mailto:[email protected]")
self.assertIsNone(ugp)
return
def test_get_user_uri_mismatch(self):
s = self.testsite
c = s.site_data_collection()
# Create local permissions
usr = AnnalistUser.create(c, "user1", annalistuser_create_values(user_id="user1"))
# Test access to permissions defined locally in collection
ugp = s.get_user_permissions("user1", "mailto:[email protected]")
self.assertIsNone(ugp)
return
def test_get_default_user_permissions(self):
s = self.testsite
# Test access to default permissions defined in site
ugp = s.get_user_permissions("_default_user_perms", "annal:User/_default_user_perms")
self.assertEqual(ugp[ANNAL.CURIE.id], "_default_user_perms")
self.assertEqual(ugp[ANNAL.CURIE.type_id], "_user")
self.assertEqual(ugp[RDFS.CURIE.label], "Default permissions")
self.assertEqual(ugp[ANNAL.CURIE.user_uri], "annal:User/_default_user_perms")
self.assertEqual(ugp[ANNAL.CURIE.user_permission], ["VIEW"])
return
# Collections
def test_collections_dict(self):
colls = self.testsite.collections_dict()
self.assertEquals(list(colls), init_collection_keys)
self.assertDictionaryMatch(colls["coll1"], self.coll1)
return
def test_add_collection(self):
colls = self.testsite.collections_dict()
self.assertEquals(list(colls), init_collection_keys)
self.testsite.add_collection("new", self.collnewmeta)
colls = self.testsite.collections_dict()
self.assertEquals(set(colls), set(init_collection_keys+["new"]))
self.assertDictionaryMatch(colls["coll1"], self.coll1)
self.assertDictionaryMatch(colls["new"], self.collnew)
return
def test_remove_collection(self):
colls = self.testsite.collections_dict()
self.assertEquals(list(colls), init_collection_keys)
self.testsite.remove_collection("coll2")
collsb = self.testsite.collections_dict()
self.assertEquals(set(collsb), set(init_collection_keys) - {"coll2"})
self.assertDictionaryMatch(colls["coll1"], self.coll1)
return
def am_updatesite(annroot, userhome, options):
"""
Update site data, leaving user data alone
annroot is the root directory for the Annalist software installation.
userhome is the home directory for the host system user issuing the command.
options contains options parsed from the command line.
returns 0 if all is well, or a non-zero status code.
This value is intended to be used as an exit status code
for the calling program.
"""
status = am_errors.AM_SUCCESS
sitesettings = am_get_site_settings(annroot, userhome, options)
if not sitesettings:
print("Settings not found (%s)"%(options.configuration), file=sys.stderr)
return am_errors.AM_NOSETTINGS
if len(options.args) > 0:
print(
"Unexpected arguments for %s: (%s)"%
(options.command, " ".join(options.args)),
file=sys.stderr
)
return am_errors.AM_UNEXPECTEDARGS
site_layout = layout.Layout(sitesettings.BASE_DATA_DIR)
sitebasedir = site_layout.SITE_PATH
sitebaseurl = "/annalist/" # @@TODO: figure more robust way to define this
site = Site(sitebaseurl, site_layout.SITE_PATH)
sitedata = site.site_data_collection(test_exists=False)
if sitedata is None:
print("Initializing Annalist site metadata in %s (migrating to new layout)"%(sitebasedir))
site = Site.create_empty_site_data(
sitebaseurl, sitebasedir,
label="Annalist site (%s configuration)"%options.configuration,
description="Annalist %s site metadata and site-wide values."%options.configuration
)
sitedata = site.site_data_collection()
site_data_src = os.path.join(annroot, "annalist/data/sitedata") # @@TODO: more robust definition
site_data_tgt, site_data_file = sitedata._dir_path()
# --- Migrate old site data to new site directory
site_data_old = os.path.join(sitebasedir, site_layout.SITEDATA_OLD_DIR)
old_users = os.path.join(site_data_old, layout.USER_DIR_PREV)
old_vocabs = os.path.join(site_data_old, layout.VOCAB_DIR_PREV)
if os.path.isdir(old_users) or os.path.isdir(old_vocabs):
print("Copy Annalist old user and/or vocab data from %s"%site_data_old)
migrate_old_data(site_data_old, layout.USER_DIR_PREV, site_data_tgt, layout.USER_DIR )
migrate_old_data(site_data_old, layout.VOCAB_DIR_PREV, site_data_tgt, layout.VOCAB_DIR)
#@@
# if os.path.isdir(old_users) or os.path.isdir(old_vocabs):
# print("Copy Annalist old user and/or vocab data from %s"%site_data_old)
# for sdir in ("users", "vocabs"):
# s = os.path.join(site_data_old, sdir)
# old_s = os.path.join(site_data_old, "old_"+sdir)
# d = os.path.join(site_data_tgt, sdir)
# if os.path.isdir(s):
# print("- %s +> %s (migrating)"%(sdir, d))
# updatetree(s, d)
# print("- %s >> %s (rename)"%(sdir, old_s))
# os.rename(s, old_s)
#@@
# --- Copy latest site data to target directory
print("Copy Annalist site data")
print("from %s"%site_data_src)
for sdir in layout.DATA_DIRS:
print("- %s -> %s"%(sdir, site_data_tgt))
Site.replace_site_data_dir(sitedata, sdir, site_data_src)
for sdir in (layout.USER_DIR, layout.VOCAB_DIR):
print("- %s +> %s"%(sdir, site_data_tgt))
Site.update_site_data_dir(sitedata, sdir, site_data_src)
for sdir in layout.COLL_DIRS_PREV:
remove_old_data(site_data_tgt, sdir)
print("Generating %s"%(site_layout.SITEDATA_CONTEXT_DIR))
sitedata.generate_coll_jsonld_context()
# --- Copy provider data to site config provider directory
provider_dir_tgt = os.path.join(sitesettings.CONFIG_BASE, "providers")
provider_dir_src = os.path.join(annroot, "annalist/data/identity_providers")
print("Copy identity provider data:")
print("- from: %s"%(provider_dir_src,))
print("- to: %s"%(provider_dir_tgt,))
updatetree(provider_dir_src, provider_dir_tgt)
return status
def am_createsite(annroot, userhome, options):
"""
Create Annalist empty site data.
annroot is the root directory for the Annalist software installation.
userhome is the home directory for the host system user issuing the command.
options contains options parsed from the command line.
returns 0 if all is well, or a non-zero status code.
This value is intended to be used as an exit status code
for the calling program.
"""
status = am_errors.AM_SUCCESS
sitesettings = am_get_site_settings(annroot, userhome, options)
if not sitesettings:
print("Settings not found (%s)"%(options.configuration), file=sys.stderr)
return am_errors.AM_NOSETTINGS
if len(options.args) > 0:
print(
"Unexpected arguments for %s: (%s)"%
(options.command, " ".join(options.args)),
file=sys.stderr
)
return am_errors.AM_UNEXPECTEDARGS
site_layout = layout.Layout(sitesettings.BASE_DATA_DIR, sitesettings.SITE_DIR_NAME)
sitebasedir = site_layout.SITE_PATH
#@@@@@ sitebaseurl = "/annalist/" # @@TODO: figure more robust way to define this
sitebaseurl = sitesettings.STATIC_URL
# --- If old site exists and --force option given, remove it
if os.path.exists(os.path.join(sitebasedir, site_layout.SITEDATA_DIR)):
if options.force:
print("Removing old Annalist site at %s"%(sitebasedir))
log.info("rmtree: %s"%(sitebasedir))
removetree(sitebasedir)
else:
print(
"Old data already exists at %s (use '--force' or '-f' to overwrite)."%
(sitebasedir), file=sys.stderr
)
print(
"NOTE: using '--force' or '-f' "+
"removes old site user permissions and namespace data "+
"and requires re-initialization of Django database with local usernames; "+
"consider using 'annalist-manager updatesite'."
)
return am_errors.AM_EXISTS
# --- Initialize empty site data in target directory
print("Initializing Annalist site in %s"%(sitebasedir))
site = Site.create_site_metadata(
sitebaseurl, sitebasedir,
label="Annalist site (%s configuration)"%options.configuration,
description="Annalist %s site metadata and site-wide values."%options.configuration
)
sitedata = site.site_data_collection()
Site.create_site_readme(site)
site_data_src = os.path.join(annroot, "annalist/data/sitedata") # @@TODO: more robust definition
site_data_tgt, site_data_file = sitedata._dir_path()
print("Copy Annalist site data")
print("from %s"%site_data_src)
for sdir in layout.COLL_DIRS:
print("- %s -> %s"%(sdir, site_data_tgt))
Site.replace_site_data_dir(sitedata, sdir, site_data_src)
# @@TODO: filename logic copied from EntityRoot and Collection - create separate method for getting this
(sitedata_dir, sitedata_file) = sitedata._dir_path()
context_dir = os.path.join(sitedata_dir, layout.META_COLL_BASE_REF)
context_file = os.path.join(context_dir, layout.COLL_CONTEXT_FILE)
#@@
print("Generating %s"%(context_file))
sitedata.generate_coll_jsonld_context()
# --- Copy provider data to site config provider directory
provider_dir_src = os.path.join(annroot, "annalist/data/identity_providers")
provider_dir_tgt = os.path.join(sitesettings.CONFIG_BASE, "providers")
print("Copy identity provider data:")
print("- from: %s"%(provider_dir_src,))
print("- to: %s"%(provider_dir_tgt,))
ensure_dir(provider_dir_tgt)
updatetree(provider_dir_src, provider_dir_tgt)
# --- Copy sample system configuration files to config directory
config_dir_src = os.path.join(annroot, "annalist/data/config_examples")
config_dir_tgt = os.path.join(sitesettings.CONFIG_BASE, "config")
print("Copy system configuration sample files:")
print("- from: %s"%(config_dir_src,))
print("- to: %s"%(config_dir_tgt,))
ensure_dir(config_dir_tgt)
updatetree(config_dir_src, config_dir_tgt)
# --- Created
print("Now run 'annalist-manager initialize' to create site admin database")
return status
class SiteActionViewTests(AnnalistTestCase):
"""
Tests for Site action views (completion of confirmed actions
requested from the site view)
"""
def setUp(self):
init_annalist_test_site()
self.testsite = Site(TestBaseUri, TestBaseDir)
# self.user = User.objects.create_user('testuser', '*****@*****.**', 'testpassword')
# self.user.save()
# self.client = Client(HTTP_HOST=TestHost)
# Login and permissions
create_test_user(None, "testuser", "testpassword")
self.client = Client(HTTP_HOST=TestHost)
loggedin = self.client.login(username="******", password="******")
self.assertTrue(loggedin)
create_user_permissions(
self.testsite.site_data_collection(), "testuser",
user_permissions=
[ "VIEW", "CREATE", "UPDATE", "DELETE", "CONFIG"
, "CREATE_COLLECTION", "DELETE_COLLECTION"
]
)
return
def tearDown(self):
return
@classmethod
def setUpClass(cls):
super(SiteActionViewTests, cls).setUpClass()
# Remove any collections left behind from previous tests
resetSitedata(scope="collections")
return
def _conf_data(self, action="confirm"):
action_values = (
{ 'confirm': "Confirm"
, 'cancel': "Cancel"
})
return (
{ action: action_values[action]
, "confirmed_action": reverse("AnnalistSiteActionView")
, "action_params": """{"new_label": [""], "new_id": [""], "select": ["coll1", "coll3"], "remove": ["Remove selected"]}"""
, "cancel_action": reverse("AnnalistSiteView")
})
def test_SiteActionViewTest(self):
self.assertEqual(SiteActionView.__name__, "SiteActionView", "Check SiteActionView class name")
return
def test_post_confirmed_remove(self):
# Submit positive confirmation
u = reverse("AnnalistConfirmView")
r = self.client.post(u, self._conf_data(action="confirm"))
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "Found")
self.assertEqual(r.content, b"")
v = reverse("AnnalistSiteView")
e1 = "info_head="
e2 = "info_message="
e3 = "coll1"
e4 = "coll3"
self.assertIn(v, r['location'])
self.assertIn(e1, r['location'])
self.assertIn(e2, r['location'])
self.assertIn(e3, r['location'])
self.assertIn(e4, r['location'])
# Confirm collections deleted
r = self.client.get(TestBasePath+"/site/")
colls = r.context['collections']
#@@ (diagnostic only)
if len(colls) != len(init_collection_keys)-2:
log.warning("@@ Collection count mismatch: %s != %d"%(len(colls), len(init_collection_keys)-2))
log.warning("@@ Collections seen %r"%(list(colls),))
#@@
self.assertEqual(len(colls), len(init_collection_keys)-2)
id = "coll2"
self.assertEqual(colls[id]["annal:id"], id)
self.assertEqual(colls[id]["annal:url"], init_collections[id]["annal:url"])
self.assertEqual(colls[id]["rdfs:label"], init_collections[id]["rdfs:label"])
return
def test_post_cancelled_remove(self):
u = reverse("AnnalistConfirmView")
r = self.client.post(u, self._conf_data(action="cancel"))
self.assertEqual(r.status_code, 302)
self.assertEqual(r.reason_phrase, "Found")
self.assertEqual(r.content, b"")
self.assertEqual(r['location'], TestBasePath+"/site/")
# Confirm no collections deleted
r = self.client.get(TestBasePath+"/site/")
colls = r.context['collections']
self.assertEqual(len(colls), len(init_collection_keys))
for id in init_collections:
self.assertEqual(colls[id]["annal:id"], id)
self.assertEqual(colls[id]["annal:url"], init_collections[id]["annal:url"])
self.assertEqual(colls[id]["rdfs:label"], init_collections[id]["rdfs:label"])
return
