Changeset d346e085 in trunk


Ignore:
Timestamp:
2010-07-11T20:02:52Z (15 years ago)
Author:
david-sarah <david-sarah@…>
Branches:
master
Children:
2166eef
Parents:
ca660a5
Message:

Add tests of caps from the future that have non-ASCII characters in them (encoded as UTF-8). The changes to test_uri.py, test_client.py, and test_dirnode.py add tests of non-ASCII future caps in addition to the current tests. The changes to test_web.py just replace the tests of all-ASCII future caps with tests of non-ASCII future caps. We also change uses of failUnlessEqual to failUnlessReallyEqual, in order to catch cases where the type of a string is not as expected.

Location:
src/allmydata/test
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified src/allmydata/test/test_client.py

    rca660a5 rd346e085  
    2828              )
    2929
    30 class Basic(unittest.TestCase):
     30class Basic(testutil.ReallyEqualMixin, unittest.TestCase):
    3131    def test_loadable(self):
    3232        basedir = "test_client.Basic.test_loadable"
    … …  
    8282        f.close()
    8383        c = client.Client(basedir)
    84         self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 1000)
     84        self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space, 1000)
    8585
    8686    def test_reserved_2(self):
    … …  
    9494        f.close()
    9595        c = client.Client(basedir)
    96         self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 10*1000)
     96        self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space, 10*1000)
    9797
    9898    def test_reserved_3(self):
    … …  
    106106        f.close()
    107107        c = client.Client(basedir)
    108         self.failUnlessEqual(c.getServiceNamed("storage").reserved_space,
     108        self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space,
    109109                             5*1000*1000)
    110110
    … …  
    119119        f.close()
    120120        c = client.Client(basedir)
    121         self.failUnlessEqual(c.getServiceNamed("storage").reserved_space,
    122                              78*1000*1000*1000)
     121        self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space,
     122                                   78*1000*1000*1000)
    123123
    124124    def test_reserved_bad(self):
    … …  
    132132        f.close()
    133133        c = client.Client(basedir)
    134         self.failUnlessEqual(c.getServiceNamed("storage").reserved_space, 0)
     134        self.failUnlessReallyEqual(c.getServiceNamed("storage").reserved_space, 0)
    135135
    136136    def _permute(self, sb, key):
    … …  
    143143            sb.test_add_server(k, None)
    144144
    145         self.failUnlessEqual(self._permute(sb, "one"), ['3','1','0','4','2'])
    146         self.failUnlessEqual(self._permute(sb, "two"), ['0','4','2','1','3'])
     145        self.failUnlessReallyEqual(self._permute(sb, "one"), ['3','1','0','4','2'])
     146        self.failUnlessReallyEqual(self._permute(sb, "two"), ['0','4','2','1','3'])
    147147        sb.test_servers.clear()
    148         self.failUnlessEqual(self._permute(sb, "one"), [])
     148        self.failUnlessReallyEqual(self._permute(sb, "one"), [])
    149149
    150150    def test_versions(self):
    … …  
    155155        ss = c.getServiceNamed("storage")
    156156        verdict = ss.remote_get_version()
    157         self.failUnlessEqual(verdict["application-version"],
    158                              str(allmydata.__full_version__))
     157        self.failUnlessReallyEqual(verdict["application-version"],
     158                                   str(allmydata.__full_version__))
    159159        self.failIfEqual(str(allmydata.__version__), "unknown")
    160160        self.failUnless("." in str(allmydata.__full_version__),
    … …  
    226226        return d
    227227
    228 class NodeMaker(unittest.TestCase):
     228class NodeMaker(testutil.ReallyEqualMixin, unittest.TestCase):
    229229    def test_maker(self):
    230230        basedir = "client/NodeMaker/maker"
    … …  
    298298        self.failIf(IDirectoryNode.providedBy(n))
    299299        self.failUnless(n.is_unknown())
    300         self.failUnlessEqual(n.get_uri(), unknown_rw)
    301         self.failUnlessEqual(n.get_write_uri(), unknown_rw)
    302         self.failUnlessEqual(n.get_readonly_uri(), "ro." + unknown_ro)
     300        self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
     301        self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
     302        self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)
     303
     304        unknown_rw = u"lafs://from_the_future_rw_\u263A".encode('utf-8')
     305        unknown_ro = u"lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
     306        n = c.create_node_from_uri(unknown_rw, unknown_ro)
     307        self.failUnless(IFilesystemNode.providedBy(n))
     308        self.failIf(IFileNode.providedBy(n))
     309        self.failIf(IImmutableFileNode.providedBy(n))
     310        self.failIf(IMutableFileNode.providedBy(n))
     311        self.failIf(IDirectoryNode.providedBy(n))
     312        self.failUnless(n.is_unknown())
     313        self.failUnlessReallyEqual(n.get_uri(), unknown_rw)
     314        self.failUnlessReallyEqual(n.get_write_uri(), unknown_rw)
     315        self.failUnlessReallyEqual(n.get_readonly_uri(), "ro." + unknown_ro)

  • TabularUnified src/allmydata/test/test_dirnode.py

    rca660a5 rd346e085  
    4747future_write_uri = "x-tahoe-crazy://I_am_from_the_future."
    4848future_read_uri = "x-tahoe-crazy-readonly://I_am_from_the_future."
     49future_nonascii_write_uri = u"x-tahoe-even-more-crazy://I_am_from_the_future_rw_\u263A".encode('utf-8')
     50future_nonascii_read_uri = u"x-tahoe-even-more-crazy-readonly://I_am_from_the_future_ro_\u263A".encode('utf-8')
    4951
    5052# 'o' 'n' 'e-macron'
    … …  
    5355
    5456class Dirnode(GridTestMixin, unittest.TestCase,
    55               testutil.ShouldFailMixin, testutil.StallMixin, ErrorMixin):
     57              testutil.ReallyEqualMixin, testutil.ShouldFailMixin, testutil.StallMixin, ErrorMixin):
    5658    timeout = 240 # It takes longer than 120 seconds on Francois's arm box.
    5759
    … …  
    8587                u"fut": (nm.create_from_cap(future_write_uri, future_read_uri), {}),
    8688                u"fro": (nm.create_from_cap(None, future_read_uri), {}),
     89                u"fut-unic": (nm.create_from_cap(future_nonascii_write_uri, future_nonascii_read_uri), {}),
     90                u"fro-unic": (nm.create_from_cap(None, future_nonascii_read_uri), {}),
    8791                u"empty_litdir": (nm.create_from_cap(empty_litdir_uri), {}),
    8892                u"tiny_litdir": (nm.create_from_cap(tiny_litdir_uri), {}),
    … …  
    103107       
    104108        def _check_kids(children):
    105             self.failUnlessEqual(set(children.keys()),
    106                                  set([one_nfc, u"two", u"mut", u"fut", u"fro", u"empty_litdir", u"tiny_litdir"]))
     109            self.failUnlessReallyEqual(set(children.keys()),
     110                                       set([one_nfc, u"two", u"mut", u"fut", u"fro",
     111                                            u"fut-unic", u"fro-unic", u"empty_litdir", u"tiny_litdir"]))
    107112            one_node, one_metadata = children[one_nfc]
    108113            two_node, two_metadata = children[u"two"]
    … …  
    110115            fut_node, fut_metadata = children[u"fut"]
    111116            fro_node, fro_metadata = children[u"fro"]
     117            futna_node, futna_metadata = children[u"fut-unic"]
     118            frona_node, frona_metadata = children[u"fro-unic"]
    112119            emptylit_node, emptylit_metadata = children[u"empty_litdir"]
    113120            tinylit_node, tinylit_metadata = children[u"tiny_litdir"]
    114121           
    115             self.failUnlessEqual(one_node.get_size(), 3)
    116             self.failUnlessEqual(one_node.get_uri(), one_uri)
    117             self.failUnlessEqual(one_node.get_readonly_uri(), one_uri)
     122            self.failUnlessReallyEqual(one_node.get_size(), 3)
     123            self.failUnlessReallyEqual(one_node.get_uri(), one_uri)
     124            self.failUnlessReallyEqual(one_node.get_readonly_uri(), one_uri)
    118125            self.failUnless(isinstance(one_metadata, dict), one_metadata)
    119126           
    120             self.failUnlessEqual(two_node.get_size(), 14861)
    121             self.failUnlessEqual(two_node.get_uri(), setup_py_uri)
    122             self.failUnlessEqual(two_node.get_readonly_uri(), setup_py_uri)
    123             self.failUnlessEqual(two_metadata["metakey"], "metavalue")
     127            self.failUnlessReallyEqual(two_node.get_size(), 14861)
     128            self.failUnlessReallyEqual(two_node.get_uri(), setup_py_uri)
     129            self.failUnlessReallyEqual(two_node.get_readonly_uri(), setup_py_uri)
     130            self.failUnlessReallyEqual(two_metadata["metakey"], "metavalue")
    124131           
    125             self.failUnlessEqual(mut_node.get_uri(), mut_write_uri)
    126             self.failUnlessEqual(mut_node.get_readonly_uri(), mut_read_uri)
     132            self.failUnlessReallyEqual(mut_node.get_uri(), mut_write_uri)
     133            self.failUnlessReallyEqual(mut_node.get_readonly_uri(), mut_read_uri)
    127134            self.failUnless(isinstance(mut_metadata, dict), mut_metadata)
    128135           
    129136            self.failUnless(fut_node.is_unknown())
    130             self.failUnlessEqual(fut_node.get_uri(), future_write_uri)
    131             self.failUnlessEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
     137            self.failUnlessReallyEqual(fut_node.get_uri(), future_write_uri)
     138            self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
    132139            self.failUnless(isinstance(fut_metadata, dict), fut_metadata)
    133            
     140
     141            self.failUnless(futna_node.is_unknown())
     142            self.failUnlessReallyEqual(futna_node.get_uri(), future_nonascii_write_uri)
     143            self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "ro." + future_nonascii_read_uri)
     144            self.failUnless(isinstance(futna_metadata, dict), futna_metadata)
     145
    134146            self.failUnless(fro_node.is_unknown())
    135             self.failUnlessEqual(fro_node.get_uri(), "ro." + future_read_uri)
    136             self.failUnlessEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
     147            self.failUnlessReallyEqual(fro_node.get_uri(), "ro." + future_read_uri)
     148            self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
    137149            self.failUnless(isinstance(fro_metadata, dict), fro_metadata)
    138150
     151            self.failUnless(frona_node.is_unknown())
     152            self.failUnlessReallyEqual(frona_node.get_uri(), "ro." + future_nonascii_read_uri)
     153            self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "ro." + future_nonascii_read_uri)
     154            self.failUnless(isinstance(frona_metadata, dict), frona_metadata)
     155
    139156            self.failIf(emptylit_node.is_unknown())
    140             self.failUnlessEqual(emptylit_node.get_storage_index(), None)
     157            self.failUnlessReallyEqual(emptylit_node.get_storage_index(), None)
    141158            self.failIf(tinylit_node.is_unknown())
    142             self.failUnlessEqual(tinylit_node.get_storage_index(), None)
     159            self.failUnlessReallyEqual(tinylit_node.get_storage_index(), None)
    143160
    144161            d2 = defer.succeed(None)
    … …  
    146163            d2.addCallback(lambda children: self.failUnlessEqual(children, {}))
    147164            d2.addCallback(lambda ignored: tinylit_node.list())
    148             d2.addCallback(lambda children: self.failUnlessEqual(set(children.keys()),
    149                                                                  set([u"short"])))
     165            d2.addCallback(lambda children: self.failUnlessReallyEqual(set(children.keys()),
     166                                                                       set([u"short"])))
    150167            d2.addCallback(lambda ignored: tinylit_node.list())
    151168            d2.addCallback(lambda children: children[u"short"][0].read(MemAccum()))
    152             d2.addCallback(lambda accum: self.failUnlessEqual(accum.data, "The end."))
     169            d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, "The end."))
    153170            return d2
    154171
    … …  
    186203                         {"metakey": "metavalue"}),
    187204                u"fut": (nm.create_from_cap(None, future_read_uri), {}),
     205                u"futna": (nm.create_from_cap(None, future_nonascii_read_uri), {}),
    188206                u"empty_litdir": (nm.create_from_cap(empty_litdir_uri), {}),
    189207                u"tiny_litdir": (nm.create_from_cap(tiny_litdir_uri), {}),
    … …  
    207225       
    208226        def _check_kids(children):
    209             self.failUnlessEqual(set(children.keys()),
    210                                  set([one_nfc, u"two", u"fut", u"empty_litdir", u"tiny_litdir"]))
     227            self.failUnlessReallyEqual(set(children.keys()),
     228                                       set([one_nfc, u"two", u"fut", u"futna", u"empty_litdir", u"tiny_litdir"]))
    211229            one_node, one_metadata = children[one_nfc]
    212230            two_node, two_metadata = children[u"two"]
    213231            fut_node, fut_metadata = children[u"fut"]
     232            futna_node, futna_metadata = children[u"futna"]
    214233            emptylit_node, emptylit_metadata = children[u"empty_litdir"]
    215234            tinylit_node, tinylit_metadata = children[u"tiny_litdir"]
    216235
    217             self.failUnlessEqual(one_node.get_size(), 3)
    218             self.failUnlessEqual(one_node.get_uri(), one_uri)
    219             self.failUnlessEqual(one_node.get_readonly_uri(), one_uri)
     236            self.failUnlessReallyEqual(one_node.get_size(), 3)
     237            self.failUnlessReallyEqual(one_node.get_uri(), one_uri)
     238            self.failUnlessReallyEqual(one_node.get_readonly_uri(), one_uri)
    220239            self.failUnless(isinstance(one_metadata, dict), one_metadata)
    221240
    222             self.failUnlessEqual(two_node.get_size(), 14861)
    223             self.failUnlessEqual(two_node.get_uri(), setup_py_uri)
    224             self.failUnlessEqual(two_node.get_readonly_uri(), setup_py_uri)
    225             self.failUnlessEqual(two_metadata["metakey"], "metavalue")
     241            self.failUnlessReallyEqual(two_node.get_size(), 14861)
     242            self.failUnlessReallyEqual(two_node.get_uri(), setup_py_uri)
     243            self.failUnlessReallyEqual(two_node.get_readonly_uri(), setup_py_uri)
     244            self.failUnlessReallyEqual(two_metadata["metakey"], "metavalue")
    226245
    227246            self.failUnless(fut_node.is_unknown())
    228             self.failUnlessEqual(fut_node.get_uri(), "imm." + future_read_uri)
    229             self.failUnlessEqual(fut_node.get_readonly_uri(), "imm." + future_read_uri)
     247            self.failUnlessReallyEqual(fut_node.get_uri(), "imm." + future_read_uri)
     248            self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "imm." + future_read_uri)
    230249            self.failUnless(isinstance(fut_metadata, dict), fut_metadata)
    231250
     251            self.failUnless(futna_node.is_unknown())
     252            self.failUnlessReallyEqual(futna_node.get_uri(), "imm." + future_nonascii_read_uri)
     253            self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "imm." + future_nonascii_read_uri)
     254            self.failUnless(isinstance(futna_metadata, dict), futna_metadata)
     255
    232256            self.failIf(emptylit_node.is_unknown())
    233             self.failUnlessEqual(emptylit_node.get_storage_index(), None)
     257            self.failUnlessReallyEqual(emptylit_node.get_storage_index(), None)
    234258            self.failIf(tinylit_node.is_unknown())
    235             self.failUnlessEqual(tinylit_node.get_storage_index(), None)
     259            self.failUnlessReallyEqual(tinylit_node.get_storage_index(), None)
    236260
    237261            d2 = defer.succeed(None)
    … …  
    239263            d2.addCallback(lambda children: self.failUnlessEqual(children, {}))
    240264            d2.addCallback(lambda ignored: tinylit_node.list())
    241             d2.addCallback(lambda children: self.failUnlessEqual(set(children.keys()),
    242                                                                  set([u"short"])))
     265            d2.addCallback(lambda children: self.failUnlessReallyEqual(set(children.keys()),
     266                                                                       set([u"short"])))
    243267            d2.addCallback(lambda ignored: tinylit_node.list())
    244268            d2.addCallback(lambda children: children[u"short"][0].read(MemAccum()))
    245             d2.addCallback(lambda accum: self.failUnlessEqual(accum.data, "The end."))
     269            d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, "The end."))
    246270            return d2
    247271
    … …  
    296320            cap = dn.get_cap()
    297321            self.failUnlessIn("LIT", cap.to_string())
    298             self.failUnlessEqual(cap.to_string(), "URI:DIR2-LIT:")
     322            self.failUnlessReallyEqual(cap.to_string(), "URI:DIR2-LIT:")
    299323            self.cap = cap
    300324            return dn.list()
    … …  
    314338            cap = dn.get_cap()
    315339            self.failUnlessIn("LIT", cap.to_string())
    316             self.failUnlessEqual(cap.to_string(),
    317                                  "URI:DIR2-LIT:gi4tumj2n4wdcmz2kvjesosmjfkdu3rvpbtwwlbqhiwdeot3puwcy")
     340            self.failUnlessReallyEqual(cap.to_string(),
     341                                       "URI:DIR2-LIT:gi4tumj2n4wdcmz2kvjesosmjfkdu3rvpbtwwlbqhiwdeot3puwcy")
    318342            self.cap = cap
    319343            return dn.list()
    320344        d.addCallback(_created_small)
    321         d.addCallback(lambda kids: self.failUnlessEqual(kids.keys(), [u"o"]))
     345        d.addCallback(lambda kids: self.failUnlessReallyEqual(kids.keys(), [u"o"]))
    322346
    323347        # now test n.create_subdirectory(mutable=False)
    … …  
    329353            d.addCallback(lambda ign: n.list())
    330354            d.addCallback(lambda children:
    331                           self.failUnlessEqual(children.keys(), [u"subdir"]))
     355                          self.failUnlessReallyEqual(children.keys(), [u"subdir"]))
    332356            d.addCallback(lambda ign: n.get(u"subdir"))
    333357            d.addCallback(lambda sd: sd.list())
    … …  
    363387
    364388        child = nm.create_from_cap(spacedout_write_uri, spacedout_read_uri)
    365         self.failUnlessEqual(child.get_write_uri(), spacedout_write_uri)
    366         self.failUnlessEqual(child.get_readonly_uri(), "ro." + spacedout_read_uri)
     389        self.failUnlessReallyEqual(child.get_write_uri(), spacedout_write_uri)
     390        self.failUnlessReallyEqual(child.get_readonly_uri(), "ro." + spacedout_read_uri)
    367391
    368392        child_dottedi = u"ch\u0131\u0307ld"
    … …  
    397421                self.failUnlessIn(name, kids_out)
    398422                (expected_child, ign) = kids_out[name]
    399                 self.failUnlessEqual(rw_uri, expected_child.get_write_uri())
    400                 self.failUnlessEqual("ro." + ro_uri, expected_child.get_readonly_uri())
     423                self.failUnlessReallyEqual(rw_uri, expected_child.get_write_uri())
     424                self.failUnlessReallyEqual("ro." + ro_uri, expected_child.get_readonly_uri())
    401425                numkids += 1
    402426
    403             self.failUnlessEqual(numkids, len(kids_out))
     427            self.failUnlessReallyEqual(numkids, len(kids_out))
    404428            return self.rootnode
    405429        d.addCallback(_check_data)
    … …  
    430454            # normalized to 'i'.
    431455
    432             self.failUnlessEqual(set(children.keys()), set(kids_norm.keys()))
     456            self.failUnlessReallyEqual(set(children.keys()), set(kids_norm.keys()))
    433457            child_node, child_metadata = children[u"child"]
    434458
    435             self.failUnlessEqual(child_node.get_write_uri(), stripped_write_uri)
    436             self.failUnlessEqual(child_node.get_readonly_uri(), "ro." + stripped_read_uri)
     459            self.failUnlessReallyEqual(child_node.get_write_uri(), stripped_write_uri)
     460            self.failUnlessReallyEqual(child_node.get_readonly_uri(), "ro." + stripped_read_uri)
    437461        d.addCallback(_check_kids)
    438462
    … …  
    490514            self.failUnless(IDeepCheckResults.providedBy(r))
    491515            c = r.get_counters()
    492             self.failUnlessEqual(c,
    493                                  {"count-objects-checked": 4,
    494                                   "count-objects-healthy": 4,
    495                                   "count-objects-unhealthy": 0,
    496                                   "count-objects-unrecoverable": 0,
    497                                   "count-corrupt-shares": 0,
    498                                   })
     516            self.failUnlessReallyEqual(c,
     517                                       {"count-objects-checked": 4,
     518                                        "count-objects-healthy": 4,
     519                                        "count-objects-unhealthy": 0,
     520                                        "count-objects-unrecoverable": 0,
     521                                        "count-corrupt-shares": 0,
     522                                        })
    499523            self.failIf(r.get_corrupt_shares())
    500             self.failUnlessEqual(len(r.get_all_results()), 4)
     524            self.failUnlessReallyEqual(len(r.get_all_results()), 4)
    501525        d.addCallback(_check_results)
    502526        return d
    … …  
    511535            self.failUnless(IDeepCheckAndRepairResults.providedBy(r))
    512536            c = r.get_counters()
    513             self.failUnlessEqual(c,
    514                                  {"count-objects-checked": 4,
    515                                   "count-objects-healthy-pre-repair": 4,
    516                                   "count-objects-unhealthy-pre-repair": 0,
    517                                   "count-objects-unrecoverable-pre-repair": 0,
    518                                   "count-corrupt-shares-pre-repair": 0,
    519                                   "count-objects-healthy-post-repair": 4,
    520                                   "count-objects-unhealthy-post-repair": 0,
    521                                   "count-objects-unrecoverable-post-repair": 0,
    522                                   "count-corrupt-shares-post-repair": 0,
    523                                   "count-repairs-attempted": 0,
    524                                   "count-repairs-successful": 0,
    525                                   "count-repairs-unsuccessful": 0,
    526                                   })
     537            self.failUnlessReallyEqual(c,
     538                                       {"count-objects-checked": 4,
     539                                        "count-objects-healthy-pre-repair": 4,
     540                                        "count-objects-unhealthy-pre-repair": 0,
     541                                        "count-objects-unrecoverable-pre-repair": 0,
     542                                        "count-corrupt-shares-pre-repair": 0,
     543                                        "count-objects-healthy-post-repair": 4,
     544                                        "count-objects-unhealthy-post-repair": 0,
     545                                        "count-objects-unrecoverable-post-repair": 0,
     546                                        "count-corrupt-shares-post-repair": 0,
     547                                        "count-repairs-attempted": 0,
     548                                        "count-repairs-successful": 0,
     549                                        "count-repairs-unsuccessful": 0,
     550                                        })
    527551            self.failIf(r.get_corrupt_shares())
    528552            self.failIf(r.get_remaining_corrupt_shares())
    529             self.failUnlessEqual(len(r.get_all_results()), 4)
     553            self.failUnlessReallyEqual(len(r.get_all_results()), 4)
    530554        d.addCallback(_check_results)
    531555        return d
    … …  
    543567        def _check_results(r):
    544568            c = r.get_counters()
    545             self.failUnlessEqual(c,
    546                                  {"count-objects-checked": 4,
    547                                   "count-objects-healthy": 3,
    548                                   "count-objects-unhealthy": 1,
    549                                   "count-objects-unrecoverable": 0,
    550                                   "count-corrupt-shares": 0,
    551                                   })
    552             #self.failUnlessEqual(len(r.get_problems()), 1) # TODO
     569            self.failUnlessReallyEqual(c,
     570                                       {"count-objects-checked": 4,
     571                                        "count-objects-healthy": 3,
     572                                        "count-objects-unhealthy": 1,
     573                                        "count-objects-unrecoverable": 0,
     574                                        "count-corrupt-shares": 0,
     575                                        })
     576            #self.failUnlessReallyEqual(len(r.get_problems()), 1) # TODO
    553577        d.addCallback(_check_results)
    554578        return d
    … …  
    632656            self.failUnless(u_v.startswith("URI:DIR2-Verifier:"), u_v)
    633657            u_r = n.get_repair_cap().to_string()
    634             self.failUnlessEqual(u_r, u)
     658            self.failUnlessReallyEqual(u_r, u)
    635659            self.expected_manifest.append( ((), u) )
    636660            self.expected_verifycaps.add(u_v)
    … …  
    638662            self.expected_storage_indexes.add(base32.b2a(si))
    639663            expected_si = n._uri.get_storage_index()
    640             self.failUnlessEqual(si, expected_si)
     664            self.failUnlessReallyEqual(si, expected_si)
    641665
    642666            d = n.list()
    … …  
    687711            d.addCallback(lambda res: n.list())
    688712            d.addCallback(lambda children:
    689                           self.failUnlessEqual(set(children.keys()),
    690                                                set([u"child", u"subdir"])))
     713                          self.failUnlessReallyEqual(set(children.keys()),
     714                                                     set([u"child", u"subdir"])))
    691715
    692716            d.addCallback(lambda res: n.start_deep_stats().when_done())
    … …  
    706730                            }
    707731                for k,v in expected.iteritems():
    708                     self.failUnlessEqual(stats[k], v,
    709                                          "stats[%s] was %s, not %s" %
    710                                          (k, stats[k], v))
     732                    self.failUnlessReallyEqual(stats[k], v,
     733                                               "stats[%s] was %s, not %s" %
     734                                               (k, stats[k], v))
    711735                self.failUnless(stats["size-directories"] > 500,
    712736                                stats["size-directories"])
    713737                self.failUnless(stats["largest-directory"] > 500,
    714738                                stats["largest-directory"])
    715                 self.failUnlessEqual(stats["size-files-histogram"], [])
     739                self.failUnlessReallyEqual(stats["size-files-histogram"], [])
    716740            d.addCallback(_check_deepstats)
    717741
    … …  
    719743            def _check_manifest(res):
    720744                manifest = res["manifest"]
    721                 self.failUnlessEqual(sorted(manifest),
    722                                      sorted(self.expected_manifest))
     745                self.failUnlessReallyEqual(sorted(manifest),
     746                                           sorted(self.expected_manifest))
    723747                stats = res["stats"]
    724748                _check_deepstats(stats)
    725                 self.failUnlessEqual(self.expected_verifycaps,
    726                                      res["verifycaps"])
    727                 self.failUnlessEqual(self.expected_storage_indexes,
    728                                      res["storage-index"])
     749                self.failUnlessReallyEqual(self.expected_verifycaps,
     750                                           res["verifycaps"])
     751                self.failUnlessReallyEqual(self.expected_storage_indexes,
     752                                           res["storage-index"])
    729753            d.addCallback(_check_manifest)
    730754
    … …  
    741765                                                     dirnode.DirectoryNode)))
    742766            d.addCallback(lambda res: n.get_child_at_path(u""))
    743             d.addCallback(lambda res: self.failUnlessEqual(res.get_uri(),
    744                                                            n.get_uri()))
     767            d.addCallback(lambda res: self.failUnlessReallyEqual(res.get_uri(),
     768                                                                 n.get_uri()))
    745769
    746770            d.addCallback(lambda res: n.get_metadata_for(u"child"))
    747771            d.addCallback(lambda metadata:
    748                           self.failUnlessEqual(set(metadata.keys()),
    749                                                set(["tahoe"])))
     772                          self.failUnlessReallyEqual(set(metadata.keys()),
     773                                                     set(["tahoe"])))
    750774
    751775            d.addCallback(lambda res:
    … …  
    760784                self.failUnless(isinstance(child, dirnode.DirectoryNode))
    761785                # edge-metadata needs at least one path segment
    762                 self.failUnlessEqual(set(metadata.keys()), set([]))
     786                self.failUnlessReallyEqual(set(metadata.keys()), set([]))
    763787            d.addCallback(_check_child_and_metadata1)
    764788            d.addCallback(lambda res:
    … …  
    767791            def _check_child_and_metadata2(res):
    768792                child, metadata = res
    769                 self.failUnlessEqual(child.get_uri(),
    770                                      fake_file_uri)
    771                 self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
     793                self.failUnlessReallyEqual(child.get_uri(),
     794                                           fake_file_uri)
     795                self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
    772796            d.addCallback(_check_child_and_metadata2)
    773797
    … …  
    777801                child, metadata = res
    778802                self.failUnless(isinstance(child, dirnode.DirectoryNode))
    779                 self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
     803                self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
    780804            d.addCallback(_check_child_and_metadata3)
    781805
    … …  
    787811            d.addCallback(lambda res: n.get_metadata_for(u"c2"))
    788812            d.addCallback(lambda metadata:
    789                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     813                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    790814
    791815            # You can't override the link timestamps.
    … …  
    805829            d.addCallback(lambda res: n.get_metadata_for(u"c3"))
    806830            d.addCallback(lambda metadata:
    807                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     831                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    808832
    809833            # we can also add specific metadata at set_uri() time
    … …  
    831855            d.addCallback(lambda res: n.get_metadata_for(u"d2"))
    832856            d.addCallback(lambda metadata:
    833                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     857                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    834858
    835859            # if we don't set any defaults, the child should get timestamps
    … …  
    837861            d.addCallback(lambda res: n.get_metadata_for(u"d3"))
    838862            d.addCallback(lambda metadata:
    839                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     863                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    840864
    841865            # we can also add specific metadata at set_node() time
    … …  
    875899            d.addCallback(lambda res: n.get_metadata_for(u"e1"))
    876900            d.addCallback(lambda metadata:
    877                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     901                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    878902            d.addCallback(lambda res: n.get_metadata_for(u"e2"))
    879903            d.addCallback(lambda metadata:
    880                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     904                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    881905            d.addCallback(lambda res: n.get_metadata_for(u"e3"))
    882906            d.addCallback(lambda metadata:
    … …  
    906930            d.addCallback(lambda res: n.get_metadata_for(u"f1"))
    907931            d.addCallback(lambda metadata:
    908                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     932                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    909933            d.addCallback(lambda res: n.get_metadata_for(u"f2"))
    910934            d.addCallback(lambda metadata:
    911                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     935                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    912936            d.addCallback(lambda res: n.get_metadata_for(u"f3"))
    913937            d.addCallback(lambda metadata:
    … …  
    952976            d.addCallback(lambda res: n.get_metadata_for(u"timestamps"))
    953977            def _check_timestamp1(metadata):
    954                 self.failUnlessEqual(set(metadata.keys()), set(["tahoe"]))
     978                self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"]))
    955979                tahoe_md = metadata["tahoe"]
    956                 self.failUnlessEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
     980                self.failUnlessReallyEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
    957981
    958982                self.failUnlessGreaterOrEqualThan(tahoe_md["linkcrtime"],
    … …  
    9761000                self.failUnlessIn("tahoe", metadata)
    9771001                tahoe_md = metadata["tahoe"]
    978                 self.failUnlessEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
    979 
    980                 self.failUnlessEqual(tahoe_md["linkcrtime"], self._old_linkcrtime)
     1002                self.failUnlessReallyEqual(set(tahoe_md.keys()), set(["linkcrtime", "linkmotime"]))
     1003
     1004                self.failUnlessReallyEqual(tahoe_md["linkcrtime"], self._old_linkcrtime)
    9811005                self.failUnlessGreaterThan(tahoe_md["linkmotime"], self._old_linkmotime)
    9821006                return n.delete(u"timestamps")
    … …  
    9851009            d.addCallback(lambda res: n.delete(u"subdir"))
    9861010            d.addCallback(lambda old_child:
    987                           self.failUnlessEqual(old_child.get_uri(),
     1011                          self.failUnlessReallyEqual(old_child.get_uri(),
    9881012                                               self.subdir.get_uri()))
    9891013
    9901014            d.addCallback(lambda res: n.list())
    9911015            d.addCallback(lambda children:
    992                           self.failUnlessEqual(set(children.keys()),
    993                                                set([u"child"])))
     1016                          self.failUnlessReallyEqual(set(children.keys()),
     1017                                                     set([u"child"])))
    9941018
    9951019            uploadable1 = upload.Data("some data", convergence="converge")
    … …  
    10061030            d.addCallback(lambda res: n.list())
    10071031            d.addCallback(lambda children:
    1008                           self.failUnlessEqual(set(children.keys()),
    1009                                                set([u"child", u"newfile"])))
     1032                          self.failUnlessReallyEqual(set(children.keys()),
     1033                                                     set([u"child", u"newfile"])))
    10101034            d.addCallback(lambda res: n.get_metadata_for(u"newfile"))
    10111035            d.addCallback(lambda metadata:
    1012                           self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
     1036                          self.failUnlessReallyEqual(set(metadata.keys()), set(["tahoe"])))
    10131037
    10141038            uploadable3 = upload.Data("some data", convergence="converge")
    … …  
    10361060            d.addCallback(lambda res: n.list())
    10371061            d.addCallback(lambda children:
    1038                           self.failUnlessEqual(set(children.keys()),
    1039                                                set([u"newfile", u"subdir2"])))
     1062                          self.failUnlessReallyEqual(set(children.keys()),
     1063                                                     set([u"newfile", u"subdir2"])))
    10401064            d.addCallback(lambda res: self.subdir2.list())
    10411065            d.addCallback(lambda children:
    1042                           self.failUnlessEqual(set(children.keys()),
    1043                                                set([u"child"])))
     1066                          self.failUnlessReallyEqual(set(children.keys()),
     1067                                                     set([u"child"])))
    10441068            d.addCallback(lambda res: self.subdir2.get(u"child"))
    10451069            d.addCallback(lambda child:
    1046                           self.failUnlessEqual(child.get_uri(),
    1047                                                fake_file_uri))
     1070                          self.failUnlessReallyEqual(child.get_uri(),
     1071                                                     fake_file_uri))
    10481072
    10491073            # move it back, using new_child_name=
    … …  
    10521076            d.addCallback(lambda res: n.list())
    10531077            d.addCallback(lambda children:
    1054                           self.failUnlessEqual(set(children.keys()),
    1055                                                set([u"newchild", u"newfile",
    1056                                                     u"subdir2"])))
     1078                          self.failUnlessReallyEqual(set(children.keys()),
     1079                                                     set([u"newchild", u"newfile",
     1080                                                          u"subdir2"])))
    10571081            d.addCallback(lambda res: self.subdir2.list())
    10581082            d.addCallback(lambda children:
    1059                           self.failUnlessEqual(set(children.keys()), set([])))
     1083                          self.failUnlessReallyEqual(set(children.keys()), set([])))
    10601084
    10611085            # now make sure that we honor overwrite=False
    … …  
    10721096            d.addCallback(lambda res: self.subdir2.get(u"newchild"))
    10731097            d.addCallback(lambda child:
    1074                           self.failUnlessEqual(child.get_uri(),
    1075                                                other_file_uri))
     1098                          self.failUnlessReallyEqual(child.get_uri(),
     1099                                                     other_file_uri))
    10761100
    10771101
    … …  
    11151139
    11161140        md1 = dirnode.update_metadata({"ctime": t1}, {}, t2)
    1117         self.failUnlessEqual(md1, {"tahoe":{"linkcrtime": t1, "linkmotime": t2}})
     1141        self.failUnlessReallyEqual(md1, {"tahoe":{"linkcrtime": t1, "linkmotime": t2}})
    11181142
    11191143        md2 = dirnode.update_metadata(md1, {"key": "value", "tahoe": {"bad": "mojo"}}, t3)
    1120         self.failUnlessEqual(md2, {"key": "value",
    1121                                    "tahoe":{"linkcrtime": t1, "linkmotime": t3}})
     1144        self.failUnlessReallyEqual(md2, {"key": "value",
     1145                                         "tahoe":{"linkcrtime": t1, "linkmotime": t3}})
    11221146
    11231147        md3 = dirnode.update_metadata({}, None, t3)
    1124         self.failUnlessEqual(md3, {"tahoe":{"linkcrtime": t3, "linkmotime": t3}})
     1148        self.failUnlessReallyEqual(md3, {"tahoe":{"linkcrtime": t3, "linkmotime": t3}})
    11251149
    11261150        md4 = dirnode.update_metadata({}, {"bool": True, "number": 42}, t1)
    1127         self.failUnlessEqual(md4, {"bool": True, "number": 42,
    1128                                    "tahoe":{"linkcrtime": t1, "linkmotime": t1}})
     1151        self.failUnlessReallyEqual(md4, {"bool": True, "number": 42,
     1152                                         "tahoe":{"linkcrtime": t1, "linkmotime": t1}})
    11291153
    11301154    def test_create_subdirectory(self):
    … …  
    11471171            def _check(sub):
    11481172                d = n.get_child_at_path(u"subdir")
    1149                 d.addCallback(lambda sub2: self.failUnlessEqual(sub2.get_uri(),
    1150                                                                 sub.get_uri()))
     1173                d.addCallback(lambda sub2: self.failUnlessReallyEqual(sub2.get_uri(),
     1174                                                                      sub.get_uri()))
    11511175                d.addCallback(lambda ign: sub.list())
    11521176                return d
    11531177            d.addCallback(_check)
    11541178            def _check_kids(kids2):
    1155                 self.failUnlessEqual(set(kids.keys()), set(kids2.keys()))
    1156                 self.failUnlessEqual(kids2[u"kid2"][1]["metakey"], "metavalue")
     1179                self.failUnlessReallyEqual(set(kids.keys()), set(kids2.keys()))
     1180                self.failUnlessReallyEqual(kids2[u"kid2"][1]["metakey"], "metavalue")
    11571181            d.addCallback(_check_kids)
    11581182            return d
    … …  
    11641188        return "writekey"
    11651189
    1166 class Packing(unittest.TestCase):
     1190class Packing(testutil.ReallyEqualMixin, unittest.TestCase):
    11671191    # This is a base32-encoded representation of the directory tree
    11681192    # root/file1
    … …  
    12011225        file3_rwcap = "URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
    12021226        file3_metadata = {'ctime': 1246663897.4336269, 'tahoe': {'linkmotime': 1246663897.4336269, 'linkcrtime': 1246663897.4336269}, 'mtime': 1246663897.4336269}
    1203         self.failUnlessEqual(file3_metadata, children[u'file3'][1])
    1204         self.failUnlessEqual(file3_rocap,
    1205                              children[u'file3'][0].get_readonly_uri())
    1206         self.failUnlessEqual(file3_rwcap,
    1207                              children[u'file3'][0].get_uri())
     1227        self.failUnlessReallyEqual(file3_metadata, children[u'file3'][1])
     1228        self.failUnlessReallyEqual(file3_rocap,
     1229                                   children[u'file3'][0].get_readonly_uri())
     1230        self.failUnlessReallyEqual(file3_rwcap,
     1231                                   children[u'file3'][0].get_uri())
    12081232
    12091233        # Are the metadata for child 2 right?
    … …  
    12111235        file2_rwcap = "URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
    12121236        file2_metadata = {'ctime': 1246663897.430218, 'tahoe': {'linkmotime': 1246663897.430218, 'linkcrtime': 1246663897.430218}, 'mtime': 1246663897.430218}
    1213         self.failUnlessEqual(file2_metadata, children[u'file2'][1])
    1214         self.failUnlessEqual(file2_rocap,
     1237        self.failUnlessReallyEqual(file2_metadata, children[u'file2'][1])
     1238        self.failUnlessReallyEqual(file2_rocap,
    12151239                             children[u'file2'][0].get_readonly_uri())
    1216         self.failUnlessEqual(file2_rwcap,
     1240        self.failUnlessReallyEqual(file2_rwcap,
    12171241                             children[u'file2'][0].get_uri())
    12181242
    … …  
    12211245        file1_rwcap = "URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
    12221246        file1_metadata = {'ctime': 1246663897.4275661, 'tahoe': {'linkmotime': 1246663897.4275661, 'linkcrtime': 1246663897.4275661}, 'mtime': 1246663897.4275661}
    1223         self.failUnlessEqual(file1_metadata, children[u'file1'][1])
    1224         self.failUnlessEqual(file1_rocap,
     1247        self.failUnlessReallyEqual(file1_metadata, children[u'file1'][1])
     1248        self.failUnlessReallyEqual(file1_rocap,
    12251249                             children[u'file1'][0].get_readonly_uri())
    1226         self.failUnlessEqual(file1_rwcap,
     1250        self.failUnlessReallyEqual(file1_rwcap,
    12271251                             children[u'file1'][0].get_uri())
    12281252
    … …  
    13411365        return self.nodemaker.create_from_cap(rwcap, rocap)
    13421366
    1343 class Dirnode2(unittest.TestCase, testutil.ShouldFailMixin):
     1367class Dirnode2(testutil.ReallyEqualMixin, testutil.ShouldFailMixin, unittest.TestCase):
    13441368    def setUp(self):
    13451369        client = FakeClient2()
    … …  
    13501374        # we tolerate them properly.
    13511375        d = self.nodemaker.create_new_mutable_directory()
    1352         future_write_uri = "x-tahoe-crazy://I_am_from_the_future."
    1353         future_read_uri = "x-tahoe-crazy-readonly://I_am_from_the_future."
    1354         future_imm_uri = "x-tahoe-crazy-immutable://I_am_from_the_future."
     1376        future_write_uri = u"x-tahoe-crazy://I_am_from_the_future_rw_\u263A".encode('utf-8')
     1377        future_read_uri = u"x-tahoe-crazy-readonly://I_am_from_the_future_ro_\u263A".encode('utf-8')
     1378        future_imm_uri = u"x-tahoe-crazy-immutable://I_am_from_the_future_imm_\u263A".encode('utf-8')
    13551379        future_node = UnknownNode(future_write_uri, future_read_uri)
    13561380        def _then(n):
    … …  
    13831407        d.addCallback(lambda ign: self._node.list())
    13841408        def _check(children):
    1385             self.failUnlessEqual(len(children), 4)
     1409            self.failUnlessReallyEqual(len(children), 4)
    13861410            (fn, metadata) = children[u"future"]
    13871411            self.failUnless(isinstance(fn, UnknownNode), fn)
    1388             self.failUnlessEqual(fn.get_uri(), future_write_uri)
    1389             self.failUnlessEqual(fn.get_write_uri(), future_write_uri)
    1390             self.failUnlessEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
     1412            self.failUnlessReallyEqual(fn.get_uri(), future_write_uri)
     1413            self.failUnlessReallyEqual(fn.get_write_uri(), future_write_uri)
     1414            self.failUnlessReallyEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
    13911415
    13921416            (fn2, metadata2) = children[u"add-pair"]
    13931417            self.failUnless(isinstance(fn2, UnknownNode), fn2)
    1394             self.failUnlessEqual(fn2.get_uri(), future_write_uri)
    1395             self.failUnlessEqual(fn2.get_write_uri(), future_write_uri)
    1396             self.failUnlessEqual(fn2.get_readonly_uri(), "ro." + future_read_uri)
     1418            self.failUnlessReallyEqual(fn2.get_uri(), future_write_uri)
     1419            self.failUnlessReallyEqual(fn2.get_write_uri(), future_write_uri)
     1420            self.failUnlessReallyEqual(fn2.get_readonly_uri(), "ro." + future_read_uri)
    13971421
    13981422            (fn3, metadata3) = children[u"add-ro"]
    13991423            self.failUnless(isinstance(fn3, UnknownNode), fn3)
    1400             self.failUnlessEqual(fn3.get_uri(), "ro." + future_read_uri)
    1401             self.failUnlessEqual(fn3.get_write_uri(), None)
    1402             self.failUnlessEqual(fn3.get_readonly_uri(), "ro." + future_read_uri)
     1424            self.failUnlessReallyEqual(fn3.get_uri(), "ro." + future_read_uri)
     1425            self.failUnlessReallyEqual(fn3.get_write_uri(), None)
     1426            self.failUnlessReallyEqual(fn3.get_readonly_uri(), "ro." + future_read_uri)
    14031427
    14041428            (fn4, metadata4) = children[u"add-imm"]
    14051429            self.failUnless(isinstance(fn4, UnknownNode), fn4)
    1406             self.failUnlessEqual(fn4.get_uri(), "imm." + future_imm_uri)
    1407             self.failUnlessEqual(fn4.get_write_uri(), None)
    1408             self.failUnlessEqual(fn4.get_readonly_uri(), "imm." + future_imm_uri)
     1430            self.failUnlessReallyEqual(fn4.get_uri(), "imm." + future_imm_uri)
     1431            self.failUnlessReallyEqual(fn4.get_write_uri(), None)
     1432            self.failUnlessReallyEqual(fn4.get_readonly_uri(), "imm." + future_imm_uri)
    14091433
    14101434            # We should also be allowed to copy the "future" UnknownNode, because
    … …  
    14161440        d.addCallback(lambda ign: self._node.list())
    14171441        def _check2(children):
    1418             self.failUnlessEqual(len(children), 5)
     1442            self.failUnlessReallyEqual(len(children), 5)
    14191443            (fn, metadata) = children[u"copy"]
    14201444            self.failUnless(isinstance(fn, UnknownNode), fn)
    1421             self.failUnlessEqual(fn.get_uri(), future_write_uri)
    1422             self.failUnlessEqual(fn.get_write_uri(), future_write_uri)
    1423             self.failUnlessEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
     1445            self.failUnlessReallyEqual(fn.get_uri(), future_write_uri)
     1446            self.failUnlessReallyEqual(fn.get_write_uri(), future_write_uri)
     1447            self.failUnlessReallyEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
    14241448        d.addCallback(_check2)
    14251449        return d
    14261450
    14271451    def test_unknown_strip_prefix_for_ro(self):
    1428         self.failUnlessEqual(strip_prefix_for_ro("foo",     False), "foo")
    1429         self.failUnlessEqual(strip_prefix_for_ro("ro.foo",  False), "foo")
    1430         self.failUnlessEqual(strip_prefix_for_ro("imm.foo", False), "imm.foo")
    1431         self.failUnlessEqual(strip_prefix_for_ro("foo",     True),  "foo")
    1432         self.failUnlessEqual(strip_prefix_for_ro("ro.foo",  True),  "foo")
    1433         self.failUnlessEqual(strip_prefix_for_ro("imm.foo", True),  "foo")
     1452        self.failUnlessReallyEqual(strip_prefix_for_ro("foo",     False), "foo")
     1453        self.failUnlessReallyEqual(strip_prefix_for_ro("ro.foo",  False), "foo")
     1454        self.failUnlessReallyEqual(strip_prefix_for_ro("imm.foo", False), "imm.foo")
     1455        self.failUnlessReallyEqual(strip_prefix_for_ro("foo",     True),  "foo")
     1456        self.failUnlessReallyEqual(strip_prefix_for_ro("ro.foo",  True),  "foo")
     1457        self.failUnlessReallyEqual(strip_prefix_for_ro("imm.foo", True),  "foo")
    14341458
    14351459    def test_unknownnode(self):
    … …  
    15291553
    15301554
    1531 class DeepStats(unittest.TestCase):
     1555class DeepStats(testutil.ReallyEqualMixin, unittest.TestCase):
    15321556    timeout = 240 # It takes longer than 120 seconds on Francois's arm box.
    15331557    def test_stats(self):
    … …  
    15391563
    15401564        s = ds.get_results()
    1541         self.failUnlessEqual(s["count-files"], 1)
    1542         self.failUnlessEqual(s["size-immutable-files"], 123)
    1543         self.failUnlessEqual(s["largest-directory"], 444)
    1544         self.failUnlessEqual(s["count-literal-files"], 0)
     1565        self.failUnlessReallyEqual(s["count-files"], 1)
     1566        self.failUnlessReallyEqual(s["size-immutable-files"], 123)
     1567        self.failUnlessReallyEqual(s["largest-directory"], 444)
     1568        self.failUnlessReallyEqual(s["count-literal-files"], 0)
    15451569
    15461570        ds.add("count-files")
    … …  
    15501574
    15511575        s = ds.get_results()
    1552         self.failUnlessEqual(s["count-files"], 2)
    1553         self.failUnlessEqual(s["size-immutable-files"], 444)
    1554         self.failUnlessEqual(s["largest-directory"], 444)
    1555         self.failUnlessEqual(s["count-literal-files"], 0)
    1556         self.failUnlessEqual(s["size-files-histogram"],
     1576        self.failUnlessReallyEqual(s["count-files"], 2)
     1577        self.failUnlessReallyEqual(s["size-immutable-files"], 444)
     1578        self.failUnlessReallyEqual(s["largest-directory"], 444)
     1579        self.failUnlessReallyEqual(s["count-literal-files"], 0)
     1580        self.failUnlessReallyEqual(s["size-files-histogram"],
    15571581                             [ (101, 316, 1), (317, 1000, 1) ])
    15581582
    … …  
    15621586        ds.histogram("size-files-histogram", 4*1000*1000*1000*1000) # 4TB
    15631587        s = ds.get_results()
    1564         self.failUnlessEqual(s["size-files-histogram"],
     1588        self.failUnlessReallyEqual(s["size-files-histogram"],
    15651589                             [ (1, 3, 3),
    15661590                               (4, 10, 7),
    … …  
    15941618
    15951619
    1596 class Deleter(GridTestMixin, unittest.TestCase):
     1620class Deleter(GridTestMixin, testutil.ReallyEqualMixin, unittest.TestCase):
    15971621    timeout = 3600 # It takes longer than 433 seconds on Zandr's ARM box.
    15981622    def test_retry(self):

  • TabularUnified src/allmydata/test/test_uri.py

    rca660a5 rd346e085  
    55from allmydata.interfaces import IURI, IFileURI, IDirnodeURI, IMutableFileURI, \
    66    IVerifierURI, CapConstraintError
    7 
    8 class Literal(unittest.TestCase):
     7import allmydata.test.common_util as testutil
     8
     9class Literal(testutil.ReallyEqualMixin, unittest.TestCase):
    910    def _help_test(self, data):
    1011        u = uri.LiteralFileURI(data)
    … …  
    1213        self.failUnless(IFileURI.providedBy(u))
    1314        self.failIf(IDirnodeURI.providedBy(u))
    14         self.failUnlessEqual(u.data, data)
    15         self.failUnlessEqual(u.get_size(), len(data))
     15        self.failUnlessReallyEqual(u.data, data)
     16        self.failUnlessReallyEqual(u.get_size(), len(data))
    1617        self.failUnless(u.is_readonly())
    1718        self.failIf(u.is_mutable())
    … …  
    2122        self.failUnless(IFileURI.providedBy(u2))
    2223        self.failIf(IDirnodeURI.providedBy(u2))
    23         self.failUnlessEqual(u2.data, data)
    24         self.failUnlessEqual(u2.get_size(), len(data))
     24        self.failUnlessReallyEqual(u2.data, data)
     25        self.failUnlessReallyEqual(u2.get_size(), len(data))
    2526        self.failUnless(u2.is_readonly())
    2627        self.failIf(u2.is_mutable())
    … …  
    2930        self.failUnless(IFileURI.providedBy(u2i))
    3031        self.failIf(IDirnodeURI.providedBy(u2i))
    31         self.failUnlessEqual(u2i.data, data)
    32         self.failUnlessEqual(u2i.get_size(), len(data))
     32        self.failUnlessReallyEqual(u2i.data, data)
     33        self.failUnlessReallyEqual(u2i.get_size(), len(data))
    3334        self.failUnless(u2i.is_readonly())
    3435        self.failIf(u2i.is_mutable())
    … …  
    3637        u3 = u.get_readonly()
    3738        self.failUnlessIdentical(u, u3)
    38         self.failUnlessEqual(u.get_verify_cap(), None)
     39        self.failUnlessReallyEqual(u.get_verify_cap(), None)
    3940
    4041        he = u.to_human_encoding()
    4142        u_h = uri.LiteralFileURI.init_from_human_encoding(he)
    42         self.failUnlessEqual(u, u_h)
     43        self.failUnlessReallyEqual(u, u_h)
    4344
    4445    def test_empty(self):
    … …  
    5455        return self._help_test(data)
    5556
    56 class Compare(unittest.TestCase):
     57class Compare(testutil.ReallyEqualMixin, unittest.TestCase):
    5758    def test_compare(self):
    5859        lit1 = uri.LiteralFileURI("some data")
    … …  
    6263        unk = uri.UnknownURI("lafs://from_the_future")
    6364        self.failIfEqual(lit1, chk1)
    64         self.failUnlessEqual(chk1, chk2)
     65        self.failUnlessReallyEqual(chk1, chk2)
    6566        self.failIfEqual(chk1, "not actually a URI")
    6667        # these should be hashable too
    6768        s = set([lit1, chk1, chk2, unk])
    68         self.failUnlessEqual(len(s), 3) # since chk1==chk2
     69        self.failUnlessReallyEqual(len(s), 3) # since chk1==chk2
    6970
    7071    def test_is_uri(self):
    … …  
    9091        self.failIf(uri.has_uri_prefix("foo"))
    9192
    92 class CHKFile(unittest.TestCase):
     93class CHKFile(testutil.ReallyEqualMixin, unittest.TestCase):
    9394    def test_pack(self):
    9495        key = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
    … …  
    103104                           total_shares=total_shares,
    104105                           size=size)
    105         self.failUnlessEqual(u.get_storage_index(), storage_index)
    106         self.failUnlessEqual(u.key, key)
    107         self.failUnlessEqual(u.uri_extension_hash, uri_extension_hash)
    108         self.failUnlessEqual(u.needed_shares, needed_shares)
    109         self.failUnlessEqual(u.total_shares, total_shares)
    110         self.failUnlessEqual(u.size, size)
     106        self.failUnlessReallyEqual(u.get_storage_index(), storage_index)
     107        self.failUnlessReallyEqual(u.key, key)
     108        self.failUnlessReallyEqual(u.uri_extension_hash, uri_extension_hash)
     109        self.failUnlessReallyEqual(u.needed_shares, needed_shares)
     110        self.failUnlessReallyEqual(u.total_shares, total_shares)
     111        self.failUnlessReallyEqual(u.size, size)
    111112        self.failUnless(u.is_readonly())
    112113        self.failIf(u.is_mutable())
    … …  
    114115        self.failUnless(IFileURI.providedBy(u))
    115116        self.failIf(IDirnodeURI.providedBy(u))
    116         self.failUnlessEqual(u.get_size(), 1234)
     117        self.failUnlessReallyEqual(u.get_size(), 1234)
    117118
    118119        u_ro = u.get_readonly()
    119120        self.failUnlessIdentical(u, u_ro)
    120121        he = u.to_human_encoding()
    121         self.failUnlessEqual(he, "http://127.0.0.1:3456/uri/" + u.to_string())
    122         self.failUnlessEqual(uri.CHKFileURI.init_from_human_encoding(he), u)
     122        self.failUnlessReallyEqual(he, "http://127.0.0.1:3456/uri/" + u.to_string())
     123        self.failUnlessReallyEqual(uri.CHKFileURI.init_from_human_encoding(he), u)
    123124
    124125        u2 = uri.from_string(u.to_string())
    125         self.failUnlessEqual(u2.get_storage_index(), storage_index)
    126         self.failUnlessEqual(u2.key, key)
    127         self.failUnlessEqual(u2.uri_extension_hash, uri_extension_hash)
    128         self.failUnlessEqual(u2.needed_shares, needed_shares)
    129         self.failUnlessEqual(u2.total_shares, total_shares)
    130         self.failUnlessEqual(u2.size, size)
     126        self.failUnlessReallyEqual(u2.get_storage_index(), storage_index)
     127        self.failUnlessReallyEqual(u2.key, key)
     128        self.failUnlessReallyEqual(u2.uri_extension_hash, uri_extension_hash)
     129        self.failUnlessReallyEqual(u2.needed_shares, needed_shares)
     130        self.failUnlessReallyEqual(u2.total_shares, total_shares)
     131        self.failUnlessReallyEqual(u2.size, size)
    131132        self.failUnless(u2.is_readonly())
    132133        self.failIf(u2.is_mutable())
    … …  
    134135        self.failUnless(IFileURI.providedBy(u2))
    135136        self.failIf(IDirnodeURI.providedBy(u2))
    136         self.failUnlessEqual(u2.get_size(), 1234)
     137        self.failUnlessReallyEqual(u2.get_size(), 1234)
    137138
    138139        u2i = uri.from_string(u.to_string(), deep_immutable=True)
    139         self.failUnlessEqual(u.to_string(), u2i.to_string())
     140        self.failUnlessReallyEqual(u.to_string(), u2i.to_string())
    140141        u2ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u.to_string())
    141         self.failUnlessEqual(u.to_string(), u2ro.to_string())
     142        self.failUnlessReallyEqual(u.to_string(), u2ro.to_string())
    142143        u2imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u.to_string())
    143         self.failUnlessEqual(u.to_string(), u2imm.to_string())
     144        self.failUnlessReallyEqual(u.to_string(), u2imm.to_string())
    144145
    145146        v = u.get_verify_cap()
    … …  
    149150
    150151        v2 = uri.from_string(v.to_string())
    151         self.failUnlessEqual(v, v2)
     152        self.failUnlessReallyEqual(v, v2)
    152153        he = v.to_human_encoding()
    153154        v2_h = uri.CHKFileVerifierURI.init_from_human_encoding(he)
    154         self.failUnlessEqual(v2, v2_h)
     155        self.failUnlessReallyEqual(v2, v2_h)
    155156
    156157        v3 = uri.CHKFileVerifierURI(storage_index="\x00"*16,
    … …  
    193194
    194195
    195 class Extension(unittest.TestCase):
     196class Extension(testutil.ReallyEqualMixin, unittest.TestCase):
    196197    def test_pack(self):
    197198        data = {"stuff": "value",
    … …  
    202203        ext = uri.pack_extension(data)
    203204        d = uri.unpack_extension(ext)
    204         self.failUnlessEqual(d["stuff"], "value")
    205         self.failUnlessEqual(d["size"], 12)
    206         self.failUnlessEqual(d["big_hash"], hashutil.tagged_hash("foo", "bar"))
     205        self.failUnlessReallyEqual(d["stuff"], "value")
     206        self.failUnlessReallyEqual(d["size"], 12)
     207        self.failUnlessReallyEqual(d["big_hash"], hashutil.tagged_hash("foo", "bar"))
    207208
    208209        readable = uri.unpack_extension_readable(ext)
    209         self.failUnlessEqual(readable["needed_shares"], 3)
    210         self.failUnlessEqual(readable["stuff"], "value")
    211         self.failUnlessEqual(readable["size"], 12)
    212         self.failUnlessEqual(readable["big_hash"],
     210        self.failUnlessReallyEqual(readable["needed_shares"], 3)
     211        self.failUnlessReallyEqual(readable["stuff"], "value")
     212        self.failUnlessReallyEqual(readable["size"], 12)
     213        self.failUnlessReallyEqual(readable["big_hash"],
    213214                             base32.b2a(hashutil.tagged_hash("foo", "bar")))
    214         self.failUnlessEqual(readable["UEB_hash"],
     215        self.failUnlessReallyEqual(readable["UEB_hash"],
    215216                             base32.b2a(hashutil.uri_extension_hash(ext)))
    216217
    217 class Unknown(unittest.TestCase):
     218class Unknown(testutil.ReallyEqualMixin, unittest.TestCase):
    218219    def test_from_future(self):
    219220        # any URI type that we don't recognize should be treated as unknown
    … …  
    221222        u = uri.from_string(future_uri)
    222223        self.failUnless(isinstance(u, uri.UnknownURI))
    223         self.failUnlessEqual(u.to_string(), future_uri)
     224        self.failUnlessReallyEqual(u.to_string(), future_uri)
    224225        self.failUnless(u.get_readonly() is None)
    225226        self.failUnless(u.get_error() is None)
    226227
    227228        u2 = uri.UnknownURI(future_uri, error=CapConstraintError("..."))
    228         self.failUnlessEqual(u.to_string(), future_uri)
     229        self.failUnlessReallyEqual(u.to_string(), future_uri)
    229230        self.failUnless(u2.get_readonly() is None)
    230231        self.failUnless(isinstance(u2.get_error(), CapConstraintError))
    231232
    232 class Constraint(unittest.TestCase):
     233        # Future caps might have non-ASCII chars in them. (Or maybe not, who can tell about the future?)
     234        future_uri = u"I am a cap from the \u263A future. Whatever you ".encode('utf-8')
     235        u = uri.from_string(future_uri)
     236        self.failUnless(isinstance(u, uri.UnknownURI))
     237        self.failUnlessReallyEqual(u.to_string(), future_uri)
     238        self.failUnless(u.get_readonly() is None)
     239        self.failUnless(u.get_error() is None)
     240
     241        u2 = uri.UnknownURI(future_uri, error=CapConstraintError("..."))
     242        self.failUnlessReallyEqual(u.to_string(), future_uri)
     243        self.failUnless(u2.get_readonly() is None)
     244        self.failUnless(isinstance(u2.get_error(), CapConstraintError))
     245
     246class Constraint(testutil.ReallyEqualMixin, unittest.TestCase):
    233247    def test_constraint(self):
    234248        good="http://127.0.0.1:3456/uri/URI%3ADIR2%3Agh3l5rbvnv2333mrfvalmjfr4i%3Alz6l7u3z3b7g37s4zkdmfpx5ly4ib4m6thrpbusi6ys62qtc6mma/"
    … …  
    241255        uri.CHKFileURI.init_from_string(fileURI)
    242256
    243 class Mutable(unittest.TestCase):
     257class Mutable(testutil.ReallyEqualMixin, unittest.TestCase):
    244258    def test_pack(self):
    245259        writekey = "\x01" * 16
    … …  
    247261
    248262        u = uri.WriteableSSKFileURI(writekey, fingerprint)
    249         self.failUnlessEqual(u.writekey, writekey)
    250         self.failUnlessEqual(u.fingerprint, fingerprint)
     263        self.failUnlessReallyEqual(u.writekey, writekey)
     264        self.failUnlessReallyEqual(u.fingerprint, fingerprint)
    251265        self.failIf(u.is_readonly())
    252266        self.failUnless(u.is_mutable())
    … …  
    258272        he = u.to_human_encoding()
    259273        u_h = uri.WriteableSSKFileURI.init_from_human_encoding(he)
    260         self.failUnlessEqual(u, u_h)
     274        self.failUnlessReallyEqual(u, u_h)
    261275
    262276        u2 = uri.from_string(u.to_string())
    263         self.failUnlessEqual(u2.writekey, writekey)
    264         self.failUnlessEqual(u2.fingerprint, fingerprint)
     277        self.failUnlessReallyEqual(u2.writekey, writekey)
     278        self.failUnlessReallyEqual(u2.fingerprint, fingerprint)
    265279        self.failIf(u2.is_readonly())
    266280        self.failUnless(u2.is_mutable())
    … …  
    278292        u3 = u2.get_readonly()
    279293        readkey = hashutil.ssk_readkey_hash(writekey)
    280         self.failUnlessEqual(u3.fingerprint, fingerprint)
    281         self.failUnlessEqual(u3.readkey, readkey)
     294        self.failUnlessReallyEqual(u3.fingerprint, fingerprint)
     295        self.failUnlessReallyEqual(u3.readkey, readkey)
    282296        self.failUnless(u3.is_readonly())
    283297        self.failUnless(u3.is_mutable())
    … …  
    289303        self.failUnless(isinstance(u3i, uri.UnknownURI), u3i)
    290304        u3ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u3.to_string())
    291         self.failUnlessEqual(u3.to_string(), u3ro.to_string())
     305        self.failUnlessReallyEqual(u3.to_string(), u3ro.to_string())
    292306        u3imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u3.to_string())
    293307        self.failUnless(isinstance(u3imm, uri.UnknownURI), u3imm)
    … …  
    295309        he = u3.to_human_encoding()
    296310        u3_h = uri.ReadonlySSKFileURI.init_from_human_encoding(he)
    297         self.failUnlessEqual(u3, u3_h)
     311        self.failUnlessReallyEqual(u3, u3_h)
    298312
    299313        u4 = uri.ReadonlySSKFileURI(readkey, fingerprint)
    300         self.failUnlessEqual(u4.fingerprint, fingerprint)
    301         self.failUnlessEqual(u4.readkey, readkey)
     314        self.failUnlessReallyEqual(u4.fingerprint, fingerprint)
     315        self.failUnlessReallyEqual(u4.readkey, readkey)
    302316        self.failUnless(u4.is_readonly())
    303317        self.failUnless(u4.is_mutable())
    … …  
    309323        self.failUnless(isinstance(u4i, uri.UnknownURI), u4i)
    310324        u4ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u4.to_string())
    311         self.failUnlessEqual(u4.to_string(), u4ro.to_string())
     325        self.failUnlessReallyEqual(u4.to_string(), u4ro.to_string())
    312326        u4imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u4.to_string())
    313327        self.failUnless(isinstance(u4imm, uri.UnknownURI), u4imm)
    314328
    315329        u4a = uri.from_string(u4.to_string())
    316         self.failUnlessEqual(u4a, u4)
     330        self.failUnlessReallyEqual(u4a, u4)
    317331        self.failUnless("ReadonlySSKFileURI" in str(u4a))
    318332        self.failUnlessIdentical(u4a.get_readonly(), u4a)
    … …  
    320334        u5 = u4.get_verify_cap()
    321335        self.failUnless(IVerifierURI.providedBy(u5))
    322         self.failUnlessEqual(u5.get_storage_index(), u.get_storage_index())
     336        self.failUnlessReallyEqual(u5.get_storage_index(), u.get_storage_index())
    323337        u7 = u.get_verify_cap()
    324338        self.failUnless(IVerifierURI.providedBy(u7))
    325         self.failUnlessEqual(u7.get_storage_index(), u.get_storage_index())
     339        self.failUnlessReallyEqual(u7.get_storage_index(), u.get_storage_index())
    326340
    327341        he = u5.to_human_encoding()
    328342        u5_h = uri.SSKVerifierURI.init_from_human_encoding(he)
    329         self.failUnlessEqual(u5, u5_h)
    330 
    331 
    332 class Dirnode(unittest.TestCase):
     343        self.failUnlessReallyEqual(u5, u5_h)
     344
     345
     346class Dirnode(testutil.ReallyEqualMixin, unittest.TestCase):
    333347    def test_pack(self):
    334348        writekey = "\x01" * 16
    … …  
    348362
    349363        u2 = uri.from_string(u1.to_string())
    350         self.failUnlessEqual(u1.to_string(), u2.to_string())
     364        self.failUnlessReallyEqual(u1.to_string(), u2.to_string())
    351365        self.failIf(u2.is_readonly())
    352366        self.failUnless(u2.is_mutable())
    … …  
    379393
    380394        u4 = uri.ReadonlyDirectoryURI(u2._filenode_uri.get_readonly())
    381         self.failUnlessEqual(u4.to_string(), u3.to_string())
     395        self.failUnlessReallyEqual(u4.to_string(), u3.to_string())
    382396        self.failUnless(u4.is_readonly())
    383397        self.failUnless(u4.is_mutable())
    … …  
    396410        for v in verifiers:
    397411            self.failUnless(IVerifierURI.providedBy(v))
    398             self.failUnlessEqual(v._filenode_uri,
     412            self.failUnlessReallyEqual(v._filenode_uri,
    399413                                 u1.get_verify_cap()._filenode_uri)
    400414
    … …  
    412426                               size=size)
    413427        fncap = fnuri.to_string()
    414         self.failUnlessEqual(fncap, "URI:CHK:aeaqcaibaeaqcaibaeaqcaibae:nf3nimquen7aeqm36ekgxomalstenpkvsdmf6fplj7swdatbv5oa:3:10:1234")
     428        self.failUnlessReallyEqual(fncap, "URI:CHK:aeaqcaibaeaqcaibaeaqcaibae:nf3nimquen7aeqm36ekgxomalstenpkvsdmf6fplj7swdatbv5oa:3:10:1234")
    415429        u1 = uri.ImmutableDirectoryURI(fnuri)
    416430        self.failUnless(u1.is_readonly())
    … …  
    423437        self.failIf(u1_filenode.is_mutable())
    424438        self.failUnless(u1_filenode.is_readonly())
    425         self.failUnlessEqual(u1_filenode.to_string(), fncap)
     439        self.failUnlessReallyEqual(u1_filenode.to_string(), fncap)
    426440        self.failUnless(str(u1))
    427441
    428442        u2 = uri.from_string(u1.to_string())
    429         self.failUnlessEqual(u1.to_string(), u2.to_string())
     443        self.failUnlessReallyEqual(u1.to_string(), u2.to_string())
    430444        self.failUnless(u2.is_readonly())
    431445        self.failIf(u2.is_mutable())
    … …  
    435449
    436450        u2i = uri.from_string(u1.to_string(), deep_immutable=True)
    437         self.failUnlessEqual(u1.to_string(), u2i.to_string())
     451        self.failUnlessReallyEqual(u1.to_string(), u2i.to_string())
    438452
    439453        u3 = u2.get_readonly()
    440         self.failUnlessEqual(u3.to_string(), u2.to_string())
     454        self.failUnlessReallyEqual(u3.to_string(), u2.to_string())
    441455        self.failUnless(str(u3))
    442456
    443457        u3i = uri.from_string(u2.to_string(), deep_immutable=True)
    444         self.failUnlessEqual(u2.to_string(), u3i.to_string())
     458        self.failUnlessReallyEqual(u2.to_string(), u3i.to_string())
    445459
    446460        u2_verifier = u2.get_verify_cap()
    … …  
    456470        u2vfs = u2_verifier_fileuri.to_string()
    457471        # URI:CHK-Verifier:$key:$ueb:$k:$n:$size
    458         self.failUnlessEqual(u2vfs, fnuri.get_verify_cap().to_string())
    459         self.failUnlessEqual(u2vs[len("URI:DIR2-"):], u2vfs[len("URI:"):])
     472        self.failUnlessReallyEqual(u2vfs, fnuri.get_verify_cap().to_string())
     473        self.failUnlessReallyEqual(u2vs[len("URI:DIR2-"):], u2vfs[len("URI:"):])
    460474        self.failUnless(str(u2_verifier))
    461475
    … …  
    464478        u1 = uri.LiteralDirectoryURI(u0)
    465479        self.failUnless(str(u1))
    466         self.failUnlessEqual(u1.to_string(), "URI:DIR2-LIT:mrqxiyi")
     480        self.failUnlessReallyEqual(u1.to_string(), "URI:DIR2-LIT:mrqxiyi")
    467481        self.failUnless(u1.is_readonly())
    468482        self.failIf(u1.is_mutable())
    … …  
    470484        self.failIf(IFileURI.providedBy(u1))
    471485        self.failUnless(IDirnodeURI.providedBy(u1))
    472         self.failUnlessEqual(u1.get_verify_cap(), None)
    473         self.failUnlessEqual(u1.get_storage_index(), None)
    474         self.failUnlessEqual(u1.abbrev_si(), "<LIT>")
     486        self.failUnlessReallyEqual(u1.get_verify_cap(), None)
     487        self.failUnlessReallyEqual(u1.get_storage_index(), None)
     488        self.failUnlessReallyEqual(u1.abbrev_si(), "<LIT>")

  • TabularUnified src/allmydata/test/test_web.py

    rca660a5 rd346e085  
     1
    12import os.path, re, urllib
    23import simplejson
    … …  
    3637timeout = 480 # Most of these take longer than 240 seconds on Francois's arm box.
    3738
    38 unknown_rwcap = "lafs://from_the_future"
    39 unknown_rocap = "ro.lafs://readonly_from_the_future"
    40 unknown_immcap = "imm.lafs://immutable_from_the_future"
     39unknown_rwcap = u"lafs://from_the_future_rw_\u263A".encode('utf-8')
     40unknown_rocap = u"ro.lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
     41unknown_immcap = u"imm.lafs://immutable_from_the_future_imm_\u263A".encode('utf-8')
    4142
    4243class FakeStatsProvider:
    … …  
    209210
    210211    def failUnlessIsBarDotTxt(self, res):
    211         self.failUnlessEqual(res, self.BAR_CONTENTS, res)
     212        self.failUnlessReallyEqual(res, self.BAR_CONTENTS, res)
    212213
    213214    def failUnlessIsBarJSON(self, res):
    214215        data = simplejson.loads(res)
    215216        self.failUnless(isinstance(data, list))
    216         self.failUnlessEqual(data[0], u"filenode")
     217        self.failUnlessReallyEqual(data[0], "filenode")
    217218        self.failUnless(isinstance(data[1], dict))
    218219        self.failIf(data[1]["mutable"])
    219220        self.failIf("rw_uri" in data[1]) # immutable
    220         self.failUnlessEqual(data[1]["ro_uri"], self._bar_txt_uri)
    221         self.failUnlessEqual(data[1]["verify_uri"], self._bar_txt_verifycap)
    222         self.failUnlessEqual(data[1]["size"], len(self.BAR_CONTENTS))
     221        self.failUnlessReallyEqual(data[1]["ro_uri"], self._bar_txt_uri)
     222        self.failUnlessReallyEqual(data[1]["verify_uri"], self._bar_txt_verifycap)
     223        self.failUnlessReallyEqual(data[1]["size"], len(self.BAR_CONTENTS))
    223224
    224225    def failUnlessIsFooJSON(self, res):
    225226        data = simplejson.loads(res)
    226227        self.failUnless(isinstance(data, list))
    227         self.failUnlessEqual(data[0], "dirnode", res)
     228        self.failUnlessReallyEqual(data[0], "dirnode", res)
    228229        self.failUnless(isinstance(data[1], dict))
    229230        self.failUnless(data[1]["mutable"])
    230231        self.failUnless("rw_uri" in data[1]) # mutable
    231         self.failUnlessEqual(data[1]["rw_uri"], self._foo_uri)
    232         self.failUnlessEqual(data[1]["ro_uri"], self._foo_readonly_uri)
    233         self.failUnlessEqual(data[1]["verify_uri"], self._foo_verifycap)
     232        self.failUnlessReallyEqual(data[1]["rw_uri"], self._foo_uri)
     233        self.failUnlessReallyEqual(data[1]["ro_uri"], self._foo_readonly_uri)
     234        self.failUnlessReallyEqual(data[1]["verify_uri"], self._foo_verifycap)
    234235
    235236        kidnames = sorted([unicode(n) for n in data[1]["children"]])
    236         self.failUnlessEqual(kidnames,
    237                              [u"bar.txt", u"blockingfile", u"empty",
    238                               u"n\u00fc.txt", u"sub"])
     237        self.failUnlessReallyEqual(kidnames,
     238                                   [u"bar.txt", u"blockingfile", u"empty",
     239                                    u"n\u00fc.txt", u"sub"])
    239240        kids = dict( [(unicode(name),value)
    240241                      for (name,value)
    241242                      in data[1]["children"].iteritems()] )
    242         self.failUnlessEqual(kids[u"sub"][0], "dirnode")
     243        self.failUnlessReallyEqual(kids[u"sub"][0], "dirnode")
    243244        self.failUnlessIn("metadata", kids[u"sub"][1])
    244245        self.failUnlessIn("tahoe", kids[u"sub"][1]["metadata"])
    … …  
    246247        self.failUnlessIn("linkcrtime", tahoe_md)
    247248        self.failUnlessIn("linkmotime", tahoe_md)
    248         self.failUnlessEqual(kids[u"bar.txt"][0], "filenode")
    249         self.failUnlessEqual(kids[u"bar.txt"][1]["size"], len(self.BAR_CONTENTS))
    250         self.failUnlessEqual(kids[u"bar.txt"][1]["ro_uri"], self._bar_txt_uri)
    251         self.failUnlessEqual(kids[u"bar.txt"][1]["verify_uri"],
    252                              self._bar_txt_verifycap)
     249        self.failUnlessReallyEqual(kids[u"bar.txt"][0], "filenode")
     250        self.failUnlessReallyEqual(kids[u"bar.txt"][1]["size"], len(self.BAR_CONTENTS))
     251        self.failUnlessReallyEqual(kids[u"bar.txt"][1]["ro_uri"], self._bar_txt_uri)
     252        self.failUnlessReallyEqual(kids[u"bar.txt"][1]["verify_uri"],
     253                                   self._bar_txt_verifycap)
    253254        self.failUnlessIn("metadata", kids[u"bar.txt"][1])
    254255        self.failUnlessIn("tahoe", kids[u"bar.txt"][1]["metadata"])
    255         self.failUnlessEqual(kids[u"bar.txt"][1]["metadata"]["tahoe"]["linkcrtime"],
    256                              self._bar_txt_metadata["tahoe"]["linkcrtime"])
    257         self.failUnlessEqual(kids[u"n\u00fc.txt"][1]["ro_uri"],
    258                              self._bar_txt_uri)
     256        self.failUnlessReallyEqual(kids[u"bar.txt"][1]["metadata"]["tahoe"]["linkcrtime"],
     257                                   self._bar_txt_metadata["tahoe"]["linkcrtime"])
     258        self.failUnlessReallyEqual(kids[u"n\u00fc.txt"][1]["ro_uri"],
     259                                   self._bar_txt_uri)
    259260
    260261    def GET(self, urlpath, followRedirect=False, return_response=False,
    … …  
    374375        if isinstance(res, failure.Failure):
    375376            res.trap(error.Error)
    376             self.failUnlessEqual(res.value.status, "404")
     377            self.failUnlessReallyEqual(res.value.status, "404")
    377378        else:
    378379            self.fail("%s was supposed to Error(404), not get '%s'" %
    … …  
    382383        if isinstance(res, failure.Failure):
    383384            res.trap(error.Error)
    384             self.failUnlessEqual(res.value.status, "302")
     385            self.failUnlessReallyEqual(res.value.status, "302")
    385386        else:
    386387            self.fail("%s was supposed to Error(302), not get '%s'" %
    … …  
    388389
    389390
    390 class Web(WebMixin, WebErrorMixin, testutil.StallMixin, unittest.TestCase):
     391class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixin, unittest.TestCase):
    391392    def test_create(self):
    392393        pass
    … …  
    535536    def test_status_numbers(self):
    536537        drrm = status.DownloadResultsRendererMixin()
    537         self.failUnlessEqual(drrm.render_time(None, None), "")
    538         self.failUnlessEqual(drrm.render_time(None, 2.5), "2.50s")
    539         self.failUnlessEqual(drrm.render_time(None, 0.25), "250ms")
    540         self.failUnlessEqual(drrm.render_time(None, 0.0021), "2.1ms")
    541         self.failUnlessEqual(drrm.render_time(None, 0.000123), "123us")
    542         self.failUnlessEqual(drrm.render_rate(None, None), "")
    543         self.failUnlessEqual(drrm.render_rate(None, 2500000), "2.50MBps")
    544         self.failUnlessEqual(drrm.render_rate(None, 30100), "30.1kBps")
    545         self.failUnlessEqual(drrm.render_rate(None, 123), "123Bps")
     538        self.failUnlessReallyEqual(drrm.render_time(None, None), "")
     539        self.failUnlessReallyEqual(drrm.render_time(None, 2.5), "2.50s")
     540        self.failUnlessReallyEqual(drrm.render_time(None, 0.25), "250ms")
     541        self.failUnlessReallyEqual(drrm.render_time(None, 0.0021), "2.1ms")
     542        self.failUnlessReallyEqual(drrm.render_time(None, 0.000123), "123us")
     543        self.failUnlessReallyEqual(drrm.render_rate(None, None), "")
     544        self.failUnlessReallyEqual(drrm.render_rate(None, 2500000), "2.50MBps")
     545        self.failUnlessReallyEqual(drrm.render_rate(None, 30100), "30.1kBps")
     546        self.failUnlessReallyEqual(drrm.render_rate(None, 123), "123Bps")
    546547
    547548        urrm = status.UploadResultsRendererMixin()
    548         self.failUnlessEqual(urrm.render_time(None, None), "")
    549         self.failUnlessEqual(urrm.render_time(None, 2.5), "2.50s")
    550         self.failUnlessEqual(urrm.render_time(None, 0.25), "250ms")
    551         self.failUnlessEqual(urrm.render_time(None, 0.0021), "2.1ms")
    552         self.failUnlessEqual(urrm.render_time(None, 0.000123), "123us")
    553         self.failUnlessEqual(urrm.render_rate(None, None), "")
    554         self.failUnlessEqual(urrm.render_rate(None, 2500000), "2.50MBps")
    555         self.failUnlessEqual(urrm.render_rate(None, 30100), "30.1kBps")
    556         self.failUnlessEqual(urrm.render_rate(None, 123), "123Bps")
     549        self.failUnlessReallyEqual(urrm.render_time(None, None), "")
     550        self.failUnlessReallyEqual(urrm.render_time(None, 2.5), "2.50s")
     551        self.failUnlessReallyEqual(urrm.render_time(None, 0.25), "250ms")
     552        self.failUnlessReallyEqual(urrm.render_time(None, 0.0021), "2.1ms")
     553        self.failUnlessReallyEqual(urrm.render_time(None, 0.000123), "123us")
     554        self.failUnlessReallyEqual(urrm.render_rate(None, None), "")
     555        self.failUnlessReallyEqual(urrm.render_rate(None, 2500000), "2.50MBps")
     556        self.failUnlessReallyEqual(urrm.render_rate(None, 30100), "30.1kBps")
     557        self.failUnlessReallyEqual(urrm.render_rate(None, 123), "123Bps")
    557558
    558559    def test_GET_FILEURL(self):
    … …  
    566567                     return_response=True)
    567568        def _got((res, status, headers)):
    568             self.failUnlessEqual(int(status), 206)
     569            self.failUnlessReallyEqual(int(status), 206)
    569570            self.failUnless(headers.has_key("content-range"))
    570             self.failUnlessEqual(headers["content-range"][0],
    571                                  "bytes 1-10/%d" % len(self.BAR_CONTENTS))
    572             self.failUnlessEqual(res, self.BAR_CONTENTS[1:11])
     571            self.failUnlessReallyEqual(headers["content-range"][0],
     572                                       "bytes 1-10/%d" % len(self.BAR_CONTENTS))
     573            self.failUnlessReallyEqual(res, self.BAR_CONTENTS[1:11])
    573574        d.addCallback(_got)
    574575        return d
    … …  
    580581                     return_response=True)
    581582        def _got((res, status, headers)):
    582             self.failUnlessEqual(int(status), 206)
     583            self.failUnlessReallyEqual(int(status), 206)
    583584            self.failUnless(headers.has_key("content-range"))
    584             self.failUnlessEqual(headers["content-range"][0],
    585                                  "bytes 5-%d/%d" % (length-1, length))
    586             self.failUnlessEqual(res, self.BAR_CONTENTS[5:])
     585            self.failUnlessReallyEqual(headers["content-range"][0],
     586                                       "bytes 5-%d/%d" % (length-1, length))
     587            self.failUnlessReallyEqual(res, self.BAR_CONTENTS[5:])
    587588        d.addCallback(_got)
    588589        return d
    … …  
    594595                     return_response=True)
    595596        def _got((res, status, headers)):
    596             self.failUnlessEqual(int(status), 206)
     597            self.failUnlessReallyEqual(int(status), 206)
    597598            self.failUnless(headers.has_key("content-range"))
    598             self.failUnlessEqual(headers["content-range"][0],
    599                                  "bytes %d-%d/%d" % (length-5, length-1, length))
    600             self.failUnlessEqual(res, self.BAR_CONTENTS[-5:])
     599            self.failUnlessReallyEqual(headers["content-range"][0],
     600                                       "bytes %d-%d/%d" % (length-5, length-1, length))
     601            self.failUnlessReallyEqual(res, self.BAR_CONTENTS[-5:])
    601602        d.addCallback(_got)
    602603        return d
    … …  
    616617                     return_response=True)
    617618        def _got((res, status, headers)):
    618             self.failUnlessEqual(res, "")
    619             self.failUnlessEqual(int(status), 206)
     619            self.failUnlessReallyEqual(res, "")
     620            self.failUnlessReallyEqual(int(status), 206)
    620621            self.failUnless(headers.has_key("content-range"))
    621             self.failUnlessEqual(headers["content-range"][0],
    622                                  "bytes 1-10/%d" % len(self.BAR_CONTENTS))
     622            self.failUnlessReallyEqual(headers["content-range"][0],
     623                                       "bytes 1-10/%d" % len(self.BAR_CONTENTS))
    623624        d.addCallback(_got)
    624625        return d
    … …  
    630631                     return_response=True)
    631632        def _got((res, status, headers)):
    632             self.failUnlessEqual(int(status), 206)
     633            self.failUnlessReallyEqual(int(status), 206)
    633634            self.failUnless(headers.has_key("content-range"))
    634             self.failUnlessEqual(headers["content-range"][0],
    635                                  "bytes 5-%d/%d" % (length-1, length))
     635            self.failUnlessReallyEqual(headers["content-range"][0],
     636                                       "bytes 5-%d/%d" % (length-1, length))
    636637        d.addCallback(_got)
    637638        return d
    … …  
    643644                     return_response=True)
    644645        def _got((res, status, headers)):
    645             self.failUnlessEqual(int(status), 206)
     646            self.failUnlessReallyEqual(int(status), 206)
    646647            self.failUnless(headers.has_key("content-range"))
    647             self.failUnlessEqual(headers["content-range"][0],
    648                                  "bytes %d-%d/%d" % (length-5, length-1, length))
     648            self.failUnlessReallyEqual(headers["content-range"][0],
     649                                       "bytes %d-%d/%d" % (length-5, length-1, length))
    649650        d.addCallback(_got)
    650651        return d
    … …  
    664665                     return_response=True)
    665666        def _got((res, status, headers)):
    666             self.failUnlessEqual(int(status), 200)
     667            self.failUnlessReallyEqual(int(status), 200)
    667668            self.failUnless(not headers.has_key("content-range"))
    668             self.failUnlessEqual(res, self.BAR_CONTENTS)
     669            self.failUnlessReallyEqual(res, self.BAR_CONTENTS)
    669670        d.addCallback(_got)
    670671        return d
    … …  
    673674        d = self.HEAD(self.public_url + "/foo/bar.txt", return_response=True)
    674675        def _got((res, status, headers)):
    675             self.failUnlessEqual(res, "")
    676             self.failUnlessEqual(headers["content-length"][0],
    677                                  str(len(self.BAR_CONTENTS)))
    678             self.failUnlessEqual(headers["content-type"], ["text/plain"])
     676            self.failUnlessReallyEqual(res, "")
     677            self.failUnlessReallyEqual(headers["content-length"][0],
     678                                       str(len(self.BAR_CONTENTS)))
     679            self.failUnlessReallyEqual(headers["content-type"], ["text/plain"])
    679680        d.addCallback(_got)
    680681        return d
    … …  
    806807        d = self.PUT(self.public_url + "/foo/new.txt", self.NEWFILE_CONTENTS)
    807808        # TODO: we lose the response code, so we can't check this
    808         #self.failUnlessEqual(responsecode, 201)
     809        #self.failUnlessReallyEqual(responsecode, 201)
    809810        d.addCallback(self.failUnlessURIMatchesROChild, self._foo_node, u"new.txt")
    810811        d.addCallback(lambda res:
    … …  
    817818                     self.NEWFILE_CONTENTS)
    818819        # TODO: we lose the response code, so we can't check this
    819         #self.failUnlessEqual(responsecode, 201)
     820        #self.failUnlessReallyEqual(responsecode, 201)
    820821        d.addCallback(self.failUnlessURIMatchesROChild, self._foo_node, u"new.txt")
    821822        d.addCallback(lambda res:
    … …  
    841842                     self.NEWFILE_CONTENTS)
    842843        # TODO: we lose the response code, so we can't check this
    843         #self.failUnlessEqual(responsecode, 201)
     844        #self.failUnlessReallyEqual(responsecode, 201)
    844845        def _check_uri(res):
    845846            u = uri.from_string_mutable_filenode(res)
    … …  
    867868        d = self.PUT(self.public_url + "/foo/bar.txt", self.NEWFILE_CONTENTS)
    868869        # TODO: we lose the response code, so we can't check this
    869         #self.failUnlessEqual(responsecode, 200)
     870        #self.failUnlessReallyEqual(responsecode, 200)
    870871        d.addCallback(self.failUnlessURIMatchesROChild, self._foo_node, u"bar.txt")
    871872        d.addCallback(lambda res:
    … …  
    940941        self.failUnlessIn("linkcrtime", data[1]["metadata"]["tahoe"])
    941942        self.failUnlessIn("linkmotime", data[1]["metadata"]["tahoe"])
    942         self.failUnlessEqual(data[1]["metadata"]["tahoe"]["linkcrtime"],
    943                              self._bar_txt_metadata["tahoe"]["linkcrtime"])
     943        self.failUnlessReallyEqual(data[1]["metadata"]["tahoe"]["linkcrtime"],
     944                                   self._bar_txt_metadata["tahoe"]["linkcrtime"])
    944945
    945946    def test_GET_FILEURL_json(self):
    … …  
    964965        d = self.GET(self.public_url + "/foo/bar.txt?t=uri")
    965966        def _check(res):
    966             self.failUnlessEqual(res, self._bar_txt_uri)
     967            self.failUnlessReallyEqual(res, self._bar_txt_uri)
    967968        d.addCallback(_check)
    968969        d.addCallback(lambda res:
    … …  
    970971        def _check2(res):
    971972            # for now, for files, uris and readonly-uris are the same
    972             self.failUnlessEqual(res, self._bar_txt_uri)
     973            self.failUnlessReallyEqual(res, self._bar_txt_uri)
    973974        d.addCallback(_check2)
    974975        return d
    … …  
    11321133            for (path_list, cap) in data:
    11331134                got[tuple(path_list)] = cap
    1134             self.failUnlessEqual(got[(u"sub",)], self._sub_uri)
     1135            self.failUnlessReallyEqual(got[(u"sub",)], self._sub_uri)
    11351136            self.failUnless((u"sub",u"baz.txt") in got)
    11361137            self.failUnless("finished" in res)
    … …  
    11561157        d.addCallback(self.get_operation_results, "126", "json")
    11571158        def _got_json(data):
    1158             self.failUnlessEqual(data["finished"], True)
     1159            self.failUnlessReallyEqual(data["finished"], True)
    11591160            size = data["size"]
    11601161            self.failUnless(size > 1000)
    … …  
    11971198                        }
    11981199            for k,v in expected.iteritems():
    1199                 self.failUnlessEqual(stats[k], v,
    1200                                      "stats[%s] was %s, not %s" %
    1201                                      (k, stats[k], v))
    1202             self.failUnlessEqual(stats["size-files-histogram"],
    1203                                  [ [11, 31, 3] ])
     1200                self.failUnlessReallyEqual(stats[k], v,
     1201                                           "stats[%s] was %s, not %s" %
     1202                                           (k, stats[k], v))
     1203            self.failUnlessReallyEqual(stats["size-files-histogram"],
     1204                                       [ [11, 31, 3] ])
    12041205        d.addCallback(_got_json)
    12051206        return d
    … …  
    12101211            self.failUnless(res.endswith("\n"))
    12111212            units = [simplejson.loads(t) for t in res[:-1].split("\n")]
    1212             self.failUnlessEqual(len(units), 7)
    1213             self.failUnlessEqual(units[-1]["type"], "stats")
     1213            self.failUnlessReallyEqual(len(units), 7)
     1214            self.failUnlessReallyEqual(units[-1]["type"], "stats")
    12141215            first = units[0]
    1215             self.failUnlessEqual(first["path"], [])
    1216             self.failUnlessEqual(first["cap"], self._foo_uri)
    1217             self.failUnlessEqual(first["type"], "directory")
     1216            self.failUnlessReallyEqual(first["path"], [])
     1217            self.failUnlessReallyEqual(first["cap"], self._foo_uri)
     1218            self.failUnlessReallyEqual(first["type"], "directory")
    12181219            baz = [u for u in units[:-1] if u["cap"] == self._baz_file_uri][0]
    1219             self.failUnlessEqual(baz["path"], ["sub", "baz.txt"])
     1220            self.failUnlessReallyEqual(baz["path"], ["sub", "baz.txt"])
    12201221            self.failIfEqual(baz["storage-index"], None)
    12211222            self.failIfEqual(baz["verifycap"], None)
    … …  
    12281229        d = self.GET(self.public_url + "/foo?t=uri")
    12291230        def _check(res):
    1230             self.failUnlessEqual(res, self._foo_uri)
     1231            self.failUnlessReallyEqual(res, self._foo_uri)
    12311232        d.addCallback(_check)
    12321233        return d
    … …  
    12351236        d = self.GET(self.public_url + "/foo?t=readonly-uri")
    12361237        def _check(res):
    1237             self.failUnlessEqual(res, self._foo_readonly_uri)
     1238            self.failUnlessReallyEqual(res, self._foo_readonly_uri)
    12381239        d.addCallback(_check)
    12391240        return d
    … …  
    13871388            def made_subsub(ssuri):
    13881389                d = self._foo_node.get_child_at_path(u"mkp/sub1/sub2")
    1389                 d.addCallback(lambda ssnode: self.failUnlessEqual(ssnode.get_uri(), ssuri))
     1390                d.addCallback(lambda ssnode: self.failUnlessReallyEqual(ssnode.get_uri(), ssuri))
    13901391                d = self.POST(url)
    1391                 d.addCallback(lambda uri2: self.failUnlessEqual(uri2, ssuri))
     1392                d.addCallback(lambda uri2: self.failUnlessReallyEqual(uri2, ssuri))
    13921393                return d
    13931394            d.addCallback(made_subsub)
    … …  
    14381439        d = node.list()
    14391440        def _check(children):
    1440             self.failUnlessEqual(sorted(children.keys()), sorted(expected_keys))
     1441            self.failUnlessReallyEqual(sorted(children.keys()), sorted(expected_keys))
    14411442        d.addCallback(_check)
    14421443        return d
    … …  
    14611462        d.addCallback(lambda node: download_to_data(node))
    14621463        def _check(contents):
    1463             self.failUnlessEqual(contents, expected_contents)
     1464            self.failUnlessReallyEqual(contents, expected_contents)
    14641465        d.addCallback(_check)
    14651466        return d
    … …  
    14701471        d.addCallback(lambda node: node.download_best_version())
    14711472        def _check(contents):
    1472             self.failUnlessEqual(contents, expected_contents)
     1473            self.failUnlessReallyEqual(contents, expected_contents)
    14731474        d.addCallback(_check)
    14741475        return d
    … …  
    14791480        def _check(child):
    14801481            self.failUnless(child.is_unknown() or not child.is_readonly())
    1481             self.failUnlessEqual(child.get_uri(), expected_uri.strip())
    1482             self.failUnlessEqual(child.get_write_uri(), expected_uri.strip())
     1482            self.failUnlessReallyEqual(child.get_uri(), expected_uri.strip())
     1483            self.failUnlessReallyEqual(child.get_write_uri(), expected_uri.strip())
    14831484            expected_ro_uri = self._make_readonly(expected_uri)
    14841485            if expected_ro_uri:
    1485                 self.failUnlessEqual(child.get_readonly_uri(), expected_ro_uri.strip())
     1486                self.failUnlessReallyEqual(child.get_readonly_uri(), expected_ro_uri.strip())
    14861487        d.addCallback(_check)
    14871488        return d
    … …  
    14921493        def _check(child):
    14931494            self.failUnless(child.is_unknown() or child.is_readonly())
    1494             self.failUnlessEqual(child.get_write_uri(), None)
    1495             self.failUnlessEqual(child.get_uri(), expected_uri.strip())
    1496             self.failUnlessEqual(child.get_readonly_uri(), expected_uri.strip())
     1495            self.failUnlessReallyEqual(child.get_write_uri(), None)
     1496            self.failUnlessReallyEqual(child.get_uri(), expected_uri.strip())
     1497            self.failUnlessReallyEqual(child.get_readonly_uri(), expected_uri.strip())
    14971498        d.addCallback(_check)
    14981499        return d
    … …  
    15031504        def _check(child):
    15041505            self.failUnless(child.is_unknown() or not child.is_readonly())
    1505             self.failUnlessEqual(child.get_uri(), got_uri.strip())
    1506             self.failUnlessEqual(child.get_write_uri(), got_uri.strip())
     1506            self.failUnlessReallyEqual(child.get_uri(), got_uri.strip())
     1507            self.failUnlessReallyEqual(child.get_write_uri(), got_uri.strip())
    15071508            expected_ro_uri = self._make_readonly(got_uri)
    15081509            if expected_ro_uri:
    1509                 self.failUnlessEqual(child.get_readonly_uri(), expected_ro_uri.strip())
     1510                self.failUnlessReallyEqual(child.get_readonly_uri(), expected_ro_uri.strip())
    15101511        d.addCallback(_check)
    15111512        return d
    … …  
    15161517        def _check(child):
    15171518            self.failUnless(child.is_unknown() or child.is_readonly())
    1518             self.failUnlessEqual(child.get_write_uri(), None)
    1519             self.failUnlessEqual(got_uri.strip(), child.get_uri())
    1520             self.failUnlessEqual(got_uri.strip(), child.get_readonly_uri())
     1519            self.failUnlessReallyEqual(child.get_write_uri(), None)
     1520            self.failUnlessReallyEqual(got_uri.strip(), child.get_uri())
     1521            self.failUnlessReallyEqual(got_uri.strip(), child.get_readonly_uri())
    15211522        d.addCallback(_check)
    15221523        return d
    … …  
    15461547        target_url = self.public_url + "/foo/" + filename.encode("utf-8")
    15471548        d.addCallback(lambda res: self.GET(target_url))
    1548         d.addCallback(lambda contents: self.failUnlessEqual(contents,
    1549                                                             self.NEWFILE_CONTENTS,
    1550                                                             contents))
     1549        d.addCallback(lambda contents: self.failUnlessReallyEqual(contents,
     1550                                                                  self.NEWFILE_CONTENTS,
     1551                                                                  contents))
    15511552        return d
    15521553
    … …  
    15631564        target_url = self.public_url + "/foo/" + filename.encode("utf-8")
    15641565        d.addCallback(lambda res: self.GET(target_url))
    1565         d.addCallback(lambda contents: self.failUnlessEqual(contents,
    1566                                                             self.NEWFILE_CONTENTS,
    1567                                                             contents))
     1566        d.addCallback(lambda contents: self.failUnlessReallyEqual(contents,
     1567                                                                  self.NEWFILE_CONTENTS,
     1568                                                                  contents))
    15681569        return d
    15691570
    … …  
    16061607    def test_POST_upload_no_link_whendone_results(self):
    16071608        def check(statuscode, target):
    1608             self.failUnlessEqual(statuscode, str(http.FOUND))
     1609            self.failUnlessReallyEqual(statuscode, str(http.FOUND))
    16091610            self.failUnless(target.startswith(self.webish_url), target)
    16101611            return client.getPage(target, method="GET")
    … …  
    16151616                                 file=("new.txt", self.NEWFILE_CONTENTS))
    16161617        d.addCallback(lambda res:
    1617                       self.failUnlessEqual(res, self.NEWFILE_CONTENTS))
     1618                      self.failUnlessReallyEqual(res, self.NEWFILE_CONTENTS))
    16181619        return d
    16191620
    … …  
    16311632        d.addCallback(_check)
    16321633        def _check2(data):
    1633             self.failUnlessEqual(data, self.NEWFILE_CONTENTS)
     1634            self.failUnlessReallyEqual(data, self.NEWFILE_CONTENTS)
    16341635            return self.GET("/uri/%s" % urllib.quote(self.filecap))
    16351636        d.addCallback(_check2)
    16361637        def _check3(data):
    1637             self.failUnlessEqual(data, self.NEWFILE_CONTENTS)
     1638            self.failUnlessReallyEqual(data, self.NEWFILE_CONTENTS)
    16381639            return self.GET("/file/%s" % urllib.quote(self.filecap))
    16391640        d.addCallback(_check3)
    16401641        def _check4(data):
    1641             self.failUnlessEqual(data, self.NEWFILE_CONTENTS)
     1642            self.failUnlessReallyEqual(data, self.NEWFILE_CONTENTS)
    16421643        d.addCallback(_check4)
    16431644        return d
    … …  
    16871688            self.failUnless(newnode.is_mutable())
    16881689            self.failIf(newnode.is_readonly())
    1689             self.failUnlessEqual(self._mutable_uri, newnode.get_uri())
     1690            self.failUnlessReallyEqual(self._mutable_uri, newnode.get_uri())
    16901691        d.addCallback(_got2)
    16911692
    … …  
    17161717            self.failUnless(newnode.is_mutable())
    17171718            self.failIf(newnode.is_readonly())
    1718             self.failUnlessEqual(self._mutable_uri, newnode.get_uri())
     1719            self.failUnlessReallyEqual(self._mutable_uri, newnode.get_uri())
    17191720        d.addCallback(_got3)
    17201721
    … …  
    17251726        def _check_page_json(res):
    17261727            parsed = simplejson.loads(res)
    1727             self.failUnlessEqual(parsed[0], "dirnode")
     1728            self.failUnlessReallyEqual(parsed[0], "dirnode")
    17281729            children = dict( [(unicode(name),value)
    17291730                              for (name,value)
    … …  
    17311732            self.failUnless("new.txt" in children)
    17321733            new_json = children["new.txt"]
    1733             self.failUnlessEqual(new_json[0], "filenode")
     1734            self.failUnlessReallyEqual(new_json[0], "filenode")
    17341735            self.failUnless(new_json[1]["mutable"])
    1735             self.failUnlessEqual(new_json[1]["rw_uri"], self._mutable_uri)
    1736             ro_uri = unicode(self._mutable_node.get_readonly().to_string())
    1737             self.failUnlessEqual(new_json[1]["ro_uri"], ro_uri)
     1736            self.failUnlessReallyEqual(new_json[1]["rw_uri"], self._mutable_uri)
     1737            ro_uri = self._mutable_node.get_readonly().to_string()
     1738            self.failUnlessReallyEqual(new_json[1]["ro_uri"], ro_uri)
    17381739        d.addCallback(_check_page_json)
    17391740
    … …  
    17431744        def _check_file_json(res):
    17441745            parsed = simplejson.loads(res)
    1745             self.failUnlessEqual(parsed[0], "filenode")
     1746            self.failUnlessReallyEqual(parsed[0], "filenode")
    17461747            self.failUnless(parsed[1]["mutable"])
    1747             self.failUnlessEqual(parsed[1]["rw_uri"], self._mutable_uri)
    1748             ro_uri = unicode(self._mutable_node.get_readonly().to_string())
    1749             self.failUnlessEqual(parsed[1]["ro_uri"], ro_uri)
     1748            self.failUnlessReallyEqual(parsed[1]["rw_uri"], self._mutable_uri)
     1749            ro_uri = self._mutable_node.get_readonly().to_string()
     1750            self.failUnlessReallyEqual(parsed[1]["ro_uri"], ro_uri)
    17501751        d.addCallback(_check_file_json)
    17511752
    … …  
    17531754        d.addCallback(lambda res:
    17541755                      self.GET(self.public_url + "/foo/new.txt?t=uri"))
    1755         d.addCallback(lambda res: self.failUnlessEqual(res, self._mutable_uri))
     1756        d.addCallback(lambda res: self.failUnlessReallyEqual(res, self._mutable_uri))
    17561757        d.addCallback(lambda res:
    17571758                      self.GET(self.public_url + "/foo/new.txt?t=readonly-uri"))
    17581759        def _check_ro_uri(res):
    1759             ro_uri = unicode(self._mutable_node.get_readonly().to_string())
    1760             self.failUnlessEqual(res, ro_uri)
     1760            ro_uri = self._mutable_node.get_readonly().to_string()
     1761            self.failUnlessReallyEqual(res, ro_uri)
    17611762        d.addCallback(_check_ro_uri)
    17621763
    … …  
    17651766                      self.GET("/uri/%s" % urllib.quote(self._mutable_uri)))
    17661767        d.addCallback(lambda res:
    1767                       self.failUnlessEqual(res, NEW2_CONTENTS))
     1768                      self.failUnlessReallyEqual(res, NEW2_CONTENTS))
    17681769
    17691770        # and that HEAD computes the size correctly
    … …  
    17721773                                return_response=True))
    17731774        def _got_headers((res, status, headers)):
    1774             self.failUnlessEqual(res, "")
    1775             self.failUnlessEqual(headers["content-length"][0],
    1776                                  str(len(NEW2_CONTENTS)))
    1777             self.failUnlessEqual(headers["content-type"], ["text/plain"])
     1775            self.failUnlessReallyEqual(res, "")
     1776            self.failUnlessReallyEqual(headers["content-length"][0],
     1777                                       str(len(NEW2_CONTENTS)))
     1778            self.failUnlessReallyEqual(headers["content-type"], ["text/plain"])
    17781779        d.addCallback(_got_headers)
    17791780
    … …  
    18331834                      file=("new.txt", self.NEWFILE_CONTENTS))
    18341835        d.addCallback(lambda res: self.GET(self.public_url + "/foo/new.txt"))
    1835         d.addCallback(lambda res: self.failUnlessEqual(res,
    1836                                                        self.NEWFILE_CONTENTS))
     1836        d.addCallback(lambda res: self.failUnlessReallyEqual(res,
     1837                                                             self.NEWFILE_CONTENTS))
    18371838        return d
    18381839
    … …  
    19041905        redir_url = "http://allmydata.org/TARGET"
    19051906        def _check2(statuscode, target):
    1906             self.failUnlessEqual(statuscode, str(http.FOUND))
    1907             self.failUnlessEqual(target, redir_url)
     1907            self.failUnlessReallyEqual(statuscode, str(http.FOUND))
     1908            self.failUnlessReallyEqual(target, redir_url)
    19081909        d.addCallback(lambda res:
    19091910                      self.shouldRedirect2("test_POST_FILEURL_check",
    … …  
    19381939        redir_url = "http://allmydata.org/TARGET"
    19391940        def _check2(statuscode, target):
    1940             self.failUnlessEqual(statuscode, str(http.FOUND))
    1941             self.failUnlessEqual(target, redir_url)
     1941            self.failUnlessReallyEqual(statuscode, str(http.FOUND))
     1942            self.failUnlessReallyEqual(target, redir_url)
    19421943        d.addCallback(lambda res:
    19431944                      self.shouldRedirect2("test_POST_FILEURL_check_and_repair",
    … …  
    19631964        redir_url = "http://allmydata.org/TARGET"
    19641965        def _check2(statuscode, target):
    1965             self.failUnlessEqual(statuscode, str(http.FOUND))
    1966             self.failUnlessEqual(target, redir_url)
     1966            self.failUnlessReallyEqual(statuscode, str(http.FOUND))
     1967            self.failUnlessReallyEqual(target, redir_url)
    19671968        d.addCallback(lambda res:
    19681969                      self.shouldRedirect2("test_POST_DIRURL_check",
    … …  
    19971998        redir_url = "http://allmydata.org/TARGET"
    19981999        def _check2(statuscode, target):
    1999             self.failUnlessEqual(statuscode, str(http.FOUND))
    2000             self.failUnlessEqual(target, redir_url)
     2000            self.failUnlessReallyEqual(statuscode, str(http.FOUND))
     2001            self.failUnlessReallyEqual(target, redir_url)
    20012002        d.addCallback(lambda res:
    20022003                      self.shouldRedirect2("test_POST_DIRURL_check_and_repair",
    … …  
    20512052    def test_POST_DIRURL_deepcheck(self):
    20522053        def _check_redirect(statuscode, target):
    2053             self.failUnlessEqual(statuscode, str(http.FOUND))
     2054            self.failUnlessReallyEqual(statuscode, str(http.FOUND))
    20542055            self.failUnless(target.endswith("/operations/123"))
    20552056        d = self.shouldRedirect2("test_POST_DIRURL_deepcheck", _check_redirect,
    … …  
    20582059        d.addCallback(self.wait_for_operation, "123")
    20592060        def _check_json(data):
    2060             self.failUnlessEqual(data["finished"], True)
    2061             self.failUnlessEqual(data["count-objects-checked"], 8)
    2062             self.failUnlessEqual(data["count-objects-healthy"], 8)
     2061            self.failUnlessReallyEqual(data["finished"], True)
     2062            self.failUnlessReallyEqual(data["count-objects-checked"], 8)
     2063            self.failUnlessReallyEqual(data["count-objects-healthy"], 8)
    20632064        d.addCallback(_check_json)
    20642065        d.addCallback(self.get_operation_results, "123", "html")
    … …  
    20832084        def _check_foo_json(res):
    20842085            data = simplejson.loads(res)
    2085             self.failUnlessEqual(data["storage-index"], foo_si_s)
     2086            self.failUnlessReallyEqual(data["storage-index"], foo_si_s)
    20862087            self.failUnless(data["results"]["healthy"])
    20872088        d.addCallback(_check_foo_json)
    … …  
    20932094        d.addCallback(self.wait_for_operation, "124")
    20942095        def _check_json(data):
    2095             self.failUnlessEqual(data["finished"], True)
    2096             self.failUnlessEqual(data["count-objects-checked"], 8)
    2097             self.failUnlessEqual(data["count-objects-healthy-pre-repair"], 8)
    2098             self.failUnlessEqual(data["count-objects-unhealthy-pre-repair"], 0)
    2099             self.failUnlessEqual(data["count-corrupt-shares-pre-repair"], 0)
    2100             self.failUnlessEqual(data["count-repairs-attempted"], 0)
    2101             self.failUnlessEqual(data["count-repairs-successful"], 0)
    2102             self.failUnlessEqual(data["count-repairs-unsuccessful"], 0)
    2103             self.failUnlessEqual(data["count-objects-healthy-post-repair"], 8)
    2104             self.failUnlessEqual(data["count-objects-unhealthy-post-repair"], 0)
    2105             self.failUnlessEqual(data["count-corrupt-shares-post-repair"], 0)
     2096            self.failUnlessReallyEqual(data["finished"], True)
     2097            self.failUnlessReallyEqual(data["count-objects-checked"], 8)
     2098            self.failUnlessReallyEqual(data["count-objects-healthy-pre-repair"], 8)
     2099            self.failUnlessReallyEqual(data["count-objects-unhealthy-pre-repair"], 0)
     2100            self.failUnlessReallyEqual(data["count-corrupt-shares-pre-repair"], 0)
     2101            self.failUnlessReallyEqual(data["count-repairs-attempted"], 0)
     2102            self.failUnlessReallyEqual(data["count-repairs-successful"], 0)
     2103            self.failUnlessReallyEqual(data["count-repairs-unsuccessful"], 0)
     2104            self.failUnlessReallyEqual(data["count-objects-healthy-post-repair"], 8)
     2105            self.failUnlessReallyEqual(data["count-objects-unhealthy-post-repair"], 0)
     2106            self.failUnlessReallyEqual(data["count-corrupt-shares-post-repair"], 0)
    21062107        d.addCallback(_check_json)
    21072108        d.addCallback(self.get_operation_results, "124", "html")
    … …  
    26382639    def failUnlessIsEmptyJSON(self, res):
    26392640        data = simplejson.loads(res)
    2640         self.failUnlessEqual(data[0], "dirnode", data)
    2641         self.failUnlessEqual(len(data[1]["children"]), 0)
     2641        self.failUnlessReallyEqual(data[0], "dirnode", data)
     2642        self.failUnlessReallyEqual(len(data[1]["children"]), 0)
    26422643
    26432644    def test_POST_rename_file_slash_fail(self):
    … …  
    26742675        res.trap(error.PageRedirect)
    26752676        if statuscode is not None:
    2676             self.failUnlessEqual(res.value.status, statuscode,
    2677                                  "%s: not a redirect" % which)
     2677            self.failUnlessReallyEqual(res.value.status, statuscode,
     2678                                       "%s: not a redirect" % which)
    26782679        if target is not None:
    26792680            # the PageRedirect does not seem to capture the uri= query arg
    26802681            # properly, so we can't check for it.
    26812682            realtarget = self.webish_url + target
    2682             self.failUnlessEqual(res.value.location, realtarget,
    2683                                  "%s: wrong target" % which)
     2683            self.failUnlessReallyEqual(res.value.location, realtarget,
     2684                                       "%s: wrong target" % which)
    26842685        return res.value.location
    26852686
    … …  
    27592760            d = self.PUT(self.public_url + "/foo?t=uri", new_uri)
    27602761            d.addCallback(lambda res:
    2761                           self.failUnlessEqual(res.strip(), new_uri))
     2762                          self.failUnlessReallyEqual(res.strip(), new_uri))
    27622763            d.addCallback(lambda res:
    27632764                          self.failUnlessRWChildURIIs(self.public_root,
    … …  
    28002801        contents, n, new_uri = self.makefile(8)
    28012802        d = self.PUT(self.public_url + "/foo/new.txt?t=uri", new_uri)
    2802         d.addCallback(lambda res: self.failUnlessEqual(res.strip(), new_uri))
     2803        d.addCallback(lambda res: self.failUnlessReallyEqual(res.strip(), new_uri))
    28032804        d.addCallback(lambda res:
    28042805                      self.failUnlessChildContentsAre(self._foo_node, u"new.txt",
    … …  
    28092810        contents, n, new_uri = self.makefile(8)
    28102811        d = self.PUT(self.public_url + "/foo/bar.txt?t=uri", new_uri)
    2811         d.addCallback(lambda res: self.failUnlessEqual(res.strip(), new_uri))
     2812        d.addCallback(lambda res: self.failUnlessReallyEqual(res.strip(), new_uri))
    28122813        d.addCallback(lambda res:
    28132814                      self.failUnlessChildContentsAre(self._foo_node, u"bar.txt",
    … …  
    28502851            assert isinstance(uri, str), uri
    28512852            self.failUnless(uri in FakeCHKFileNode.all_contents)
    2852             self.failUnlessEqual(FakeCHKFileNode.all_contents[uri],
    2853                                  file_contents)
     2853            self.failUnlessReallyEqual(FakeCHKFileNode.all_contents[uri],
     2854                                       file_contents)
    28542855            return self.GET("/uri/%s" % uri)
    28552856        d.addCallback(_check)
    28562857        def _check2(res):
    2857             self.failUnlessEqual(res, file_contents)
     2858            self.failUnlessReallyEqual(res, file_contents)
    28582859        d.addCallback(_check2)
    28592860        return d
    … …  
    28652866            assert isinstance(uri, str), uri
    28662867            self.failUnless(uri in FakeCHKFileNode.all_contents)
    2867             self.failUnlessEqual(FakeCHKFileNode.all_contents[uri],
    2868                                  file_contents)
     2868            self.failUnlessReallyEqual(FakeCHKFileNode.all_contents[uri],
     2869                                       file_contents)
    28692870            return self.GET("/uri/%s" % uri)
    28702871        d.addCallback(_check)
    28712872        def _check2(res):
    2872             self.failUnlessEqual(res, file_contents)
     2873            self.failUnlessReallyEqual(res, file_contents)
    28732874        d.addCallback(_check2)
    28742875        return d
    … …  
    28952896        d.addCallback(_check1)
    28962897        def _check2(data):
    2897             self.failUnlessEqual(data, file_contents)
     2898            self.failUnlessReallyEqual(data, file_contents)
    28982899            return self.GET("/uri/%s" % urllib.quote(self.filecap))
    28992900        d.addCallback(_check2)
    29002901        def _check3(res):
    2901             self.failUnlessEqual(res, file_contents)
     2902            self.failUnlessReallyEqual(res, file_contents)
    29022903        d.addCallback(_check3)
    29032904        return d
    … …  
    31023103        d = self.GET("/static/subdir/hello.txt")
    31033104        def _check(res):
    3104             self.failUnlessEqual(res, "hello")
     3105            self.failUnlessReallyEqual(res, "hello")
    31053106        d.addCallback(_check)
    31063107        return d
    31073108
    31083109
    3109 class Util(unittest.TestCase, ShouldFailMixin):
     3110class Util(ShouldFailMixin, testutil.ReallyEqualMixin, unittest.TestCase):
    31103111    def test_load_file(self):
    31113112        # This will raise an exception unless a well-formed XML file is found under that name.
    … …  
    31133114
    31143115    def test_parse_replace_arg(self):
    3115         self.failUnlessEqual(common.parse_replace_arg("true"), True)
    3116         self.failUnlessEqual(common.parse_replace_arg("false"), False)
    3117         self.failUnlessEqual(common.parse_replace_arg("only-files"),
    3118                              "only-files")
     3116        self.failUnlessReallyEqual(common.parse_replace_arg("true"), True)
     3117        self.failUnlessReallyEqual(common.parse_replace_arg("false"), False)
     3118        self.failUnlessReallyEqual(common.parse_replace_arg("only-files"),
     3119                                   "only-files")
    31193120        self.shouldFail(AssertionError, "test_parse_replace_arg", "",
    31203121                        common.parse_replace_arg, "only_fles")
    31213122
    31223123    def test_abbreviate_time(self):
    3123         self.failUnlessEqual(common.abbreviate_time(None), "")
    3124         self.failUnlessEqual(common.abbreviate_time(1.234), "1.23s")
    3125         self.failUnlessEqual(common.abbreviate_time(0.123), "123ms")
    3126         self.failUnlessEqual(common.abbreviate_time(0.00123), "1.2ms")
    3127         self.failUnlessEqual(common.abbreviate_time(0.000123), "123us")
     3124        self.failUnlessReallyEqual(common.abbreviate_time(None), "")
     3125        self.failUnlessReallyEqual(common.abbreviate_time(1.234), "1.23s")
     3126        self.failUnlessReallyEqual(common.abbreviate_time(0.123), "123ms")
     3127        self.failUnlessReallyEqual(common.abbreviate_time(0.00123), "1.2ms")
     3128        self.failUnlessReallyEqual(common.abbreviate_time(0.000123), "123us")
    31283129
    31293130    def test_abbreviate_rate(self):
    3130         self.failUnlessEqual(common.abbreviate_rate(None), "")
    3131         self.failUnlessEqual(common.abbreviate_rate(1234000), "1.23MBps")
    3132         self.failUnlessEqual(common.abbreviate_rate(12340), "12.3kBps")
    3133         self.failUnlessEqual(common.abbreviate_rate(123), "123Bps")
     3131        self.failUnlessReallyEqual(common.abbreviate_rate(None), "")
     3132        self.failUnlessReallyEqual(common.abbreviate_rate(1234000), "1.23MBps")
     3133        self.failUnlessReallyEqual(common.abbreviate_rate(12340), "12.3kBps")
     3134        self.failUnlessReallyEqual(common.abbreviate_rate(123), "123Bps")
    31343135
    31353136    def test_abbreviate_size(self):
    3136         self.failUnlessEqual(common.abbreviate_size(None), "")
    3137         self.failUnlessEqual(common.abbreviate_size(1.23*1000*1000*1000), "1.23GB")
    3138         self.failUnlessEqual(common.abbreviate_size(1.23*1000*1000), "1.23MB")
    3139         self.failUnlessEqual(common.abbreviate_size(1230), "1.2kB")
    3140         self.failUnlessEqual(common.abbreviate_size(123), "123B")
     3137        self.failUnlessReallyEqual(common.abbreviate_size(None), "")
     3138        self.failUnlessReallyEqual(common.abbreviate_size(1.23*1000*1000*1000), "1.23GB")
     3139        self.failUnlessReallyEqual(common.abbreviate_size(1.23*1000*1000), "1.23MB")
     3140        self.failUnlessReallyEqual(common.abbreviate_size(1230), "1.2kB")
     3141        self.failUnlessReallyEqual(common.abbreviate_size(123), "123B")
    31413142
    31423143    def test_plural(self):
    31433144        def convert(s):
    31443145            return "%d second%s" % (s, status.plural(s))
    3145         self.failUnlessEqual(convert(0), "0 seconds")
    3146         self.failUnlessEqual(convert(1), "1 second")
    3147         self.failUnlessEqual(convert(2), "2 seconds")
     3146        self.failUnlessReallyEqual(convert(0), "0 seconds")
     3147        self.failUnlessReallyEqual(convert(1), "1 second")
     3148        self.failUnlessReallyEqual(convert(2), "2 seconds")
    31483149        def convert2(s):
    31493150            return "has share%s: %s" % (status.plural(s), ",".join(s))
    3150         self.failUnlessEqual(convert2([]), "has shares: ")
    3151         self.failUnlessEqual(convert2(["1"]), "has share: 1")
    3152         self.failUnlessEqual(convert2(["1","2"]), "has shares: 1,2")
    3153 
    3154 
    3155 class Grid(GridTestMixin, WebErrorMixin, unittest.TestCase, ShouldFailMixin):
     3151        self.failUnlessReallyEqual(convert2([]), "has shares: ")
     3152        self.failUnlessReallyEqual(convert2(["1"]), "has share: 1")
     3153        self.failUnlessReallyEqual(convert2(["1","2"]), "has shares: 1,2")
     3154
     3155
     3156class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMixin, unittest.TestCase):
    31563157
    31573158    def CHECK(self, ign, which, args, clientnum=0):
    … …  
    31953196        def _clobber_shares(ignored):
    31963197            good_shares = self.find_shares(self.uris["good"])
    3197             self.failUnlessEqual(len(good_shares), 10)
     3198            self.failUnlessReallyEqual(len(good_shares), 10)
    31983199            sick_shares = self.find_shares(self.uris["sick"])
    31993200            os.unlink(sick_shares[0][2])
    … …  
    32233224        def _got_json_good(res):
    32243225            r = simplejson.loads(res)
    3225             self.failUnlessEqual(r["summary"], "Healthy")
     3226            self.failUnlessReallyEqual(r["summary"], "Healthy")
    32263227            self.failUnless(r["results"]["healthy"])
    32273228            self.failIf(r["results"]["needs-rebalancing"])
    … …  
    32443245        def _got_json_small(res):
    32453246            r = simplejson.loads(res)
    3246             self.failUnlessEqual(r["storage-index"], "")
     3247            self.failUnlessReallyEqual(r["storage-index"], "")
    32473248            self.failUnless(r["results"]["healthy"])
    32483249        d.addCallback(_got_json_small)
    … …  
    32563257        def _got_json_smalldir(res):
    32573258            r = simplejson.loads(res)
    3258             self.failUnlessEqual(r["storage-index"], "")
     3259            self.failUnlessReallyEqual(r["storage-index"], "")
    32593260            self.failUnless(r["results"]["healthy"])
    32603261        d.addCallback(_got_json_smalldir)
    … …  
    32673268        def _got_json_sick(res):
    32683269            r = simplejson.loads(res)
    3269             self.failUnlessEqual(r["summary"],
    3270                                  "Not Healthy: 9 shares (enc 3-of-10)")
     3270            self.failUnlessReallyEqual(r["summary"],
     3271                                       "Not Healthy: 9 shares (enc 3-of-10)")
    32713272            self.failIf(r["results"]["healthy"])
    32723273            self.failIf(r["results"]["needs-rebalancing"])
    … …  
    32813282        def _got_json_dead(res):
    32823283            r = simplejson.loads(res)
    3283             self.failUnlessEqual(r["summary"],
    3284                                  "Not Healthy: 1 shares (enc 3-of-10)")
     3284            self.failUnlessReallyEqual(r["summary"],
     3285                                       "Not Healthy: 1 shares (enc 3-of-10)")
    32853286            self.failIf(r["results"]["healthy"])
    32863287            self.failIf(r["results"]["needs-rebalancing"])
    … …  
    32993300            self.failIf(r["results"]["healthy"])
    33003301            self.failUnless(r["results"]["recoverable"])
    3301             self.failUnlessEqual(r["results"]["count-shares-good"], 9)
    3302             self.failUnlessEqual(r["results"]["count-corrupt-shares"], 1)
     3302            self.failUnlessReallyEqual(r["results"]["count-shares-good"], 9)
     3303            self.failUnlessReallyEqual(r["results"]["count-corrupt-shares"], 1)
    33033304        d.addCallback(_got_json_corrupt)
    33043305
    … …  
    33363337        def _clobber_shares(ignored):
    33373338            good_shares = self.find_shares(self.uris["good"])
    3338             self.failUnlessEqual(len(good_shares), 10)
     3339            self.failUnlessReallyEqual(len(good_shares), 10)
    33393340            sick_shares = self.find_shares(self.uris["sick"])
    33403341            os.unlink(sick_shares[0][2])
    … …  
    34103411        def _got_json_sick(res):
    34113412            r = simplejson.loads(res)
    3412             self.failUnlessEqual(r["repair-attempted"], True)
    3413             self.failUnlessEqual(r["repair-successful"], True)
    3414             self.failUnlessEqual(r["pre-repair-results"]["summary"],
    3415                                  "Not Healthy: 9 shares (enc 3-of-10)")
     3413            self.failUnlessReallyEqual(r["repair-attempted"], True)
     3414            self.failUnlessReallyEqual(r["repair-successful"], True)
     3415            self.failUnlessReallyEqual(r["pre-repair-results"]["summary"],
     3416                                       "Not Healthy: 9 shares (enc 3-of-10)")
    34163417            self.failIf(r["pre-repair-results"]["results"]["healthy"])
    3417             self.failUnlessEqual(r["post-repair-results"]["summary"], "healthy")
     3418            self.failUnlessReallyEqual(r["post-repair-results"]["summary"], "healthy")
    34183419            self.failUnless(r["post-repair-results"]["results"]["healthy"])
    34193420        d.addCallback(_got_json_sick)
    … …  
    34633464            mo = re.search(r'<a href="([^"]+)">More Info</a>', res)
    34643465            info_url = mo.group(1)
    3465             self.failUnlessEqual(info_url, "%s?t=info" % (str(name),))
     3466            self.failUnlessReallyEqual(info_url, "%s?t=info" % (str(name),))
    34663467        if immutable:
    34673468            d.addCallback(_check_directory_html, "-IMM")
    … …  
    34723473        def _check_directory_json(res, expect_rw_uri):
    34733474            data = simplejson.loads(res)
    3474             self.failUnlessEqual(data[0], "dirnode")
     3475            self.failUnlessReallyEqual(data[0], "dirnode")
    34753476            f = data[1]["children"][name]
    3476             self.failUnlessEqual(f[0], "unknown")
     3477            self.failUnlessReallyEqual(f[0], "unknown")
    34773478            if expect_rw_uri:
    3478                 self.failUnlessEqual(f[1]["rw_uri"], unknown_rwcap)
     3479                self.failUnlessReallyEqual(f[1]["rw_uri"], unknown_rwcap.decode('utf-8'))
    34793480            else:
    34803481                self.failIfIn("rw_uri", f[1])
    34813482            if immutable:
    3482                 self.failUnlessEqual(f[1]["ro_uri"], unknown_immcap, data)
     3483                self.failUnlessReallyEqual(f[1]["ro_uri"], unknown_immcap.decode('utf-8'), data)
    34833484            else:
    3484                 self.failUnlessEqual(f[1]["ro_uri"], unknown_rocap)
     3485                self.failUnlessReallyEqual(f[1]["ro_uri"], unknown_rocap.decode('utf-8'))
    34853486            self.failUnless("metadata" in f[1])
    34863487        d.addCallback(_check_directory_json, expect_rw_uri=not immutable)
    … …  
    35133514        def _check_json(res, expect_rw_uri):
    35143515            data = simplejson.loads(res)
    3515             self.failUnlessEqual(data[0], "unknown")
     3516            self.failUnlessReallyEqual(data[0], "unknown")
    35163517            if expect_rw_uri:
    3517                 self.failUnlessEqual(data[1]["rw_uri"], unknown_rwcap)
     3518                self.failUnlessReallyEqual(data[1]["rw_uri"], unknown_rwcap.decode('utf-8'))
    35183519            else:
    35193520                self.failIfIn("rw_uri", data[1])
    35203521
    35213522            if immutable:
    3522                 self.failUnlessEqual(data[1]["ro_uri"], unknown_immcap)
    3523                 self.failUnlessEqual(data[1]["mutable"], False)
     3523                self.failUnlessReallyEqual(data[1]["ro_uri"], unknown_immcap.decode('utf-8'))
     3524                self.failUnlessReallyEqual(data[1]["mutable"], False)
    35243525            elif expect_rw_uri:
    3525                 self.failUnlessEqual(data[1]["ro_uri"], unknown_rocap)
    3526                 self.failUnlessEqual(data[1]["mutable"], True)
     3526                self.failUnlessReallyEqual(data[1]["ro_uri"], unknown_rocap.decode('utf-8'))
     3527                self.failUnlessReallyEqual(data[1]["mutable"], True)
    35273528            else:
    3528                 self.failUnlessEqual(data[1]["ro_uri"], unknown_rocap)
     3529                self.failUnlessReallyEqual(data[1]["ro_uri"], unknown_rocap.decode('utf-8'))
    35293530                self.failIf("mutable" in data[1], data[1])
    35303531
    … …  
    36333634                self.failUnless(name in kids)
    36343635                (expected_child, ign) = kids[name]
    3635                 self.failUnlessEqual(ro_uri, expected_child.get_readonly_uri())
     3636                self.failUnlessReallyEqual(ro_uri, expected_child.get_readonly_uri())
    36363637                numkids += 1
    36373638
    3638             self.failUnlessEqual(numkids, 3)
     3639            self.failUnlessReallyEqual(numkids, 3)
    36393640            return self.rootnode.list()
    36403641        d.addCallback(_check_data)
    … …  
    36423643        # Now when we use the real directory listing code, the mutants should be absent.
    36433644        def _check_kids(children):
    3644             self.failUnlessEqual(sorted(children.keys()), [u"lonely"])
     3645            self.failUnlessReallyEqual(sorted(children.keys()), [u"lonely"])
    36453646            lonely_node, lonely_metadata = children[u"lonely"]
    36463647
    3647             self.failUnlessEqual(lonely_node.get_write_uri(), None)
    3648             self.failUnlessEqual(lonely_node.get_readonly_uri(), lonely_uri)
     3648            self.failUnlessReallyEqual(lonely_node.get_write_uri(), None)
     3649            self.failUnlessReallyEqual(lonely_node.get_readonly_uri(), lonely_uri)
    36493650        d.addCallback(_check_kids)
    36503651
    … …  
    36753676        def _check_json(res):
    36763677            data = simplejson.loads(res)
    3677             self.failUnlessEqual(data[0], "dirnode")
     3678            self.failUnlessReallyEqual(data[0], "dirnode")
    36783679            listed_children = data[1]["children"]
    3679             self.failUnlessEqual(sorted(listed_children.keys()), [u"lonely"])
     3680            self.failUnlessReallyEqual(sorted(listed_children.keys()), [u"lonely"])
    36803681            ll_type, ll_data = listed_children[u"lonely"]
    3681             self.failUnlessEqual(ll_type, "filenode")
     3682            self.failUnlessReallyEqual(ll_type, "filenode")
    36823683            self.failIf("rw_uri" in ll_data)
    3683             self.failUnlessEqual(ll_data["ro_uri"], lonely_uri)
     3684            self.failUnlessReallyEqual(ll_data["ro_uri"], lonely_uri)
    36843685        d.addCallback(_check_json)
    36853686        return d
    … …  
    37383739                print "undecodeable line was '%s'" % line
    37393740                raise
    3740             self.failUnlessEqual(len(units), 5+1)
     3741            self.failUnlessReallyEqual(len(units), 5+1)
    37413742            # should be parent-first
    37423743            u0 = units[0]
    3743             self.failUnlessEqual(u0["path"], [])
    3744             self.failUnlessEqual(u0["type"], "directory")
    3745             self.failUnlessEqual(u0["cap"], self.rootnode.get_uri())
     3744            self.failUnlessReallyEqual(u0["path"], [])
     3745            self.failUnlessReallyEqual(u0["type"], "directory")
     3746            self.failUnlessReallyEqual(u0["cap"], self.rootnode.get_uri())
    37463747            u0cr = u0["check-results"]
    3747             self.failUnlessEqual(u0cr["results"]["count-shares-good"], 10)
     3748            self.failUnlessReallyEqual(u0cr["results"]["count-shares-good"], 10)
    37483749
    37493750            ugood = [u for u in units
    37503751                     if u["type"] == "file" and u["path"] == [u"good"]][0]
    3751             self.failUnlessEqual(ugood["cap"], self.uris["good"])
     3752            self.failUnlessReallyEqual(ugood["cap"], self.uris["good"])
    37523753            ugoodcr = ugood["check-results"]
    3753             self.failUnlessEqual(ugoodcr["results"]["count-shares-good"], 10)
     3754            self.failUnlessReallyEqual(ugoodcr["results"]["count-shares-good"], 10)
    37543755
    37553756            stats = units[-1]
    3756             self.failUnlessEqual(stats["type"], "stats")
     3757            self.failUnlessReallyEqual(stats["type"], "stats")
    37573758            s = stats["stats"]
    3758             self.failUnlessEqual(s["count-immutable-files"], 2)
    3759             self.failUnlessEqual(s["count-literal-files"], 1)
    3760             self.failUnlessEqual(s["count-directories"], 1)
    3761             self.failUnlessEqual(s["count-unknown"], 1)
     3759            self.failUnlessReallyEqual(s["count-immutable-files"], 2)
     3760            self.failUnlessReallyEqual(s["count-literal-files"], 1)
     3761            self.failUnlessReallyEqual(s["count-directories"], 1)
     3762            self.failUnlessReallyEqual(s["count-unknown"], 1)
    37623763        d.addCallback(_done)
    37633764
    … …  
    37663767            self.failUnless(res.endswith("\n"))
    37673768            units = [simplejson.loads(t) for t in res[:-1].split("\n")]
    3768             self.failUnlessEqual(len(units), 5+1)
    3769             self.failUnlessEqual(units[-1]["type"], "stats")
     3769            self.failUnlessReallyEqual(len(units), 5+1)
     3770            self.failUnlessReallyEqual(units[-1]["type"], "stats")
    37703771            first = units[0]
    3771             self.failUnlessEqual(first["path"], [])
    3772             self.failUnlessEqual(first["cap"], self.rootnode.get_uri())
    3773             self.failUnlessEqual(first["type"], "directory")
     3772            self.failUnlessReallyEqual(first["path"], [])
     3773            self.failUnlessReallyEqual(first["cap"], self.rootnode.get_uri())
     3774            self.failUnlessReallyEqual(first["type"], "directory")
    37743775            stats = units[-1]["stats"]
    3775             self.failUnlessEqual(stats["count-immutable-files"], 2)
    3776             self.failUnlessEqual(stats["count-literal-files"], 1)
    3777             self.failUnlessEqual(stats["count-mutable-files"], 0)
    3778             self.failUnlessEqual(stats["count-immutable-files"], 2)
    3779             self.failUnlessEqual(stats["count-unknown"], 1)
     3776            self.failUnlessReallyEqual(stats["count-immutable-files"], 2)
     3777            self.failUnlessReallyEqual(stats["count-literal-files"], 1)
     3778            self.failUnlessReallyEqual(stats["count-mutable-files"], 0)
     3779            self.failUnlessReallyEqual(stats["count-immutable-files"], 2)
     3780            self.failUnlessReallyEqual(stats["count-unknown"], 1)
    37803781        d.addCallback(_check_manifest)
    37813782
    … …  
    38233824            self.failUnless(len(error_msg) > 2, error_msg_s) # some traceback
    38243825            units = [simplejson.loads(line) for line in lines[:first_error]]
    3825             self.failUnlessEqual(len(units), 6) # includes subdir
     3826            self.failUnlessReallyEqual(len(units), 6) # includes subdir
    38263827            last_unit = units[-1]
    3827             self.failUnlessEqual(last_unit["path"], ["subdir"])
     3828            self.failUnlessReallyEqual(last_unit["path"], ["subdir"])
    38283829        d.addCallback(_check_broken_manifest)
    38293830
    … …  
    38443845            self.failUnless(len(error_msg) > 2, error_msg_s) # some traceback
    38453846            units = [simplejson.loads(line) for line in lines[:first_error]]
    3846             self.failUnlessEqual(len(units), 6) # includes subdir
     3847            self.failUnlessReallyEqual(len(units), 6) # includes subdir
    38473848            last_unit = units[-1]
    3848             self.failUnlessEqual(last_unit["path"], ["subdir"])
     3849            self.failUnlessReallyEqual(last_unit["path"], ["subdir"])
    38493850            r = last_unit["check-results"]["results"]
    3850             self.failUnlessEqual(r["count-recoverable-versions"], 0)
    3851             self.failUnlessEqual(r["count-shares-good"], 1)
    3852             self.failUnlessEqual(r["recoverable"], False)
     3851            self.failUnlessReallyEqual(r["count-recoverable-versions"], 0)
     3852            self.failUnlessReallyEqual(r["count-shares-good"], 1)
     3853            self.failUnlessReallyEqual(r["recoverable"], False)
    38533854        d.addCallback(_check_broken_deepcheck)
    38543855
    … …  
    38943895        def _clobber_shares(ignored):
    38953896            good_shares = self.find_shares(self.uris["good"])
    3896             self.failUnlessEqual(len(good_shares), 10)
     3897            self.failUnlessReallyEqual(len(good_shares), 10)
    38973898            sick_shares = self.find_shares(self.uris["sick"])
    38983899            os.unlink(sick_shares[0][2])
    … …  
    39183919                     for line in res.splitlines()
    39193920                     if line]
    3920             self.failUnlessEqual(len(units), 4+1)
     3921            self.failUnlessReallyEqual(len(units), 4+1)
    39213922            # should be parent-first
    39223923            u0 = units[0]
    3923             self.failUnlessEqual(u0["path"], [])
    3924             self.failUnlessEqual(u0["type"], "directory")
    3925             self.failUnlessEqual(u0["cap"], self.rootnode.get_uri())
     3924            self.failUnlessReallyEqual(u0["path"], [])
     3925            self.failUnlessReallyEqual(u0["type"], "directory")
     3926            self.failUnlessReallyEqual(u0["cap"], self.rootnode.get_uri())
    39263927            u0crr = u0["check-and-repair-results"]
    3927             self.failUnlessEqual(u0crr["repair-attempted"], False)
    3928             self.failUnlessEqual(u0crr["pre-repair-results"]["results"]["count-shares-good"], 10)
     3928            self.failUnlessReallyEqual(u0crr["repair-attempted"], False)
     3929            self.failUnlessReallyEqual(u0crr["pre-repair-results"]["results"]["count-shares-good"], 10)
    39293930
    39303931            ugood = [u for u in units
    39313932                     if u["type"] == "file" and u["path"] == [u"good"]][0]
    3932             self.failUnlessEqual(ugood["cap"], self.uris["good"])
     3933            self.failUnlessReallyEqual(ugood["cap"], self.uris["good"])
    39333934            ugoodcrr = ugood["check-and-repair-results"]
    3934             self.failUnlessEqual(ugoodcrr["repair-attempted"], False)
    3935             self.failUnlessEqual(ugoodcrr["pre-repair-results"]["results"]["count-shares-good"], 10)
     3935            self.failUnlessReallyEqual(ugoodcrr["repair-attempted"], False)
     3936            self.failUnlessReallyEqual(ugoodcrr["pre-repair-results"]["results"]["count-shares-good"], 10)
    39363937
    39373938            usick = [u for u in units
    39383939                     if u["type"] == "file" and u["path"] == [u"sick"]][0]
    3939             self.failUnlessEqual(usick["cap"], self.uris["sick"])
     3940            self.failUnlessReallyEqual(usick["cap"], self.uris["sick"])
    39403941            usickcrr = usick["check-and-repair-results"]
    3941             self.failUnlessEqual(usickcrr["repair-attempted"], True)
    3942             self.failUnlessEqual(usickcrr["repair-successful"], True)
    3943             self.failUnlessEqual(usickcrr["pre-repair-results"]["results"]["count-shares-good"], 9)
    3944             self.failUnlessEqual(usickcrr["post-repair-results"]["results"]["count-shares-good"], 10)
     3942            self.failUnlessReallyEqual(usickcrr["repair-attempted"], True)
     3943            self.failUnlessReallyEqual(usickcrr["repair-successful"], True)
     3944            self.failUnlessReallyEqual(usickcrr["pre-repair-results"]["results"]["count-shares-good"], 9)
     3945            self.failUnlessReallyEqual(usickcrr["post-repair-results"]["results"]["count-shares-good"], 10)
    39453946
    39463947            stats = units[-1]
    3947             self.failUnlessEqual(stats["type"], "stats")
     3948            self.failUnlessReallyEqual(stats["type"], "stats")
    39483949            s = stats["stats"]
    3949             self.failUnlessEqual(s["count-immutable-files"], 2)
    3950             self.failUnlessEqual(s["count-literal-files"], 1)
    3951             self.failUnlessEqual(s["count-directories"], 1)
     3950            self.failUnlessReallyEqual(s["count-immutable-files"], 2)
     3951            self.failUnlessReallyEqual(s["count-literal-files"], 1)
     3952            self.failUnlessReallyEqual(s["count-directories"], 1)
    39523953        d.addCallback(_done)
    39533954
    … …  
    40964097                     if line]
    40974098            # root, one, small, mutable,   stats
    4098             self.failUnlessEqual(len(units), 4+1)
     4099            self.failUnlessReallyEqual(len(units), 4+1)
    40994100        d.addCallback(_done)
    41004101
    … …  
    41864187                   "this object to learn more. The full error message is: "
    41874188                   "Failed to get enough shareholders: have 0, need 3")
    4188             self.failUnlessEqual(exp, body)
     4189            self.failUnlessReallyEqual(exp, body)
    41894190        d.addCallback(_check_zero_shares)
    41904191
    … …  
    42034204                   "this object to learn more. The full error message is:"
    42044205                   " Failed to get enough shareholders: have 1, need 3")
    4205             self.failUnlessEqual(exp, body)
     4206            self.failUnlessReallyEqual(exp, body)
    42064207        d.addCallback(_check_one_share)
    42074208
    … …  
    42694270                   "departure, hard drive failure, or disk corruption. You "
    42704271                   "should perform a filecheck on this object to learn more.")
    4271             self.failUnlessEqual(exp, body)
     4272            self.failUnlessReallyEqual(exp, body)
    42724273        d.addCallback(_check_unrecoverable_file)
    42734274
Note: See TracChangeset for help on using the changeset viewer.