Added Tests for (/lib/utils): 100% Coverage

packages/better_networking/test/extensions/map_extensions_test.dart

@@ -124,4 +124,22 @@ void main() {
       },
     );
   });
+
+  group("Testing removeKeyContentType() function", () {
+    test('Removes lowercase content-type key', () {
+      Map<String, String> header1 = {
+        "content-type": "application/json",
+        "authorization": "Bearer token",
+      };
+      header1.removeKeyContentType();
+      expect(header1.containsKey("content-type"), false);
+      expect(header1.containsKey("authorization"), true);
+    });
+
+    test('Preserves original map after mutation', () {
+      final header4 = {"Content-Type": "application/json", "X-Custom": "value"};
+      final result = header4.removeKeyContentType();
+      expect(identical(result, header4), true);
+    });
+  });
 }

packages/better_networking/test/stream_request_test/gql_test.dart

@@ -81,6 +81,7 @@ void main() {
       );
       httpClientManager.cancelRequest('graphql_test_c');
       final output = await stream.first;
+      print(output);
       final errMsg = output?.$4;
       expect(
         errMsg,

packages/better_networking/test/utils/content_type_utils_test.dart

@@ -0,0 +1,101 @@
+import 'package:better_networking/better_networking.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('getMediaTypeFromContentType', () {
+    test('Parses valid content type', () {
+      final mediaType = getMediaTypeFromContentType('application/json');
+      expect(mediaType, isNotNull);
+      expect(mediaType!.type, 'application');
+      expect(mediaType.subtype, 'json');
+    });
+
+    test('Returns null on invalid content type', () {
+      final mediaType = getMediaTypeFromContentType('not-a-valid-header');
+      expect(mediaType, isNull);
+    });
+
+    test('Returns null when input is null', () {
+      final mediaType = getMediaTypeFromContentType(null);
+      expect(mediaType, isNull);
+    });
+  });
+
+  group('getContentTypeFromMediaType', () {
+    test('Returns json content type for application/json', () {
+      final mediaType = MediaType.parse('application/json');
+      expect(getContentTypeFromMediaType(mediaType), ContentType.json);
+    });
+
+    test('Returns formdata for multipart/form-data', () {
+      final mediaType = MediaType.parse('multipart/form-data');
+      expect(getContentTypeFromMediaType(mediaType), ContentType.formdata);
+    });
+
+    test('Returns text for other types', () {
+      final mediaType = MediaType.parse('text/html');
+      expect(getContentTypeFromMediaType(mediaType), ContentType.text);
+    });
+
+    test('Returns null for null mediaType', () {
+      expect(getContentTypeFromMediaType(null), isNull);
+    });
+  });
+
+  group('getMediaTypeFromHeaders', () {
+    test('Extracts MediaType from headers map', () {
+      final headers = {"Content-Type": "application/json"};
+      final mediaType = getMediaTypeFromHeaders(headers);
+      expect(mediaType, isNotNull);
+      expect(mediaType!.type, 'application');
+      expect(mediaType.subtype, 'json');
+    });
+
+    test('Returns null if Content-Type is missing', () {
+      final headers = {"Accept": "application/json"};
+      expect(getMediaTypeFromHeaders(headers), isNull);
+    });
+  });
+
+  group('getContentTypeFromHeadersMap', () {
+    test('Returns ContentType.json from headers map', () {
+      final headers = {"content-type": "application/json"};
+      expect(getContentTypeFromHeadersMap(headers), ContentType.json);
+    });
+
+    test('Returns ContentType.formdata from headers map', () {
+      final headers = {"Content-Type": "multipart/form-data"};
+      expect(getContentTypeFromHeadersMap(headers), ContentType.formdata);
+    });
+
+    test('Returns null when headers map is null', () {
+      expect(getContentTypeFromHeadersMap(null), isNull);
+    });
+
+    test('Returns null when Content-Type is missing', () {
+      final headers = {"Accept": "application/json"};
+      expect(getContentTypeFromHeadersMap(headers), isNull);
+    });
+  });
+
+  group('getContentTypeFromContentTypeStr', () {
+    test('Correctly parses string into ContentType', () {
+      expect(
+        getContentTypeFromContentTypeStr('application/json'),
+        ContentType.json,
+      );
+      expect(
+        getContentTypeFromContentTypeStr('multipart/form-data'),
+        ContentType.formdata,
+      );
+    });
+
+    test('Returns null for invalid string', () {
+      expect(getContentTypeFromContentTypeStr('invalid-content-type'), isNull);
+    });
+
+    test('Returns null for null input', () {
+      expect(getContentTypeFromContentTypeStr(null), isNull);
+    });
+  });
+}

