Use Chromium BUILD to approximate Blimp protocol version, and check it.

blimp/net/engine_authentication_handler_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/common/protocol_version.h"
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_transport.h"
 #include "blimp/net/common.h"
 #include "blimp/net/connection_error_observer.h"
 #include "blimp/net/engine_authentication_handler.h"
 #include "blimp/net/test_common.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Eq;
+using testing::Return;
 using testing::SaveArg;
 
 namespace blimp {
 namespace {
 const char client_token[] = "valid token";
 }  // namespace
 
 class EngineAuthenticationHandlerTest : public testing::Test {
  public:
   EngineAuthenticationHandlerTest()
@@ skipping 24 matching lines @@
 
 TEST_F(EngineAuthenticationHandlerTest, AuthenticationSucceeds) {
   ExpectOnConnection();
   EXPECT_CALL(*connection_, RemoveConnectionErrorObserver(_));
   EXPECT_CALL(connection_handler_, HandleConnectionPtr(Eq(connection_.get())));
   auth_handler_->HandleConnection(std::move(connection_));
   EXPECT_NE(nullptr, error_observer_);
   EXPECT_NE(nullptr, incoming_message_processor_);
 
   std::unique_ptr<BlimpMessage> blimp_message =
-      CreateStartConnectionMessage(client_token, 0);
+      CreateStartConnectionMessage(client_token, kProtocolVersion);
   net::TestCompletionCallback process_message_cb;
   incoming_message_processor_->ProcessMessage(std::move(blimp_message),
                                               process_message_cb.callback());
   EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
 }
 
+TEST_F(EngineAuthenticationHandlerTest, ProtocolMismatch) {
+  const int kInvalidProtocolVersion = -1;
+
+  BlimpMessage end_connection_message;
+  MockBlimpMessageProcessor message_processor;
+  EXPECT_CALL(message_processor, MockableProcessMessage(_, _))
+      .WillOnce(SaveArg<0>(&end_connection_message));
+  EXPECT_CALL(*connection_, GetOutgoingMessageProcessor())
+      .WillOnce(Return(&message_processor));
+
+  ExpectOnConnection();
+  auth_handler_->HandleConnection(std::move(connection_));
+
+  std::unique_ptr<BlimpMessage> blimp_message =
+      CreateStartConnectionMessage(client_token, kInvalidProtocolVersion);
+  net::TestCompletionCallback process_message_cb;
+  incoming_message_processor_->ProcessMessage(std::move(blimp_message),
+                                              process_message_cb.callback());
+  EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
+
+  EXPECT_EQ(BlimpMessage::kProtocolControl,
+            end_connection_message.feature_case());
+  EXPECT_EQ(
+      ProtocolControlMessage::kEndConnection,
+      end_connection_message.protocol_control().connection_message_case());
+  EXPECT_EQ(
+      EndConnectionMessage::PROTOCOL_MISMATCH,
+      end_connection_message.protocol_control().end_connection().reason());
+}
+
 TEST_F(EngineAuthenticationHandlerTest, AuthenticationFailed) {
   ExpectOnConnection();
   auth_handler_->HandleConnection(std::move(connection_));
 
   std::unique_ptr<BlimpMessage> blimp_message =
-      CreateStartConnectionMessage("invalid token", 0);
+      CreateStartConnectionMessage("invalid token", kProtocolVersion);
   net::TestCompletionCallback process_message_cb;
   incoming_message_processor_->ProcessMessage(std::move(blimp_message),
                                               process_message_cb.callback());
   EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
 }
 
 TEST_F(EngineAuthenticationHandlerTest, WrongMessageReceived) {
   ExpectOnConnection();
   auth_handler_->HandleConnection(std::move(connection_));
 
@@ skipping 22 matching lines @@
 
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(11));
 }
 
 TEST_F(EngineAuthenticationHandlerTest, AuthHandlerDeletedFirst) {
   ExpectOnConnection();
   auth_handler_->HandleConnection(std::move(connection_));
   auth_handler_.reset();
 
   std::unique_ptr<BlimpMessage> blimp_message =
-      CreateStartConnectionMessage(client_token, 0);
+      CreateStartConnectionMessage(client_token, kProtocolVersion);
   net::TestCompletionCallback process_message_cb;
   incoming_message_processor_->ProcessMessage(std::move(blimp_message),
                                               process_message_cb.callback());
   EXPECT_EQ(net::OK, process_message_cb.WaitForResult());
 }
 
 }  // namespace blimp