chore: include util test

Author: jogboms

test/flutter_offline_test.dart

@@ -74,6 +74,18 @@ void main() {
       }, throwsAssertionError);
     });
 
+    testWidgets('Test null Host options', (WidgetTester tester) async {
+      expect(() {
+        OfflineBuilder.initialize(
+          connectivityService: TestConnectivityService(ConnectivityResult.none),
+          hostToCheck: null,
+          checkHost: null,
+          connectivityBuilder: (_, __, Widget child) => child,
+          child: const Text('child_result'),
+        );
+      }, throwsAssertionError);
+    });
+
     testWidgets('Test builder & child param', (WidgetTester tester) async {
       expect(() {
         OfflineBuilder.initialize(
@@ -159,6 +171,65 @@ void main() {
     });
   });
 
+  group("Test Check If Host", () {
+    testWidgets('with default host', (WidgetTester tester) async {
+      const debounceDuration = Duration.zero;
+      await tester.pumpWidget(MaterialApp(
+        home: OfflineBuilder.initialize(
+          connectivityService:
+              TestConnectivityService(ConnectivityResult.mobile),
+          checkHost: true,
+          debounceDuration: debounceDuration,
+          connectivityBuilder: (_, ConnectivityResult connectivity, __) =>
+              Text('$connectivity'),
+          child: const SizedBox(),
+        ),
+      ));
+
+      await tester.pump(debounceDuration);
+      expect(find.byType(SizedBox), findsOneWidget);
+    });
+
+    testWidgets('with local host', (WidgetTester tester) async {
+      const debounceDuration = Duration.zero;
+      await tester.pumpWidget(MaterialApp(
+        home: OfflineBuilder.initialize(
+          connectivityService:
+              TestConnectivityService(ConnectivityResult.mobile),
+          checkHost: true,
+          hostToCheck: "127.0.0.1",
+          debounceDuration: debounceDuration,
+          connectivityBuilder: (_, ConnectivityResult connectivity, __) =>
+              Text('$connectivity'),
+          child: const SizedBox(),
+        ),
+      ));
+
+      await tester.pump(debounceDuration);
+      expect(find.byType(SizedBox), findsOneWidget);
+    });
+
+    testWidgets('with bad host', (WidgetTester tester) async {
+      const debounceDuration = Duration.zero;
+      await tester.pumpWidget(MaterialApp(
+        home: OfflineBuilder.initialize(
+          connectivityService: TestConnectivityService(ConnectivityResult.none),
+          checkHost: true,
+          hostToCheck: "kkk",
+          debounceDuration: debounceDuration,
+          connectivityBuilder: (_, ConnectivityResult connectivity, __) {
+            print(connectivity);
+            return Text('$connectivity');
+          },
+          child: const SizedBox(),
+        ),
+      ));
+
+      await tester.pump(debounceDuration);
+      expect(find.byType(SizedBox), findsOneWidget);
+    });
+  });
+
   group("Test Debounce", () {
     testWidgets('Test for Debounce: Zero', (WidgetTester tester) async {
       final service = TestConnectivityService(ConnectivityResult.none);
@@ -280,9 +351,7 @@ class TestConnectivityService implements Connectivity {
   Stream<ConnectivityResult> get onConnectivityChanged => controller.stream;
 
   @override
-  Future<ConnectivityResult> checkConnectivity() {
-    return Future.delayed(Duration.zero, () => initialConnection);
-  }
+  Future<ConnectivityResult> checkConnectivity() async => initialConnection;
 
   @override
   Future<String> getWifiIP() async => '127.0.0.1';

test/utils_check_if_host_test.dart

@@ -0,0 +1,105 @@
+import 'dart:async';
+
+import 'package:connectivity/connectivity.dart';
+import 'package:flutter_offline/src/utils.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+Future<void> waitForTimer(int milliseconds) => Future<void>(() {
+      /* ensure Timer is started*/
+    })
+        .then<void>(
+      (_) => Future<void>.delayed(Duration(milliseconds: milliseconds + 1)),
+    );
+
+void main() {
+  group('Group', () {
+    StreamController<ConnectivityResult> values;
+    List emittedValues;
+    bool valuesCanceled;
+    bool isDone;
+    List errors;
+    StreamSubscription subscription;
+
+    void setUpStreams(StreamTransformer transformer) {
+      final stream = () => StreamController<ConnectivityResult>.broadcast();
+
+      valuesCanceled = false;
+      values = stream()..onCancel = () => valuesCanceled = true;
+      emittedValues = <ConnectivityResult>[];
+      errors = <ConnectivityResult>[];
+      isDone = false;
+      subscription = values.stream.transform<void>(transformer).listen(
+            emittedValues.add,
+            onError: errors.add,
+            onDone: () => isDone = true,
+          );
+    }
+
+    void cleanUpStreams() {
+      valuesCanceled = null;
+      values = null;
+      emittedValues = null;
+      errors = null;
+      isDone = null;
+      subscription = null;
+    }
+
+    group('when host is ok', () {
+      setUp(() async {
+        setUpStreams(checkIfHostIsAvailble("127.0.0.1"));
+      });
+
+      tearDown(() {
+        cleanUpStreams();
+      });
+
+      test('cancels values', () async {
+        await subscription.cancel();
+        expect(valuesCanceled, true);
+      });
+
+      test('works as expected', () async {
+        values.add(ConnectivityResult.wifi);
+        await waitForTimer(5);
+        expect(emittedValues, [ConnectivityResult.wifi]);
+      });
+
+      test('waits for pending value to close', () async {
+        values.add(ConnectivityResult.mobile);
+        await waitForTimer(5);
+        await values.close();
+        await Future(() {});
+        expect(isDone, true);
+      });
+    });
+
+    group('when host is not ok', () {
+      setUp(() async {
+        setUpStreams(checkIfHostIsAvailble("fake"));
+      });
+
+      tearDown(() {
+        cleanUpStreams();
+      });
+
+      test('cancels values', () async {
+        await subscription.cancel();
+        expect(valuesCanceled, true);
+      });
+
+      test('returns a ConnectivityResult.none', () async {
+        values.add(ConnectivityResult.wifi);
+        await waitForTimer(5);
+        expect(emittedValues, [ConnectivityResult.none]);
+      });
+
+      test('waits for pending value to close', () async {
+        values.add(ConnectivityResult.mobile);
+        await waitForTimer(5);
+        await values.close();
+        await Future(() {});
+        expect(isDone, true);
+      });
+    });
+  });
+}