ExternalVendorCode/tahoe-lafs
1
0
Fork 0
mirror of https://github.com/tahoe-lafs/tahoe-lafs.git synced 2025-05-31 23:00:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Start porting test infrastructure to Python 3 compatibility.

Browse Source
This commit is contained in:
Itamar Turner-Trauring 2020-11-06 10:04:46 -05:00
parent cd01d4dafa
commit e17be38d69
2 changed files with 68 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
src/allmydata/test/mutable/test_filenode.py
View File

@ -73,11 +73,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
return n return n
d.addCallback(_created) d.addCallback(_created)
d.addCallback(lambda n: d.addCallback(lambda n:
n.overwrite(MutableData("Contents" * 50000))) n.overwrite(MutableData(b"Contents" * 50000)))
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self._node.download_best_version()) self._node.download_best_version())
d.addCallback(lambda contents: d.addCallback(lambda contents:
self.failUnlessEqual(contents, "Contents" * 50000)) self.failUnlessEqual(contents, b"Contents" * 50000))
return d return d
def test_max_shares(self): def test_max_shares(self):
@ -95,7 +95,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d.addCallback(_created) d.addCallback(_created)
# Now we upload some contents # Now we upload some contents
d.addCallback(lambda n: d.addCallback(lambda n:
n.overwrite(MutableData("contents" * 50000))) n.overwrite(MutableData(b"contents" * 50000)))
# ...then download contents # ...then download contents
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self._node.download_best_version()) self._node.download_best_version())
@ -119,7 +119,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
return n return n
d.addCallback(_created) d.addCallback(_created)
d.addCallback(lambda n: d.addCallback(lambda n:
n.overwrite(MutableData("contents" * 50000))) n.overwrite(MutableData(b"contents" * 50000)))
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self._node.download_best_version()) self._node.download_best_version())
d.addCallback(lambda contents: d.addCallback(lambda contents:
@ -216,33 +216,33 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d.addCallback(lambda smap: smap.dump(StringIO())) d.addCallback(lambda smap: smap.dump(StringIO()))
d.addCallback(lambda sio: d.addCallback(lambda sio:
self.failUnless("3-of-10" in sio.getvalue())) self.failUnless("3-of-10" in sio.getvalue()))
d.addCallback(lambda res: n.overwrite(MutableData("contents 1"))) d.addCallback(lambda res: n.overwrite(MutableData(b"contents 1")))
d.addCallback(lambda res: self.failUnlessIdentical(res, None)) d.addCallback(lambda res: self.failUnlessIdentical(res, None))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 1")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 1"))
d.addCallback(lambda res: n.get_size_of_best_version()) d.addCallback(lambda res: n.get_size_of_best_version())
d.addCallback(lambda size: d.addCallback(lambda size:
self.failUnlessEqual(size, len("contents 1"))) self.failUnlessEqual(size, len(b"contents 1")))
d.addCallback(lambda res: n.overwrite(MutableData("contents 2"))) d.addCallback(lambda res: n.overwrite(MutableData(b"contents 2")))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 2"))
d.addCallback(lambda res: n.get_servermap(MODE_WRITE)) d.addCallback(lambda res: n.get_servermap(MODE_WRITE))
d.addCallback(lambda smap: n.upload(MutableData("contents 3"), smap)) d.addCallback(lambda smap: n.upload(MutableData(b"contents 3"), smap))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 3")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 3"))
d.addCallback(lambda res: n.get_servermap(MODE_ANYTHING)) d.addCallback(lambda res: n.get_servermap(MODE_ANYTHING))
d.addCallback(lambda smap: d.addCallback(lambda smap:
n.download_version(smap, n.download_version(smap,
smap.best_recoverable_version())) smap.best_recoverable_version()))
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 3")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 3"))
# test a file that is large enough to overcome the # test a file that is large enough to overcome the
# mapupdate-to-retrieve data caching (i.e. make the shares larger # mapupdate-to-retrieve data caching (i.e. make the shares larger
# than the default readsize, which is 2000 bytes). A 15kB file # than the default readsize, which is 2000 bytes). A 15kB file
# will have 5kB shares. # will have 5kB shares.
d.addCallback(lambda res: n.overwrite(MutableData("large size file" * 1000))) d.addCallback(lambda res: n.overwrite(MutableData(b"large size file" * 1000)))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: d.addCallback(lambda res:
self.failUnlessEqual(res, "large size file" * 1000)) self.failUnlessEqual(res, b"large size file" * 1000))
return d return d
d.addCallback(_created) d.addCallback(_created)
return d return d
@ -261,7 +261,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
# Now overwrite the contents with some new contents. We want # Now overwrite the contents with some new contents. We want
# to make them big enough to force the file to be uploaded # to make them big enough to force the file to be uploaded
# in more than one segment. # in more than one segment.
big_contents = "contents1" * 100000 # about 900 KiB big_contents = b"contents1" * 100000 # about 900 KiB
big_contents_uploadable = MutableData(big_contents) big_contents_uploadable = MutableData(big_contents)
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
n.overwrite(big_contents_uploadable)) n.overwrite(big_contents_uploadable))
@ -273,7 +273,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
# before, they need to be big enough to force multiple # before, they need to be big enough to force multiple
# segments, so that we make the downloader deal with # segments, so that we make the downloader deal with
# multiple segments. # multiple segments.
bigger_contents = "contents2" * 1000000 # about 9MiB bigger_contents = b"contents2" * 1000000 # about 9MiB
bigger_contents_uploadable = MutableData(bigger_contents) bigger_contents_uploadable = MutableData(bigger_contents)
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
n.overwrite(bigger_contents_uploadable)) n.overwrite(bigger_contents_uploadable))
@ -289,7 +289,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def test_retrieve_producer_mdmf(self): def test_retrieve_producer_mdmf(self):
# We should make sure that the retriever is able to pause and stop # We should make sure that the retriever is able to pause and stop
# correctly. # correctly.
data = "contents1" * 100000 data = b"contents1" * 100000
d = self.nodemaker.create_mutable_file(MutableData(data), d = self.nodemaker.create_mutable_file(MutableData(data),
version=MDMF_VERSION) version=MDMF_VERSION)
d.addCallback(lambda node: node.get_best_mutable_version()) d.addCallback(lambda node: node.get_best_mutable_version())
@ -300,7 +300,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
# after-the-first-write() trick to pause or stop the download. # after-the-first-write() trick to pause or stop the download.
# Disabled until we find a better approach. # Disabled until we find a better approach.
def OFF_test_retrieve_producer_sdmf(self): def OFF_test_retrieve_producer_sdmf(self):
data = "contents1" * 100000 data = b"contents1" * 100000
d = self.nodemaker.create_mutable_file(MutableData(data), d = self.nodemaker.create_mutable_file(MutableData(data),
version=SDMF_VERSION) version=SDMF_VERSION)
d.addCallback(lambda node: node.get_best_mutable_version()) d.addCallback(lambda node: node.get_best_mutable_version())
@ -347,15 +347,15 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def _created(node): def _created(node):
self.uri = node.get_uri() self.uri = node.get_uri()
# also confirm that the cap has no extension fields # also confirm that the cap has no extension fields
pieces = self.uri.split(":") pieces = self.uri.split(b":")
self.failUnlessEqual(len(pieces), 4) self.failUnlessEqual(len(pieces), 4)
return node.overwrite(MutableData("contents1" * 100000)) return node.overwrite(MutableData(b"contents1" * 100000))
def _then(ignored): def _then(ignored):
node = self.nodemaker.create_from_cap(self.uri) node = self.nodemaker.create_from_cap(self.uri)
return node.download_best_version() return node.download_best_version()
def _downloaded(data): def _downloaded(data):
self.failUnlessEqual(data, "contents1" * 100000) self.failUnlessEqual(data, b"contents1" * 100000)
d.addCallback(_created) d.addCallback(_created)
d.addCallback(_then) d.addCallback(_then)
d.addCallback(_downloaded) d.addCallback(_downloaded)
@ -368,7 +368,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
be published. Otherwise, we introduce undesirable semantics that are a be published. Otherwise, we introduce undesirable semantics that are a
regression from SDMF. regression from SDMF.
""" """
upload = MutableData("MDMF" * 100000) # about 400 KiB upload = MutableData(b"MDMF" * 100000) # about 400 KiB
d = self.nodemaker.create_mutable_file(upload, d = self.nodemaker.create_mutable_file(upload,
version=MDMF_VERSION) version=MDMF_VERSION)
def _check_server_write_counts(ignored): def _check_server_write_counts(ignored):
@ -385,18 +385,18 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d = self.nodemaker.create_mutable_file(upload1) d = self.nodemaker.create_mutable_file(upload1)
def _created(n): def _created(n):
d = n.download_best_version() d = n.download_best_version()
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 1")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 1"))
upload2 = MutableData("contents 2") upload2 = MutableData(b"contents 2")
d.addCallback(lambda res: n.overwrite(upload2)) d.addCallback(lambda res: n.overwrite(upload2))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 2"))
return d return d
d.addCallback(_created) d.addCallback(_created)
return d return d
def test_create_mdmf_with_initial_contents(self): def test_create_mdmf_with_initial_contents(self):
initial_contents = "foobarbaz" * 131072 # 900KiB initial_contents = b"foobarbaz" * 131072 # 900KiB
initial_contents_uploadable = MutableData(initial_contents) initial_contents_uploadable = MutableData(initial_contents)
d = self.nodemaker.create_mutable_file(initial_contents_uploadable, d = self.nodemaker.create_mutable_file(initial_contents_uploadable,
version=MDMF_VERSION) version=MDMF_VERSION)
@ -404,24 +404,24 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d = n.download_best_version() d = n.download_best_version()
d.addCallback(lambda data: d.addCallback(lambda data:
self.failUnlessEqual(data, initial_contents)) self.failUnlessEqual(data, initial_contents))
uploadable2 = MutableData(initial_contents + "foobarbaz") uploadable2 = MutableData(initial_contents + b"foobarbaz")
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
n.overwrite(uploadable2)) n.overwrite(uploadable2))
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
n.download_best_version()) n.download_best_version())
d.addCallback(lambda data: d.addCallback(lambda data:
self.failUnlessEqual(data, initial_contents + self.failUnlessEqual(data, initial_contents +
"foobarbaz")) b"foobarbaz"))
return d return d
d.addCallback(_created) d.addCallback(_created)
return d return d
def test_create_with_initial_contents_function(self): def test_create_with_initial_contents_function(self):
data = "initial contents" data = b"initial contents"
def _make_contents(n): def _make_contents(n):
self.failUnless(isinstance(n, MutableFileNode)) self.failUnless(isinstance(n, MutableFileNode))
key = n.get_writekey() key = n.get_writekey()
self.failUnless(isinstance(key, str), key) self.failUnless(isinstance(key, bytes), key)
self.failUnlessEqual(len(key), 16) # AES key size self.failUnlessEqual(len(key), 16) # AES key size
return MutableData(data) return MutableData(data)
d = self.nodemaker.create_mutable_file(_make_contents) d = self.nodemaker.create_mutable_file(_make_contents)
@ -433,11 +433,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def test_create_mdmf_with_initial_contents_function(self): def test_create_mdmf_with_initial_contents_function(self):
data = "initial contents" * 100000 data = b"initial contents" * 100000
def _make_contents(n): def _make_contents(n):
self.failUnless(isinstance(n, MutableFileNode)) self.failUnless(isinstance(n, MutableFileNode))
key = n.get_writekey() key = n.get_writekey()
self.failUnless(isinstance(key, str), key) self.failUnless(isinstance(key, bytes), key)
self.failUnlessEqual(len(key), 16) self.failUnlessEqual(len(key), 16)
return MutableData(data) return MutableData(data)
d = self.nodemaker.create_mutable_file(_make_contents, d = self.nodemaker.create_mutable_file(_make_contents,
@ -450,7 +450,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def test_create_with_too_large_contents(self): def test_create_with_too_large_contents(self):
BIG = "a" * (self.OLD_MAX_SEGMENT_SIZE + 1) BIG = b"a" * (self.OLD_MAX_SEGMENT_SIZE + 1)
BIG_uploadable = MutableData(BIG) BIG_uploadable = MutableData(BIG)
d = self.nodemaker.create_mutable_file(BIG_uploadable) d = self.nodemaker.create_mutable_file(BIG_uploadable)
def _created(n): def _created(n):
@ -469,7 +469,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def test_modify(self): def test_modify(self):
def _modifier(old_contents, servermap, first_time): def _modifier(old_contents, servermap, first_time):
new_contents = old_contents + "line2" new_contents = old_contents + b"line2"
return new_contents return new_contents
def _non_modifier(old_contents, servermap, first_time): def _non_modifier(old_contents, servermap, first_time):
return old_contents return old_contents
@ -478,7 +478,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def _error_modifier(old_contents, servermap, first_time): def _error_modifier(old_contents, servermap, first_time):
raise ValueError("oops") raise ValueError("oops")
def _toobig_modifier(old_contents, servermap, first_time): def _toobig_modifier(old_contents, servermap, first_time):
new_content = "b" * (self.OLD_MAX_SEGMENT_SIZE + 1) new_content = b"b" * (self.OLD_MAX_SEGMENT_SIZE + 1)
return new_content return new_content
calls = [] calls = []
def _ucw_error_modifier(old_contents, servermap, first_time): def _ucw_error_modifier(old_contents, servermap, first_time):
@ -486,7 +486,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
calls.append(1) calls.append(1)
if len(calls) <= 1: if len(calls) <= 1:
raise UncoordinatedWriteError("simulated") raise UncoordinatedWriteError("simulated")
new_contents = old_contents + "line3" new_contents = old_contents + b"line3"
return new_contents return new_contents
def _ucw_error_non_modifier(old_contents, servermap, first_time): def _ucw_error_non_modifier(old_contents, servermap, first_time):
# simulate an UncoordinatedWriteError once, and don't actually # simulate an UncoordinatedWriteError once, and don't actually
@ -496,41 +496,41 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
raise UncoordinatedWriteError("simulated") raise UncoordinatedWriteError("simulated")
return old_contents return old_contents
initial_contents = "line1" initial_contents = b"line1"
d = self.nodemaker.create_mutable_file(MutableData(initial_contents)) d = self.nodemaker.create_mutable_file(MutableData(initial_contents))
def _created(n): def _created(n):
d = n.modify(_modifier) d = n.modify(_modifier)
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "m")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "m"))
d.addCallback(lambda res: n.modify(_non_modifier)) d.addCallback(lambda res: n.modify(_non_modifier))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "non")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "non"))
d.addCallback(lambda res: n.modify(_none_modifier)) d.addCallback(lambda res: n.modify(_none_modifier))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "none")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "none"))
d.addCallback(lambda res: d.addCallback(lambda res:
self.shouldFail(ValueError, "error_modifier", None, self.shouldFail(ValueError, "error_modifier", None,
n.modify, _error_modifier)) n.modify, _error_modifier))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "err")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "err"))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "big")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "big"))
d.addCallback(lambda res: n.modify(_ucw_error_modifier)) d.addCallback(lambda res: n.modify(_ucw_error_modifier))
d.addCallback(lambda res: self.failUnlessEqual(len(calls), 2)) d.addCallback(lambda res: self.failUnlessEqual(len(calls), 2))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, d.addCallback(lambda res: self.failUnlessEqual(res,
"line1line2line3")) b"line1line2line3"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "ucw")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "ucw"))
def _reset_ucw_error_modifier(res): def _reset_ucw_error_modifier(res):
@ -548,7 +548,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d.addCallback(lambda res: self.failUnlessEqual(len(calls), 2)) d.addCallback(lambda res: self.failUnlessEqual(len(calls), 2))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, d.addCallback(lambda res: self.failUnlessEqual(res,
"line1line2line3")) b"line1line2line3"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 4, "ucw")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 4, "ucw"))
d.addCallback(lambda res: n.modify(_toobig_modifier)) d.addCallback(lambda res: n.modify(_toobig_modifier))
return d return d
@ -558,14 +558,14 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
def test_modify_backoffer(self): def test_modify_backoffer(self):
def _modifier(old_contents, servermap, first_time): def _modifier(old_contents, servermap, first_time):
return old_contents + "line2" return old_contents + b"line2"
calls = [] calls = []
def _ucw_error_modifier(old_contents, servermap, first_time): def _ucw_error_modifier(old_contents, servermap, first_time):
# simulate an UncoordinatedWriteError once # simulate an UncoordinatedWriteError once
calls.append(1) calls.append(1)
if len(calls) <= 1: if len(calls) <= 1:
raise UncoordinatedWriteError("simulated") raise UncoordinatedWriteError("simulated")
return old_contents + "line3" return old_contents + b"line3"
def _always_ucw_error_modifier(old_contents, servermap, first_time): def _always_ucw_error_modifier(old_contents, servermap, first_time):
raise UncoordinatedWriteError("simulated") raise UncoordinatedWriteError("simulated")
def _backoff_stopper(node, f): def _backoff_stopper(node, f):
@ -580,11 +580,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
giveuper._delay = 0.1 giveuper._delay = 0.1
giveuper.factor = 1 giveuper.factor = 1
d = self.nodemaker.create_mutable_file(MutableData("line1")) d = self.nodemaker.create_mutable_file(MutableData(b"line1"))
def _created(n): def _created(n):
d = n.modify(_modifier) d = n.modify(_modifier)
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "m")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "m"))
d.addCallback(lambda res: d.addCallback(lambda res:
@ -593,7 +593,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
n.modify, _ucw_error_modifier, n.modify, _ucw_error_modifier,
_backoff_stopper)) _backoff_stopper))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "line1line2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"line1line2"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "stop")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 2, "stop"))
def _reset_ucw_error_modifier(res): def _reset_ucw_error_modifier(res):
@ -604,7 +604,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
_backoff_pauser)) _backoff_pauser))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, d.addCallback(lambda res: self.failUnlessEqual(res,
"line1line2line3")) b"line1line2line3"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "pause")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "pause"))
d.addCallback(lambda res: d.addCallback(lambda res:
@ -614,7 +614,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
giveuper.delay)) giveuper.delay))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, d.addCallback(lambda res: self.failUnlessEqual(res,
"line1line2line3")) b"line1line2line3"))
d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "giveup")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "giveup"))
return d return d
@ -630,22 +630,22 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d.addCallback(lambda smap: smap.dump(StringIO())) d.addCallback(lambda smap: smap.dump(StringIO()))
d.addCallback(lambda sio: d.addCallback(lambda sio:
self.failUnless("3-of-10" in sio.getvalue())) self.failUnless("3-of-10" in sio.getvalue()))
d.addCallback(lambda res: n.overwrite(MutableData("contents 1"))) d.addCallback(lambda res: n.overwrite(MutableData(b"contents 1")))
d.addCallback(lambda res: self.failUnlessIdentical(res, None)) d.addCallback(lambda res: self.failUnlessIdentical(res, None))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 1")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 1"))
d.addCallback(lambda res: n.overwrite(MutableData("contents 2"))) d.addCallback(lambda res: n.overwrite(MutableData(b"contents 2")))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 2")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 2"))
d.addCallback(lambda res: n.get_servermap(MODE_WRITE)) d.addCallback(lambda res: n.get_servermap(MODE_WRITE))
d.addCallback(lambda smap: n.upload(MutableData("contents 3"), smap)) d.addCallback(lambda smap: n.upload(MutableData(b"contents 3"), smap))
d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: n.download_best_version())
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 3")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 3"))
d.addCallback(lambda res: n.get_servermap(MODE_ANYTHING)) d.addCallback(lambda res: n.get_servermap(MODE_ANYTHING))
d.addCallback(lambda smap: d.addCallback(lambda smap:
n.download_version(smap, n.download_version(smap,
smap.best_recoverable_version())) smap.best_recoverable_version()))
d.addCallback(lambda res: self.failUnlessEqual(res, "contents 3")) d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 3"))
return d return d
d.addCallback(_created) d.addCallback(_created)
return d return d
@ -663,11 +663,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin):
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self.failUnlessEqual(self.n.get_size(), 0)) self.failUnlessEqual(self.n.get_size(), 0))
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self.n.overwrite(MutableData("foobarbaz"))) self.n.overwrite(MutableData(b"foobarbaz")))
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self.failUnlessEqual(self.n.get_size(), 9)) self.failUnlessEqual(self.n.get_size(), 9))
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self.nodemaker.create_mutable_file(MutableData("foobarbaz"))) self.nodemaker.create_mutable_file(MutableData(b"foobarbaz")))
d.addCallback(_created) d.addCallback(_created)
d.addCallback(lambda ignored: d.addCallback(lambda ignored:
self.failUnlessEqual(self.n.get_size(), 9)) self.failUnlessEqual(self.n.get_size(), 9))