packages/better_networking/test/utils/http_request_utils.dart

@@ -1,74 +0,0 @@
-import 'package:better_networking/better_networking.dart';
-import 'package:test/test.dart';
-
-void main() {
-  group('Testing RemoveJsonComments', () {
-    test('Removes single-line comments', () {
-      String input = '''
-      {
-        // This is a single-line comment
-        "key": "value"
-      }
-      ''';
-
-      String expected = '''{
-  "key": "value"
-}''';
-      expect(removeJsonComments(input), expected);
-    });
-
-    test('Removes multi-line comments', () {
-      String input = '''
-      {
-        /*
-          This is a multi-line comment
-        */
-        "key": "value"
-      }
-      ''';
-
-      String expected = '''{
-  "key": "value"
-}''';
-      expect(removeJsonComments(input), expected);
-    });
-
-    test('Handles valid JSON without comments', () {
-      String input = '{"key":"value"}';
-      String expected = '''{
-  "key": "value"
-}''';
-      expect(removeJsonComments(input), expected);
-    });
-
-    test('Returns original string if invalid JSON', () {
-      String input = '{key: value}';
-      String expected = '{key: value}';
-      expect(removeJsonComments(input), expected);
-    });
-
-    test('Removes trailing commas', () {
-      String input = '''
-      {
-        "key1": "value1",
-        "key2": "value2", // trailing comma
-      }
-      ''';
-
-      String expected = '''{
-  "key1": "value1",
-  "key2": "value2"
-}''';
-      expect(removeJsonComments(input), expected);
-    });
-
-    test('Test blank json', () {
-      String input = '''
-      {}
-      ''';
-
-      String expected = '{}';
-      expect(removeJsonComments(input), expected);
-    });
-  });
-}

packages/better_networking/test/utils/http_request_utils_test.dart

