Add a test for `remote_add_lease` with respect to reserved space

src/allmydata/interfaces.py

@@ -52,6 +52,8 @@ WriteEnablerSecret = Hash # used to protect mutable share modifications
 LeaseRenewSecret = Hash # used to protect lease renewal requests
 LeaseCancelSecret = Hash # was used to protect lease cancellation requests
 
+class NoSpace(Exception):
+    """Storage space was not available for a space-allocating operation."""
 
 class DataTooLargeError(Exception):
     """The write went past the expected size of the bucket."""

src/allmydata/test/common.py

@@ -87,6 +87,7 @@ from allmydata.interfaces import (
     SDMF_VERSION,
     MDMF_VERSION,
     IAddressFamily,
+    NoSpace,
 )
 from allmydata.check_results import CheckResults, CheckAndRepairResults, \
      DeepCheckResults, DeepCheckAndRepairResults
@@ -139,6 +140,42 @@ EMPTY_CLIENT_CONFIG = config_from_string(
     ""
 )
 
+@attr.s
+class FakeDisk(object):
+    """
+    Just enough of a disk to be able to report free / used information.
+    """
+    total = attr.ib()
+    used = attr.ib()
+
+    def use(self, num_bytes):
+        """
+        Mark some amount of available bytes as used (and no longer available).
+
+        :param int num_bytes: The number of bytes to use.
+
+        :raise NoSpace: If there are fewer bytes available than ``num_bytes``.
+
+        :return: ``None``
+        """
+        if num_bytes > self.total - self.used:
+            raise NoSpace()
+        self.used += num_bytes
+
+    @property
+    def available(self):
+        return self.total - self.used
+
+    def get_disk_stats(self, whichdir, reserved_space):
+        avail = self.available
+        return {
+            'total': self.total,
+            'free_for_root': avail,
+            'free_for_nonroot': avail,
+            'used': self.used,
+            'avail': avail - reserved_space,
+        }
+
 
 @attr.s
 class MemoryIntroducerClient(object):

src/allmydata/test/common_storage.py

@@ -0,0 +1,33 @@
+
+from .common_util import (
+    FakeCanary,
+)
+
+def upload_immutable(storage_server, storage_index, renew_secret, cancel_secret, shares):
+    """
+    Synchronously upload some immutable shares to a ``StorageServer``.
+
+    :param allmydata.storage.server.StorageServer storage_server: The storage
+        server object to use to perform the upload.
+
+    :param bytes storage_index: The storage index for the immutable shares.
+
+    :param bytes renew_secret: The renew secret for the implicitly created lease.
+    :param bytes cancel_secret: The cancel secret for the implicitly created lease.
+
+    :param dict[int, bytes] shares: A mapping from share numbers to share data
+        to upload.  The data for all shares must be of the same length.
+
+    :return: ``None``
+    """
+    already, writers = storage_server.remote_allocate_buckets(
+        storage_index,
+        renew_secret,
+        cancel_secret,
+        shares.keys(),
+        len(next(iter(shares.values()))),
+        canary=FakeCanary(),
+    )
+    for shnum, writer in writers.items():
+        writer.remote_write(0, shares[shnum])
+        writer.remote_close()

src/allmydata/test/test_storage.py

@@ -60,8 +60,15 @@ from allmydata.test.no_network import NoNetworkServer
 from allmydata.storage_client import (
     _StorageServer,
 )
-from .common import LoggingServiceParent, ShouldFailMixin
+from .common import (
+    LoggingServiceParent,
+    ShouldFailMixin,
+    FakeDisk,
+)
 from .common_util import FakeCanary
+from .common_storage import (
+    upload_immutable,
+)
 from .strategies import (
     offsets,
     lengths,
@@ -651,6 +658,32 @@ class Server(unittest.TestCase):
         self.failUnlessEqual(already, set())
         self.failUnlessEqual(set(writers.keys()), set([0,1,2]))
 
+    def test_reserved_space_immutable_lease(self):
+        """
+        If there is not enough available space to store an additional lease then
+        ``remote_add_lease`` fails with ``NoSpace`` when an attempt is made to
+        use it to create a new lease.
+        """
+        disk = FakeDisk(total=1024, used=0)
+        self.patch(fileutil, "get_disk_stats", disk.get_disk_stats)
+
+        ss = self.create("test_reserved_space_immutable_lease")
+
+        storage_index = b"x" * 16
+        renew_secret = b"r" * 32
+        cancel_secret = b"c" * 32
+        shares = {0: b"y" * 500}
+        upload_immutable(ss, storage_index, renew_secret, cancel_secret, shares)
+
+        # use up all the available space
+        disk.use(disk.available)
+
+        # Different secrets to produce a different lease, not a renewal.
+        renew_secret = b"R" * 32
+        cancel_secret = b"C" * 32
+        with self.assertRaises(interfaces.NoSpace):
+            ss.remote_add_lease(storage_index, renew_secret, cancel_secret)
+
     def test_reserved_space(self):
         reserved = 10000
         allocated = 0