third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream_unittest.cc - chromium/src - Git at Google

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

 #include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream.h"
 #include "net/test/gtest_util.h"
 #include "net/third_party/quic/core/quic_data_writer.h"
 #include "net/third_party/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream_impl.h"
 #include "third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_stream_delegate.h"

 namespace blink {

 namespace {

 using testing::_;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;

 const uint32_t kWriteBufferSize = 1024;
 const quic::QuicStreamId kStreamId = 5;
 const std::string kSomeData = "howdy";

 }  // namespace

 // Unit tests for the P2PQuicStream, using a mock QuicSession, which allows
 // us to isolate testing the behaviors of reading a writing.
 class P2PQuicStreamTest : public testing::Test {
  public:
   P2PQuicStreamTest()
       : connection_(
             new quic::test::MockQuicConnection(&connection_helper_,
                                                &alarm_factory_,
                                                quic::Perspective::IS_CLIENT)),
         session_(connection_) {
     session_.Initialize();
     stream_ = new P2PQuicStreamImpl(kStreamId, &session_, kWriteBufferSize);
     stream_->SetDelegate(&delegate_);
     // The session takes the ownership of the stream.
     session_.ActivateStream(std::unique_ptr<P2PQuicStreamImpl>(stream_));
     // DCHECKS get hit when the clock is at 0.
     connection_helper_.AdvanceTime(quic::QuicTime::Delta::FromSeconds(1));
   }

   ~P2PQuicStreamTest() override {}

   quic::test::MockQuicConnectionHelper connection_helper_;
   quic::test::MockAlarmFactory alarm_factory_;
   // Owned by the |session_|.
   quic::test::MockQuicConnection* connection_;
   // The MockQuicSession allows us to see data that is being written and control
   // whether the data is being "sent across" or blocked.
   quic::test::MockQuicSession session_;
   MockP2PQuicStreamDelegate delegate_;
   // Owned by |session_|.
   P2PQuicStreamImpl* stream_;
 };

 TEST_F(P2PQuicStreamTest, StreamSendsFinAndCanNoLongerWrite) {
   EXPECT_CALL(session_, WritevData(stream_, kStreamId, _, _, _))
       .WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));

   stream_->WriteData({}, /*fin=*/true);

   EXPECT_TRUE(stream_->fin_sent());
   EXPECT_TRUE(stream_->write_side_closed());
   EXPECT_FALSE(stream_->reading_stopped());
 }

 TEST_F(P2PQuicStreamTest, StreamResetSendsRst) {
   EXPECT_CALL(session_, SendRstStream(kStreamId, _, _));
   stream_->Reset();
   EXPECT_TRUE(stream_->rst_sent());
 }

 // Tests that when a stream receives a stream frame with the FIN bit set it
 // will fire the appropriate callback and close the stream for reading.
 TEST_F(P2PQuicStreamTest, StreamOnStreamFrameWithFin) {
   EXPECT_CALL(delegate_, OnRemoteFinish());

   quic::QuicStreamFrame fin_frame(kStreamId, /*fin=*/true, 0, 0);
   stream_->OnStreamFrame(fin_frame);

   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_FALSE(stream_->write_side_closed());
 }

 // Tests that when a stream receives a stream frame with the FIN bit set after
 // it has written the FIN bit, then the stream will close.
 TEST_F(P2PQuicStreamTest, StreamClosedAfterSendingThenReceivingFin) {
   EXPECT_CALL(session_, WritevData(stream_, kStreamId, _, _, _))
       .WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));
   stream_->WriteData({}, /*fin=*/true);
   EXPECT_FALSE(stream_->IsClosedForTesting());

   quic::QuicStreamFrame fin_frame(stream_->id(), /*fin=*/true, 0, 0);
   stream_->OnStreamFrame(fin_frame);

   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
   EXPECT_TRUE(stream_->IsClosedForTesting());
 }

 // Tests that when a stream writes a FIN bit after receiving a stream frame with
 // the FIN bit then the stream will close.
 TEST_F(P2PQuicStreamTest, StreamClosedAfterReceivingThenSendingFin) {
   quic::QuicStreamFrame fin_frame(stream_->id(), /*fin=*/true, 0, 0);
   stream_->OnStreamFrame(fin_frame);
   EXPECT_FALSE(stream_->IsClosedForTesting());

   EXPECT_CALL(session_, WritevData(stream_, kStreamId, _, _, _))
       .WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));

   stream_->WriteData({}, /*fin=*/true);

   EXPECT_TRUE(stream_->IsClosedForTesting());
 }

 // Tests that when a stream writes some data with the FIN bit set, and receives
 // data with the FIN bit set it will become closed.
 TEST_F(P2PQuicStreamTest, StreamClosedAfterWritingAndReceivingDataWithFin) {
   EXPECT_CALL(session_, WritevData(stream_, kStreamId,
                                    /*write_length=*/kSomeData.size(), _, _))
       .WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));
   stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
                      /*fin=*/true);
   EXPECT_FALSE(stream_->IsClosedForTesting());

   quic::QuicStreamFrame fin_frame_with_data(stream_->id(), /*fin=*/true, 0,
                                             kSomeData);
   stream_->OnStreamFrame(fin_frame_with_data);

   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
   EXPECT_TRUE(stream_->IsClosedForTesting());
 }

 // Tests that when a stream receives a RST_STREAM frame it will fire the
 // appropriate callback and the stream will become closed.
 TEST_F(P2PQuicStreamTest, StreamClosedAfterReceivingReset) {
   EXPECT_CALL(delegate_, OnRemoteReset());

   quic::QuicRstStreamFrame rst_frame(quic::kInvalidControlFrameId, kStreamId,
                                      quic::QUIC_STREAM_CANCELLED, 0);
   stream_->OnStreamReset(rst_frame);

   EXPECT_TRUE(stream_->IsClosedForTesting());
 }

 // Tests that data written to the P2PQuicStream will appropriately get written
 // to the underlying QUIC library.
 TEST_F(P2PQuicStreamTest, StreamWritesData) {
   EXPECT_CALL(session_, WritevData(stream_, kStreamId,
                                    /*write_length=*/kSomeData.size(), _, _))
       .WillOnce(Invoke([](quic::QuicStream* stream, quic::QuicStreamId id,
                           size_t write_length, quic::QuicStreamOffset offset,
                           quic::StreamSendingState state) {
         // quic::QuicSession::WritevData does not pass the data. The data is
         // saved to the stream, so we must grab it before it's consumed, in
         // order to check that it's what was written.
         std::string data_consumed_by_quic(write_length, 'a');
         quic::QuicDataWriter writer(write_length, &data_consumed_by_quic[0],
                                     quic::NETWORK_BYTE_ORDER);
         stream->WriteStreamData(offset, write_length, &writer);

         EXPECT_EQ(kSomeData, data_consumed_by_quic);
         EXPECT_EQ(quic::StreamSendingState::NO_FIN, state);
         return quic::QuicConsumedData(
             write_length, state != quic::StreamSendingState::NO_FIN);
       }));
   EXPECT_CALL(delegate_, OnWriteDataConsumed(kSomeData.size()));

   stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
                      /*fin=*/false);
 }

 // Tests that data written to the P2PQuicStream will appropriately get written
 // to the underlying QUIC library with the FIN bit set.
 TEST_F(P2PQuicStreamTest, StreamWritesDataWithFin) {
   EXPECT_CALL(session_, WritevData(stream_, kStreamId,
                                    /*write_length=*/kSomeData.size(), _, _))
       .WillOnce(Invoke([](quic::QuicStream* stream, quic::QuicStreamId id,
                           size_t write_length, quic::QuicStreamOffset offset,
                           quic::StreamSendingState state) {
         // WritevData does not pass the data. The data is saved to the stream,
         // so we must grab it before it's consumed, in order to check that it's
         // what was written.
         std::string data_consumed_by_quic(write_length, 'a');
         quic::QuicDataWriter writer(write_length, &data_consumed_by_quic[0],
                                     quic::NETWORK_BYTE_ORDER);
         stream->WriteStreamData(offset, write_length, &writer);

         EXPECT_EQ(kSomeData, data_consumed_by_quic);
         EXPECT_EQ(quic::StreamSendingState::FIN, state);
         return quic::QuicConsumedData(
             write_length, state != quic::StreamSendingState::NO_FIN);
       }));
   EXPECT_CALL(delegate_, OnWriteDataConsumed(kSomeData.size()));

   stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
                      /*fin=*/true);
 }

 // Tests that when written data is not consumed by QUIC (due to buffering),
 // the OnWriteDataConsumed will not get fired.
 TEST_F(P2PQuicStreamTest, StreamWritesDataAndNotConsumedByQuic) {
   EXPECT_CALL(delegate_, OnWriteDataConsumed(_)).Times(0);
   EXPECT_CALL(session_, WritevData(stream_, kStreamId,
                                    /*write_length=*/kSomeData.size(), _, _))
       .WillOnce(Invoke([](quic::QuicStream* stream, quic::QuicStreamId id,
                           size_t write_length, quic::QuicStreamOffset offset,
                           quic::StreamSendingState state) {
         // We mock that the QUIC library is not consuming the data, meaning it's
         // being buffered. In this case, the OnWriteDataConsumed() callback
         // should not be called.
         return quic::QuicConsumedData(/*bytes_consumed=*/0,
                                       quic::StreamSendingState::NO_FIN);
       }));

   stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
                      /*fin=*/true);
 }

 // Tests that OnWriteDataConsumed() is fired with the amount consumed by QUIC.
 // This tests the case when amount consumed by QUIC is less than what is written
 // with P2PQuicStream::WriteData. This can happen when QUIC is receiving back
 // pressure from the receive side, and its "send window" is smaller than the
 // amount attempted to be written.
 TEST_F(P2PQuicStreamTest, StreamWritesDataAndPartiallyConsumedByQuic) {
   size_t amount_consumed_by_quic = 2;
   EXPECT_CALL(delegate_, OnWriteDataConsumed(amount_consumed_by_quic));
   EXPECT_CALL(session_, WritevData(stream_, kStreamId,
                                    /*write_length=*/kSomeData.size(), _, _))
       .WillOnce(Invoke([&amount_consumed_by_quic](
                            quic::QuicStream* stream, quic::QuicStreamId id,
                            size_t write_length, quic::QuicStreamOffset offset,
                            quic::StreamSendingState state) {
         // We mock that the QUIC library is only consuming some of the data,
         // meaning the rest is being buffered.
         return quic::QuicConsumedData(
             /*bytes_consumed=*/amount_consumed_by_quic,
             quic::StreamSendingState::NO_FIN);
       }));

   stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
                      /*fin=*/true);
 }

 }  // namespace blink
	// Copyright 2018 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream.h"
	#include "net/test/gtest_util.h"
	#include "net/third_party/quic/core/quic_data_writer.h"
	#include "net/third_party/quic/test_tools/quic_test_utils.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream_impl.h"
	#include "third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_stream_delegate.h"

	namespace blink {

	namespace {

	using testing::_;
	using testing::Invoke;
	using testing::InvokeWithoutArgs;

	const uint32_t kWriteBufferSize = 1024;
	const quic::QuicStreamId kStreamId = 5;
	const std::string kSomeData = "howdy";

	} // namespace

	// Unit tests for the P2PQuicStream, using a mock QuicSession, which allows
	// us to isolate testing the behaviors of reading a writing.
	class P2PQuicStreamTest : public testing::Test {
	public:
	P2PQuicStreamTest()
	: connection_(
	new quic::test::MockQuicConnection(&connection_helper_,
	&alarm_factory_,
	quic::Perspective::IS_CLIENT)),
	session_(connection_) {
	session_.Initialize();
	stream_ = new P2PQuicStreamImpl(kStreamId, &session_, kWriteBufferSize);
	stream_->SetDelegate(&delegate_);
	// The session takes the ownership of the stream.
	session_.ActivateStream(std::unique_ptr<P2PQuicStreamImpl>(stream_));
	// DCHECKS get hit when the clock is at 0.
	connection_helper_.AdvanceTime(quic::QuicTime::Delta::FromSeconds(1));
	}

	~P2PQuicStreamTest() override {}

	quic::test::MockQuicConnectionHelper connection_helper_;
	quic::test::MockAlarmFactory alarm_factory_;
	// Owned by the \|session_\|.
	quic::test::MockQuicConnection* connection_;
	// The MockQuicSession allows us to see data that is being written and control
	// whether the data is being "sent across" or blocked.
	quic::test::MockQuicSession session_;
	MockP2PQuicStreamDelegate delegate_;
	// Owned by \|session_\|.
	P2PQuicStreamImpl* stream_;
	};

	TEST_F(P2PQuicStreamTest, StreamSendsFinAndCanNoLongerWrite) {
	EXPECT_CALL(session_, WritevData(stream_, kStreamId, _, _, _))
	.WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));

	stream_->WriteData({}, /fin=/true);

	EXPECT_TRUE(stream_->fin_sent());
	EXPECT_TRUE(stream_->write_side_closed());
	EXPECT_FALSE(stream_->reading_stopped());
	}

	TEST_F(P2PQuicStreamTest, StreamResetSendsRst) {
	EXPECT_CALL(session_, SendRstStream(kStreamId, _, _));
	stream_->Reset();
	EXPECT_TRUE(stream_->rst_sent());
	}

	// Tests that when a stream receives a stream frame with the FIN bit set it
	// will fire the appropriate callback and close the stream for reading.
	TEST_F(P2PQuicStreamTest, StreamOnStreamFrameWithFin) {
	EXPECT_CALL(delegate_, OnRemoteFinish());

	quic::QuicStreamFrame fin_frame(kStreamId, /fin=/true, 0, 0);
	stream_->OnStreamFrame(fin_frame);

	EXPECT_TRUE(stream_->reading_stopped());
	EXPECT_FALSE(stream_->write_side_closed());
	}

	// Tests that when a stream receives a stream frame with the FIN bit set after
	// it has written the FIN bit, then the stream will close.
	TEST_F(P2PQuicStreamTest, StreamClosedAfterSendingThenReceivingFin) {
	EXPECT_CALL(session_, WritevData(stream_, kStreamId, _, _, _))
	.WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));
	stream_->WriteData({}, /fin=/true);
	EXPECT_FALSE(stream_->IsClosedForTesting());

	quic::QuicStreamFrame fin_frame(stream_->id(), /fin=/true, 0, 0);
	stream_->OnStreamFrame(fin_frame);

	EXPECT_TRUE(stream_->reading_stopped());
	EXPECT_TRUE(stream_->write_side_closed());
	EXPECT_TRUE(stream_->IsClosedForTesting());
	}

	// Tests that when a stream writes a FIN bit after receiving a stream frame with
	// the FIN bit then the stream will close.
	TEST_F(P2PQuicStreamTest, StreamClosedAfterReceivingThenSendingFin) {
	quic::QuicStreamFrame fin_frame(stream_->id(), /fin=/true, 0, 0);
	stream_->OnStreamFrame(fin_frame);
	EXPECT_FALSE(stream_->IsClosedForTesting());

	EXPECT_CALL(session_, WritevData(stream_, kStreamId, _, _, _))
	.WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));

	stream_->WriteData({}, /fin=/true);

	EXPECT_TRUE(stream_->IsClosedForTesting());
	}

	// Tests that when a stream writes some data with the FIN bit set, and receives
	// data with the FIN bit set it will become closed.
	TEST_F(P2PQuicStreamTest, StreamClosedAfterWritingAndReceivingDataWithFin) {
	EXPECT_CALL(session_, WritevData(stream_, kStreamId,
	/write_length=/kSomeData.size(), _, _))
	.WillOnce(Invoke(quic::test::MockQuicSession::ConsumeData));
	stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
	/fin=/true);
	EXPECT_FALSE(stream_->IsClosedForTesting());

	quic::QuicStreamFrame fin_frame_with_data(stream_->id(), /fin=/true, 0,
	kSomeData);
	stream_->OnStreamFrame(fin_frame_with_data);

	EXPECT_TRUE(stream_->reading_stopped());
	EXPECT_TRUE(stream_->write_side_closed());
	EXPECT_TRUE(stream_->IsClosedForTesting());
	}

	// Tests that when a stream receives a RST_STREAM frame it will fire the
	// appropriate callback and the stream will become closed.
	TEST_F(P2PQuicStreamTest, StreamClosedAfterReceivingReset) {
	EXPECT_CALL(delegate_, OnRemoteReset());

	quic::QuicRstStreamFrame rst_frame(quic::kInvalidControlFrameId, kStreamId,
	quic::QUIC_STREAM_CANCELLED, 0);
	stream_->OnStreamReset(rst_frame);

	EXPECT_TRUE(stream_->IsClosedForTesting());
	}

	// Tests that data written to the P2PQuicStream will appropriately get written
	// to the underlying QUIC library.
	TEST_F(P2PQuicStreamTest, StreamWritesData) {
	EXPECT_CALL(session_, WritevData(stream_, kStreamId,
	/write_length=/kSomeData.size(), _, _))
	.WillOnce(Invoke([](quic::QuicStream* stream, quic::QuicStreamId id,
	size_t write_length, quic::QuicStreamOffset offset,
	quic::StreamSendingState state) {
	// quic::QuicSession::WritevData does not pass the data. The data is
	// saved to the stream, so we must grab it before it's consumed, in
	// order to check that it's what was written.
	std::string data_consumed_by_quic(write_length, 'a');
	quic::QuicDataWriter writer(write_length, &data_consumed_by_quic[0],
	quic::NETWORK_BYTE_ORDER);
	stream->WriteStreamData(offset, write_length, &writer);

	EXPECT_EQ(kSomeData, data_consumed_by_quic);
	EXPECT_EQ(quic::StreamSendingState::NO_FIN, state);
	return quic::QuicConsumedData(
	write_length, state != quic::StreamSendingState::NO_FIN);
	}));
	EXPECT_CALL(delegate_, OnWriteDataConsumed(kSomeData.size()));

	stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
	/fin=/false);
	}

	// Tests that data written to the P2PQuicStream will appropriately get written
	// to the underlying QUIC library with the FIN bit set.
	TEST_F(P2PQuicStreamTest, StreamWritesDataWithFin) {
	EXPECT_CALL(session_, WritevData(stream_, kStreamId,
	/write_length=/kSomeData.size(), _, _))
	.WillOnce(Invoke([](quic::QuicStream* stream, quic::QuicStreamId id,
	size_t write_length, quic::QuicStreamOffset offset,
	quic::StreamSendingState state) {
	// WritevData does not pass the data. The data is saved to the stream,
	// so we must grab it before it's consumed, in order to check that it's
	// what was written.
	std::string data_consumed_by_quic(write_length, 'a');
	quic::QuicDataWriter writer(write_length, &data_consumed_by_quic[0],
	quic::NETWORK_BYTE_ORDER);
	stream->WriteStreamData(offset, write_length, &writer);

	EXPECT_EQ(kSomeData, data_consumed_by_quic);
	EXPECT_EQ(quic::StreamSendingState::FIN, state);
	return quic::QuicConsumedData(
	write_length, state != quic::StreamSendingState::NO_FIN);
	}));
	EXPECT_CALL(delegate_, OnWriteDataConsumed(kSomeData.size()));

	stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
	/fin=/true);
	}

	// Tests that when written data is not consumed by QUIC (due to buffering),
	// the OnWriteDataConsumed will not get fired.
	TEST_F(P2PQuicStreamTest, StreamWritesDataAndNotConsumedByQuic) {
	EXPECT_CALL(delegate_, OnWriteDataConsumed(_)).Times(0);
	EXPECT_CALL(session_, WritevData(stream_, kStreamId,
	/write_length=/kSomeData.size(), _, _))
	.WillOnce(Invoke([](quic::QuicStream* stream, quic::QuicStreamId id,
	size_t write_length, quic::QuicStreamOffset offset,
	quic::StreamSendingState state) {
	// We mock that the QUIC library is not consuming the data, meaning it's
	// being buffered. In this case, the OnWriteDataConsumed() callback
	// should not be called.
	return quic::QuicConsumedData(/bytes_consumed=/0,
	quic::StreamSendingState::NO_FIN);
	}));

	stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
	/fin=/true);
	}

	// Tests that OnWriteDataConsumed() is fired with the amount consumed by QUIC.
	// This tests the case when amount consumed by QUIC is less than what is written
	// with P2PQuicStream::WriteData. This can happen when QUIC is receiving back
	// pressure from the receive side, and its "send window" is smaller than the
	// amount attempted to be written.
	TEST_F(P2PQuicStreamTest, StreamWritesDataAndPartiallyConsumedByQuic) {
	size_t amount_consumed_by_quic = 2;
	EXPECT_CALL(delegate_, OnWriteDataConsumed(amount_consumed_by_quic));
	EXPECT_CALL(session_, WritevData(stream_, kStreamId,
	/write_length=/kSomeData.size(), _, _))
	.WillOnce(Invoke([&amount_consumed_by_quic](
	quic::QuicStream* stream, quic::QuicStreamId id,
	size_t write_length, quic::QuicStreamOffset offset,
	quic::StreamSendingState state) {
	// We mock that the QUIC library is only consuming some of the data,
	// meaning the rest is being buffered.
	return quic::QuicConsumedData(
	/bytes_consumed=/amount_consumed_by_quic,
	quic::StreamSendingState::NO_FIN);
	}));

	stream_->WriteData(std::vector<uint8_t>(kSomeData.begin(), kSomeData.end()),
	/fin=/true);
	}

	} // namespace blink