@@ -0,0 +1,282 @@
+import 'dart:convert';
+
+import 'package:better_networking/better_networking.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Testing RemoveJsonComments', () {
+    test('Removes single-line comments', () {
+      String input = '''
+      {
+        // This is a single-line comment
+        "key": "value"
+      }
+      ''';
+
+      String expected = '''{
+  "key": "value"
+}''';
+      expect(removeJsonComments(input), expected);
+    });
+
+    test('Removes multi-line comments', () {
+      String input = '''
+      {
+        /*
+          This is a multi-line comment
+        */
+        "key": "value"
+      }
+      ''';
+
+      String expected = '''{
+  "key": "value"
+}''';
+      expect(removeJsonComments(input), expected);
+    });
+
+    test('Handles valid JSON without comments', () {
+      String input = '{"key":"value"}';
+      String expected = '''{
+  "key": "value"
+}''';
+      expect(removeJsonComments(input), expected);
+    });
+
+    test('Returns original string if invalid JSON', () {
+      String input = '{key: value}';
+      String expected = '{key: value}';
+      expect(removeJsonComments(input), expected);
+    });
+
+    test('Removes trailing commas', () {
+      String input = '''
+      {
+        "key1": "value1",
+        "key2": "value2", // trailing comma
+      }
+      ''';
+
+      String expected = '''{
+  "key1": "value1",
+  "key2": "value2"
+}''';
+      expect(removeJsonComments(input), expected);
+    });
+
+    test('Test blank json', () {
+      String input = '''
+      {}
+      ''';
+
+      String expected = '{}';
+      expect(removeJsonComments(input), expected);
+    });
+  });
+
+  group("Testing rowsToMap", () {
+    test('Testing for null', () {
+      expect(rowsToMap(null), null);
+    });
+    test('Testing for string KVRow values', () {
+      const kvRow1 = NameValueModel(name: "code", value: "IN");
+      expect(rowsToMap([kvRow1]), {"code": "IN"});
+    });
+    test('Testing when header is True', () {
+      const kvRow2 = NameValueModel(name: "Text", value: "ABC");
+      expect(rowsToMap([kvRow2], isHeader: true), {"text": "ABC"});
+    });
+    test('Testing when header is false and key is in upper case', () {
+      const kvRow3 = <NameValueModel>[
+        NameValueModel(name: "TEXT", value: "ABC"),
+        NameValueModel(name: "version", value: 0.1),
+        NameValueModel(name: "month", value: 4),
+      ];
+      expect(rowsToMap(kvRow3), {
+        "TEXT": "ABC",
+        "version": "0.1",
+        "month": "4",
+      });
+    });
+  });
+
+  group("Testing mapToRows", () {
+    test('Testing for null', () {
+      expect(mapToRows(null), null);
+    });
+    test('Testing with a map value', () {
+      Map<String, String> value1 = {"text": "abc", "lang": "eng", "code": "1"};
+      const result1Expected = <NameValueModel>[
+        NameValueModel(name: "text", value: "abc"),
+        NameValueModel(name: "lang", value: "eng"),
+        NameValueModel(name: "code", value: "1"),
+      ];
+      expect(mapToRows(value1), result1Expected);
+    });
+  });
+
+  group("Testing rowsToFormDataMapList", () {
+    test('Testing for null', () {
+      expect(rowsToFormDataMapList(null), null);
+    });
+    test('Testing with a map value', () {
+      const input = <FormDataModel>[
+        FormDataModel(name: "text", value: "abc", type: FormDataType.file),
+        FormDataModel(name: "lang", value: "eng", type: FormDataType.file),
+        FormDataModel(name: "code", value: "1", type: FormDataType.text),
+      ];
+      const expectedResult = [
+        {"name": "text", "value": "abc", "type": "file"},
+        {"name": "lang", "value": "eng", "type": "file"},
+        {"name": "code", "value": "1", "type": "text"},
+      ];
+      expect(rowsToFormDataMapList(input), expectedResult);
+    });
+  });
+
+  group("Testing mapListToFormDataModelRows", () {
+    test('Testing for null', () {
+      expect(mapListToFormDataModelRows(null), null);
+    });
+    test('Testing with a map value', () {
+      const input = [
+        {"name": "text", "value": "abc", "type": "file"},
+        {"name": "lang", "value": "eng", "type": "file"},
+        {"name": "code", "value": "1", "type": "text"},
+      ];
+      const expectedResult = <FormDataModel>[
+        FormDataModel(name: "text", value: "abc", type: FormDataType.file),
+        FormDataModel(name: "lang", value: "eng", type: FormDataType.file),
+        FormDataModel(name: "code", value: "1", type: FormDataType.text),
+      ];
+      expect(mapListToFormDataModelRows(input), expectedResult);
+    });
+  });
+
+  group("Test getEnabledRows", () {
+    test('Testing for null', () {
+      expect(getEnabledRows(null, null), null);
+    });
+    test('Testing for empty list', () {
+      expect(getEnabledRows([], []), []);
+    });
+    const kvRow1 = NameValueModel(name: "code", value: "IN");
+    const kvRow2 = NameValueModel(name: "lang", value: "eng");
+    const kvRow3 = NameValueModel(name: "version", value: 0.1);
+    const kvRow4 = NameValueModel(name: "month", value: 4);
+    test('Testing with isRowEnabledList null', () {
+      expect(getEnabledRows([kvRow1, kvRow2, kvRow3, kvRow4], null), [
+        kvRow1,
+        kvRow2,
+        kvRow3,
+        kvRow4,
+      ]);
+    });
+    test('Testing for list with all enabled', () {
+      expect(
+        getEnabledRows(
+          [kvRow1, kvRow2, kvRow3, kvRow4],
+          [true, true, true, true],
+        ),
+        [kvRow1, kvRow2, kvRow3, kvRow4],
+      );
+    });
+    test('Testing for list with all disabled', () {
+      expect(
+        getEnabledRows(
+          [kvRow1, kvRow2, kvRow3, kvRow4],
+          [false, false, false, false],
+        ),
+        [],
+      );
+    });
+    test('Testing for list with some disabled', () {
+      expect(
+        getEnabledRows(
+          [kvRow1, kvRow2, kvRow3, kvRow4],
+          [true, false, true, false],
+        ),
+        [kvRow1, kvRow3],
+      );
+    });
+  });
+
+  group('Testing getRequestBody', () {
+    test('Returns body for REST when hasJsonData is true', () {
+      const model = HttpRequestModel(
+        body: '{"key":"value"}',
+        method: HTTPVerb.post,
+      );
+      final result = getRequestBody(APIType.rest, model);
+      expect(result, '{"key":"value"}');
+    });
+
+    test('Returns body for REST when hasTextData is true', () {
+      const model = HttpRequestModel(body: 'plain text', method: HTTPVerb.post);
+      final result = getRequestBody(APIType.rest, model);
+      expect(result, 'plain text');
+    });
+
+    test('Returns null for REST when no data', () {
+      const model = HttpRequestModel(body: null);
+      final result = getRequestBody(APIType.rest, model);
+      expect(result, isNull);
+    });
+
+    test('Returns GraphQL body as JSON when query is present', () {
+      const model = HttpRequestModel(
+        query: '{ users { name } }',
+        method: HTTPVerb.post,
+      );
+      final result = getRequestBody(APIType.graphql, model);
+      expect(result, '{\n  "query": "{ users { name } }"\n}');
+    });
+
+    test('Returns null for GraphQL when query is missing', () {
+      const model = HttpRequestModel(query: null);
+      final result = getRequestBody(APIType.graphql, model);
+      expect(result, isNull);
+    });
+
+    test('Returns null for GraphQL when query is empty', () {
+      const model = HttpRequestModel(query: '');
+      final result = getRequestBody(APIType.graphql, model);
+      expect(result, isNull);
+    });
+  });
+
+  group('getFormDataType', () {
+    test('Returns correct enum for valid type "text"', () {
+      expect(getFormDataType("text"), FormDataType.text);
+    });
+
+    test('Returns correct enum for valid type "file"', () {
+      expect(getFormDataType("file"), FormDataType.file);
+    });
+
+    test('Returns FormDataType.text for any other unknown type', () {
+      expect(getFormDataType("unknown_type"), FormDataType.text);
+    });
+  });
+
+  group('convertStreamedResponse', () {
+    test('Converts StreamedResponse into Response correctly', () async {
+      final bodyBytes = "Hello".codeUnits; // "Hello"
+      final streamedResponse = StreamedResponse(
+        Stream.fromIterable([bodyBytes]),
+        200,
+        headers: {'content-type': 'text/plain'},
+        reasonPhrase: 'OK',
+        persistentConnection: true,
+      );
+
+      final response = await convertStreamedResponse(streamedResponse);
+
+      expect(response.statusCode, 200);
+      expect(response.body, 'Hello');
+      expect(response.headers['content-type'], 'text/plain');
+      expect(response.reasonPhrase, 'OK');
+      expect(response.persistentConnection, true);
+    });
+  });
+}

