Added unit test cases (#125)

* Add first unit test to project

* Add new unit test

* Add new unit test to increase coverage

* Update library test and fix issue reported by 'analyze'

* Fixed errors after merging with main.

* Fixed flutter analyze warnings

* Updated flush_policy_test.dart

---------

Co-authored-by: Edson Amaya <edson.amaya.dev@gmail.com>
Co-authored-by: Shane L. Duvall <sduvall@mark4tech.com>
Co-authored-by: Rishabh Jain <risjain@twilio.com>
Co-authored-by: Michael Grosse Huelsewiesche <mihuelsewiesche@twilio.com>

Author: 5 people

.gitignore

@@ -38,4 +38,7 @@ build/
 launch.json
 
 #Coverage
-coverage/
+coverage/
+
+# FVM Version Cache
+.fvm/

packages/core/lib/analytics_pigeon.dart

@@ -1,3 +1,4 @@
+
 import 'package:segment_analytics/analytics_platform_interface.dart';
 import 'package:flutter/services.dart';
 
@@ -7,11 +8,13 @@ import 'native_context.dart';
 class AnalyticsPlatformImpl extends AnalyticsPlatform {
   static const EventChannel _eChannel =
       EventChannel('analytics/deep_link_events');
-  final NativeContextApi _api = NativeContextApi();
+  NativeContextApi api;
+
+  AnalyticsPlatformImpl({NativeContextApi? api}) : api = api ?? NativeContextApi();
 
   @override
   Future<NativeContext> getContext({bool collectDeviceId = false}) {
-    return _api.getContext(collectDeviceId);
+    return api.getContext(collectDeviceId);
   }
 
   @override

packages/core/lib/flush_policies/count_flush_policy.dart

@@ -1,3 +1,4 @@
+import 'package:flutter/foundation.dart';
 import 'package:segment_analytics/event.dart';
 import 'package:segment_analytics/flush_policies/flush_policy.dart';
 
@@ -7,6 +8,9 @@ class CountFlushPolicy extends FlushPolicy {
 
   CountFlushPolicy(this._flushAt, {int? count}) : _count = count ?? 0;
 
+  @visibleForTesting
+  int get count => _count;
+
   @override
   void start() {
     _count = 0;

packages/core/lib/plugins/segment_destination.dart

@@ -15,10 +15,10 @@ class SegmentDestination extends DestinationPlugin with Flushable {
   String? _apiHost;
 
   SegmentDestination() : super(segmentDestinationKey) {
-    _queuePlugin = QueueFlushingPlugin(_sendEvents);
+    _queuePlugin = QueueFlushingPlugin(sendEvents);
   }
 
-  Future _sendEvents(List<RawEvent> events) async {
+  Future sendEvents(List<RawEvent> events) async {
     if (events.isEmpty) {
       return;
     }

packages/core/lib/utils/lifecycle/fgbg.dart

@@ -4,12 +4,14 @@ import 'package:segment_analytics/utils/lifecycle/lifecycle.dart';
 import 'package:flutter_fgbg/flutter_fgbg.dart';
 
 class FGBGLifecycle extends LifeCycle {
-  final _stream = FGBGEvents.instance.stream;
+  final Stream<FGBGType> stream;
+
+  FGBGLifecycle(this.stream);
 
   @override
   StreamSubscription<AppStatus> listen(void Function(AppStatus event)? onData,
       {Function? onError, void Function()? onDone, bool? cancelOnError}) {
-    return _stream
+    return stream
         .map((event) => (event == FGBGType.foreground)
             ? AppStatus.foreground
             : AppStatus.background)

packages/core/lib/utils/lifecycle/lifecycle.dart

@@ -1,6 +1,7 @@
 import 'dart:async';
 import 'dart:io';
 
+import 'package:flutter_fgbg/flutter_fgbg.dart';
 import 'package:segment_analytics/utils/lifecycle/fgbg.dart';
 import 'package:segment_analytics/utils/lifecycle/widget_observer.dart';
 import 'package:flutter/foundation.dart';
@@ -9,16 +10,17 @@ enum AppStatus { foreground, background }
 
 abstract class LifeCycle extends Stream<AppStatus> {}
 
-LifeCycle _getLifecycleStream() {
+@visibleForTesting
+LifeCycle getLifecycleStream() {
   if (!kIsWeb && (Platform.isAndroid || Platform.isIOS)) {
     // For iOS and Android we will use the FgBg Lifecycle listener as it reports directly from native level
     // ignoring native popups
-    return FGBGLifecycle();
+    return FGBGLifecycle(FGBGEvents.instance.stream);
   } else {
     // For Web and Desktop we use the WidgetObserver implementation directly from Flutter
     // TBF Flutter doesn't have a very reliable background signal for those platforms
     return WidgetObserverLifecycle();
   }
 }
 
-final LifeCycle lifecycle = _getLifecycleStream();
+final LifeCycle lifecycle = getLifecycleStream();

packages/core/lib/utils/store/io.dart

@@ -1,3 +1,4 @@
+// coverage:ignore-file
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';

packages/core/pubspec.yaml

@@ -29,10 +29,11 @@ dev_dependencies:
   build_runner: ^2.4.7
   flutter_test:
     sdk: flutter
+  fake_async: ^1.0.0
   flutter_lints: ^4.0.0
   json_serializable: ^6.8.0
   pigeon: ^7.2.1
-  mockito: ^5.4.4
+  mockito: ^5.3.2
 
 flutter:
   plugin:

packages/core/test/analytics_pigeon_test.dart

@@ -0,0 +1,33 @@
+// test/analytics_platform_impl_test.dart
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/mockito.dart';
+import 'package:segment_analytics/analytics_pigeon.dart';
+
+import 'package:segment_analytics/native_context.dart';
+import 'mocks/mocks.mocks.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  group('AnalyticsPlatformImpl Tests', () {
+    late AnalyticsPlatformImpl analyticsPlatform;
+    late MockNativeContextApi mockNativeContextApi;
+
+    setUp(() {
+      mockNativeContextApi = MockNativeContextApi();
+      analyticsPlatform = AnalyticsPlatformImpl();
+      analyticsPlatform.api = mockNativeContextApi;
+    });
+
+    test('getContext returns NativeContext', () async {
+      final nativeContext = NativeContext();
+      when(mockNativeContextApi.getContext(any))
+          .thenAnswer((_) async => nativeContext);
+
+      final result = await analyticsPlatform.getContext(collectDeviceId: true);
+
+      expect(result, isA<NativeContext>());
+      verify(mockNativeContextApi.getContext(true)).called(1);
+    });
+  });
+}

packages/core/test/analytics_test.dart

@@ -1,14 +1,19 @@
 import 'package:segment_analytics/analytics.dart';
 import 'package:segment_analytics/analytics_platform_interface.dart';
+import 'package:segment_analytics/client.dart';
 import 'package:segment_analytics/event.dart';
+import 'package:segment_analytics/flush_policies/count_flush_policy.dart';
+import 'package:segment_analytics/flush_policies/flush_policy.dart';
 import 'package:segment_analytics/logger.dart';
+import 'package:segment_analytics/plugins/event_logger.dart';
 import 'package:segment_analytics/state.dart';
 import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mockito/mockito.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
 import 'mocks/mocks.dart';
+import 'mocks/mocks.mocks.dart';
 
 void main() {
   WidgetsFlutterBinding.ensureInitialized();
@@ -21,55 +26,118 @@ void main() {
   ];
 
   group("analytics", () {
-
-    setUp(() {
+    late Analytics analytics;
+    late MockHTTPClient httpClient;
+    setUp(() async {
       AnalyticsPlatform.instance = MockPlatform();
-
       // Prevents spamming the test console. Eventually logging info will be behind a debug flag so this won't be needed
       LogFactory.logger = Mocks.logTarget();
-
       SharedPreferences.setMockInitialValues({});
-    });
 
-    test(
-        "it fetches settings but does not fire track event when not tracking lifecycle events",
-        () async {
-      final httpClient = Mocks.httpClient();
+      httpClient = Mocks.httpClient();
       when(httpClient.settingsFor(writeKey))
           .thenAnswer((_) => Future.value(SegmentAPISettings({})));
       when(httpClient.startBatchUpload(writeKey, batch))
           .thenAnswer((_) => Future.value(true));
 
-      Analytics analytics = Analytics(
+      analytics = Analytics(
           Configuration("123",
               trackApplicationLifecycleEvents: false,
-              appStateStream: () => Mocks.streamSubscription()),
+              token: "abcdef12345"),
           Mocks.store(),
           httpClient: (_) => httpClient);
       await analytics.init();
+    });
 
+    test(
+        "it fetches settings but does not fire track event when not tracking lifecycle events",
+        () async {
+      
       verify(httpClient.settingsFor(writeKey));
       verifyNever(httpClient.startBatchUpload(writeKey, batch));
     });
     test(
         "it fetches settings and fires track event when tracking lifecycle events",
         () async {
-      final httpClient = Mocks.httpClient();
-      when(httpClient.settingsFor(writeKey))
-          .thenAnswer((_) => Future.value(SegmentAPISettings({})));
-      when(httpClient.startBatchUpload(writeKey, batch))
-          .thenAnswer((_) => Future.value(true));
-
-      Analytics analytics = Analytics(
-          Configuration("123",
-              trackApplicationLifecycleEvents: true,
-              appStateStream: () => Mocks.streamSubscription()),
-          Mocks.store(),
-          httpClient: (_) => httpClient);
-      await analytics.init();
 
       verify(httpClient.settingsFor(writeKey));
       verifyNever(httpClient.startBatchUpload(writeKey, batch));
     });
+
+    test('it analytics track should be callable', () {
+      analytics.track("test track");
+    });
+    test('it analytics screen should be callable', () {
+      analytics.screen("test screem");
+    });
+    test('it analytics identify should be callable', () {
+      analytics.identify();
+    });
+    test('it analytics group should be callable', () {
+      analytics.group("test group");
+    });
+    test('it analytics alias should be callable', () {
+      analytics.alias("test alias");
+    });
+    test('it analytics cleanup should be callable', () {
+      analytics.cleanup();
+    });
+    test('it analytics reset should be callable', () {
+      analytics.reset();
+    });
+    test('it analytics addFlushPolicy should be callable', () {
+      List<FlushPolicy> policies = [];
+      policies.add(CountFlushPolicy(5));
+      analytics.addFlushPolicy(policies);
+    });
+    test('it analytics getFlushPolicies should be callable', () {
+      analytics.getFlushPolicies();
+    });
+    test('it analytics removeFlushPolicy should be callable', () {
+      List<FlushPolicy> policies = [];
+      policies.add(CountFlushPolicy(5));
+      analytics.removeFlushPolicy(policies);
+    });
+    test('it analytics removePlugin should be callable', () {
+      analytics.addPlugin(EventLogger(), settings: {"event":"Track Event"});
+    });
+    test('it analytics removePlugin should be callable', () {
+      analytics.removePlugin(EventLogger());
+    });
+    test('it analytics onContextLoaded should be callable', () {
+      analytics.onContextLoaded((p0) { });
+    });
+    test('it analytics onPluginLoaded should be callable', () {
+      analytics.onPluginLoaded((p0) { });
+    });
+    
+    test("Test analytics platform getContext", () {
+      AnalyticsPlatform analyticsPlatform = MockAnalyticsPlatform();
+
+      expect(
+        () async => await analyticsPlatform.getContext(),
+        throwsA(isA<UnimplementedError>()),
+      );
+    });
+    test("Test analytics platform linkStream", () {
+      AnalyticsPlatform analyticsPlatform = MockAnalyticsPlatform();
+
+      expect(
+        () async => analyticsPlatform.linkStream,
+        throwsA(isA<UnimplementedError>()),
+      );
+    });
+
+    test("it createClient", () async {
+      Analytics analytics = createClient(Configuration("123",
+              debug: false,
+              trackApplicationLifecycleEvents: true,
+              trackDeeplinks: true,
+              token: "abcdef12345")
+              );
+      expect(analytics, isA<Analytics>());
+    });
   });
 }
+
+class MockAnalyticsPlatform extends AnalyticsPlatform { }