mirror of
https://github.com/tahoe-lafs/tahoe-lafs.git
synced 2025-02-21 02:01:31 +00:00
Add tests of caps from the future that have non-ASCII characters in them (encoded as UTF-8). The changes to test_uri.py, test_client.py, and test_dirnode.py add tests of non-ASCII future caps in addition to the current tests. The changes to test_web.py just replace the tests of all-ASCII future caps with tests of non-ASCII future caps. We also change uses of failUnlessEqual to failUnlessReallyEqual, in order to catch cases where the type of a string is not as expected.
This commit is contained in:
david-sarah
parent
ca660a5fc6
commit
d346e0853d
@ -27,7 +27,7 @@ BASECONFIG = ("[client]\n"
|
||||
"introducer.furl = \n"
|
||||
)
|
||||
|
||||
class Basic(unittest.TestCase):
|
||||
class Basic(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_loadable(self):
|
||||
basedir = "test_client.Basic.test_loadable"
|
||||
os.mkdir(basedir)
|
||||
@ -81,7 +81,7 @@ class Basic(unittest.TestCase):
|
||||
f.write("reserved_space = 1000\n")
|
||||
f.close()
|
||||
c = client.Client(basedir)
|
||||
self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 1000)
|
||||
self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space, 1000)
|
||||
|
||||
def test_reserved_2(self):
|
||||
basedir = "client.Basic.test_reserved_2"
|
||||
@ -93,7 +93,7 @@ class Basic(unittest.TestCase):
|
||||
f.write("reserved_space = 10K\n")
|
||||
f.close()
|
||||
c = client.Client(basedir)
|
||||
self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 10*1000)
|
||||
self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space, 10*1000)
|
||||
|
||||
def test_reserved_3(self):
|
||||
basedir = "client.Basic.test_reserved_3"
|
||||
@ -105,7 +105,7 @@ class Basic(unittest.TestCase):
|
||||
f.write("reserved_space = 5mB\n")
|
||||
f.close()
|
||||
c = client.Client(basedir)
|
||||
self.failUnlessEqual(c.getServiceNamed("storage").reserved_space,
|
||||
self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space,
|
||||
5*1000*1000)
|
||||
|
||||
def test_reserved_4(self):
|
||||
@ -118,8 +118,8 @@ class Basic(unittest.TestCase):
|
||||
f.write("reserved_space = 78Gb\n")
|
||||
f.close()
|
||||
c = client.Client(basedir)
|
||||
self.failUnlessEqual(c.getServiceNamed("storage").reserved_space,
|
||||
78*1000*1000*1000)
|
||||
self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space,
|
||||
78*1000*1000*1000)
|
||||
|
||||
def test_reserved_bad(self):
|
||||
basedir = "client.Basic.test_reserved_bad"
|
||||
@ -131,7 +131,7 @@ class Basic(unittest.TestCase):
|
||||
f.write("reserved_space = bogus\n")
|
||||
f.close()
|
||||
c = client.Client(basedir)
|
||||
self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 0)
|
||||
self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space, 0)
|
||||
|
||||
def _permute(self, sb, key):
|
||||
return [ peerid
|
||||
@ -142,10 +142,10 @@ class Basic(unittest.TestCase):
|
||||
for k in ["%d" % i for i in range(5)]:
|
||||
sb.test_add_server(k, None)
|
||||
|
||||
self.failUnlessEqual(self._permute(sb, "one"), ['3','1','0','4','2'])
|
||||
self.failUnlessEqual(self._permute(sb, "two"), ['0','4','2','1','3'])
|
||||
self.failUnlessReallyEqual(self._permute(sb, "one"), ['3','1','0','4','2'])
|
||||
self.failUnlessReallyEqual(self._permute(sb, "two"), ['0','4','2','1','3'])
|
||||
sb.test_servers.clear()
|
||||
self.failUnlessEqual(self._permute(sb, "one"), [])
|
||||
self.failUnlessReallyEqual(self._permute(sb, "one"), [])
|
||||
|
||||
def test_versions(self):
|
||||
basedir = "test_client.Basic.test_versions"
|
||||
@ -154,8 +154,8 @@ class Basic(unittest.TestCase):
|
||||
c = client.Client(basedir)
|
||||
ss = c.getServiceNamed("storage")
|
||||
verdict = ss.remote_get_version()
|
||||
self.failUnlessEqual(verdict["application-version"],
|
||||
str(allmydata.__full_version__))
|
||||
self.failUnlessReallyEqual(verdict["application-version"],
|
||||
str(allmydata.__full_version__))
|
||||
self.failIfEqual(str(allmydata.__version__), "unknown")
|
||||
self.failUnless("." in str(allmydata.__full_version__),
|
||||
"non-numeric version in '%s'" % allmydata.__version__)
|
||||
@ -225,7 +225,7 @@ class Run(unittest.TestCase, testutil.StallMixin):
|
||||
d.addCallback(_restart)
|
||||
return d
|
||||
|
||||
class NodeMaker(unittest.TestCase):
|
||||
class NodeMaker(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_maker(self):
|
||||
basedir = "client/NodeMaker/maker"
|
||||
fileutil.make_dirs(basedir)
|
||||
@ -297,6 +297,19 @@ class NodeMaker(unittest.TestCase):
|
||||
self.failIf(IMutableFileNode.providedBy(n))
|
||||
self.failIf(IDirectoryNode.providedBy(n))
|
||||
self.failUnless(n.is_unknown())
|
||||
self.failUnlessEqual(n.get_uri(), unknown_rw)
|
||||
self.failUnlessEqual(n.get_write_uri(), unknown_rw)
|
||||
self.failUnlessEqual(n.get_readonly_uri(), "ro." + unknown_ro)
|
||||
self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
|
||||
self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
|
||||
self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)
|
||||
|
||||
unknown_rw = u"lafs://from_the_future_rw_\u263A".encode('utf-8')
|
||||
unknown_ro = u"lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
|
||||
n = c.create_node_from_uri(unknown_rw, unknown_ro)
|
||||
self.failUnless(IFilesystemNode.providedBy(n))
|
||||
self.failIf(IFileNode.providedBy(n))
|
||||
self.failIf(IImmutableFileNode.providedBy(n))
|
||||
self.failIf(IMutableFileNode.providedBy(n))
|
||||
self.failIf(IDirectoryNode.providedBy(n))
|
||||
self.failUnless(n.is_unknown())
|
||||
self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
|
||||
self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
|
||||
self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)
|
||||
|
||||
@ -46,13 +46,15 @@ tiny_litdir_uri = "URI:DIR2-LIT:gqytunj2onug64tufqzdcosvkjetutcjkq5gw4tvm5vwszdg
|
||||
mut_read_uri = "URI:SSK-RO:jf6wkflosyvntwxqcdo7a54jvm:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
|
||||
future_write_uri = "x-tahoe-crazy://I_am_from_the_future."
|
||||
future_read_uri = "x-tahoe-crazy-readonly://I_am_from_the_future."
|
||||
future_nonascii_write_uri = u"x-tahoe-even-more-crazy://I_am_from_the_future_rw_\u263A".encode('utf-8')
|
||||
future_nonascii_read_uri = u"x-tahoe-even-more-crazy-readonly://I_am_from_the_future_ro_\u263A".encode('utf-8')
|
||||
|
||||
# 'o' 'n' 'e-macron'
|
||||
one_nfc = u"on\u0113"
|
||||
one_nfd = u"one\u0304"
|
||||
|
||||
class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
testutil.ShouldFailMixin, testutil.StallMixin, ErrorMixin):
|
||||
testutil.ReallyEqualMixin, testutil.ShouldFailMixin, testutil.StallMixin, ErrorMixin):
|
||||
timeout = 240 # It takes longer than 120 seconds on Francois's arm box.
|
||||
|
||||
def test_basic(self):
|
||||
@ -84,6 +86,8 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
u"mut": (nm.create_from_cap(mut_write_uri, mut_read_uri), {}),
|
||||
u"fut": (nm.create_from_cap(future_write_uri, future_read_uri), {}),
|
||||
u"fro": (nm.create_from_cap(None, future_read_uri), {}),
|
||||
u"fut-unic": (nm.create_from_cap(future_nonascii_write_uri, future_nonascii_read_uri), {}),
|
||||
u"fro-unic": (nm.create_from_cap(None, future_nonascii_read_uri), {}),
|
||||
u"empty_litdir": (nm.create_from_cap(empty_litdir_uri), {}),
|
||||
u"tiny_litdir": (nm.create_from_cap(tiny_litdir_uri), {}),
|
||||
}
|
||||
@ -102,54 +106,67 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(_created)
|
||||
|
||||
def _check_kids(children):
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([one_nfc, u"two", u"mut", u"fut", u"fro", u"empty_litdir", u"tiny_litdir"]))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([one_nfc, u"two", u"mut", u"fut", u"fro",
|
||||
u"fut-unic", u"fro-unic", u"empty_litdir", u"tiny_litdir"]))
|
||||
one_node, one_metadata = children[one_nfc]
|
||||
two_node, two_metadata = children[u"two"]
|
||||
mut_node, mut_metadata = children[u"mut"]
|
||||
fut_node, fut_metadata = children[u"fut"]
|
||||
fro_node, fro_metadata = children[u"fro"]
|
||||
futna_node, futna_metadata = children[u"fut-unic"]
|
||||
frona_node, frona_metadata = children[u"fro-unic"]
|
||||
emptylit_node, emptylit_metadata = children[u"empty_litdir"]
|
||||
tinylit_node, tinylit_metadata = children[u"tiny_litdir"]
|
||||
|
||||
self.failUnlessEqual(one_node.get_size(), 3)
|
||||
self.failUnlessEqual(one_node.get_uri(), one_uri)
|
||||
self.failUnlessEqual(one_node.get_readonly_uri(), one_uri)
|
||||
self.failUnlessReallyEqual(one_node.get_size(), 3)
|
||||
self.failUnlessReallyEqual(one_node.get_uri(), one_uri)
|
||||
self.failUnlessReallyEqual(one_node.get_readonly_uri(), one_uri)
|
||||
self.failUnless(isinstance(one_metadata, dict), one_metadata)
|
||||
|
||||
self.failUnlessEqual(two_node.get_size(), 14861)
|
||||
self.failUnlessEqual(two_node.get_uri(), setup_py_uri)
|
||||
self.failUnlessEqual(two_node.get_readonly_uri(), setup_py_uri)
|
||||
self.failUnlessEqual(two_metadata["metakey"], "metavalue")
|
||||
self.failUnlessReallyEqual(two_node.get_size(), 14861)
|
||||
self.failUnlessReallyEqual(two_node.get_uri(), setup_py_uri)
|
||||
self.failUnlessReallyEqual(two_node.get_readonly_uri(), setup_py_uri)
|
||||
self.failUnlessReallyEqual(two_metadata["metakey"], "metavalue")
|
||||
|
||||
self.failUnlessEqual(mut_node.get_uri(), mut_write_uri)
|
||||
self.failUnlessEqual(mut_node.get_readonly_uri(), mut_read_uri)
|
||||
self.failUnlessReallyEqual(mut_node.get_uri(), mut_write_uri)
|
||||
self.failUnlessReallyEqual(mut_node.get_readonly_uri(), mut_read_uri)
|
||||
self.failUnless(isinstance(mut_metadata, dict), mut_metadata)
|
||||
|
||||
self.failUnless(fut_node.is_unknown())
|
||||
self.failUnlessEqual(fut_node.get_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fut_node.get_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnless(isinstance(fut_metadata, dict), fut_metadata)
|
||||
|
||||
|
||||
self.failUnless(futna_node.is_unknown())
|
||||
self.failUnlessReallyEqual(futna_node.get_uri(), future_nonascii_write_uri)
|
||||
self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "ro." + future_nonascii_read_uri)
|
||||
self.failUnless(isinstance(futna_metadata, dict), futna_metadata)
|
||||
|
||||
self.failUnless(fro_node.is_unknown())
|
||||
self.failUnlessEqual(fro_node.get_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fro_node.get_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnless(isinstance(fro_metadata, dict), fro_metadata)
|
||||
|
||||
self.failUnless(frona_node.is_unknown())
|
||||
self.failUnlessReallyEqual(frona_node.get_uri(), "ro." + future_nonascii_read_uri)
|
||||
self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "ro." + future_nonascii_read_uri)
|
||||
self.failUnless(isinstance(frona_metadata, dict), frona_metadata)
|
||||
|
||||
self.failIf(emptylit_node.is_unknown())
|
||||
self.failUnlessEqual(emptylit_node.get_storage_index(), None)
|
||||
self.failUnlessReallyEqual(emptylit_node.get_storage_index(), None)
|
||||
self.failIf(tinylit_node.is_unknown())
|
||||
self.failUnlessEqual(tinylit_node.get_storage_index(), None)
|
||||
self.failUnlessReallyEqual(tinylit_node.get_storage_index(), None)
|
||||
|
||||
d2 = defer.succeed(None)
|
||||
d2.addCallback(lambda ignored: emptylit_node.list())
|
||||
d2.addCallback(lambda children: self.failUnlessEqual(children, {}))
|
||||
d2.addCallback(lambda ignored: tinylit_node.list())
|
||||
d2.addCallback(lambda children: self.failUnlessEqual(set(children.keys()),
|
||||
set([u"short"])))
|
||||
d2.addCallback(lambda children: self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"short"])))
|
||||
d2.addCallback(lambda ignored: tinylit_node.list())
|
||||
d2.addCallback(lambda children: children[u"short"][0].read(MemAccum()))
|
||||
d2.addCallback(lambda accum: self.failUnlessEqual(accum.data, "The end."))
|
||||
d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, "The end."))
|
||||
return d2
|
||||
|
||||
d.addCallback(_check_kids)
|
||||
@ -185,6 +202,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
u"two": (nm.create_from_cap(setup_py_uri),
|
||||
{"metakey": "metavalue"}),
|
||||
u"fut": (nm.create_from_cap(None, future_read_uri), {}),
|
||||
u"futna": (nm.create_from_cap(None, future_nonascii_read_uri), {}),
|
||||
u"empty_litdir": (nm.create_from_cap(empty_litdir_uri), {}),
|
||||
u"tiny_litdir": (nm.create_from_cap(tiny_litdir_uri), {}),
|
||||
}
|
||||
@ -206,43 +224,49 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(_created)
|
||||
|
||||
def _check_kids(children):
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([one_nfc, u"two", u"fut", u"empty_litdir", u"tiny_litdir"]))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([one_nfc, u"two", u"fut", u"futna", u"empty_litdir", u"tiny_litdir"]))
|
||||
one_node, one_metadata = children[one_nfc]
|
||||
two_node, two_metadata = children[u"two"]
|
||||
fut_node, fut_metadata = children[u"fut"]
|
||||
futna_node, futna_metadata = children[u"futna"]
|
||||
emptylit_node, emptylit_metadata = children[u"empty_litdir"]
|
||||
tinylit_node, tinylit_metadata = children[u"tiny_litdir"]
|
||||
|
||||
self.failUnlessEqual(one_node.get_size(), 3)
|
||||
self.failUnlessEqual(one_node.get_uri(), one_uri)
|
||||
self.failUnlessEqual(one_node.get_readonly_uri(), one_uri)
|
||||
self.failUnlessReallyEqual(one_node.get_size(), 3)
|
||||
self.failUnlessReallyEqual(one_node.get_uri(), one_uri)
|
||||
self.failUnlessReallyEqual(one_node.get_readonly_uri(), one_uri)
|
||||
self.failUnless(isinstance(one_metadata, dict), one_metadata)
|
||||
|
||||
self.failUnlessEqual(two_node.get_size(), 14861)
|
||||
self.failUnlessEqual(two_node.get_uri(), setup_py_uri)
|
||||
self.failUnlessEqual(two_node.get_readonly_uri(), setup_py_uri)
|
||||
self.failUnlessEqual(two_metadata["metakey"], "metavalue")
|
||||
self.failUnlessReallyEqual(two_node.get_size(), 14861)
|
||||
self.failUnlessReallyEqual(two_node.get_uri(), setup_py_uri)
|
||||
self.failUnlessReallyEqual(two_node.get_readonly_uri(), setup_py_uri)
|
||||
self.failUnlessReallyEqual(two_metadata["metakey"], "metavalue")
|
||||
|
||||
self.failUnless(fut_node.is_unknown())
|
||||
self.failUnlessEqual(fut_node.get_uri(), "imm." + future_read_uri)
|
||||
self.failUnlessEqual(fut_node.get_readonly_uri(), "imm." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fut_node.get_uri(), "imm." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "imm." + future_read_uri)
|
||||
self.failUnless(isinstance(fut_metadata, dict), fut_metadata)
|
||||
|
||||
self.failUnless(futna_node.is_unknown())
|
||||
self.failUnlessReallyEqual(futna_node.get_uri(), "imm." + future_nonascii_read_uri)
|
||||
self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "imm." + future_nonascii_read_uri)
|
||||
self.failUnless(isinstance(futna_metadata, dict), futna_metadata)
|
||||
|
||||
self.failIf(emptylit_node.is_unknown())
|
||||
self.failUnlessEqual(emptylit_node.get_storage_index(), None)
|
||||
self.failUnlessReallyEqual(emptylit_node.get_storage_index(), None)
|
||||
self.failIf(tinylit_node.is_unknown())
|
||||
self.failUnlessEqual(tinylit_node.get_storage_index(), None)
|
||||
self.failUnlessReallyEqual(tinylit_node.get_storage_index(), None)
|
||||
|
||||
d2 = defer.succeed(None)
|
||||
d2.addCallback(lambda ignored: emptylit_node.list())
|
||||
d2.addCallback(lambda children: self.failUnlessEqual(children, {}))
|
||||
d2.addCallback(lambda ignored: tinylit_node.list())
|
||||
d2.addCallback(lambda children: self.failUnlessEqual(set(children.keys()),
|
||||
set([u"short"])))
|
||||
d2.addCallback(lambda children: self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"short"])))
|
||||
d2.addCallback(lambda ignored: tinylit_node.list())
|
||||
d2.addCallback(lambda children: children[u"short"][0].read(MemAccum()))
|
||||
d2.addCallback(lambda accum: self.failUnlessEqual(accum.data, "The end."))
|
||||
d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, "The end."))
|
||||
return d2
|
||||
|
||||
d.addCallback(_check_kids)
|
||||
@ -295,7 +319,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
self.failUnless("RO-IMM" in rep)
|
||||
cap = dn.get_cap()
|
||||
self.failUnlessIn("LIT", cap.to_string())
|
||||
self.failUnlessEqual(cap.to_string(), "URI:DIR2-LIT:")
|
||||
self.failUnlessReallyEqual(cap.to_string(), "URI:DIR2-LIT:")
|
||||
self.cap = cap
|
||||
return dn.list()
|
||||
d.addCallback(_created_empty)
|
||||
@ -313,12 +337,12 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
self.failUnless("RO-IMM" in rep)
|
||||
cap = dn.get_cap()
|
||||
self.failUnlessIn("LIT", cap.to_string())
|
||||
self.failUnlessEqual(cap.to_string(),
|
||||
"URI:DIR2-LIT:gi4tumj2n4wdcmz2kvjesosmjfkdu3rvpbtwwlbqhiwdeot3puwcy")
|
||||
self.failUnlessReallyEqual(cap.to_string(),
|
||||
"URI:DIR2-LIT:gi4tumj2n4wdcmz2kvjesosmjfkdu3rvpbtwwlbqhiwdeot3puwcy")
|
||||
self.cap = cap
|
||||
return dn.list()
|
||||
d.addCallback(_created_small)
|
||||
d.addCallback(lambda kids: self.failUnlessEqual(kids.keys(), [u"o"]))
|
||||
d.addCallback(lambda kids: self.failUnlessReallyEqual(kids.keys(), [u"o"]))
|
||||
|
||||
# now test n.create_subdirectory(mutable=False)
|
||||
d.addCallback(lambda ign: c.create_dirnode())
|
||||
@ -328,7 +352,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(_check_kids)
|
||||
d.addCallback(lambda ign: n.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(children.keys(), [u"subdir"]))
|
||||
self.failUnlessReallyEqual(children.keys(), [u"subdir"]))
|
||||
d.addCallback(lambda ign: n.get(u"subdir"))
|
||||
d.addCallback(lambda sd: sd.list())
|
||||
d.addCallback(_check_kids)
|
||||
@ -362,8 +386,8 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
spacedout_read_uri = stripped_read_uri + " "
|
||||
|
||||
child = nm.create_from_cap(spacedout_write_uri, spacedout_read_uri)
|
||||
self.failUnlessEqual(child.get_write_uri(), spacedout_write_uri)
|
||||
self.failUnlessEqual(child.get_readonly_uri(), "ro." + spacedout_read_uri)
|
||||
self.failUnlessReallyEqual(child.get_write_uri(), spacedout_write_uri)
|
||||
self.failUnlessReallyEqual(child.get_readonly_uri(), "ro." + spacedout_read_uri)
|
||||
|
||||
child_dottedi = u"ch\u0131\u0307ld"
|
||||
|
||||
@ -396,11 +420,11 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
rw_uri = self.rootnode._decrypt_rwcapdata(rwcapdata)
|
||||
self.failUnlessIn(name, kids_out)
|
||||
(expected_child, ign) = kids_out[name]
|
||||
self.failUnlessEqual(rw_uri, expected_child.get_write_uri())
|
||||
self.failUnlessEqual("ro." + ro_uri, expected_child.get_readonly_uri())
|
||||
self.failUnlessReallyEqual(rw_uri, expected_child.get_write_uri())
|
||||
self.failUnlessReallyEqual("ro." + ro_uri, expected_child.get_readonly_uri())
|
||||
numkids += 1
|
||||
|
||||
self.failUnlessEqual(numkids, len(kids_out))
|
||||
self.failUnlessReallyEqual(numkids, len(kids_out))
|
||||
return self.rootnode
|
||||
d.addCallback(_check_data)
|
||||
|
||||
@ -429,11 +453,11 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
# ro_uri, since it's unknown). Also the dotless-i + dot-above should have been
|
||||
# normalized to 'i'.
|
||||
|
||||
self.failUnlessEqual(set(children.keys()), set(kids_norm.keys()))
|
||||
self.failUnlessReallyEqual(set(children.keys()), set(kids_norm.keys()))
|
||||
child_node, child_metadata = children[u"child"]
|
||||
|
||||
self.failUnlessEqual(child_node.get_write_uri(), stripped_write_uri)
|
||||
self.failUnlessEqual(child_node.get_readonly_uri(), "ro." + stripped_read_uri)
|
||||
self.failUnlessReallyEqual(child_node.get_write_uri(), stripped_write_uri)
|
||||
self.failUnlessReallyEqual(child_node.get_readonly_uri(), "ro." + stripped_read_uri)
|
||||
d.addCallback(_check_kids)
|
||||
|
||||
d.addCallback(lambda ign: nm.create_from_cap(self.cap.to_string()))
|
||||
@ -489,15 +513,15 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
def _check_results(r):
|
||||
self.failUnless(IDeepCheckResults.providedBy(r))
|
||||
c = r.get_counters()
|
||||
self.failUnlessEqual(c,
|
||||
{"count-objects-checked": 4,
|
||||
"count-objects-healthy": 4,
|
||||
"count-objects-unhealthy": 0,
|
||||
"count-objects-unrecoverable": 0,
|
||||
"count-corrupt-shares": 0,
|
||||
})
|
||||
self.failUnlessReallyEqual(c,
|
||||
{"count-objects-checked": 4,
|
||||
"count-objects-healthy": 4,
|
||||
"count-objects-unhealthy": 0,
|
||||
"count-objects-unrecoverable": 0,
|
||||
"count-corrupt-shares": 0,
|
||||
})
|
||||
self.failIf(r.get_corrupt_shares())
|
||||
self.failUnlessEqual(len(r.get_all_results()), 4)
|
||||
self.failUnlessReallyEqual(len(r.get_all_results()), 4)
|
||||
d.addCallback(_check_results)
|
||||
return d
|
||||
|
||||
@ -510,23 +534,23 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
def _check_results(r):
|
||||
self.failUnless(IDeepCheckAndRepairResults.providedBy(r))
|
||||
c = r.get_counters()
|
||||
self.failUnlessEqual(c,
|
||||
{"count-objects-checked": 4,
|
||||
"count-objects-healthy-pre-repair": 4,
|
||||
"count-objects-unhealthy-pre-repair": 0,
|
||||
"count-objects-unrecoverable-pre-repair": 0,
|
||||
"count-corrupt-shares-pre-repair": 0,
|
||||
"count-objects-healthy-post-repair": 4,
|
||||
"count-objects-unhealthy-post-repair": 0,
|
||||
"count-objects-unrecoverable-post-repair": 0,
|
||||
"count-corrupt-shares-post-repair": 0,
|
||||
"count-repairs-attempted": 0,
|
||||
"count-repairs-successful": 0,
|
||||
"count-repairs-unsuccessful": 0,
|
||||
})
|
||||
self.failUnlessReallyEqual(c,
|
||||
{"count-objects-checked": 4,
|
||||
"count-objects-healthy-pre-repair": 4,
|
||||
"count-objects-unhealthy-pre-repair": 0,
|
||||
"count-objects-unrecoverable-pre-repair": 0,
|
||||
"count-corrupt-shares-pre-repair": 0,
|
||||
"count-objects-healthy-post-repair": 4,
|
||||
"count-objects-unhealthy-post-repair": 0,
|
||||
"count-objects-unrecoverable-post-repair": 0,
|
||||
"count-corrupt-shares-post-repair": 0,
|
||||
"count-repairs-attempted": 0,
|
||||
"count-repairs-successful": 0,
|
||||
"count-repairs-unsuccessful": 0,
|
||||
})
|
||||
self.failIf(r.get_corrupt_shares())
|
||||
self.failIf(r.get_remaining_corrupt_shares())
|
||||
self.failUnlessEqual(len(r.get_all_results()), 4)
|
||||
self.failUnlessReallyEqual(len(r.get_all_results()), 4)
|
||||
d.addCallback(_check_results)
|
||||
return d
|
||||
|
||||
@ -542,14 +566,14 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(lambda rootnode: rootnode.start_deep_check().when_done())
|
||||
def _check_results(r):
|
||||
c = r.get_counters()
|
||||
self.failUnlessEqual(c,
|
||||
{"count-objects-checked": 4,
|
||||
"count-objects-healthy": 3,
|
||||
"count-objects-unhealthy": 1,
|
||||
"count-objects-unrecoverable": 0,
|
||||
"count-corrupt-shares": 0,
|
||||
})
|
||||
#self.failUnlessEqual(len(r.get_problems()), 1) # TODO
|
||||
self.failUnlessReallyEqual(c,
|
||||
{"count-objects-checked": 4,
|
||||
"count-objects-healthy": 3,
|
||||
"count-objects-unhealthy": 1,
|
||||
"count-objects-unrecoverable": 0,
|
||||
"count-corrupt-shares": 0,
|
||||
})
|
||||
#self.failUnlessReallyEqual(len(r.get_problems()), 1) # TODO
|
||||
d.addCallback(_check_results)
|
||||
return d
|
||||
|
||||
@ -631,13 +655,13 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
u_v = n.get_verify_cap().to_string()
|
||||
self.failUnless(u_v.startswith("URI:DIR2-Verifier:"), u_v)
|
||||
u_r = n.get_repair_cap().to_string()
|
||||
self.failUnlessEqual(u_r, u)
|
||||
self.failUnlessReallyEqual(u_r, u)
|
||||
self.expected_manifest.append( ((), u) )
|
||||
self.expected_verifycaps.add(u_v)
|
||||
si = n.get_storage_index()
|
||||
self.expected_storage_indexes.add(base32.b2a(si))
|
||||
expected_si = n._uri.get_storage_index()
|
||||
self.failUnlessEqual(si, expected_si)
|
||||
self.failUnlessReallyEqual(si, expected_si)
|
||||
|
||||
d = n.list()
|
||||
d.addCallback(lambda res: self.failUnlessEqual(res, {}))
|
||||
@ -686,8 +710,8 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
|
||||
d.addCallback(lambda res: n.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([u"child", u"subdir"])))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"child", u"subdir"])))
|
||||
|
||||
d.addCallback(lambda res: n.start_deep_stats().when_done())
|
||||
def _check_deepstats(stats):
|
||||
@ -705,27 +729,27 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
"largest-immutable-file": 0,
|
||||
}
|
||||
for k,v in expected.iteritems():
|
||||
self.failUnlessEqual(stats[k], v,
|
||||
"stats[%s] was %s, not %s" %
|
||||
(k, stats[k], v))
|
||||
self.failUnlessReallyEqual(stats[k], v,
|
||||
"stats[%s] was %s, not %s" %
|
||||
(k, stats[k], v))
|
||||
self.failUnless(stats["size-directories"] > 500,
|
||||
stats["size-directories"])
|
||||
self.failUnless(stats["largest-directory"] > 500,
|
||||
stats["largest-directory"])
|
||||
self.failUnlessEqual(stats["size-files-histogram"], [])
|
||||
self.failUnlessReallyEqual(stats["size-files-histogram"], [])
|
||||
d.addCallback(_check_deepstats)
|
||||
|
||||
d.addCallback(lambda res: n.build_manifest().when_done())
|
||||
def _check_manifest(res):
|
||||
manifest = res["manifest"]
|
||||
self.failUnlessEqual(sorted(manifest),
|
||||
sorted(self.expected_manifest))
|
||||
self.failUnlessReallyEqual(sorted(manifest),
|
||||
sorted(self.expected_manifest))
|
||||
stats = res["stats"]
|
||||
_check_deepstats(stats)
|
||||
self.failUnlessEqual(self.expected_verifycaps,
|
||||
res["verifycaps"])
|
||||
self.failUnlessEqual(self.expected_storage_indexes,
|
||||
res["storage-index"])
|
||||
self.failUnlessReallyEqual(self.expected_verifycaps,
|
||||
res["verifycaps"])
|
||||
self.failUnlessReallyEqual(self.expected_storage_indexes,
|
||||
res["storage-index"])
|
||||
d.addCallback(_check_manifest)
|
||||
|
||||
def _add_subsubdir(res):
|
||||
@ -740,13 +764,13 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
self.failUnless(isinstance(subsubdir,
|
||||
dirnode.DirectoryNode)))
|
||||
d.addCallback(lambda res: n.get_child_at_path(u""))
|
||||
d.addCallback(lambda res: self.failUnlessEqual(res.get_uri(),
|
||||
n.get_uri()))
|
||||
d.addCallback(lambda res: self.failUnlessReallyEqual(res.get_uri(),
|
||||
n.get_uri()))
|
||||
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"child"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()),
|
||||
set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()),
|
||||
set(["tahoe"])))
|
||||
|
||||
d.addCallback(lambda res:
|
||||
self.shouldFail(NoSuchChildError, "gcamap-no",
|
||||
@ -759,16 +783,16 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
child, metadata = res
|
||||
self.failUnless(isinstance(child, dirnode.DirectoryNode))
|
||||
# edge-metadata needs at least one path segment
|
||||
self.failUnlessEqual(set(metadata.keys()), set([]))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set([]))
|
||||
d.addCallback(_check_child_and_metadata1)
|
||||
d.addCallback(lambda res:
|
||||
n.get_child_and_metadata_at_path(u"child"))
|
||||
|
||||
def _check_child_and_metadata2(res):
|
||||
child, metadata = res
|
||||
self.failUnlessEqual(child.get_uri(),
|
||||
fake_file_uri)
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
self.failUnlessReallyEqual(child.get_uri(),
|
||||
fake_file_uri)
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
d.addCallback(_check_child_and_metadata2)
|
||||
|
||||
d.addCallback(lambda res:
|
||||
@ -776,7 +800,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
def _check_child_and_metadata3(res):
|
||||
child, metadata = res
|
||||
self.failUnless(isinstance(child, dirnode.DirectoryNode))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
d.addCallback(_check_child_and_metadata3)
|
||||
|
||||
# set_uri + metadata
|
||||
@ -786,7 +810,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
{}))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"c2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
# You can't override the link timestamps.
|
||||
d.addCallback(lambda res: n.set_uri(u"c2",
|
||||
@ -804,7 +828,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
fake_file_uri, fake_file_uri))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"c3"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
# we can also add specific metadata at set_uri() time
|
||||
d.addCallback(lambda res: n.set_uri(u"c4",
|
||||
@ -830,13 +854,13 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
overwrite=False))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"d2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
# if we don't set any defaults, the child should get timestamps
|
||||
d.addCallback(lambda res: n.set_node(u"d3", n))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"d3"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
# we can also add specific metadata at set_node() time
|
||||
d.addCallback(lambda res: n.set_node(u"d4", n,
|
||||
@ -874,10 +898,10 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(lambda children: self.failIf(u"new" in children))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"e1"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"e2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"e3"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnless((set(metadata.keys()) == set(["key", "tahoe"])) and
|
||||
@ -905,10 +929,10 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(lambda children: self.failIf(u"new" in children))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"f1"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"f2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"f3"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnless((set(metadata.keys()) == set(["key", "tahoe"])) and
|
||||
@ -951,9 +975,9 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"timestamps"))
|
||||
def _check_timestamp1(metadata):
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
tahoe_md = metadata["tahoe"]
|
||||
self.failUnlessEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
self.failUnlessReallyEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
|
||||
self.failUnlessGreaterOrEqualThan(tahoe_md["linkcrtime"],
|
||||
self._start_timestamp)
|
||||
@ -975,22 +999,22 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
def _check_timestamp2(metadata):
|
||||
self.failUnlessIn("tahoe", metadata)
|
||||
tahoe_md = metadata["tahoe"]
|
||||
self.failUnlessEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
self.failUnlessReallyEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
|
||||
self.failUnlessEqual(tahoe_md["linkcrtime"], self._old_linkcrtime)
|
||||
self.failUnlessReallyEqual(tahoe_md["linkcrtime"], self._old_linkcrtime)
|
||||
self.failUnlessGreaterThan(tahoe_md["linkmotime"], self._old_linkmotime)
|
||||
return n.delete(u"timestamps")
|
||||
d.addCallback(_check_timestamp2)
|
||||
|
||||
d.addCallback(lambda res: n.delete(u"subdir"))
|
||||
d.addCallback(lambda old_child:
|
||||
self.failUnlessEqual(old_child.get_uri(),
|
||||
self.failUnlessReallyEqual(old_child.get_uri(),
|
||||
self.subdir.get_uri()))
|
||||
|
||||
d.addCallback(lambda res: n.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([u"child"])))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"child"])))
|
||||
|
||||
uploadable1 = upload.Data("some data", convergence="converge")
|
||||
d.addCallback(lambda res: n.add_file(u"newfile", uploadable1))
|
||||
@ -1005,11 +1029,11 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
overwrite=False))
|
||||
d.addCallback(lambda res: n.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([u"child", u"newfile"])))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"child", u"newfile"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"newfile"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
uploadable3 = upload.Data("some data", convergence="converge")
|
||||
d.addCallback(lambda res: n.add_file(u"newfile-metadata",
|
||||
@ -1035,28 +1059,28 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
n.move_child_to(u"child", self.subdir2))
|
||||
d.addCallback(lambda res: n.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([u"newfile", u"subdir2"])))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"newfile", u"subdir2"])))
|
||||
d.addCallback(lambda res: self.subdir2.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([u"child"])))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"child"])))
|
||||
d.addCallback(lambda res: self.subdir2.get(u"child"))
|
||||
d.addCallback(lambda child:
|
||||
self.failUnlessEqual(child.get_uri(),
|
||||
fake_file_uri))
|
||||
self.failUnlessReallyEqual(child.get_uri(),
|
||||
fake_file_uri))
|
||||
|
||||
# move it back, using new_child_name=
|
||||
d.addCallback(lambda res:
|
||||
self.subdir2.move_child_to(u"child", n, u"newchild"))
|
||||
d.addCallback(lambda res: n.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()),
|
||||
set([u"newchild", u"newfile",
|
||||
u"subdir2"])))
|
||||
self.failUnlessReallyEqual(set(children.keys()),
|
||||
set([u"newchild", u"newfile",
|
||||
u"subdir2"])))
|
||||
d.addCallback(lambda res: self.subdir2.list())
|
||||
d.addCallback(lambda children:
|
||||
self.failUnlessEqual(set(children.keys()), set([])))
|
||||
self.failUnlessReallyEqual(set(children.keys()), set([])))
|
||||
|
||||
# now make sure that we honor overwrite=False
|
||||
d.addCallback(lambda res:
|
||||
@ -1071,8 +1095,8 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
overwrite=False))
|
||||
d.addCallback(lambda res: self.subdir2.get(u"newchild"))
|
||||
d.addCallback(lambda child:
|
||||
self.failUnlessEqual(child.get_uri(),
|
||||
other_file_uri))
|
||||
self.failUnlessReallyEqual(child.get_uri(),
|
||||
other_file_uri))
|
||||
|
||||
|
||||
# Setting the no-write field should diminish a mutable cap to read-only
|
||||
@ -1114,18 +1138,18 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
(t1, t2, t3) = (626644800.0, 634745640.0, 892226160.0)
|
||||
|
||||
md1 = dirnode.update_metadata({"ctime": t1}, {}, t2)
|
||||
self.failUnlessEqual(md1, {"tahoe":{"linkcrtime": t1, "linkmotime": t2}})
|
||||
self.failUnlessReallyEqual(md1, {"tahoe":{"linkcrtime": t1, "linkmotime": t2}})
|
||||
|
||||
md2 = dirnode.update_metadata(md1, {"key": "value", "tahoe": {"bad": "mojo"}}, t3)
|
||||
self.failUnlessEqual(md2, {"key": "value",
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t3}})
|
||||
self.failUnlessReallyEqual(md2, {"key": "value",
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t3}})
|
||||
|
||||
md3 = dirnode.update_metadata({}, None, t3)
|
||||
self.failUnlessEqual(md3, {"tahoe":{"linkcrtime": t3, "linkmotime": t3}})
|
||||
self.failUnlessReallyEqual(md3, {"tahoe":{"linkcrtime": t3, "linkmotime": t3}})
|
||||
|
||||
md4 = dirnode.update_metadata({}, {"bool": True, "number": 42}, t1)
|
||||
self.failUnlessEqual(md4, {"bool": True, "number": 42,
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t1}})
|
||||
self.failUnlessReallyEqual(md4, {"bool": True, "number": 42,
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t1}})
|
||||
|
||||
def test_create_subdirectory(self):
|
||||
self.basedir = "dirnode/Dirnode/test_create_subdirectory"
|
||||
@ -1146,14 +1170,14 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d = n.create_subdirectory(u"subdir", kids)
|
||||
def _check(sub):
|
||||
d = n.get_child_at_path(u"subdir")
|
||||
d.addCallback(lambda sub2: self.failUnlessEqual(sub2.get_uri(),
|
||||
sub.get_uri()))
|
||||
d.addCallback(lambda sub2: self.failUnlessReallyEqual(sub2.get_uri(),
|
||||
sub.get_uri()))
|
||||
d.addCallback(lambda ign: sub.list())
|
||||
return d
|
||||
d.addCallback(_check)
|
||||
def _check_kids(kids2):
|
||||
self.failUnlessEqual(set(kids.keys()), set(kids2.keys()))
|
||||
self.failUnlessEqual(kids2[u"kid2"][1]["metakey"], "metavalue")
|
||||
self.failUnlessReallyEqual(set(kids.keys()), set(kids2.keys()))
|
||||
self.failUnlessReallyEqual(kids2[u"kid2"][1]["metakey"], "metavalue")
|
||||
d.addCallback(_check_kids)
|
||||
return d
|
||||
d.addCallback(_then)
|
||||
@ -1163,7 +1187,7 @@ class MinimalFakeMutableFile:
|
||||
def get_writekey(self):
|
||||
return "writekey"
|
||||
|
||||
class Packing(unittest.TestCase):
|
||||
class Packing(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
# This is a base32-encoded representation of the directory tree
|
||||
# root/file1
|
||||
# root/file2
|
||||
@ -1200,30 +1224,30 @@ class Packing(unittest.TestCase):
|
||||
file3_rocap = "URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
|
||||
file3_rwcap = "URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
|
||||
file3_metadata = {'ctime': 1246663897.4336269, 'tahoe': {'linkmotime': 1246663897.4336269, 'linkcrtime': 1246663897.4336269}, 'mtime': 1246663897.4336269}
|
||||
self.failUnlessEqual(file3_metadata, children[u'file3'][1])
|
||||
self.failUnlessEqual(file3_rocap,
|
||||
children[u'file3'][0].get_readonly_uri())
|
||||
self.failUnlessEqual(file3_rwcap,
|
||||
children[u'file3'][0].get_uri())
|
||||
self.failUnlessReallyEqual(file3_metadata, children[u'file3'][1])
|
||||
self.failUnlessReallyEqual(file3_rocap,
|
||||
children[u'file3'][0].get_readonly_uri())
|
||||
self.failUnlessReallyEqual(file3_rwcap,
|
||||
children[u'file3'][0].get_uri())
|
||||
|
||||
# Are the metadata for child 2 right?
|
||||
file2_rocap = "URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
|
||||
file2_rwcap = "URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
|
||||
file2_metadata = {'ctime': 1246663897.430218, 'tahoe': {'linkmotime': 1246663897.430218, 'linkcrtime': 1246663897.430218}, 'mtime': 1246663897.430218}
|
||||
self.failUnlessEqual(file2_metadata, children[u'file2'][1])
|
||||
self.failUnlessEqual(file2_rocap,
|
||||
self.failUnlessReallyEqual(file2_metadata, children[u'file2'][1])
|
||||
self.failUnlessReallyEqual(file2_rocap,
|
||||
children[u'file2'][0].get_readonly_uri())
|
||||
self.failUnlessEqual(file2_rwcap,
|
||||
self.failUnlessReallyEqual(file2_rwcap,
|
||||
children[u'file2'][0].get_uri())
|
||||
|
||||
# Are the metadata for child 1 right?
|
||||
file1_rocap = "URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
|
||||
file1_rwcap = "URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
|
||||
file1_metadata = {'ctime': 1246663897.4275661, 'tahoe': {'linkmotime': 1246663897.4275661, 'linkcrtime': 1246663897.4275661}, 'mtime': 1246663897.4275661}
|
||||
self.failUnlessEqual(file1_metadata, children[u'file1'][1])
|
||||
self.failUnlessEqual(file1_rocap,
|
||||
self.failUnlessReallyEqual(file1_metadata, children[u'file1'][1])
|
||||
self.failUnlessReallyEqual(file1_rocap,
|
||||
children[u'file1'][0].get_readonly_uri())
|
||||
self.failUnlessEqual(file1_rwcap,
|
||||
self.failUnlessReallyEqual(file1_rwcap,
|
||||
children[u'file1'][0].get_uri())
|
||||
|
||||
def _make_kids(self, nm, which):
|
||||
@ -1340,7 +1364,7 @@ class FakeClient2(Client):
|
||||
def create_node_from_uri(self, rwcap, rocap):
|
||||
return self.nodemaker.create_from_cap(rwcap, rocap)
|
||||
|
||||
class Dirnode2(unittest.TestCase, testutil.ShouldFailMixin):
|
||||
class Dirnode2(testutil.ReallyEqualMixin, testutil.ShouldFailMixin, unittest.TestCase):
|
||||
def setUp(self):
|
||||
client = FakeClient2()
|
||||
self.nodemaker = client.nodemaker
|
||||
@ -1349,9 +1373,9 @@ class Dirnode2(unittest.TestCase, testutil.ShouldFailMixin):
|
||||
# Create a mutable directory that contains unknown URI types, and make sure
|
||||
# we tolerate them properly.
|
||||
d = self.nodemaker.create_new_mutable_directory()
|
||||
future_write_uri = "x-tahoe-crazy://I_am_from_the_future."
|
||||
future_read_uri = "x-tahoe-crazy-readonly://I_am_from_the_future."
|
||||
future_imm_uri = "x-tahoe-crazy-immutable://I_am_from_the_future."
|
||||
future_write_uri = u"x-tahoe-crazy://I_am_from_the_future_rw_\u263A".encode('utf-8')
|
||||
future_read_uri = u"x-tahoe-crazy-readonly://I_am_from_the_future_ro_\u263A".encode('utf-8')
|
||||
future_imm_uri = u"x-tahoe-crazy-immutable://I_am_from_the_future_imm_\u263A".encode('utf-8')
|
||||
future_node = UnknownNode(future_write_uri, future_read_uri)
|
||||
def _then(n):
|
||||
self._node = n
|
||||
@ -1382,30 +1406,30 @@ class Dirnode2(unittest.TestCase, testutil.ShouldFailMixin):
|
||||
|
||||
d.addCallback(lambda ign: self._node.list())
|
||||
def _check(children):
|
||||
self.failUnlessEqual(len(children), 4)
|
||||
self.failUnlessReallyEqual(len(children), 4)
|
||||
(fn, metadata) = children[u"future"]
|
||||
self.failUnless(isinstance(fn, UnknownNode), fn)
|
||||
self.failUnlessEqual(fn.get_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fn.get_write_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fn.get_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fn.get_write_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
|
||||
|
||||
(fn2, metadata2) = children[u"add-pair"]
|
||||
self.failUnless(isinstance(fn2, UnknownNode), fn2)
|
||||
self.failUnlessEqual(fn2.get_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fn2.get_write_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fn2.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fn2.get_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fn2.get_write_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fn2.get_readonly_uri(), "ro." + future_read_uri)
|
||||
|
||||
(fn3, metadata3) = children[u"add-ro"]
|
||||
self.failUnless(isinstance(fn3, UnknownNode), fn3)
|
||||
self.failUnlessEqual(fn3.get_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessEqual(fn3.get_write_uri(), None)
|
||||
self.failUnlessEqual(fn3.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fn3.get_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fn3.get_write_uri(), None)
|
||||
self.failUnlessReallyEqual(fn3.get_readonly_uri(), "ro." + future_read_uri)
|
||||
|
||||
(fn4, metadata4) = children[u"add-imm"]
|
||||
self.failUnless(isinstance(fn4, UnknownNode), fn4)
|
||||
self.failUnlessEqual(fn4.get_uri(), "imm." + future_imm_uri)
|
||||
self.failUnlessEqual(fn4.get_write_uri(), None)
|
||||
self.failUnlessEqual(fn4.get_readonly_uri(), "imm." + future_imm_uri)
|
||||
self.failUnlessReallyEqual(fn4.get_uri(), "imm." + future_imm_uri)
|
||||
self.failUnlessReallyEqual(fn4.get_write_uri(), None)
|
||||
self.failUnlessReallyEqual(fn4.get_readonly_uri(), "imm." + future_imm_uri)
|
||||
|
||||
# We should also be allowed to copy the "future" UnknownNode, because
|
||||
# it contains all the information that was in the original directory
|
||||
@ -1415,22 +1439,22 @@ class Dirnode2(unittest.TestCase, testutil.ShouldFailMixin):
|
||||
|
||||
d.addCallback(lambda ign: self._node.list())
|
||||
def _check2(children):
|
||||
self.failUnlessEqual(len(children), 5)
|
||||
self.failUnlessReallyEqual(len(children), 5)
|
||||
(fn, metadata) = children[u"copy"]
|
||||
self.failUnless(isinstance(fn, UnknownNode), fn)
|
||||
self.failUnlessEqual(fn.get_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fn.get_write_uri(), future_write_uri)
|
||||
self.failUnlessEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
|
||||
self.failUnlessReallyEqual(fn.get_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fn.get_write_uri(), future_write_uri)
|
||||
self.failUnlessReallyEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
|
||||
d.addCallback(_check2)
|
||||
return d
|
||||
|
||||
def test_unknown_strip_prefix_for_ro(self):
|
||||
self.failUnlessEqual(strip_prefix_for_ro("foo", False), "foo")
|
||||
self.failUnlessEqual(strip_prefix_for_ro("ro.foo", False), "foo")
|
||||
self.failUnlessEqual(strip_prefix_for_ro("imm.foo", False), "imm.foo")
|
||||
self.failUnlessEqual(strip_prefix_for_ro("foo", True), "foo")
|
||||
self.failUnlessEqual(strip_prefix_for_ro("ro.foo", True), "foo")
|
||||
self.failUnlessEqual(strip_prefix_for_ro("imm.foo", True), "foo")
|
||||
self.failUnlessReallyEqual(strip_prefix_for_ro("foo", False), "foo")
|
||||
self.failUnlessReallyEqual(strip_prefix_for_ro("ro.foo", False), "foo")
|
||||
self.failUnlessReallyEqual(strip_prefix_for_ro("imm.foo", False), "imm.foo")
|
||||
self.failUnlessReallyEqual(strip_prefix_for_ro("foo", True), "foo")
|
||||
self.failUnlessReallyEqual(strip_prefix_for_ro("ro.foo", True), "foo")
|
||||
self.failUnlessReallyEqual(strip_prefix_for_ro("imm.foo", True), "foo")
|
||||
|
||||
def test_unknownnode(self):
|
||||
mut_write_uri = "URI:SSK:vfvcbdfbszyrsaxchgevhmmlii:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
|
||||
@ -1528,7 +1552,7 @@ class Dirnode2(unittest.TestCase, testutil.ShouldFailMixin):
|
||||
self.failUnless(n.get_readonly_uri().startswith("imm."), i)
|
||||
|
||||
|
||||
class DeepStats(unittest.TestCase):
|
||||
class DeepStats(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
timeout = 240 # It takes longer than 120 seconds on Francois's arm box.
|
||||
def test_stats(self):
|
||||
ds = dirnode.DeepStats(None)
|
||||
@ -1538,10 +1562,10 @@ class DeepStats(unittest.TestCase):
|
||||
ds.max("largest-directory", 444)
|
||||
|
||||
s = ds.get_results()
|
||||
self.failUnlessEqual(s["count-files"], 1)
|
||||
self.failUnlessEqual(s["size-immutable-files"], 123)
|
||||
self.failUnlessEqual(s["largest-directory"], 444)
|
||||
self.failUnlessEqual(s["count-literal-files"], 0)
|
||||
self.failUnlessReallyEqual(s["count-files"], 1)
|
||||
self.failUnlessReallyEqual(s["size-immutable-files"], 123)
|
||||
self.failUnlessReallyEqual(s["largest-directory"], 444)
|
||||
self.failUnlessReallyEqual(s["count-literal-files"], 0)
|
||||
|
||||
ds.add("count-files")
|
||||
ds.add("size-immutable-files", 321)
|
||||
@ -1549,11 +1573,11 @@ class DeepStats(unittest.TestCase):
|
||||
ds.max("largest-directory", 2)
|
||||
|
||||
s = ds.get_results()
|
||||
self.failUnlessEqual(s["count-files"], 2)
|
||||
self.failUnlessEqual(s["size-immutable-files"], 444)
|
||||
self.failUnlessEqual(s["largest-directory"], 444)
|
||||
self.failUnlessEqual(s["count-literal-files"], 0)
|
||||
self.failUnlessEqual(s["size-files-histogram"],
|
||||
self.failUnlessReallyEqual(s["count-files"], 2)
|
||||
self.failUnlessReallyEqual(s["size-immutable-files"], 444)
|
||||
self.failUnlessReallyEqual(s["largest-directory"], 444)
|
||||
self.failUnlessReallyEqual(s["count-literal-files"], 0)
|
||||
self.failUnlessReallyEqual(s["size-files-histogram"],
|
||||
[ (101, 316, 1), (317, 1000, 1) ])
|
||||
|
||||
ds = dirnode.DeepStats(None)
|
||||
@ -1561,7 +1585,7 @@ class DeepStats(unittest.TestCase):
|
||||
ds.histogram("size-files-histogram", i)
|
||||
ds.histogram("size-files-histogram", 4*1000*1000*1000*1000) # 4TB
|
||||
s = ds.get_results()
|
||||
self.failUnlessEqual(s["size-files-histogram"],
|
||||
self.failUnlessReallyEqual(s["size-files-histogram"],
|
||||
[ (1, 3, 3),
|
||||
(4, 10, 7),
|
||||
(11, 31, 21),
|
||||
@ -1593,7 +1617,7 @@ class UCWEingNodeMaker(NodeMaker):
|
||||
return n.init_from_cap(cap)
|
||||
|
||||
|
||||
class Deleter(GridTestMixin, unittest.TestCase):
|
||||
class Deleter(GridTestMixin, testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
timeout = 3600 # It takes longer than 433 seconds on Zandr's ARM box.
|
||||
def test_retry(self):
|
||||
# ticket #550, a dirnode.delete which experiences an
|
||||
|
||||
@ -4,15 +4,16 @@ from allmydata import uri
|
||||
from allmydata.util import hashutil, base32
|
||||
from allmydata.interfaces import IURI, IFileURI, IDirnodeURI, IMutableFileURI, \
|
||||
IVerifierURI, CapConstraintError
|
||||
import allmydata.test.common_util as testutil
|
||||
|
||||
class Literal(unittest.TestCase):
|
||||
class Literal(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def _help_test(self, data):
|
||||
u = uri.LiteralFileURI(data)
|
||||
self.failUnless(IURI.providedBy(u))
|
||||
self.failUnless(IFileURI.providedBy(u))
|
||||
self.failIf(IDirnodeURI.providedBy(u))
|
||||
self.failUnlessEqual(u.data, data)
|
||||
self.failUnlessEqual(u.get_size(), len(data))
|
||||
self.failUnlessReallyEqual(u.data, data)
|
||||
self.failUnlessReallyEqual(u.get_size(), len(data))
|
||||
self.failUnless(u.is_readonly())
|
||||
self.failIf(u.is_mutable())
|
||||
|
||||
@ -20,26 +21,26 @@ class Literal(unittest.TestCase):
|
||||
self.failUnless(IURI.providedBy(u2))
|
||||
self.failUnless(IFileURI.providedBy(u2))
|
||||
self.failIf(IDirnodeURI.providedBy(u2))
|
||||
self.failUnlessEqual(u2.data, data)
|
||||
self.failUnlessEqual(u2.get_size(), len(data))
|
||||
self.failUnlessReallyEqual(u2.data, data)
|
||||
self.failUnlessReallyEqual(u2.get_size(), len(data))
|
||||
self.failUnless(u2.is_readonly())
|
||||
self.failIf(u2.is_mutable())
|
||||
|
||||
u2i = uri.from_string(u.to_string(), deep_immutable=True)
|
||||
self.failUnless(IFileURI.providedBy(u2i))
|
||||
self.failIf(IDirnodeURI.providedBy(u2i))
|
||||
self.failUnlessEqual(u2i.data, data)
|
||||
self.failUnlessEqual(u2i.get_size(), len(data))
|
||||
self.failUnlessReallyEqual(u2i.data, data)
|
||||
self.failUnlessReallyEqual(u2i.get_size(), len(data))
|
||||
self.failUnless(u2i.is_readonly())
|
||||
self.failIf(u2i.is_mutable())
|
||||
|
||||
u3 = u.get_readonly()
|
||||
self.failUnlessIdentical(u, u3)
|
||||
self.failUnlessEqual(u.get_verify_cap(), None)
|
||||
self.failUnlessReallyEqual(u.get_verify_cap(), None)
|
||||
|
||||
he = u.to_human_encoding()
|
||||
u_h = uri.LiteralFileURI.init_from_human_encoding(he)
|
||||
self.failUnlessEqual(u, u_h)
|
||||
self.failUnlessReallyEqual(u, u_h)
|
||||
|
||||
def test_empty(self):
|
||||
data = "" # This data is some *very* small data!
|
||||
@ -53,7 +54,7 @@ class Literal(unittest.TestCase):
|
||||
data = "This contains \x00 and URI:LIT: and \n, oh my."
|
||||
return self._help_test(data)
|
||||
|
||||
class Compare(unittest.TestCase):
|
||||
class Compare(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_compare(self):
|
||||
lit1 = uri.LiteralFileURI("some data")
|
||||
fileURI = 'URI:CHK:f5ahxa25t4qkktywz6teyfvcx4:opuioq7tj2y6idzfp6cazehtmgs5fdcebcz3cygrxyydvcozrmeq:3:10:345834'
|
||||
@ -61,11 +62,11 @@ class Compare(unittest.TestCase):
|
||||
chk2 = uri.CHKFileURI.init_from_string(fileURI)
|
||||
unk = uri.UnknownURI("lafs://from_the_future")
|
||||
self.failIfEqual(lit1, chk1)
|
||||
self.failUnlessEqual(chk1, chk2)
|
||||
self.failUnlessReallyEqual(chk1, chk2)
|
||||
self.failIfEqual(chk1, "not actually a URI")
|
||||
# these should be hashable too
|
||||
s = set([lit1, chk1, chk2, unk])
|
||||
self.failUnlessEqual(len(s), 3) # since chk1==chk2
|
||||
self.failUnlessReallyEqual(len(s), 3) # since chk1==chk2
|
||||
|
||||
def test_is_uri(self):
|
||||
lit1 = uri.LiteralFileURI("some data").to_string()
|
||||
@ -89,7 +90,7 @@ class Compare(unittest.TestCase):
|
||||
self.failIf(uri.has_uri_prefix(None))
|
||||
self.failIf(uri.has_uri_prefix("foo"))
|
||||
|
||||
class CHKFile(unittest.TestCase):
|
||||
class CHKFile(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_pack(self):
|
||||
key = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
|
||||
storage_index = hashutil.storage_index_hash(key)
|
||||
@ -102,45 +103,45 @@ class CHKFile(unittest.TestCase):
|
||||
needed_shares=needed_shares,
|
||||
total_shares=total_shares,
|
||||
size=size)
|
||||
self.failUnlessEqual(u.get_storage_index(), storage_index)
|
||||
self.failUnlessEqual(u.key, key)
|
||||
self.failUnlessEqual(u.uri_extension_hash, uri_extension_hash)
|
||||
self.failUnlessEqual(u.needed_shares, needed_shares)
|
||||
self.failUnlessEqual(u.total_shares, total_shares)
|
||||
self.failUnlessEqual(u.size, size)
|
||||
self.failUnlessReallyEqual(u.get_storage_index(), storage_index)
|
||||
self.failUnlessReallyEqual(u.key, key)
|
||||
self.failUnlessReallyEqual(u.uri_extension_hash, uri_extension_hash)
|
||||
self.failUnlessReallyEqual(u.needed_shares, needed_shares)
|
||||
self.failUnlessReallyEqual(u.total_shares, total_shares)
|
||||
self.failUnlessReallyEqual(u.size, size)
|
||||
self.failUnless(u.is_readonly())
|
||||
self.failIf(u.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u))
|
||||
self.failUnless(IFileURI.providedBy(u))
|
||||
self.failIf(IDirnodeURI.providedBy(u))
|
||||
self.failUnlessEqual(u.get_size(), 1234)
|
||||
self.failUnlessReallyEqual(u.get_size(), 1234)
|
||||
|
||||
u_ro = u.get_readonly()
|
||||
self.failUnlessIdentical(u, u_ro)
|
||||
he = u.to_human_encoding()
|
||||
self.failUnlessEqual(he, "http://127.0.0.1:3456/uri/" + u.to_string())
|
||||
self.failUnlessEqual(uri.CHKFileURI.init_from_human_encoding(he), u)
|
||||
self.failUnlessReallyEqual(he, "http://127.0.0.1:3456/uri/" + u.to_string())
|
||||
self.failUnlessReallyEqual(uri.CHKFileURI.init_from_human_encoding(he), u)
|
||||
|
||||
u2 = uri.from_string(u.to_string())
|
||||
self.failUnlessEqual(u2.get_storage_index(), storage_index)
|
||||
self.failUnlessEqual(u2.key, key)
|
||||
self.failUnlessEqual(u2.uri_extension_hash, uri_extension_hash)
|
||||
self.failUnlessEqual(u2.needed_shares, needed_shares)
|
||||
self.failUnlessEqual(u2.total_shares, total_shares)
|
||||
self.failUnlessEqual(u2.size, size)
|
||||
self.failUnlessReallyEqual(u2.get_storage_index(), storage_index)
|
||||
self.failUnlessReallyEqual(u2.key, key)
|
||||
self.failUnlessReallyEqual(u2.uri_extension_hash, uri_extension_hash)
|
||||
self.failUnlessReallyEqual(u2.needed_shares, needed_shares)
|
||||
self.failUnlessReallyEqual(u2.total_shares, total_shares)
|
||||
self.failUnlessReallyEqual(u2.size, size)
|
||||
self.failUnless(u2.is_readonly())
|
||||
self.failIf(u2.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u2))
|
||||
self.failUnless(IFileURI.providedBy(u2))
|
||||
self.failIf(IDirnodeURI.providedBy(u2))
|
||||
self.failUnlessEqual(u2.get_size(), 1234)
|
||||
self.failUnlessReallyEqual(u2.get_size(), 1234)
|
||||
|
||||
u2i = uri.from_string(u.to_string(), deep_immutable=True)
|
||||
self.failUnlessEqual(u.to_string(), u2i.to_string())
|
||||
self.failUnlessReallyEqual(u.to_string(), u2i.to_string())
|
||||
u2ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u.to_string())
|
||||
self.failUnlessEqual(u.to_string(), u2ro.to_string())
|
||||
self.failUnlessReallyEqual(u.to_string(), u2ro.to_string())
|
||||
u2imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u.to_string())
|
||||
self.failUnlessEqual(u.to_string(), u2imm.to_string())
|
||||
self.failUnlessReallyEqual(u.to_string(), u2imm.to_string())
|
||||
|
||||
v = u.get_verify_cap()
|
||||
self.failUnless(isinstance(v.to_string(), str))
|
||||
@ -148,10 +149,10 @@ class CHKFile(unittest.TestCase):
|
||||
self.failIf(v.is_mutable())
|
||||
|
||||
v2 = uri.from_string(v.to_string())
|
||||
self.failUnlessEqual(v, v2)
|
||||
self.failUnlessReallyEqual(v, v2)
|
||||
he = v.to_human_encoding()
|
||||
v2_h = uri.CHKFileVerifierURI.init_from_human_encoding(he)
|
||||
self.failUnlessEqual(v2, v2_h)
|
||||
self.failUnlessReallyEqual(v2, v2_h)
|
||||
|
||||
v3 = uri.CHKFileVerifierURI(storage_index="\x00"*16,
|
||||
uri_extension_hash="\x00"*32,
|
||||
@ -192,7 +193,7 @@ class CHKFile(unittest.TestCase):
|
||||
)
|
||||
|
||||
|
||||
class Extension(unittest.TestCase):
|
||||
class Extension(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_pack(self):
|
||||
data = {"stuff": "value",
|
||||
"size": 12,
|
||||
@ -201,35 +202,48 @@ class Extension(unittest.TestCase):
|
||||
}
|
||||
ext = uri.pack_extension(data)
|
||||
d = uri.unpack_extension(ext)
|
||||
self.failUnlessEqual(d["stuff"], "value")
|
||||
self.failUnlessEqual(d["size"], 12)
|
||||
self.failUnlessEqual(d["big_hash"], hashutil.tagged_hash("foo", "bar"))
|
||||
self.failUnlessReallyEqual(d["stuff"], "value")
|
||||
self.failUnlessReallyEqual(d["size"], 12)
|
||||
self.failUnlessReallyEqual(d["big_hash"], hashutil.tagged_hash("foo", "bar"))
|
||||
|
||||
readable = uri.unpack_extension_readable(ext)
|
||||
self.failUnlessEqual(readable["needed_shares"], 3)
|
||||
self.failUnlessEqual(readable["stuff"], "value")
|
||||
self.failUnlessEqual(readable["size"], 12)
|
||||
self.failUnlessEqual(readable["big_hash"],
|
||||
self.failUnlessReallyEqual(readable["needed_shares"], 3)
|
||||
self.failUnlessReallyEqual(readable["stuff"], "value")
|
||||
self.failUnlessReallyEqual(readable["size"], 12)
|
||||
self.failUnlessReallyEqual(readable["big_hash"],
|
||||
base32.b2a(hashutil.tagged_hash("foo", "bar")))
|
||||
self.failUnlessEqual(readable["UEB_hash"],
|
||||
self.failUnlessReallyEqual(readable["UEB_hash"],
|
||||
base32.b2a(hashutil.uri_extension_hash(ext)))
|
||||
|
||||
class Unknown(unittest.TestCase):
|
||||
class Unknown(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_from_future(self):
|
||||
# any URI type that we don't recognize should be treated as unknown
|
||||
future_uri = "I am a URI from the future. Whatever you do, don't "
|
||||
u = uri.from_string(future_uri)
|
||||
self.failUnless(isinstance(u, uri.UnknownURI))
|
||||
self.failUnlessEqual(u.to_string(), future_uri)
|
||||
self.failUnlessReallyEqual(u.to_string(), future_uri)
|
||||
self.failUnless(u.get_readonly() is None)
|
||||
self.failUnless(u.get_error() is None)
|
||||
|
||||
u2 = uri.UnknownURI(future_uri, error=CapConstraintError("..."))
|
||||
self.failUnlessEqual(u.to_string(), future_uri)
|
||||
self.failUnlessReallyEqual(u.to_string(), future_uri)
|
||||
self.failUnless(u2.get_readonly() is None)
|
||||
self.failUnless(isinstance(u2.get_error(), CapConstraintError))
|
||||
|
||||
class Constraint(unittest.TestCase):
|
||||
# Future caps might have non-ASCII chars in them. (Or maybe not, who can tell about the future?)
|
||||
future_uri = u"I am a cap from the \u263A future. Whatever you ".encode('utf-8')
|
||||
u = uri.from_string(future_uri)
|
||||
self.failUnless(isinstance(u, uri.UnknownURI))
|
||||
self.failUnlessReallyEqual(u.to_string(), future_uri)
|
||||
self.failUnless(u.get_readonly() is None)
|
||||
self.failUnless(u.get_error() is None)
|
||||
|
||||
u2 = uri.UnknownURI(future_uri, error=CapConstraintError("..."))
|
||||
self.failUnlessReallyEqual(u.to_string(), future_uri)
|
||||
self.failUnless(u2.get_readonly() is None)
|
||||
self.failUnless(isinstance(u2.get_error(), CapConstraintError))
|
||||
|
||||
class Constraint(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_constraint(self):
|
||||
good="http://127.0.0.1:3456/uri/URI%3ADIR2%3Agh3l5rbvnv2333mrfvalmjfr4i%3Alz6l7u3z3b7g37s4zkdmfpx5ly4ib4m6thrpbusi6ys62qtc6mma/"
|
||||
uri.DirectoryURI.init_from_human_encoding(good)
|
||||
@ -240,14 +254,14 @@ class Constraint(unittest.TestCase):
|
||||
fileURI = 'URI:CHK:gh3l5rbvnv2333mrfvalmjfr4i:lz6l7u3z3b7g37s4zkdmfpx5ly4ib4m6thrpbusi6ys62qtc6mma:3:10:345834'
|
||||
uri.CHKFileURI.init_from_string(fileURI)
|
||||
|
||||
class Mutable(unittest.TestCase):
|
||||
class Mutable(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_pack(self):
|
||||
writekey = "\x01" * 16
|
||||
fingerprint = "\x02" * 32
|
||||
|
||||
u = uri.WriteableSSKFileURI(writekey, fingerprint)
|
||||
self.failUnlessEqual(u.writekey, writekey)
|
||||
self.failUnlessEqual(u.fingerprint, fingerprint)
|
||||
self.failUnlessReallyEqual(u.writekey, writekey)
|
||||
self.failUnlessReallyEqual(u.fingerprint, fingerprint)
|
||||
self.failIf(u.is_readonly())
|
||||
self.failUnless(u.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u))
|
||||
@ -257,11 +271,11 @@ class Mutable(unittest.TestCase):
|
||||
|
||||
he = u.to_human_encoding()
|
||||
u_h = uri.WriteableSSKFileURI.init_from_human_encoding(he)
|
||||
self.failUnlessEqual(u, u_h)
|
||||
self.failUnlessReallyEqual(u, u_h)
|
||||
|
||||
u2 = uri.from_string(u.to_string())
|
||||
self.failUnlessEqual(u2.writekey, writekey)
|
||||
self.failUnlessEqual(u2.fingerprint, fingerprint)
|
||||
self.failUnlessReallyEqual(u2.writekey, writekey)
|
||||
self.failUnlessReallyEqual(u2.fingerprint, fingerprint)
|
||||
self.failIf(u2.is_readonly())
|
||||
self.failUnless(u2.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u2))
|
||||
@ -277,8 +291,8 @@ class Mutable(unittest.TestCase):
|
||||
|
||||
u3 = u2.get_readonly()
|
||||
readkey = hashutil.ssk_readkey_hash(writekey)
|
||||
self.failUnlessEqual(u3.fingerprint, fingerprint)
|
||||
self.failUnlessEqual(u3.readkey, readkey)
|
||||
self.failUnlessReallyEqual(u3.fingerprint, fingerprint)
|
||||
self.failUnlessReallyEqual(u3.readkey, readkey)
|
||||
self.failUnless(u3.is_readonly())
|
||||
self.failUnless(u3.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u3))
|
||||
@ -288,17 +302,17 @@ class Mutable(unittest.TestCase):
|
||||
u3i = uri.from_string(u3.to_string(), deep_immutable=True)
|
||||
self.failUnless(isinstance(u3i, uri.UnknownURI), u3i)
|
||||
u3ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u3.to_string())
|
||||
self.failUnlessEqual(u3.to_string(), u3ro.to_string())
|
||||
self.failUnlessReallyEqual(u3.to_string(), u3ro.to_string())
|
||||
u3imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u3.to_string())
|
||||
self.failUnless(isinstance(u3imm, uri.UnknownURI), u3imm)
|
||||
|
||||
he = u3.to_human_encoding()
|
||||
u3_h = uri.ReadonlySSKFileURI.init_from_human_encoding(he)
|
||||
self.failUnlessEqual(u3, u3_h)
|
||||
self.failUnlessReallyEqual(u3, u3_h)
|
||||
|
||||
u4 = uri.ReadonlySSKFileURI(readkey, fingerprint)
|
||||
self.failUnlessEqual(u4.fingerprint, fingerprint)
|
||||
self.failUnlessEqual(u4.readkey, readkey)
|
||||
self.failUnlessReallyEqual(u4.fingerprint, fingerprint)
|
||||
self.failUnlessReallyEqual(u4.readkey, readkey)
|
||||
self.failUnless(u4.is_readonly())
|
||||
self.failUnless(u4.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u4))
|
||||
@ -308,28 +322,28 @@ class Mutable(unittest.TestCase):
|
||||
u4i = uri.from_string(u4.to_string(), deep_immutable=True)
|
||||
self.failUnless(isinstance(u4i, uri.UnknownURI), u4i)
|
||||
u4ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u4.to_string())
|
||||
self.failUnlessEqual(u4.to_string(), u4ro.to_string())
|
||||
self.failUnlessReallyEqual(u4.to_string(), u4ro.to_string())
|
||||
u4imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u4.to_string())
|
||||
self.failUnless(isinstance(u4imm, uri.UnknownURI), u4imm)
|
||||
|
||||
u4a = uri.from_string(u4.to_string())
|
||||
self.failUnlessEqual(u4a, u4)
|
||||
self.failUnlessReallyEqual(u4a, u4)
|
||||
self.failUnless("ReadonlySSKFileURI" in str(u4a))
|
||||
self.failUnlessIdentical(u4a.get_readonly(), u4a)
|
||||
|
||||
u5 = u4.get_verify_cap()
|
||||
self.failUnless(IVerifierURI.providedBy(u5))
|
||||
self.failUnlessEqual(u5.get_storage_index(), u.get_storage_index())
|
||||
self.failUnlessReallyEqual(u5.get_storage_index(), u.get_storage_index())
|
||||
u7 = u.get_verify_cap()
|
||||
self.failUnless(IVerifierURI.providedBy(u7))
|
||||
self.failUnlessEqual(u7.get_storage_index(), u.get_storage_index())
|
||||
self.failUnlessReallyEqual(u7.get_storage_index(), u.get_storage_index())
|
||||
|
||||
he = u5.to_human_encoding()
|
||||
u5_h = uri.SSKVerifierURI.init_from_human_encoding(he)
|
||||
self.failUnlessEqual(u5, u5_h)
|
||||
self.failUnlessReallyEqual(u5, u5_h)
|
||||
|
||||
|
||||
class Dirnode(unittest.TestCase):
|
||||
class Dirnode(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
def test_pack(self):
|
||||
writekey = "\x01" * 16
|
||||
fingerprint = "\x02" * 32
|
||||
@ -347,7 +361,7 @@ class Dirnode(unittest.TestCase):
|
||||
self.failIf(u1_filenode.is_readonly())
|
||||
|
||||
u2 = uri.from_string(u1.to_string())
|
||||
self.failUnlessEqual(u1.to_string(), u2.to_string())
|
||||
self.failUnlessReallyEqual(u1.to_string(), u2.to_string())
|
||||
self.failIf(u2.is_readonly())
|
||||
self.failUnless(u2.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u2))
|
||||
@ -378,7 +392,7 @@ class Dirnode(unittest.TestCase):
|
||||
self.failUnlessIdentical(u3a, u3a.get_readonly())
|
||||
|
||||
u4 = uri.ReadonlyDirectoryURI(u2._filenode_uri.get_readonly())
|
||||
self.failUnlessEqual(u4.to_string(), u3.to_string())
|
||||
self.failUnlessReallyEqual(u4.to_string(), u3.to_string())
|
||||
self.failUnless(u4.is_readonly())
|
||||
self.failUnless(u4.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u4))
|
||||
@ -395,7 +409,7 @@ class Dirnode(unittest.TestCase):
|
||||
]
|
||||
for v in verifiers:
|
||||
self.failUnless(IVerifierURI.providedBy(v))
|
||||
self.failUnlessEqual(v._filenode_uri,
|
||||
self.failUnlessReallyEqual(v._filenode_uri,
|
||||
u1.get_verify_cap()._filenode_uri)
|
||||
|
||||
def test_immutable(self):
|
||||
@ -411,7 +425,7 @@ class Dirnode(unittest.TestCase):
|
||||
total_shares=total_shares,
|
||||
size=size)
|
||||
fncap = fnuri.to_string()
|
||||
self.failUnlessEqual(fncap, "URI:CHK:aeaqcaibaeaqcaibaeaqcaibae:nf3nimquen7aeqm36ekgxomalstenpkvsdmf6fplj7swdatbv5oa:3:10:1234")
|
||||
self.failUnlessReallyEqual(fncap, "URI:CHK:aeaqcaibaeaqcaibaeaqcaibae:nf3nimquen7aeqm36ekgxomalstenpkvsdmf6fplj7swdatbv5oa:3:10:1234")
|
||||
u1 = uri.ImmutableDirectoryURI(fnuri)
|
||||
self.failUnless(u1.is_readonly())
|
||||
self.failIf(u1.is_mutable())
|
||||
@ -422,11 +436,11 @@ class Dirnode(unittest.TestCase):
|
||||
u1_filenode = u1.get_filenode_cap()
|
||||
self.failIf(u1_filenode.is_mutable())
|
||||
self.failUnless(u1_filenode.is_readonly())
|
||||
self.failUnlessEqual(u1_filenode.to_string(), fncap)
|
||||
self.failUnlessReallyEqual(u1_filenode.to_string(), fncap)
|
||||
self.failUnless(str(u1))
|
||||
|
||||
u2 = uri.from_string(u1.to_string())
|
||||
self.failUnlessEqual(u1.to_string(), u2.to_string())
|
||||
self.failUnlessReallyEqual(u1.to_string(), u2.to_string())
|
||||
self.failUnless(u2.is_readonly())
|
||||
self.failIf(u2.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u2))
|
||||
@ -434,14 +448,14 @@ class Dirnode(unittest.TestCase):
|
||||
self.failUnless(IDirnodeURI.providedBy(u2))
|
||||
|
||||
u2i = uri.from_string(u1.to_string(), deep_immutable=True)
|
||||
self.failUnlessEqual(u1.to_string(), u2i.to_string())
|
||||
self.failUnlessReallyEqual(u1.to_string(), u2i.to_string())
|
||||
|
||||
u3 = u2.get_readonly()
|
||||
self.failUnlessEqual(u3.to_string(), u2.to_string())
|
||||
self.failUnlessReallyEqual(u3.to_string(), u2.to_string())
|
||||
self.failUnless(str(u3))
|
||||
|
||||
u3i = uri.from_string(u2.to_string(), deep_immutable=True)
|
||||
self.failUnlessEqual(u2.to_string(), u3i.to_string())
|
||||
self.failUnlessReallyEqual(u2.to_string(), u3i.to_string())
|
||||
|
||||
u2_verifier = u2.get_verify_cap()
|
||||
self.failUnless(isinstance(u2_verifier,
|
||||
@ -455,20 +469,20 @@ class Dirnode(unittest.TestCase):
|
||||
self.failUnless(IVerifierURI.providedBy(u2_verifier_fileuri))
|
||||
u2vfs = u2_verifier_fileuri.to_string()
|
||||
# URI:CHK-Verifier:$key:$ueb:$k:$n:$size
|
||||
self.failUnlessEqual(u2vfs, fnuri.get_verify_cap().to_string())
|
||||
self.failUnlessEqual(u2vs[len("URI:DIR2-"):], u2vfs[len("URI:"):])
|
||||
self.failUnlessReallyEqual(u2vfs, fnuri.get_verify_cap().to_string())
|
||||
self.failUnlessReallyEqual(u2vs[len("URI:DIR2-"):], u2vfs[len("URI:"):])
|
||||
self.failUnless(str(u2_verifier))
|
||||
|
||||
def test_literal(self):
|
||||
u0 = uri.LiteralFileURI("data")
|
||||
u1 = uri.LiteralDirectoryURI(u0)
|
||||
self.failUnless(str(u1))
|
||||
self.failUnlessEqual(u1.to_string(), "URI:DIR2-LIT:mrqxiyi")
|
||||
self.failUnlessReallyEqual(u1.to_string(), "URI:DIR2-LIT:mrqxiyi")
|
||||
self.failUnless(u1.is_readonly())
|
||||
self.failIf(u1.is_mutable())
|
||||
self.failUnless(IURI.providedBy(u1))
|
||||
self.failIf(IFileURI.providedBy(u1))
|
||||
self.failUnless(IDirnodeURI.providedBy(u1))
|
||||
self.failUnlessEqual(u1.get_verify_cap(), None)
|
||||
self.failUnlessEqual(u1.get_storage_index(), None)
|
||||
self.failUnlessEqual(u1.abbrev_si(), "<LIT>")
|
||||
self.failUnlessReallyEqual(u1.get_verify_cap(), None)
|
||||
self.failUnlessReallyEqual(u1.get_storage_index(), None)
|
||||
self.failUnlessReallyEqual(u1.abbrev_si(), "<LIT>")
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user