remoting/ios/bridge/client_proxy_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.

#if !defined(__has_feature) || !__has_feature(objc_arc)
#error "This file requires ARC support."
#endif

#import "remoting/ios/bridge/client_proxy.h"

#import "base/compiler_specific.h"
#import "testing/gtest_mac.h"

#import "remoting/ios/data_store.h"
#import "remoting/ios/bridge/client_proxy_delegate_wrapper.h"

@interface ClientProxyDelegateTester : NSObject<ClientProxyDelegate>
@property(nonatomic, assign) BOOL isConnected;
@property(nonatomic, copy) NSString* statusMessage;
@property(nonatomic, copy) NSString* errorMessage;
@property(nonatomic, assign) BOOL isPairingSupported;
@property(nonatomic, assign) webrtc::DesktopSize size;
@property(nonatomic, assign) NSInteger stride;
@property(nonatomic, assign) uint8_t* data;
@property(nonatomic, assign) std::vector<webrtc::DesktopRect> regions;
@property(nonatomic, assign) webrtc::DesktopVector hotspot;
@end

@implementation ClientProxyDelegateTester

@synthesize isConnected = _isConnected;
@synthesize statusMessage = _statusMessage;
@synthesize errorMessage = _errorMessage;
@synthesize isPairingSupported = _isPairingSupported;
@synthesize size = _size;
@synthesize stride = _stride;
@synthesize data = _data;
@synthesize regions = _regions;
@synthesize hotspot = _hotspot;

- (void)connected {
  _isConnected = true;
}

- (void)connectionStatus:(NSString*)statusMessage {
  _statusMessage = statusMessage;
}

- (void)connectionFailed:(NSString*)errorMessage {
  _errorMessage = errorMessage;
}

- (void)requestHostPin:(BOOL)pairingSupported {
  _isPairingSupported = pairingSupported;
}

- (void)applyFrame:(const webrtc::DesktopSize&)size
            stride:(NSInteger)stride
              data:(uint8_t*)data
           regions:(const std::vector<webrtc::DesktopRect>&)regions {
  _size = size;
  _stride = stride;
  _data = data;
  _regions.assign(regions.begin(), regions.end());
}

- (void)applyCursor:(const webrtc::DesktopSize&)size
            hotspot:(const webrtc::DesktopVector&)hotspot
         cursorData:(uint8_t*)data {
  _size = size;
  _hotspot = hotspot;
  _data = data;
}

@end

namespace remoting {

namespace {

NSString* kStatusINITIALIZING = @"Initializing connection";
NSString* kStatusCONNECTING = @"Connecting";
NSString* kStatusAUTHENTICATED = @"Authenticated";
NSString* kStatusCONNECTED = @"Connected";
NSString* kStatusFAILED = @"Connection Failed";
NSString* kStatusCLOSED = @"Connection closed";
NSString* kStatusDEFAULT = @"Unknown connection state";

NSString* kErrorPEER_IS_OFFLINE = @"Requested host is offline.";
NSString* kErrorSESSION_REJECTED = @"Session was rejected by the host.";
NSString* kErrorINCOMPATIBLE_PROTOCOL = @"Incompatible Protocol.";
NSString* kErrorAUTHENTICATION_FAILED = @"Authentication Failed.";
NSString* kErrorCHANNEL_CONNECTION_ERROR = @"Channel Connection Error";
NSString* kErrorSIGNALING_ERROR = @"Signaling Error";
NSString* kErrorSIGNALING_TIMEOUT = @"Signaling Timeout";
NSString* kErrorHOST_OVERLOAD = @"Host Overload";
NSString* kErrorUNKNOWN_ERROR =
    @"An unknown error has occurred, preventing the session from opening.";
NSString* kErrorDEFAULT = @"An unknown error code has occurred.";

const webrtc::DesktopSize kFrameSize(100, 100);

// Note these are disjoint regions.  Testing intersecting regions is beyond the
// scope of this test class.
const webrtc::DesktopRect kFrameSubRect1 =
    webrtc::DesktopRect::MakeXYWH(0, 0, 10, 10);
const webrtc::DesktopRect kFrameSubRect2 =
    webrtc::DesktopRect::MakeXYWH(11, 11, 10, 10);
const webrtc::DesktopRect kFrameSubRect3 =
    webrtc::DesktopRect::MakeXYWH(22, 22, 10, 10);

const int kCursorHeight = 10;
const int kCursorWidth = 20;
const int kCursorHotSpotX = 4;
const int kCursorHotSpotY = 8;
// |kCursorDataLength| is assumed to be evenly divisible by 4
const int kCursorDataLength = kCursorHeight * kCursorWidth;
const uint32_t kCursorDataPattern = 0xF0E1D2C3;

const std::string kHostName = "ClientProxyHostNameTest";
const std::string kPairingId = "ClientProxyPairingIdTest";
const std::string kPairingSecret = "ClientProxyPairingSecretTest";

}  // namespace

class ClientProxyTest : public ::testing::Test {
 protected:
  virtual void SetUp() OVERRIDE {
    delegateTester_ = [[ClientProxyDelegateTester alloc] init];
    clientProxy_.reset(new ClientProxy(
        [ClientProxyDelegateWrapper wrapDelegate:delegateTester_]));
  }

