Fix receiving a GOAWAY frame from updating the max recv ID

Receiving a GOAWAY should update the max *send* ID, it shouldn't affect
the max recv.

tests/h2-tests/tests/server.rs

@@ -656,6 +656,55 @@ async fn graceful_shutdown() {
     join(client, srv).await;
 }
 
+#[tokio::test]
+async fn goaway_even_if_client_sent_goaway() {
+    let _ = env_logger::try_init();
+    let (io, mut client) = mock::new();
+
+    let client = async move {
+        let settings = client.assert_server_handshake().await;
+        assert_default_settings!(settings);
+        client
+            .send_frame(
+                frames::headers(5)
+                    .request("GET", "https://example.com/")
+                    .eos(),
+            )
+            .await;
+        // Ping-pong so as to wait until server gets req
+        client.ping_pong([0; 8]).await;
+        client.send_frame(frames::go_away(0)).await;
+        // 2^31 - 1 = 2147483647
+        // Note: not using a constant in the library because library devs
+        // can be unsmart.
+        client.recv_frame(frames::go_away(2147483647)).await;
+        client.recv_frame(frames::ping(frame::Ping::SHUTDOWN)).await;
+        client
+            .recv_frame(frames::headers(5).response(200).eos())
+            .await;
+        client
+            .send_frame(frames::ping(frame::Ping::SHUTDOWN).pong())
+            .await;
+        client.recv_frame(frames::go_away(5)).await;
+        client.recv_eof().await;
+    };
+
+    let srv = async move {
+        let mut srv = server::handshake(io).await.expect("handshake");
+        let (req, mut stream) = srv.next().await.unwrap().unwrap();
+        assert_eq!(req.method(), &http::Method::GET);
+
+        srv.graceful_shutdown();
+
+        let rsp = http::Response::builder().status(200).body(()).unwrap();
+        stream.send_response(rsp, true).unwrap();
+
+        assert!(srv.next().await.is_none(), "unexpected request");
+    };
+
+    join(client, srv).await;
+}
+
 #[tokio::test]
 async fn sends_reset_cancel_when_res_body_is_dropped() {
     let _ = env_logger::try_init();

tests/h2-tests/tests/stream_states.rs

@@ -330,6 +330,40 @@ async fn recv_goaway_finishes_processed_streams() {
     join(srv, h2).await;
 }
 
+#[tokio::test]
+async fn recv_goaway_with_higher_last_processed_id() {
+    let _ = env_logger::try_init();
+    let (io, mut srv) = mock::new();
+
+    let srv = async move {
+        let settings = srv.assert_client_handshake().await;
+        assert_default_settings!(settings);
+        srv.recv_frame(
+            frames::headers(1)
+                .request("GET", "https://example.com/")
+                .eos(),
+        )
+        .await;
+        srv.send_frame(frames::go_away(1)).await;
+        // a bigger goaway? kaboom
+        srv.send_frame(frames::go_away(3)).await;
+        // expecting a goaway of 0, since server never initiated a stream
+        srv.recv_frame(frames::go_away(0).protocol_error()).await;
+        //.close();
+    };
+
+    let client = async move {
+        let (mut client, mut conn) = client::handshake(io).await.expect("handshake");
+        let err = conn
+            .drive(client.get("https://example.com"))
+            .await
+            .expect_err("client should error");
+        assert_eq!(err.reason(), Some(Reason::PROTOCOL_ERROR));
+    };
+
+    join(srv, client).await;
+}
+
 #[tokio::test]
 async fn recv_next_stream_id_updated_by_malformed_headers() {
     let _ = env_logger::try_init();