iOS Chromoting Client

remoting/ios/bridge/client_instance_unittest.mm

+// 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 "remoting/ios/bridge/client_instance.h"
+
+#include "base/compiler_specific.h"
+#include "base/run_loop.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/synchronization/waitable_event.h"
+#include "remoting/protocol/libjingle_transport_factory.h"
+#import "testing/gtest_mac.h"
+
+#include "remoting/ios/data_store.h"
+#include "remoting/ios/bridge/client_proxy.h"
+#include "remoting/ios/bridge/client_proxy_delegate_wrapper.h"
+
+@interface ClientProxyDelegateForClientInstanceTester
+    : NSObject<ClientProxyDelegate>
+
+- (void)resetDidReceiveSomething;
+
+// Validating what was received is outside of the scope for this test unit.  See
+// ClientProxyUnittest for those tests.
+@property(nonatomic, assign) BOOL didReceiveSomething;
+
+@end
+
+@implementation ClientProxyDelegateForClientInstanceTester
+
+@synthesize didReceiveSomething = _didReceiveSomething;
+
+- (void)resetDidReceiveSomething {
+  _didReceiveSomething = false;
+}
+
+- (void)requestHostPin:(BOOL)pairingSupported {
+  _didReceiveSomething = true;
+}
+
+- (void)connected {
+  _didReceiveSomething = true;
+}
+
+- (void)connectionStatus:(NSString*)statusMessage {
+  _didReceiveSomething = true;
+}
+
+- (void)connectionFailed:(NSString*)errorMessage {
+  _didReceiveSomething = true;
+}
+
+- (void)applyFrame:(const webrtc::DesktopSize&)size
+            stride:(NSInteger)stride
+              data:(uint8_t*)data
+           regions:(const std::vector<webrtc::DesktopRect>&)regions {
+  _didReceiveSomething = true;
+}
+
+- (void)applyCursor:(const webrtc::DesktopSize&)size
+            hotspot:(const webrtc::DesktopVector&)hotspot
+         cursorData:(uint8_t*)data {
+  _didReceiveSomething = true;
+}
+
+@end
+
+namespace remoting {
+
+namespace {
+
+const std::string kHostId = "HostIdTest";
+const std::string kPairingId = "PairingIdTest";
+const std::string kPairingSecret = "PairingSecretTest";
+const std::string kSecretPin = "SecretPinTest";
+
+// TODO(aboone) should be able to call RunLoop().RunUntilIdle() instead but
+// MessagePumpUIApplication::DoRun is marked NOTREACHED()
+void RunCFMessageLoop() {
+  int result;
+  do {  // Repeat until no messages remain
+    result = CFRunLoopRunInMode(
+        kCFRunLoopDefaultMode,
+        0,     // Execute queued messages, do not wait for additional messages
+        YES);  // Do only one message at a time
+  } while (result != kCFRunLoopRunStopped && result != kCFRunLoopRunFinished &&
+           result != kCFRunLoopRunTimedOut);
+}
+
+void SecretPinCallBack(const std::string& secret) {
+  ASSERT_STREQ(kSecretPin.c_str(), secret.c_str());
+}
+
+}  // namespace
+
+class ClientInstanceTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    testDelegate_.reset(
+        [[ClientProxyDelegateForClientInstanceTester alloc] init]);
+    proxy_.reset(new ClientProxy(
+        [ClientProxyDelegateWrapper wrapDelegate:testDelegate_]));
+    instance_ =
+        new ClientInstance(proxy_->AsWeakPtr(), "", "", "", "", "", "", "");
+  }
+  virtual void TearDown() OVERRIDE {
+    // Ensure memory is not leaking
+    // Notice Cleanup is safe to call, regardless of if Start() was ever called.
+    instance_->Cleanup();
+    RunCFMessageLoop();
+    // An object on the network thread which owns a reference to |instance_| may
+    // be cleaned up 'soon', but not immediately.  Lets wait it out, up to 1
+    // second.
+    for (int i = 0; i < 100; i++) {
+      if (!instance_->HasOneRef()) {
+        [NSThread sleepForTimeInterval:.01];
+      } else {
+        break;
+      }
+    }
+
+    // Remove the last reference from |instance_|, and destructor is called.
+    ASSERT_TRUE(instance_->HasOneRef());
+    instance_ = NULL;
+  }
+
+  void AssertAcknowledged(BOOL wasAcknowledged) {
+    ASSERT_EQ(wasAcknowledged, [testDelegate_ didReceiveSomething]);
+    // Reset for the next test
+    [testDelegate_ resetDidReceiveSomething];
+  }
+
+  void TestStatusAndError(protocol::ConnectionToHost::State state,
+                          protocol::ErrorCode error) {
+    instance_->OnConnectionState(state, error);
+    AssertAcknowledged(true);
+  }
+
+  void TestConnectionStatus(protocol::ConnectionToHost::State state) {
+    TestStatusAndError(state, protocol::ErrorCode::OK);
+    TestStatusAndError(state, protocol::ErrorCode::PEER_IS_OFFLINE);
+    TestStatusAndError(state, protocol::ErrorCode::SESSION_REJECTED);
+    TestStatusAndError(state, protocol::ErrorCode::INCOMPATIBLE_PROTOCOL);
+    TestStatusAndError(state, protocol::ErrorCode::AUTHENTICATION_FAILED);
+    TestStatusAndError(state, protocol::ErrorCode::CHANNEL_CONNECTION_ERROR);
+    TestStatusAndError(state, protocol::ErrorCode::SIGNALING_ERROR);
+    TestStatusAndError(state, protocol::ErrorCode::SIGNALING_TIMEOUT);
+    TestStatusAndError(state, protocol::ErrorCode::HOST_OVERLOAD);
+    TestStatusAndError(state, protocol::ErrorCode::UNKNOWN_ERROR);
+  }
+
+  base::scoped_nsobject<ClientProxyDelegateForClientInstanceTester>
+      testDelegate_;
+  scoped_ptr<ClientProxy> proxy_;
+  scoped_refptr<ClientInstance> instance_;
+};
+
+TEST_F(ClientInstanceTest, Create) {
+  // This is a test for memory leaking.  Ensure a completely unused instance of
+  // ClientInstance is destructed.
+
+  ASSERT_TRUE(instance_ != NULL);
+  ASSERT_TRUE(instance_->HasOneRef());
+}
+
+TEST_F(ClientInstanceTest, CreateAndStart) {
+  // This is a test for memory leaking.  Ensure a properly used instance of
+  // ClientInstance is destructed.
+
+  ASSERT_TRUE(instance_ != NULL);
+  ASSERT_TRUE(instance_->HasOneRef());
+
+  instance_->Start();
+  RunCFMessageLoop();
+  ASSERT_TRUE(!instance_->HasOneRef());  // more than one
+}
+
+TEST_F(ClientInstanceTest, SecretPin) {
+  NSString* hostId = [NSString stringWithUTF8String:kHostId.c_str()];
+  NSString* pairingId = [NSString stringWithUTF8String:kPairingId.c_str()];
+  NSString* pairingSecret =
+      [NSString stringWithUTF8String:kPairingSecret.c_str()];
+
+  DataStore* store = [DataStore sharedStore];
+
+  const HostPreferences* host = [store createHost:hostId];
+  host.pairId = pairingId;
+  host.pairSecret = pairingSecret;
+  [store saveChanges];
+
+  // Suggesting that our pairing Id is known, but since its obviously not we
+  // expect it to be discarded when requesting the PIN.
+  instance_ = new ClientInstance(
+      proxy_->AsWeakPtr(), "", "", "", kHostId, "", kPairingId, kPairingSecret);
+
+  instance_->Start();
+  RunCFMessageLoop();
+
+  instance_->FetchSecret(false, base::Bind(&SecretPinCallBack));
+  RunCFMessageLoop();
+  AssertAcknowledged(true);
+
+  // The pairing information was discarded
+  host = [store getHostForId:hostId];
+  ASSERT_NSEQ(@"", host.pairId);
+  ASSERT_NSEQ(@"", host.pairSecret);
+
+  instance_->ProvideSecret(kSecretPin, false);
+  RunCFMessageLoop();
+}
+
+TEST_F(ClientInstanceTest, NoProxy) {
+  // After the proxy is released, we still expect quite a few functions to be
+  // able to run, but not produce any output.  Some of these are just being
+  // executed for code coverage, the outputs are not pertinent to this test
+  // unit.
+  proxy_.reset();
+
+  instance_->Start();
+  RunCFMessageLoop();
+
+  instance_->FetchSecret(false, base::Bind(&SecretPinCallBack));
+  AssertAcknowledged(false);
+
+  instance_->ProvideSecret(kSecretPin, false);
+  AssertAcknowledged(false);
+
+  instance_->PerformMouseAction(
+      webrtc::DesktopVector(0, 0), webrtc::DesktopVector(0, 0), 0, false);
+  AssertAcknowledged(false);
+
+  instance_->PerformKeyboardAction(0, false);
+  AssertAcknowledged(false);
+
+  instance_->OnConnectionState(protocol::ConnectionToHost::State::CONNECTED,
+                               protocol::ErrorCode::OK);
+  AssertAcknowledged(false);
+
+  instance_->OnConnectionReady(false);
+  AssertAcknowledged(false);
+
+  instance_->OnRouteChanged("", protocol::TransportRoute());
+  AssertAcknowledged(false);
+
+  // SetCapabilities requires a host connection to be established
+  // instance_->SetCapabilities("");
+  // AssertAcknowledged(false);
+
+  instance_->SetPairingResponse(protocol::PairingResponse());
+  AssertAcknowledged(false);
+
+  instance_->DeliverHostMessage(protocol::ExtensionMessage());
+  AssertAcknowledged(false);
+
+  ASSERT_TRUE(instance_->GetClipboardStub() != NULL);
+  ASSERT_TRUE(instance_->GetCursorShapeStub() != NULL);
+  ASSERT_TRUE(instance_->GetTokenFetcher("") == NULL);
+
+  instance_->InjectClipboardEvent(protocol::ClipboardEvent());
+  AssertAcknowledged(false);
+
+  instance_->SetCursorShape(protocol::CursorShapeInfo());
+  AssertAcknowledged(false);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionStateINITIALIZING) {
+  TestConnectionStatus(protocol::ConnectionToHost::State::INITIALIZING);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionStateCONNECTING) {
+  TestConnectionStatus(protocol::ConnectionToHost::State::CONNECTING);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionStateAUTHENTICATED) {
+  TestConnectionStatus(protocol::ConnectionToHost::State::AUTHENTICATED);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionStateCONNECTED) {
+  TestConnectionStatus(protocol::ConnectionToHost::State::CONNECTED);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionStateFAILED) {
+  TestConnectionStatus(protocol::ConnectionToHost::State::FAILED);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionStateCLOSED) {
+  TestConnectionStatus(protocol::ConnectionToHost::State::CLOSED);
+}
+
+TEST_F(ClientInstanceTest, OnConnectionReady) {
+  instance_->OnConnectionReady(true);
+  AssertAcknowledged(false);
+  instance_->OnConnectionReady(false);
+  AssertAcknowledged(false);
+}
+
+TEST_F(ClientInstanceTest, OnRouteChanged) {
+  // Not expecting anything to happen
+  protocol::TransportRoute route;
+
+  route.type = protocol::TransportRoute::DIRECT;
+  instance_->OnRouteChanged("", route);
+  AssertAcknowledged(false);
+
+  route.type = protocol::TransportRoute::STUN;
+  instance_->OnRouteChanged("", route);
+  AssertAcknowledged(false);
+
+  route.type = protocol::TransportRoute::RELAY;
+  instance_->OnRouteChanged("", route);
+  AssertAcknowledged(false);
+}
+
+TEST_F(ClientInstanceTest, SetCursorShape) {
+  instance_->SetCursorShape(protocol::CursorShapeInfo());
+  AssertAcknowledged(true);
+}
+
+}  // namespace remoting