Update Unit test for AppRTCMobile app

webrtc/examples/objc/AppRTCMobile/tests/ARDAppClientTest.mm

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #import <Foundation/Foundation.h>
+#import <QuartzCore/CoreAnimation.h>

[tkchin_webrtc, 2016/11/07 19:14:21]

alphabetize

 #import <OCMock/OCMock.h>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/ssladapter.h"
 
 #import "WebRTC/RTCMediaConstraints.h"
 #import "WebRTC/RTCPeerConnectionFactory.h"
 #import "WebRTC/RTCSessionDescription.h"
 
 #import "ARDAppClient+Internal.h"
@@ skipping 27 matching lines @@
 
 - (void)fulfill {
   _isFulfilled = YES;
 }
 
 @end
 
 @interface ARDTestCase : NSObject
 
 - (ARDTestExpectation *)expectationWithDescription:(NSString *)description;
-- (void)waitForExpectationsWithTimeout:(NSTimeInterval)timeout
-                               handler:(void (^)(NSError *error))handler;
+- (void)waitForExpectationsWithTimeout:(CFTimeInterval)timeout
+                               handler:(void (^)(BOOL didError))handler;

[tkchin_webrtc, 2016/11/07 19:14:21]

This was meant to mirror XCTest interfaces so make our transition to XCTestCase
easier. Please don't change to BOOL.

[afedor, 2016/11/07 20:25:25]

OK, but to maintain the interface, I should also probably change the signature
back to use NSTimeInterval

 
 @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];
+- (void)waitForExpectationsWithTimeout:(CFTimeInterval)timeout
+                               handler:(void (^)(BOOL didError))handler {
+  CFTimeInterval startTime = CACurrentMediaTime();
+  BOOL didErrorExp = NO;

[tkchin_webrtc, 2016/11/07 19:14:21]

CFTimeInterval change looks good, but please return an error instead of a bool.

   while (![self areExpectationsFulfilled]) {
-    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startDate];
+    CFTimeInterval duration = CACurrentMediaTime() - startTime;
     if (duration > timeout) {
-      NSAssert(NO, @"Expectation timed out.");
+      didErrorExp = YES;
       break;
     }
     [[NSRunLoop currentRunLoop]
         runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];
   }
-  handler(nil);
+  handler(didErrorExp);
 }
 
 - (BOOL)areExpectationsFulfilled {
   for (ARDTestExpectation *expectation in _expectations) {
     if (!expectation.isFulfilled) {
       return NO;
     }
   }
   return YES;
 }
@@ skipping 25 matching lines @@
   joinResponse.messages = messages;
 
   // Successful message response.
   ARDMessageResponse *messageResponse = [[ARDMessageResponse alloc] init];
   messageResponse.result = kARDMessageResultTypeSuccess;
 
   // Return join response from above on join.
   [[[mockRoomServerClient stub] andDo:^(NSInvocation *invocation) {
     __unsafe_unretained void (^completionHandler)(ARDJoinResponse *response,
                                                   NSError *error);
-    [invocation getArgument:&completionHandler atIndex:3];
+    [invocation getArgument:&completionHandler atIndex:4];
     completionHandler(joinResponse, nil);
   }] joinRoomWithRoomId:roomId isLoopback:NO completionHandler:[OCMArg any]];
 
   // Return message response from above on join.
   [[[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];
@@ skipping 45 matching lines @@
   }] 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 {
+                          connectedHandler:(void (^)(NSString *))connectedHandler {

[tkchin_webrtc, 2016/11/07 19:14:21]

instead of passing the name of the method, just introduce a new event handler

e.g.
...
messageHandler:
connectedHandler:
localVideoTrackHandler:

This avoids all the selector magic and makes it more obvious what's going on.

   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();
+    connectedHandler(NSStringFromSelector([invocation selector]));
   }] appClient:[OCMArg any]
       didChangeConnectionState:RTCIceConnectionStateConnected];
+  [[[delegate stub] andDo:^(NSInvocation *invocation) {
+    connectedHandler(NSStringFromSelector([invocation selector]));
+  }] appClient:[OCMArg any]
+      didReceiveLocalVideoTrack:[OCMArg any]];
 
   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
@@ skipping 15 matching lines @@
   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];
+  } connectedHandler:^(NSString *connectedSelectorString){
+    if ([connectedSelectorString
+         isEqualToString:@"appClient:didChangeConnectionState:"])
+      [callerConnectionExpectation fulfill];
   }];
   // TODO(tkchin): Figure out why DTLS-SRTP constraint causes thread assertion
   // crash in Debug.
   caller.defaultPeerConnectionConstraints =
       [[RTCMediaConstraints alloc] initWithMandatoryConstraints:nil
                                             optionalConstraints:nil];
   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];
