Teach StorageFarmBroker to fire a deferred when a connection threshold is reached...

[tahoe-lafs/tahoe-lafs.git] / src / allmydata / test / test_helper.py

diff --git a/src/allmydata/test/test_helper.py b/src/allmydata/test/test_helper.py
index c0851f8cae3a6a5b75439d4d603befd927bdb007..7b6c53eee2c9a749fb03265629120eefaba99e35 100644 (file)
--- a/src/allmydata/test/test_helper.py
+++ b/src/allmydata/test/test_helper.py
@@ -22,24 +22,36 @@ class CHKUploadHelper_fake(offloaded.CHKUploadHelper):
         def _got_size(size):
             d2 = eu.get_all_encoding_parameters()
             def _got_parms(parms):
+                # just pretend we did the upload
                 needed_shares, happy, total_shares, segsize = parms
                 ueb_data = {"needed_shares": needed_shares,
                             "total_shares": total_shares,
                             "segment_size": segsize,
                             "size": size,
                             }
-                self._results.uri_extension_data = ueb_data
-                self._results.verifycapstr = uri.CHKFileVerifierURI(self._storage_index, "x"*32,
-                                                                 needed_shares, total_shares,
-                                                                 size).to_string()
-                return self._results
+                ueb_hash = "fake"
+                v = uri.CHKFileVerifierURI(self._storage_index, "x"*32,
+                                           needed_shares, total_shares, size)
+                _UR = upload.UploadResults
+                ur = _UR(file_size=size,
+                         ciphertext_fetched=0,
+                         preexisting_shares=0,
+                         pushed_shares=total_shares,
+                         sharemap={},
+                         servermap={},
+                         timings={},
+                         uri_extension_data=ueb_data,
+                         uri_extension_hash=ueb_hash,
+                         verifycapstr=v.to_string())
+                self._upload_status.set_results(ur)
+                return ur
             d2.addCallback(_got_parms)
             return d2
         d.addCallback(_got_size)
         return d
 
 class Helper_fake_upload(offloaded.Helper):
-    def _make_chk_upload_helper(self, storage_index, r, lp):
+    def _make_chk_upload_helper(self, storage_index, lp):
         si_s = si_b2a(storage_index)
         incoming_file = os.path.join(self._chk_incoming, si_s)
         encoding_file = os.path.join(self._chk_encoding, si_s)
@@ -47,12 +59,12 @@ class Helper_fake_upload(offloaded.Helper):
                                   self._storage_broker,
                                   self._secret_holder,
                                   incoming_file, encoding_file,
-                                  r, lp)
+                                  lp)
         return uh
 
 class Helper_already_uploaded(Helper_fake_upload):
-    def _check_chk(self, storage_index, results, lp):
-        res = upload.UploadResults()
+    def _check_chk(self, storage_index, lp):
+        res = upload.HelperUploadResults()
         res.uri_extension_hash = hashutil.uri_extension_hash("")
 
         # we're pretending that the file they're trying to upload was already
@@ -77,6 +89,8 @@ class FakeClient(service.MultiService):
 
     def get_encoding_parameters(self):
         return self.DEFAULT_ENCODING_PARAMETERS
+    def get_storage_broker(self):
+        return self.storage_broker
 
 def flush_but_dont_ignore(res):
     d = flushEventualQueue()
@@ -102,8 +116,8 @@ class AssistedUpload(unittest.TestCase):
     timeout = 240 # It takes longer than 120 seconds on Francois's arm box.
     def setUp(self):
         self.s = FakeClient()
-        self.storage_broker = StorageFarmBroker(None, True)
-        self.secret_holder = client.SecretHolder("lease secret", "convergence")
+        self.s.storage_broker = StorageFarmBroker(None, True, 0, None)
+        self.s.secret_holder = client.SecretHolder("lease secret", "converge")
         self.s.startService()
 
         self.tub = t = Tub()
@@ -117,8 +131,8 @@ class AssistedUpload(unittest.TestCase):
     def setUpHelper(self, basedir, helper_class=Helper_fake_upload):
         fileutil.make_dirs(basedir)
         self.helper = h = helper_class(basedir,
-                                       self.storage_broker,
-                                       self.secret_holder,
+                                       self.s.storage_broker,
+                                       self.s.secret_holder,
                                        None, None)
         self.helper_furl = self.tub.registerReference(h)
 
@@ -143,7 +157,7 @@ class AssistedUpload(unittest.TestCase):
             return upload_data(u, DATA, convergence="some convergence string")
         d.addCallback(_ready)
         def _uploaded(results):
-            the_uri = results.uri
+            the_uri = results.get_uri()
             assert "CHK" in the_uri
         d.addCallback(_uploaded)
 
@@ -193,7 +207,7 @@ class AssistedUpload(unittest.TestCase):
             return upload_data(u, DATA, convergence="test convergence string")
         d.addCallback(_ready)
         def _uploaded(results):
-            the_uri = results.uri
+            the_uri = results.get_uri()
             assert "CHK" in the_uri
         d.addCallback(_uploaded)
 
@@ -220,7 +234,7 @@ class AssistedUpload(unittest.TestCase):
             return upload_data(u, DATA, convergence="some convergence string")
         d.addCallback(_ready)
         def _uploaded(results):
-            the_uri = results.uri
+            the_uri = results.get_uri()
             assert "CHK" in the_uri
         d.addCallback(_uploaded)