talk/examples/objc/AppRTCDemo/tests/ARDAppClientTest.mm - src - Git at Google

 /*
  * libjingle
  * Copyright 2014, Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */


 #import <Foundation/Foundation.h>
 #import <OCMock/OCMock.h>

 #import "ARDAppClient+Internal.h"
 #import "ARDRegisterResponse+Internal.h"
 #import "ARDMessageResponse+Internal.h"
 #import "RTCMediaConstraints.h"
 #import "RTCPeerConnectionFactory.h"

 #include "webrtc/base/gunit.h"
 #include "webrtc/base/ssladapter.h"

 // These classes mimic XCTest APIs, to make eventual conversion to XCTest
 // easier. Conversion will happen once XCTest is supported well on build bots.
 @interface ARDTestExpectation : NSObject

 @property(nonatomic, readonly) NSString *description;
 @property(nonatomic, readonly) BOOL isFulfilled;

 - (instancetype)initWithDescription:(NSString *)description;
 - (void)fulfill;

 @end

 @implementation ARDTestExpectation

 @synthesize description = _description;
 @synthesize isFulfilled = _isFulfilled;

 - (instancetype)initWithDescription:(NSString *)description {
   if (self = [super init]) {
     _description = description;
   }
   return self;
 }

 - (void)fulfill {
   _isFulfilled = YES;
 }

 @end

 @interface ARDTestCase : NSObject

 - (ARDTestExpectation *)expectationWithDescription:(NSString *)description;
 - (void)waitForExpectationsWithTimeout:(NSTimeInterval)timeout
                                handler:(void (^)(NSError *error))handler;

 @end

 @implementation ARDTestCase {
   NSMutableArray *_expectations;
 }

 - (instancetype)init {
   if (self = [super init]) {
    _expectations = [NSMutableArray array];
   }
   return self;
 }

 - (ARDTestExpectation *)expectationWithDescription:(NSString *)description {
   ARDTestExpectation *expectation =
       [[ARDTestExpectation alloc] initWithDescription:description];
   [_expectations addObject:expectation];
   return expectation;
 }

 - (void)waitForExpectationsWithTimeout:(NSTimeInterval)timeout
                                handler:(void (^)(NSError *error))handler {
   NSDate *startDate = [NSDate date];
   while (![self areExpectationsFulfilled]) {
     NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startDate];
     if (duration > timeout) {
       NSAssert(NO, @"Expectation timed out.");
       break;
     }
     [[NSRunLoop currentRunLoop]
         runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];
   }
   handler(nil);
 }

 - (BOOL)areExpectationsFulfilled {
   for (ARDTestExpectation *expectation in _expectations) {
     if (!expectation.isFulfilled) {
       return NO;
     }
   }
   return YES;
 }

 @end

 @interface ARDAppClientTest : ARDTestCase
 @end

 @implementation ARDAppClientTest

 #pragma mark - Mock helpers

 - (id)mockRoomServerClientForRoomId:(NSString *)roomId
                            clientId:(NSString *)clientId
                         isInitiator:(BOOL)isInitiator
                            messages:(NSArray *)messages
                      messageHandler:
     (void (^)(ARDSignalingMessage *))messageHandler {
   id mockRoomServerClient =
       [OCMockObject mockForProtocol:@protocol(ARDRoomServerClient)];

   // Successful register response.
   ARDRegisterResponse *registerResponse = [[ARDRegisterResponse alloc] init];
   registerResponse.result = kARDRegisterResultTypeSuccess;
   registerResponse.roomId = roomId;
   registerResponse.clientId = clientId;
   registerResponse.isInitiator = isInitiator;
   registerResponse.messages = messages;

   // Successful message response.
   ARDMessageResponse *messageResponse = [[ARDMessageResponse alloc] init];
   messageResponse.result = kARDMessageResultTypeSuccess;

   // Return register response from above on register.
   [[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
     __unsafe_unretained void (^completionHandler)(ARDRegisterResponse *response,
                                                   NSError *error);
     [invocation getArgument:&completionHandler atIndex:3];
     completionHandler(registerResponse, nil);
   }] registerForRoomId:roomId completionHandler:[OCMArg any]];

   // Return message response from above on register.
   [[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
     __unsafe_unretained ARDSignalingMessage *message;
     __unsafe_unretained void (^completionHandler)(ARDMessageResponse *response,
                                                   NSError *error);
     [invocation getArgument:&message atIndex:2];
     [invocation getArgument:&completionHandler atIndex:5];
     messageHandler(message);
     completionHandler(messageResponse, nil);
   }] sendMessage:[OCMArg any]
             forRoomId:roomId
              clientId:clientId
     completionHandler:[OCMArg any]];

   // Do nothing on deregister.
   [[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
     __unsafe_unretained void (^completionHandler)(NSError *error);
     [invocation getArgument:&completionHandler atIndex:4];
     if (completionHandler) {
       completionHandler(nil);
     }
   }] deregisterForRoomId:roomId
                 clientId:clientId
        completionHandler:[OCMArg any]];

   return mockRoomServerClient;
 }

 - (id)mockSignalingChannelForRoomId:(NSString *)roomId
                            clientId:(NSString *)clientId
                      messageHandler:
     (void (^)(ARDSignalingMessage *message))messageHandler {
   id mockSignalingChannel =
       [OCMockObject niceMockForProtocol:@protocol(ARDSignalingChannel)];
   [[mockSignalingChannel stub] registerForRoomId:roomId clientId:clientId];
   [[[mockSignalingChannel stub] andDo:^(NSInvocation *invocation) {
     __unsafe_unretained ARDSignalingMessage *message;
     [invocation getArgument:&message atIndex:2];
     messageHandler(message);
   }] sendMessage:[OCMArg any]];
   return mockSignalingChannel;
 }

 - (id)mockTURNClient {
   id mockTURNClient =
       [OCMockObject mockForProtocol:@protocol(ARDTURNClient)];
   [[[mockTURNClient stub] andDo:^(NSInvocation *invocation) {
     // Don't return anything in TURN response.
     __unsafe_unretained void (^completionHandler)(NSArray *turnServers,
                                                   NSError *error);
     [invocation getArgument:&completionHandler atIndex:2];
     completionHandler([NSArray array], nil);
   }] requestServersWithCompletionHandler:[OCMArg any]];
   return mockTURNClient;
 }

 - (ARDAppClient *)createAppClientForRoomId:(NSString *)roomId
                                   clientId:(NSString *)clientId
                                isInitiator:(BOOL)isInitiator
                                   messages:(NSArray *)messages
                             messageHandler:
     (void (^)(ARDSignalingMessage *message))messageHandler
                           connectedHandler:(void (^)(void))connectedHandler {
   id turnClient = [self mockTURNClient];
   id signalingChannel = [self mockSignalingChannelForRoomId:roomId
                                                    clientId:clientId
                                              messageHandler:messageHandler];
   id roomServerClient =
       [self mockRoomServerClientForRoomId:roomId
                                  clientId:clientId
                               isInitiator:isInitiator
                                  messages:messages
                            messageHandler:messageHandler];
   id delegate =
       [OCMockObject niceMockForProtocol:@protocol(ARDAppClientDelegate)];
   [[[delegate stub] andDo:^(NSInvocation *invocation) {
     connectedHandler();
   }] appClient:[OCMArg any] didChangeConnectionState:RTCICEConnectionConnected];

   return [[ARDAppClient alloc] initWithRoomServerClient:roomServerClient
                                        signalingChannel:signalingChannel
                                              turnClient:turnClient
                                                delegate:delegate];
 }

 // Tests that an ICE connection is established between two ARDAppClient objects
 // where one is set up as a caller and the other the answerer. Network
 // components are mocked out and messages are relayed directly from object to
 // object. It's expected that both clients reach the RTCICEConnectionConnected
 // state within a reasonable amount of time.
 - (void)testSession {
   // Need block arguments here because we're setting up a callbacks before we
   // create the clients.
   ARDAppClient *caller = nil;
   ARDAppClient *answerer = nil;
   __block __weak ARDAppClient *weakCaller = nil;
   __block __weak ARDAppClient *weakAnswerer = nil;
   NSString *roomId = @"testRoom";
   NSString *callerId = @"testCallerId";
   NSString *answererId = @"testAnswererId";

   ARDTestExpectation *callerConnectionExpectation =
       [self expectationWithDescription:@"Caller PC connected."];
   ARDTestExpectation *answererConnectionExpectation =
       [self expectationWithDescription:@"Answerer PC connected."];

   caller = [self createAppClientForRoomId:roomId
                                  clientId:callerId
                               isInitiator:YES
                                  messages:[NSArray array]
                            messageHandler:^(ARDSignalingMessage *message) {
     ARDAppClient *strongAnswerer = weakAnswerer;
     [strongAnswerer channel:strongAnswerer.channel didReceiveMessage:message];
   } connectedHandler:^{
     [callerConnectionExpectation fulfill];
   }];
   // TODO(tkchin): Figure out why DTLS-SRTP constraint causes thread assertion
   // crash in Debug.
   caller.defaultPeerConnectionConstraints = [[RTCMediaConstraints alloc] init];
   weakCaller = caller;

   answerer = [self createAppClientForRoomId:roomId
                                    clientId:answererId
                                 isInitiator:NO
                                    messages:[NSArray array]
                              messageHandler:^(ARDSignalingMessage *message) {
     ARDAppClient *strongCaller = weakCaller;
     [strongCaller channel:strongCaller.channel didReceiveMessage:message];
   } connectedHandler:^{
     [answererConnectionExpectation fulfill];
   }];
   // TODO(tkchin): Figure out why DTLS-SRTP constraint causes thread assertion
   // crash in Debug.
   answerer.defaultPeerConnectionConstraints =
       [[RTCMediaConstraints alloc] init];
   weakAnswerer = answerer;

   // Kick off connection.
   [caller connectToRoomWithId:roomId options:nil];
   [answerer connectToRoomWithId:roomId options:nil];
   [self waitForExpectationsWithTimeout:20 handler:^(NSError *error) {
     if (error) {
       NSLog(@"Expectations error: %@", error);
     }
   }];
 }

 @end

 class SignalingTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     rtc::InitializeSSL();
   }
   static void TearDownTestCase() {
     rtc::CleanupSSL();
   }
 };

 TEST_F(SignalingTest, SessionTest) {
   @autoreleasepool {
     ARDAppClientTest *test = [[ARDAppClientTest alloc] init];
     [test testSession];
   }
 }
	/*
	* libjingle
	* Copyright 2014, Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/


	#import <Foundation/Foundation.h>
	#import <OCMock/OCMock.h>

	#import "ARDAppClient+Internal.h"
	#import "ARDRegisterResponse+Internal.h"
	#import "ARDMessageResponse+Internal.h"
	#import "RTCMediaConstraints.h"
	#import "RTCPeerConnectionFactory.h"

	#include "webrtc/base/gunit.h"
	#include "webrtc/base/ssladapter.h"

	// These classes mimic XCTest APIs, to make eventual conversion to XCTest
	// easier. Conversion will happen once XCTest is supported well on build bots.
	@interface ARDTestExpectation : NSObject

	@property(nonatomic, readonly) NSString *description;
	@property(nonatomic, readonly) BOOL isFulfilled;

	- (instancetype)initWithDescription:(NSString *)description;
	- (void)fulfill;

	@end

	@implementation ARDTestExpectation

	@synthesize description = _description;
	@synthesize isFulfilled = _isFulfilled;

	- (instancetype)initWithDescription:(NSString *)description {
	if (self = [super init]) {
	_description = description;
	}
	return self;
	}

	- (void)fulfill {
	_isFulfilled = YES;
	}

	@end

	@interface ARDTestCase : NSObject

	- (ARDTestExpectation )expectationWithDescription:(NSString )description;
	- (void)waitForExpectationsWithTimeout:(NSTimeInterval)timeout
	handler:(void (^)(NSError *error))handler;

	@end

	@implementation ARDTestCase {
	NSMutableArray *_expectations;
	}

	- (instancetype)init {
	if (self = [super init]) {
	_expectations = [NSMutableArray array];
	}
	return self;
	}

	- (ARDTestExpectation )expectationWithDescription:(NSString )description {
	ARDTestExpectation *expectation =
	[[ARDTestExpectation alloc] initWithDescription:description];
	[_expectations addObject:expectation];
	return expectation;
	}

	- (void)waitForExpectationsWithTimeout:(NSTimeInterval)timeout
	handler:(void (^)(NSError *error))handler {
	NSDate *startDate = [NSDate date];
	while (![self areExpectationsFulfilled]) {
	NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startDate];
	if (duration > timeout) {
	NSAssert(NO, @"Expectation timed out.");
	break;
	}
	[[NSRunLoop currentRunLoop]
	runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];
	}
	handler(nil);
	}

	- (BOOL)areExpectationsFulfilled {
	for (ARDTestExpectation *expectation in _expectations) {
	if (!expectation.isFulfilled) {
	return NO;
	}
	}
	return YES;
	}

	@end

	@interface ARDAppClientTest : ARDTestCase
	@end

	@implementation ARDAppClientTest

	#pragma mark - Mock helpers

	- (id)mockRoomServerClientForRoomId:(NSString *)roomId
	clientId:(NSString *)clientId
	isInitiator:(BOOL)isInitiator
	messages:(NSArray *)messages
	messageHandler:
	(void (^)(ARDSignalingMessage *))messageHandler {
	id mockRoomServerClient =
	[OCMockObject mockForProtocol:@protocol(ARDRoomServerClient)];

	// Successful register response.
	ARDRegisterResponse *registerResponse = [[ARDRegisterResponse alloc] init];
	registerResponse.result = kARDRegisterResultTypeSuccess;
	registerResponse.roomId = roomId;
	registerResponse.clientId = clientId;
	registerResponse.isInitiator = isInitiator;
	registerResponse.messages = messages;

	// Successful message response.
	ARDMessageResponse *messageResponse = [[ARDMessageResponse alloc] init];
	messageResponse.result = kARDMessageResultTypeSuccess;

	// Return register response from above on register.
	[[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
	__unsafe_unretained void (^completionHandler)(ARDRegisterResponse *response,
	NSError *error);
	[invocation getArgument:&completionHandler atIndex:3];
	completionHandler(registerResponse, nil);
	}] registerForRoomId:roomId completionHandler:[OCMArg any]];

	// Return message response from above on register.
	[[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
	__unsafe_unretained ARDSignalingMessage *message;
	__unsafe_unretained void (^completionHandler)(ARDMessageResponse *response,
	NSError *error);
	[invocation getArgument:&message atIndex:2];
	[invocation getArgument:&completionHandler atIndex:5];
	messageHandler(message);
	completionHandler(messageResponse, nil);
	}] sendMessage:[OCMArg any]
	forRoomId:roomId
	clientId:clientId
	completionHandler:[OCMArg any]];

	// Do nothing on deregister.
	[[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
	__unsafe_unretained void (^completionHandler)(NSError *error);
	[invocation getArgument:&completionHandler atIndex:4];
	if (completionHandler) {
	completionHandler(nil);
	}
	}] deregisterForRoomId:roomId
	clientId:clientId
	completionHandler:[OCMArg any]];

	return mockRoomServerClient;
	}

	- (id)mockSignalingChannelForRoomId:(NSString *)roomId
	clientId:(NSString *)clientId
	messageHandler:
	(void (^)(ARDSignalingMessage *message))messageHandler {
	id mockSignalingChannel =
	[OCMockObject niceMockForProtocol:@protocol(ARDSignalingChannel)];
	[[mockSignalingChannel stub] registerForRoomId:roomId clientId:clientId];
	[[[mockSignalingChannel stub] andDo:^(NSInvocation *invocation) {
	__unsafe_unretained ARDSignalingMessage *message;
	[invocation getArgument:&message atIndex:2];
	messageHandler(message);
	}] sendMessage:[OCMArg any]];
	return mockSignalingChannel;
	}

	- (id)mockTURNClient {
	id mockTURNClient =
	[OCMockObject mockForProtocol:@protocol(ARDTURNClient)];
	[[[mockTURNClient stub] andDo:^(NSInvocation *invocation) {
	// Don't return anything in TURN response.
	__unsafe_unretained void (^completionHandler)(NSArray *turnServers,
	NSError *error);
	[invocation getArgument:&completionHandler atIndex:2];
	completionHandler([NSArray array], nil);
	}] requestServersWithCompletionHandler:[OCMArg any]];
	return mockTURNClient;
	}

	- (ARDAppClient )createAppClientForRoomId:(NSString )roomId
	clientId:(NSString *)clientId
	isInitiator:(BOOL)isInitiator
	messages:(NSArray *)messages
	messageHandler:
	(void (^)(ARDSignalingMessage *message))messageHandler
	connectedHandler:(void (^)(void))connectedHandler {
	id turnClient = [self mockTURNClient];
	id signalingChannel = [self mockSignalingChannelForRoomId:roomId
	clientId:clientId
	messageHandler:messageHandler];
	id roomServerClient =
	[self mockRoomServerClientForRoomId:roomId
	clientId:clientId
	isInitiator:isInitiator
	messages:messages
	messageHandler:messageHandler];
	id delegate =
	[OCMockObject niceMockForProtocol:@protocol(ARDAppClientDelegate)];
	[[[delegate stub] andDo:^(NSInvocation *invocation) {
	connectedHandler();
	}] appClient:[OCMArg any] didChangeConnectionState:RTCICEConnectionConnected];

	return [[ARDAppClient alloc] initWithRoomServerClient:roomServerClient
	signalingChannel:signalingChannel
	turnClient:turnClient
	delegate:delegate];
	}

	// Tests that an ICE connection is established between two ARDAppClient objects
	// where one is set up as a caller and the other the answerer. Network
	// components are mocked out and messages are relayed directly from object to
	// object. It's expected that both clients reach the RTCICEConnectionConnected
	// state within a reasonable amount of time.
	- (void)testSession {
	// Need block arguments here because we're setting up a callbacks before we
	// create the clients.
	ARDAppClient *caller = nil;
	ARDAppClient *answerer = nil;
	__block __weak ARDAppClient *weakCaller = nil;
	__block __weak ARDAppClient *weakAnswerer = nil;
	NSString *roomId = @"testRoom";
	NSString *callerId = @"testCallerId";
	NSString *answererId = @"testAnswererId";

	ARDTestExpectation *callerConnectionExpectation =
	[self expectationWithDescription:@"Caller PC connected."];
	ARDTestExpectation *answererConnectionExpectation =
	[self expectationWithDescription:@"Answerer PC connected."];

	caller = [self createAppClientForRoomId:roomId
	clientId:callerId
	isInitiator:YES
	messages:[NSArray array]
	messageHandler:^(ARDSignalingMessage *message) {
	ARDAppClient *strongAnswerer = weakAnswerer;
	[strongAnswerer channel:strongAnswerer.channel didReceiveMessage:message];
	} connectedHandler:^{
	[callerConnectionExpectation fulfill];
	}];
	// TODO(tkchin): Figure out why DTLS-SRTP constraint causes thread assertion
	// crash in Debug.
	caller.defaultPeerConnectionConstraints = [[RTCMediaConstraints alloc] init];
	weakCaller = caller;

	answerer = [self createAppClientForRoomId:roomId
	clientId:answererId
	isInitiator:NO
	messages:[NSArray array]
	messageHandler:^(ARDSignalingMessage *message) {
	ARDAppClient *strongCaller = weakCaller;
	[strongCaller channel:strongCaller.channel didReceiveMessage:message];
	} connectedHandler:^{
	[answererConnectionExpectation fulfill];
	}];
	// TODO(tkchin): Figure out why DTLS-SRTP constraint causes thread assertion
	// crash in Debug.
	answerer.defaultPeerConnectionConstraints =
	[[RTCMediaConstraints alloc] init];
	weakAnswerer = answerer;

	// Kick off connection.
	[caller connectToRoomWithId:roomId options:nil];
	[answerer connectToRoomWithId:roomId options:nil];
	[self waitForExpectationsWithTimeout:20 handler:^(NSError *error) {
	if (error) {
	NSLog(@"Expectations error: %@", error);
	}
	}];
	}

	@end

	class SignalingTest : public ::testing::Test {
	protected:
	static void SetUpTestCase() {
	rtc::InitializeSSL();
	}
	static void TearDownTestCase() {
	rtc::CleanupSSL();
	}
	};

	TEST_F(SignalingTest, SessionTest) {
	@autoreleasepool {
	ARDAppClientTest *test = [[ARDAppClientTest alloc] init];
	[test testSession];
	}
	}