aft-web-services/dist/test/http/http-service-spec.js

Automated Functional Testing (AFT) module for testing web services over HTTP and HTTPS

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const aft_core_1 = require("aft-core");
const FormData = require("form-data");
const src_1 = require("../../src");
const http_service_1 = require("../../src/http/http-service");
describe('HttpService', () => {
    it('will set default request values if not passed in to performRequest', () => __awaiter(void 0, void 0, void 0, function* () {
        let svc = new http_service_1.HttpService();
        let actual;
        spyOn(svc, '_request').and.callFake((req) => {
            actual = req;
        });
        spyOn(svc, '_response').and.returnValue({});
        yield svc.performRequest();
        expect(actual).toBeDefined();
        expect(actual.url).toEqual('http://127.0.0.1');
        expect(actual.headers).toEqual({});
        expect(actual.allowAutoRedirect).toEqual(true);
        expect(actual.method).toEqual('GET');
        expect(actual.postData).toBeUndefined();
    }));
    it('can override default request values via constructor options if not passed in to performRequest', () => __awaiter(void 0, void 0, void 0, function* () {
        const aftCfg = new aft_core_1.AftConfig({
            HttpServiceConfig: {
                defaultUrl: 'https://fake.url/test',
                defaultHeaders: { "Authorization": "basic a098dfasd09/==" },
                defaultAllowRedirect: true,
                defaultMethod: 'DELETE',
                defaultPostData: 'some-fake-post-data'
            }
        });
        let svc = new http_service_1.HttpService(aftCfg);
        let actual;
        spyOn(svc, '_request').and.callFake((req) => {
            actual = req;
        });
        spyOn(svc, '_response').and.returnValue({});
        yield svc.performRequest();
        const hsc = aftCfg.getSection(http_service_1.HttpServiceConfig);
        expect(actual).toBeDefined();
        expect(actual.url).toEqual(hsc.defaultUrl);
        expect(actual.headers).toEqual(hsc.defaultHeaders);
        expect(actual.allowAutoRedirect).toEqual(hsc.defaultAllowRedirect);
        expect(actual.method).toEqual(hsc.defaultMethod);
        expect(actual.postData).toEqual(hsc.defaultPostData);
    }));
    it('can send GET request', () => __awaiter(void 0, void 0, void 0, function* () {
        let svc = new http_service_1.HttpService();
        let request = {
            url: 'http://127.0.0.1',
            method: 'GET'
        };
        spyOn(svc, '_request').and.returnValue({});
        let mockResponse = {
            statusCode: 200,
            data: '{"foo": "bar"}'
        };
        spyOn(svc, '_response').and.returnValue(mockResponse);
        let response = yield svc.performRequest(request);
        expect(response.statusCode).toEqual(200);
        expect(response.data).toEqual(mockResponse.data);
    }));
    it('can send POST request', () => __awaiter(void 0, void 0, void 0, function* () {
        let svc = new http_service_1.HttpService();
        let request = {
            url: 'http://127.0.0.1',
            method: 'POST',
            postData: '{"hello":"world"}'
        };
        spyOn(svc, '_request').and.returnValue({});
        let mockResponse = {
            statusCode: 200,
            data: '{"foo": "bar"}'
        };
        spyOn(svc, '_response').and.returnValue(mockResponse);
        let response = yield svc.performRequest(request);
        expect(response.statusCode).toEqual(200);
        expect(response.data).toEqual(mockResponse.data);
    }));
    it('can send Multipart POST request', () => __awaiter(void 0, void 0, void 0, function* () {
        let svc = new http_service_1.HttpService();
        let formData = new FormData();
        formData.append('foo', 'bar');
        let request = {
            url: 'http://127.0.0.1',
            method: 'POST',
            postData: formData,
            multipart: true
        };
        spyOn(svc, '_request').and.returnValue({});
        let mockResponse = {
            statusCode: 200,
            data: '{"foo": "bar"}'
        };
        spyOn(svc, '_response').and.returnValue(mockResponse);
        let response = yield svc.performRequest(request);
        expect(response.statusCode).toEqual(200);
        expect(response.data).toEqual(mockResponse.data);
    }));
    it('can handle unreachable URLs', () => __awaiter(void 0, void 0, void 0, function* () {
        let svc = new http_service_1.HttpService();
        let request = {
            url: `http://${aft_core_1.rand.getString(12)}`,
            method: 'GET'
        };
        let e;
        const response = yield svc.performRequest(request)
            .catch((err) => e = err);
        expect(e).toBeDefined();
        expect(e.toString()).toContain('getaddrinfo'); // DNS error
    }), 30000);
    /**
     * #### NOTE:
     * > only for functional local testing. not to be enabled for committed code
     */
    xit('can get values from a real web API', () => __awaiter(void 0, void 0, void 0, function* () {
        let resp = yield src_1.httpService.performRequest({ url: 'https://reqres.in/api/users?page=2' });
        expect(resp).toBeDefined();
        expect(resp.statusCode).toBe(200);
        expect(resp.headers).toBeDefined();
        expect(resp.headers['content-type']).toBe('application/json; charset=utf-8');
        expect(resp.data).toBeDefined();
        let data = src_1.httpData.as(resp);
        expect(data).toBeDefined();
        expect(data.page).toBe(2);
        expect(data.data).toBeDefined();
        expect(data.data.length).toBeGreaterThan(0);
    }));
});
//# sourceMappingURL=http-service-spec.js.map