components/cast_channel/cast_framer_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/cast_channel/cast_framer.h"
   6
   7 #include <stddef.h>
   8
   9 #include <algorithm>
  10 #include <string>
  11
  12 #include "components/cast_channel/proto/cast_channel.pb.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace cast_channel {
  16
  17 using ::cast_channel::ChannelError;
  18
  19 class CastFramerTest : public testing::Test {
  20  public:
  21   CastFramerTest() {}
  22   ~CastFramerTest() override {}
  23
  24   void SetUp() override {
  25     cast_message_.set_protocol_version(CastMessage::CASTV2_1_0);
  26     cast_message_.set_source_id("source");
  27     cast_message_.set_destination_id("destination");
  28     cast_message_.set_namespace_("namespace");
  29     cast_message_.set_payload_type(CastMessage::STRING);
  30     cast_message_.set_payload_utf8("payload");
  31     ASSERT_TRUE(MessageFramer::Serialize(cast_message_, &cast_message_str_));
  32
  33     buffer_ = base::MakeRefCounted<net::GrowableIOBuffer>();
  34     buffer_->SetCapacity(MessageFramer::MessageHeader::max_message_size());
  35     framer_.reset(new MessageFramer(buffer_.get()));
  36   }
  37
  38   void WriteToBuffer(const std::string& data) {
  39     memcpy(buffer_->StartOfBuffer(), data.data(), data.size());
  40   }
  41
  42  protected:
  43   CastMessage cast_message_;
  44   std::string cast_message_str_;
  45   scoped_refptr<net::GrowableIOBuffer> buffer_;
  46   std::unique_ptr<MessageFramer> framer_;
  47 };
  48
  49 TEST_F(CastFramerTest, TestMessageFramerCompleteMessage) {
  50   ChannelError error;
  51   size_t message_length;
  52
  53   WriteToBuffer(cast_message_str_);
  54
  55   // Receive 1 byte of the header, framer demands 3 more bytes.
  56   EXPECT_EQ(4u, framer_->BytesRequested());
  57   EXPECT_EQ(nullptr, framer_->Ingest(1, &message_length, &error).get());
  58   EXPECT_EQ(ChannelError::NONE, error);
  59   EXPECT_EQ(3u, framer_->BytesRequested());
  60
  61   // Ingest remaining 3, expect that the framer has moved on to requesting the
  62   // body contents.
  63   EXPECT_EQ(nullptr, framer_->Ingest(3, &message_length, &error).get());
  64   EXPECT_EQ(ChannelError::NONE, error);
  65   EXPECT_EQ(
  66       cast_message_str_.size() - MessageFramer::MessageHeader::header_size(),
  67       framer_->BytesRequested());
  68
  69   // Remainder of packet sent over the wire.
  70   std::unique_ptr<CastMessage> message;
  71   message = framer_->Ingest(framer_->BytesRequested(), &message_length, &error);
  72   EXPECT_NE(static_cast<CastMessage*>(nullptr), message.get());
  73   EXPECT_EQ(ChannelError::NONE, error);
  74   EXPECT_EQ(message->SerializeAsString(), cast_message_.SerializeAsString());
  75   EXPECT_EQ(4u, framer_->BytesRequested());
  76   EXPECT_EQ(message->SerializeAsString().size(), message_length);
  77 }
  78
  79 TEST_F(CastFramerTest, TestSerializeErrorMessageTooLarge) {
  80   std::string serialized;
  81   CastMessage big_message;
  82   big_message.CopyFrom(cast_message_);
  83   std::string payload;
  84   payload.append(MessageFramer::MessageHeader::max_body_size() + 1, 'x');
  85   big_message.set_payload_utf8(payload);
  86   EXPECT_FALSE(MessageFramer::Serialize(big_message, &serialized));
  87 }
  88
  89 TEST_F(CastFramerTest, TestIngestIllegalLargeMessage) {
  90   std::string mangled_cast_message = cast_message_str_;
  91   mangled_cast_message[0] = 88;
  92   mangled_cast_message[1] = 88;
  93   mangled_cast_message[2] = 88;
  94   mangled_cast_message[3] = 88;
  95   WriteToBuffer(mangled_cast_message);
  96
  97   size_t bytes_ingested;
  98   ChannelError error;
  99   EXPECT_EQ(4u, framer_->BytesRequested());
 100   EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
 101   EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
 102   EXPECT_EQ(0u, framer_->BytesRequested());
 103
 104   // Test that the parser enters a terminal error state.
 105   WriteToBuffer(cast_message_str_);
 106   EXPECT_EQ(0u, framer_->BytesRequested());
 107   EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
 108   EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
 109   EXPECT_EQ(0u, framer_->BytesRequested());
 110 }
 111
 112 TEST_F(CastFramerTest, TestIngestIllegalLargeMessage2) {
 113   std::string mangled_cast_message = cast_message_str_;
 114   // Header indicates body size is 0x00010001 = 65537
 115   mangled_cast_message[0] = 0;
 116   mangled_cast_message[1] = 0x1;
 117   mangled_cast_message[2] = 0;
 118   mangled_cast_message[3] = 0x1;
 119   WriteToBuffer(mangled_cast_message);
 120
 121   size_t bytes_ingested;
 122   ChannelError error;
 123   EXPECT_EQ(4u, framer_->BytesRequested());
 124   EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
 125   EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
 126   EXPECT_EQ(0u, framer_->BytesRequested());
 127
 128   // Test that the parser enters a terminal error state.
 129   WriteToBuffer(cast_message_str_);
 130   EXPECT_EQ(0u, framer_->BytesRequested());
 131   EXPECT_EQ(nullptr, framer_->Ingest(4, &bytes_ingested, &error).get());
 132   EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
 133   EXPECT_EQ(0u, framer_->BytesRequested());
 134 }
 135
 136 TEST_F(CastFramerTest, TestUnparsableBodyProto) {
 137   // Message header is OK, but the body is replaced with "x"en.
 138   std::string mangled_cast_message = cast_message_str_;
 139   for (size_t i = MessageFramer::MessageHeader::header_size();
 140        i < mangled_cast_message.size(); ++i) {
 141     std::fill(mangled_cast_message.begin() +
 142                   MessageFramer::MessageHeader::header_size(),
 143               mangled_cast_message.end(), 'x');
 144   }
 145   WriteToBuffer(mangled_cast_message);
 146
 147   // Send header.
 148   size_t message_length;
 149   ChannelError error;
 150   EXPECT_EQ(4u, framer_->BytesRequested());
 151   EXPECT_EQ(nullptr, framer_->Ingest(4, &message_length, &error).get());
 152   EXPECT_EQ(ChannelError::NONE, error);
 153   EXPECT_EQ(cast_message_str_.size() - 4, framer_->BytesRequested());
 154
 155   // Send body, expect an error.
 156   std::unique_ptr<CastMessage> message;
 157   EXPECT_EQ(nullptr,
 158             framer_->Ingest(framer_->BytesRequested(), &message_length, &error)
 159                 .get());
 160   EXPECT_EQ(ChannelError::INVALID_MESSAGE, error);
 161 }
 162 }  // namespace cast_channel