chromeos/network/firewall_hole_unittest.cc

   1 // Copyright 2015 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 "base/bind.h"
   6 #include "base/run_loop.h"
   7 #include "chromeos/dbus/dbus_thread_manager.h"
   8 #include "chromeos/dbus/fake_permission_broker_client.h"
   9 #include "chromeos/network/firewall_hole.h"
  10 #include "dbus/file_descriptor.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using chromeos::DBusThreadManager;
  15 using chromeos::FirewallHole;
  16 using testing::_;
  17
  18 namespace {
  19
  20 ACTION_TEMPLATE(InvokeCallback,
  21                 HAS_1_TEMPLATE_PARAMS(int, k),
  22                 AND_1_VALUE_PARAMS(p1)) {
  23   ::std::tr1::get<k>(args).Run(p1);
  24 }
  25
  26 class MockPermissionsBrokerClient : public chromeos::PermissionBrokerClient {
  27  public:
  28   MockPermissionsBrokerClient() {}
  29   ~MockPermissionsBrokerClient() override {}
  30
  31   MOCK_METHOD1(Init, void(dbus::Bus* bus));
  32   MOCK_METHOD3(RequestPathAccess,
  33                void(const std::string& path,
  34                     int interface_id,
  35                     const ResultCallback& callback));
  36   MOCK_METHOD4(RequestTcpPortAccess,
  37                void(uint16 port,
  38                     const std::string& interface,
  39                     const dbus::FileDescriptor& lifeline_fd,
  40                     const ResultCallback& callback));
  41   MOCK_METHOD4(RequestUdpPortAccess,
  42                void(uint16 port,
  43                     const std::string& interface,
  44                     const dbus::FileDescriptor& lifeline_fd,
  45                     const ResultCallback& callback));
  46   MOCK_METHOD3(ReleaseTcpPort,
  47                void(uint16 port,
  48                     const std::string& interface,
  49                     const ResultCallback& callback));
  50   MOCK_METHOD3(ReleaseUdpPort,
  51                void(uint16 port,
  52                     const std::string& interface,
  53                     const ResultCallback& callback));
  54 };
  55
  56 }  // namespace
  57
  58 class FirewallHoleTest : public testing::Test {
  59  public:
  60   FirewallHoleTest() {}
  61   ~FirewallHoleTest() override {}
  62
  63   void SetUp() override {
  64     mock_permissions_broker_client_ = new MockPermissionsBrokerClient();
  65     DBusThreadManager::GetSetterForTesting()->SetPermissionBrokerClient(
  66         make_scoped_ptr(mock_permissions_broker_client_));
  67   }
  68
  69   void TearDown() override { DBusThreadManager::Shutdown(); }
  70
  71   void AssertOpenSuccess(scoped_ptr<FirewallHole> hole) {
  72     EXPECT_TRUE(hole.get() != nullptr);
  73     run_loop_.Quit();
  74   }
  75
  76   void AssertOpenFailure(scoped_ptr<FirewallHole> hole) {
  77     EXPECT_TRUE(hole.get() == nullptr);
  78     run_loop_.Quit();
  79   }
  80
  81  private:
  82   base::MessageLoopForUI message_loop_;
  83
  84  protected:
  85   base::RunLoop run_loop_;
  86   MockPermissionsBrokerClient* mock_permissions_broker_client_ = nullptr;
  87 };
  88
  89 TEST_F(FirewallHoleTest, GrantTcpPortAccess) {
  90   EXPECT_CALL(*mock_permissions_broker_client_,
  91               RequestTcpPortAccess(1234, "foo0", _, _))
  92       .WillOnce(InvokeCallback<3>(true));
  93   EXPECT_CALL(*mock_permissions_broker_client_, ReleaseTcpPort(1234, "foo0", _))
  94       .WillOnce(InvokeCallback<2>(true));
  95
  96   FirewallHole::Open(
  97       FirewallHole::PortType::TCP, 1234, "foo0",
  98       base::Bind(&FirewallHoleTest::AssertOpenSuccess, base::Unretained(this)));
  99   run_loop_.Run();
 100 }
 101
 102 TEST_F(FirewallHoleTest, DenyTcpPortAccess) {
 103   EXPECT_CALL(*mock_permissions_broker_client_,
 104               RequestTcpPortAccess(1234, "foo0", _, _))
 105       .WillOnce(InvokeCallback<3>(false));
 106
 107   FirewallHole::Open(
 108       FirewallHole::PortType::TCP, 1234, "foo0",
 109       base::Bind(&FirewallHoleTest::AssertOpenFailure, base::Unretained(this)));
 110   run_loop_.Run();
 111 }
 112
 113 TEST_F(FirewallHoleTest, GrantUdpPortAccess) {
 114   EXPECT_CALL(*mock_permissions_broker_client_,
 115               RequestUdpPortAccess(1234, "foo0", _, _))
 116       .WillOnce(InvokeCallback<3>(true));
 117   EXPECT_CALL(*mock_permissions_broker_client_, ReleaseUdpPort(1234, "foo0", _))
 118       .WillOnce(InvokeCallback<2>(true));
 119
 120   FirewallHole::Open(
 121       FirewallHole::PortType::UDP, 1234, "foo0",
 122       base::Bind(&FirewallHoleTest::AssertOpenSuccess, base::Unretained(this)));
 123   run_loop_.Run();
 124 }
 125
 126 TEST_F(FirewallHoleTest, DenyUdpPortAccess) {
 127   EXPECT_CALL(*mock_permissions_broker_client_,
 128               RequestUdpPortAccess(1234, "foo0", _, _))
 129       .WillOnce(InvokeCallback<3>(false));
 130
 131   FirewallHole::Open(
 132       FirewallHole::PortType::UDP, 1234, "foo0",
 133       base::Bind(&FirewallHoleTest::AssertOpenFailure, base::Unretained(this)));
 134   run_loop_.Run();
 135 }