@testring/http-api - npm Package Compare versions

Comparing version 0.2.9 to 0.2.11

dist/cookie-jar.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tough_cookie_1 = require("tough-cookie");
+class HttpCookieJar {
+    constructor() {
+        this.jar = new tough_cookie_1.CookieJar();
+    }
+    setCookie(cookie, url) {
+        this.jar.setCookieSync(cookie, url);
+    }
+    setCookies(cookies, url) {
+        cookies.forEach((cookie) => this.jar.setCookieSync(cookie, url));
+    }
+    getCookies(url) {
+        return this.jar.getCookiesSync(url);
+    }
+    createCookie(properties) {
+        return new tough_cookie_1.Cookie(properties);
+    }
+}
+exports.HttpCookieJar = HttpCookieJar;

dist/request-function.js

+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("request");
+const requestPromise = require("request-promise");
+const toString = c => c.toString();
+const createCookieStore = (cookies, url) => {
+    const cookieJar = request_1.jar();
+    if (Array.isArray(cookies)) {
+        cookies.forEach((c) => {
+            cookieJar.setCookie(c, url);
+        });
+    }
+    return cookieJar;
+};
+exports.requestFunction = (request) => __awaiter(this, void 0, void 0, function* () {
+    const cookieJar = createCookieStore(request.cookies, request.url);
+    const normalizedRequest = {
+        url: request.url,
+        body: request.body,
+        qs: request.query,
+        method: request.method,
+        timeout: request.timeout,
+        headers: request.headers,
+        json: true,
+        jar: cookieJar
+    };
+    const response = yield requestPromise(normalizedRequest);
+    const responseCookies = cookieJar.getCookies(request.url).map(toString);
+    return {
+        statusCode: response.statusCode,
+        statusMessage: response.statusMessage,
+        headers: response.headers,
+        body: response.body,
+        cookies: responseCookies
+    };
+});

src/cookie-jar.ts

+import { CookieJar, Cookie } from 'tough-cookie';
+import { IHttpCookieJar } from '@testring/types';
+
+export class HttpCookieJar implements IHttpCookieJar {
+    private jar = new CookieJar();
+
+    public setCookie(cookie: Cookie | string, url: string) {
+        this.jar.setCookieSync(cookie, url);
+    }
+
+    public setCookies(cookies: Array<string>, url: string) {
+        cookies.forEach((cookie) => this.jar.setCookieSync(cookie, url));
+    }
+
+    public getCookies(url: string) {
+        return this.jar.getCookiesSync(url);
+    }
+
+    public createCookie(properties: Cookie.Properties) {
+        return new Cookie(properties);
+    }
+}

src/request-function.ts

+import { IHttpRequest, IHttpResponse } from '@testring/types';
+import { Response, OptionsWithUrl, jar } from 'request';
+import * as requestPromise from 'request-promise';
+
+const toString = c => c.toString();
+
+const createCookieStore = (cookies: Array<string> | void, url: string) => {
+    const cookieJar = jar();
+
+    if (Array.isArray(cookies)) {
+        cookies.forEach((c) => {
+            cookieJar.setCookie(c, url);
+        });
+    }
+
+    return cookieJar;
+};
+
+export const requestFunction = async (request: IHttpRequest): Promise<IHttpResponse> => {
+    const cookieJar = createCookieStore(request.cookies, request.url);
+
+    const normalizedRequest: OptionsWithUrl = {
+        url: request.url,
+        body: request.body,
+        qs: request.query,
+        method: request.method,
+        timeout: request.timeout,
+        headers: request.headers,
+        json: true,
+        jar: cookieJar
+    };
+
+    const response: Response = await requestPromise(normalizedRequest);
+    const responseCookies = cookieJar.getCookies(request.url).map(toString);
+
+    return {
+        statusCode: response.statusCode,
+        statusMessage: response.statusMessage,
+        headers: response.headers,
+        body: response.body,
+        cookies: responseCookies
+    };
+};

dist/abstract-http-client.js

@@ -12,3 +12,5 @@ "use strict";
 const logger_1 = require("@testring/logger");