  void ResetIsConnected() { delegateTester_.isConnected = false; }

  void TestConnnectionStatus(protocol::ConnectionToHost::State state,
                             NSString* expectedStatusMsg) {
    ResetIsConnected();
    clientProxy_->ReportConnectionStatus(state, protocol::ErrorCode::OK);
    EXPECT_NSEQ(expectedStatusMsg, delegateTester_.statusMessage);

    if (state == protocol::ConnectionToHost::State::CONNECTED) {
      EXPECT_TRUE(delegateTester_.isConnected);
    } else {
      EXPECT_FALSE(delegateTester_.isConnected);
    }

    TestErrorMessages(state, expectedStatusMsg);
  }

  void TestForError(protocol::ConnectionToHost::State state,
                    protocol::ErrorCode errorCode,
                    NSString* expectedStatusMsg,
                    NSString* expectedErrorMsg) {
    ResetIsConnected();
    clientProxy_->ReportConnectionStatus(state, errorCode);
    EXPECT_FALSE(delegateTester_.isConnected);
    EXPECT_NSEQ(expectedStatusMsg, delegateTester_.statusMessage);
    EXPECT_NSEQ(expectedErrorMsg, delegateTester_.errorMessage);
  }

  void TestErrorMessages(protocol::ConnectionToHost::State state,
                         NSString* expectedStatusMsg) {
    TestForError(state,
                 protocol::ErrorCode::AUTHENTICATION_FAILED,
                 expectedStatusMsg,
                 kErrorAUTHENTICATION_FAILED);
    TestForError(state,
                 protocol::ErrorCode::CHANNEL_CONNECTION_ERROR,
                 expectedStatusMsg,
                 kErrorCHANNEL_CONNECTION_ERROR);
    TestForError(state,
                 protocol::ErrorCode::HOST_OVERLOAD,
                 expectedStatusMsg,
                 kErrorHOST_OVERLOAD);
    TestForError(state,
                 protocol::ErrorCode::INCOMPATIBLE_PROTOCOL,
                 expectedStatusMsg,
                 kErrorINCOMPATIBLE_PROTOCOL);
    TestForError(state,
                 protocol::ErrorCode::PEER_IS_OFFLINE,
                 expectedStatusMsg,
                 kErrorPEER_IS_OFFLINE);
    TestForError(state,
                 protocol::ErrorCode::SESSION_REJECTED,
                 expectedStatusMsg,
                 kErrorSESSION_REJECTED);
    TestForError(state,
                 protocol::ErrorCode::SIGNALING_ERROR,
                 expectedStatusMsg,
                 kErrorSIGNALING_ERROR);
    TestForError(state,
                 protocol::ErrorCode::SIGNALING_TIMEOUT,
                 expectedStatusMsg,
                 kErrorSIGNALING_TIMEOUT);
    TestForError(state,
                 protocol::ErrorCode::UNKNOWN_ERROR,
                 expectedStatusMsg,
                 kErrorUNKNOWN_ERROR);
    TestForError(state,
                 static_cast<protocol::ErrorCode>(999),
                 expectedStatusMsg,
                 kErrorDEFAULT);
  }

