Fix an error-reporting problem in test_welcome (this does not fix the underlying...

[tahoe-lafs/tahoe-lafs.git] / src / allmydata / test / test_web.py
diff --git a/src/allmydata/test/test_web.py b/src/allmydata/test/test_web.py

index 033b542e4b0188872e21cdbe4293749068665ac0..18514a3a57b012bbebf4cbe3d35b9a9e9d3571cf 100644 (file)
--- a/src/allmydata/test/test_web.py
+++ b/src/allmydata/test/test_web.py
@@ -1,16 +1,22 @@
-import os.path, re, urllib, time
+import os.path, re, urllib, time, cgi
  import simplejson
  from StringIO import StringIO
  import simplejson
  from StringIO import StringIO
+
  from twisted.application import service
  from twisted.trial import unittest
  from twisted.internet import defer, reactor
  from twisted.internet.task import Clock
  from twisted.web import client, error, http
  from twisted.python import failure, log
  from twisted.application import service
  from twisted.trial import unittest
  from twisted.internet import defer, reactor
  from twisted.internet.task import Clock
  from twisted.web import client, error, http
  from twisted.python import failure, log
+
+from foolscap.api import fireEventually, flushEventualQueue
+
+from nevow.util import escapeToXML
  from nevow import rend
  from nevow import rend
+
  from allmydata import interfaces, uri, webish, dirnode
  from allmydata.storage.shares import get_share_file
  from allmydata import interfaces, uri, webish, dirnode
  from allmydata.storage.shares import get_share_file
-from allmydata.storage_client import StorageFarmBroker
+from allmydata.storage_client import StorageFarmBroker, StubServer
  from allmydata.immutable import upload
  from allmydata.immutable.downloader.status import DownloadStatus
  from allmydata.dirnode import DirectoryNode
  from allmydata.immutable import upload
  from allmydata.immutable.downloader.status import DownloadStatus
  from allmydata.dirnode import DirectoryNode
@@ -32,6 +38,7 @@ from allmydata.test.no_network import GridTestMixin
  from allmydata.test.common_web import HTTPClientGETFactory, \
       HTTPClientHEADFactory
  from allmydata.client import Client, SecretHolder
  from allmydata.test.common_web import HTTPClientGETFactory, \
       HTTPClientHEADFactory
  from allmydata.client import Client, SecretHolder
+from allmydata.introducer import IntroducerNode
  
  # create a fake uploader/downloader, and a couple of fake dirnodes, then
  # create a webserver that works against them
  
  # create a fake uploader/downloader, and a couple of fake dirnodes, then
  # create a webserver that works against them
@@ -43,7 +50,7 @@ unknown_rocap = u"ro.lafs://readonly_from_the_future_ro_\u263A".encode('utf-8')
  unknown_immcap = u"imm.lafs://immutable_from_the_future_imm_\u263A".encode('utf-8')
  
  FAVICON_MARKUP = '<link href="/icon.png" rel="shortcut icon" />'
  unknown_immcap = u"imm.lafs://immutable_from_the_future_imm_\u263A".encode('utf-8')
  
  FAVICON_MARKUP = '<link href="/icon.png" rel="shortcut icon" />'
-
+DIR_HTML_TAG = '<html lang="en">'
  
  class FakeStatsProvider:
      def get_stats(self):
  
  class FakeStatsProvider:
      def get_stats(self):
@@ -58,47 +65,55 @@ class FakeNodeMaker(NodeMaker):
          'max_segment_size':128*1024 # 1024=KiB
      }
      def _create_lit(self, cap):
          'max_segment_size':128*1024 # 1024=KiB
      }
      def _create_lit(self, cap):
-        return FakeCHKFileNode(cap)
+        return FakeCHKFileNode(cap, self.all_contents)
      def _create_immutable(self, cap):
      def _create_immutable(self, cap):
-        return FakeCHKFileNode(cap)
+        return FakeCHKFileNode(cap, self.all_contents)
      def _create_mutable(self, cap):
      def _create_mutable(self, cap):
-        return FakeMutableFileNode(None,
-                                   None,
-                                   self.encoding_params, None).init_from_cap(cap)
+        return FakeMutableFileNode(None, None,
+                                   self.encoding_params, None,
+                                   self.all_contents).init_from_cap(cap)
      def create_mutable_file(self, contents="", keysize=None,
                              version=SDMF_VERSION):
      def create_mutable_file(self, contents="", keysize=None,
                              version=SDMF_VERSION):
-        n = FakeMutableFileNode(None, None, self.encoding_params, None)
+        n = FakeMutableFileNode(None, None, self.encoding_params, None,
+                                self.all_contents)
          return n.create(contents, version=version)
  
  class FakeUploader(service.Service):
      name = "uploader"
          return n.create(contents, version=version)
  
  class FakeUploader(service.Service):
      name = "uploader"
+    helper_furl = None
+    helper_connected = False
+
      def upload(self, uploadable):
          d = uploadable.get_size()
          d.addCallback(lambda size: uploadable.read(size))
          def _got_data(datav):
              data = "".join(datav)
      def upload(self, uploadable):
          d = uploadable.get_size()
          d.addCallback(lambda size: uploadable.read(size))
          def _got_data(datav):
              data = "".join(datav)
-            n = create_chk_filenode(data)
-            results = upload.UploadResults()
-            results.uri = n.get_uri()
-            return results
+            n = create_chk_filenode(data, self.all_contents)
+            ur = upload.UploadResults(file_size=len(data),
+                                      ciphertext_fetched=0,
+                                      preexisting_shares=0,
+                                      pushed_shares=10,
+                                      sharemap={},
+                                      servermap={},
+                                      timings={},
+                                      uri_extension_data={},
+                                      uri_extension_hash="fake",
+                                      verifycapstr="fakevcap")
+            ur.set_uri(n.get_uri())
+            return ur
          d.addCallback(_got_data)
          return d
          d.addCallback(_got_data)
          return d
+
      def get_helper_info(self):
      def get_helper_info(self):
-        return (None, False)
+        return (self.helper_furl, self.helper_connected)
  
  
-class FakeIServer:
-    def __init__(self, binaryserverid):
-        self.binaryserverid = binaryserverid
-    def get_name(self): return "short"
-    def get_longname(self): return "long"
-    def get_serverid(self): return self.binaryserverid
  
  def build_one_ds():
      ds = DownloadStatus("storage_index", 1234)
      now = time.time()
  
  
  def build_one_ds():
      ds = DownloadStatus("storage_index", 1234)
      now = time.time()
  
-    serverA = FakeIServer(hashutil.tagged_hash("foo", "serverid_a")[:20])
-    serverB = FakeIServer(hashutil.tagged_hash("foo", "serverid_b")[:20])
+    serverA = StubServer(hashutil.tagged_hash("foo", "serverid_a")[:20])
+    serverB = StubServer(hashutil.tagged_hash("foo", "serverid_b")[:20])
      storage_index = hashutil.storage_index_hash("SI")
      e0 = ds.add_segment_request(0, now)
      e0.activate(now+0.5)
      storage_index = hashutil.storage_index_hash("SI")
      e0 = ds.add_segment_request(0, now)
      e0.activate(now+0.5)
@@ -156,28 +171,108 @@ class FakeHistory:
      def list_all_helper_statuses(self):
          return []
  
      def list_all_helper_statuses(self):
          return []
  
+class FakeDisplayableServer(StubServer):
+    def __init__(self, serverid, nickname, connected,
+                 last_connect_time, last_loss_time, last_rx_time):
+        StubServer.__init__(self, serverid)
+        self.announcement = {"my-version": "allmydata-tahoe-fake",
+                             "service-name": "storage",
+                             "nickname": nickname}
+        self.connected = connected
+        self.last_loss_time = last_loss_time
+        self.last_rx_time = last_rx_time
+        self.last_connect_time = last_connect_time
+    def is_connected(self):
+        return self.connected
+    def get_permutation_seed(self):
+        return ""
+    def get_remote_host(self):
+        return ""
+    def get_last_loss_time(self):
+        return self.last_loss_time
+    def get_last_received_data_time(self):
+        return self.last_rx_time
+    def get_last_connect_time(self):
+        return self.last_connect_time
+    def get_announcement(self):
+        return self.announcement
+    def get_nickname(self):
+        return self.announcement["nickname"]
+    def get_available_space(self):
+        return 123456
+
+class FakeBucketCounter(object):
+    def get_state(self):
+        return {"last-complete-bucket-count": 0}
+    def get_progress(self):
+        return {"estimated-time-per-cycle": 0,
+                "cycle-in-progress": False,
+                "remaining-wait-time": 0}
+
+class FakeLeaseChecker(object):
+    def __init__(self):
+        self.expiration_enabled = False
+        self.mode = "age"
+        self.override_lease_duration = None
+        self.sharetypes_to_expire = {}
+    def get_state(self):
+        return {"history": None}
+    def get_progress(self):
+        return {"estimated-time-per-cycle": 0,
+                "cycle-in-progress": False,
+                "remaining-wait-time": 0}
+
+class FakeStorageServer(service.MultiService):
+    name = 'storage'
+    def __init__(self, nodeid, nickname):
+        service.MultiService.__init__(self)
+        self.my_nodeid = nodeid
+        self.nickname = nickname
+        self.bucket_counter = FakeBucketCounter()
+        self.lease_checker = FakeLeaseChecker()
+    def get_stats(self):
+        return {"storage_server.accepting_immutable_shares": False}
+
  class FakeClient(Client):
      def __init__(self):
          # don't upcall to Client.__init__, since we only want to initialize a
          # minimal subset
          service.MultiService.__init__(self)
  class FakeClient(Client):
      def __init__(self):
          # don't upcall to Client.__init__, since we only want to initialize a
          # minimal subset
          service.MultiService.__init__(self)
+        self.all_contents = {}
          self.nodeid = "fake_nodeid"
          self.nodeid = "fake_nodeid"
-        self.nickname = "fake_nickname"
+        self.nickname = u"fake_nickname \u263A"
          self.introducer_furl = "None"
          self.stats_provider = FakeStatsProvider()
          self._secret_holder = SecretHolder("lease secret", "convergence secret")
          self.helper = None
          self.convergence = "some random string"
          self.storage_broker = StorageFarmBroker(None, permute_peers=True)
          self.introducer_furl = "None"
          self.stats_provider = FakeStatsProvider()
          self._secret_holder = SecretHolder("lease secret", "convergence secret")
          self.helper = None
          self.convergence = "some random string"
          self.storage_broker = StorageFarmBroker(None, permute_peers=True)
+        # fake knowledge of another server
+        self.storage_broker.test_add_server("other_nodeid",
+            FakeDisplayableServer(
+                serverid="other_nodeid", nickname=u"other_nickname \u263B", connected = True,
+                last_connect_time = 10, last_loss_time = 20, last_rx_time = 30))
+        self.storage_broker.test_add_server("disconnected_nodeid",
+            FakeDisplayableServer(
+                serverid="other_nodeid", nickname=u"disconnected_nickname \u263B", connected = False,
+                last_connect_time = 15, last_loss_time = 25, last_rx_time = 35))
          self.introducer_client = None
          self.history = FakeHistory()
          self.uploader = FakeUploader()
          self.introducer_client = None
          self.history = FakeHistory()
          self.uploader = FakeUploader()
+        self.uploader.all_contents = self.all_contents
          self.uploader.setServiceParent(self)
          self.blacklist = None
          self.nodemaker = FakeNodeMaker(None, self._secret_holder, None,
                                         self.uploader, None,
                                         None, None, None)
          self.uploader.setServiceParent(self)
          self.blacklist = None
          self.nodemaker = FakeNodeMaker(None, self._secret_holder, None,
                                         self.uploader, None,
                                         None, None, None)
+        self.nodemaker.all_contents = self.all_contents
          self.mutable_file_default = SDMF_VERSION
          self.mutable_file_default = SDMF_VERSION
