Add a partial Mojo serial connection interface and implementation.

device/serial/serial_service_unittest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "device/serial/serial.mojom.h"
 #include "device/serial/serial_service_impl.h"
+#include "device/serial/test_serial_io_handler.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
+namespace {
+
+class FakeSerialDeviceEnumerator : public SerialDeviceEnumerator {
+  virtual mojo::Array<serial::DeviceInfoPtr> GetDevices() OVERRIDE {
+    mojo::Array<serial::DeviceInfoPtr> devices(1);
+    devices[0] = serial::DeviceInfo::New();
+    devices[0]->path = "device";
+    return devices.Pass();
+  }
+};
+
+class FailToOpenIoHandler : public TestSerialIoHandler {
+ public:
+  static scoped_refptr<SerialIoHandler> Create() {
+    return new FailToOpenIoHandler;
+  }
+
+  virtual void Open(const std::string& port,
+                    const OpenCompleteCallback& callback) OVERRIDE {
+    callback.Run(false);
+  }
+
+ protected:
+  virtual ~FailToOpenIoHandler() {}
+};
+
+}  // namespace
 
 class SerialServiceTest : public testing::Test, public mojo::ErrorHandler {
  public:
   SerialServiceTest() {}
 
   void StoreDevices(mojo::Array<serial::DeviceInfoPtr> devices) {
     devices_ = devices.Pass();
-    message_loop_.PostTask(FROM_HERE, run_loop_.QuitClosure());
+    StopMessageLoop();
   }
 
   virtual void OnConnectionError() OVERRIDE {
-    message_loop_.PostTask(FROM_HERE, run_loop_.QuitClosure());
-    FAIL() << "Connection error";
+    StopMessageLoop();
+    EXPECT_TRUE(expecting_error_);
   }
 
+  void RunMessageLoop() {
+    run_loop_.reset(new base::RunLoop);
+    run_loop_->Run();
+  }
+
+  void StopMessageLoop() {
+    ASSERT_TRUE(run_loop_);
+    message_loop_.PostTask(FROM_HERE, run_loop_->QuitClosure());
+  }
+
+  void OnGotInfo(serial::ConnectionInfoPtr options) { StopMessageLoop(); }
+
   base::MessageLoop message_loop_;
-  base::RunLoop run_loop_;
+  scoped_ptr<base::RunLoop> run_loop_;
   mojo::Array<serial::DeviceInfoPtr> devices_;
+  scoped_refptr<TestSerialIoHandler> io_handler_;
+  bool expecting_error_;
+  serial::ConnectionInfoPtr info_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SerialServiceTest);
 };
 
 TEST_F(SerialServiceTest, GetDevices) {
   mojo::InterfacePtr<serial::SerialService> service;
-  SerialServiceImpl::Create(mojo::Get(&service));
+  SerialServiceImpl::Create(NULL, mojo::Get(&service));
   service.set_error_handler(this);
   mojo::Array<serial::DeviceInfoPtr> result;
   service->GetDevices(
       base::Bind(&SerialServiceTest::StoreDevices, base::Unretained(this)));
-  run_loop_.Run();
+  RunMessageLoop();
 
   // Because we're running on unknown hardware, only check that we received a
   // non-null result.
   EXPECT_TRUE(devices_);
 }
 
+TEST_F(SerialServiceTest, Connect) {
+  mojo::InterfacePtr<serial::SerialService> service;
+  mojo::BindToProxy(
+      new SerialServiceImpl(
+          new SerialConnectionFactory(base::Bind(&TestSerialIoHandler::Create),
+                                      base::MessageLoopProxy::current()),
+          scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator)),
+      &service);
+  service.set_error_handler(this);
+  mojo::InterfacePtr<serial::Connection> connection;
+  service->Connect(
+      "device", serial::ConnectionOptions::New(), mojo::Get(&connection));
+  connection.set_error_handler(this);
+  connection->GetInfo(
+      base::Bind(&SerialServiceTest::OnGotInfo, base::Unretained(this)));
+  RunMessageLoop();
+  connection.reset();
+}
+
+TEST_F(SerialServiceTest, ConnectInvalidPath) {
+  mojo::InterfacePtr<serial::SerialService> service;
+  mojo::BindToProxy(
+      new SerialServiceImpl(
+          new SerialConnectionFactory(base::Bind(&TestSerialIoHandler::Create),
+                                      base::MessageLoopProxy::current()),
+          scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator)),
+      &service);
+  mojo::InterfacePtr<serial::Connection> connection;
+  service->Connect(
+      "invalid_path", serial::ConnectionOptions::New(), mojo::Get(&connection));
+  connection.set_error_handler(this);
+  expecting_error_ = true;
+  RunMessageLoop();
+  EXPECT_TRUE(connection.encountered_error());
+}
+
+TEST_F(SerialServiceTest, ConnectOpenFailed) {
+  mojo::InterfacePtr<serial::SerialService> service;
+  mojo::BindToProxy(
+      new SerialServiceImpl(
+          new SerialConnectionFactory(base::Bind(&FailToOpenIoHandler::Create),
+                                      base::MessageLoopProxy::current()),
+          scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator)),
+      &service);
+  mojo::InterfacePtr<serial::Connection> connection;
+  service->Connect(
+      "device", serial::ConnectionOptions::New(), mojo::Get(&connection));
+  expecting_error_ = true;
+  connection.set_error_handler(this);
+  RunMessageLoop();
+  EXPECT_TRUE(connection.encountered_error());
+}
+
 }  // namespace device