Custom Header and Response Status Check

lib/src/internet_check_option.dart

@@ -1,5 +1,7 @@
 part of internet_connection_checker_plus;
 
+typedef ResponseStatusFn = bool Function(http.Response response);
+
 /// Options for checking the internet connectivity to an address.
 ///
 /// This class provides a way to specify options for checking the connectivity
@@ -27,12 +29,17 @@ class InternetCheckOption {
   /// final options = InternetCheckOption(
   ///   uri: Uri.parse('https://example.com'),
   ///   timeout: Duration(seconds: 5),
+  ///   headers: {
+  ///      'Authorization': 'Bearer token',
+  ///   },
   /// );
   /// ```
   InternetCheckOption({
     required this.uri,
     this.timeout = const Duration(seconds: 3),
-  });
+    Map<String, String>? headers,
+    this.responseStatusFn,
+  }) : headers = headers ?? <String, String>{};
 
   /// URI to check for connectivity. A HEAD request will be made to this URI.
   ///
@@ -50,11 +57,18 @@ class InternetCheckOption {
   /// Defaults to 3 seconds.
   final Duration timeout;
 
+  /// A map of additional headers to send with the request.
+  final Map<String, String> headers;
+
+  /// A callback to check expected response
+  final ResponseStatusFn? responseStatusFn;
+
   @override
   String toString() {
     return 'InternetCheckOption(\n'
         '  uri: $uri,\n'
-        '  timeout: $timeout\n'
+        '  timeout: $timeout,\n'
+        '  headers: ${headers.toString()}\n'
         ')';
   }
 }

lib/src/internet_connection.dart

@@ -127,11 +127,19 @@ class InternetConnection {
     InternetCheckOption option,
   ) async {
     try {
-      final response = await http.head(option.uri).timeout(option.timeout);
+      final response = await http
+          .head(
+            option.uri,
+            headers: option.headers,
+          )
+          .timeout(option.timeout);
+
+      ResponseStatusFn statusFn =
+          option.responseStatusFn ?? (response) => response.statusCode == 200;
 
       return InternetCheckResult(
         option: option,
-        isSuccess: response.statusCode == 200,
+        isSuccess: statusFn(response),
       );
     } catch (_) {
       return InternetCheckResult(

test/__mocks__/test_http_client.dart

@@ -0,0 +1,36 @@
+import 'package:http/http.dart' as http;
+
+typedef TestHttpResponseBuilder = http.Response Function(
+    http.BaseRequest request);
+
+class TestHttpClient extends http.BaseClient {
+  TestHttpResponseBuilder? responseBuilder;
+
+  static Future<void> run(
+      Future<void> Function(TestHttpClient client) fn) async {
+    final client = TestHttpClient();
+    await http.runWithClient(
+      () => fn(client),
+      () => client,
+    );
+  }
+
+  static http.Response createResponse({String? body, int statusCode = 200}) =>
+      http.Response(body ?? '', statusCode);
+
+  @override
+  Future<http.StreamedResponse> send(http.BaseRequest request) async {
+    final response =
+        (responseBuilder ?? (req) => http.Response('', 200))(request);
+    return http.StreamedResponse(
+      Stream.value(response.bodyBytes),
+      response.statusCode,
+      contentLength: response.contentLength,
+      headers: response.headers,
+      isRedirect: response.isRedirect,
+      persistentConnection: response.persistentConnection,
+      reasonPhrase: response.reasonPhrase,
+      request: request,
+    );
+  }
+}

test/internet_check_option_test.dart

@@ -13,7 +13,8 @@ void main() {
 
       const expectedString = 'InternetCheckOption(\n'
           '  uri: https://example.com,\n'
-          '  timeout: 0:00:05.000000\n'
+          '  timeout: 0:00:05.000000,\n'
+          '  headers: {}\n'
           ')';
 
       expect(options.toString(), expectedString);

test/internet_check_result_test.dart

@@ -19,7 +19,8 @@ void main() {
         String expectedString = 'InternetCheckResult(\n'
             '  option: InternetCheckOption(\n'
             '    uri: https://example.com,\n'
-            '    timeout: 0:00:03.000000\n'
+            '    timeout: 0:00:03.000000,\n'
+            '    headers: {}\n'
             '  ),\n'
             '  isSuccess: true\n'
             ')';

test/internet_connection_test.dart

@@ -2,6 +2,8 @@ import 'package:flutter_test/flutter_test.dart';
 
 import 'package:internet_connection_checker_plus/internet_connection_checker_plus.dart';
 
+import '__mocks__/test_http_client.dart';
+
 void main() {
   group('InternetConnection', () {
     test('hasInternetAccess returns true for valid URIs', () async {
@@ -21,6 +23,55 @@ void main() {
       expect(await checker.hasInternetAccess, false);
     });
 
+    test('hasInternetAccess invoke responseStatusFn to determine success',
+        () async {
+      await TestHttpClient.run((client) async {
+        client.responseBuilder =
+            (req) => TestHttpClient.createResponse(statusCode: 500);
+        const expectedStatus = true;
+        final checker = InternetConnection.createInstance(
+          customCheckOptions: [
+            InternetCheckOption(
+              uri: Uri.parse('https://www.example.com/nonexistent-page'),
+              responseStatusFn: (response) => expectedStatus,
+            ),
+          ],
+          useDefaultOptions: false,
+        );
+
+        expect(await checker.hasInternetAccess, expectedStatus);
+      });
+    });
+
+    test('hasInternetAccess send custom header on request', () async {
+      await TestHttpClient.run((client) async {
+        const expectedStatus = true;
+        const expectedHeaders = {'Authorization': 'Bearer token'};
+
+        client.responseBuilder = (req) {
+          for (final header in expectedHeaders.entries) {
+            final key = header.key;
+            if (!req.headers.containsKey(key) ||
+                req.headers[key] != header.value) {
+              return TestHttpClient.createResponse(statusCode: 500);
+            }
+          }
+          return TestHttpClient.createResponse(statusCode: 200);
+        };
+        final checker = InternetConnection.createInstance(
+          customCheckOptions: [
+            InternetCheckOption(
+              uri: Uri.parse('https://www.example.com'),
+              headers: expectedHeaders,
+            ),
+          ],
+          useDefaultOptions: false,
+        );
+
+        expect(await checker.hasInternetAccess, expectedStatus);
+      });
+    });
+
     test('main constructor returns the same instance', () {
       final checker = InternetConnection();
       expect(checker, InternetConnection());