+        self.addService(FakeStorageServer(self.nodeid, self.nickname))
+
+    def get_long_nodeid(self):
+        return "v0-nodeid"
+    def get_long_tubid(self):
+        return "tubid"
  
      def startService(self):
          return service.MultiService.startService(self)
  
      def startService(self):
          return service.MultiService.startService(self)
@@ -186,14 +281,16 @@ class FakeClient(Client):
  
      MUTABLE_SIZELIMIT = FakeMutableFileNode.MUTABLE_SIZELIMIT
  
  
      MUTABLE_SIZELIMIT = FakeMutableFileNode.MUTABLE_SIZELIMIT
  
-class WebMixin(object):
+class WebMixin(testutil.TimezoneMixin):
      def setUp(self):
      def setUp(self):
+        self.setTimezone('UTC-13:00')
          self.s = FakeClient()
          self.s.startService()
          self.staticdir = self.mktemp()
          self.clock = Clock()
          self.s = FakeClient()
          self.s.startService()
          self.staticdir = self.mktemp()
          self.clock = Clock()
+        self.fakeTime = 86460 # 1d 0h 1m 0s
          self.ws = webish.WebishServer(self.s, "0", staticdir=self.staticdir,
          self.ws = webish.WebishServer(self.s, "0", staticdir=self.staticdir,
-                                      clock=self.clock)
+                                      clock=self.clock, now_fn=lambda:self.fakeTime)
          self.ws.setServiceParent(self.s)
          self.webish_port = self.ws.getPortnum()
          self.webish_url = self.ws.getURL()
          self.ws.setServiceParent(self.s)
          self.webish_port = self.ws.getPortnum()
          self.webish_url = self.ws.getURL()
@@ -239,22 +336,33 @@ class WebMixin(object):
              self._sub_uri = sub_uri
              foo.set_uri(u"sub", sub_uri, sub_uri)
              sub = self.s.create_node_from_uri(sub_uri)
              self._sub_uri = sub_uri
              foo.set_uri(u"sub", sub_uri, sub_uri)
              sub = self.s.create_node_from_uri(sub_uri)
+            self._sub_node = sub
  
              _ign, n, blocking_uri = self.makefile(1)
              foo.set_uri(u"blockingfile", blocking_uri, blocking_uri)
  
  
              _ign, n, blocking_uri = self.makefile(1)
              foo.set_uri(u"blockingfile", blocking_uri, blocking_uri)
  
+            # filenode to test for html encoding issues
+            self._htmlname_unicode = u"<&weirdly'named\"file>>>_<iframe />.txt"
+            self._htmlname_raw = self._htmlname_unicode.encode('utf-8')
+            self._htmlname_urlencoded = urllib.quote(self._htmlname_raw, '')
+            self._htmlname_escaped = escapeToXML(self._htmlname_raw)
+            self._htmlname_escaped_attr = cgi.escape(self._htmlname_raw, quote=True)
+            self._htmlname_escaped_double = escapeToXML(cgi.escape(self._htmlname_raw, quote=True))
+            self.HTMLNAME_CONTENTS, n, self._htmlname_txt_uri = self.makefile(0)
+            foo.set_uri(self._htmlname_unicode, self._htmlname_txt_uri, self._htmlname_txt_uri)
+
              unicode_filename = u"n\u00fc.txt" # n u-umlaut . t x t
              # ok, unicode calls it LATIN SMALL LETTER U WITH DIAERESIS but I
              # still think of it as an umlaut
              foo.set_uri(unicode_filename, self._bar_txt_uri, self._bar_txt_uri)
  
              unicode_filename = u"n\u00fc.txt" # n u-umlaut . t x t
              # ok, unicode calls it LATIN SMALL LETTER U WITH DIAERESIS but I
              # still think of it as an umlaut
              foo.set_uri(unicode_filename, self._bar_txt_uri, self._bar_txt_uri)
  
-            _ign, n, baz_file = self.makefile(2)
+            self.SUBBAZ_CONTENTS, n, baz_file = self.makefile(2)
              self._baz_file_uri = baz_file
              sub.set_uri(u"baz.txt", baz_file, baz_file)
  
              _ign, n, self._bad_file_uri = self.makefile(3)
              # this uri should not be downloadable
              self._baz_file_uri = baz_file
              sub.set_uri(u"baz.txt", baz_file, baz_file)
  
              _ign, n, self._bad_file_uri = self.makefile(3)
              # this uri should not be downloadable
-            del FakeCHKFileNode.all_contents[self._bad_file_uri]
+            del self.s.all_contents[self._bad_file_uri]
  
              rodir = res[5][1]
              self.public_root.set_uri(u"reedownlee", rodir.get_readonly_uri(),
  
              rodir = res[5][1]
              self.public_root.set_uri(u"reedownlee", rodir.get_readonly_uri(),
@@ -267,6 +375,7 @@ class WebMixin(object):
              # public/foo/baz.txt
              # public/foo/quux.txt
              # public/foo/blockingfile
              # public/foo/baz.txt
              # public/foo/quux.txt
              # public/foo/blockingfile
+            # public/foo/<&weirdly'named\"file>>>_<iframe />.txt
              # public/foo/empty/
              # public/foo/sub/
              # public/foo/sub/baz.txt
              # public/foo/empty/
              # public/foo/sub/
              # public/foo/sub/baz.txt
@@ -281,14 +390,17 @@ class WebMixin(object):
          d.addCallback(_got_metadata)
          return d
  
          d.addCallback(_got_metadata)
          return d
  
+    def get_all_contents(self):
+        return self.s.all_contents
+
      def makefile(self, number):
          contents = "contents of file %s\n" % number
      def makefile(self, number):
          contents = "contents of file %s\n" % number
-        n = create_chk_filenode(contents)
+        n = create_chk_filenode(contents, self.get_all_contents())
          return contents, n, n.get_uri()
  
      def makefile_mutable(self, number, mdmf=False):
          contents = "contents of mutable file %s\n" % number
          return contents, n, n.get_uri()
  
      def makefile_mutable(self, number, mdmf=False):
          contents = "contents of mutable file %s\n" % number
-        n = create_mutable_filenode(contents, mdmf)
+        n = create_mutable_filenode(contents, mdmf, self.s.all_contents)
          return contents, n, n.get_uri(), n.get_readonly_uri()
  
      def tearDown(self):
          return contents, n, n.get_uri(), n.get_readonly_uri()
  
      def tearDown(self):
@@ -303,6 +415,9 @@ class WebMixin(object):
      def failUnlessIsBazDotTxt(self, res):
          self.failUnlessReallyEqual(res, self.BAZ_CONTENTS, res)
  
      def failUnlessIsBazDotTxt(self, res):
          self.failUnlessReallyEqual(res, self.BAZ_CONTENTS, res)
  
+    def failUnlessIsSubBazDotTxt(self, res):
+        self.failUnlessReallyEqual(res, self.SUBBAZ_CONTENTS, res)
+
      def failUnlessIsBarJSON(self, res):
          data = simplejson.loads(res)
          self.failUnless(isinstance(data, list))
      def failUnlessIsBarJSON(self, res):
          data = simplejson.loads(res)
          self.failUnless(isinstance(data, list))
@@ -346,8 +461,8 @@ class WebMixin(object):
  
          kidnames = sorted([unicode(n) for n in data[1]["children"]])
          self.failUnlessEqual(kidnames,
  
          kidnames = sorted([unicode(n) for n in data[1]["children"]])
          self.failUnlessEqual(kidnames,
-                             [u"bar.txt", u"baz.txt", u"blockingfile",
-                              u"empty", u"n\u00fc.txt", u"quux.txt", u"sub"])
+                             [self._htmlname_unicode, u"bar.txt", u"baz.txt",
+                              u"blockingfile", u"empty", u"n\u00fc.txt", u"quux.txt", u"sub"])
          kids = dict( [(unicode(name),value)
                        for (name,value)
                        in data[1]["children"].iteritems()] )
          kids = dict( [(unicode(name),value)
                        for (name,value)
                        in data[1]["children"].iteritems()] )
@@ -469,9 +584,16 @@ class WebMixin(object):
              if isinstance(res, failure.Failure):
                  res.trap(expected_failure)
                  if substring:
              if isinstance(res, failure.Failure):
                  res.trap(expected_failure)
                  if substring:
-                    self.failUnlessIn(substring, str(res), which)
+                    self.failUnlessIn(substring, str(res),
+                                      "'%s' not in '%s' (response is '%s') for test '%s'" % \
+                                      (substring, str(res),
+                                       getattr(res.value, "response", ""),
+                                       which))
                  if response_substring:
                  if response_substring:
-                    self.failUnlessIn(response_substring, res.value.response, which)
+                    self.failUnlessIn(response_substring, res.value.response,
+                                      "'%s' not in '%s' for test '%s'" % \
+                                      (response_substring, res.value.response,
+                                       which))
              else:
                  self.fail("%s was supposed to raise %s, not get '%s'" %
                            (which, expected_failure, res))
              else:
                  self.fail("%s was supposed to raise %s, not get '%s'" %
                            (which, expected_failure, res))
@@ -494,7 +616,6 @@ class WebMixin(object):
              self.fail("%s was supposed to Error(302), not get '%s'" %
                        (which, res))
  
              self.fail("%s was supposed to Error(302), not get '%s'" %
                        (which, res))
  
-
  class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixin, unittest.TestCase):
      def test_create(self):
          pass
  class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixin, unittest.TestCase):
      def test_create(self):
          pass
@@ -502,9 +623,24 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
      def test_welcome(self):
          d = self.GET("/")
          def _check(res):
      def test_welcome(self):
          d = self.GET("/")
          def _check(res):
-            self.failUnlessIn('Welcome To Tahoe-LAFS', res)
+            self.failUnlessIn('<title>Tahoe-LAFS - Welcome</title>', res)
              self.failUnlessIn(FAVICON_MARKUP, res)
              self.failUnlessIn(FAVICON_MARKUP, res)
-            self.failUnlessIn('href="https://tahoe-lafs.org/"', res)
+            self.failUnlessIn('<a href="status">Recent and Active Operations</a>', res)
+            self.failUnlessIn('<a href="statistics">Operational Statistics</a>', res)
+            self.failUnless(re.search('<input (type="hidden" |name="t" |value="report-incident" ){3}/>',res), res)
+            self.failUnlessIn('Page rendered at', res)
+            self.failUnlessIn('Tahoe-LAFS code imported from:', res)
+            res_u = res.decode('utf-8')
+            self.failUnlessIn(u'<td>fake_nickname \u263A</td>', res_u)
+            self.failUnlessIn(u'<div class="nickname">other_nickname \u263B</div>', res_u)
+            self.failUnlessIn(u'Connected to <span>1</span>\n              of <span>2</span> known storage servers', res_u)
+            self.failUnless(re.search(u'<div class="status-indicator"><img (src="img/connected-yes.png" |alt="Connected" ){2}/></div>\n                <a( class="timestamp"| title="1970-01-01 13:00:10"){2}>1d\u00A00h\u00A00m\u00A050s</a>', res_u), repr(res_u))
+            self.failUnless(re.search(u'<div class="status-indicator"><img (src="img/connected-no.png" |alt="Disconnected" ){2}/></div>\n                <a( class="timestamp"| title="1970-01-01 13:00:25"){2}>1d\u00A00h\u00A00m\u00A035s</a>', res_u), repr(res_u))
+            self.failUnless(re.search(u'<td class="service-last-received-data"><a( class="timestamp"| title="1970-01-01 13:00:30"){2}>1d\u00A00h\u00A00m\u00A030s</a></td>', res_u), repr(res_u))
+            self.failUnless(re.search(u'<td class="service-last-received-data"><a( class="timestamp"| title="1970-01-01 13:00:35"){2}>1d\u00A00h\u00A00m\u00A025s</a></td>', res_u), repr(res_u))
+            self.failUnlessIn(u'\u00A9 <a href="https://tahoe-lafs.org/">Tahoe-LAFS Software Foundation', res_u)
+            self.failUnlessIn('<td><h3>Available</h3></td>', res)
+            self.failUnlessIn('123.5kB', res)
  
              self.s.basedir = 'web/test_welcome'
              fileutil.make_dirs("web/test_welcome")
  
              self.s.basedir = 'web/test_welcome'
              fileutil.make_dirs("web/test_welcome")
