tests: Fix RST_STREAM asserts not conforming to RFC

Author: MadMockers

test/test_closed_streams.py

@@ -390,17 +390,22 @@ def test_resets_further_frames_after_recv_reset(self,
         assert not events
         assert c.data_to_send() == rst_frame.serialize()
 
+        # "An endpoint MUST ignore frames that it receives on closed streams
+        # after it has sent a RST_STREAM frame."
+        # The initial RST_STREAM was seen in the previous assert. Additional
+        # frames should be ignored.
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == rst_frame.serialize() * 3
+        assert c.data_to_send() == b""
 
         # Iterate over the streams to make sure it's gone, then confirm the
         # behaviour is unchanged.
         c.open_outbound_streams
 
+        # Additional frames should continue to be ignored
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == rst_frame.serialize() * 3
+        assert c.data_to_send() == b""
 
     def test_resets_further_data_frames_after_recv_reset(self,
                                                          frame_factory):
@@ -445,15 +450,15 @@ def test_resets_further_data_frames_after_recv_reset(self,
 
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == expected * 3
+        assert c.data_to_send() == b""
 
         # Iterate over the streams to make sure it's gone, then confirm the
         # behaviour is unchanged.
         c.open_outbound_streams
 
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == expected * 3
+        assert c.data_to_send() == b""
 
     @pytest.mark.parametrize(
         "frame",
@@ -486,6 +491,7 @@ def test_resets_further_frames_after_send_reset(self,
             end_stream=False
         )
 
+        # Send initial RST_STREAM
         c.reset_stream(1, h2.errors.ErrorCodes.INTERNAL_ERROR)
 
         rst_frame = frame_factory.build_rst_stream_frame(
@@ -496,23 +502,24 @@ def test_resets_further_frames_after_send_reset(self,
         f = frame(self, frame_factory)
         events = c.receive_data(f.serialize())
 
-        rst_frame = frame_factory.build_rst_stream_frame(
-            1, h2.errors.ErrorCodes.STREAM_CLOSED
-        )
+        # "An endpoint MUST ignore frames that it receives on closed streams
+        # after it has sent a RST_STREAM frame."
+        # The initial RST_STREAM was sent in the test setup. Additional frames
+        # should be ignored.
         assert not events
-        assert c.data_to_send() == rst_frame.serialize()
+        assert c.data_to_send() == b""
 
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == rst_frame.serialize() * 3
+        assert c.data_to_send() == b""
 
         # Iterate over the streams to make sure it's gone, then confirm the
         # behaviour is unchanged.
         c.open_outbound_streams
 
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == rst_frame.serialize() * 3
+        assert c.data_to_send() == b""
 
     def test_resets_further_data_frames_after_send_reset(self,
                                                          frame_factory):
@@ -535,6 +542,7 @@ def test_resets_further_data_frames_after_send_reset(self,
             end_stream=False
         )
 
+        # Send initial RST_STREAM
         c.reset_stream(1, h2.errors.ErrorCodes.INTERNAL_ERROR)
 
         c.clear_outbound_data_buffer()
@@ -544,20 +552,16 @@ def test_resets_further_data_frames_after_send_reset(self,
         )
         events = c.receive_data(f.serialize())
         assert not events
-        expected = frame_factory.build_rst_stream_frame(
-            stream_id=1,
-            error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
-        ).serialize()
-        assert c.data_to_send() == expected
+        assert c.data_to_send() == b""
 
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == expected * 3
+        assert c.data_to_send() == b""
 
         # Iterate over the streams to make sure it's gone, then confirm the
         # behaviour is unchanged.
         c.open_outbound_streams
 
         events = c.receive_data(f.serialize() * 3)
         assert not events
-        assert c.data_to_send() == expected * 3
+        assert c.data_to_send() == b""

test/test_flow_control_window.py

@@ -652,27 +652,18 @@ def test_send_update_on_closed_streams(self, frame_factory):
         events = c.receive_data(f.serialize()*3)
         assert not events
 
-        expected = frame_factory.build_rst_stream_frame(
-            stream_id=1,
-            error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
-        ).serialize() * 2 + frame_factory.build_window_update_frame(
+        expected = frame_factory.build_window_update_frame(
             stream_id=0,
             increment=40500,
-        ).serialize() + frame_factory.build_rst_stream_frame(
-            stream_id=1,
-            error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
         ).serialize()
         assert c.data_to_send() == expected
 
         f = frame_factory.build_data_frame(b'')
         events = c.receive_data(f.serialize())
         assert not events
 
-        expected = frame_factory.build_rst_stream_frame(
-            stream_id=1,
-            error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
-        ).serialize()
-        assert c.data_to_send() == expected
+        # RST_STREAM has already been sent. Expect no data here.
+        assert c.data_to_send() == b""
 
 
 class TestAutomaticFlowControl(object):

test/test_invalid_frame_sequences.py

@@ -153,6 +153,7 @@ def test_reject_data_on_closed_streams(self, frame_factory):
         bad_frame = frame_factory.build_data_frame(
             data=b'some data'
         )
+
         c.receive_data(bad_frame.serialize())
 
         expected = frame_factory.build_rst_stream_frame(
@@ -349,15 +350,25 @@ def test_one_one_stream_reset(self, frame_factory):
         bad_frame = frame_factory.build_data_frame(
             data=b'some data'
         )
-        # Receive 5 frames.
-        events = c.receive_data(bad_frame.serialize() * 5)
+
+        rst_frame = frame_factory.build_rst_stream_frame(
+            stream_id=1,
+            error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
+        )
 
         expected = frame_factory.build_rst_stream_frame(
             stream_id=1,
             error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
         ).serialize()
-        assert c.data_to_send() == expected * 5
 
+        # Receive 5 frames.
+        events = c.receive_data(bad_frame.serialize())
+        assert len(events) == 1
+        assert c.data_to_send() == expected
+
+        events += c.receive_data(rst_frame.serialize() * 4)
+
+        assert c.data_to_send() == b""
         assert len(events) == 1
         event = events[0]
         assert isinstance(event, h2.events.StreamReset)

test/test_stream_reset.py

@@ -39,19 +39,19 @@ def test_reset_stream_keeps_header_state_correct(self, frame_factory):
         c = h2.connection.H2Connection()
         c.initiate_connection()
         c.send_headers(stream_id=1, headers=self.example_request_headers)
+        # Send initial RST_STREAM
         c.reset_stream(stream_id=1)
         c.send_headers(stream_id=3, headers=self.example_request_headers)
         c.clear_outbound_data_buffer()
 
         f = frame_factory.build_headers_frame(
             headers=self.example_response_headers, stream_id=1
         )
-        rst_frame = frame_factory.build_rst_stream_frame(
-            1, h2.errors.ErrorCodes.STREAM_CLOSED
-        )
+
+        # RST_STREAM already sent. Expect no data here.
         events = c.receive_data(f.serialize())
         assert not events
-        assert c.data_to_send() == rst_frame.serialize()
+        assert c.data_to_send() == b""
 
         # This works because the header state should be intact from the headers
         # frame that was send on stream 1, so they should decode cleanly.
@@ -85,6 +85,7 @@ def test_reset_stream_keeps_flow_control_correct(self,
             headers=self.example_response_headers, stream_id=close_id
         )
         c.receive_data(f.serialize())
+        # Send initial reset
         c.reset_stream(stream_id=close_id)
         c.clear_outbound_data_buffer()
 
@@ -94,11 +95,8 @@ def test_reset_stream_keeps_flow_control_correct(self,
         )
         c.receive_data(f.serialize())
 
-        expected = frame_factory.build_rst_stream_frame(
-            stream_id=close_id,
-            error_code=h2.errors.ErrorCodes.STREAM_CLOSED,
-        ).serialize()
-        assert c.data_to_send() == expected
+        # RST_STREAM already sent. Expect no data here.
+        assert c.data_to_send() == b""
 
         new_window = c.remote_flow_control_window(stream_id=other_id)
         assert initial_window - len(b'some data') == new_window