feat: adds request data to response data (#85)

* feat: adds request data to response data class

* docs: adds documentation for request and response data

* build: version bump

* docs: update changelog

Author: CodingAleCR

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.0.1
+
+- ✨  Changed: `ResponseData` now has `request` to allow checking on the request that triggered the response. Thanks to @II11II
+- 🐞  Fixed: Use `queryParametersAll` when creating `RequestData`. Thanks to @Mawi137
+- 📖  Fixed: `README` to include `required` keywords needed. Thanks to @meysammahfouzi
+- 🚦  Tests: Improved testing and documentation.
+
 ## 1.0.0
 
 Check out the [1.0.0 migration guide](./guides/migration_guide_1.0.0.md) for information on how to migrate your code.

lib/http/intercepted_client.dart

@@ -169,7 +169,7 @@ class InterceptedClient extends BaseClient {
     });
   }
 
-  // TODO: Implement interception from `send` method.
+  // TODO(codingalecr): Implement interception from `send` method.
   @override
   Future<StreamedResponse> send(BaseRequest request) {
     return _inner.send(request);

lib/models/request_data.dart

@@ -5,12 +5,28 @@ import 'package:http_interceptor/extensions/extensions.dart';
 import 'package:http_interceptor/http/http.dart';
 import 'package:http_interceptor/utils/utils.dart';
 
+/// A class that mimics HTTP Request in order to intercept it's data.
 class RequestData {
+  /// The HTTP method of the request.
+  ///
+  /// Most commonly "GET" or "POST", less commonly "HEAD", "PUT", or "DELETE".
+  /// Non-standard method names are also supported.
   Method method;
+
+  /// The base URL String to which the request will be sent. It does not include
+  /// the query parameters.
   String baseUrl;
+
+  /// Map of String to String that represents the headers of the request.
   Map<String, String> headers;
+
+  /// Map of String to String that represents the query parameters of the
+  /// request.
   Map<String, dynamic> params;
-  dynamic? body;
+
+  dynamic body;
+
+  /// The encoding used for the request.
   Encoding? encoding;
 
   RequestData({
@@ -23,24 +39,38 @@ class RequestData {
   })  : headers = headers ?? {},
         params = params ?? {};
 
+  /// The complete URL String including query parameters to which the request
+  /// will be sent.
   String get url => buildUrlString(baseUrl, params);
 
-  factory RequestData.fromHttpRequest(Request request) {
+  /// Creates a new request data from an HTTP request.
+  ///
+  /// For now it only supports [Request].
+  /// TODO(codingalecr): Support for [MultipartRequest] and [StreamedRequest].
+  factory RequestData.fromHttpRequest(BaseRequest request) {
     var params = Map<String, dynamic>();
     request.url.queryParametersAll.forEach((key, value) {
       params[key] = value;
     });
     String baseUrl = request.url.origin + request.url.path;
-    return RequestData(
-      method: methodFromString(request.method),
-      encoding: request.encoding,
-      body: request.body,
-      baseUrl: baseUrl,
-      headers: request.headers,
-      params: params,
+
+    if (request is Request) {
+      return RequestData(
+        method: methodFromString(request.method),
+        baseUrl: baseUrl,
+        headers: request.headers,
+        body: request.body,
+        encoding: request.encoding,
+        params: params,
+      );
+    }
+
+    throw UnsupportedError(
+      "Can't intercept ${request.runtimeType}. Request type not supported yet.",
     );
   }
 
+  /// Converts this request data to an HTTP request.
   Request toHttpRequest() {
     var reqUrl = buildUrlString(baseUrl, params);
 
@@ -50,7 +80,7 @@ class RequestData {
     if (encoding != null) request.encoding = encoding!;
     if (body != null) {
       if (body is String) {
-        request.body = body;
+        request.body = body as String;
       } else if (body is List) {
         request.bodyBytes = body?.cast<int>();
       } else if (body is Map) {
@@ -63,6 +93,7 @@ class RequestData {
     return request;
   }
 
+  /// Convenient toString implementation for logging.
   @override
   String toString() {
     return 'Request Data { $method, $baseUrl, $headers, $params, $body }';

lib/models/response_data.dart

@@ -2,62 +2,83 @@ import 'dart:typed_data';
 
 import 'package:http/http.dart';
 import 'package:http_interceptor/http/http.dart';
+import 'package:http_interceptor/models/request_data.dart';
 
+/// A class that mimics HTTP Response in order to intercept it's data.
 class ResponseData {
-  String? url;
-  int? statusCode;
-  Method? method;
+  /// The bytes comprising the body of this response.
+  Uint8List bodyBytes;
+
+  /// The HTTP status code for this response.
+  int statusCode;
+
   Map<String, String>? headers;
+
+  /// The body of the response as a string.
   String? body;
 
-  /// The bytes comprising the body of this response.
-  Uint8List bodyBytes;
+  /// The size of the response body, in bytes.
+  ///
+  /// If the size of the request is not known in advance, this is `null`.
   int? contentLength;
+
   bool? isRedirect;
+
+  /// Whether the server requested that a persistent connection be maintained.
   bool? persistentConnection;
 
-  ResponseData({
-    this.method,
-    this.url,
-    this.statusCode,
+  /// The (frozen) request that triggered this response.
+  RequestData? request;
+
+  /// Creates a new response data with body bytes.
+  ResponseData(
+    this.bodyBytes,
+    this.statusCode, {
     this.headers,
     this.body,
-    required this.bodyBytes,
     this.contentLength,
     this.isRedirect,
     this.persistentConnection,
+    this.request,
   });
 
+  /// Method of the request that triggered this response.
+  Method? get method => request?.method;
+
+  /// URL as String of the request that triggered this response.
+  String? get url => request?.url;
+
+  /// Creates a new response data from an HTTP response.
   factory ResponseData.fromHttpResponse(Response response) {
     return ResponseData(
-      statusCode: response.statusCode,
+      response.bodyBytes,
+      response.statusCode,
       headers: response.headers,
       body: response.body,
-      bodyBytes: response.bodyBytes,
       contentLength: response.contentLength,
       isRedirect: response.isRedirect,
-      url: response.request!.url.toString(),
-      method: methodFromString(response.request!.method),
       persistentConnection: response.persistentConnection,
+      request: (response.request != null)
+          ? RequestData.fromHttpRequest(response.request!)
+          : null,
     );
   }
 
+  /// Converts this response data to an HTTP response.
   Response toHttpResponse() {
     return Response.bytes(
       bodyBytes,
-      statusCode!,
+      statusCode,
       headers: headers!,
       persistentConnection: persistentConnection!,
       isRedirect: isRedirect!,
-      request: Request(
-        methodToString(method!),
-        Uri.parse(url!),
-      ),
+      request: request?.toHttpRequest(),
     );
   }
 
+  /// Convenient toString implementation for logging.
   @override
   String toString() {
-    return 'ResponseData { $method, $url, $headers, $statusCode, $body }';
+    return 'ResponseData { $method, $url, $headers, $statusCode, $body, $request }';
   }
 }

pubspec.yaml

@@ -1,6 +1,6 @@
 name: http_interceptor
 description: A lightweight, simple plugin that allows you to intercept request and response objects and modify them if desired.
-version: 1.0.0
+version: 1.0.1
 homepage: https://github.com/CodingAleCR/http_interceptor
 issue_tracker: https://github.com/CodingAleCR/http_interceptor/issues
 repository: https://github.com/CodingAleCR/http_interceptor

test/models/response_data_test.dart

@@ -1,19 +1,56 @@
 import 'dart:typed_data';
 
+import 'package:http/http.dart';
 import 'package:test/test.dart';
 import 'package:http_interceptor/models/response_data.dart';
 
 main() {
   group("Initialization", () {
     test("ResponseData can be instantiated", () {
       // Arrange
-      ResponseData requestData;
+      ResponseData responseData;
 
       // Act
-      requestData = ResponseData(bodyBytes: Uint8List(0));
+      responseData = ResponseData(Uint8List(0), 200);
 
       // Assert
-      expect(requestData, isNotNull);
+      expect(responseData, isNotNull);
+    });
+
+    test("ResponseData can be instantiated from HTTP Response", () {
+      // Arrange
+      final response = Response("Empty Body", 200);
+      ResponseData responseData;
+
+      // Act
+      responseData = ResponseData.fromHttpResponse(response);
+
+      // Assert
+      expect(responseData, isNotNull);
+    });
+    test("ResponseData can all properties from HTTP Response", () {
+      // Arrange
+      Uri url = Uri.parse(
+          "https://www.google.com/helloworld?key=123ABC&name=Hugo&type=3");
+
+      Request request = Request("GET", url);
+      Response response = Response("Empty Body", 200, request: request);
+      ResponseData responseData;
+
+      // Act
+      responseData = ResponseData.fromHttpResponse(response);
+
+      // Assert
+      expect(responseData, isNotNull);
+      expect(responseData.request, isNotNull);
+      expect(responseData.body, isNotNull);
+      expect(responseData.bodyBytes, isNotNull);
+      expect(responseData.statusCode, isNotNull);
+      expect(responseData.url, equals(response.request!.url.toString()));
+      expect(responseData.isRedirect, equals(response.isRedirect));
+      expect(responseData.persistentConnection,
+          equals(response.persistentConnection));
+      expect(responseData.headers, equals(response.headers));
     });
   });
 }

test/models/retry_policy_test.dart

@@ -29,7 +29,7 @@ main() {
     test("returns false by default", () async {
       expect(
         await testObject.shouldAttemptRetryOnResponse(
-          ResponseData(bodyBytes: Uint8List(0)),
+          ResponseData(Uint8List(0), 200),
         ),
         false,
       );