Preserve write buffer when raw.write() returns None on blocked socket

Add a check in cheroot.makefile.BufferedWriter._flush_unlocked to prevent
clearing of the write buffer when raw.write() returns None due to a blocked
stream. Also limits each write call to SOCK_WRITE_BLOCKSIZE bytes, which
was defined but not previously used in this method.

Author: cbbm142

cheroot/makefile.py

@@ -26,13 +26,17 @@ def write(self, b):
     def _flush_unlocked(self):
         self._checkClosed('flush of closed file')
         while self._write_buf:
+            n = None
             try:
                 # ssl sockets only except 'bytes', not bytearrays
                 # so perhaps we should conditionally wrap this for perf?
-                n = self.raw.write(bytes(self._write_buf))
+                n = self.raw.write(
+                    bytes(self._write_buf[:SOCK_WRITE_BLOCKSIZE]),
+                )
             except io.BlockingIOError as e:
                 n = e.characters_written
-            del self._write_buf[:n]
+            if n:
+                del self._write_buf[:n]
 
 
 class StreamReader(io.BufferedReader):

cheroot/test/test_makefile.py

@@ -51,3 +51,39 @@ def test_bytes_written():
     wfile = makefile.MakeFile(sock, 'w')
     wfile.write(b'bar')
     assert wfile.bytes_written == 3
+
+
+def test_flush_preserves_data_when_raw_write_returns_none():
+    """_flush_unlocked() must not treat None from raw.write() as a byte count.
+
+    io.RawIOBase.write() returns None when a non-blocking socket cannot accept
+    data. del self._write_buf[:None] is equivalent to del self._write_buf[:]
+    which silently clears the entire buffer, truncating the response without
+    raising an exception.
+    """
+    data = b'x' * 32768  # larger than SOCK_WRITE_BLOCKSIZE to stress the loop
+
+    sock = MockSocket()
+    wfile = makefile.MakeFile(sock, 'w')
+    wfile._write_buf.extend(data)
+
+    written = bytearray()
+    call_count = 0
+
+    def mock_raw_write(b):
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            return (
+                None  # simulates socket returning None on first blocked write
+            )
+        written.extend(b)
+        return len(b)
+
+    wfile.raw.write = mock_raw_write
+    wfile._flush_unlocked()
+
+    assert bytes(written) == data, (
+        f'Expected {len(data)} bytes but only {len(written)} reached raw.write(): '
+        'buffer was silently discarded when raw.write() returned None'
+    )