@@ -513,6 +649,104 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(_check)
          return d
  
          d.addCallback(_check)
          return d
  
+    def test_introducer_status(self):
+        class MockIntroducerClient(object):
+            def __init__(self, connected):
+                self.connected = connected
+            def connected_to_introducer(self):
+                return self.connected
+
+        d = defer.succeed(None)
+
+        # introducer not connected, unguessable furl
+        def _set_introducer_not_connected_unguessable(ign):
+            self.s.introducer_furl = "pb://someIntroducer/secret"
+            self.s.introducer_client = MockIntroducerClient(False)
+            return self.GET("/")
+        d.addCallback(_set_introducer_not_connected_unguessable)
+        def _check_introducer_not_connected_unguessable(res):
+            html = res.replace('\n', ' ')
+            self.failUnlessIn('<div class="furl">pb://someIntroducer/[censored]</div>', html)
+            self.failIfIn('pb://someIntroducer/secret', html)
+            self.failUnless(re.search('<img (alt="Disconnected" |src="img/connected-no.png" ){2}/>', html), res)
+        d.addCallback(_check_introducer_not_connected_unguessable)
+
+        # introducer connected, unguessable furl
+        def _set_introducer_connected_unguessable(ign):
+            self.s.introducer_furl = "pb://someIntroducer/secret"
+            self.s.introducer_client = MockIntroducerClient(True)
+            return self.GET("/")
+        d.addCallback(_set_introducer_connected_unguessable)
+        def _check_introducer_connected_unguessable(res):
+            html = res.replace('\n', ' ')
+            self.failUnlessIn('<div class="furl">pb://someIntroducer/[censored]</div>', html)
+            self.failIfIn('pb://someIntroducer/secret', html)
+            self.failUnless(re.search('<img (src="img/connected-yes.png" |alt="Connected" ){2}/>', html), res)
+        d.addCallback(_check_introducer_connected_unguessable)
+
+        # introducer connected, guessable furl
+        def _set_introducer_connected_guessable(ign):
+            self.s.introducer_furl = "pb://someIntroducer/introducer"
+            self.s.introducer_client = MockIntroducerClient(True)
+            return self.GET("/")
+        d.addCallback(_set_introducer_connected_guessable)
+        def _check_introducer_connected_guessable(res):
+            html = res.replace('\n', ' ')
+            self.failUnlessIn('<div class="furl">pb://someIntroducer/introducer</div>', html)
+            self.failUnless(re.search('<img (src="img/connected-yes.png" |alt="Connected" ){2}/>', html), res)
+        d.addCallback(_check_introducer_connected_guessable)
+        return d
+
+    def test_helper_status(self):
+        d = defer.succeed(None)
+
+        # set helper furl to None
+        def _set_no_helper(ign):
+            self.s.uploader.helper_furl = None
+            return self.GET("/")
+        d.addCallback(_set_no_helper)
+        def _check_no_helper(res):
+            html = res.replace('\n', ' ')
+            self.failUnless(re.search('<img (src="img/connected-not-configured.png" |alt="Not Configured" ){2}/>', html), res)
+        d.addCallback(_check_no_helper)
+
+        # enable helper, not connected
+        def _set_helper_not_connected(ign):
+            self.s.uploader.helper_furl = "pb://someHelper/secret"
+            self.s.uploader.helper_connected = False
+            return self.GET("/")
+        d.addCallback(_set_helper_not_connected)
+        def _check_helper_not_connected(res):
+            html = res.replace('\n', ' ')
+            self.failUnlessIn('<div class="furl">pb://someHelper/[censored]</div>', html)
+            self.failIfIn('pb://someHelper/secret', html)
+            self.failUnless(re.search('<img (src="img/connected-no.png" |alt="Disconnected" ){2}/>', html), res)
+        d.addCallback(_check_helper_not_connected)
+
+        # enable helper, connected
+        def _set_helper_connected(ign):
+            self.s.uploader.helper_furl = "pb://someHelper/secret"
+            self.s.uploader.helper_connected = True
+            return self.GET("/")
+        d.addCallback(_set_helper_connected)
+        def _check_helper_connected(res):
+            html = res.replace('\n', ' ')
+            self.failUnlessIn('<div class="furl">pb://someHelper/[censored]</div>', html)
+            self.failIfIn('pb://someHelper/secret', html)
+            self.failUnless(re.search('<img (src="img/connected-yes.png" |alt="Connected" ){2}/>', html), res)
+        d.addCallback(_check_helper_connected)
+        return d
+
+    def test_storage(self):
+        d = self.GET("/storage")
+        def _check(res):
+            self.failUnlessIn('Storage Server Status', res)
+            self.failUnlessIn(FAVICON_MARKUP, res)
+            res_u = res.decode('utf-8')
+            self.failUnlessIn(u'<li>Server Nickname: <span class="nickname mine">fake_nickname \u263A</span></li>', res_u)
+        d.addCallback(_check)
+        return d
+
      def test_status(self):
          h = self.s.get_history()
          dl_num = h.list_all_download_statuses()[0].get_counter()
      def test_status(self):
          h = self.s.get_history()
          dl_num = h.list_all_download_statuses()[0].get_counter()
@@ -522,7 +756,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          ret_num = h.list_all_retrieve_statuses()[0].get_counter()
          d = self.GET("/status", followRedirect=True)
          def _check(res):
          ret_num = h.list_all_retrieve_statuses()[0].get_counter()
          d = self.GET("/status", followRedirect=True)
          def _check(res):
-            self.failUnlessIn('Upload and Download Status', res)
+            self.failUnlessIn('Recent and Active Operations', res)
              self.failUnlessIn('"down-%d"' % dl_num, res)
              self.failUnlessIn('"up-%d"' % ul_num, res)
              self.failUnlessIn('"mapupdate-%d"' % mu_num, res)
              self.failUnlessIn('"down-%d"' % dl_num, res)
              self.failUnlessIn('"up-%d"' % ul_num, res)
              self.failUnlessIn('"mapupdate-%d"' % mu_num, res)
@@ -555,11 +789,15 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
              cmpu_id = base32.b2a(hashutil.tagged_hash("foo", "serverid_b")[:20])
              # serverids[] keys are strings, since that's what JSON does, but
              # we'd really like them to be ints
              cmpu_id = base32.b2a(hashutil.tagged_hash("foo", "serverid_b")[:20])
              # serverids[] keys are strings, since that's what JSON does, but
              # we'd really like them to be ints
-            self.failUnlessEqual(data["serverids"]["0"], "phwr")
-            self.failUnless(data["serverids"].has_key("1"), data["serverids"])
-            self.failUnlessEqual(data["serverids"]["1"], "cmpu", data["serverids"])
-            self.failUnlessEqual(data["server_info"][phwr_id]["short"], "phwr")
-            self.failUnlessEqual(data["server_info"][cmpu_id]["short"], "cmpu")
+            self.failUnlessEqual(data["serverids"]["0"], "phwrsjte")
+            self.failUnless(data["serverids"].has_key("1"),
+                            str(data["serverids"]))
+            self.failUnlessEqual(data["serverids"]["1"], "cmpuvkjm",
+                                 str(data["serverids"]))
+            self.failUnlessEqual(data["server_info"][phwr_id]["short"],
+                                 "phwrsjte")
+            self.failUnlessEqual(data["server_info"][cmpu_id]["short"],
+                                 "cmpuvkjm")
              self.failUnlessIn("dyhb", data)
              self.failUnlessIn("misc", data)
          d.addCallback(_check_dl_json)
              self.failUnlessIn("dyhb", data)
              self.failUnlessIn("misc", data)
          d.addCallback(_check_dl_json)
@@ -885,6 +1123,90 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
                               self.PUT, base, "new_data"))
          return d
  
                               self.PUT, base, "new_data"))
          return d
  
