fixed windows tests

Author: pavelrevak

tests/test_timeout_during_response.py

@@ -23,7 +23,6 @@ def test_no_408_while_response_in_progress(self):
         """Connection streaming file response should not get 408 timeout"""
         temp_dir = tempfile.mkdtemp()
         large_file = os.path.join(temp_dir, 'large.bin')
-        # Large file with tiny chunk size ensures streaming takes multiple iterations
         with open(large_file, 'wb') as f:
             f.write(b'X' * 200_000)
 
@@ -32,15 +31,13 @@ def test_no_408_while_response_in_progress(self):
         trigger_sock = None
 
         try:
-            # Connect and send request
             client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             client_sock.connect(('localhost', self.PORT))
             client_sock.setblocking(False)
             client_sock.send(
                 b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
             time.sleep(0.1)
 
-            # Get loaded connection
             connection = None
             for _ in range(10):
                 r, _, _ = select.select(server.read_sockets, [], [], 0.1)
@@ -50,14 +47,13 @@ def test_no_408_while_response_in_progress(self):
                         break
             self.assertIsNotNone(connection)
 
-            # Start file response - streaming keeps _response_started True
             connection.respond_file(large_file)
             self.assertTrue(connection._response_started)
 
             # Wait longer than keep_alive_timeout
             time.sleep(0.5)
 
-            # Trigger cleanup via event_read (new connection triggers accept)
+            # Trigger cleanup via new connection
             trigger_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             trigger_sock.connect(('localhost', self.PORT))
             time.sleep(0.1)
@@ -66,12 +62,11 @@ def test_no_408_while_response_in_progress(self):
             if r:
                 server.event_read(r)
 
-            # Connection should still be alive (not closed by 408)
             self.assertIsNotNone(
                 connection.socket,
                 "Connection should not be closed while response is in progress")
 
-            # Drain the response to verify it's still valid
+            # Drain the response
             response = b""
             for _ in range(200):
                 w = server.write_sockets
@@ -95,44 +90,57 @@ def test_no_408_while_response_in_progress(self):
             client_sock.close()
             if trigger_sock:
                 trigger_sock.close()
+            # Close server first so file handles are released (Windows)
             server.close()
-            os.unlink(large_file)
-            os.rmdir(temp_dir)
+            time.sleep(0.1)
+            try:
+                os.unlink(large_file)
+                os.rmdir(temp_dir)
+            except OSError:
+                pass
 
     def test_idle_keepalive_still_gets_408(self):
         """Idle keep-alive connection (no response started) should still get 408"""
         server = uhttp_server.HttpServer(
             port=self.PORT + 1, keep_alive_timeout=0.3)
+        trigger_sock = None
 
         try:
-            # Connect but don't send a full request (simulate idle keep-alive)
             client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             client_sock.connect(('localhost', self.PORT + 1))
             client_sock.setblocking(False)
 
-            # Send partial request to create connection in waiting pool
             client_sock.send(
                 b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
             time.sleep(0.1)
 
-            # Process the request
-            r, _, _ = select.select(server.read_sockets, [], [], 0.2)
-            if r:
-                connection = server.event_read(r)
-                if connection:
-                    # Respond and let keep-alive reset
-                    connection.respond('ok')
-                    # Flush send buffer
-                    for _ in range(10):
-                        w = server.write_sockets
-                        if w:
-                            _, ww, _ = select.select([], w, [], 0.1)
-                            if ww:
-                                server.event_write(ww)
-                        else:
-                            break
-
-            # Wait for timeout
+            # Process the request and respond
+            for _ in range(10):
+                r, _, _ = select.select(server.read_sockets, [], [], 0.1)
+                if r:
+                    connection = server.event_read(r)
+                    if connection:
+                        connection.respond('ok')
+                        break
+
+            # Flush send buffer
+            for _ in range(20):
+                w = server.write_sockets
+                if w:
+                    _, ww, _ = select.select([], w, [], 0.1)
+                    if ww:
+                        server.event_write(ww)
+                else:
+                    break
+
+            # Drain the first response
+            try:
+                while True:
+                    client_sock.recv(4096)
+            except BlockingIOError:
+                pass
+
+            # Wait for keep-alive timeout
             time.sleep(0.5)
 
             # Trigger cleanup
@@ -144,16 +152,21 @@ def test_idle_keepalive_still_gets_408(self):
             if r:
                 server.event_read(r)
 
+            # Flush 408 response
+            for _ in range(20):
+                w = server.write_sockets
+                if w:
+                    _, ww, _ = select.select([], w, [], 0.1)
+                    if ww:
+                        server.event_write(ww)
+                else:
+                    break
+
             # Read the 408 response
+            time.sleep(0.1)
             response = b""
             try:
                 for _ in range(10):
-                    # Flush server writes
-                    w = server.write_sockets
-                    if w:
-                        _, ww, _ = select.select([], w, [], 0.1)
-                        if ww:
-                            server.event_write(ww)
                     chunk = client_sock.recv(4096)
                     if chunk:
                         response += chunk
@@ -166,7 +179,8 @@ def test_idle_keepalive_still_gets_408(self):
 
         finally:
             client_sock.close()
-            trigger_sock.close()
+            if trigger_sock:
+                trigger_sock.close()
             server.close()