simplified the logic of the bad write retry test to be pass or fail

Author: julianz-

tests/test_ssl.py

@@ -3163,39 +3163,59 @@ def _badwriteretry(self, mode: int) -> bool:
                             bad write error"
                     )
 
-            # Now, attempt to send application data over the established
+            # Now, attempt to send some application data over the established
             # SSL connection. Since the underlying raw socket's buffer is full,
             # this should cause a WantWriteError.
-            msg2 = b"Y" * 65536
-
-            try:
-                written = client.send(msg2)
-            except SSL.WantWriteError:
+            result = None
+            msg2 = b"Y" * 64
+            print(f"ID of msg2: {id(msg2)}")
+            # try multiple times as may not get a WantWriteError the first time
+            for i in range(100):
                 try:
-                    # After a WantWriteError if the connection has partially
-                    # written the last buffer it will expect a retry write.
-                    # This next write should fail but for two different reasons
-                    # depending on whether SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
-                    # was set
-                    msg3 = b"Z" * 65536
-                    written = client.send(msg3)
-                    pytest.fail("Retry succeeded unexpectedly")
+                    written = client.send(msg2)
+                except SSL.WantWriteError:
+                    try:
+                        # After a WantWriteError if the connection has
+                        # partially written the last buffer it will expect
+                        # a retry write. We try with a new buffer so that the
+                        # next write should pass if
+                        # SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER was set but fail
+                        # otherwise. Note if the buffer has a different length
+                        # the write generates a "bad length" SSL.Error rather
+                        # than "bad write retry".
+                        # Create a new buffer that is guaranteed to be at a
+                        # different location (because of different contents)
+                        msg3 = b"Z" * 64
+                        print(f"ID of msg3: {id(msg2)}")
+                        written = client.send(msg3)
+                        # the retry was successful
+                        result = False
+                        break
+                    except SSL.WantWriteError:
+                        # if this write generated another WantWriteError
+                        # rather than a bad retry allow for loop to try again
+                        pass
+                    except SSL.Error as e:
+                        reason = get_ssl_error_reason(e)
+                        if reason == "bad write retry":
+                            # Got SSL error on retry (expected if not using \
+                            # SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)
+                            result = True
+                            break
+                        else:
+                            # the write unexpectedly failed
+                            pytest.fail(f"Got unexpected SSL error on retry: \
+                                         {e} {reason}")
+
                 except SSL.Error as e:
                     reason = get_ssl_error_reason(e)
-                    if reason == "bad write retry":
-                        # Got SSL error on retry (expected if not using \
-                        # SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)
-                        result = True
-                    else:
-                        # when using SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
-                        # we expect this to fail for a WantWriteError
-                        result = False
+                    pytest.fail(f"Got unexpected SSL error on retry: \
+                                {e} {reason}")
+                except Exception as e:
+                    pytest.fail(f"Unexpected exception during send: {e}")
 
-            except SSL.Error as e:
-                reason = get_ssl_error_reason(e)
-                pytest.fail(f"Got unexpected SSL error on retry: {e} {reason}")
-            except Exception as e:
-                pytest.fail(f"Unexpected exception during send: {e}")
+            if result is None:
+                pytest.fail("Failed to induce WantWriteError")
 
         finally:
             # Cleanup: shut down SSL connections and close raw sockets
@@ -3225,12 +3245,12 @@ def test_moving_write_buffer_should_pass(self) -> None:
             _lib.SSL_MODE_ENABLE_PARTIAL_WRITE
             | _lib.SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
         )
-        result = self._badwriteretry(mode)
+        bad_retry = self._badwriteretry(mode)
 
-        if result:
+        if bad_retry:
             pytest.fail(
                 "Using SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER failed to \
-                        prevent bad write rety"
+                        prevent bad write retry"
             )
 
     def test_moving_write_buffer_should_fail(self) -> None:
@@ -3242,12 +3262,11 @@ def test_moving_write_buffer_should_fail(self) -> None:
         buffer is presented.
         """
         mode = 0
-        result = self._badwriteretry(mode)
+        bad_retry = self._badwriteretry(mode)
 
-        if not result:
+        if not bad_retry:
             pytest.fail(
-                "Using SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER failed to \
-                        prevent bad write rety"
+                "Failed to generate bad write retry error."
             )
 
     def test_get_finished_before_connect(self) -> None: