feat: Enhance DeviceDiscoveryViewModel for testability with isMobileOverride and expose bleScanFuture

Author: oldrev

client/lib/core/services/platform_service.dart

@@ -0,0 +1,53 @@
+import 'dart:io' show Platform;
+import 'package:flutter/foundation.dart';
+
+/// Platform-related utilities exposed via dependency injection.
+///
+/// This interface exists so that tests can substitute a fake implementation
+/// if desired and to avoid sprinkling `Platform`/`kIsWeb` checks throughout
+/// the codebase.
+abstract class PlatformService {
+  /// `true` when running in a web browser.
+  bool get isWeb;
+
+  /// Conventional mobile platforms.
+  bool get isAndroid;
+  bool get isIOS;
+
+  /// Conventional desktop platforms.
+  bool get isWindows;
+  bool get isMacOS;
+  bool get isLinux;
+
+  /// Convenience helpers.
+  bool get isMobile; // android || ios
+  bool get isDesktop; // windows || macos || linux
+}
+
+/// Default implementation that delegates to Flutter's and Dart's
+/// built‑in platform checks.
+class PlatformServiceImpl implements PlatformService {
+  @override
+  bool get isWeb => kIsWeb;
+
+  @override
+  bool get isAndroid => !kIsWeb && Platform.isAndroid;
+
+  @override
+  bool get isIOS => !kIsWeb && Platform.isIOS;
+
+  @override
+  bool get isWindows => !kIsWeb && Platform.isWindows;
+
+  @override
+  bool get isMacOS => !kIsWeb && Platform.isMacOS;
+
+  @override
+  bool get isLinux => !kIsWeb && Platform.isLinux;
+
+  @override
+  bool get isMobile => isAndroid || isIOS;
+
+  @override
+  bool get isDesktop => isWindows || isMacOS || isLinux;
+}

client/lib/features/devices/view_models/device_discovery_view_model.dart

@@ -9,6 +9,7 @@ import 'package:cancellation_token/cancellation_token.dart';
 import 'package:flutter/foundation.dart';
 import 'package:logger/logger.dart';
 import 'package:permission_handler/permission_handler.dart';
+import 'package:borneo_app/core/services/platform_service.dart';
 
 import '../models/events.dart';
 import 'package:borneo_app/core/services/devices/device_manager.dart';
