352 lines
18 KiB
JavaScript
352 lines
18 KiB
JavaScript
"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());
|
|
});
|
|
};
|
|
var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var index_1 = require("./index");
|
|
describe('Server-side cookie functions', function () {
|
|
beforeEach(function () {
|
|
// Reset mocks before each test
|
|
jest.clearAllMocks();
|
|
// Mock isClientSide to always return false for server-side tests
|
|
jest.spyOn(require('../common/utils'), 'isClientSide').mockReturnValue(false);
|
|
});
|
|
describe('getCookies', function () {
|
|
describe('Next.js', function () {
|
|
it('should return cookies from req.cookies', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, cookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = {
|
|
cookies: {
|
|
set: jest.fn(),
|
|
getAll: jest.fn().mockReturnValue([{ name: 'test', value: 'value' }]),
|
|
},
|
|
};
|
|
return [4 /*yield*/, (0, index_1.getCookies)({ req: mockReq })];
|
|
case 1:
|
|
cookies = _a.sent();
|
|
expect(cookies).toEqual({ test: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should return cookies from res.cookies', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockRes, cookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockRes = {
|
|
cookies: {
|
|
set: jest.fn(),
|
|
getAll: jest.fn().mockReturnValue([{ name: 'test', value: 'value' }]),
|
|
},
|
|
};
|
|
return [4 /*yield*/, (0, index_1.getCookies)({ res: mockRes })];
|
|
case 1:
|
|
cookies = _a.sent();
|
|
expect(cookies).toEqual({ test: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should return cookies from cookies()', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockCookies, cookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockCookies = jest.fn().mockResolvedValue({
|
|
getAll: jest.fn().mockReturnValue([{ name: 'test', value: 'value' }]),
|
|
set: jest.fn(),
|
|
});
|
|
return [4 /*yield*/, (0, index_1.getCookies)({ cookies: mockCookies })];
|
|
case 1:
|
|
cookies = _a.sent();
|
|
expect(cookies).toEqual({ test: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
describe('Http', function () {
|
|
it('should parse cookies from req.headers.cookie', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, cookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { headers: { cookie: 'test=value' } };
|
|
return [4 /*yield*/, (0, index_1.getCookies)({ req: mockReq })];
|
|
case 1:
|
|
cookies = _a.sent();
|
|
expect(cookies).toEqual({ test: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should return cookies from req.cookies', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, cookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { cookies: { test: 'value' } };
|
|
return [4 /*yield*/, (0, index_1.getCookies)({ req: mockReq })];
|
|
case 1:
|
|
cookies = _a.sent();
|
|
expect(cookies).toEqual({ test: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should return empty object if no cookies are present', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var cookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0: return [4 /*yield*/, (0, index_1.getCookies)()];
|
|
case 1:
|
|
cookies = _a.sent();
|
|
expect(cookies).toEqual({});
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
});
|
|
describe('getCookie', function () {
|
|
it('should return a specific cookie value', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, value;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = {
|
|
cookies: {
|
|
set: jest.fn(),
|
|
getAll: jest.fn().mockReturnValue([
|
|
{ name: 'test', value: 'value' },
|
|
{ name: 'test2', value: 'value2' },
|
|
]),
|
|
},
|
|
};
|
|
return [4 /*yield*/, (0, index_1.getCookie)('test2', { req: mockReq })];
|
|
case 1:
|
|
value = _a.sent();
|
|
expect(value).toBe('value2');
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should return undefined for non-existent cookie', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, value;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = {
|
|
cookies: {
|
|
set: jest.fn(),
|
|
getAll: jest.fn().mockReturnValue([]),
|
|
},
|
|
};
|
|
return [4 /*yield*/, (0, index_1.getCookie)('nonexistent', { req: mockReq })];
|
|
case 1:
|
|
value = _a.sent();
|
|
expect(value).toBeUndefined();
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
describe('setCookie', function () {
|
|
describe('Next.js', function () {
|
|
it('should set a cookie on req', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = {
|
|
cookies: {
|
|
set: jest.fn(),
|
|
getAll: jest.fn().mockReturnValue([]),
|
|
},
|
|
};
|
|
return [4 /*yield*/, (0, index_1.setCookie)('test', 'value', { req: mockReq })];
|
|
case 1:
|
|
_a.sent();
|
|
expect(mockReq.cookies.set).toHaveBeenCalledWith({ name: 'test', value: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should set a cookie on res', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockRes;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockRes = {
|
|
cookies: {
|
|
set: jest.fn(),
|
|
getAll: jest.fn().mockReturnValue([]),
|
|
},
|
|
};
|
|
return [4 /*yield*/, (0, index_1.setCookie)('test', 'value', { res: mockRes })];
|
|
case 1:
|
|
_a.sent();
|
|
expect(mockRes.cookies.set).toHaveBeenCalledWith({ name: 'test', value: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should set a cookie on cookies()', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockSet, mockCookies;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockSet = jest.fn();
|
|
mockCookies = jest.fn().mockResolvedValue({
|
|
set: mockSet,
|
|
getAll: jest.fn().mockReturnValue([]),
|
|
});
|
|
return [4 /*yield*/, (0, index_1.setCookie)('test', 'value', { cookies: mockCookies })];
|
|
case 1:
|
|
_a.sent();
|
|
expect(mockSet).toHaveBeenCalledWith({ name: 'test', value: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
describe('Http', function () {
|
|
it('should set a cookie on headers', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, mockRes;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { headers: { cookie: 'other=cookie;' } };
|
|
mockRes = { setHeader: jest.fn(), getHeader: jest.fn().mockReturnValue([]) };
|
|
return [4 /*yield*/, (0, index_1.setCookie)('test', 'value', { req: mockReq, res: mockRes })];
|
|
case 1:
|
|
_a.sent();
|
|
expect(mockRes.setHeader).toHaveBeenCalledWith('Set-Cookie', expect.arrayContaining([expect.stringContaining('test=value;')]));
|
|
expect(mockReq.headers.cookie).toBe('other=cookie;test=value;');
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should set a cookie on cookies', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, mockRes;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { cookies: { other: 'cookie' } };
|
|
mockRes = { setHeader: jest.fn(), getHeader: jest.fn().mockReturnValue([]) };
|
|
return [4 /*yield*/, (0, index_1.setCookie)('test', 'value', { req: mockReq, res: mockRes })];
|
|
case 1:
|
|
_a.sent();
|
|
expect(mockReq === null || mockReq === void 0 ? void 0 : mockReq.cookies).toEqual({ other: 'cookie', test: 'value' });
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
});
|
|
describe('deleteCookie', function () {
|
|
it('should delete a cookie', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, mockRes;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { cookies: {} };
|
|
mockRes = { setHeader: jest.fn(), getHeader: jest.fn().mockReturnValue([]) };
|
|
return [4 /*yield*/, (0, index_1.setCookie)('test', 'value', { req: mockReq, res: mockRes })];
|
|
case 1:
|
|
_a.sent();
|
|
expect(mockReq === null || mockReq === void 0 ? void 0 : mockReq.cookies).toEqual({ test: 'value' });
|
|
return [4 /*yield*/, (0, index_1.deleteCookie)('test', { req: mockReq, res: mockRes })];
|
|
case 2:
|
|
_a.sent();
|
|
expect(mockReq === null || mockReq === void 0 ? void 0 : mockReq.cookies).toEqual({});
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
describe('hasCookie', function () {
|
|
it('should return true if cookie exists', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, mockRes, has;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { cookies: { existing: 'cookie' } };
|
|
mockRes = { setHeader: jest.fn(), getHeader: jest.fn().mockReturnValue([]) };
|
|
return [4 /*yield*/, (0, index_1.hasCookie)('existing', { req: mockReq, res: mockRes })];
|
|
case 1:
|
|
has = _a.sent();
|
|
expect(has).toBe(true);
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
it('should return false if cookie does not exist', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
var mockReq, mockRes, has;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
mockReq = { cookies: {} };
|
|
mockRes = { setHeader: jest.fn(), getHeader: jest.fn().mockReturnValue([]) };
|
|
return [4 /*yield*/, (0, index_1.hasCookie)('non-existing-cookie', { req: mockReq, res: mockRes })];
|
|
case 1:
|
|
has = _a.sent();
|
|
expect(has).toBe(false);
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
describe('Error handling', function () {
|
|
it('should throw an error when trying to access cookies on client-side', function () { return __awaiter(void 0, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
jest.spyOn(require('../common/utils'), 'isClientSide').mockReturnValue(true);
|
|
return [4 /*yield*/, expect((0, index_1.getCookies)()).rejects.toThrow('You are trying to access cookies on the client side')];
|
|
case 1:
|
|
_a.sent();
|
|
return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
});
|
|
});
|