class PidTestCase(TestCase):
fixtures = ['pids.json']
def setUp(self):
# dependent objects to use for creating test pids
self.domain = Domain(name="test domain")
self.domain.save()
self.user = User(username="******")
self.user.set_password("pidpass")
self.user.save()
# test pids: one ark & one purl
self.ark = Pid(name="testark",
domain=self.domain,
creator=self.user,
editor=self.user,
type="Ark")
self.ark.save()
self.purl = Pid(name="testpurl",
domain=self.domain,
creator=self.user,
editor=self.user,
type="Purl")
self.purl.save()
def tearDown(self):
self.domain.delete()
self.user.delete()
self.ark.delete()
self.purl.delete()
def test_mint_noid(self):
noid = Pid.mint_noid()
self.assertNotEqual(None, noid,
"value returned by mint_noid should not be None")
self.assert_(
re.compile("^[a-z0-9]+$").match(noid),
"generated noid '" + noid + "' matches expected pattern")
def test_primary_target(self):
self.assertEqual(None, self.ark.primary_target())
self.assertEqual(None, self.purl.primary_target())
purl_target = self.purl.target_set.create(uri="some.uri")
self.assertEqual(purl_target, self.purl.primary_target())
ark_target = self.ark.target_set.create(uri="some.other.uri")
ark_qual_target = self.ark.target_set.create(uri="some.other.uri/foo",
qualify='q')
self.assertEqual(ark_target, self.ark.primary_target())
def test_is_valid__purl(self):
self.assert_(self.purl.is_valid(), "purl with no targets is valid")
self.purl.target_set.create(uri="some.uri")
self.assert_(self.purl.is_valid(),
"purl with single unqualified target is valid")
self.purl.primary_target().qualify = "qual"
self.assertRaises(Exception, self.purl.is_valid,
"purl with single qualified target is invalid")
self.purl.target_set.get().qualify = ""
self.purl.target_set.create(qualify='q', uri="no.uri")
self.assertRaises(Exception, self.purl.is_valid,
"purl with multiple targets is invalid")
def test_is_valid__ark(self):
self.assert_(self.ark.is_valid(), "ark with no targets is valid")
self.ark.target_set.create(uri="http://some.uri")
self.assert_(self.ark.is_valid(),
"ark with one unqualified target is valid")
self.ark.target_set.create(qualify="q", uri="http://other.uri")
self.assert_(self.ark.is_valid(), "ark with two targets is valid")
self.ark.target_set.create(qualify="qual",
uri="http://some.url",
proxy=None)
self.assert_(self.ark.is_valid(), "ark with two targets is valid")
for t in self.ark.target_set.all():
t.qualify = "q"
self.assertRaises(Exception, self.ark.is_valid,
"ark with duplicate qualifiers is invalid")
def test_purl_url(self):
# url when there is no target
self.assertEqual(
'', self.purl.url(),
"url for purl with no target should be '', got " + self.purl.url())
# now add a target
self.purl.target_set.create(uri="some.uri")
self.assertEqual(
settings.PID_RESOLVER_URL + "/" + self.purl.pid, self.purl.url(),
"url for purl with target should be " + settings.PID_RESOLVER_URL +
"/" + self.purl.pid + ", got " + self.purl.url())
def test_ark_url(self):
# url when there is no target
self.assertEqual(
'', self.ark.url(),
"url for ark with no target should be '', got " + self.ark.url())
# add a qualified target (no unqualified/primary target)
self.ark.target_set.create(qualify="q", uri="http://ti.ny")
self.assertEqual(
settings.PID_RESOLVER_URL +
"/ark:/" + settings.PID_ARK_NAAN + "/" + self.ark.pid + "/q",
self.ark.url(), "url for ark with no primary target should be " +
settings.PID_RESOLVER_URL + "/ark:/" + settings.PID_ARK_NAAN +
"/" + self.ark.pid + "/q , got " + self.ark.url())
# add an unqualified target
self.ark.target_set.create(uri="http://wh.ee")
self.assertEqual(
settings.PID_RESOLVER_URL +
"/ark:/" + settings.PID_ARK_NAAN + "/" + self.ark.pid,
self.ark.url(), "url for ark with primary target should be " +
settings.PID_RESOLVER_URL + "/ark:/" + settings.PID_ARK_NAAN +
"/" + self.ark.pid + ", got " + self.ark.url())
def test_get_policy(self):
# pid with explicit policy set
pid = Pid.objects.get(pk=1)
p = pid.get_policy()
self.assert_(isinstance(p, Policy),
"Pid get_policy returns Policy object")
self.assertEqual(p, pid.policy, "get_policy response is Pid policy")
self.assertNotEqual(
p, pid.domain.policy,
"get_policy response is different than domain policy")
# pid with no explicit policy - inherits from domain
pid = Pid.objects.get(pk=2)
self.assertEqual(pid.policy, None, "test pid has no explicit policy")
p = pid.get_policy()
self.assert_(isinstance(p, Policy),
"pid get_policy returns Policy object")
self.assertEqual(p, pid.domain.policy,
"pid get_policy returns domain policy")
# inactive pid returns inactive policy
pid = Pid.objects.get(pk=2)
for t in pid.target_set.all():
t.active = False
t.save()
self.assertEquals(pid.is_active(), False)
p = Policy.objects.get(title__exact='Inactive Policy')
self.assertEquals(pid.get_policy(), p)
def test_url_link(self):
self.purl.target_set.create(uri="some.uri")
url = settings.PID_RESOLVER_URL + "/" + self.purl.pid
self.assert_(
re.compile('^<a [^>]*href=[\'"]' + url + '[\'"]>' + url +
'</a>$').match(self.purl.url_link()),
"url link for purl with target should match pattern for link with "
+ url + ", got " + self.purl.url_link())
def test_is_active(self):
# setup creates ark/purl with no targets, so they are inactive
self.assertFalse(self.ark.is_active())
self.assertFalse(self.purl.is_active())
purl_target = self.purl.target_set.create(uri="some.uri")
ark_target = self.ark.target_set.create(uri="some.other.uri")
self.assertTrue(self.ark.is_active())
self.assertTrue(self.purl.is_active())
purl_target.active = False
purl_target.save()
ark_target.active = False
ark_target.save()
self.assertFalse(self.ark.is_active())
self.assertFalse(self.purl.is_active())
@unittest.skip # linkcheck disabled in 0.10
def test_target_linkcheck_status(self):
# no links checked, status -> none
self.assertEqual(
None, self.ark.target_linkcheck_status(),
'ARK with no targets should have linkcheck status of None (unknown)'
)
self.assertEqual(
None, self.purl.target_linkcheck_status(),
'PURL with no targets should have linkcheck status of None (unknown)'
)
# add targets; automatically get checked and will fail
purl_target = self.purl.target_set.create(uri="some.uri")
ark_target = self.ark.target_set.create(uri="some.other.uri")
ark_qual_target = self.ark.target_set.create(uri="some.other.uri/foo",
qualify='q')
self.assertFalse(
self.ark.target_linkcheck_status(),
'ARK with invalid target uris should have linkcheck status of False (error)'
)
self.assertFalse(
self.purl.target_linkcheck_status(),
'PURL with invalid target uri should have linkcheck status of False (error)'
)
# manually update status to check valid / mixed
purl_linkcheck = purl_target.linkcheck.first()
purl_linkcheck.url.status = True
purl_linkcheck.url.save()
self.assertTrue(
self.purl.target_linkcheck_status(),
'purl with valid target uri should have link status True (ok)')
# one valid ark target and one invalid is still invalid
ark_linkcheck = ark_target.linkcheck.first()
ark_linkcheck.url.status = True
ark_linkcheck.url.save()
self.assertFalse(self.ark.target_linkcheck_status(),
'ark with one valid and one invalid target uri should have ' + \
'link status False (error)')
ark_qual_linkcheck = ark_qual_target.linkcheck.first()
ark_qual_linkcheck.url.status = True
ark_qual_linkcheck.url.save()
self.assertTrue(
self.ark.target_linkcheck_status(),
'ark with all valid target uris should have link status True (ok)')
class PidTestCase(TestCase):
fixtures = ['pids.json']
def setUp(self):
# dependent objects to use for creating test pids
self.domain = Domain(name="test domain")
self.domain.save()
self.user = User(username="******")
self.user.set_password("pidpass")
self.user.save()
# test pids: one ark & one purl
self.ark = Pid(name="testark", domain=self.domain, creator=self.user,
editor=self.user, type="Ark")
self.ark.save()
self.purl = Pid(name="testpurl", domain=self.domain, creator=self.user,
editor=self.user, type="Purl")
self.purl.save()
def tearDown(self):
self.domain.delete()
self.user.delete()
self.ark.delete()
self.purl.delete()
def test_mint_noid(self):
noid = Pid.mint_noid()
self.assertNotEqual(None, noid, "value returned by mint_noid should not be None")
self.assert_(re.compile("^[a-z0-9]+$").match(noid),
"generated noid '" + noid + "' matches expected pattern")
def test_primary_target(self):
self.assertEqual(None, self.ark.primary_target())
self.assertEqual(None, self.purl.primary_target())
purl_target = self.purl.target_set.create(uri="some.uri")
self.assertEqual(purl_target, self.purl.primary_target())
ark_target = self.ark.target_set.create(uri="some.other.uri")
ark_qual_target = self.ark.target_set.create(uri="some.other.uri/foo", qualify='q')
self.assertEqual(ark_target, self.ark.primary_target())
def test_is_valid__purl(self):
self.assert_(self.purl.is_valid(), "purl with no targets is valid")
self.purl.target_set.create(uri="some.uri")
self.assert_(self.purl.is_valid(), "purl with single unqualified target is valid")
self.purl.primary_target().qualify = "qual"
self.assertRaises(Exception, self.purl.is_valid, "purl with single qualified target is invalid")
self.purl.target_set.get().qualify = ""
self.purl.target_set.create(qualify='q', uri="no.uri")
self.assertRaises(Exception, self.purl.is_valid, "purl with multiple targets is invalid")
def test_is_valid__ark(self):
self.assert_(self.ark.is_valid(), "ark with no targets is valid")
self.ark.target_set.create(uri="http://some.uri")
self.assert_(self.ark.is_valid(), "ark with one unqualified target is valid")
self.ark.target_set.create(qualify="q", uri="http://other.uri")
self.assert_(self.ark.is_valid(), "ark with two targets is valid")
self.ark.target_set.create(qualify="qual", uri="http://some.url", proxy=None)
self.assert_(self.ark.is_valid(), "ark with two targets is valid")
for t in self.ark.target_set.all():
t.qualify = "q"
self.assertRaises(Exception, self.ark.is_valid, "ark with duplicate qualifiers is invalid")
def test_purl_url(self):
# url when there is no target
self.assertEqual('', self.purl.url(),
"url for purl with no target should be '', got " + self.purl.url())
# now add a target
self.purl.target_set.create(uri="some.uri")
self.assertEqual(settings.PID_RESOLVER_URL + "/" + self.purl.pid, self.purl.url(),
"url for purl with target should be " + settings.PID_RESOLVER_URL + "/" +
self.purl.pid + ", got " + self.purl.url())
def test_ark_url(self):
# url when there is no target
self.assertEqual('', self.ark.url(),
"url for ark with no target should be '', got " + self.ark.url())
# add a qualified target (no unqualified/primary target)
self.ark.target_set.create(qualify="q", uri="http://ti.ny")
self.assertEqual(settings.PID_RESOLVER_URL + "/ark:/" + settings.PID_ARK_NAAN + "/" +
self.ark.pid + "/q", self.ark.url(), "url for ark with no primary target should be " +
settings.PID_RESOLVER_URL + "/ark:/" + settings.PID_ARK_NAAN + "/" +
self.ark.pid + "/q , got " + self.ark.url())
# add an unqualified target
self.ark.target_set.create(uri="http://wh.ee")
self.assertEqual(settings.PID_RESOLVER_URL + "/ark:/" + settings.PID_ARK_NAAN + "/" +
self.ark.pid, self.ark.url(), "url for ark with primary target should be " +
settings.PID_RESOLVER_URL + "/ark:/" + settings.PID_ARK_NAAN + "/" +
self.ark.pid + ", got " + self.ark.url())
def test_get_policy(self):
# pid with explicit policy set
pid = Pid.objects.get(pk=1)
p = pid.get_policy()
self.assert_(isinstance(p, Policy), "Pid get_policy returns Policy object")
self.assertEqual(p, pid.policy, "get_policy response is Pid policy")
self.assertNotEqual(p, pid.domain.policy, "get_policy response is different than domain policy")
# pid with no explicit policy - inherits from domain
pid = Pid.objects.get(pk=2)
self.assertEqual(pid.policy, None, "test pid has no explicit policy")
p = pid.get_policy()
self.assert_(isinstance(p, Policy), "pid get_policy returns Policy object")
self.assertEqual(p, pid.domain.policy, "pid get_policy returns domain policy")
# inactive pid returns inactive policy
pid = Pid.objects.get(pk=2)
for t in pid.target_set.all():
t.active = False
t.save()
self.assertEquals(pid.is_active(), False)
p = Policy.objects.get(title__exact='Inactive Policy')
self.assertEquals(pid.get_policy(), p)
def test_url_link(self):
self.purl.target_set.create(uri="some.uri")
url = settings.PID_RESOLVER_URL + "/" + self.purl.pid
self.assert_(re.compile('^<a [^>]*href=[\'"]' + url + '[\'"]>' + url + '</a>$').match(self.purl.url_link()),
"url link for purl with target should match pattern for link with "
+ url + ", got " + self.purl.url_link())
def test_is_active(self):
# setup creates ark/purl with no targets, so they are inactive
self.assertFalse(self.ark.is_active())
self.assertFalse(self.purl.is_active())
purl_target = self.purl.target_set.create(uri="some.uri")
ark_target = self.ark.target_set.create(uri="some.other.uri")
self.assertTrue(self.ark.is_active())
self.assertTrue(self.purl.is_active())
purl_target.active = False
purl_target.save()
ark_target.active = False
ark_target.save()
self.assertFalse(self.ark.is_active())
self.assertFalse(self.purl.is_active())
@unittest.skip # linkcheck disabled in 0.10
def test_target_linkcheck_status(self):
# no links checked, status -> none
self.assertEqual(None, self.ark.target_linkcheck_status(),
'ARK with no targets should have linkcheck status of None (unknown)')
self.assertEqual(None, self.purl.target_linkcheck_status(),
'PURL with no targets should have linkcheck status of None (unknown)')
# add targets; automatically get checked and will fail
purl_target = self.purl.target_set.create(uri="some.uri")
ark_target = self.ark.target_set.create(uri="some.other.uri")
ark_qual_target = self.ark.target_set.create(uri="some.other.uri/foo", qualify='q')
self.assertFalse(self.ark.target_linkcheck_status(),
'ARK with invalid target uris should have linkcheck status of False (error)')
self.assertFalse(self.purl.target_linkcheck_status(),
'PURL with invalid target uri should have linkcheck status of False (error)')
# manually update status to check valid / mixed
purl_linkcheck = purl_target.linkcheck.first()
purl_linkcheck.url.status = True
purl_linkcheck.url.save()
self.assertTrue(self.purl.target_linkcheck_status(),
'purl with valid target uri should have link status True (ok)')
# one valid ark target and one invalid is still invalid
ark_linkcheck = ark_target.linkcheck.first()
ark_linkcheck.url.status = True
ark_linkcheck.url.save()
self.assertFalse(self.ark.target_linkcheck_status(),
'ark with one valid and one invalid target uri should have ' + \
'link status False (error)')
ark_qual_linkcheck = ark_qual_target.linkcheck.first()
ark_qual_linkcheck.url.status = True
ark_qual_linkcheck.url.save()
self.assertTrue(self.ark.target_linkcheck_status(),
'ark with all valid target uris should have link status True (ok)')
