[camera] Remove OCMock from AvailableCamerasTests, CameraOrientationTests and ThreadSafeEventChannelTests

packages/camera/camera_avfoundation/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.9.17+8
+
+* Introduces new protocols `FLTEventChannel` and `FLTCameraDeviceDiscovering`
+
+## 0.9.17+7
+
+* Introduces new protocols `FLTCaptureDeviceControlling` and `FLTDeviceOrientationProviding`
+
 ## 0.9.17+6
 
 * Updates minimum supported SDK version to Flutter 3.22/Dart 3.4.

packages/camera/camera_avfoundation/example/ios/RunnerTests/AvailableCamerasTest.m

@@ -8,33 +8,54 @@
 #endif
 @import XCTest;
 @import AVFoundation;
-#import <OCMock/OCMock.h>
+
+#import "MockCameraDeviceDiscoverer.h"
+#import "MockCaptureDeviceController.h"
+#import "MockCaptureSession.h"
 
 @interface AvailableCamerasTest : XCTestCase
+@property(nonatomic, strong) MockCameraDeviceDiscoverer *mockDeviceDiscoverer;
+@property(nonatomic, strong) CameraPlugin *cameraPlugin;
 @end
 
 @implementation AvailableCamerasTest
 
+- (void)setUp {
+  [super setUp];
+
+  self.mockDeviceDiscoverer = [[MockCameraDeviceDiscoverer alloc] init];
+  self.cameraPlugin = [[CameraPlugin alloc] initWithRegistry:nil
+      messenger:nil
+      globalAPI:nil
+      deviceDiscoverer:_mockDeviceDiscoverer
+      deviceFactory:^id<FLTCaptureDeviceControlling>(NSString *name) {
+        return [[MockCaptureDeviceController alloc] init];
+      }
+      captureSessionFactory:^id<FLTCaptureSession> {
+        return [[MockCaptureSession alloc] init];
+      }
+      captureDeviceInputFactory:[[MockCaptureDeviceInputFactory alloc] init]];
+}
+
 - (void)testAvailableCamerasShouldReturnAllCamerasOnMultiCameraIPhone {
-  CameraPlugin *camera = [[CameraPlugin alloc] initWithRegistry:nil messenger:nil];
   XCTestExpectation *expectation = [self expectationWithDescription:@"Result finished"];
 
   // iPhone 13 Cameras:
-  AVCaptureDevice *wideAngleCamera = OCMClassMock([AVCaptureDevice class]);
-  OCMStub([wideAngleCamera uniqueID]).andReturn(@"0");
-  OCMStub([wideAngleCamera position]).andReturn(AVCaptureDevicePositionBack);
+  MockCaptureDeviceController *wideAngleCamera = [[MockCaptureDeviceController alloc] init];
+  wideAngleCamera.uniqueID = @"0";
+  wideAngleCamera.position = AVCaptureDevicePositionBack;
 
-  AVCaptureDevice *frontFacingCamera = OCMClassMock([AVCaptureDevice class]);
-  OCMStub([frontFacingCamera uniqueID]).andReturn(@"1");
-  OCMStub([frontFacingCamera position]).andReturn(AVCaptureDevicePositionFront);
+  MockCaptureDeviceController *frontFacingCamera = [[MockCaptureDeviceController alloc] init];
+  frontFacingCamera.uniqueID = @"1";
+  frontFacingCamera.position = AVCaptureDevicePositionFront;
 
-  AVCaptureDevice *ultraWideCamera = OCMClassMock([AVCaptureDevice class]);
-  OCMStub([ultraWideCamera uniqueID]).andReturn(@"2");
-  OCMStub([ultraWideCamera position]).andReturn(AVCaptureDevicePositionBack);
+  MockCaptureDeviceController *ultraWideCamera = [[MockCaptureDeviceController alloc] init];
+  ultraWideCamera.uniqueID = @"2";
+  ultraWideCamera.position = AVCaptureDevicePositionBack;
 
-  AVCaptureDevice *telephotoCamera = OCMClassMock([AVCaptureDevice class]);
-  OCMStub([telephotoCamera uniqueID]).andReturn(@"3");
-  OCMStub([telephotoCamera position]).andReturn(AVCaptureDevicePositionBack);
+  MockCaptureDeviceController *telephotoCamera = [[MockCaptureDeviceController alloc] init];
+  telephotoCamera.uniqueID = @"3";
+  telephotoCamera.position = AVCaptureDevicePositionBack;
 
   NSMutableArray *requiredTypes =
       [@[ AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeBuiltInTelephotoCamera ]
@@ -43,21 +64,23 @@ - (void)testAvailableCamerasShouldReturnAllCamerasOnMultiCameraIPhone {
     [requiredTypes addObject:AVCaptureDeviceTypeBuiltInUltraWideCamera];
   }
 
-  id discoverySessionMock = OCMClassMock([AVCaptureDeviceDiscoverySession class]);
-  OCMStub([discoverySessionMock discoverySessionWithDeviceTypes:requiredTypes
-                                                      mediaType:AVMediaTypeVideo
-                                                       position:AVCaptureDevicePositionUnspecified])
-      .andReturn(discoverySessionMock);
-
   NSMutableArray *cameras = [NSMutableArray array];
   [cameras addObjectsFromArray:@[ wideAngleCamera, frontFacingCamera, telephotoCamera ]];
   if (@available(iOS 13.0, *)) {
     [cameras addObject:ultraWideCamera];
   }
-  OCMStub([discoverySessionMock devices]).andReturn([NSArray arrayWithArray:cameras]);
+
+  _mockDeviceDiscoverer.discoverySessionStub = ^NSArray<id<FLTCaptureDeviceControlling>> *_Nullable(
+      NSArray<AVCaptureDeviceType> *_Nonnull deviceTypes, AVMediaType _Nonnull mediaType,
+      AVCaptureDevicePosition position) {
+    XCTAssertEqualObjects(deviceTypes, requiredTypes);
+    XCTAssertEqual(mediaType, AVMediaTypeVideo);
+    XCTAssertEqual(position, AVCaptureDevicePositionUnspecified);
+    return cameras;
+  };
 
   __block NSArray<FCPPlatformCameraDescription *> *resultValue;
-  [camera
+  [_cameraPlugin
       availableCamerasWithCompletion:^(NSArray<FCPPlatformCameraDescription *> *_Nullable result,
                                        FlutterError *_Nullable error) {
         XCTAssertNil(error);
@@ -74,17 +97,16 @@ - (void)testAvailableCamerasShouldReturnAllCamerasOnMultiCameraIPhone {
   }
 }
 - (void)testAvailableCamerasShouldReturnOneCameraOnSingleCameraIPhone {
-  CameraPlugin *camera = [[CameraPlugin alloc] initWithRegistry:nil messenger:nil];
   XCTestExpectation *expectation = [self expectationWithDescription:@"Result finished"];
 
   // iPhone 8 Cameras:
-  AVCaptureDevice *wideAngleCamera = OCMClassMock([AVCaptureDevice class]);
-  OCMStub([wideAngleCamera uniqueID]).andReturn(@"0");
-  OCMStub([wideAngleCamera position]).andReturn(AVCaptureDevicePositionBack);
+  MockCaptureDeviceController *wideAngleCamera = [[MockCaptureDeviceController alloc] init];
+  wideAngleCamera.uniqueID = @"0";
+  wideAngleCamera.position = AVCaptureDevicePositionBack;
 
-  AVCaptureDevice *frontFacingCamera = OCMClassMock([AVCaptureDevice class]);
-  OCMStub([frontFacingCamera uniqueID]).andReturn(@"1");
-  OCMStub([frontFacingCamera position]).andReturn(AVCaptureDevicePositionFront);
+  MockCaptureDeviceController *frontFacingCamera = [[MockCaptureDeviceController alloc] init];
+  frontFacingCamera.uniqueID = @"1";
+  frontFacingCamera.position = AVCaptureDevicePositionFront;
 
   NSMutableArray *requiredTypes =
       [@[ AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeBuiltInTelephotoCamera ]
@@ -93,18 +115,20 @@ - (void)testAvailableCamerasShouldReturnOneCameraOnSingleCameraIPhone {
     [requiredTypes addObject:AVCaptureDeviceTypeBuiltInUltraWideCamera];
   }
 
-  id discoverySessionMock = OCMClassMock([AVCaptureDeviceDiscoverySession class]);
-  OCMStub([discoverySessionMock discoverySessionWithDeviceTypes:requiredTypes
-                                                      mediaType:AVMediaTypeVideo
-                                                       position:AVCaptureDevicePositionUnspecified])
-      .andReturn(discoverySessionMock);
-
   NSMutableArray *cameras = [NSMutableArray array];
   [cameras addObjectsFromArray:@[ wideAngleCamera, frontFacingCamera ]];
-  OCMStub([discoverySessionMock devices]).andReturn([NSArray arrayWithArray:cameras]);
+
+  _mockDeviceDiscoverer.discoverySessionStub = ^NSArray<id<FLTCaptureDeviceControlling>> *_Nullable(
+      NSArray<AVCaptureDeviceType> *_Nonnull deviceTypes, AVMediaType _Nonnull mediaType,
+      AVCaptureDevicePosition position) {
+    XCTAssertEqualObjects(deviceTypes, requiredTypes);
+    XCTAssertEqual(mediaType, AVMediaTypeVideo);
+    XCTAssertEqual(position, AVCaptureDevicePositionUnspecified);
+    return cameras;
+  };
 
   __block NSArray<FCPPlatformCameraDescription *> *resultValue;
-  [camera
+  [_cameraPlugin
       availableCamerasWithCompletion:^(NSArray<FCPPlatformCameraDescription *> *_Nullable result,
                                        FlutterError *_Nullable error) {
         XCTAssertNil(error);

packages/camera/camera_avfoundation/example/ios/RunnerTests/CameraCaptureSessionQueueRaceConditionTests.m

@@ -8,13 +8,29 @@
 #endif
 @import XCTest;
 
+#import "MockCameraDeviceDiscoverer.h"
+#import "MockCaptureDeviceController.h"
+#import "MockCaptureSession.h"
+
 @interface CameraCaptureSessionQueueRaceConditionTests : XCTestCase
 @end
 
 @implementation CameraCaptureSessionQueueRaceConditionTests
 
 - (void)testFixForCaptureSessionQueueNullPointerCrashDueToRaceCondition {
-  CameraPlugin *camera = [[CameraPlugin alloc] initWithRegistry:nil messenger:nil];
+  MockCaptureDeviceController *captureDevice = [[MockCaptureDeviceController alloc] init];
+
+  CameraPlugin *camera = [[CameraPlugin alloc] initWithRegistry:nil
+      messenger:nil
+      globalAPI:nil
+      deviceDiscoverer:[[MockCameraDeviceDiscoverer alloc] init]
+      deviceFactory:^id<FLTCaptureDeviceControlling>(NSString *name) {
+        return captureDevice;
+      }
+      captureSessionFactory:^id<FLTCaptureSession> {
+        return [[MockCaptureSession alloc] init];
+      }
+      captureDeviceInputFactory:[[MockCaptureDeviceInputFactory alloc] init]];
 
   XCTestExpectation *disposeExpectation =
       [self expectationWithDescription:@"dispose's result block must be called"];

packages/camera/camera_avfoundation/example/ios/RunnerTests/CameraExposureTests.m

@@ -5,51 +5,79 @@
 @import camera_avfoundation;
 @import XCTest;
 @import AVFoundation;
-#import <OCMock/OCMock.h>
 
-@interface FLTCam : NSObject <FlutterTexture,
-                              AVCaptureVideoDataOutputSampleBufferDelegate,
-                              AVCaptureAudioDataOutputSampleBufferDelegate>
-
-- (void)setExposurePointWithResult:(FlutterResult)result x:(double)x y:(double)y;
-@end
+#import "CameraTestUtils.h"
+#import "MockCaptureDeviceController.h"
+#import "MockDeviceOrientationProvider.h"
 
 @interface CameraExposureTests : XCTestCase
 @property(readonly, nonatomic) FLTCam *camera;
-@property(readonly, nonatomic) id mockDevice;
-@property(readonly, nonatomic) id mockUIDevice;
+@property(readonly, nonatomic) MockCaptureDeviceController *mockDevice;
+@property(readonly, nonatomic) MockDeviceOrientationProvider *mockDeviceOrientationProvider;
 @end
 
 @implementation CameraExposureTests
 
 - (void)setUp {
-  _camera = [[FLTCam alloc] init];
-  _mockDevice = OCMClassMock([AVCaptureDevice class]);
-  _mockUIDevice = OCMPartialMock([UIDevice currentDevice]);
-}
+  MockCaptureDeviceController *mockDevice = [[MockCaptureDeviceController alloc] init];
+  _mockDeviceOrientationProvider = [[MockDeviceOrientationProvider alloc] init];
+  _mockDevice = mockDevice;
 
-- (void)tearDown {
-  [_mockDevice stopMocking];
-  [_mockUIDevice stopMocking];
+  _camera = FLTCreateCamWithCaptureSessionQueueAndMediaSettings(
+      nil, nil, nil,
+      ^id<FLTCaptureDeviceControlling>(void) {
+        return mockDevice;
+      },
+      _mockDeviceOrientationProvider);
 }
 
-- (void)testSetExpsourePointWithResult_SetsExposurePointOfInterest {
+- (void)testSetExposurePointWithResult_SetsExposurePointOfInterest {
   // UI is currently in landscape left orientation
-  OCMStub([(UIDevice *)_mockUIDevice orientation]).andReturn(UIDeviceOrientationLandscapeLeft);
+  _mockDeviceOrientationProvider.orientation = UIDeviceOrientationLandscapeLeft;
   // Exposure point of interest is supported
-  OCMStub([_mockDevice isExposurePointOfInterestSupported]).andReturn(true);
-  // Set mock device as the current capture device
-  [_camera setValue:_mockDevice forKey:@"captureDevice"];
+  _mockDevice.isExposurePointOfInterestSupported = YES;
+
+  // Verify the focus point of interest has been set
+  __block CGPoint setPoint = CGPointZero;
+  _mockDevice.setExposurePointOfInterestStub = ^(CGPoint point) {
+    if (CGPointEqualToPoint(CGPointMake(1, 1), point)) {
+      setPoint = point;
+    }
+  };
 
   // Run test
+  XCTestExpectation *completionExpectation = [self expectationWithDescription:@"Completion called"];
+  [_camera setExposurePoint:[FCPPlatformPoint makeWithX:1 y:1]
+             withCompletion:^(FlutterError *_Nullable error) {
+               XCTAssertNil(error);
+               [completionExpectation fulfill];
+             }];
+
+  [self waitForExpectationsWithTimeout:1 handler:nil];
+  XCTAssertEqual(setPoint.x, 1.0);
+  XCTAssertEqual(setPoint.y, 1.0);
+}
+
+- (void)testSetExposurePoint_WhenNotSupported_ReturnsError {
+  // UI is currently in landscape left orientation
+  _mockDeviceOrientationProvider.orientation = UIDeviceOrientationLandscapeLeft;
+  // Exposure point of interest is not supported
+  _mockDevice.isExposurePointOfInterestSupported = NO;
+
+  XCTestExpectation *expectation = [self expectationWithDescription:@"Completion with error"];
+
+  // Run
   [_camera
-      setExposurePointWithResult:^void(id _Nullable result) {
-      }
-                               x:1
-                               y:1];
+      setExposurePoint:[FCPPlatformPoint makeWithX:1 y:1]
+        withCompletion:^(FlutterError *_Nullable error) {
+          XCTAssertNotNil(error);
+          XCTAssertEqualObjects(error.code, @"setExposurePointFailed");
+          XCTAssertEqualObjects(error.message, @"Device does not have exposure point capabilities");
+          [expectation fulfill];
+        }];
 
-  // Verify the focus point of interest has been set
-  OCMVerify([_mockDevice setExposurePointOfInterest:CGPointMake(1, 1)]);
+  // Verify
+  [self waitForExpectationsWithTimeout:1 handler:nil];
 }
 
 @end