+  } connectedHandler:^(NSString *connectedSelectorString){
+    if ([connectedSelectorString
+         isEqualToString:@"appClient:didChangeConnectionState:"])
+      [answererConnectionExpectation fulfill];
   }];
   // TODO(tkchin): Figure out why DTLS-SRTP constraint causes thread assertion
   // crash in Debug.
   answerer.defaultPeerConnectionConstraints =
       [[RTCMediaConstraints alloc] initWithMandatoryConstraints:nil
                                             optionalConstraints:nil];
   weakAnswerer = answerer;
 
   // Kick off connection.
   [caller connectToRoomWithId:roomId
                    isLoopback:NO
                   isAudioOnly:NO
             shouldMakeAecDump:NO
         shouldUseLevelControl:NO];
   [answerer connectToRoomWithId:roomId
                      isLoopback:NO
                     isAudioOnly:NO
               shouldMakeAecDump:NO
           shouldUseLevelControl:NO];
-  [self waitForExpectationsWithTimeout:20 handler:^(NSError *error) {
-    if (error) {
-      NSLog(@"Expectations error: %@", error);
+  [self waitForExpectationsWithTimeout:20 handler:^(BOOL didError) {
+    if (didError) {
+      EXPECT_TRUE(0);
     }
   }];
 }
+
+// Test to see that we get a local video connection
+// Note this will currently pass even when no camera is connected as a local
+// video track is created regardless (Perhaps there should be a test for that...)
+- (void)testSessionShouldGetLocalVideoTrackCallback {
+  ARDAppClient *caller = nil;
+  NSString *roomId = @"testRoom";
+  NSString *callerId = @"testCallerId";
+
+  ARDTestExpectation *callerConnectionExpectation =
+  [self expectationWithDescription:@"Caller PC connected."];

[tkchin_webrtc, 2016/11/07 19:14:21]

indent 4

+
+  caller = [self createAppClientForRoomId:roomId
+                                 clientId:callerId
+                              isInitiator:YES
+                                 messages:[NSArray array]
+                           messageHandler:^(ARDSignalingMessage *message) {

[tkchin_webrtc, 2016/11/07 19:14:21]

please follow formatting as in other methods
do not use git cl format for ObjC++ files

+                           }
+                         connectedHandler:^(NSString *connectedSelectorString) {
+                           if ([connectedSelectorString
+                               isEqualToString:@"appClient:didReceiveLocalVideoTrack:"])
+                           [callerConnectionExpectation fulfill];
+                         }];
+  caller.defaultPeerConnectionConstraints =
+  [[RTCMediaConstraints alloc] initWithMandatoryConstraints:nil

[tkchin_webrtc, 2016/11/07 19:14:21]

indent 4

+                                        optionalConstraints:nil];
+
+  // Kick off connection.
+  [caller connectToRoomWithId:roomId
+                   isLoopback:NO
+                  isAudioOnly:NO
+            shouldMakeAecDump:NO
+        shouldUseLevelControl:NO];
+  [self waitForExpectationsWithTimeout:20 handler:^(BOOL didError) {
+    if (didError) {
+      EXPECT_TRUE(0);
+    }
+  }];
+}
 
 @end
 
 @interface ARDSDPUtilsTest : ARDTestCase
 - (void)testPreferVideoCodec;
 @end
 
 @implementation ARDSDPUtilsTest
 
 - (void)testPreferVideoCodec {
   NSString *sdp = @("m=video 9 RTP/SAVPF 100 116 117 96 120\n"
                     "a=rtpmap:120 H264/90000\n");
   NSString *expectedSdp = @("m=video 9 RTP/SAVPF 120 100 116 117 96\n"
                             "a=rtpmap:120 H264/90000\n");
   RTCSessionDescription* desc =
       [[RTCSessionDescription alloc] initWithType:RTCSdpTypeOffer sdp:sdp];
   RTCSessionDescription *h264Desc =
       [ARDSDPUtils descriptionForDescription:desc
                          preferredVideoCodec:@"H264"];
-  EXPECT_TRUE([h264Desc.description isEqualToString:expectedSdp]);
+  EXPECT_TRUE([h264Desc.description rangeOfString: expectedSdp].location != NSNotFound);

[tkchin_webrtc, 2016/11/07 19:14:21]

nit: no space after :
EXPECT_NE?

 }
 
 @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];
   }
 }
 
+#if !TARGET_IPHONE_SIMULATOR
+// Expected fail on iOS Simulator due to no camera support
+TEST_F(SignalingTest, SessionLocalVideoCallbackTest) {
+  @autoreleasepool {
+    ARDAppClientTest *test = [[ARDAppClientTest alloc] init];
+    [test testSessionShouldGetLocalVideoTrackCallback];
+  }
+}
+#endif
+
 TEST_F(SignalingTest, SDPTest) {
   @autoreleasepool {
     ARDSDPUtilsTest *test = [[ARDSDPUtilsTest alloc] init];
     [test testPreferVideoCodec];
   }
 }
 
-
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}