+ def test_writable_mdmf_cap(self):
+ u1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint)
+ cap = u1.to_string()
+ u = uri.WritableMDMFFileURI.init_from_string(cap)
+
+ self.failUnless(IMutableFileURI.providedBy(u))
+ self.failUnlessReallyEqual(u.fingerprint, self.fingerprint)
+ self.failUnlessReallyEqual(u.writekey, self.writekey)
+ self.failUnless(u.is_mutable())
+ self.failIf(u.is_readonly())
+ self.failUnlessEqual(cap, u.to_string())
+
+ # Now get a readonly cap from the writable cap, and test that it
+ # degrades gracefully.
+ ru = u.get_readonly()
+ self.failUnlessReallyEqual(self.readkey, ru.readkey)
+ self.failUnlessReallyEqual(self.fingerprint, ru.fingerprint)
+ self.failUnless(ru.is_mutable())
+ self.failUnless(ru.is_readonly())
+
+ # Now get a verifier cap.
+ vu = ru.get_verify_cap()
+ self.failUnlessReallyEqual(self.storage_index, vu.storage_index)
+ self.failUnlessReallyEqual(self.fingerprint, vu.fingerprint)
+ self.failUnless(IVerifierURI.providedBy(vu))
+
+ def test_readonly_mdmf_cap(self):
+ u1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint)
+ cap = u1.to_string()
+ u2 = uri.ReadonlyMDMFFileURI.init_from_string(cap)
+
+ self.failUnlessReallyEqual(u2.fingerprint, self.fingerprint)
+ self.failUnlessReallyEqual(u2.readkey, self.readkey)
+ self.failUnless(u2.is_readonly())
+ self.failUnless(u2.is_mutable())
+
+ vu = u2.get_verify_cap()
+ self.failUnlessEqual(vu.storage_index, self.storage_index)
+ self.failUnlessEqual(vu.fingerprint, self.fingerprint)
+
+ def test_create_writable_mdmf_cap_from_readcap(self):
+ # we shouldn't be able to create a writable MDMF cap given only a
+ # readcap.
+ u1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint)
+ cap = u1.to_string()
+ self.failUnlessRaises(uri.BadURIError,
+ uri.WritableMDMFFileURI.init_from_string,
+ cap)
+
+ def test_create_writable_mdmf_cap_from_verifycap(self):
+ u1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ cap = u1.to_string()
+ self.failUnlessRaises(uri.BadURIError,
+ uri.WritableMDMFFileURI.init_from_string,
+ cap)
+
+ def test_create_readonly_mdmf_cap_from_verifycap(self):
+ u1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ cap = u1.to_string()
+ self.failUnlessRaises(uri.BadURIError,
+ uri.ReadonlyMDMFFileURI.init_from_string,
+ cap)
+
+ def test_mdmf_verifier_cap(self):
+ u1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ self.failUnless(u1.is_readonly())
+ self.failIf(u1.is_mutable())
+ self.failUnlessReallyEqual(self.storage_index, u1.storage_index)
+ self.failUnlessReallyEqual(self.fingerprint, u1.fingerprint)
+
+ cap = u1.to_string()
+ u2 = uri.MDMFVerifierURI.init_from_string(cap)
+ self.failUnless(u2.is_readonly())
+ self.failIf(u2.is_mutable())
+ self.failUnlessReallyEqual(self.storage_index, u2.storage_index)
+ self.failUnlessReallyEqual(self.fingerprint, u2.fingerprint)
+
+ u3 = u2.get_readonly()
+ self.failUnlessReallyEqual(u3, u2)
+
+ u4 = u2.get_verify_cap()
+ self.failUnlessReallyEqual(u4, u2)
+
+ def test_mdmf_cap_extra_information(self):
+ # MDMF caps can be arbitrarily extended after the fingerprint
+ # and key/storage index fields.
+ u1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint)
+ self.failUnlessEqual([], u1.get_extension_params())
+
+ cap = u1.to_string()
+ # Now let's append some fields. Say, 131073 (the segment size)
+ # and 3 (the "k" encoding parameter).
+ expected_extensions = []
+ for e in ('131073', '3'):
+ cap += (":%s" % e)
+ expected_extensions.append(e)
+
+ u2 = uri.WritableMDMFFileURI.init_from_string(cap)
+ self.failUnlessReallyEqual(self.writekey, u2.writekey)
+ self.failUnlessReallyEqual(self.fingerprint, u2.fingerprint)
+ self.failIf(u2.is_readonly())
+ self.failUnless(u2.is_mutable())
+
+ c2 = u2.to_string()
+ u2n = uri.WritableMDMFFileURI.init_from_string(c2)
+ self.failUnlessReallyEqual(u2, u2n)
+
+ # We should get the extra back when we ask for it.
+ self.failUnlessEqual(expected_extensions, u2.get_extension_params())
+
+ # These should be preserved through cap attenuation, too.
+ u3 = u2.get_readonly()
+ self.failUnlessReallyEqual(self.readkey, u3.readkey)
+ self.failUnlessReallyEqual(self.fingerprint, u3.fingerprint)
+ self.failUnless(u3.is_readonly())
+ self.failUnless(u3.is_mutable())
+ self.failUnlessEqual(expected_extensions, u3.get_extension_params())
+
+ c3 = u3.to_string()
+ u3n = uri.ReadonlyMDMFFileURI.init_from_string(c3)
+ self.failUnlessReallyEqual(u3, u3n)
+
+ u4 = u3.get_verify_cap()
+ self.failUnlessReallyEqual(self.storage_index, u4.storage_index)
+ self.failUnlessReallyEqual(self.fingerprint, u4.fingerprint)
+ self.failUnless(u4.is_readonly())
+ self.failIf(u4.is_mutable())
+
+ c4 = u4.to_string()
+ u4n = uri.MDMFVerifierURI.init_from_string(c4)
+ self.failUnlessReallyEqual(u4n, u4)
+
+ self.failUnlessEqual(expected_extensions, u4.get_extension_params())
+
+
+ def test_sdmf_cap_extra_information(self):
+ # For interface consistency, we define a method to get
+ # extensions for SDMF files as well. This method must always
+ # return no extensions, since SDMF files were not created with
+ # extensions and cannot be modified to include extensions
+ # without breaking older clients.
+ u1 = uri.WriteableSSKFileURI(self.writekey, self.fingerprint)
+ cap = u1.to_string()
+ u2 = uri.WriteableSSKFileURI.init_from_string(cap)
+ self.failUnlessEqual([], u2.get_extension_params())
+
+ def test_extension_character_range(self):
+ # As written now, we shouldn't put things other than numbers in
+ # the extension fields.
+ writecap = uri.WritableMDMFFileURI(self.writekey, self.fingerprint).to_string()
+ readcap = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint).to_string()
+ vcap = uri.MDMFVerifierURI(self.storage_index, self.fingerprint).to_string()
+ self.failUnlessRaises(uri.BadURIError,
+ uri.WritableMDMFFileURI.init_from_string,
+ ("%s:invalid" % writecap))
+ self.failUnlessRaises(uri.BadURIError,
+ uri.ReadonlyMDMFFileURI.init_from_string,
+ ("%s:invalid" % readcap))
+ self.failUnlessRaises(uri.BadURIError,
+ uri.MDMFVerifierURI.init_from_string,
+ ("%s:invalid" % vcap))
+
+
+ def test_mdmf_valid_human_encoding(self):
+ # What's a human encoding? Well, it's of the form:
+ base = "https://127.0.0.1:3456/uri/"
+ # With a cap on the end. For each of the cap types, we need to
+ # test that a valid cap (with and without the traditional
+ # separators) is recognized and accepted by the classes.
+ w1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint)
+ w2 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint,
+ ['131073', '3'])
+ r1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint)
+ r2 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint,
+ ['131073', '3'])
+ v1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ v2 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint,
+ ['131073', '3'])
+
+ # These will yield six different caps.
+ for o in (w1, w2, r1 , r2, v1, v2):
+ url = base + o.to_string()
+ o1 = o.__class__.init_from_human_encoding(url)
+ self.failUnlessReallyEqual(o1, o)
+
+ # Note that our cap will, by default, have : as separators.
+ # But it's expected that users from, e.g., the WUI, will
+ # have %3A as a separator. We need to make sure that the
+ # initialization routine handles that, too.
+ cap = o.to_string()
+ cap = re.sub(":", "%3A", cap)
+ url = base + cap
+ o2 = o.__class__.init_from_human_encoding(url)
+ self.failUnlessReallyEqual(o2, o)
+
+
+ def test_mdmf_human_encoding_invalid_base(self):
+ # What's a human encoding? Well, it's of the form:
+ base = "https://127.0.0.1:3456/foo/bar/bazuri/"
+ # With a cap on the end. For each of the cap types, we need to
+ # test that a valid cap (with and without the traditional
+ # separators) is recognized and accepted by the classes.
+ w1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint)
+ w2 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint,
+ ['131073', '3'])
+ r1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint)
+ r2 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint,
+ ['131073', '3'])
+ v1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ v2 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint,
+ ['131073', '3'])
+
+ # These will yield six different caps.
+ for o in (w1, w2, r1 , r2, v1, v2):
+ url = base + o.to_string()
+ self.failUnlessRaises(uri.BadURIError,
+ o.__class__.init_from_human_encoding,
+ url)
+
+ def test_mdmf_human_encoding_invalid_cap(self):
+ base = "https://127.0.0.1:3456/uri/"
+ # With a cap on the end. For each of the cap types, we need to
+ # test that a valid cap (with and without the traditional
+ # separators) is recognized and accepted by the classes.
+ w1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint)
+ w2 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint,
+ ['131073', '3'])
+ r1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint)
+ r2 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint,
+ ['131073', '3'])
+ v1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ v2 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint,
+ ['131073', '3'])
+
+ # These will yield six different caps.
+ for o in (w1, w2, r1 , r2, v1, v2):
+ # not exhaustive, obviously...
+ url = base + o.to_string() + "foobarbaz"
+ url2 = base + "foobarbaz" + o.to_string()
+ url3 = base + o.to_string()[:25] + "foo" + o.to_string()[:25]
+ for u in (url, url2, url3):
+ self.failUnlessRaises(uri.BadURIError,
+ o.__class__.init_from_human_encoding,
+ u)
+
+ def test_mdmf_from_string(self):
+ # Make sure that the from_string utility function works with
+ # MDMF caps.
+ u1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint)
+ cap = u1.to_string()
+ self.failUnless(uri.is_uri(cap))
+ u2 = uri.from_string(cap)
+ self.failUnlessReallyEqual(u1, u2)
+ u3 = uri.from_string_mutable_filenode(cap)
+ self.failUnlessEqual(u3, u1)
+
+ # XXX: We should refactor the extension field into setUp
+ u1 = uri.WritableMDMFFileURI(self.writekey, self.fingerprint,
+ ['131073', '3'])
+ cap = u1.to_string()
+ self.failUnless(uri.is_uri(cap))
+ u2 = uri.from_string(cap)
+ self.failUnlessReallyEqual(u1, u2)
+ u3 = uri.from_string_mutable_filenode(cap)
+ self.failUnlessEqual(u3, u1)
+
+ u1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint)
+ cap = u1.to_string()
+ self.failUnless(uri.is_uri(cap))
+ u2 = uri.from_string(cap)
+ self.failUnlessReallyEqual(u1, u2)
+ u3 = uri.from_string_mutable_filenode(cap)
+ self.failUnlessEqual(u3, u1)
+
+ u1 = uri.ReadonlyMDMFFileURI(self.readkey, self.fingerprint,
+ ['131073', '3'])
+ cap = u1.to_string()
+ self.failUnless(uri.is_uri(cap))
+ u2 = uri.from_string(cap)
+ self.failUnlessReallyEqual(u1, u2)
+ u3 = uri.from_string_mutable_filenode(cap)
+ self.failUnlessEqual(u3, u1)
+
+ u1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint)
+ cap = u1.to_string()
+ self.failUnless(uri.is_uri(cap))
+ u2 = uri.from_string(cap)
+ self.failUnlessReallyEqual(u1, u2)
+ u3 = uri.from_string_verifier(cap)
+ self.failUnlessEqual(u3, u1)
+
+ u1 = uri.MDMFVerifierURI(self.storage_index, self.fingerprint,
+ ['131073', '3'])
+ cap = u1.to_string()
+ self.failUnless(uri.is_uri(cap))
+ u2 = uri.from_string(cap)
+ self.failUnlessReallyEqual(u1, u2)
+ u3 = uri.from_string_verifier(cap)
+ self.failUnlessEqual(u3, u1)
+
+