+    def test_GET_etags(self):
+
+        def _check_etags(uri):
+            d1 = _get_etag(uri)
+            d2 = _get_etag(uri, 'json')
+            d = defer.DeferredList([d1, d2], consumeErrors=True)
+            def _check(results):
+                # All deferred must succeed
+                self.failUnless(all([r[0] for r in results]))
+                # the etag for the t=json form should be just like the etag
+                # fo the default t='' form, but with a 'json' suffix
+                self.failUnlessEqual(results[0][1] + 'json', results[1][1])
+            d.addCallback(_check)
+            return d
+
+        def _get_etag(uri, t=''):
+            targetbase = "/uri/%s?t=%s" % (urllib.quote(uri.strip()), t)
+            d = self.GET(targetbase, return_response=True, followRedirect=True)
+            def _just_the_etag(result):
+                data, response, headers = result
+                etag = headers['etag'][0]
+                if uri.startswith('URI:DIR'):
+                    self.failUnless(etag.startswith('DIR:'), etag)
+                return etag
+            return d.addCallback(_just_the_etag)
+
+        # Check that etags work with immutable directories
+        (newkids, caps) = self._create_immutable_children()
+        d = self.POST2(self.public_url + "/foo/newdir?t=mkdir-immutable",
+                      simplejson.dumps(newkids))
+        def _stash_immdir_uri(uri):
+            self._immdir_uri = uri
+            return uri
+        d.addCallback(_stash_immdir_uri)
+        d.addCallback(_check_etags)
+
+        # Check that etags work with immutable files
+        d.addCallback(lambda _: _check_etags(self._bar_txt_uri))
+
+        # use the ETag on GET
+        def _check_match(ign):
+            uri = "/uri/%s" % self._bar_txt_uri
+            d = self.GET(uri, return_response=True)
+            # extract the ETag
+            d.addCallback(lambda (data, code, headers):
+                          headers['etag'][0])
+            # do a GET that's supposed to match the ETag
+            d.addCallback(lambda etag:
+                          self.GET(uri, return_response=True,
+                                   headers={"If-None-Match": etag}))
+            # make sure it short-circuited (304 instead of 200)
+            d.addCallback(lambda (data, code, headers):
+                          self.failUnlessEqual(int(code), http.NOT_MODIFIED))
+            return d
+        d.addCallback(_check_match)
+
+        def _no_etag(uri, t):
+            target = "/uri/%s?t=%s" % (uri, t)
+            d = self.GET(target, return_response=True, followRedirect=True)
+            d.addCallback(lambda (data, code, headers):
+                          self.failIf("etag" in headers, target))
+            return d
+        def _yes_etag(uri, t):
+            target = "/uri/%s?t=%s" % (uri, t)
+            d = self.GET(target, return_response=True, followRedirect=True)
+            d.addCallback(lambda (data, code, headers):
+                          self.failUnless("etag" in headers, target))
+            return d
+
+        d.addCallback(lambda ign: _yes_etag(self._bar_txt_uri, ""))
+        d.addCallback(lambda ign: _yes_etag(self._bar_txt_uri, "json"))
+        d.addCallback(lambda ign: _yes_etag(self._bar_txt_uri, "uri"))
+        d.addCallback(lambda ign: _yes_etag(self._bar_txt_uri, "readonly-uri"))
+        d.addCallback(lambda ign: _no_etag(self._bar_txt_uri, "info"))
+
+        d.addCallback(lambda ign: _yes_etag(self._immdir_uri, ""))
+        d.addCallback(lambda ign: _yes_etag(self._immdir_uri, "json"))
+        d.addCallback(lambda ign: _yes_etag(self._immdir_uri, "uri"))
+        d.addCallback(lambda ign: _yes_etag(self._immdir_uri, "readonly-uri"))
+        d.addCallback(lambda ign: _no_etag(self._immdir_uri, "info"))
+        d.addCallback(lambda ign: _no_etag(self._immdir_uri, "rename-form"))
+
+        return d
+
      # TODO: version of this with a Unicode filename
      def test_GET_FILEURL_save(self):
          d = self.GET(self.public_url + "/foo/bar.txt?filename=bar.txt&save=true",
      # TODO: version of this with a Unicode filename
      def test_GET_FILEURL_save(self):
          d = self.GET(self.public_url + "/foo/bar.txt?filename=bar.txt&save=true",
@@ -1206,29 +1528,47 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
      def _check_upload_and_mkdir_forms(self, html):
          # We should have a form to create a file, with radio buttons that allow
          # the user to toggle whether it is a CHK/LIT (default), SDMF, or MDMF file.
      def _check_upload_and_mkdir_forms(self, html):
          # We should have a form to create a file, with radio buttons that allow
          # the user to toggle whether it is a CHK/LIT (default), SDMF, or MDMF file.
-        self.failUnlessIn('name="t" value="upload"', html)
-        self.failUnlessIn('input checked="checked" type="radio" id="upload-chk" value="chk" name="format"', html)
-        self.failUnlessIn('input type="radio" id="upload-sdmf" value="sdmf" name="format"', html)
-        self.failUnlessIn('input type="radio" id="upload-mdmf" value="mdmf" name="format"', html)
+        self.failUnless(re.search('<input (name="t" |value="upload" |type="hidden" ){3}/>', html), html)
+        self.failUnless(re.search('<input [^/]*id="upload-chk"', html), html)
+        self.failUnless(re.search('<input [^/]*id="upload-sdmf"', html), html)
+        self.failUnless(re.search('<input [^/]*id="upload-mdmf"', html), html)
  
          # We should also have the ability to create a mutable directory, with
          # radio buttons that allow the user to toggle whether it is an SDMF (default)
          # or MDMF directory.
  
          # We should also have the ability to create a mutable directory, with
          # radio buttons that allow the user to toggle whether it is an SDMF (default)
          # or MDMF directory.
-        self.failUnlessIn('name="t" value="mkdir"', html)
-        self.failUnlessIn('input checked="checked" type="radio" id="mkdir-sdmf" value="sdmf" name="format"', html)
-        self.failUnlessIn('input type="radio" id="mkdir-mdmf" value="mdmf" name="format"', html)
+        self.failUnless(re.search('<input (name="t" |value="mkdir" |type="hidden" ){3}/>', html), html)
+        self.failUnless(re.search('<input [^/]*id="mkdir-sdmf"', html), html)
+        self.failUnless(re.search('<input [^/]*id="mkdir-mdmf"', html), html)
  
          self.failUnlessIn(FAVICON_MARKUP, html)
  
      def test_GET_DIRECTORY_html(self):
          d = self.GET(self.public_url + "/foo", followRedirect=True)
          def _check(html):
  
          self.failUnlessIn(FAVICON_MARKUP, html)
  
      def test_GET_DIRECTORY_html(self):
          d = self.GET(self.public_url + "/foo", followRedirect=True)
          def _check(html):
-            self.failUnlessIn('<div class="toolbar-item"><a href="../../..">Return to Welcome page</a></div>', html)
+            self.failUnlessIn('<li class="toolbar-item"><a href="../../..">Return to Welcome page</a></li>', html)
              self._check_upload_and_mkdir_forms(html)
              self.failUnlessIn("quux", html)
          d.addCallback(_check)
          return d
  
              self._check_upload_and_mkdir_forms(html)
              self.failUnlessIn("quux", html)
          d.addCallback(_check)
          return d
  
+    def test_GET_DIRECTORY_html_filenode_encoding(self):
+        d = self.GET(self.public_url + "/foo", followRedirect=True)
+        def _check(html):
+            # Check if encoded entries are there
+            self.failUnlessIn('@@named=/' + self._htmlname_urlencoded + '">'
+                              + self._htmlname_escaped + '</a>', html)
+            self.failUnlessIn('value="' + self._htmlname_escaped_attr + '"', html)
+            self.failIfIn(self._htmlname_escaped_double, html)
+            # Make sure that Nevow escaping actually works by checking for unsafe characters
+            # and that '&' is escaped.
+            for entity in '<>':
+                self.failUnlessIn(entity, self._htmlname_raw)
+                self.failIfIn(entity, self._htmlname_escaped)
+            self.failUnlessIn('&', re.sub(r'&(amp|lt|gt|quot|apos);', '', self._htmlname_raw))
+            self.failIfIn('&', re.sub(r'&(amp|lt|gt|quot|apos);', '', self._htmlname_escaped))
+        d.addCallback(_check)
+        return d
+
      def test_GET_root_html(self):
          d = self.GET("/")
          d.addCallback(self._check_upload_and_mkdir_forms)
      def test_GET_root_html(self):
          d = self.GET("/")
          d.addCallback(self._check_upload_and_mkdir_forms)
@@ -1252,7 +1592,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
                                 r'\s+<td align="right">%d</td>' % len(self.BAR_CONTENTS),
                                 ])
              self.failUnless(re.search(get_bar, res), res)
                                 r'\s+<td align="right">%d</td>' % len(self.BAR_CONTENTS),
                                 ])
              self.failUnless(re.search(get_bar, res), res)
-            for label in ['unlink', 'rename']:
+            for label in ['unlink', 'rename/relink']:
                  for line in res.split("\n"):
                      # find the line that contains the relevant button for bar.txt
                      if ("form action" in line and
                  for line in res.split("\n"):
                      # find the line that contains the relevant button for bar.txt
                      if ("form action" in line and
@@ -1270,7 +1610,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
                              self.failUnlessIn('method="post"', line)
                          break
                  else:
                              self.failUnlessIn('method="post"', line)
                          break
                  else:
-                    self.fail("unable to find '%s bar.txt' line" % (label,), res)
+                    self.fail("unable to find '%s bar.txt' line" % (label,))
  
              # the DIR reference just points to a URI
              sub_url = ("%s/uri/%s/" % (ROOT, urllib.quote(self._sub_uri)))
  
              # the DIR reference just points to a URI
              sub_url = ("%s/uri/%s/" % (ROOT, urllib.quote(self._sub_uri)))
@@ -1299,7 +1639,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(lambda res: self.GET(self.public_url + "/foo/empty/"))
          def _check4(res):
              self.failUnlessIn("directory is empty", res)
          d.addCallback(lambda res: self.GET(self.public_url + "/foo/empty/"))
          def _check4(res):
              self.failUnlessIn("directory is empty", res)
-            MKDIR_BUTTON_RE=re.compile('<input type="hidden" name="t" value="mkdir" />.*<legend class="freeform-form-label">Create a new directory in this directory</legend>.*<input type="submit" value="Create" />', re.I)
+            MKDIR_BUTTON_RE=re.compile('<input (type="hidden" |name="t" |value="mkdir" ){3}/>.*<legend class="freeform-form-label">Create a new directory in this directory</legend>.*<input (type="submit" |class="btn" |value="Create" ){3}/>', re.I)
              self.failUnless(MKDIR_BUTTON_RE.search(res), res)
          d.addCallback(_check4)
  
              self.failUnless(MKDIR_BUTTON_RE.search(res), res)
          d.addCallback(_check4)
  
@@ -1451,16 +1791,16 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(self.wait_for_operation, "127")
          d.addCallback(self.get_operation_results, "127", "json")
          def _got_json(stats):
          d.addCallback(self.wait_for_operation, "127")
          d.addCallback(self.get_operation_results, "127", "json")
          def _got_json(stats):
-            expected = {"count-immutable-files": 3,
+            expected = {"count-immutable-files": 4,
                          "count-mutable-files": 2,
                          "count-literal-files": 0,
                          "count-mutable-files": 2,
                          "count-literal-files": 0,
-                        "count-files": 5,
+                        "count-files": 6,
                          "count-directories": 3,
                          "count-directories": 3,
-                        "size-immutable-files": 57,
+                        "size-immutable-files": 76,
                          "size-literal-files": 0,
                          #"size-directories": 1912, # varies
                          #"largest-directory": 1590,
                          "size-literal-files": 0,
                          #"size-directories": 1912, # varies
                          #"largest-directory": 1590,
-                        "largest-directory-children": 7,
+                        "largest-directory-children": 8,
                          "largest-immutable-file": 19,
                          }
              for k,v in expected.iteritems():
                          "largest-immutable-file": 19,
                          }
              for k,v in expected.iteritems():
@@ -1468,7 +1808,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
                                             "stats[%s] was %s, not %s" %
                                             (k, stats[k], v))
              self.failUnlessReallyEqual(stats["size-files-histogram"],
                                             "stats[%s] was %s, not %s" %
                                             (k, stats[k], v))
              self.failUnlessReallyEqual(stats["size-files-histogram"],
-                                       [ [11, 31, 3] ])
+                                       [ [11, 31, 4] ])
          d.addCallback(_got_json)
          return d
  
          d.addCallback(_got_json)
          return d
  
@@ -1477,7 +1817,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          def _check(res):
              self.failUnless(res.endswith("\n"))
              units = [simplejson.loads(t) for t in res[:-1].split("\n")]
          def _check(res):
              self.failUnless(res.endswith("\n"))
              units = [simplejson.loads(t) for t in res[:-1].split("\n")]
-            self.failUnlessReallyEqual(len(units), 9)
+            self.failUnlessReallyEqual(len(units), 10)
              self.failUnlessEqual(units[-1]["type"], "stats")
              first = units[0]
              self.failUnlessEqual(first["path"], [])
              self.failUnlessEqual(units[-1]["type"], "stats")
              first = units[0]
              self.failUnlessEqual(first["path"], [])
@@ -1719,25 +2059,6 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(self.failUnlessNodeKeysAre, [u"baz.txt"])
          return d
  
          d.addCallback(self.failUnlessNodeKeysAre, [u"baz.txt"])
          return d
  