packages/better_networking/test/utils/string_utils_test.dart

@@ -0,0 +1,37 @@
+import 'package:better_networking/utils/string_utils.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('RandomStringGenerator', () {
+    test('getRandomString returns correct length', () {
+      final result = RandomStringGenerator.getRandomString(10);
+      expect(result.length, 10);
+    });
+
+    test('getRandomString returns only valid characters', () {
+      final result = RandomStringGenerator.getRandomString(100);
+      const _chars =
+          'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz1234567890';
+      final validChars = _chars.split('').toSet();
+      final isValid = result.split('').every(validChars.contains);
+      expect(isValid, true);
+    });
+
+    test('getRandomStringLines returns correct number of lines', () {
+      final result = RandomStringGenerator.getRandomStringLines(5, 8);
+      final lines = result.split('\n');
+      expect(lines.length, 5);
+      expect(lines.every((line) => line.length == 8), true);
+    });
+
+    test('getRandomStringLines returns empty string for 0 lines', () {
+      final result = RandomStringGenerator.getRandomStringLines(0, 8);
+      expect(result, '');
+    });
+
+    test('getRandomString returns empty string for length 0', () {
+      final result = RandomStringGenerator.getRandomString(0);
+      expect(result, '');
+    });
+  });
+}

packages/better_networking/test/utils/uri_utils_test.dart