+const cookie_jar_1 = require("./cookie-jar");
 const nanoid = require('nanoid');
+const toString = c => c.toString();
 class AbstractHttpClient {
@@ -18,17 +20,20 @@ constructor(transportInstance) {
     }
-    post(options) {
-        return this.sendRequest(Object.assign({}, options, { method: 'POST' }));
+    post(options, cookieJar) {
+        return this.sendRequest(Object.assign({}, options, { method: 'POST' }), cookieJar);
     }
-    get(options) {
-        return this.sendRequest(Object.assign({}, options, { method: 'GET' }));
+    get(options, cookieJar) {
+        return this.sendRequest(Object.assign({}, options, { method: 'GET' }), cookieJar);
     }
-    delete(options) {
-        return this.sendRequest(Object.assign({}, options, { method: 'DELETE' }));
+    delete(options, cookieJar) {
+        return this.sendRequest(Object.assign({}, options, { method: 'DELETE' }), cookieJar);
     }
-    put(options) {
-        return this.sendRequest(Object.assign({}, options, { method: 'PUT' }));
+    put(options, cookieJar) {
+        return this.sendRequest(Object.assign({}, options, { method: 'PUT' }), cookieJar);
     }
-    send(options) {
-        return this.sendRequest(Object.assign({}, options));
+    send(options, cookieJar) {
+        return this.sendRequest(Object.assign({}, options), cookieJar);
     }
+    createCookieJar() {
+        return new cookie_jar_1.HttpCookieJar();
+    }
     isValidData(data) {
@@ -40,6 +45,9 @@ return (data !== null && data !== undefined);
     }
-    sendRequest(options) {
+    sendRequest(requestParameters, cookieJar) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isValidRequest(options)) {
-                logger_1.loggerClient.error(`Http Client: ${options} request is not valid`);
+            if (cookieJar) {
+                requestParameters = Object.assign({}, requestParameters, { cookies: cookieJar.getCookies(requestParameters.url).map(toString) });
+            }
+            if (!this.isValidRequest(requestParameters)) {
+                logger_1.loggerClient.error(`Http Client: ${requestParameters} request is not valid`);
                 throw new Error('request is not valid');
@@ -57,2 +65,5 @@ }
                         removeRejectHandler();
+                        if (cookieJar) {
+                            cookieJar.setCookies(response.response.cookies, requestParameters.url);
+                        }
                         resolve(response.response);
@@ -69,3 +80,2 @@ }
                         removeResponseHandler();
-                        logger_1.loggerClient.error(`Http Client: failed with error ${response.error}`);
                         reject(response.error);
@@ -76,3 +86,3 @@ }
                     uid: requestUID,
-                    request: options
+                    request: requestParameters
                 });
@@ -79,0 +89,0 @@ });

dist/http-client-local.js

@@ -7,3 +7,3 @@ "use strict";
     broadcast(request) {
-        logger_1.loggerClientLocal.debug('Http client: send message inside root process', request);
+        logger_1.loggerClientLocal.verbose('[http client] send message inside root process', request);
         this.transportInstance.broadcastLocal("sendHttpRequest" /* send */, request);
@@ -10,0 +10,0 @@ }

dist/http-client.js

@@ -7,3 +7,3 @@ "use strict";
     broadcast(request) {
-        logger_1.loggerClient.debug('Http client: send message to parent process', request);
+        logger_1.loggerClient.verbose('[http client] send message to parent process', request);
         this.transportInstance.broadcast("sendHttpRequest" /* send */, request);
@@ -10,0 +10,0 @@ }

dist/http-server.js

@@ -38,3 +38,3 @@ "use strict";
                 const request = data.request;
-                logger_1.loggerClientLocal.log(`Sending http request to ${request.url}`);
+                logger_1.loggerClientLocal.verbose(`[http server] Sending http request to ${request.url}`);
                 this.isBusy = true;
@@ -46,3 +46,3 @@ const requestAfterHook = yield this.callHook("beforeRequest" /* beforeRequest */, request);
                 }