-    def test_PUT_NEWDIRURL_mkdir_p(self):
-        d = defer.succeed(None)
-        d.addCallback(lambda res: self.POST(self.public_url + "/foo", t='mkdir', name='mkp'))
-        d.addCallback(lambda res: self.failUnlessNodeHasChild(self._foo_node, u"mkp"))
-        d.addCallback(lambda res: self._foo_node.get(u"mkp"))
-        def mkdir_p(mkpnode):
-            url = '/uri/%s?t=mkdir-p&path=/sub1/sub2' % urllib.quote(mkpnode.get_uri())
-            d = self.POST(url)
-            def made_subsub(ssuri):
-                d = self._foo_node.get_child_at_path(u"mkp/sub1/sub2")
-                d.addCallback(lambda ssnode: self.failUnlessReallyEqual(ssnode.get_uri(), ssuri))
-                d = self.POST(url)
-                d.addCallback(lambda uri2: self.failUnlessReallyEqual(uri2, ssuri))
-                return d
-            d.addCallback(made_subsub)
-            return d
-        d.addCallback(mkdir_p)
-        return d
-
      def test_PUT_NEWDIRURL_mkdirs(self):
          d = self.PUT(self.public_url + "/foo/subdir/newdir?t=mkdir", "")
          d.addCallback(lambda res:
      def test_PUT_NEWDIRURL_mkdirs(self):
          d = self.PUT(self.public_url + "/foo/subdir/newdir?t=mkdir", "")
          d.addCallback(lambda res:
@@ -1908,7 +2229,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          return d
  
      def failUnlessCHKURIHasContents(self, got_uri, contents):
          return d
  
      def failUnlessCHKURIHasContents(self, got_uri, contents):
-        self.failUnless(FakeCHKFileNode.all_contents[got_uri] == contents)
+        self.failUnless(self.get_all_contents()[got_uri] == contents)
  
      def test_POST_upload(self):
          d = self.POST(self.public_url + "/foo", t="upload",
  
      def test_POST_upload(self):
          d = self.POST(self.public_url + "/foo", t="upload",
@@ -1994,10 +2315,11 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
              self.failUnlessReallyEqual(statuscode, str(http.FOUND))
              self.failUnless(target.startswith(self.webish_url), target)
              return client.getPage(target, method="GET")
              self.failUnlessReallyEqual(statuscode, str(http.FOUND))
              self.failUnless(target.startswith(self.webish_url), target)
              return client.getPage(target, method="GET")
+        # We encode "uri" as "%75ri" to exercise a case affected by ticket #1860.
          d = self.shouldRedirect2("test_POST_upload_no_link_whendone_results",
                                   check,
                                   self.POST, "/uri", t="upload",
          d = self.shouldRedirect2("test_POST_upload_no_link_whendone_results",
                                   check,
                                   self.POST, "/uri", t="upload",
-                                 when_done="/uri/%(uri)s",
+                                 when_done="/%75ri/%(uri)s",
                                   file=("new.txt", self.NEWFILE_CONTENTS))
          d.addCallback(lambda res:
                        self.failUnlessReallyEqual(res, self.NEWFILE_CONTENTS))
                                   file=("new.txt", self.NEWFILE_CONTENTS))
          d.addCallback(lambda res:
                        self.failUnlessReallyEqual(res, self.NEWFILE_CONTENTS))
@@ -2011,7 +2333,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
              self.failUnless(filecap.startswith("URI:SSK:"), filecap)
              self.filecap = filecap
              u = uri.WriteableSSKFileURI.init_from_string(filecap)
              self.failUnless(filecap.startswith("URI:SSK:"), filecap)
              self.filecap = filecap
              u = uri.WriteableSSKFileURI.init_from_string(filecap)
-            self.failUnlessIn(u.get_storage_index(), FakeMutableFileNode.all_contents)
+            self.failUnlessIn(u.get_storage_index(), self.get_all_contents())
              n = self.s.create_node_from_uri(filecap)
              return n.download_best_version()
          d.addCallback(_check)
              n = self.s.create_node_from_uri(filecap)
              return n.download_best_version()
          d.addCallback(_check)
@@ -2341,7 +2663,8 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          # make sure that nothing was added
          d.addCallback(lambda res:
                        self.failUnlessNodeKeysAre(self._foo_node,
          # make sure that nothing was added
          d.addCallback(lambda res:
                        self.failUnlessNodeKeysAre(self._foo_node,
-                                                 [u"bar.txt", u"baz.txt", u"blockingfile",
+                                                 [self._htmlname_unicode,
+                                                  u"bar.txt", u"baz.txt", u"blockingfile",
                                                    u"empty", u"n\u00fc.txt", u"quux.txt",
                                                    u"sub"]))
          return d
                                                    u"empty", u"n\u00fc.txt", u"quux.txt",
                                                    u"sub"]))
          return d
@@ -2533,13 +2856,13 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(self.wait_for_operation, "123")
          def _check_json(data):
              self.failUnlessReallyEqual(data["finished"], True)
          d.addCallback(self.wait_for_operation, "123")
          def _check_json(data):
              self.failUnlessReallyEqual(data["finished"], True)
-            self.failUnlessReallyEqual(data["count-objects-checked"], 10)
-            self.failUnlessReallyEqual(data["count-objects-healthy"], 10)
+            self.failUnlessReallyEqual(data["count-objects-checked"], 11)
+            self.failUnlessReallyEqual(data["count-objects-healthy"], 11)
          d.addCallback(_check_json)
          d.addCallback(self.get_operation_results, "123", "html")
          def _check_html(res):
          d.addCallback(_check_json)
          d.addCallback(self.get_operation_results, "123", "html")
          def _check_html(res):
-            self.failUnlessIn("Objects Checked: <span>10</span>", res)
-            self.failUnlessIn("Objects Healthy: <span>10</span>", res)
+            self.failUnlessIn("Objects Checked: <span>11</span>", res)
+            self.failUnlessIn("Objects Healthy: <span>11</span>", res)
              self.failUnlessIn(FAVICON_MARKUP, res)
          d.addCallback(_check_html)
  
              self.failUnlessIn(FAVICON_MARKUP, res)
          d.addCallback(_check_html)
  
@@ -2569,22 +2892,22 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(self.wait_for_operation, "124")
          def _check_json(data):
              self.failUnlessReallyEqual(data["finished"], True)
          d.addCallback(self.wait_for_operation, "124")
          def _check_json(data):
              self.failUnlessReallyEqual(data["finished"], True)
-            self.failUnlessReallyEqual(data["count-objects-checked"], 10)
-            self.failUnlessReallyEqual(data["count-objects-healthy-pre-repair"], 10)
+            self.failUnlessReallyEqual(data["count-objects-checked"], 11)
+            self.failUnlessReallyEqual(data["count-objects-healthy-pre-repair"], 11)
              self.failUnlessReallyEqual(data["count-objects-unhealthy-pre-repair"], 0)
              self.failUnlessReallyEqual(data["count-corrupt-shares-pre-repair"], 0)
              self.failUnlessReallyEqual(data["count-repairs-attempted"], 0)
              self.failUnlessReallyEqual(data["count-repairs-successful"], 0)
              self.failUnlessReallyEqual(data["count-repairs-unsuccessful"], 0)
              self.failUnlessReallyEqual(data["count-objects-unhealthy-pre-repair"], 0)
              self.failUnlessReallyEqual(data["count-corrupt-shares-pre-repair"], 0)
              self.failUnlessReallyEqual(data["count-repairs-attempted"], 0)
              self.failUnlessReallyEqual(data["count-repairs-successful"], 0)
              self.failUnlessReallyEqual(data["count-repairs-unsuccessful"], 0)
-            self.failUnlessReallyEqual(data["count-objects-healthy-post-repair"], 10)
+            self.failUnlessReallyEqual(data["count-objects-healthy-post-repair"], 11)
              self.failUnlessReallyEqual(data["count-objects-unhealthy-post-repair"], 0)
              self.failUnlessReallyEqual(data["count-corrupt-shares-post-repair"], 0)
          d.addCallback(_check_json)
          d.addCallback(self.get_operation_results, "124", "html")
          def _check_html(res):
              self.failUnlessReallyEqual(data["count-objects-unhealthy-post-repair"], 0)
              self.failUnlessReallyEqual(data["count-corrupt-shares-post-repair"], 0)
          d.addCallback(_check_json)
          d.addCallback(self.get_operation_results, "124", "html")
          def _check_html(res):
-            self.failUnlessIn("Objects Checked: <span>10</span>", res)
+            self.failUnlessIn("Objects Checked: <span>11</span>", res)
  
  
-            self.failUnlessIn("Objects Healthy (before repair): <span>10</span>", res)
+            self.failUnlessIn("Objects Healthy (before repair): <span>11</span>", res)
              self.failUnlessIn("Objects Unhealthy (before repair): <span>0</span>", res)
              self.failUnlessIn("Corrupt Shares (before repair): <span>0</span>", res)
  
              self.failUnlessIn("Objects Unhealthy (before repair): <span>0</span>", res)
              self.failUnlessIn("Corrupt Shares (before repair): <span>0</span>", res)
  
@@ -2592,7 +2915,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
              self.failUnlessIn("Repairs Successful: <span>0</span>", res)
              self.failUnlessIn("Repairs Unsuccessful: <span>0</span>", res)
  
              self.failUnlessIn("Repairs Successful: <span>0</span>", res)
              self.failUnlessIn("Repairs Unsuccessful: <span>0</span>", res)
  
-            self.failUnlessIn("Objects Healthy (after repair): <span>10</span>", res)
+            self.failUnlessIn("Objects Healthy (after repair): <span>11</span>", res)
              self.failUnlessIn("Objects Unhealthy (after repair): <span>0</span>", res)
              self.failUnlessIn("Corrupt Shares (after repair): <span>0</span>", res)
  
              self.failUnlessIn("Objects Unhealthy (after repair): <span>0</span>", res)
              self.failUnlessIn("Corrupt Shares (after repair): <span>0</span>", res)
  
@@ -2840,7 +3163,8 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
      def _create_immutable_children(self):
          contents, n, filecap1 = self.makefile(12)
          md1 = {"metakey1": "metavalue1"}
      def _create_immutable_children(self):
          contents, n, filecap1 = self.makefile(12)
          md1 = {"metakey1": "metavalue1"}
-        tnode = create_chk_filenode("immutable directory contents\n"*10)
+        tnode = create_chk_filenode("immutable directory contents\n"*10,
+                                    self.get_all_contents())
          dnode = DirectoryNode(tnode, None, None)
          assert not dnode.is_mutable()
          immdircap = dnode.get_uri()
          dnode = DirectoryNode(tnode, None, None)
          assert not dnode.is_mutable()
          immdircap = dnode.get_uri()
@@ -2953,12 +3277,13 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d = self.GET("/")
          def _after_get_welcome_page(res):
              MKDIR_BUTTON_RE = re.compile(
          d = self.GET("/")
          def _after_get_welcome_page(res):
              MKDIR_BUTTON_RE = re.compile(
-                '<form action="([^"]*)" method="post".*?'
-                '<input type="hidden" name="t" value="([^"]*)" />'
-                '<input type="hidden" name="([^"]*)" value="([^"]*)" />'
-                '<input type="submit" value="Create a directory" />',
-                re.I)
-            mo = MKDIR_BUTTON_RE.search(res)
+                '<form(?: action="([^"]*)"| method="post"| enctype="multipart/form-data"){3}>.*'
+                '<input (?:type="hidden" |name="t" |value="([^"]*?)" ){3}/>[ ]*'
+                '<input (?:type="hidden" |name="([^"]*)" |value="([^"]*)" ){3}/>[ ]*'
+                '<input (type="submit" |class="btn" |value="Create a directory[^"]*" ){3}/>')
+            html = res.replace('\n', ' ')
+            mo = MKDIR_BUTTON_RE.search(html)
+            self.failUnless(mo, html)
              formaction = mo.group(1)
              formt = mo.group(2)
              formaname = mo.group(3)
              formaction = mo.group(1)
              formt = mo.group(2)
              formaname = mo.group(3)
@@ -3208,16 +3533,50 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(self.failUnlessIsEmptyJSON)
          return d
  
          d.addCallback(self.failUnlessIsEmptyJSON)
          return d
  
+    def test_POST_rename_file_no_replace_same_link(self):
+        d = self.POST(self.public_url + "/foo", t="rename",
+                      replace="false", from_name="bar.txt", to_name="bar.txt")
+        d.addCallback(lambda res: self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_rename_file_replace_only_files(self):
+        d = self.POST(self.public_url + "/foo", t="rename",
+                      replace="only-files", from_name="bar.txt",
+                      to_name="baz.txt")
+        d.addCallback(lambda res: self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/baz.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/baz.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_rename_file_replace_only_files_conflict(self):
+        d = self.shouldFail2(error.Error, "POST_relink_file_replace_only_files_conflict",
+                             "409 Conflict",
+                             "There was already a child by that name, and you asked me to not replace it.",
+                             self.POST, self.public_url + "/foo", t="relink",
+                             replace="only-files", from_name="bar.txt",
+                             to_name="empty")
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
      def failUnlessIsEmptyJSON(self, res):
          data = simplejson.loads(res)
          self.failUnlessEqual(data[0], "dirnode", data)
          self.failUnlessReallyEqual(len(data[1]["children"]), 0)
  
      def failUnlessIsEmptyJSON(self, res):
          data = simplejson.loads(res)
          self.failUnlessEqual(data[0], "dirnode", data)
          self.failUnlessReallyEqual(len(data[1]["children"]), 0)
  
-    def test_POST_rename_file_slash_fail(self):
+    def test_POST_rename_file_to_slash_fail(self):
          d = self.POST(self.public_url + "/foo", t="rename",
                        from_name="bar.txt", to_name='kirk/spock.txt')
          d.addBoth(self.shouldFail, error.Error,
          d = self.POST(self.public_url + "/foo", t="rename",
                        from_name="bar.txt", to_name='kirk/spock.txt')
          d.addBoth(self.shouldFail, error.Error,
-                  "test_POST_rename_file_slash_fail",
+                  "test_POST_rename_file_to_slash_fail",
                    "400 Bad Request",
                    "to_name= may not contain a slash",
                    )
                    "400 Bad Request",
                    "to_name= may not contain a slash",
                    )
@@ -3225,6 +3584,18 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
                        self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
          return d
  
                        self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
          return d
  
+    def test_POST_rename_file_from_slash_fail(self):
+        d = self.POST(self.public_url + "/foo", t="rename",
+                      from_name="sub/bar.txt", to_name='spock.txt')
+        d.addBoth(self.shouldFail, error.Error,
+                  "test_POST_rename_from_file_slash_fail",
+                  "400 Bad Request",
+                  "from_name= may not contain a slash",
+                  )
+        d.addCallback(lambda res:
+                      self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
+        return d
+
      def test_POST_rename_dir(self):
          d = self.POST(self.public_url, t="rename",
                        from_name="foo", to_name='plunk')
      def test_POST_rename_dir(self):
          d = self.POST(self.public_url, t="rename",
                        from_name="foo", to_name='plunk')
@@ -3236,6 +3607,241 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d.addCallback(self.failUnlessIsFooJSON)
          return d
  
          d.addCallback(self.failUnlessIsFooJSON)
          return d
  
+    def test_POST_relink_file(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt",
+                      to_dir=self.public_root.get_uri() + "/foo/sub")
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res:
+                      self.failUnlessNodeHasChild(self._sub_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_new_name(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt",
+                      to_name="wibble.txt", to_dir=self.public_root.get_uri() + "/foo/sub")
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._sub_node, u"bar.txt"))
+        d.addCallback(lambda res:
+                      self.failUnlessNodeHasChild(self._sub_node, u"wibble.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/wibble.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/wibble.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_replace(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt",
+                      to_name="baz.txt", to_dir=self.public_root.get_uri() + "/foo/sub")
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/baz.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/baz.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_no_replace(self):
+        d = self.shouldFail2(error.Error, "POST_relink_file_no_replace",
+                             "409 Conflict",
+                             "There was already a child by that name, and you asked me to not replace it",
+                             self.POST, self.public_url + "/foo", t="relink",
+                             replace="false", from_name="bar.txt",
+                             to_name="baz.txt", to_dir=self.public_root.get_uri() + "/foo/sub")
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/baz.txt"))
+        d.addCallback(self.failUnlessIsSubBazDotTxt)
+        return d
+
+    def test_POST_relink_file_no_replace_explicitly_same_link(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      replace="false", from_name="bar.txt",
+                      to_name="bar.txt", to_dir=self.public_root.get_uri() + "/foo")
+        d.addCallback(lambda res: self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_replace_only_files(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      replace="only-files", from_name="bar.txt",
+                      to_name="baz.txt", to_dir=self.public_root.get_uri() + "/foo/sub")
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/baz.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/baz.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_replace_only_files_conflict(self):
+        d = self.shouldFail2(error.Error, "POST_relink_file_replace_only_files_conflict",
+                             "409 Conflict",
+                             "There was already a child by that name, and you asked me to not replace it.",
+                             self.POST, self.public_url + "/foo", t="relink",
+                             replace="only-files", from_name="bar.txt",
+                             to_name="sub", to_dir=self.public_root.get_uri() + "/foo")
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_to_slash_fail(self):
+        d = self.shouldFail2(error.Error, "test_POST_rename_file_slash_fail",
+                             "400 Bad Request",
+                             "to_name= may not contain a slash",
+                             self.POST, self.public_url + "/foo", t="relink",
+                             from_name="bar.txt",
+                             to_name="slash/fail.txt", to_dir=self.public_root.get_uri() + "/foo/sub")
+        d.addCallback(lambda res:
+                      self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._sub_node, u"slash/fail.txt"))
+        d.addCallback(lambda ign:
+                      self.shouldFail2(error.Error,
+                                       "test_POST_rename_file_slash_fail2",
+                                       "400 Bad Request",
+                                       "from_name= may not contain a slash",
+                                       self.POST, self.public_url + "/foo",
+                                       t="relink",
+                                       from_name="nope/bar.txt",
+                                       to_name="fail.txt",
+                                       to_dir=self.public_root.get_uri() + "/foo/sub"))
+        return d
+
+    def test_POST_relink_file_explicitly_same_link(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt",
+                      to_name="bar.txt", to_dir=self.public_root.get_uri() + "/foo")
+        d.addCallback(lambda res: self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_implicitly_same_link(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt")
+        d.addCallback(lambda res: self.failUnlessNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_same_dir(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt",
+                      to_name="baz.txt", to_dir=self.public_root.get_uri() + "/foo")
+        d.addCallback(lambda res: self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.failUnlessNodeHasChild(self._sub_node, u"baz.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/baz.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/baz.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_bad_replace(self):
+        d = self.shouldFail2(error.Error, "test_POST_relink_file_bad_replace",
+                             "400 Bad Request", "invalid replace= argument: 'boogabooga'",
+                             self.POST,
+                             self.public_url + "/foo", t="relink",
+                             replace="boogabooga", from_name="bar.txt",
+                             to_dir=self.public_root.get_uri() + "/foo/sub")
+        return d
+
+    def test_POST_relink_file_multi_level(self):
+        d = self.POST(self.public_url + "/foo/sub/level2?t=mkdir", "")
+        d.addCallback(lambda res: self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt", to_dir=self.public_root.get_uri() + "/foo/sub/level2"))
+        d.addCallback(lambda res: self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.failIfNodeHasChild(self._sub_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/level2/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/level2/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_to_uri(self):
+        d = self.POST(self.public_url + "/foo", t="relink", target_type="uri",
+                      from_name="bar.txt", to_dir=self._sub_uri)
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._foo_node, u"bar.txt"))
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/sub/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_to_nonexistent_dir(self):
+        d = self.shouldFail2(error.Error, "POST_relink_file_to_nonexistent_dir",
+                            "404 Not Found", "No such child: nopechucktesta",
+                            self.POST, self.public_url + "/foo", t="relink",
+                            from_name="bar.txt",
+                            to_dir=self.public_root.get_uri() + "/nopechucktesta")
+        return d
+
+    def test_POST_relink_file_into_file(self):
+        d = self.shouldFail2(error.Error, "POST_relink_file_into_file",
+                             "400 Bad Request", "to_dir is not a directory",
+                             self.POST, self.public_url + "/foo", t="relink",
+                             from_name="bar.txt",
+                             to_dir=self.public_root.get_uri() + "/foo/baz.txt")
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/baz.txt"))
+        d.addCallback(self.failUnlessIsBazDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_file_to_bad_uri(self):
+        d =  self.shouldFail2(error.Error, "POST_relink_file_to_bad_uri",
+                              "400 Bad Request", "to_dir is not a directory",
+                              self.POST, self.public_url + "/foo", t="relink",
+                              from_name="bar.txt",
+                              to_dir="URI:DIR2:mn5jlyjnrjeuydyswlzyui72i:rmneifcj6k6sycjljjhj3f6majsq2zqffydnnul5hfa4j577arma")
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        d.addCallback(lambda res: self.GET(self.public_url + "/foo/bar.txt?t=json"))
+        d.addCallback(self.failUnlessIsBarJSON)
+        return d
+
+    def test_POST_relink_dir(self):
+        d = self.POST(self.public_url + "/foo", t="relink",
+                      from_name="bar.txt",
+                      to_dir=self.public_root.get_uri() + "/foo/empty")
+        d.addCallback(lambda res: self.POST(self.public_url + "/foo",
+                      t="relink", from_name="empty",
+                      to_dir=self.public_root.get_uri() + "/foo/sub"))
+        d.addCallback(lambda res:
+                      self.failIfNodeHasChild(self._foo_node, u"empty"))
+        d.addCallback(lambda res:
+                      self.failUnlessNodeHasChild(self._sub_node, u"empty"))
+        d.addCallback(lambda res:
+                      self._sub_node.get_child_at_path(u"empty"))
+        d.addCallback(lambda node:
+                      self.failUnlessNodeHasChild(node, u"bar.txt"))
+        d.addCallback(lambda res:
+                      self.GET(self.public_url + "/foo/sub/empty/bar.txt"))
+        d.addCallback(self.failUnlessIsBarDotTxt)
+        return d
+
      def shouldRedirect(self, res, target=None, statuscode=None, which=""):
          """ If target is not None then the redirection has to go to target.  If
          statuscode is not None then the redirection has to be accomplished with
      def shouldRedirect(self, res, target=None, statuscode=None, which=""):
          """ If target is not None then the redirection has to go to target.  If
          statuscode is not None then the redirection has to be accomplished with
@@ -3287,8 +3893,8 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d = self.GET(self.public_url + "/foo?t=rename-form&name=bar.txt",
                       followRedirect=True)
          def _check(res):
          d = self.GET(self.public_url + "/foo?t=rename-form&name=bar.txt",
                       followRedirect=True)
          def _check(res):
-            self.failUnlessIn('name="when_done" value="."', res)
-            self.failUnless(re.search(r'name="from_name" value="bar\.txt"', res))
+            self.failUnless(re.search('<input (name="when_done" |value="." |type="hidden" ){3}/>', res), res)
+            self.failUnless(re.search(r'<input (readonly="true" |type="text" |name="from_name" |value="bar\.txt" ){4}/>', res), res)
              self.failUnlessIn(FAVICON_MARKUP, res)
          d.addCallback(_check)
          return d
              self.failUnlessIn(FAVICON_MARKUP, res)
          d.addCallback(_check)
          return d
@@ -3412,12 +4018,12 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          return d
  
      def test_PUT_NEWFILEURL_bad_format(self):
          return d
  
      def test_PUT_NEWFILEURL_bad_format(self):
-       new_contents = self.NEWFILE_CONTENTS * 300000
-       return self.shouldHTTPError("PUT_NEWFILEURL_bad_format",
-                                   400, "Bad Request", "Unknown format: foo",
-                                   self.PUT, self.public_url + \
-                                   "/foo/foo.txt?format=foo",
-                                   new_contents)
+        new_contents = self.NEWFILE_CONTENTS * 300000
+        return self.shouldHTTPError("PUT_NEWFILEURL_bad_format",
+                                    400, "Bad Request", "Unknown format: foo",
+                                    self.PUT, self.public_url + \
+                                    "/foo/foo.txt?format=foo",
+                                    new_contents)
  
      def test_PUT_NEWFILEURL_uri_replace(self):
          contents, n, new_uri = self.makefile(8)
  
      def test_PUT_NEWFILEURL_uri_replace(self):
          contents, n, new_uri = self.makefile(8)
@@ -3463,8 +4069,8 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d = self.PUT("/uri", file_contents)
          def _check(uri):
              assert isinstance(uri, str), uri
          d = self.PUT("/uri", file_contents)
          def _check(uri):
              assert isinstance(uri, str), uri
-            self.failUnlessIn(uri, FakeCHKFileNode.all_contents)
-            self.failUnlessReallyEqual(FakeCHKFileNode.all_contents[uri],
+            self.failUnlessIn(uri, self.get_all_contents())
+            self.failUnlessReallyEqual(self.get_all_contents()[uri],
                                         file_contents)
              return self.GET("/uri/%s" % uri)
          d.addCallback(_check)
                                         file_contents)
              return self.GET("/uri/%s" % uri)
          d.addCallback(_check)
@@ -3478,8 +4084,8 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d = self.PUT("/uri?mutable=false", file_contents)
          def _check(uri):
              assert isinstance(uri, str), uri
          d = self.PUT("/uri?mutable=false", file_contents)
          def _check(uri):
              assert isinstance(uri, str), uri
-            self.failUnlessIn(uri, FakeCHKFileNode.all_contents)
-            self.failUnlessReallyEqual(FakeCHKFileNode.all_contents[uri],
+            self.failUnlessIn(uri, self.get_all_contents())
+            self.failUnlessReallyEqual(self.get_all_contents()[uri],
                                         file_contents)
              return self.GET("/uri/%s" % uri)
          d.addCallback(_check)
                                         file_contents)
              return self.GET("/uri/%s" % uri)
          d.addCallback(_check)
@@ -3504,7 +4110,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
              self.failUnless(filecap.startswith("URI:SSK:"), filecap)
              self.filecap = filecap
              u = uri.WriteableSSKFileURI.init_from_string(filecap)
              self.failUnless(filecap.startswith("URI:SSK:"), filecap)
              self.filecap = filecap
              u = uri.WriteableSSKFileURI.init_from_string(filecap)
-            self.failUnlessIn(u.get_storage_index(), FakeMutableFileNode.all_contents)
+            self.failUnlessIn(u.get_storage_index(), self.get_all_contents())
              n = self.s.create_node_from_uri(filecap)
              return n.download_best_version()
          d.addCallback(_check1)
              n = self.s.create_node_from_uri(filecap)
              return n.download_best_version()
          d.addCallback(_check1)
@@ -3796,7 +4402,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          d = self.POST("/report_incident", details="eek")
          def _done(res):
              self.failIfIn("<html>", res)
          d = self.POST("/report_incident", details="eek")
          def _done(res):
              self.failIfIn("<html>", res)
-            self.failUnlessIn("Thank you for your report!", res)
+            self.failUnlessIn("An incident report has been saved", res)
          d.addCallback(_done)
          return d
  
          d.addCallback(_done)
          return d
  
@@ -3814,6 +4420,58 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
          return d
  
  
          return d
  
  
+class IntroducerWeb(unittest.TestCase):
+    def setUp(self):
+        self.node = None
+
+    def tearDown(self):
+        d = defer.succeed(None)
+        if self.node:
+            d.addCallback(lambda ign: self.node.stopService())
+        d.addCallback(flushEventualQueue)
+        return d
+
+    def test_welcome(self):
+        basedir = "web.IntroducerWeb.test_welcome"
+        os.mkdir(basedir)
+        cfg = "\n".join(["[node]",
+                         "tub.location = 127.0.0.1:1",
+                         "web.port = tcp:0",
+                         ]) + "\n"
+        fileutil.write(os.path.join(basedir, "tahoe.cfg"), cfg)
+        self.node = IntroducerNode(basedir)
+        self.ws = self.node.getServiceNamed("webish")
+
+        d = fireEventually(None)
+        d.addCallback(lambda ign: self.node.startService())
+        d.addCallback(lambda ign: self.node.when_tub_ready())
+
+        d.addCallback(lambda ign: self.GET("/"))
+        def _check(res):
+            self.failUnlessIn('Welcome to the Tahoe-LAFS Introducer', res)
+            self.failUnlessIn(FAVICON_MARKUP, res)
+            self.failUnlessIn('Page rendered at', res)
+            self.failUnlessIn('Tahoe-LAFS code imported from:', res)
+        d.addCallback(_check)
+        return d
+
+    def GET(self, urlpath, followRedirect=False, return_response=False,
+            **kwargs):
+        # if return_response=True, this fires with (data, statuscode,
+        # respheaders) instead of just data.
+        assert not isinstance(urlpath, unicode)
+        url = self.ws.getURL().rstrip('/') + urlpath
+        factory = HTTPClientGETFactory(url, method="GET",
+                                       followRedirect=followRedirect, **kwargs)
+        reactor.connectTCP("localhost", self.ws.getPortnum(), factory)
+        d = factory.deferred
+        def _got_data(data):
+            return (data, factory.status, factory.response_headers)
+        if return_response:
+            d.addCallback(_got_data)
+        return factory.deferred
+
+
  class Util(ShouldFailMixin, testutil.ReallyEqualMixin, unittest.TestCase):
      def test_load_file(self):
          # This will raise an exception unless a well-formed XML file is found under that name.
  class Util(ShouldFailMixin, testutil.ReallyEqualMixin, unittest.TestCase):
      def test_load_file(self):
          # This will raise an exception unless a well-formed XML file is found under that name.
@@ -3824,8 +4482,7 @@ class Util(ShouldFailMixin, testutil.ReallyEqualMixin, unittest.TestCase):
          self.failUnlessReallyEqual(common.parse_replace_arg("false"), False)
          self.failUnlessReallyEqual(common.parse_replace_arg("only-files"),
                                     "only-files")
          self.failUnlessReallyEqual(common.parse_replace_arg("false"), False)
          self.failUnlessReallyEqual(common.parse_replace_arg("only-files"),
                                     "only-files")
-        self.shouldFail(AssertionError, "test_parse_replace_arg", "",
-                        common.parse_replace_arg, "only_fles")
+        self.failUnlessRaises(common.WebError, common.parse_replace_arg, "only_fles")
  
      def test_abbreviate_time(self):
          self.failUnlessReallyEqual(common.abbreviate_time(None), "")
  
      def test_abbreviate_time(self):
          self.failUnlessReallyEqual(common.abbreviate_time(None), "")
@@ -3892,7 +4549,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri(ur, which):
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri(ur, which):
-            self.uris[which] = ur.uri
+            self.uris[which] = ur.get_uri()
          d.addCallback(_stash_uri, "good")
          d.addCallback(lambda ign:
                        c0.upload(upload.Data(DATA+"1", convergence="")))
          d.addCallback(_stash_uri, "good")
          d.addCallback(lambda ign:
                        c0.upload(upload.Data(DATA+"1", convergence="")))
@@ -3950,7 +4607,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              r = simplejson.loads(res)
              self.failUnlessEqual(r["summary"], "Healthy")
              self.failUnless(r["results"]["healthy"])
              r = simplejson.loads(res)
              self.failUnlessEqual(r["summary"], "Healthy")
              self.failUnless(r["results"]["healthy"])
-            self.failIf(r["results"]["needs-rebalancing"])
+            self.failIfIn("needs-rebalancing", r["results"])
              self.failUnless(r["results"]["recoverable"])
          d.addCallback(_got_json_good)
  
              self.failUnless(r["results"]["recoverable"])
          d.addCallback(_got_json_good)
  
@@ -3994,8 +4651,8 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessEqual(r["summary"],
                                   "Not Healthy: 9 shares (enc 3-of-10)")
              self.failIf(r["results"]["healthy"])
              self.failUnlessEqual(r["summary"],
                                   "Not Healthy: 9 shares (enc 3-of-10)")
              self.failIf(r["results"]["healthy"])
-            self.failIf(r["results"]["needs-rebalancing"])
              self.failUnless(r["results"]["recoverable"])
              self.failUnless(r["results"]["recoverable"])
+            self.failIfIn("needs-rebalancing", r["results"])
          d.addCallback(_got_json_sick)
  
          d.addCallback(self.CHECK, "dead", "t=check")
          d.addCallback(_got_json_sick)
  
          d.addCallback(self.CHECK, "dead", "t=check")
@@ -4008,8 +4665,8 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessEqual(r["summary"],
                                   "Not Healthy: 1 shares (enc 3-of-10)")
              self.failIf(r["results"]["healthy"])
              self.failUnlessEqual(r["summary"],
                                   "Not Healthy: 1 shares (enc 3-of-10)")
              self.failIf(r["results"]["healthy"])
-            self.failIf(r["results"]["needs-rebalancing"])
              self.failIf(r["results"]["recoverable"])
              self.failIf(r["results"]["recoverable"])
+            self.failIfIn("needs-rebalancing", r["results"])
          d.addCallback(_got_json_dead)
  
          d.addCallback(self.CHECK, "corrupt", "t=check&verify=true")
          d.addCallback(_got_json_dead)
  
          d.addCallback(self.CHECK, "corrupt", "t=check&verify=true")
@@ -4022,6 +4679,8 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessIn("Unhealthy: 9 shares (enc 3-of-10)", r["summary"])
              self.failIf(r["results"]["healthy"])
              self.failUnless(r["results"]["recoverable"])
              self.failUnlessIn("Unhealthy: 9 shares (enc 3-of-10)", r["summary"])
              self.failIf(r["results"]["healthy"])
              self.failUnless(r["results"]["recoverable"])
+            self.failIfIn("needs-rebalancing", r["results"])
+            self.failUnlessReallyEqual(r["results"]["count-happiness"], 9)
              self.failUnlessReallyEqual(r["results"]["count-shares-good"], 9)
              self.failUnlessReallyEqual(r["results"]["count-corrupt-shares"], 1)
          d.addCallback(_got_json_corrupt)
              self.failUnlessReallyEqual(r["results"]["count-shares-good"], 9)
              self.failUnlessReallyEqual(r["results"]["count-corrupt-shares"], 1)
          d.addCallback(_got_json_corrupt)
@@ -4037,7 +4696,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri(ur, which):
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri(ur, which):
-            self.uris[which] = ur.uri
+            self.uris[which] = ur.get_uri()
          d.addCallback(_stash_uri, "good")
          d.addCallback(lambda ign:
                        c0.upload(upload.Data(DATA+"1", convergence="")))
          d.addCallback(_stash_uri, "good")
          d.addCallback(lambda ign:
                        c0.upload(upload.Data(DATA+"1", convergence="")))
@@ -4118,7 +4777,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA+"1", convergence=""))
          def _stash_uri(ur, which):
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA+"1", convergence=""))
          def _stash_uri(ur, which):
-            self.uris[which] = ur.uri
+            self.uris[which] = ur.get_uri()
          d.addCallback(_stash_uri, "sick")
  
          def _compute_fileurls(ignored):
          d.addCallback(_stash_uri, "sick")
  
          def _compute_fileurls(ignored):
@@ -4470,12 +5129,14 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessEqual(u0["type"], "directory")
              self.failUnlessReallyEqual(to_str(u0["cap"]), self.rootnode.get_uri())
              u0cr = u0["check-results"]
              self.failUnlessEqual(u0["type"], "directory")
              self.failUnlessReallyEqual(to_str(u0["cap"]), self.rootnode.get_uri())
              u0cr = u0["check-results"]
+            self.failUnlessReallyEqual(u0cr["results"]["count-happiness"], 10)
              self.failUnlessReallyEqual(u0cr["results"]["count-shares-good"], 10)
  
              ugood = [u for u in units
                       if u["type"] == "file" and u["path"] == [u"good"]][0]
              self.failUnlessReallyEqual(to_str(ugood["cap"]), self.uris["good"])
              ugoodcr = ugood["check-results"]
              self.failUnlessReallyEqual(u0cr["results"]["count-shares-good"], 10)
  
              ugood = [u for u in units
                       if u["type"] == "file" and u["path"] == [u"good"]][0]
              self.failUnlessReallyEqual(to_str(ugood["cap"]), self.uris["good"])
              ugoodcr = ugood["check-results"]
+            self.failUnlessReallyEqual(ugoodcr["results"]["count-happiness"], 10)
              self.failUnlessReallyEqual(ugoodcr["results"]["count-shares-good"], 10)
  
              stats = units[-1]
              self.failUnlessReallyEqual(ugoodcr["results"]["count-shares-good"], 10)
  
              stats = units[-1]
@@ -4574,6 +5235,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessEqual(last_unit["path"], ["subdir"])
              r = last_unit["check-results"]["results"]
              self.failUnlessReallyEqual(r["count-recoverable-versions"], 0)
              self.failUnlessEqual(last_unit["path"], ["subdir"])
              r = last_unit["check-results"]["results"]
              self.failUnlessReallyEqual(r["count-recoverable-versions"], 0)
+            self.failUnlessReallyEqual(r["count-happiness"], 1)
              self.failUnlessReallyEqual(r["count-shares-good"], 1)
              self.failUnlessReallyEqual(r["recoverable"], False)
          d.addCallback(_check_broken_deepcheck)
              self.failUnlessReallyEqual(r["count-shares-good"], 1)
              self.failUnlessReallyEqual(r["recoverable"], False)
          d.addCallback(_check_broken_deepcheck)
@@ -4651,6 +5313,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessReallyEqual(to_str(u0["cap"]), self.rootnode.get_uri())
              u0crr = u0["check-and-repair-results"]
              self.failUnlessReallyEqual(u0crr["repair-attempted"], False)
              self.failUnlessReallyEqual(to_str(u0["cap"]), self.rootnode.get_uri())
              u0crr = u0["check-and-repair-results"]
              self.failUnlessReallyEqual(u0crr["repair-attempted"], False)
+            self.failUnlessReallyEqual(u0crr["pre-repair-results"]["results"]["count-happiness"], 10)
              self.failUnlessReallyEqual(u0crr["pre-repair-results"]["results"]["count-shares-good"], 10)
  
              ugood = [u for u in units
              self.failUnlessReallyEqual(u0crr["pre-repair-results"]["results"]["count-shares-good"], 10)
  
              ugood = [u for u in units
@@ -4658,6 +5321,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.failUnlessEqual(to_str(ugood["cap"]), self.uris["good"])
              ugoodcrr = ugood["check-and-repair-results"]
              self.failUnlessReallyEqual(ugoodcrr["repair-attempted"], False)
              self.failUnlessEqual(to_str(ugood["cap"]), self.uris["good"])
              ugoodcrr = ugood["check-and-repair-results"]
              self.failUnlessReallyEqual(ugoodcrr["repair-attempted"], False)
+            self.failUnlessReallyEqual(ugoodcrr["pre-repair-results"]["results"]["count-happiness"], 10)
              self.failUnlessReallyEqual(ugoodcrr["pre-repair-results"]["results"]["count-shares-good"], 10)
  
              usick = [u for u in units
              self.failUnlessReallyEqual(ugoodcrr["pre-repair-results"]["results"]["count-shares-good"], 10)
  
              usick = [u for u in units
@@ -4666,7 +5330,9 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              usickcrr = usick["check-and-repair-results"]
              self.failUnlessReallyEqual(usickcrr["repair-attempted"], True)
              self.failUnlessReallyEqual(usickcrr["repair-successful"], True)
              usickcrr = usick["check-and-repair-results"]
              self.failUnlessReallyEqual(usickcrr["repair-attempted"], True)
              self.failUnlessReallyEqual(usickcrr["repair-successful"], True)
+            self.failUnlessReallyEqual(usickcrr["pre-repair-results"]["results"]["count-happiness"], 9)
              self.failUnlessReallyEqual(usickcrr["pre-repair-results"]["results"]["count-shares-good"], 9)
              self.failUnlessReallyEqual(usickcrr["pre-repair-results"]["results"]["count-shares-good"], 9)
+            self.failUnlessReallyEqual(usickcrr["post-repair-results"]["results"]["count-happiness"], 10)
              self.failUnlessReallyEqual(usickcrr["post-repair-results"]["results"]["count-shares-good"], 10)
  
              stats = units[-1]
              self.failUnlessReallyEqual(usickcrr["post-repair-results"]["results"]["count-shares-good"], 10)
  
              stats = units[-1]
@@ -4704,7 +5370,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri(ur, which):
          DATA = "data" * 100
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri(ur, which):
-            self.uris[which] = ur.uri
+            self.uris[which] = ur.get_uri()
          d.addCallback(_stash_uri, "one")
          d.addCallback(lambda ign:
                        c0.upload(upload.Data(DATA+"1", convergence="")))
          d.addCallback(_stash_uri, "one")
          d.addCallback(lambda ign:
                        c0.upload(upload.Data(DATA+"1", convergence="")))
@@ -4862,7 +5528,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          self.basedir = "web/Grid/exceptions"
          self.set_up_grid(num_clients=1, num_servers=2)
          c0 = self.g.clients[0]
          self.basedir = "web/Grid/exceptions"
          self.set_up_grid(num_clients=1, num_servers=2)
          c0 = self.g.clients[0]
-        c0.DEFAULT_ENCODING_PARAMETERS['happy'] = 2
+        c0.encoding_params['happy'] = 2
          self.fileurls = {}
          DATA = "data" * 100
          d = c0.create_dirnode()
          self.fileurls = {}
          DATA = "data" * 100
          d = c0.create_dirnode()
@@ -4873,10 +5539,10 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          d.addCallback(_stash_root)
          d.addCallback(lambda ign: c0.upload(upload.Data(DATA, convergence="")))
          def _stash_bad(ur):
          d.addCallback(_stash_root)
          d.addCallback(lambda ign: c0.upload(upload.Data(DATA, convergence="")))
          def _stash_bad(ur):
-            self.fileurls["1share"] = "uri/" + urllib.quote(ur.uri)
-            self.delete_shares_numbered(ur.uri, range(1,10))
+            self.fileurls["1share"] = "uri/" + urllib.quote(ur.get_uri())
+            self.delete_shares_numbered(ur.get_uri(), range(1,10))
  
  
-            u = uri.from_string(ur.uri)
+            u = uri.from_string(ur.get_uri())
              u.key = testutil.flip_bit(u.key, 0)
              baduri = u.to_string()
              self.fileurls["0shares"] = "uri/" + urllib.quote(baduri)
              u.key = testutil.flip_bit(u.key, 0)
              baduri = u.to_string()
              self.fileurls["0shares"] = "uri/" + urllib.quote(baduri)
@@ -4951,7 +5617,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
  
          d.addCallback(lambda ignored: self.GET(self.fileurls["dir-0share"]))
          def _check_0shares_dir_html(body):
  
          d.addCallback(lambda ignored: self.GET(self.fileurls["dir-0share"]))
          def _check_0shares_dir_html(body):
-            self.failUnlessIn("<html>", body)
+            self.failUnlessIn(DIR_HTML_TAG, body)
              # we should see the regular page, but without the child table or
              # the dirops forms
              body = " ".join(body.strip().split())
              # we should see the regular page, but without the child table or
              # the dirops forms
              body = " ".join(body.strip().split())
@@ -4974,7 +5640,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              # and some-shares like we did for immutable files (since there
              # are different sorts of advice to offer in each case). For now,
              # they present the same way.
              # and some-shares like we did for immutable files (since there
              # are different sorts of advice to offer in each case). For now,
              # they present the same way.
-            self.failUnlessIn("<html>", body)
+            self.failUnlessIn(DIR_HTML_TAG, body)
              body = " ".join(body.strip().split())
              self.failUnlessIn('href="?t=info">More info on this directory',
                                body)
              body = " ".join(body.strip().split())
              self.failUnlessIn('href="?t=info">More info on this directory',
                                body)
@@ -5033,7 +5699,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
                        self.shouldHTTPError("GET errorboom_html",
                                             500, "Internal Server Error", None,
                                             self.GET, "ERRORBOOM",
                        self.shouldHTTPError("GET errorboom_html",
                                             500, "Internal Server Error", None,
                                             self.GET, "ERRORBOOM",
-                                           headers={"accept": ["*/*"]}))
+                                           headers={"accept": "*/*"}))
          def _internal_error_html1(body):
              self.failUnlessIn("<html>", "expected HTML, not '%s'" % body)
          d.addCallback(_internal_error_html1)
          def _internal_error_html1(body):
              self.failUnlessIn("<html>", "expected HTML, not '%s'" % body)
          d.addCallback(_internal_error_html1)
@@ -5042,7 +5708,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
                        self.shouldHTTPError("GET errorboom_text",
                                             500, "Internal Server Error", None,
                                             self.GET, "ERRORBOOM",
                        self.shouldHTTPError("GET errorboom_text",
                                             500, "Internal Server Error", None,
                                             self.GET, "ERRORBOOM",
-                                           headers={"accept": ["text/plain"]}))
+                                           headers={"accept": "text/plain"}))
          def _internal_error_text2(body):
              self.failIfIn("<html>", body)
              self.failUnless(body.startswith("Traceback "), body)
          def _internal_error_text2(body):
              self.failIfIn("<html>", body)
              self.failUnless(body.startswith("Traceback "), body)
@@ -5053,7 +5719,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
                        self.shouldHTTPError("GET errorboom_text",
                                             500, "Internal Server Error", None,
                                             self.GET, "ERRORBOOM",
                        self.shouldHTTPError("GET errorboom_text",
                                             500, "Internal Server Error", None,
                                             self.GET, "ERRORBOOM",
-                                           headers={"accept": [CLI_accepts]}))
+                                           headers={"accept": CLI_accepts}))
          def _internal_error_text3(body):
              self.failIfIn("<html>", body)
              self.failUnless(body.startswith("Traceback "), body)
          def _internal_error_text3(body):
              self.failIfIn("<html>", body)
              self.failUnless(body.startswith("Traceback "), body)
@@ -5087,7 +5753,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
  
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri_and_create_dir(ur):
  
          d = c0.upload(upload.Data(DATA, convergence=""))
          def _stash_uri_and_create_dir(ur):
-            self.uri = ur.uri
+            self.uri = ur.get_uri()
              self.url = "uri/"+self.uri
              u = uri.from_string_filenode(self.uri)
              self.si = u.get_storage_index()
              self.url = "uri/"+self.uri
              u = uri.from_string_filenode(self.uri)
              self.si = u.get_storage_index()
@@ -5101,7 +5767,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          d.addCallback(_stash_dir)
          d.addCallback(lambda ign: self.GET(self.dir_url, followRedirect=True))
          def _check_dir_html(body):
          d.addCallback(_stash_dir)
          d.addCallback(lambda ign: self.GET(self.dir_url, followRedirect=True))
          def _check_dir_html(body):
-            self.failUnlessIn("<html>", body)
+            self.failUnlessIn(DIR_HTML_TAG, body)
              self.failUnlessIn("blacklisted.txt</a>", body)
          d.addCallback(_check_dir_html)
          d.addCallback(lambda ign: self.GET(self.url))
              self.failUnlessIn("blacklisted.txt</a>", body)
          d.addCallback(_check_dir_html)
          d.addCallback(lambda ign: self.GET(self.url))
@@ -5125,7 +5791,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
          # We should still be able to list the parent directory, in HTML...
          d.addCallback(lambda ign: self.GET(self.dir_url, followRedirect=True))
          def _check_dir_html2(body):
          # We should still be able to list the parent directory, in HTML...
          d.addCallback(lambda ign: self.GET(self.dir_url, followRedirect=True))
          def _check_dir_html2(body):
-            self.failUnlessIn("<html>", body)
+            self.failUnlessIn(DIR_HTML_TAG, body)
              self.failUnlessIn("blacklisted.txt</strike>", body)
          d.addCallback(_check_dir_html2)
  
              self.failUnlessIn("blacklisted.txt</strike>", body)
          d.addCallback(_check_dir_html2)
  
@@ -5176,7 +5842,7 @@ class Grid(GridTestMixin, WebErrorMixin, ShouldFailMixin, testutil.ReallyEqualMi
              self.child_url = "uri/"+dn.get_readonly_uri()+"/child"
          d.addCallback(_get_dircap)
          d.addCallback(lambda ign: self.GET(self.dir_url_base, followRedirect=True))
              self.child_url = "uri/"+dn.get_readonly_uri()+"/child"
          d.addCallback(_get_dircap)
          d.addCallback(lambda ign: self.GET(self.dir_url_base, followRedirect=True))
-        d.addCallback(lambda body: self.failUnlessIn("<html>", body))
+        d.addCallback(lambda body: self.failUnlessIn(DIR_HTML_TAG, body))
          d.addCallback(lambda ign: self.GET(self.dir_url_json1))
          d.addCallback(lambda res: simplejson.loads(res))  # just check it decodes
          d.addCallback(lambda ign: self.GET(self.dir_url_json2))
          d.addCallback(lambda ign: self.GET(self.dir_url_json1))
          d.addCallback(lambda res: simplejson.loads(res))  # just check it decodes
          d.addCallback(lambda ign: self.GET(self.dir_url_json2))