  void ValidateHost(const std::string& hostName,
                    const std::string& pairingId,
                    const std::string& pairingSecret) {
    DataStore* store = [DataStore sharedStore];
    NSString* hostNameAsNSString =
        [NSString stringWithUTF8String:hostName.c_str()];
    const HostPreferences* host = [store getHostForId:hostNameAsNSString];
    if (host != nil) {
      [store removeHost:host];
    }

    clientProxy_->CommitPairingCredentials(hostName, pairingId, pairingSecret);

    host = [store getHostForId:hostNameAsNSString];

    ASSERT_TRUE(host != nil);
    ASSERT_STREQ(hostName.c_str(), [host.hostId UTF8String]);
    ASSERT_STREQ(pairingId.c_str(), [host.pairId UTF8String]);
    ASSERT_STREQ(pairingSecret.c_str(), [host.pairSecret UTF8String]);
  }

  scoped_ptr<ClientProxy> clientProxy_;
  ClientProxyDelegateTester* delegateTester_;
  ClientProxyDelegateWrapper* delegateWrapper_;
};

TEST_F(ClientProxyTest, ReportConnectionStatusINITIALIZING) {
  TestConnnectionStatus(protocol::ConnectionToHost::State::INITIALIZING,
                        kStatusINITIALIZING);
}

TEST_F(ClientProxyTest, ReportConnectionStatusCONNECTING) {
  TestConnnectionStatus(protocol::ConnectionToHost::State::CONNECTING,
                        kStatusCONNECTING);
}

TEST_F(ClientProxyTest, ReportConnectionStatusAUTHENTICATED) {
  TestConnnectionStatus(protocol::ConnectionToHost::State::AUTHENTICATED,
                        kStatusAUTHENTICATED);
}

TEST_F(ClientProxyTest, ReportConnectionStatusCONNECTED) {
  TestConnnectionStatus(protocol::ConnectionToHost::State::CONNECTED,
                        kStatusCONNECTED);
}

TEST_F(ClientProxyTest, ReportConnectionStatusFAILED) {
  TestConnnectionStatus(protocol::ConnectionToHost::State::FAILED,
                        kStatusFAILED);
}

TEST_F(ClientProxyTest, ReportConnectionStatusCLOSED) {
  TestConnnectionStatus(protocol::ConnectionToHost::State::CLOSED,
                        kStatusCLOSED);
}

TEST_F(ClientProxyTest, ReportConnectionStatusDEFAULT) {
  TestConnnectionStatus(static_cast<protocol::ConnectionToHost::State>(999),
                        kStatusDEFAULT);
}

TEST_F(ClientProxyTest, DisplayAuthenticationPrompt) {
  clientProxy_->DisplayAuthenticationPrompt(true);
  ASSERT_TRUE(delegateTester_.isPairingSupported);
  clientProxy_->DisplayAuthenticationPrompt(false);
  ASSERT_FALSE(delegateTester_.isPairingSupported);
}

TEST_F(ClientProxyTest, CommitPairingCredentialsBasic) {
  ValidateHost("", "", "");
}

TEST_F(ClientProxyTest, CommitPairingCredentialsExtended) {
  ValidateHost(kHostName, kPairingId, kPairingSecret);
}

TEST_F(ClientProxyTest, RedrawCanvasBasic) {

  webrtc::BasicDesktopFrame frame(webrtc::DesktopSize(1, 1));
  webrtc::DesktopRegion regions;
  regions.AddRect(webrtc::DesktopRect::MakeLTRB(0, 0, 1, 1));

  clientProxy_->RedrawCanvas(webrtc::DesktopSize(1, 1), &frame, regions);

  ASSERT_TRUE(webrtc::DesktopSize(1, 1).equals(delegateTester_.size));
  ASSERT_EQ(4, delegateTester_.stride);
  ASSERT_TRUE(delegateTester_.data != NULL);
  ASSERT_EQ(1, delegateTester_.regions.size());
  ASSERT_TRUE(delegateTester_.regions[0].equals(
      webrtc::DesktopRect::MakeLTRB(0, 0, 1, 1)));
}
TEST_F(ClientProxyTest, RedrawCanvasExtended) {

  webrtc::BasicDesktopFrame frame(kFrameSize);
  webrtc::DesktopRegion regions;
  regions.AddRect(kFrameSubRect1);
  regions.AddRect(kFrameSubRect2);
  regions.AddRect(kFrameSubRect3);

  clientProxy_->RedrawCanvas(kFrameSize, &frame, regions);

  ASSERT_TRUE(kFrameSize.equals(delegateTester_.size));
  ASSERT_EQ(kFrameSize.width() * webrtc::DesktopFrame::kBytesPerPixel,
            delegateTester_.stride);
  ASSERT_TRUE(delegateTester_.data != NULL);
  ASSERT_EQ(3, delegateTester_.regions.size());
  ASSERT_TRUE(delegateTester_.regions[0].equals(kFrameSubRect1));
  ASSERT_TRUE(delegateTester_.regions[1].equals(kFrameSubRect2));
  ASSERT_TRUE(delegateTester_.regions[2].equals(kFrameSubRect3));
}

TEST_F(ClientProxyTest, UpdateCursorBasic) {
  protocol::CursorShapeInfo cursor_proto;
  cursor_proto.set_width(1);
  cursor_proto.set_height(1);
  cursor_proto.set_hotspot_x(0);
  cursor_proto.set_hotspot_y(0);

  char data[4];
  memset(data, 0xFF, 4);

  cursor_proto.set_data(data);

  clientProxy_->UpdateCursorShape(cursor_proto);

  ASSERT_EQ(1, delegateTester_.size.width());
  ASSERT_EQ(1, delegateTester_.size.height());
  ASSERT_EQ(0, delegateTester_.hotspot.x());
  ASSERT_EQ(0, delegateTester_.hotspot.y());
  ASSERT_TRUE(delegateTester_.data != NULL);
  for (int i = 0; i < 4; i++) {
    ASSERT_EQ(0xFF, delegateTester_.data[i]);
  }
}

TEST_F(ClientProxyTest, UpdateCursorExtended) {
  protocol::CursorShapeInfo cursor_proto;
  cursor_proto.set_width(kCursorWidth);
  cursor_proto.set_height(kCursorHeight);
  cursor_proto.set_hotspot_x(kCursorHotSpotX);
  cursor_proto.set_hotspot_y(kCursorHotSpotY);

  char data[kCursorDataLength];
  memset_pattern4(data, &kCursorDataPattern, kCursorDataLength);

  cursor_proto.set_data(data);

  clientProxy_->UpdateCursorShape(cursor_proto);

  ASSERT_EQ(kCursorWidth, delegateTester_.size.width());
  ASSERT_EQ(kCursorHeight, delegateTester_.size.height());
  ASSERT_EQ(kCursorHotSpotX, delegateTester_.hotspot.x());
  ASSERT_EQ(kCursorHotSpotY, delegateTester_.hotspot.y());
  ASSERT_TRUE(delegateTester_.data != NULL);
  for (int i = 0; i < kCursorDataLength / 4; i++) {
    ASSERT_TRUE(memcmp(&delegateTester_.data[i * 4], &kCursorDataPattern, 4) ==
                0);
  }
}

}  // namespace remoting