diff --git a/newsfragments/3475.minor b/newsfragments/3475.minor new file mode 100644 index 000000000..e69de29bb diff --git a/src/allmydata/mutable/checker.py b/src/allmydata/mutable/checker.py index 6e083f8f5..536bc68f1 100644 --- a/src/allmydata/mutable/checker.py +++ b/src/allmydata/mutable/checker.py @@ -187,7 +187,7 @@ class MutableChecker(object): if self.bad_shares: report.append("Corrupt Shares:") summary.append("Corrupt Shares:") - for (server, shnum, f) in sorted(self.bad_shares): + for (server, shnum, f) in self.bad_shares: serverid = server.get_serverid() locator = (server, self._storage_index, shnum) corrupt_share_locators.append(locator) diff --git a/src/allmydata/mutable/publish.py b/src/allmydata/mutable/publish.py index 187aa98bd..4ba675e56 100644 --- a/src/allmydata/mutable/publish.py +++ b/src/allmydata/mutable/publish.py @@ -901,7 +901,7 @@ class Publish(object): def log_goal(self, goal, message=""): logmsg = [message] - for (shnum, server) in sorted([(s,p) for (p,s) in goal]): + for (shnum, server) in [(s,p) for (p,s) in goal]: logmsg.append("sh%d to [%s]" % (shnum, server.get_name())) self.log("current goal: %s" % (", ".join(logmsg)), level=log.NOISY) self.log("we are planning to push new seqnum=#%d" % self._new_seqnum, diff --git a/src/allmydata/test/mutable/test_checker.py b/src/allmydata/test/mutable/test_checker.py index 666b70ce3..11ba776fd 100644 --- a/src/allmydata/test/mutable/test_checker.py +++ b/src/allmydata/test/mutable/test_checker.py @@ -1,3 +1,15 @@ +""" +Ported to Python 3. +""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function +from __future__ import unicode_literals + +from future.utils import PY2 +if PY2: + from future.builtins import filter, map, zip, ascii, chr, hex, input, next, oct, open, pow, round, super, bytes, dict, list, object, range, str, max, min # noqa: F401 + from twisted.trial import unittest from foolscap.api import flushEventualQueue from allmydata.monitor import Monitor @@ -22,7 +34,7 @@ class Checker(unittest.TestCase, CheckerMixin, PublishMixin): return d def test_check_no_shares(self): - for shares in self._storage._peers.values(): + for shares in list(self._storage._peers.values()): shares.clear() d = self._fn.check(Monitor()) d.addCallback(self.check_bad, "test_check_no_shares") @@ -31,7 +43,7 @@ class Checker(unittest.TestCase, CheckerMixin, PublishMixin): def test_check_mdmf_no_shares(self): d = self.publish_mdmf() def _then(ignored): - for share in self._storage._peers.values(): + for share in list(self._storage._peers.values()): share.clear() d.addCallback(_then) d.addCallback(lambda ignored: @@ -40,8 +52,8 @@ class Checker(unittest.TestCase, CheckerMixin, PublishMixin): return d def test_check_not_enough_shares(self): - for shares in self._storage._peers.values(): - for shnum in shares.keys(): + for shares in list(self._storage._peers.values()): + for shnum in list(shares.keys()): if shnum > 0: del shares[shnum] d = self._fn.check(Monitor()) @@ -51,8 +63,8 @@ class Checker(unittest.TestCase, CheckerMixin, PublishMixin): def test_check_mdmf_not_enough_shares(self): d = self.publish_mdmf() def _then(ignored): - for shares in self._storage._peers.values(): - for shnum in shares.keys(): + for shares in list(self._storage._peers.values()): + for shnum in list(shares.keys()): if shnum > 0: del shares[shnum] d.addCallback(_then) @@ -83,7 +95,7 @@ class Checker(unittest.TestCase, CheckerMixin, PublishMixin): # On 8 of the shares, corrupt the beginning of the share data. # The signature check during the servermap update won't catch this. d.addCallback(lambda ignored: - corrupt(None, self._storage, "share_data", range(8))) + corrupt(None, self._storage, "share_data", list(range(8)))) # On 2 of the shares, corrupt the end of the share data. # The signature check during the servermap update won't catch # this either, and the retrieval process will have to process @@ -242,14 +254,14 @@ class Checker(unittest.TestCase, CheckerMixin, PublishMixin): return d def test_verify_sdmf_empty(self): - d = self.publish_sdmf("") + d = self.publish_sdmf(b"") d.addCallback(lambda ignored: self._fn.check(Monitor(), verify=True)) d.addCallback(self.check_good, "test_verify_sdmf") d.addCallback(flushEventualQueue) return d def test_verify_mdmf_empty(self): - d = self.publish_mdmf("") + d = self.publish_mdmf(b"") d.addCallback(lambda ignored: self._fn.check(Monitor(), verify=True)) d.addCallback(self.check_good, "test_verify_mdmf") d.addCallback(flushEventualQueue) diff --git a/src/allmydata/test/mutable/test_exceptions.py b/src/allmydata/test/mutable/test_exceptions.py index ed6cab1b0..6a9b2b575 100644 --- a/src/allmydata/test/mutable/test_exceptions.py +++ b/src/allmydata/test/mutable/test_exceptions.py @@ -1,3 +1,16 @@ +""" +Ported to Python 3. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function +from __future__ import unicode_literals + +from future.utils import PY2 +if PY2: + from future.builtins import filter, map, zip, ascii, chr, hex, input, next, oct, open, pow, round, super, bytes, dict, list, object, range, str, max, min # noqa: F401 + from twisted.trial import unittest from allmydata.mutable.common import NeedMoreDataError, UncoordinatedWriteError diff --git a/src/allmydata/test/mutable/test_filenode.py b/src/allmydata/test/mutable/test_filenode.py index fdc19d5cb..de03afc5a 100644 --- a/src/allmydata/test/mutable/test_filenode.py +++ b/src/allmydata/test/mutable/test_filenode.py @@ -1,3 +1,15 @@ +""" +Ported to Python 3. +""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function +from __future__ import unicode_literals + +from future.utils import PY2 +if PY2: + from future.builtins import filter, map, zip, ascii, chr, hex, input, next, oct, open, pow, round, super, bytes, dict, list, object, range, str, max, min # noqa: F401 + from six.moves import cStringIO as StringIO from twisted.internet import defer, reactor from twisted.trial import unittest @@ -73,11 +85,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): return n d.addCallback(_created) d.addCallback(lambda n: - n.overwrite(MutableData("Contents" * 50000))) + n.overwrite(MutableData(b"Contents" * 50000))) d.addCallback(lambda ignored: self._node.download_best_version()) d.addCallback(lambda contents: - self.failUnlessEqual(contents, "Contents" * 50000)) + self.failUnlessEqual(contents, b"Contents" * 50000)) return d def test_max_shares(self): @@ -95,13 +107,13 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): d.addCallback(_created) # Now we upload some contents d.addCallback(lambda n: - n.overwrite(MutableData("contents" * 50000))) + n.overwrite(MutableData(b"contents" * 50000))) # ...then download contents d.addCallback(lambda ignored: self._node.download_best_version()) # ...and check to make sure everything went okay. d.addCallback(lambda contents: - self.failUnlessEqual("contents" * 50000, contents)) + self.failUnlessEqual(b"contents" * 50000, contents)) return d def test_max_shares_mdmf(self): @@ -119,11 +131,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): return n d.addCallback(_created) d.addCallback(lambda n: - n.overwrite(MutableData("contents" * 50000))) + n.overwrite(MutableData(b"contents" * 50000))) d.addCallback(lambda ignored: self._node.download_best_version()) d.addCallback(lambda contents: - self.failUnlessEqual(contents, "contents" * 50000)) + self.failUnlessEqual(contents, b"contents" * 50000)) return d def test_mdmf_filenode_cap(self): @@ -148,7 +160,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def _created(n): self.failUnless(isinstance(n, MutableFileNode)) s = n.get_uri() - self.failUnless(s.startswith("URI:MDMF")) + self.failUnless(s.startswith(b"URI:MDMF")) n2 = self.nodemaker.create_from_cap(s) self.failUnless(isinstance(n2, MutableFileNode)) self.failUnlessEqual(n.get_storage_index(), n2.get_storage_index()) @@ -216,33 +228,33 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): d.addCallback(lambda smap: smap.dump(StringIO())) d.addCallback(lambda sio: 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: 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 size: - self.failUnlessEqual(size, len("contents 1"))) - d.addCallback(lambda res: n.overwrite(MutableData("contents 2"))) + self.failUnlessEqual(size, len(b"contents 1"))) + d.addCallback(lambda res: n.overwrite(MutableData(b"contents 2"))) 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 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: 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 smap: n.download_version(smap, 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 # mapupdate-to-retrieve data caching (i.e. make the shares larger # than the default readsize, which is 2000 bytes). A 15kB file # 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: - self.failUnlessEqual(res, "large size file" * 1000)) + self.failUnlessEqual(res, b"large size file" * 1000)) return d d.addCallback(_created) return d @@ -261,7 +273,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): # Now overwrite the contents with some new contents. We want # to make them big enough to force the file to be uploaded # 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) d.addCallback(lambda ignored: n.overwrite(big_contents_uploadable)) @@ -273,7 +285,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): # before, they need to be big enough to force multiple # segments, so that we make the downloader deal with # multiple segments. - bigger_contents = "contents2" * 1000000 # about 9MiB + bigger_contents = b"contents2" * 1000000 # about 9MiB bigger_contents_uploadable = MutableData(bigger_contents) d.addCallback(lambda ignored: n.overwrite(bigger_contents_uploadable)) @@ -289,7 +301,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def test_retrieve_producer_mdmf(self): # We should make sure that the retriever is able to pause and stop # correctly. - data = "contents1" * 100000 + data = b"contents1" * 100000 d = self.nodemaker.create_mutable_file(MutableData(data), version=MDMF_VERSION) d.addCallback(lambda node: node.get_best_mutable_version()) @@ -300,7 +312,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): # after-the-first-write() trick to pause or stop the download. # Disabled until we find a better approach. def OFF_test_retrieve_producer_sdmf(self): - data = "contents1" * 100000 + data = b"contents1" * 100000 d = self.nodemaker.create_mutable_file(MutableData(data), version=SDMF_VERSION) d.addCallback(lambda node: node.get_best_mutable_version()) @@ -347,15 +359,15 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def _created(node): self.uri = node.get_uri() # also confirm that the cap has no extension fields - pieces = self.uri.split(":") + pieces = self.uri.split(b":") self.failUnlessEqual(len(pieces), 4) - return node.overwrite(MutableData("contents1" * 100000)) + return node.overwrite(MutableData(b"contents1" * 100000)) def _then(ignored): node = self.nodemaker.create_from_cap(self.uri) return node.download_best_version() def _downloaded(data): - self.failUnlessEqual(data, "contents1" * 100000) + self.failUnlessEqual(data, b"contents1" * 100000) d.addCallback(_created) d.addCallback(_then) d.addCallback(_downloaded) @@ -368,7 +380,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): be published. Otherwise, we introduce undesirable semantics that are a 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, version=MDMF_VERSION) def _check_server_write_counts(ignored): @@ -381,22 +393,22 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def test_create_with_initial_contents(self): - upload1 = MutableData("contents 1") + upload1 = MutableData(b"contents 1") d = self.nodemaker.create_mutable_file(upload1) def _created(n): d = n.download_best_version() - d.addCallback(lambda res: self.failUnlessEqual(res, "contents 1")) - upload2 = MutableData("contents 2") + d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 1")) + upload2 = MutableData(b"contents 2") d.addCallback(lambda res: n.overwrite(upload2)) 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 d.addCallback(_created) return d 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) d = self.nodemaker.create_mutable_file(initial_contents_uploadable, version=MDMF_VERSION) @@ -404,24 +416,24 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): d = n.download_best_version() d.addCallback(lambda data: self.failUnlessEqual(data, initial_contents)) - uploadable2 = MutableData(initial_contents + "foobarbaz") + uploadable2 = MutableData(initial_contents + b"foobarbaz") d.addCallback(lambda ignored: n.overwrite(uploadable2)) d.addCallback(lambda ignored: n.download_best_version()) d.addCallback(lambda data: self.failUnlessEqual(data, initial_contents + - "foobarbaz")) + b"foobarbaz")) return d d.addCallback(_created) return d def test_create_with_initial_contents_function(self): - data = "initial contents" + data = b"initial contents" def _make_contents(n): self.failUnless(isinstance(n, MutableFileNode)) key = n.get_writekey() - self.failUnless(isinstance(key, str), key) + self.failUnless(isinstance(key, bytes), key) self.failUnlessEqual(len(key), 16) # AES key size return MutableData(data) d = self.nodemaker.create_mutable_file(_make_contents) @@ -433,11 +445,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def test_create_mdmf_with_initial_contents_function(self): - data = "initial contents" * 100000 + data = b"initial contents" * 100000 def _make_contents(n): self.failUnless(isinstance(n, MutableFileNode)) key = n.get_writekey() - self.failUnless(isinstance(key, str), key) + self.failUnless(isinstance(key, bytes), key) self.failUnlessEqual(len(key), 16) return MutableData(data) d = self.nodemaker.create_mutable_file(_make_contents, @@ -450,7 +462,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): 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) d = self.nodemaker.create_mutable_file(BIG_uploadable) def _created(n): @@ -469,7 +481,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def test_modify(self): def _modifier(old_contents, servermap, first_time): - new_contents = old_contents + "line2" + new_contents = old_contents + b"line2" return new_contents def _non_modifier(old_contents, servermap, first_time): return old_contents @@ -478,7 +490,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def _error_modifier(old_contents, servermap, first_time): raise ValueError("oops") 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 calls = [] def _ucw_error_modifier(old_contents, servermap, first_time): @@ -486,7 +498,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): calls.append(1) if len(calls) <= 1: raise UncoordinatedWriteError("simulated") - new_contents = old_contents + "line3" + new_contents = old_contents + b"line3" return new_contents def _ucw_error_non_modifier(old_contents, servermap, first_time): # simulate an UncoordinatedWriteError once, and don't actually @@ -496,41 +508,41 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): raise UncoordinatedWriteError("simulated") return old_contents - initial_contents = "line1" + initial_contents = b"line1" d = self.nodemaker.create_mutable_file(MutableData(initial_contents)) def _created(n): d = n.modify(_modifier) 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: n.modify(_non_modifier)) 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: n.modify(_none_modifier)) 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.shouldFail(ValueError, "error_modifier", None, n.modify, _error_modifier)) 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: 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: n.modify(_ucw_error_modifier)) d.addCallback(lambda res: self.failUnlessEqual(len(calls), 2)) d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: self.failUnlessEqual(res, - "line1line2line3")) + b"line1line2line3")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "ucw")) def _reset_ucw_error_modifier(res): @@ -548,7 +560,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): d.addCallback(lambda res: self.failUnlessEqual(len(calls), 2)) d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: self.failUnlessEqual(res, - "line1line2line3")) + b"line1line2line3")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 4, "ucw")) d.addCallback(lambda res: n.modify(_toobig_modifier)) return d @@ -558,14 +570,14 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): def test_modify_backoffer(self): def _modifier(old_contents, servermap, first_time): - return old_contents + "line2" + return old_contents + b"line2" calls = [] def _ucw_error_modifier(old_contents, servermap, first_time): # simulate an UncoordinatedWriteError once calls.append(1) if len(calls) <= 1: raise UncoordinatedWriteError("simulated") - return old_contents + "line3" + return old_contents + b"line3" def _always_ucw_error_modifier(old_contents, servermap, first_time): raise UncoordinatedWriteError("simulated") def _backoff_stopper(node, f): @@ -580,11 +592,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): giveuper._delay = 0.1 giveuper.factor = 1 - d = self.nodemaker.create_mutable_file(MutableData("line1")) + d = self.nodemaker.create_mutable_file(MutableData(b"line1")) def _created(n): d = n.modify(_modifier) 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: @@ -593,7 +605,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): n.modify, _ucw_error_modifier, _backoff_stopper)) 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")) def _reset_ucw_error_modifier(res): @@ -604,7 +616,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): _backoff_pauser)) d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: self.failUnlessEqual(res, - "line1line2line3")) + b"line1line2line3")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "pause")) d.addCallback(lambda res: @@ -614,7 +626,7 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): giveuper.delay)) d.addCallback(lambda res: n.download_best_version()) d.addCallback(lambda res: self.failUnlessEqual(res, - "line1line2line3")) + b"line1line2line3")) d.addCallback(lambda res: self.failUnlessCurrentSeqnumIs(n, 3, "giveup")) return d @@ -630,22 +642,22 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): d.addCallback(lambda smap: smap.dump(StringIO())) d.addCallback(lambda sio: 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: n.download_best_version()) - d.addCallback(lambda res: self.failUnlessEqual(res, "contents 1")) - d.addCallback(lambda res: n.overwrite(MutableData("contents 2"))) + d.addCallback(lambda res: self.failUnlessEqual(res, b"contents 1")) + d.addCallback(lambda res: n.overwrite(MutableData(b"contents 2"))) 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 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: 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 smap: n.download_version(smap, 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 d.addCallback(_created) return d @@ -663,11 +675,11 @@ class Filenode(unittest.TestCase, testutil.ShouldFailMixin): d.addCallback(lambda ignored: self.failUnlessEqual(self.n.get_size(), 0)) d.addCallback(lambda ignored: - self.n.overwrite(MutableData("foobarbaz"))) + self.n.overwrite(MutableData(b"foobarbaz"))) d.addCallback(lambda ignored: self.failUnlessEqual(self.n.get_size(), 9)) d.addCallback(lambda ignored: - self.nodemaker.create_mutable_file(MutableData("foobarbaz"))) + self.nodemaker.create_mutable_file(MutableData(b"foobarbaz"))) d.addCallback(_created) d.addCallback(lambda ignored: self.failUnlessEqual(self.n.get_size(), 9)) diff --git a/src/allmydata/test/mutable/util.py b/src/allmydata/test/mutable/util.py index 30a75aead..07d4e74e4 100644 --- a/src/allmydata/test/mutable/util.py +++ b/src/allmydata/test/mutable/util.py @@ -1,3 +1,4 @@ +from future.utils import bchr from past.builtins import long from io import BytesIO @@ -146,14 +147,14 @@ class FakeStorageServer(object): def flip_bit(original, byte_offset): return (original[:byte_offset] + - chr(ord(original[byte_offset]) ^ 0x01) + + bchr(ord(original[byte_offset:byte_offset+1]) ^ 0x01) + original[byte_offset+1:]) def add_two(original, byte_offset): # It isn't enough to simply flip the bit for the version number, # because 1 is a valid version number. So we add two instead. return (original[:byte_offset] + - chr(ord(original[byte_offset]) ^ 0x02) + + bchr(ord(original[byte_offset:byte_offset+1]) ^ 0x02) + original[byte_offset+1:]) def corrupt(res, s, offset, shnums_to_corrupt=None, offset_offset=0): @@ -313,7 +314,7 @@ class PublishMixin(object): def publish_one(self): # publish a file and create shares, which can then be manipulated # later. - self.CONTENTS = "New contents go here" * 1000 + self.CONTENTS = b"New contents go here" * 1000 self.uploadable = MutableData(self.CONTENTS) self._storage = FakeStorage() self._nodemaker = make_nodemaker(self._storage) @@ -330,7 +331,7 @@ class PublishMixin(object): # an MDMF file. # self.CONTENTS should have more than one segment. if data is None: - data = "This is an MDMF file" * 100000 + data = b"This is an MDMF file" * 100000 self.CONTENTS = data self.uploadable = MutableData(self.CONTENTS) self._storage = FakeStorage() @@ -348,7 +349,7 @@ class PublishMixin(object): # like publish_one, except that the result is guaranteed to be # an SDMF file if data is None: - data = "This is an SDMF file" * 1000 + data = b"This is an SDMF file" * 1000 self.CONTENTS = data self.uploadable = MutableData(self.CONTENTS) self._storage = FakeStorage() @@ -363,11 +364,11 @@ class PublishMixin(object): def publish_multiple(self, version=0): - self.CONTENTS = ["Contents 0", - "Contents 1", - "Contents 2", - "Contents 3a", - "Contents 3b"] + self.CONTENTS = [b"Contents 0", + b"Contents 1", + b"Contents 2", + b"Contents 3a", + b"Contents 3b"] self.uploadables = [MutableData(d) for d in self.CONTENTS] self._copied_shares = {} self._storage = FakeStorage() diff --git a/src/allmydata/util/_python3.py b/src/allmydata/util/_python3.py index d689dfff3..d26579cc9 100644 --- a/src/allmydata/util/_python3.py +++ b/src/allmydata/util/_python3.py @@ -95,9 +95,12 @@ PORTED_MODULES = [ ] PORTED_TEST_MODULES = [ + "allmydata.test.mutable.test_checker", "allmydata.test.mutable.test_datahandle", "allmydata.test.mutable.test_different_encoding", + "allmydata.test.mutable.test_exceptions", "allmydata.test.mutable.test_filehandle", + "allmydata.test.mutable.test_filenode", "allmydata.test.test_abbreviate", "allmydata.test.test_base32", "allmydata.test.test_base62",