fix: broken unit-test, typo in readme

Author: jossef

CHANGELOG.md

@@ -1,3 +1,11 @@
 ## 1.0.0
 
 - Initial version
+
+## 3.0.1
+
+- updated api with breaking changes
+
+## 3.0.3
+
+- fix: parse json only if requested

README.md

@@ -1,8 +1,7 @@
-![banner-01](https://user-images.githubusercontent.com/1287098/67152735-969fd300-f2e5-11e9-9aa5-b73652ac502e.png)
+![banner-01](https://user-images.githubusercontent.com/1287098/68531964-ccead400-0320-11ea-93a6-fa83b9183dd8.png)
 
-# Flutter HTTP client + json + cookies.
 
-a flutter library to simply call HTTP requests (inspired by python [requests](https://github.com/psf/requests) module). It comes with JSON support and a lightweight implementation to store cookies like a browser.
+a flutter library to make HTTP requests (inspired by python [requests](https://github.com/psf/requests) module). It comes with JSON support and a lightweight implementation to store cookies like a browser.
 
 ### Cookies, huh?
 Server side cookies (via response header `SET-COOKIE`) are stored using the assistance of `shared_preferences`. Stored cookies will be send seamlessly on the next http requests you make to the same domain (simple implementation, similar to a web browser)
@@ -14,7 +13,7 @@ Add this to your package's pubspec.yaml file:
 
 ```yaml
 dependencies:
-  requests: ^3.0.1
+  requests: ^3.0.3
 ```
 
 ## Usage
@@ -61,7 +60,7 @@ just like in python's request module, the `Response` object has this functionall
 
  ### Class Methods
 
-- `.getHostnam(url)` - returns the hostname of the given url
+- `.getHostname(url)` - returns the hostname of the given url
 - `.clearStoredCookies(hostname)` - clears the stored cookies for the hostname
 - `.setStoredCookies(hostname, Map<String, String>)` - set the stored cookies for the hostname
 - `.getStoredCookies(hostname)` - returns a Map<String, String> of the stored cookies for the hostname

lib/src/common.dart

@@ -46,4 +46,12 @@ class Common {
     var digest = sha256.convert(bytes);
     return toHexString(digest.bytes);
   }
+
+  static String encodeMap(Map data) {
+    return data.keys.map((key) {
+      var k = Uri.encodeComponent(key.toString());
+      var v = Uri.encodeComponent(data[key].toString());
+      return "${k}=${v}";
+    }).join("&");
+  }
 }

lib/src/requests.dart

@@ -9,7 +9,7 @@ import 'common.dart';
 import 'event.dart';
 import 'dart:io';
 
-enum RequestBodyEncoding { JSON, FormURLEncoded }
+enum RequestBodyEncoding { JSON, FormURLEncoded, PlainText }
 
 final Logger log = Logger('requests');
 
@@ -28,8 +28,7 @@ class Response {
 
   throwForStatus() {
     if (!success) {
-      throw HTTPException(
-          "Invalid HTTP status code $statusCode for url ${url}", this);
+      throw HTTPException("Invalid HTTP status code $statusCode for url ${url}", this);
     }
   }
 
@@ -69,31 +68,17 @@ class Requests {
   static const String HTTP_METHOD_HEAD = "head";
   static const int DEFAULT_TIMEOUT_SECONDS = 10;
 
-  static const RequestBodyEncoding DEFAULT_BODY_ENCODING =
-      RequestBodyEncoding.FormURLEncoded;
+  static const RequestBodyEncoding DEFAULT_BODY_ENCODING = RequestBodyEncoding.FormURLEncoded;
 
-  static Set _cookiesKeysToIgnore = Set.from([
-    "SameSite",
-    "Path",
-    "Domain",
-    "Max-Age",
-    "Expires",
-    "Secure",
-    "HttpOnly"
-  ]);
+  static Set _cookiesKeysToIgnore = Set.from(["SameSite", "Path", "Domain", "Max-Age", "Expires", "Secure", "HttpOnly"]);
 
   static Map<String, String> _extractResponseCookies(responseHeaders) {
     Map<String, String> cookies = {};
     for (var key in responseHeaders.keys) {
       if (Common.equalsIgnoreCase(key, 'set-cookie')) {
         String cookie = responseHeaders[key];
         cookie.split(",").forEach((String one) {
-          cookie
-              .split(";")
-              .map((x) => x.trim().split("="))
-              .where((x) => x.length == 2)
-              .where((x) => !_cookiesKeysToIgnore.contains(x[0]))
-              .forEach((x) => cookies[x[0]] = x[1]);
+          cookie.split(";").map((x) => x.trim().split("=")).where((x) => x.length == 2).where((x) => !_cookiesKeysToIgnore.contains(x[0])).forEach((x) => cookies[x[0]] = x[1]);
         });
         break;
       }
@@ -102,11 +87,9 @@ class Requests {
     return cookies;
   }
 
-  static Future<Map> _constructRequestHeaders(
-      String hostname, Map<String, String> customHeaders) async {
+  static Future<Map> _constructRequestHeaders(String hostname, Map<String, String> customHeaders) async {
     var cookies = await getStoredCookies(hostname);
-    String cookie =
-        cookies.keys.map((key) => "$key=${cookies[key]}").join("; ");
+    String cookie = cookies.keys.map((key) => "$key=${cookies[key]}").join("; ");
     Map<String, String> requestHeaders = Map();
     requestHeaders['cookie'] = cookie;
 
@@ -123,14 +106,12 @@ class Requests {
       var cookies = Common.fromJson(cookiesJson);
       return Map<String, String>.from(cookies);
     } catch (e) {
-      log.shout(
-          "problem reading stored cookies. fallback with empty cookies $e");
+      log.shout("problem reading stored cookies. fallback with empty cookies $e");
       return Map<String, String>();
     }
   }
 
-  static Future setStoredCookies(
-      String hostname, Map<String, String> cookies) async {
+  static Future setStoredCookies(String hostname, Map<String, String> cookies) async {
     String hostnameHash = Common.hashStringSHA256(hostname);
     String cookiesJson = Common.toJson(cookies);
     await Common.storageSet('cookies-$hostnameHash', cookiesJson);
@@ -146,8 +127,7 @@ class Requests {
     return "${uri.host}:${uri.port}";
   }
 
-  static Future<Response> _handleHttpResponse(
-      String hostname, http.Response rawResponse, bool persistCookies) async {
+  static Future<Response> _handleHttpResponse(String hostname, http.Response rawResponse, bool persistCookies) async {
     if (persistCookies) {
       var responseCookies = _extractResponseCookies(rawResponse.headers);
       if (responseCookies.isNotEmpty) {
@@ -166,106 +146,31 @@ class Requests {
     return response;
   }
 
-  static Future<Response> head(String url,
-      {headers,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) {
-    return _httpRequest(HTTP_METHOD_HEAD, url,
-        bodyEncoding: bodyEncoding,
-        headers: headers,
-        timeoutSeconds: timeoutSeconds,
-        persistCookies: persistCookies,
-        verify: verify);
+  static Future<Response> head(String url, {headers, bodyEncoding = DEFAULT_BODY_ENCODING, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) {
+    return _httpRequest(HTTP_METHOD_HEAD, url, bodyEncoding: bodyEncoding, headers: headers, timeoutSeconds: timeoutSeconds, persistCookies: persistCookies, verify: verify);
   }
 
-  static Future<Response> get(String url,
-      {headers,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) {
-    return _httpRequest(HTTP_METHOD_GET, url,
-        bodyEncoding: bodyEncoding,
-        headers: headers,
-        timeoutSeconds: timeoutSeconds,
-        persistCookies: persistCookies,
-        verify: verify);
+  static Future<Response> get(String url, {headers, bodyEncoding = DEFAULT_BODY_ENCODING, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) {
+    return _httpRequest(HTTP_METHOD_GET, url, bodyEncoding: bodyEncoding, headers: headers, timeoutSeconds: timeoutSeconds, persistCookies: persistCookies, verify: verify);
   }
 
-  static Future<Response> patch(String url,
-      {headers,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) {
-    return _httpRequest(HTTP_METHOD_PATCH, url,
-        bodyEncoding: bodyEncoding,
-        headers: headers,
-        timeoutSeconds: timeoutSeconds,
-        persistCookies: persistCookies,
-        verify: verify);
+  static Future<Response> patch(String url, {headers, bodyEncoding = DEFAULT_BODY_ENCODING, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) {
+    return _httpRequest(HTTP_METHOD_PATCH, url, bodyEncoding: bodyEncoding, headers: headers, timeoutSeconds: timeoutSeconds, persistCookies: persistCookies, verify: verify);
   }
 
-  static Future<Response> delete(String url,
-      {headers,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) {
-    return _httpRequest(HTTP_METHOD_DELETE, url,
-        bodyEncoding: bodyEncoding,
-        headers: headers,
-        timeoutSeconds: timeoutSeconds,
-        persistCookies: persistCookies,
-        verify: verify);
+  static Future<Response> delete(String url, {headers, bodyEncoding = DEFAULT_BODY_ENCODING, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) {
+    return _httpRequest(HTTP_METHOD_DELETE, url, bodyEncoding: bodyEncoding, headers: headers, timeoutSeconds: timeoutSeconds, persistCookies: persistCookies, verify: verify);
   }
 
-  static Future<Response> post(String url,
-      {json,
-      body,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      headers,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) {
-    return _httpRequest(HTTP_METHOD_POST, url,
-        bodyEncoding: bodyEncoding,
-        json: json,
-        body: body,
-        headers: headers,
-        timeoutSeconds: timeoutSeconds,
-        persistCookies: persistCookies,
-        verify: verify);
+  static Future<Response> post(String url, {json, body, bodyEncoding = DEFAULT_BODY_ENCODING, headers, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) {
+    return _httpRequest(HTTP_METHOD_POST, url, bodyEncoding: bodyEncoding, json: json, body: body, headers: headers, timeoutSeconds: timeoutSeconds, persistCookies: persistCookies, verify: verify);
   }
 
-  static Future<Response> put(String url,
-      {json,
-      body,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      headers,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) {
-    return _httpRequest(HTTP_METHOD_PUT, url,
-        bodyEncoding: bodyEncoding,
-        json: json,
-        body: body,
-        headers: headers,
-        timeoutSeconds: timeoutSeconds,
-        persistCookies: persistCookies,
-        verify: verify);
+  static Future<Response> put(String url, {json, body, bodyEncoding = DEFAULT_BODY_ENCODING, headers, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) {
+    return _httpRequest(HTTP_METHOD_PUT, url, bodyEncoding: bodyEncoding, json: json, body: body, headers: headers, timeoutSeconds: timeoutSeconds, persistCookies: persistCookies, verify: verify);
   }
 
-  static Future<Response> _httpRequest(String method, String url,
-      {json,
-      body,
-      bodyEncoding = DEFAULT_BODY_ENCODING,
-      headers,
-      timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
-      persistCookies = true,
-      verify = true}) async {
+  static Future<Response> _httpRequest(String method, String url, {json, body, bodyEncoding = DEFAULT_BODY_ENCODING, headers, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, persistCookies = true, verify = true}) async {
     http.Client client;
     if (!verify) {
       // Ignore SSL errors
@@ -280,13 +185,12 @@ class Requests {
     var uri = Uri.parse(url);
 
     if (uri.scheme != 'http' && uri.scheme != 'https') {
-      throw ArgumentError(
-          "invalid url, must start with 'http://' or 'https://' sheme (e.g. 'http://example.com')");
+      throw ArgumentError("invalid url, must start with 'http://' or 'https://' sheme (e.g. 'http://example.com')");
     }
 
     String hostname = getHostname(url);
     headers = await _constructRequestHeaders(hostname, headers);
-    dynamic bodyString = "";
+    dynamic requestBody;
 
     if (body != null && json != null) {
       throw ArgumentError('cannot use both "json" and "body" choose only one.');
@@ -299,22 +203,24 @@ class Requests {
 
     if (body != null) {
       String contentTypeHeader;
-      bodyString = body;
-      if (body is String) {
+
+      if (bodyEncoding == RequestBodyEncoding.JSON) {
+        requestBody = Common.toJson(body);
+        contentTypeHeader = "application/json";
+      }
+      else if (bodyEncoding == RequestBodyEncoding.FormURLEncoded) {
+        requestBody = Common.encodeMap(body);
+        contentTypeHeader = "application/x-www-form-urlencoded";
+      }
+      else if (bodyEncoding == RequestBodyEncoding.PlainText) {
+        requestBody = body;
         contentTypeHeader = "text/plain";
-      } else if (body is Map || body is List) {
-        if (bodyEncoding == RequestBodyEncoding.JSON) {
-          bodyString = Common.toJson(body);
-          contentTypeHeader = "application/json";
-        } else if (bodyEncoding == RequestBodyEncoding.FormURLEncoded) {
-          contentTypeHeader = "application/x-www-form-urlencoded";
-        } else {
-          throw Exception('unsupported bodyEncoding "$bodyEncoding"');
-        }
+      }
+      else {
+        throw Exception('unsupported bodyEncoding "$bodyEncoding"');
       }
 
-      if (contentTypeHeader != null &&
-          !Common.hasKeyIgnoreCase(headers, "content-type")) {
+      if (contentTypeHeader != null && !Common.hasKeyIgnoreCase(headers, "content-type")) {
         headers["content-type"] = contentTypeHeader;
       }
     }
@@ -326,19 +232,19 @@ class Requests {
         future = client.get(uri, headers: headers);
         break;
       case HTTP_METHOD_PUT:
-        future = client.put(uri, body: bodyString, headers: headers);
+        future = client.put(uri, body: requestBody, headers: headers);
         break;
       case HTTP_METHOD_DELETE:
         future = client.delete(uri, headers: headers);
         break;
       case HTTP_METHOD_POST:
-        future = client.post(uri, body: bodyString, headers: headers);
+        future = client.post(uri, body: requestBody, headers: headers);
         break;
       case HTTP_METHOD_HEAD:
         future = client.head(uri, headers: headers);
         break;
       case HTTP_METHOD_PATCH:
-        future = client.patch(uri, body: bodyString, headers: headers);
+        future = client.patch(uri, body: requestBody, headers: headers);
         break;
       default:
         throw Exception('unsupported http method "$method"');

logo/banner-01.png

@@ -82,7 +82,7 @@ void main() {
     test('remove cookies', () async {
       String url = "$PLACEHOLDER_PROVIDER/api/users/1";
       String hostname = Requests.getHostname(url);
-      expect("reqres.in", hostname);
+      expect("reqres.in:443", hostname);
       await Requests.clearStoredCookies(hostname);
       await Requests.setStoredCookies(hostname, {'session': 'bla'});
       var cookies = await Requests.getStoredCookies(hostname);