Add more tests for coverage and preventing regressions.

Author: mindflayer

mocket/socket.py

@@ -449,6 +449,9 @@ def sendall(
 
         if response is not None:
             address = self._address_key()
+            # Ensure the address pipe exists before deciding whether to mirror
+            # response bytes or only publish readiness signals.
+            self.fileno()
             self.io.seek(0)
             self._clear_readable_pipe()
             self.io.write(response)
@@ -617,6 +620,9 @@ def recv(self, buffersize: int, flags: int | None = None) -> bytes:
         Raises:
             BlockingIOError: If socket is non-blocking and no data available
         """
+        if buffersize is None:
+            buffersize = self._buflen
+
         address = self._address_key()
         r_fd, _ = Mocket.get_pair(address)
         if r_fd and Mocket.pipe_uses_data(address):

mocket/ssl/socket.py

@@ -28,6 +28,8 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         self._did_handshake: bool = False
         self._sent_non_empty_bytes: bool = False
         self._has_written: bool = False
+        self._ssl_pending: bytes = b""
+        self._ssl_pending_pos: int = 0
         self._original_socket: MocketSocket = self
 
     def read(self, buffersize: int | None = None) -> bytes:
@@ -40,7 +42,16 @@ def read(self, buffersize: int | None = None) -> bytes:
             Bytes read from the socket
 
         """
-        rv = self.io.read(buffersize)
+        if self._ssl_pending_pos < len(self._ssl_pending):
+            if buffersize is None:
+                rv = self._ssl_pending[self._ssl_pending_pos :]
+                self._ssl_pending_pos = len(self._ssl_pending)
+            else:
+                end = self._ssl_pending_pos + buffersize
+                rv = self._ssl_pending[self._ssl_pending_pos : end]
+                self._ssl_pending_pos = min(end, len(self._ssl_pending))
+        else:
+            rv = b""
         if rv:
             self._sent_non_empty_bytes = True
 
@@ -65,7 +76,13 @@ def write(self, data: bytes) -> int | None:
             Number of bytes written
         """
         self._has_written = self._has_written or bool(data)
-        return self.send(encode_to_bytes(data))
+        bytes_sent = self.send(encode_to_bytes(data))
+
+        # Keep a private read buffer for SSL protocol consumers so response
+        # parsing does not depend on shared socket I/O cursor state.
+        self._ssl_pending = self.io.getvalue()
+        self._ssl_pending_pos = 0
+        return bytes_sent
 
     def do_handshake(self) -> None:
         """Perform SSL handshake (mock implementation)."""
@@ -165,5 +182,7 @@ def _create(
         ssl_socket._io = sock._io
         ssl_socket._entry = sock._entry
         ssl_socket._has_written = getattr(sock, "_has_written", False)
+        ssl_socket._ssl_pending = getattr(sock, "_ssl_pending", b"")
+        ssl_socket._ssl_pending_pos = getattr(sock, "_ssl_pending_pos", 0)
 
         return ssl_socket