test: add initializeCamera and onCameraInitialized tests

packages/camera/camera_web/example/integration_test/camera_web_test.dart

@@ -5,6 +5,7 @@
 import 'dart:html';
 import 'dart:ui';
 
+import 'package:async/async.dart';
 import 'package:camera_platform_interface/camera_platform_interface.dart';
 import 'package:camera_web/camera_web.dart';
 import 'package:camera_web/src/camera.dart';
@@ -327,21 +328,18 @@ void main() {
         const ultraHighResolutionSize = Size(3840, 2160);
         const maxResolutionSize = Size(3840, 2160);
 
-        late CameraDescription cameraDescription;
-        late CameraMetadata cameraMetadata;
-
-        setUp(() {
-          cameraDescription = CameraDescription(
-            name: 'name',
-            lensDirection: CameraLensDirection.front,
-            sensorOrientation: 0,
-          );
+        final cameraDescription = CameraDescription(
+          name: 'name',
+          lensDirection: CameraLensDirection.front,
+          sensorOrientation: 0,
+        );
 
-          cameraMetadata = CameraMetadata(
-            deviceId: 'deviceId',
-            facingMode: 'user',
-          );
+        final cameraMetadata = CameraMetadata(
+          deviceId: 'deviceId',
+          facingMode: 'user',
+        );
 
+        setUp(() {
           // Add metadata for the camera description.
           (CameraPlatform.instance as CameraPlugin)
               .camerasMetadata[cameraDescription] = cameraMetadata;
@@ -434,11 +432,38 @@ void main() {
       });
     });
 
-    testWidgets('initializeCamera throws UnimplementedError', (tester) async {
-      expect(
-        () => CameraPlatform.instance.initializeCamera(cameraId),
-        throwsUnimplementedError,
-      );
+    group('initializeCamera', () {
+      testWidgets(
+          'throws CameraException '
+          'with notFound error '
+          'if the camera does not exist', (tester) async {
+        expect(
+          () => CameraPlatform.instance.initializeCamera(cameraId),
+          throwsA(
+            isA<CameraException>().having(
+              (e) => e.code,
+              'code',
+              CameraErrorCodes.notFound,
+            ),
+          ),
+        );
+      });
+
+      testWidgets('initializes and plays the camera', (tester) async {
+        final camera = MockCamera();
+
+        when(camera.getVideoSize).thenAnswer((_) => Future.value(Size(10, 10)));
+        when(camera.initialize).thenAnswer((_) => Future.value());
+        when(camera.play).thenAnswer((_) => Future.value());
+
+        // Save the camera in the camera plugin.
+        (CameraPlatform.instance as CameraPlugin).cameras[cameraId] = camera;
+
+        await CameraPlatform.instance.initializeCamera(cameraId);
+
+        verify(camera.initialize).called(1);
+        verify(camera.play).called(1);
+      });
     });
 
     testWidgets('lockCaptureOrientation throws UnimplementedError',
@@ -628,13 +653,78 @@ void main() {
       );
     });
 
+    group('getCamera', () {
+      testWidgets('returns the correct camera', (tester) async {
+        final camera = Camera(textureId: cameraId, window: window);
+
+        // Save the camera in the camera plugin.
+        (CameraPlatform.instance as CameraPlugin).cameras[cameraId] = camera;
+
+        expect(
+          (CameraPlatform.instance as CameraPlugin).getCamera(cameraId),
+          equals(camera),
+        );
+      });
+
+      testWidgets(
+          'throws CameraException '
+          'with notFound error '
+          'if the camera does not exist', (tester) async {
+        expect(
+          () => (CameraPlatform.instance as CameraPlugin).getCamera(cameraId),
+          throwsA(
+            isA<CameraException>().having(
+              (e) => e.code,
+              'code',
+              CameraErrorCodes.notFound,
+            ),
+          ),
+        );
+      });
+    });
+
     group('events', () {
-      testWidgets('onCameraInitialized throws UnimplementedError',
-          (tester) async {
+      testWidgets(
+          'onCameraInitialized emits a CameraInitializedEvent '
+          'on initializeCamera', (tester) async {
+        // Mock the camera to use a blank video stream of size 1280x720.
+        const videoSize = Size(1280, 720);
+
+        videoElement = getVideoElementWithBlankStream(videoSize);
+
+        when(
+          () => mediaDevices.getUserMedia(any()),
+        ).thenAnswer((_) async => videoElement.captureStream());
+
+        final camera = Camera(
+          textureId: cameraId,
+          window: window,
+        );
+
+        // Save the camera in the camera plugin.
+        (CameraPlatform.instance as CameraPlugin).cameras[cameraId] = camera;
+
+        final Stream<CameraInitializedEvent> eventStream =
+            CameraPlatform.instance.onCameraInitialized(cameraId);
+
+        final streamQueue = StreamQueue(eventStream);
+
+        await CameraPlatform.instance.initializeCamera(cameraId);
+
         expect(
-          () => CameraPlatform.instance.onCameraInitialized(cameraId),
-          throwsUnimplementedError,
+          await streamQueue.next,
+          CameraInitializedEvent(
+            cameraId,
+            videoSize.width,
+            videoSize.height,
+            ExposureMode.auto,
+            false,
+            FocusMode.auto,
+            false,
+          ),
         );
+
+        await streamQueue.cancel();
       });
 
       testWidgets('onCameraResolutionChanged throws UnimplementedError',

packages/camera/camera_web/example/integration_test/helpers/mocks.dart

@@ -4,6 +4,7 @@
 
 import 'dart:html';
 
+import 'package:camera_web/src/camera.dart';
 import 'package:camera_web/src/camera_settings.dart';
 import 'package:mocktail/mocktail.dart';
 
@@ -17,6 +18,8 @@ class MockCameraSettings extends Mock implements CameraSettings {}
 
 class MockMediaStreamTrack extends Mock implements MediaStreamTrack {}
 
+class MockCamera extends Mock implements Camera {}
+
 /// A fake [MediaStream] that returns the provided [_videoTracks].
 class FakeMediaStream extends Fake implements MediaStream {
   FakeMediaStream(this._videoTracks);