alagarr/dist/src/response/middleware/compress.test.js

Alagarr is a request-response helper library that removes the boilerplate from your Node.js serverless functions and helps make your code portable.

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const zlib = __importStar(require("zlib"));
const requests_1 = require("../../../test/fixtures/requests");
const compress_1 = __importDefault(require("./compress"));
const testTextBody = [...Array(1000).keys()].join('');
const mockRequest = Object.assign({}, requests_1.get, { headers: {
        'accept-encoding': 'deflate, gzip, br',
    } });
describe('Compress response middleware', () => {
    test('should not compress response body when content-type is not compressible', () => {
        const { body, headers, isBase64Encoded } = compress_1.default({
            body: testTextBody.substr(0, 256),
            headers: {
                'content-type': 'image/jpeg',
            },
            statusCode: 200,
        }, mockRequest);
        expect(isBase64Encoded).toBeUndefined();
        expect(headers['content-type']).toBe('image/jpeg');
        expect(headers['content-encoding']).toBeUndefined();
        expect(typeof body).toBe('string');
        expect(body).toBe(testTextBody.substr(0, 256));
    });
    test('should not gzip response body when body is <= 256 bytes', () => {
        const { body, headers, isBase64Encoded } = compress_1.default({
            body: testTextBody.substr(0, 256),
            headers: {
                'content-type': 'text/plain',
            },
            statusCode: 200,
        }, mockRequest);
        expect(isBase64Encoded).toBeUndefined();
        expect(headers['content-type']).toBe('text/plain');
        expect(headers['content-encoding']).toBeUndefined();
        expect(typeof body).toBe('string');
        expect(body).toBe(testTextBody.substr(0, 256));
    });
    test('should gzip response body when body is > 256 bytes', () => {
        const { body, headers, isBase64Encoded } = compress_1.default({
            body: testTextBody,
            headers: {
                'content-type': 'text/plain',
            },
            statusCode: 200,
        }, mockRequest);
        const uncompressedBody = zlib
            .gunzipSync(Buffer.from(body, 'base64'))
            .toString();
        expect(isBase64Encoded).toBe(true);
        expect(headers['content-type']).toBe('text/plain');
        expect(headers['content-encoding']).toBe('gzip');
        expect(typeof body).toBe('string');
        expect(uncompressedBody).toBe(testTextBody);
    });
    test('should use deflate when "gzip" not in Accepts-Encoding header', () => {
        const { body, headers, isBase64Encoded } = compress_1.default({
            body: testTextBody,
            headers: {
                'content-type': 'text/plain',
            },
            statusCode: 200,
        }, Object.assign({}, mockRequest, { headers: { 'accept-encoding': 'deflate, br' } }));
        const uncompressedBody = zlib
            .inflateSync(Buffer.from(body, 'base64'))
            .toString();
        expect(isBase64Encoded).toBe(true);
        expect(headers['content-type']).toBe('text/plain');
        expect(headers['content-encoding']).toBe('deflate');
        expect(typeof body).toBe('string');
        expect(uncompressedBody).toBe(testTextBody);
    });
});