@@ -176,4 +176,33 @@ void main() {
       expect(getValidRequestUri(url7, null), (uri7Expected, null));
     });
   });
+
+  group("Testing stripUriParams", () {
+    test('Removes query parameters from Uri with query', () {
+      final uri = Uri.parse(
+        "https://example.com/path/to/resource?param1=value1&param2=value2",
+      );
+      expect(stripUriParams(uri), "https://example.com/path/to/resource");
+    });
+
+    test('Removes fragment and query from Uri', () {
+      final uri = Uri.parse("https://example.com/api#section?foo=bar");
+      expect(stripUriParams(uri), "https://example.com/api");
+    });
+
+    test('stripUrlParams removes query from URL string', () {
+      const url = "https://example.com/page?x=1&y=2";
+      expect(stripUrlParams(url), "https://example.com/page");
+    });
+
+    test('stripUrlParams handles URL with no query', () {
+      const url = "https://example.com/page";
+      expect(stripUrlParams(url), "https://example.com/page");
+    });
+
+    test('stripUrlParams with only ? and no query', () {
+      const url = "https://example.com/page?";
+      expect(stripUrlParams(url), "https://example.com/page");
+    });
+  });
 }

test/utils/convert_utils_test.dart

@@ -94,81 +94,6 @@ void main() {
       expect(formatHeaderCase(headerText2), headerText2Expected);
     });
   });
