spdy_stream_unittest.cc | Explore in Territory

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "net/spdy/spdy_stream.h"

#include <stdint.h>

#include <algorithm>
#include <cstddef>
#include <limits>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/functional/bind.h"
#include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/time/time.h"
#include "net/base/request_priority.h"
#include "net/base/session_usage.h"
#include "net/dns/public/secure_dns_policy.h"
#include "net/http/http_request_info.h"
#include "net/log/net_log_event_type.h"
#include "net/log/test_net_log.h"
#include "net/log/test_net_log_util.h"
#include "net/socket/socket_tag.h"
#include "net/socket/socket_test_util.h"
#include "net/spdy/buffered_spdy_framer.h"
#include "net/spdy/spdy_http_utils.h"
#include "net/spdy/spdy_session.h"
#include "net/spdy/spdy_session_pool.h"
#include "net/spdy/spdy_stream_test_util.h"
#include "net/spdy/spdy_test_util_common.h"
#include "net/test/cert_test_util.h"
#include "net/test/gtest_util.h"
#include "net/test/test_data_directory.h"
#include "net/test/test_with_task_environment.h"
#include "net/third_party/quiche/src/quiche/common/http/http_header_block.h"
#include "net/third_party/quiche/src/quiche/spdy/core/spdy_protocol.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

// TODO(ukai): factor out common part with spdy_http_stream_unittest.cc
//
namespace net::test {

namespace {

const char kPostBody[] = …;
const size_t kPostBodyLength = …;
const std::string_view kPostBodyStringPiece(kPostBody, kPostBodyLength);

// Creates a MockRead from the given serialized frame except for the last byte.
MockRead ReadFrameExceptForLastByte(const spdy::SpdySerializedFrame& frame) { … }

// Creates a MockRead from the last byte of the given serialized frame.
MockRead LastByteOfReadFrame(const spdy::SpdySerializedFrame& frame) { … }

}  // namespace

class SpdyStreamTest : public ::testing::Test, public WithTaskEnvironment { … };

TEST_F(SpdyStreamTest, SendDataAfterOpen) { … }

TEST_F(SpdyStreamTest, BrokenConnectionDetectionSuccessfulRequest) { … }

// Delegate that receives trailers.
class StreamDelegateWithTrailers : public test::StreamDelegateWithBody { … };

// Regression test for https://crbug.com/481033.
TEST_F(SpdyStreamTest, Trailers) { … }

TEST_F(SpdyStreamTest, StreamError) { … }

// Make sure that large blocks of data are properly split up into frame-sized
// chunks for a request/response (i.e., an HTTP-like) stream.
TEST_F(SpdyStreamTest, SendLargeDataAfterOpenRequestResponse) { … }

// Make sure that large blocks of data are properly split up into frame-sized
// chunks for a bidirectional (i.e., non-HTTP-like) stream.
TEST_F(SpdyStreamTest, SendLargeDataAfterOpenBidirectional) { … }

// Receiving a header with uppercase ASCII should result in a protocol error.
TEST_F(SpdyStreamTest, UpperCaseHeaders) { … }

TEST_F(SpdyStreamTest, HeadersMustHaveStatus) { … }

TEST_F(SpdyStreamTest, TrailersMustNotFollowTrailers) { … }

TEST_F(SpdyStreamTest, DataMustNotFollowTrailers) { … }

class SpdyStreamTestWithMockClock : public SpdyStreamTest { … };

// Test that the response start time is recorded for non-informational response.
TEST_F(SpdyStreamTestWithMockClock, NonInformationalResponseStart) { … }

TEST_F(SpdyStreamTestWithMockClock, InformationalHeaders) { … }

// Tests that timing information of 103 Eary Hints responses are collected and
// callbacks are called as expected.
TEST_F(SpdyStreamTestWithMockClock, EarlyHints) { … }

TEST_F(SpdyStreamTest, StatusMustBeNumber) { … }

TEST_F(SpdyStreamTest, StatusCannotHaveExtraText) { … }

TEST_F(SpdyStreamTest, StatusMustBePresent) { … }

// Call IncreaseSendWindowSize on a stream with a large enough delta to overflow
// an int32_t. The SpdyStream should handle that case gracefully.
TEST_F(SpdyStreamTest, IncreaseSendWindowSizeOverflow) { … }

// Functions used with
// RunResumeAfterUnstall{RequestResponse,Bidirectional}Test().

void StallStream(const base::WeakPtr<SpdyStream>& stream) { … }

void IncreaseStreamSendWindowSize(const base::WeakPtr<SpdyStream>& stream,
                                  int32_t delta_window_size) { … }

void AdjustStreamSendWindowSize(const base::WeakPtr<SpdyStream>& stream,
                                int32_t delta_window_size) { … }

// Given an unstall function, runs a test to make sure that a
// request/response (i.e., an HTTP-like) stream resumes after a stall
// and unstall.
void SpdyStreamTest::RunResumeAfterUnstallRequestResponseTest(
    UnstallFunction unstall_function) { … }

TEST_F(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseRequestResponse) { … }

TEST_F(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustRequestResponse) { … }

// Given an unstall function, runs a test to make sure that a bidirectional
// (i.e., non-HTTP-like) stream resumes after a stall and unstall.
void SpdyStreamTest::RunResumeAfterUnstallBidirectionalTest(
    UnstallFunction unstall_function) { … }

TEST_F(SpdyStreamTest, ResumeAfterSendWindowSizeIncreaseBidirectional) { … }

TEST_F(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustBidirectional) { … }

// Test calculation of amount of bytes received from network.
TEST_F(SpdyStreamTest, ReceivedBytes) { … }

// Regression test for https://crbug.com/810763.
TEST_F(SpdyStreamTest, DataOnHalfClosedRemoveStream) { … }

TEST_F(SpdyStreamTest, DelegateIsInformedOfEOF) { … }

// A small read should trigger sending a receive window update and dropping the
// count of unacknowledged bytes to zero only after
// kDefaultTimeToBufferSmallWindowUpdates time has passed.
TEST_F(SpdyStreamTestWithMockClock, FlowControlSlowReads) { … }

}  // namespace net::test
chromium/net/spdy/spdy_stream_unittest.cc