@@ -25,6 +26,7 @@ class DeviceDiscoveryViewModel extends AbstractScreenViewModel {
   final IDeviceManager _deviceManager;
   final IBleProvisioner _bleProvisioner;
   final IDeviceModuleRegistry deviceMdoules;
+  final PlatformService _platformService;
 
   bool get _isDiscovering => _deviceManager.isDiscoverying;
   bool _isRefreshing = false;
@@ -50,13 +52,14 @@ class DeviceDiscoveryViewModel extends AbstractScreenViewModel {
   int get remainingSeconds => _remainingSeconds;
 
   // Platform check
-  bool get isMobile => defaultTargetPlatform == TargetPlatform.android || defaultTargetPlatform == TargetPlatform.iOS;
+  bool get isMobile => _platformService.isMobile;
 
   DeviceDiscoveryViewModel(
     this._logger,
     this._deviceManager,
     this._bleProvisioner,
-    this.deviceMdoules, {
+    this.deviceMdoules,
+    this._platformService, {
     required super.globalEventBus,
     required super.gt,
     super.logger,

client/lib/features/devices/views/device_discovery_screen.dart

@@ -2,6 +2,7 @@ import 'package:borneo_app/features/devices/models/discoverable_device.dart';
 import 'package:borneo_app/features/devices/views/provisioning_screen.dart';
 import 'package:borneo_kernel_abstractions/models/supported_device_descriptor.dart';
 import 'package:flutter/material.dart';
+import 'package:borneo_app/core/services/platform_service.dart';
 import 'package:flutter_gettext/flutter_gettext/context_ext.dart';
 import 'package:flutter_gettext/flutter_gettext/gettext_localizations.dart';
 import 'package:provider/provider.dart';
@@ -25,6 +26,7 @@ class DeviceDiscoveryScreen extends StatelessWidget {
         cb.read<IDeviceManager>(),
         cb.read<IBleProvisioner>(),
         cb.read<IDeviceModuleRegistry>(),
+        cb.read<PlatformService>(), // injected platform helper
         globalEventBus: cb.read<EventBus>(),
         gt: gt,
         logger: cb.read<Logger>(),

client/lib/main.dart

@@ -16,6 +16,7 @@ import 'package:flutter/services.dart';
 import 'package:logger/logger.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:provider/provider.dart' as provider;
+import 'package:borneo_app/core/services/platform_service.dart';
 import 'package:provider/single_child_widget.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:event_bus/event_bus.dart';
@@ -129,6 +130,9 @@ Future<Widget> buildAppWidget({
     // LocaleService
     provider.Provider<ILocaleService>(create: (_) => AppLocaleService(), lazy: false),
 
+    // PlatformService (used by various components to make platform checks testable)
+    provider.Provider<PlatformService>(create: (_) => PlatformServiceImpl(), lazy: false),
+
     // EventBus
     provider.Provider<EventBus>(create: (_) => bus, lazy: false),
 

client/test/core/services/platform_service_test.dart

@@ -0,0 +1,75 @@
+import 'dart:io' show Platform;
+import 'package:flutter/foundation.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:borneo_app/core/services/platform_service.dart';
+
+class FakePlatformService implements PlatformService {
+  @override
+  bool isAndroid;
+
+  @override
+  bool isDesktop;
+
+  @override
+  bool isIOS;
+
+  @override
+  bool isLinux;
+
+  @override
+  bool isMacOS;
+
+  @override
+  bool isMobile;
+
+  @override
+  bool isWeb;
+
+  FakePlatformService({
+    this.isWeb = false,
+    this.isAndroid = false,
+    this.isIOS = false,
+    this.isWindows = false,
+    this.isMacOS = false,
+    this.isLinux = false,
+  }) : isDesktop = isWindows || isMacOS || isLinux,
+       isMobile = isAndroid || isIOS;
+
+  @override
+  bool isWindows = false;
+}
+
+void main() {
+  group('PlatformServiceImpl (real)', () {
+    final service = PlatformServiceImpl();
+
+    test('flags reflect current runtime', () {
+      // can't assert specific values since they vary by host; just ensure
+      // consistency between helpers and raw checks.
+      expect(service.isWeb, kIsWeb);
+      if (!kIsWeb) {
+        expect(service.isAndroid, Platform.isAndroid);
+        expect(service.isIOS, Platform.isIOS);
+        expect(service.isWindows, Platform.isWindows);
+        expect(service.isMacOS, Platform.isMacOS);
+        expect(service.isLinux, Platform.isLinux);
+      }
+
+      expect(service.isMobile, service.isAndroid || service.isIOS);
+      expect(service.isDesktop, service.isWindows || service.isMacOS || service.isLinux);
+    });
+  });
+
+  group('FakePlatformService', () {
+    test('allows test-friendly overrides', () {
+      final fake = FakePlatformService(isWeb: true, isAndroid: false, isIOS: false);
+      expect(fake.isWeb, true);
+      expect(fake.isDesktop, false);
+      expect(fake.isMobile, false);
+
+      final mobileFake = FakePlatformService(isAndroid: true);
+      expect(mobileFake.isMobile, true);
+      expect(mobileFake.isDesktop, false);
+    });
+  });
+}

client/test/view_models/device_discovery_view_model_test.dart

@@ -13,6 +13,7 @@ import 'package:borneo_app/features/devices/view_models/device_discovery_view_mo
 import 'package:borneo_app/core/services/devices/device_manager.dart';
 import 'package:borneo_app/core/services/devices/ble_provisioner.dart';
 import 'package:borneo_app/core/services/devices/device_module_registry.dart';
+import 'package:borneo_app/core/services/platform_service.dart';
 import 'package:borneo_app/features/devices/models/device_entity.dart';
 import 'package:borneo_app/features/devices/models/device_module_metadata.dart';
 import 'package:lw_wot/wot.dart';
@@ -23,6 +24,43 @@ import '../mocks/mocks.dart';
 
 // Minimal implementations / fakes for the interfaces used by the view model.
 
+// A tiny fake that lets tests pretend they are running on a particular
+// platform without depending on the real `dart:io` APIs.
+class FakePlatformService implements PlatformService {
+  @override
+  bool isWeb;
+
+  @override
+  bool isAndroid;
+
+  @override
+  bool isIOS;
+
+  @override
+  bool isWindows;
+
+  @override
+  bool isMacOS;
+
+  @override
+  bool isLinux;
+
+  FakePlatformService({
+    this.isWeb = false,
+    this.isAndroid = false,
+    this.isIOS = false,
+    this.isWindows = false,
+    this.isMacOS = false,
+    this.isLinux = false,
+  });
+
+  @override
+  bool get isMobile => isAndroid || isIOS;
+
+  @override
+  bool get isDesktop => isWindows || isMacOS || isLinux;
+}
+
 class FakeDeviceManager implements IDeviceManager {
   // ignore: unused_field
   final EventBus _bus = EventBus();
@@ -168,66 +206,59 @@ void main() {
     late DeviceDiscoveryViewModel vm;
     late FakeBleProvisioner bleProv;
 
-    setUp(() {
-      bleProv = FakeBleProvisioner();
-      vm = DeviceDiscoveryViewModel(
+    // helper to construct a VM configured for mobile/desktop and an optional
+    // permission stub.
+    DeviceDiscoveryViewModel makeVm({
+      required bool mobile,
+      Future<bool> Function()? permissions,
+      FakeBleProvisioner? ble,
+    }) {
+      bleProv = ble ?? FakeBleProvisioner();
+      return DeviceDiscoveryViewModel(
         Logger(),
         FakeDeviceManager(),
         bleProv,
         FakeDeviceModuleRegistry(),
+        FakePlatformService(isAndroid: mobile, isIOS: false, isWindows: !mobile),
         globalEventBus: EventBus(),
         gt: FakeGettext(),
         logger: Logger(),
-        requestBlePermissions: () async => false,
+        requestBlePermissions: permissions ?? () async => false,
       );
-    });
+    }
 
     test('startDiscovery does not call BLE scan when permissions denied', () async {
+      vm = makeVm(mobile: true, permissions: () async => false);
       expect(bleProv.scanCalled, isFalse);
       await vm.startDiscovery();
       expect(bleProv.scanCalled, isFalse);
       expect(vm.scanError.value, 'Bluetooth permissions are required to discover devices.');
     });
 
     test('startDiscovery calls BLE scan when permissions granted', () async {
-      // create new vm with permission true
-      vm = DeviceDiscoveryViewModel(
-        Logger(),
-        FakeDeviceManager(),
-        bleProv,
-        FakeDeviceModuleRegistry(),
-        globalEventBus: EventBus(),
-        gt: FakeGettext(),
-        logger: Logger(),
-        requestBlePermissions: () async => true,
-      );
-
+      vm = makeVm(mobile: true, permissions: () async => true);
       await vm.startDiscovery();
-      // allow _startBleScan unawaited future to run
+      // scanning happens asynchronously; give it a chance
       await Future.delayed(Duration.zero);
       expect(bleProv.scanCalled, isTrue);
     });
 
     test('startDiscovery handles platform exception permission denial', () async {
       final errorProv = FakeBleProvisioner();
-      // override to throw
       errorProv.scanImpl = (String prefix, {CancellationToken? cancelToken}) async {
         throw PlatformException(code: 'PERMISSION_DENIED', message: 'nope');
       };
-      vm = DeviceDiscoveryViewModel(
-        Logger(),
-        FakeDeviceManager(),
-        errorProv,
-        FakeDeviceModuleRegistry(),
-        globalEventBus: EventBus(),
-        gt: FakeGettext(),
-        logger: Logger(),
-        requestBlePermissions: () async => true,
-      );
-
+      vm = makeVm(mobile: true, permissions: () async => true, ble: errorProv);
       await vm.startDiscovery();
       await Future.delayed(Duration.zero);
       expect(vm.scanError.value, 'Bluetooth permissions are required to discover devices.');
     });
+
+    test('non‑mobile platforms skip BLE scan entirely', () async {
+      vm = makeVm(mobile: false, permissions: () async => true);
+      await vm.startDiscovery();
+      expect(bleProv.scanCalled, isFalse);
+      expect(vm.scanError.value, isNull);
+    });
   });
 }