device/serial/serial_service_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 "base/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/run_loop.h"
   8 #include "device/serial/serial.mojom.h"
   9 #include "device/serial/serial_service_impl.h"
  10 #include "device/serial/test_serial_io_handler.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
  13 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_ptr.h"
  14 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
  15
  16 namespace device {
  17 namespace {
  18
  19 class FakeSerialDeviceEnumerator : public SerialDeviceEnumerator {
  20   mojo::Array<serial::DeviceInfoPtr> GetDevices() override {
  21     mojo::Array<serial::DeviceInfoPtr> devices(1);
  22     devices[0] = serial::DeviceInfo::New();
  23     devices[0]->path = "device";
  24     return devices.Pass();
  25   }
  26 };
  27
  28 class FailToOpenIoHandler : public TestSerialIoHandler {
  29  public:
  30   void Open(const std::string& port,
  31             const serial::ConnectionOptions& options,
  32             const OpenCompleteCallback& callback) override {
  33     callback.Run(false);
  34   }
  35
  36  protected:
  37   ~FailToOpenIoHandler() override {}
  38 };
  39
  40 }  // namespace
  41
  42 class SerialServiceTest : public testing::Test, public mojo::ErrorHandler {
  43  public:
  44   SerialServiceTest() : connected_(false), expecting_error_(false) {}
  45
  46   void StoreDevices(mojo::Array<serial::DeviceInfoPtr> devices) {
  47     devices_ = devices.Pass();
  48     StopMessageLoop();
  49   }
  50
  51   void OnConnectionError() override {
  52     StopMessageLoop();
  53     EXPECT_TRUE(expecting_error_);
  54   }
  55
  56   void RunMessageLoop() {
  57     run_loop_.reset(new base::RunLoop);
  58     run_loop_->Run();
  59   }
  60
  61   void StopMessageLoop() {
  62     ASSERT_TRUE(run_loop_);
  63     message_loop_.PostTask(FROM_HERE, run_loop_->QuitClosure());
  64   }
  65
  66   void OnGotInfo(serial::ConnectionInfoPtr options) {
  67     connected_ = true;
  68     StopMessageLoop();
  69   }
  70
  71   scoped_refptr<SerialIoHandler> ReturnIoHandler() { return io_handler_; }
  72
  73   void RunConnectTest(const std::string& path, bool expecting_success) {
  74     if (!io_handler_.get())
  75       io_handler_ = new TestSerialIoHandler;
  76     mojo::InterfacePtr<serial::SerialService> service;
  77     new SerialServiceImpl(
  78         new SerialConnectionFactory(
  79             base::Bind(&SerialServiceTest::ReturnIoHandler,
  80                        base::Unretained(this)),
  81             base::ThreadTaskRunnerHandle::Get()),
  82         scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator),
  83         mojo::GetProxy(&service));
  84     mojo::InterfacePtr<serial::Connection> connection;
  85     mojo::InterfacePtr<serial::DataSink> sink;
  86     mojo::InterfacePtr<serial::DataSource> source;
  87     mojo::InterfacePtr<serial::DataSourceClient> source_client;
  88     mojo::GetProxy(&source_client);
  89     service->Connect(path, serial::ConnectionOptions::New(),
  90                      mojo::GetProxy(&connection), mojo::GetProxy(&sink),
  91                      mojo::GetProxy(&source), source_client.Pass());
  92     connection.set_error_handler(this);
  93     expecting_error_ = !expecting_success;
  94     connection->GetInfo(
  95         base::Bind(&SerialServiceTest::OnGotInfo, base::Unretained(this)));
  96     RunMessageLoop();
  97     EXPECT_EQ(!expecting_success, connection.encountered_error());
  98     EXPECT_EQ(expecting_success, connected_);
  99     connection.reset();
 100   }
 101
 102   base::MessageLoop message_loop_;
 103   scoped_ptr<base::RunLoop> run_loop_;
 104   mojo::Array<serial::DeviceInfoPtr> devices_;
 105   scoped_refptr<TestSerialIoHandler> io_handler_;
 106   bool connected_;
 107   bool expecting_error_;
 108   serial::ConnectionInfoPtr info_;
 109
 110  private:
 111   DISALLOW_COPY_AND_ASSIGN(SerialServiceTest);
 112 };
 113
 114 TEST_F(SerialServiceTest, GetDevices) {
 115   mojo::InterfacePtr<serial::SerialService> service;
 116   SerialServiceImpl::Create(NULL, NULL, mojo::GetProxy(&service));
 117   service.set_error_handler(this);
 118   mojo::Array<serial::DeviceInfoPtr> result;
 119   service->GetDevices(
 120       base::Bind(&SerialServiceTest::StoreDevices, base::Unretained(this)));
 121   RunMessageLoop();
 122
 123   // Because we're running on unknown hardware, only check that we received a
 124   // non-null result.
 125   EXPECT_TRUE(devices_);
 126 }
 127
 128 TEST_F(SerialServiceTest, Connect) {
 129   RunConnectTest("device", true);
 130 }
 131
 132 TEST_F(SerialServiceTest, ConnectInvalidPath) {
 133   RunConnectTest("invalid_path", false);
 134 }
 135
 136 TEST_F(SerialServiceTest, ConnectOpenFailed) {
 137   io_handler_ = new FailToOpenIoHandler;
 138   RunConnectTest("device", false);
 139 }
 140
 141 }  // namespace device