-  group("Testing rowsToMap", () {
-    test('Testing for null', () {
-      expect(rowsToMap(null), null);
-    });
-    test('Testing for string KVRow values', () {
-      const kvRow1 = NameValueModel(name: "code", value: "IN");
-      expect(rowsToMap([kvRow1]), {"code": "IN"});
-    });
-    test('Testing when header is True', () {
-      const kvRow2 = NameValueModel(name: "Text", value: "ABC");
-      expect(rowsToMap([kvRow2], isHeader: true), {"text": "ABC"});
-    });
-    test('Testing when header is false and key is in upper case', () {
-      const kvRow3 = <NameValueModel>[
-        NameValueModel(name: "TEXT", value: "ABC"),
-        NameValueModel(name: "version", value: 0.1),
-        NameValueModel(name: "month", value: 4),
-      ];
-      expect(
-          rowsToMap(kvRow3), {"TEXT": "ABC", "version": "0.1", "month": "4"});
-    });
-  });
-
-  group("Testing mapToRows", () {
-    test('Testing for null', () {
-      expect(mapToRows(null), null);
-    });
-    test('Testing with a map value', () {
-      Map<String, String> value1 = {"text": "abc", "lang": "eng", "code": "1"};
-      const result1Expected = <NameValueModel>[
-        NameValueModel(name: "text", value: "abc"),
-        NameValueModel(name: "lang", value: "eng"),
-        NameValueModel(name: "code", value: "1")
-      ];
-      expect(mapToRows(value1), result1Expected);
-    });
-  });
-
-  group("Testing rowsToFormDataMapList", () {
-    test('Testing for null', () {
-      expect(rowsToFormDataMapList(null), null);
-    });
-    test('Testing with a map value', () {
-      const input = <FormDataModel>[
-        FormDataModel(name: "text", value: "abc", type: FormDataType.file),
-        FormDataModel(name: "lang", value: "eng", type: FormDataType.file),
-        FormDataModel(name: "code", value: "1", type: FormDataType.text)
-      ];
-      const expectedResult = [
-        {"name": "text", "value": "abc", "type": "file"},
-        {"name": "lang", "value": "eng", "type": "file"},
-        {"name": "code", "value": "1", "type": "text"}
-      ];
-      expect(rowsToFormDataMapList(input), expectedResult);
-    });
-  });
-
-  group("Testing mapListToFormDataModelRows", () {
-    test('Testing for null', () {
-      expect(mapListToFormDataModelRows(null), null);
-    });
-    test('Testing with a map value', () {
-      const input = [
-        {"name": "text", "value": "abc", "type": "file"},
-        {"name": "lang", "value": "eng", "type": "file"},
-        {"name": "code", "value": "1", "type": "text"}
-      ];
-      const expectedResult = <FormDataModel>[
-        FormDataModel(name: "text", value: "abc", type: FormDataType.file),
-        FormDataModel(name: "lang", value: "eng", type: FormDataType.file),
-        FormDataModel(name: "code", value: "1", type: FormDataType.text)
-      ];
-      expect(mapListToFormDataModelRows(input), expectedResult);
-    });
-  });
 
   group("Testing getFormDataType", () {
     test('Testing for null', () {
@@ -240,41 +165,6 @@ Easily manipulate and play around with request inputs like headers, query parame
     });
   });
 
-  group("Test getEnabledRows", () {
-    test('Testing for null', () {
-      expect(getEnabledRows(null, null), null);
-    });
-    test('Testing for empty list', () {
-      expect(getEnabledRows([], []), []);
-    });
-    const kvRow1 = NameValueModel(name: "code", value: "IN");
-    const kvRow2 = NameValueModel(name: "lang", value: "eng");
-    const kvRow3 = NameValueModel(name: "version", value: 0.1);
-    const kvRow4 = NameValueModel(name: "month", value: 4);
-    test('Testing with isRowEnabledList null', () {
-      expect(getEnabledRows([kvRow1, kvRow2, kvRow3, kvRow4], null),
-          [kvRow1, kvRow2, kvRow3, kvRow4]);
-    });
-    test('Testing for list with all enabled', () {
-      expect(
-          getEnabledRows(
-              [kvRow1, kvRow2, kvRow3, kvRow4], [true, true, true, true]),
-          [kvRow1, kvRow2, kvRow3, kvRow4]);
-    });
-    test('Testing for list with all disabled', () {
-      expect(
-          getEnabledRows(
-              [kvRow1, kvRow2, kvRow3, kvRow4], [false, false, false, false]),
-          []);
-    });
-    test('Testing for list with some disabled', () {
-      expect(
-          getEnabledRows(
-              [kvRow1, kvRow2, kvRow3, kvRow4], [true, false, true, false]),
-          [kvRow1, kvRow3]);
-    });
-  });
-
   group("Testing audioPosition function", () {
     test('Testing using dur1', () {
       Duration dur1 = const Duration(minutes: 1, seconds: 3);