16
src/allmydata/test/mutable/util.py
View File

@ -313,7 +313,7 @@ class PublishMixin(object):
def publish_one(self): def publish_one(self):
# publish a file and create shares, which can then be manipulated # publish a file and create shares, which can then be manipulated
# later. # later.
self.CONTENTS = "New contents go here" * 1000 self.CONTENTS = b"New contents go here" * 1000
self.uploadable = MutableData(self.CONTENTS) self.uploadable = MutableData(self.CONTENTS)
self._storage = FakeStorage() self._storage = FakeStorage()
self._nodemaker = make_nodemaker(self._storage) self._nodemaker = make_nodemaker(self._storage)
@ -330,7 +330,7 @@ class PublishMixin(object):
# an MDMF file. # an MDMF file.
# self.CONTENTS should have more than one segment. # self.CONTENTS should have more than one segment.
if data is None: if data is None:
data = "This is an MDMF file" * 100000 data = b"This is an MDMF file" * 100000
self.CONTENTS = data self.CONTENTS = data
self.uploadable = MutableData(self.CONTENTS) self.uploadable = MutableData(self.CONTENTS)
self._storage = FakeStorage() self._storage = FakeStorage()
@ -348,7 +348,7 @@ class PublishMixin(object):
# like publish_one, except that the result is guaranteed to be # like publish_one, except that the result is guaranteed to be
# an SDMF file # an SDMF file
if data is None: if data is None:
data = "This is an SDMF file" * 1000 data = b"This is an SDMF file" * 1000
self.CONTENTS = data self.CONTENTS = data
self.uploadable = MutableData(self.CONTENTS) self.uploadable = MutableData(self.CONTENTS)
self._storage = FakeStorage() self._storage = FakeStorage()
@ -363,11 +363,11 @@ class PublishMixin(object):
def publish_multiple(self, version=0): def publish_multiple(self, version=0):
self.CONTENTS = ["Contents 0", self.CONTENTS = [b"Contents 0",
"Contents 1", b"Contents 1",
"Contents 2", b"Contents 2",
"Contents 3a", b"Contents 3a",
"Contents 3b"] b"Contents 3b"]
self.uploadables = [MutableData(d) for d in self.CONTENTS] self.uploadables = [MutableData(d) for d in self.CONTENTS]
self._copied_shares = {} self._copied_shares = {}
self._storage = FakeStorage() self._storage = FakeStorage()