-                logger_1.loggerClientLocal.log('Successful responses');
+                logger_1.loggerClientLocal.verbose('[http server] Successful response');
                 const responseAfterHook = yield this.callHook("beforeResponse" /* beforeResponse */, response);
@@ -49,0 +49,0 @@ this.send(src, "responseHttpRequest" /* response */, {

dist/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const requestPromise = require("request-promise");
+const request_function_1 = require("./request-function");
+const http_client_local_1 = require("./http-client-local");
+exports.HttpClientLocal = http_client_local_1.HttpClientLocal;
 const http_client_1 = require("./http-client");
 exports.HttpClient = http_client_1.HttpClient;
-const http_client_local_1 = require("./http-client-local");
-exports.HttpClientLocal = http_client_local_1.HttpClientLocal;
 const http_server_1 = require("./http-server");
 exports.HttpServer = http_server_1.HttpServer;
 const createHttpServer = (config, transport) => {
-    return new http_server_1.HttpServer(transport, config, requestPromise);
+    return new http_server_1.HttpServer(transport, config, request_function_1.requestFunction);
 };
 exports.createHttpServer = createHttpServer;

package.json

 {
   "name": "@testring/http-api",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "main": "./dist/index.js",
@@ -13,12 +13,14 @@ "types": "./src/index.ts",
   "dependencies": {
-    "@testring/logger": "^0.2.9",
-    "@testring/pluggable-module": "^0.2.9",
-    "@testring/test-utils": "^0.2.9",
-    "@testring/transport": "^0.2.9",
-    "@testring/types": "^0.2.9",
+    "@testring/logger": "^0.2.11",
+    "@testring/pluggable-module": "^0.2.11",
+    "@testring/test-utils": "^0.2.11",
+    "@testring/transport": "^0.2.11",
+    "@testring/types": "^0.2.11",
     "@types/nanoid": "^1.0.0",
     "@types/request-promise": "^4.1.42",
+    "@types/tough-cookie": "^2.3.3",
     "nanoid": "^1.1.0",
-    "request-promise": "^4.2.2"
+    "request-promise": "^4.2.2",
+    "tough-cookie": "^2.4.3"
   }
 }

src/abstract-http-client.ts

@@ -1,17 +0,20 @@
-import { OptionsWithUrl } from 'request-promise';
 import {
+    HttpMessageType,
     ITransport,
     IHttpClient,
-    HttpMessageType,
-    IHttpResponse,
+    IHttpCookieJar,
     IHttpRequest,
-    IHttpResponseReject
+    IHttpResponseMessage,
+    IHttpRequestMessage,
+    IHttpResponseRejectMessage
 } from '@testring/types';
 import { loggerClient } from '@testring/logger';
+import { HttpCookieJar } from './cookie-jar';
 
-
 const nanoid = require('nanoid');
 
+const toString = c => c.toString();
+
 export abstract class AbstractHttpClient implements IHttpClient {
-    protected abstract broadcast(options: IHttpRequest): void;
+    protected abstract broadcast(options: IHttpRequestMessage): void;
 
@@ -21,22 +24,26 @@ constructor(protected transportInstance: ITransport) {
 
-    public post(options: OptionsWithUrl): Promise<any> {
-        return this.sendRequest({ ...options, method: 'POST' });
+    public post(options: IHttpRequest, cookieJar?: IHttpCookieJar): Promise<any> {
+        return this.sendRequest({ ...options, method: 'POST' }, cookieJar);
     }
 
-    public get(options: OptionsWithUrl): Promise<any> {
-        return this.sendRequest({ ...options, method: 'GET' });
+    public get(options: IHttpRequest, cookieJar?: IHttpCookieJar): Promise<any> {
+        return this.sendRequest({ ...options, method: 'GET' }, cookieJar);
     }
 
-    public delete(options: OptionsWithUrl): Promise<any> {
-        return this.sendRequest({ ...options, method: 'DELETE' });
+    public delete(options: IHttpRequest, cookieJar?: IHttpCookieJar): Promise<any> {
+        return this.sendRequest({ ...options, method: 'DELETE' }, cookieJar);
     }
 
-    public put(options: OptionsWithUrl): Promise<any> {
-        return this.sendRequest({ ...options, method: 'PUT' });
+    public put(options: IHttpRequest, cookieJar?: IHttpCookieJar): Promise<any> {
+        return this.sendRequest({ ...options, method: 'PUT' }, cookieJar);
     }
 
-    public send(options: OptionsWithUrl): Promise<any> {
-        return this.sendRequest({ ...options });
+    public send(options: IHttpRequest, cookieJar?: IHttpCookieJar): Promise<any> {
+        return this.sendRequest({ ...options }, cookieJar);
     }
 
+    public createCookieJar() {
+        return new HttpCookieJar();
+    }
+
     private isValidData(data: any): boolean {
@@ -46,10 +53,17 @@ return (data !== null && data !== undefined);
 
-    private isValidRequest(request: OptionsWithUrl): boolean {
+    private isValidRequest(request: IHttpRequest): boolean {
         return (this.isValidData(request) && request.hasOwnProperty('url'));
     }
 
-    private async sendRequest(options: OptionsWithUrl): Promise<any> {
-        if (!this.isValidRequest(options)) {
-            loggerClient.error(`Http Client: ${options} request is not valid`);
+    private async sendRequest(requestParameters: IHttpRequest, cookieJar?: IHttpCookieJar): Promise<any> {
+        if (cookieJar) {
+            requestParameters = {
+                ...requestParameters,
+                cookies: cookieJar.getCookies(requestParameters.url).map(toString)
+            };
+        }
 
+        if (!this.isValidRequest(requestParameters)) {
+            loggerClient.error(`Http Client: ${requestParameters} request is not valid`);
+
             throw new Error('request is not valid');
@@ -63,3 +77,3 @@ }
                 HttpMessageType.response,
-                (response: IHttpResponse) => {
+                (response: IHttpResponseMessage) => {
                     if (!response.uid) {
@@ -69,5 +83,11 @@ loggerClient.error('Http Client: no response uid');
                     }
+
                     if (response.uid === requestUID) {
                         removeResponseHandler();
                         removeRejectHandler();
+
+                        if (cookieJar) {
+                            cookieJar.setCookies(response.response.cookies, requestParameters.url);
+                        }
+
                         resolve(response.response);
@@ -80,3 +100,3 @@ }
                 HttpMessageType.reject,
-                (response: IHttpResponseReject) => {
+                (response: IHttpResponseRejectMessage) => {
                     if (!response.uid) {
@@ -90,4 +110,2 @@ loggerClient.error('Http Client: no response uid');
                         removeResponseHandler();
-                        loggerClient.error(`Http Client: failed with error ${response.error}`);
-
                         reject(response.error);
@@ -100,3 +118,3 @@ }
                 uid: requestUID,
-                request: options
+                request: requestParameters
             });
@@ -103,0 +121,0 @@ });

src/http-client-local.ts

 import { loggerClientLocal } from '@testring/logger';
-import { IHttpRequest, HttpMessageType } from '@testring/types';
+import { IHttpRequestMessage, HttpMessageType } from '@testring/types';
 import { AbstractHttpClient } from './abstract-http-client';
 
 export class HttpClientLocal extends AbstractHttpClient {
-    protected broadcast(request: IHttpRequest) {
-        loggerClientLocal.debug('Http client: send message inside root process', request);
+    protected broadcast(request: IHttpRequestMessage) {
+        loggerClientLocal.verbose('[http client] send message inside root process', request);
 
@@ -9,0 +9,0 @@ this.transportInstance.broadcastLocal(HttpMessageType.send, request);

src/http-client.ts

 import { loggerClient } from '@testring/logger';
-import { IHttpRequest, HttpMessageType } from '@testring/types';
+import { IHttpRequestMessage, HttpMessageType } from '@testring/types';
 import { AbstractHttpClient } from './abstract-http-client';
 
 export class HttpClient extends AbstractHttpClient {
-    protected broadcast(request: IHttpRequest) {
-        loggerClient.debug('Http client: send message to parent process', request);
+    protected broadcast(request: IHttpRequestMessage) {
+        loggerClient.verbose('[http client] send message to parent process', request);
 
@@ -9,0 +9,0 @@ this.transportInstance.broadcast(HttpMessageType.send, request);

src/http-server.ts

@@ -1,3 +0,2 @@
-import * as request from 'request';
-import * as requestPromise from 'request-promise';
+import { IHttpRequest, IHttpResponse } from '@testring/types';
 import { PluggableModule } from '@testring/pluggable-module';
@@ -8,5 +7,5 @@ import { loggerClientLocal } from '@testring/logger';
     ITransport,
-    IHttpRequest,
-    IHttpResponse,
-    IHttpResponseReject,
+    IHttpRequestMessage,
+    IHttpResponseMessage,
+    IHttpResponseRejectMessage,
     HttpMessageType,
@@ -17,7 +16,7 @@ HttpServerPlugins
 interface QueueRequest {
-    data: IHttpRequest;
+    data: IHttpRequestMessage;
     src: string;
 }
 
-type MakeRequest = (request: requestPromise.OptionsWithUrl) => any;
+type MakeRequest = (request: IHttpRequest) => Promise<IHttpResponse>;
 
@@ -53,3 +52,3 @@ export class HttpServer extends PluggableModule {
             const request = data.request;
-            loggerClientLocal.log(`Sending http request to ${request.url}`);
+            loggerClientLocal.verbose(`[http server] Sending http request to ${request.url}`);
 
@@ -59,3 +58,3 @@ this.isBusy = true;
             const requestAfterHook = await this.callHook(HttpServerPlugins.beforeRequest, request);
-            const response: request.Response = await this.request(requestAfterHook);
+            const response = await this.request(requestAfterHook);
 
@@ -66,7 +65,7 @@ if (response.statusCode >= 400) {
 
-            loggerClientLocal.log('Successful responses');
+            loggerClientLocal.verbose('[http server] Successful response');
 
             const responseAfterHook = await this.callHook(HttpServerPlugins.beforeResponse, response);
 
-            this.send<IHttpResponse>(src, HttpMessageType.response, {
+            this.send<IHttpResponseMessage>(src, HttpMessageType.response, {
                 uid,
@@ -77,3 +76,3 @@ response: responseAfterHook
         } catch (error) {
-            this.send<IHttpResponseReject>(src, HttpMessageType.reject, {
+            this.send<IHttpResponseRejectMessage>(src, HttpMessageType.reject, {
                 uid,
@@ -112,3 +111,3 @@ error
 
-        this.transportInstance.on(HttpMessageType.send, (data: IHttpRequest, src: string) => {
+        this.transportInstance.on(HttpMessageType.send, (data: IHttpRequestMessage, src: string) => {
 
@@ -115,0 +114,0 @@ // todo validate data

src/index.ts

@@ -1,10 +0,9 @@
-import * as requestPromise from 'request-promise';
 import { IConfig, ITransport } from '@testring/types';
-
+import { requestFunction } from './request-function';
+import { HttpClientLocal } from './http-client-local';
 import { HttpClient } from './http-client';
-import { HttpClientLocal } from './http-client-local';
 import { HttpServer } from './http-server';
 
 const createHttpServer = (config: IConfig, transport: ITransport) => {
-    return new HttpServer(transport, config, requestPromise);
+    return new HttpServer(transport, config, requestFunction);
 };
@@ -11,0 +10,0 @@

No alert changes

Improved metrics

Total package byte prevSize

23318

33.44%

Number of package files

16

33.33%

Lines of code

555

33.73%

Worsened metrics

Dependency count

11

22.22%

Dependency changes

• + Added

  @types/tough-cookie@^2.3.3

• + Added

  tough-cookie@^2.4.3

• + Added

  @types/tough-cookie@2.3.11
  (transitive)

• - Removed

  @types/tough-cookie@4.0.5
  (transitive)

• Updated

  @testring/logger@^0.2.11

• Updated

  @testring/pluggable-module@^0.2.11

• Updated

  @testring/test-utils@^0.2.11

• Updated

  @testring/transport@^0.2.11

• Updated

  @testring/types@^0.2.11