mirror of
https://github.com/tahoe-lafs/tahoe-lafs.git
synced 2025-01-19 19:26:25 +00:00
test_dirnode and test_web: don't use failUnlessReallyEqual in cases where the return type from simplejson.loads can vary between unicode and str. Use to_str when comparing URIs parsed from JSON.
This commit is contained in:
david-sarah
parent
9a4a864573
commit
74c41ebb8b
@ -127,7 +127,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
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(two_metadata["metakey"], "metavalue")
|
||||
|
||||
self.failUnlessReallyEqual(mut_node.get_uri(), mut_write_uri)
|
||||
self.failUnlessReallyEqual(mut_node.get_readonly_uri(), mut_read_uri)
|
||||
@ -241,7 +241,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
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(two_metadata["metakey"], "metavalue")
|
||||
|
||||
self.failUnless(fut_node.is_unknown())
|
||||
self.failUnlessReallyEqual(fut_node.get_uri(), "imm." + future_read_uri)
|
||||
@ -769,8 +769,8 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"child"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessReallyEqual(set(metadata.keys()),
|
||||
set(["tahoe"])))
|
||||
self.failUnlessEqual(set(metadata.keys()),
|
||||
set(["tahoe"])))
|
||||
|
||||
d.addCallback(lambda res:
|
||||
self.shouldFail(NoSuchChildError, "gcamap-no",
|
||||
@ -783,7 +783,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
child, metadata = res
|
||||
self.failUnless(isinstance(child, dirnode.DirectoryNode))
|
||||
# edge-metadata needs at least one path segment
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set([]))
|
||||
self.failUnlessEqual(set(metadata.keys()), set([]))
|
||||
d.addCallback(_check_child_and_metadata1)
|
||||
d.addCallback(lambda res:
|
||||
n.get_child_and_metadata_at_path(u"child"))
|
||||
@ -792,7 +792,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
child, metadata = res
|
||||
self.failUnlessReallyEqual(child.get_uri(),
|
||||
fake_file_uri)
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
d.addCallback(_check_child_and_metadata2)
|
||||
|
||||
d.addCallback(lambda res:
|
||||
@ -800,7 +800,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
def _check_child_and_metadata3(res):
|
||||
child, metadata = res
|
||||
self.failUnless(isinstance(child, dirnode.DirectoryNode))
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
d.addCallback(_check_child_and_metadata3)
|
||||
|
||||
# set_uri + metadata
|
||||
@ -810,7 +810,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
{}))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"c2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
# You can't override the link timestamps.
|
||||
d.addCallback(lambda res: n.set_uri(u"c2",
|
||||
@ -828,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.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
# we can also add specific metadata at set_uri() time
|
||||
d.addCallback(lambda res: n.set_uri(u"c4",
|
||||
@ -854,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.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(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.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(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,
|
||||
@ -898,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.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"e2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(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
|
||||
@ -929,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.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"f2"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(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
|
||||
@ -975,9 +975,9 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"timestamps"))
|
||||
def _check_timestamp1(metadata):
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
|
||||
tahoe_md = metadata["tahoe"]
|
||||
self.failUnlessReallyEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
self.failUnlessEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
|
||||
self.failUnlessGreaterOrEqualThan(tahoe_md["linkcrtime"],
|
||||
self._start_timestamp)
|
||||
@ -999,7 +999,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
def _check_timestamp2(metadata):
|
||||
self.failUnlessIn("tahoe", metadata)
|
||||
tahoe_md = metadata["tahoe"]
|
||||
self.failUnlessReallyEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
self.failUnlessEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
|
||||
|
||||
self.failUnlessReallyEqual(tahoe_md["linkcrtime"], self._old_linkcrtime)
|
||||
self.failUnlessGreaterThan(tahoe_md["linkmotime"], self._old_linkmotime)
|
||||
@ -1009,7 +1009,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
d.addCallback(lambda res: n.delete(u"subdir"))
|
||||
d.addCallback(lambda old_child:
|
||||
self.failUnlessReallyEqual(old_child.get_uri(),
|
||||
self.subdir.get_uri()))
|
||||
self.subdir.get_uri()))
|
||||
|
||||
d.addCallback(lambda res: n.list())
|
||||
d.addCallback(lambda children:
|
||||
@ -1033,7 +1033,7 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
set([u"child", u"newfile"])))
|
||||
d.addCallback(lambda res: n.get_metadata_for(u"newfile"))
|
||||
d.addCallback(lambda metadata:
|
||||
self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
|
||||
|
||||
uploadable3 = upload.Data("some data", convergence="converge")
|
||||
d.addCallback(lambda res: n.add_file(u"newfile-metadata",
|
||||
@ -1138,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.failUnlessReallyEqual(md1, {"tahoe":{"linkcrtime": t1, "linkmotime": t2}})
|
||||
self.failUnlessEqual(md1, {"tahoe":{"linkcrtime": t1, "linkmotime": t2}})
|
||||
|
||||
md2 = dirnode.update_metadata(md1, {"key": "value", "tahoe": {"bad": "mojo"}}, t3)
|
||||
self.failUnlessReallyEqual(md2, {"key": "value",
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t3}})
|
||||
self.failUnlessEqual(md2, {"key": "value",
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t3}})
|
||||
|
||||
md3 = dirnode.update_metadata({}, None, t3)
|
||||
self.failUnlessReallyEqual(md3, {"tahoe":{"linkcrtime": t3, "linkmotime": t3}})
|
||||
self.failUnlessEqual(md3, {"tahoe":{"linkcrtime": t3, "linkmotime": t3}})
|
||||
|
||||
md4 = dirnode.update_metadata({}, {"bool": True, "number": 42}, t1)
|
||||
self.failUnlessReallyEqual(md4, {"bool": True, "number": 42,
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t1}})
|
||||
self.failUnlessEqual(md4, {"bool": True, "number": 42,
|
||||
"tahoe":{"linkcrtime": t1, "linkmotime": t1}})
|
||||
|
||||
def test_create_subdirectory(self):
|
||||
self.basedir = "dirnode/Dirnode/test_create_subdirectory"
|
||||
@ -1176,8 +1176,8 @@ class Dirnode(GridTestMixin, unittest.TestCase,
|
||||
return d
|
||||
d.addCallback(_check)
|
||||
def _check_kids(kids2):
|
||||
self.failUnlessReallyEqual(set(kids.keys()), set(kids2.keys()))
|
||||
self.failUnlessReallyEqual(kids2[u"kid2"][1]["metakey"], "metavalue")
|
||||
self.failUnlessEqual(set(kids.keys()), set(kids2.keys()))
|
||||
self.failUnlessEqual(kids2[u"kid2"][1]["metakey"], "metavalue")
|
||||
d.addCallback(_check_kids)
|
||||
return d
|
||||
d.addCallback(_then)
|
||||
@ -1224,7 +1224,7 @@ class Packing(testutil.ReallyEqualMixin, 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.failUnlessReallyEqual(file3_metadata, children[u'file3'][1])
|
||||
self.failUnlessEqual(file3_metadata, children[u'file3'][1])
|
||||
self.failUnlessReallyEqual(file3_rocap,
|
||||
children[u'file3'][0].get_readonly_uri())
|
||||
self.failUnlessReallyEqual(file3_rwcap,
|
||||
@ -1234,21 +1234,21 @@ class Packing(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
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.failUnlessReallyEqual(file2_metadata, children[u'file2'][1])
|
||||
self.failUnlessEqual(file2_metadata, children[u'file2'][1])
|
||||
self.failUnlessReallyEqual(file2_rocap,
|
||||
children[u'file2'][0].get_readonly_uri())
|
||||
children[u'file2'][0].get_readonly_uri())
|
||||
self.failUnlessReallyEqual(file2_rwcap,
|
||||
children[u'file2'][0].get_uri())
|
||||
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.failUnlessReallyEqual(file1_metadata, children[u'file1'][1])
|
||||
self.failUnlessEqual(file1_metadata, children[u'file1'][1])
|
||||
self.failUnlessReallyEqual(file1_rocap,
|
||||
children[u'file1'][0].get_readonly_uri())
|
||||
children[u'file1'][0].get_readonly_uri())
|
||||
self.failUnlessReallyEqual(file1_rwcap,
|
||||
children[u'file1'][0].get_uri())
|
||||
children[u'file1'][0].get_uri())
|
||||
|
||||
def _make_kids(self, nm, which):
|
||||
caps = {"imm": "URI:CHK:n7r3m6wmomelk4sep3kw5cvduq:os7ijw5c3maek7pg65e5254k2fzjflavtpejjyhshpsxuqzhcwwq:3:20:14861",
|
||||
@ -1578,7 +1578,7 @@ class DeepStats(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
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) ])
|
||||
[ (101, 316, 1), (317, 1000, 1) ])
|
||||
|
||||
ds = dirnode.DeepStats(None)
|
||||
for i in range(1, 1100):
|
||||
@ -1586,15 +1586,15 @@ class DeepStats(testutil.ReallyEqualMixin, unittest.TestCase):
|
||||
ds.histogram("size-files-histogram", 4*1000*1000*1000*1000) # 4TB
|
||||
s = ds.get_results()
|
||||
self.failUnlessReallyEqual(s["size-files-histogram"],
|
||||
[ (1, 3, 3),
|
||||
(4, 10, 7),
|
||||
(11, 31, 21),
|
||||
(32, 100, 69),
|
||||
(101, 316, 216),
|
||||
(317, 1000, 684),
|
||||
(1001, 3162, 99),
|
||||
(3162277660169L, 10000000000000L, 1),
|
||||
])
|
||||
[ (1, 3, 3),
|
||||
(4, 10, 7),
|
||||
(11, 31, 21),
|
||||
(32, 100, 69),
|
||||
(101, 316, 216),
|
||||
(317, 1000, 684),
|
||||
(1001, 3162, 99),
|
||||
(3162277660169L, 10000000000000L, 1),
|
||||
])
|
||||
|
||||
class UCWEingMutableFileNode(MutableFileNode):
|
||||
please_ucwe_after_next_upload = False
|
||||
|
||||
@ -21,6 +21,7 @@ from allmydata.scripts.debug import CorruptShareOptions, corrupt_share
|
||||
from allmydata.util import fileutil, base32
|
||||
from allmydata.util.consumer import download_to_data
|
||||
from allmydata.util.netstring import split_netstring
|
||||
from allmydata.util.encodingutil import to_str
|
||||
from allmydata.test.common import FakeCHKFileNode, FakeMutableFileNode, \
|
||||
create_chk_filenode, WebErrorMixin, ShouldFailMixin, make_mutable_file_uri
|
||||
from allmydata.interfaces import IMutableFileNode
|
||||
@ -214,48 +215,48 @@ class WebMixin(object):
|
||||
def failUnlessIsBarJSON(self, res):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnless(isinstance(data, list))
|
||||
self.failUnlessReallyEqual(data[0], "filenode")
|
||||
self.failUnlessEqual(data[0], "filenode")
|
||||
self.failUnless(isinstance(data[1], dict))
|
||||
self.failIf(data[1]["mutable"])
|
||||
self.failIf("rw_uri" in data[1]) # immutable
|
||||
self.failUnlessReallyEqual(data[1]["ro_uri"], self._bar_txt_uri)
|
||||
self.failUnlessReallyEqual(data[1]["verify_uri"], self._bar_txt_verifycap)
|
||||
self.failUnlessReallyEqual(to_str(data[1]["ro_uri"]), self._bar_txt_uri)
|
||||
self.failUnlessReallyEqual(to_str(data[1]["verify_uri"]), self._bar_txt_verifycap)
|
||||
self.failUnlessReallyEqual(data[1]["size"], len(self.BAR_CONTENTS))
|
||||
|
||||
def failUnlessIsFooJSON(self, res):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnless(isinstance(data, list))
|
||||
self.failUnlessReallyEqual(data[0], "dirnode", res)
|
||||
self.failUnlessEqual(data[0], "dirnode", res)
|
||||
self.failUnless(isinstance(data[1], dict))
|
||||
self.failUnless(data[1]["mutable"])
|
||||
self.failUnless("rw_uri" in data[1]) # mutable
|
||||
self.failUnlessReallyEqual(data[1]["rw_uri"], self._foo_uri)
|
||||
self.failUnlessReallyEqual(data[1]["ro_uri"], self._foo_readonly_uri)
|
||||
self.failUnlessReallyEqual(data[1]["verify_uri"], self._foo_verifycap)
|
||||
self.failUnlessReallyEqual(to_str(data[1]["rw_uri"]), self._foo_uri)
|
||||
self.failUnlessReallyEqual(to_str(data[1]["ro_uri"]), self._foo_readonly_uri)
|
||||
self.failUnlessReallyEqual(to_str(data[1]["verify_uri"]), self._foo_verifycap)
|
||||
|
||||
kidnames = sorted([unicode(n) for n in data[1]["children"]])
|
||||
self.failUnlessReallyEqual(kidnames,
|
||||
[u"bar.txt", u"blockingfile", u"empty",
|
||||
u"n\u00fc.txt", u"sub"])
|
||||
self.failUnlessEqual(kidnames,
|
||||
[u"bar.txt", u"blockingfile", u"empty",
|
||||
u"n\u00fc.txt", u"sub"])
|
||||
kids = dict( [(unicode(name),value)
|
||||
for (name,value)
|
||||
in data[1]["children"].iteritems()] )
|
||||
self.failUnlessReallyEqual(kids[u"sub"][0], "dirnode")
|
||||
self.failUnlessEqual(kids[u"sub"][0], "dirnode")
|
||||
self.failUnlessIn("metadata", kids[u"sub"][1])
|
||||
self.failUnlessIn("tahoe", kids[u"sub"][1]["metadata"])
|
||||
tahoe_md = kids[u"sub"][1]["metadata"]["tahoe"]
|
||||
self.failUnlessIn("linkcrtime", tahoe_md)
|
||||
self.failUnlessIn("linkmotime", tahoe_md)
|
||||
self.failUnlessReallyEqual(kids[u"bar.txt"][0], "filenode")
|
||||
self.failUnlessEqual(kids[u"bar.txt"][0], "filenode")
|
||||
self.failUnlessReallyEqual(kids[u"bar.txt"][1]["size"], len(self.BAR_CONTENTS))
|
||||
self.failUnlessReallyEqual(kids[u"bar.txt"][1]["ro_uri"], self._bar_txt_uri)
|
||||
self.failUnlessReallyEqual(kids[u"bar.txt"][1]["verify_uri"],
|
||||
self.failUnlessReallyEqual(to_str(kids[u"bar.txt"][1]["ro_uri"]), self._bar_txt_uri)
|
||||
self.failUnlessReallyEqual(to_str(kids[u"bar.txt"][1]["verify_uri"]),
|
||||
self._bar_txt_verifycap)
|
||||
self.failUnlessIn("metadata", kids[u"bar.txt"][1])
|
||||
self.failUnlessIn("tahoe", kids[u"bar.txt"][1]["metadata"])
|
||||
self.failUnlessReallyEqual(kids[u"bar.txt"][1]["metadata"]["tahoe"]["linkcrtime"],
|
||||
self._bar_txt_metadata["tahoe"]["linkcrtime"])
|
||||
self.failUnlessReallyEqual(kids[u"n\u00fc.txt"][1]["ro_uri"],
|
||||
self.failUnlessReallyEqual(to_str(kids[u"n\u00fc.txt"][1]["ro_uri"]),
|
||||
self._bar_txt_uri)
|
||||
|
||||
def GET(self, urlpath, followRedirect=False, return_response=False,
|
||||
@ -1132,7 +1133,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
got = {}
|
||||
for (path_list, cap) in data:
|
||||
got[tuple(path_list)] = cap
|
||||
self.failUnlessReallyEqual(got[(u"sub",)], self._sub_uri)
|
||||
self.failUnlessReallyEqual(to_str(got[(u"sub",)]), self._sub_uri)
|
||||
self.failUnless((u"sub",u"baz.txt") in got)
|
||||
self.failUnless("finished" in res)
|
||||
self.failUnless("origin" in res)
|
||||
@ -1211,13 +1212,13 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
self.failUnless(res.endswith("\n"))
|
||||
units = [simplejson.loads(t) for t in res[:-1].split("\n")]
|
||||
self.failUnlessReallyEqual(len(units), 7)
|
||||
self.failUnlessReallyEqual(units[-1]["type"], "stats")
|
||||
self.failUnlessEqual(units[-1]["type"], "stats")
|
||||
first = units[0]
|
||||
self.failUnlessReallyEqual(first["path"], [])
|
||||
self.failUnlessReallyEqual(first["cap"], self._foo_uri)
|
||||
self.failUnlessReallyEqual(first["type"], "directory")
|
||||
baz = [u for u in units[:-1] if u["cap"] == self._baz_file_uri][0]
|
||||
self.failUnlessReallyEqual(baz["path"], ["sub", "baz.txt"])
|
||||
self.failUnlessEqual(first["path"], [])
|
||||
self.failUnlessReallyEqual(to_str(first["cap"]), self._foo_uri)
|
||||
self.failUnlessEqual(first["type"], "directory")
|
||||
baz = [u for u in units[:-1] if to_str(u["cap"]) == self._baz_file_uri][0]
|
||||
self.failUnlessEqual(baz["path"], ["sub", "baz.txt"])
|
||||
self.failIfEqual(baz["storage-index"], None)
|
||||
self.failIfEqual(baz["verifycap"], None)
|
||||
self.failIfEqual(baz["repaircap"], None)
|
||||
@ -1228,14 +1229,14 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
def test_GET_DIRURL_uri(self):
|
||||
d = self.GET(self.public_url + "/foo?t=uri")
|
||||
def _check(res):
|
||||
self.failUnlessReallyEqual(res, self._foo_uri)
|
||||
self.failUnlessReallyEqual(to_str(res), self._foo_uri)
|
||||
d.addCallback(_check)
|
||||
return d
|
||||
|
||||
def test_GET_DIRURL_readonly_uri(self):
|
||||
d = self.GET(self.public_url + "/foo?t=readonly-uri")
|
||||
def _check(res):
|
||||
self.failUnlessReallyEqual(res, self._foo_readonly_uri)
|
||||
self.failUnlessReallyEqual(to_str(res), self._foo_readonly_uri)
|
||||
d.addCallback(_check)
|
||||
return d
|
||||
|
||||
@ -1725,17 +1726,17 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
followRedirect=True))
|
||||
def _check_page_json(res):
|
||||
parsed = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(parsed[0], "dirnode")
|
||||
self.failUnlessEqual(parsed[0], "dirnode")
|
||||
children = dict( [(unicode(name),value)
|
||||
for (name,value)
|
||||
in parsed[1]["children"].iteritems()] )
|
||||
self.failUnless("new.txt" in children)
|
||||
new_json = children["new.txt"]
|
||||
self.failUnlessReallyEqual(new_json[0], "filenode")
|
||||
self.failUnless(u"new.txt" in children)
|
||||
new_json = children[u"new.txt"]
|
||||
self.failUnlessEqual(new_json[0], "filenode")
|
||||
self.failUnless(new_json[1]["mutable"])
|
||||
self.failUnlessReallyEqual(new_json[1]["rw_uri"], self._mutable_uri)
|
||||
self.failUnlessReallyEqual(to_str(new_json[1]["rw_uri"]), self._mutable_uri)
|
||||
ro_uri = self._mutable_node.get_readonly().to_string()
|
||||
self.failUnlessReallyEqual(new_json[1]["ro_uri"], ro_uri)
|
||||
self.failUnlessReallyEqual(to_str(new_json[1]["ro_uri"]), ro_uri)
|
||||
d.addCallback(_check_page_json)
|
||||
|
||||
# and the JSON form of the file
|
||||
@ -1743,11 +1744,11 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
self.GET(self.public_url + "/foo/new.txt?t=json"))
|
||||
def _check_file_json(res):
|
||||
parsed = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(parsed[0], "filenode")
|
||||
self.failUnlessEqual(parsed[0], "filenode")
|
||||
self.failUnless(parsed[1]["mutable"])
|
||||
self.failUnlessReallyEqual(parsed[1]["rw_uri"], self._mutable_uri)
|
||||
self.failUnlessReallyEqual(to_str(parsed[1]["rw_uri"]), self._mutable_uri)
|
||||
ro_uri = self._mutable_node.get_readonly().to_string()
|
||||
self.failUnlessReallyEqual(parsed[1]["ro_uri"], ro_uri)
|
||||
self.failUnlessReallyEqual(to_str(parsed[1]["ro_uri"]), ro_uri)
|
||||
d.addCallback(_check_file_json)
|
||||
|
||||
# and look at t=uri and t=readonly-uri
|
||||
@ -2083,7 +2084,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
self.GET("/operations/123/%s?output=JSON" % foo_si_s))
|
||||
def _check_foo_json(res):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(data["storage-index"], foo_si_s)
|
||||
self.failUnlessEqual(data["storage-index"], foo_si_s)
|
||||
self.failUnless(data["results"]["healthy"])
|
||||
d.addCallback(_check_foo_json)
|
||||
return d
|
||||
@ -2638,7 +2639,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
|
||||
|
||||
def failUnlessIsEmptyJSON(self, res):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(data[0], "dirnode", data)
|
||||
self.failUnlessEqual(data[0], "dirnode", data)
|
||||
self.failUnlessReallyEqual(len(data[1]["children"]), 0)
|
||||
|
||||
def test_POST_rename_file_slash_fail(self):
|
||||
@ -3223,7 +3224,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(self.CHECK, "good", "t=check&output=json")
|
||||
def _got_json_good(res):
|
||||
r = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(r["summary"], "Healthy")
|
||||
self.failUnlessEqual(r["summary"], "Healthy")
|
||||
self.failUnless(r["results"]["healthy"])
|
||||
self.failIf(r["results"]["needs-rebalancing"])
|
||||
self.failUnless(r["results"]["recoverable"])
|
||||
@ -3244,7 +3245,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(self.CHECK, "small", "t=check&output=json")
|
||||
def _got_json_small(res):
|
||||
r = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(r["storage-index"], "")
|
||||
self.failUnlessEqual(r["storage-index"], "")
|
||||
self.failUnless(r["results"]["healthy"])
|
||||
d.addCallback(_got_json_small)
|
||||
|
||||
@ -3256,7 +3257,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(self.CHECK, "smalldir", "t=check&output=json")
|
||||
def _got_json_smalldir(res):
|
||||
r = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(r["storage-index"], "")
|
||||
self.failUnlessEqual(r["storage-index"], "")
|
||||
self.failUnless(r["results"]["healthy"])
|
||||
d.addCallback(_got_json_smalldir)
|
||||
|
||||
@ -3267,8 +3268,8 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(self.CHECK, "sick", "t=check&output=json")
|
||||
def _got_json_sick(res):
|
||||
r = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(r["summary"],
|
||||
"Not Healthy: 9 shares (enc 3-of-10)")
|
||||
self.failUnlessEqual(r["summary"],
|
||||
"Not Healthy: 9 shares (enc 3-of-10)")
|
||||
self.failIf(r["results"]["healthy"])
|
||||
self.failIf(r["results"]["needs-rebalancing"])
|
||||
self.failUnless(r["results"]["recoverable"])
|
||||
@ -3281,8 +3282,8 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(self.CHECK, "dead", "t=check&output=json")
|
||||
def _got_json_dead(res):
|
||||
r = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(r["summary"],
|
||||
"Not Healthy: 1 shares (enc 3-of-10)")
|
||||
self.failUnlessEqual(r["summary"],
|
||||
"Not Healthy: 1 shares (enc 3-of-10)")
|
||||
self.failIf(r["results"]["healthy"])
|
||||
self.failIf(r["results"]["needs-rebalancing"])
|
||||
self.failIf(r["results"]["recoverable"])
|
||||
@ -3412,10 +3413,10 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
r = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(r["repair-attempted"], True)
|
||||
self.failUnlessReallyEqual(r["repair-successful"], True)
|
||||
self.failUnlessReallyEqual(r["pre-repair-results"]["summary"],
|
||||
"Not Healthy: 9 shares (enc 3-of-10)")
|
||||
self.failUnlessEqual(r["pre-repair-results"]["summary"],
|
||||
"Not Healthy: 9 shares (enc 3-of-10)")
|
||||
self.failIf(r["pre-repair-results"]["results"]["healthy"])
|
||||
self.failUnlessReallyEqual(r["post-repair-results"]["summary"], "healthy")
|
||||
self.failUnlessEqual(r["post-repair-results"]["summary"], "healthy")
|
||||
self.failUnless(r["post-repair-results"]["results"]["healthy"])
|
||||
d.addCallback(_got_json_sick)
|
||||
|
||||
@ -3472,17 +3473,17 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(lambda ign: self.GET(self.rooturl+"?t=json"))
|
||||
def _check_directory_json(res, expect_rw_uri):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(data[0], "dirnode")
|
||||
self.failUnlessEqual(data[0], "dirnode")
|
||||
f = data[1]["children"][name]
|
||||
self.failUnlessReallyEqual(f[0], "unknown")
|
||||
self.failUnlessEqual(f[0], "unknown")
|
||||
if expect_rw_uri:
|
||||
self.failUnlessReallyEqual(f[1]["rw_uri"], unknown_rwcap.decode('utf-8'))
|
||||
self.failUnlessReallyEqual(to_str(f[1]["rw_uri"]), unknown_rwcap, data)
|
||||
else:
|
||||
self.failIfIn("rw_uri", f[1])
|
||||
if immutable:
|
||||
self.failUnlessReallyEqual(f[1]["ro_uri"], unknown_immcap.decode('utf-8'), data)
|
||||
self.failUnlessReallyEqual(to_str(f[1]["ro_uri"]), unknown_immcap, data)
|
||||
else:
|
||||
self.failUnlessReallyEqual(f[1]["ro_uri"], unknown_rocap.decode('utf-8'))
|
||||
self.failUnlessReallyEqual(to_str(f[1]["ro_uri"]), unknown_rocap, data)
|
||||
self.failUnless("metadata" in f[1])
|
||||
d.addCallback(_check_directory_json, expect_rw_uri=not immutable)
|
||||
|
||||
@ -3513,20 +3514,20 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
|
||||
def _check_json(res, expect_rw_uri):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(data[0], "unknown")
|
||||
self.failUnlessEqual(data[0], "unknown")
|
||||
if expect_rw_uri:
|
||||
self.failUnlessReallyEqual(data[1]["rw_uri"], unknown_rwcap.decode('utf-8'))
|
||||
self.failUnlessReallyEqual(to_str(data[1]["rw_uri"]), unknown_rwcap, data)
|
||||
else:
|
||||
self.failIfIn("rw_uri", data[1])
|
||||
|
||||
if immutable:
|
||||
self.failUnlessReallyEqual(data[1]["ro_uri"], unknown_immcap.decode('utf-8'))
|
||||
self.failUnlessReallyEqual(to_str(data[1]["ro_uri"]), unknown_immcap, data)
|
||||
self.failUnlessReallyEqual(data[1]["mutable"], False)
|
||||
elif expect_rw_uri:
|
||||
self.failUnlessReallyEqual(data[1]["ro_uri"], unknown_rocap.decode('utf-8'))
|
||||
self.failUnlessReallyEqual(to_str(data[1]["ro_uri"]), unknown_rocap, data)
|
||||
self.failUnlessReallyEqual(data[1]["mutable"], True)
|
||||
else:
|
||||
self.failUnlessReallyEqual(data[1]["ro_uri"], unknown_rocap.decode('utf-8'))
|
||||
self.failUnlessReallyEqual(to_str(data[1]["ro_uri"]), unknown_rocap, data)
|
||||
self.failIf("mutable" in data[1], data[1])
|
||||
|
||||
# TODO: check metadata contents
|
||||
@ -3675,13 +3676,13 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
d.addCallback(lambda ign: self.GET(self.rooturl+"?t=json"))
|
||||
def _check_json(res):
|
||||
data = simplejson.loads(res)
|
||||
self.failUnlessReallyEqual(data[0], "dirnode")
|
||||
self.failUnlessEqual(data[0], "dirnode")
|
||||
listed_children = data[1]["children"]
|
||||
self.failUnlessReallyEqual(sorted(listed_children.keys()), [u"lonely"])
|
||||
ll_type, ll_data = listed_children[u"lonely"]
|
||||
self.failUnlessReallyEqual(ll_type, "filenode")
|
||||
self.failUnlessEqual(ll_type, "filenode")
|
||||
self.failIf("rw_uri" in ll_data)
|
||||
self.failUnlessReallyEqual(ll_data["ro_uri"], lonely_uri)
|
||||
self.failUnlessReallyEqual(to_str(ll_data["ro_uri"]), lonely_uri)
|
||||
d.addCallback(_check_json)
|
||||
return d
|
||||
|
||||
@ -3741,20 +3742,20 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
self.failUnlessReallyEqual(len(units), 5+1)
|
||||
# should be parent-first
|
||||
u0 = units[0]
|
||||
self.failUnlessReallyEqual(u0["path"], [])
|
||||
self.failUnlessReallyEqual(u0["type"], "directory")
|
||||
self.failUnlessReallyEqual(u0["cap"], self.rootnode.get_uri())
|
||||
self.failUnlessEqual(u0["path"], [])
|
||||
self.failUnlessEqual(u0["type"], "directory")
|
||||
self.failUnlessReallyEqual(to_str(u0["cap"]), self.rootnode.get_uri())
|
||||
u0cr = u0["check-results"]
|
||||
self.failUnlessReallyEqual(u0cr["results"]["count-shares-good"], 10)
|
||||
|
||||
ugood = [u for u in units
|
||||
if u["type"] == "file" and u["path"] == [u"good"]][0]
|
||||
self.failUnlessReallyEqual(ugood["cap"], self.uris["good"])
|
||||
self.failUnlessReallyEqual(to_str(ugood["cap"]), self.uris["good"])
|
||||
ugoodcr = ugood["check-results"]
|
||||
self.failUnlessReallyEqual(ugoodcr["results"]["count-shares-good"], 10)
|
||||
|
||||
stats = units[-1]
|
||||
self.failUnlessReallyEqual(stats["type"], "stats")
|
||||
self.failUnlessEqual(stats["type"], "stats")
|
||||
s = stats["stats"]
|
||||
self.failUnlessReallyEqual(s["count-immutable-files"], 2)
|
||||
self.failUnlessReallyEqual(s["count-literal-files"], 1)
|
||||
@ -3767,11 +3768,11 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
self.failUnless(res.endswith("\n"))
|
||||
units = [simplejson.loads(t) for t in res[:-1].split("\n")]
|
||||
self.failUnlessReallyEqual(len(units), 5+1)
|
||||
self.failUnlessReallyEqual(units[-1]["type"], "stats")
|
||||
self.failUnlessEqual(units[-1]["type"], "stats")
|
||||
first = units[0]
|
||||
self.failUnlessReallyEqual(first["path"], [])
|
||||
self.failUnlessReallyEqual(first["cap"], self.rootnode.get_uri())
|
||||
self.failUnlessReallyEqual(first["type"], "directory")
|
||||
self.failUnlessEqual(first["path"], [])
|
||||
self.failUnlessEqual(to_str(first["cap"]), self.rootnode.get_uri())
|
||||
self.failUnlessEqual(first["type"], "directory")
|
||||
stats = units[-1]["stats"]
|
||||
self.failUnlessReallyEqual(stats["count-immutable-files"], 2)
|
||||
self.failUnlessReallyEqual(stats["count-literal-files"], 1)
|
||||
@ -3825,7 +3826,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
units = [simplejson.loads(line) for line in lines[:first_error]]
|
||||
self.failUnlessReallyEqual(len(units), 6) # includes subdir
|
||||
last_unit = units[-1]
|
||||
self.failUnlessReallyEqual(last_unit["path"], ["subdir"])
|
||||
self.failUnlessEqual(last_unit["path"], ["subdir"])
|
||||
d.addCallback(_check_broken_manifest)
|
||||
|
||||
d.addCallback(self.CHECK, "root", "t=stream-deep-check")
|
||||
@ -3846,7 +3847,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
units = [simplejson.loads(line) for line in lines[:first_error]]
|
||||
self.failUnlessReallyEqual(len(units), 6) # includes subdir
|
||||
last_unit = units[-1]
|
||||
self.failUnlessReallyEqual(last_unit["path"], ["subdir"])
|
||||
self.failUnlessEqual(last_unit["path"], ["subdir"])
|
||||
r = last_unit["check-results"]["results"]
|
||||
self.failUnlessReallyEqual(r["count-recoverable-versions"], 0)
|
||||
self.failUnlessReallyEqual(r["count-shares-good"], 1)
|
||||
@ -3921,23 +3922,23 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
self.failUnlessReallyEqual(len(units), 4+1)
|
||||
# should be parent-first
|
||||
u0 = units[0]
|
||||
self.failUnlessReallyEqual(u0["path"], [])
|
||||
self.failUnlessReallyEqual(u0["type"], "directory")
|
||||
self.failUnlessReallyEqual(u0["cap"], self.rootnode.get_uri())
|
||||
self.failUnlessEqual(u0["path"], [])
|
||||
self.failUnlessEqual(u0["type"], "directory")
|
||||
self.failUnlessReallyEqual(to_str(u0["cap"]), self.rootnode.get_uri())
|
||||
u0crr = u0["check-and-repair-results"]
|
||||
self.failUnlessReallyEqual(u0crr["repair-attempted"], False)
|
||||
self.failUnlessReallyEqual(u0crr["pre-repair-results"]["results"]["count-shares-good"], 10)
|
||||
|
||||
ugood = [u for u in units
|
||||
if u["type"] == "file" and u["path"] == [u"good"]][0]
|
||||
self.failUnlessReallyEqual(ugood["cap"], self.uris["good"])
|
||||
self.failUnlessEqual(to_str(ugood["cap"]), self.uris["good"])
|
||||
ugoodcrr = ugood["check-and-repair-results"]
|
||||
self.failUnlessReallyEqual(ugoodcrr["repair-attempted"], False)
|
||||
self.failUnlessReallyEqual(ugoodcrr["pre-repair-results"]["results"]["count-shares-good"], 10)
|
||||
|
||||
usick = [u for u in units
|
||||
if u["type"] == "file" and u["path"] == [u"sick"]][0]
|
||||
self.failUnlessReallyEqual(usick["cap"], self.uris["sick"])
|
||||
self.failUnlessReallyEqual(to_str(usick["cap"]), self.uris["sick"])
|
||||
usickcrr = usick["check-and-repair-results"]
|
||||
self.failUnlessReallyEqual(usickcrr["repair-attempted"], True)
|
||||
self.failUnlessReallyEqual(usickcrr["repair-successful"], True)
|
||||
@ -3945,7 +3946,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
|
||||
self.failUnlessReallyEqual(usickcrr["post-repair-results"]["results"]["count-shares-good"], 10)
|
||||
|
||||
stats = units[-1]
|
||||
self.failUnlessReallyEqual(stats["type"], "stats")
|
||||
self.failUnlessEqual(stats["type"], "stats")
|
||||
s = stats["stats"]
|
||||
self.failUnlessReallyEqual(s["count-immutable-files"], 2)
|
||||
self.failUnlessReallyEqual(s["count-literal-files"], 1)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user