thrilled-be-testing
Version:
Testing utilities and helpers package with Jest, Supertest, and database testing support for Express applications
302 lines (301 loc) • 9.07 kB
JavaScript
;
/**
* Simple Testing Utilities
* Basic testing utilities that work without complex dependencies
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.TestEnvironment = exports.SimpleTestHelpers = exports.SimpleMockFactory = void 0;
/* eslint-disable @typescript-eslint/no-unused-vars */
/**
* Simple Mock Data Factory
*/
class SimpleMockFactory {
static sequence = new Map();
/**
* Get next sequence number for a given key
*/
static getSequence(key) {
const current = this.sequence.get(key) || 0;
const next = current + 1;
this.sequence.set(key, next);
return next;
}
/**
* Reset sequences
*/
static reset() {
this.sequence.clear();
}
/**
* Generate random string
*/
static randomString(length = 8, prefix = '') {
const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
let result = prefix;
for (let i = 0; i < length; i++) {
result += chars.charAt(Math.floor(Math.random() * chars.length));
}
return result;
}
/**
* Generate random number within range
*/
static randomNumber(min = 1, max = 100) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
/**
* Generate random date within range
*/
static randomDate(startDate, endDate) {
const start = startDate || new Date(2020, 0, 1);
const end = endDate || new Date();
return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
}
/**
* Create mock user
*/
static createUser(overrides = {}) {
const sequence = this.getSequence('user');
return {
id: sequence,
email: `user${sequence}@example.com`,
name: `Test User ${sequence}`,
role: 'user',
createdAt: this.randomDate(),
updatedAt: new Date(),
...overrides,
};
}
/**
* Create mock API response
*/
static createApiResponse(data = null, overrides = {}) {
return {
success: true,
data,
message: 'Operation completed successfully',
timestamp: new Date().toISOString(),
request_id: this.randomString(16),
...overrides,
};
}
/**
* Create mock error response
*/
static createErrorResponse(error = {}, overrides = {}) {
return {
success: false,
error: {
code: 'GENERIC_ERROR',
message: 'An error occurred',
details: {},
...error,
},
timestamp: new Date().toISOString(),
request_id: this.randomString(16),
...overrides,
};
}
}
exports.SimpleMockFactory = SimpleMockFactory;
/**
* Simple Test Helpers
*/
class SimpleTestHelpers {
/**
* Create a basic Jest setup
* Note: This should be called at the top level of a test file, not inside a test case
*/
static setupTest(options = {}) {
// Check if we're in a test environment and not inside a test case
if (typeof jest !== 'undefined' && typeof beforeAll !== 'undefined') {
if (options.beforeAll) {
beforeAll(options.beforeAll);
}
if (options.afterAll) {
afterAll(options.afterAll);
}
if (options.beforeEach) {
beforeEach(options.beforeEach);
}
if (options.afterEach) {
afterEach(options.afterEach);
}
}
}
/**
* Create test setup configuration (for testing the setupTest method)
*/
static createTestSetup(options = {}) {
return {
beforeAll: options.beforeAll,
afterAll: options.afterAll,
beforeEach: options.beforeEach,
afterEach: options.afterEach,
};
}
/**
* Create mock database connection
*/
static createMockDb() {
if (typeof jest !== 'undefined') {
const mockQuery = jest.fn().mockResolvedValue({ rows: [], rowCount: 0 });
const mockRelease = jest.fn();
const mockConnect = jest.fn().mockResolvedValue({
query: mockQuery,
release: mockRelease,
});
const mockEnd = jest.fn().mockResolvedValue(undefined);
const mockOn = jest.fn();
return {
query: mockQuery,
connect: mockConnect,
end: mockEnd,
on: mockOn,
};
}
else {
// Fallback for non-test environments
return {
query: async () => ({ rows: [], rowCount: 0 }),
connect: async () => ({
query: async () => ({ rows: [], rowCount: 0 }),
release: () => {
// Mock release function
},
}),
end: async () => {
// Mock end function
},
on: () => {
// Mock event listener
},
};
}
}
/**
* Create mock Express request
*/
static createMockRequest(overrides = {}) {
const mockReq = {
params: {},
query: {},
body: {},
headers: {},
path: '/',
method: 'GET',
url: '/',
...overrides,
};
// Add methods after initial creation to avoid circular reference
// Check if jest is available (test environment)
if (typeof jest !== 'undefined') {
mockReq.get = jest.fn((name) => mockReq.headers[name]);
mockReq.header = jest.fn((name) => mockReq.headers[name]);
}
else {
// Fallback for non-test environments
mockReq.get = (name) => mockReq.headers[name];
mockReq.header = (name) => mockReq.headers[name];
}
return mockReq;
}
/**
* Create mock Express response
*/
static createMockResponse() {
if (typeof jest !== 'undefined') {
const res = {
status: jest.fn().mockReturnThis(),
json: jest.fn().mockReturnThis(),
send: jest.fn().mockReturnThis(),
set: jest.fn().mockReturnThis(),
get: jest.fn(),
statusCode: 200,
headersSent: false,
};
return res;
}
else {
// Fallback for non-test environments
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const res = {
status: function (code) { this.statusCode = code; return this; },
json: function (_data) { return this; },
send: function (_data) { return this; },
set: function (_field, _value) { return this; },
get: function (_field) { return undefined; },
statusCode: 200,
headersSent: false,
};
return res;
}
}
/**
* Wait for a specified amount of time
*/
static async wait(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
/**
* Assert that a value is truthy
*/
static assertTruthy(value, message) {
if (!value) {
throw new Error(message || `Expected value to be truthy, but got: ${value}`);
}
}
/**
* Assert that values are equal
*/
static assertEqual(actual, expected, message) {
if (actual !== expected) {
throw new Error(message || `Expected ${expected}, but got ${actual}`);
}
}
}
exports.SimpleTestHelpers = SimpleTestHelpers;
/**
* Test utilities for environment setup
*/
class TestEnvironment {
static envBackup = {};
/**
* Set environment variables for testing
*/
static setEnv(env) {
for (const [key, value] of Object.entries(env)) {
this.envBackup[key] = process.env[key];
process.env[key] = value;
}
}
/**
* Restore original environment variables
*/
static restoreEnv() {
for (const [key, value] of Object.entries(this.envBackup)) {
if (value === undefined) {
delete process.env[key];
}
else {
process.env[key] = value;
}
}
this.envBackup = {};
}
/**
* Create isolated test environment
*/
static isolatedTest(testFn, env = {}) {
return async () => {
this.setEnv(env);
try {
await testFn();
}
finally {
this.restoreEnv();
}
};
}
}
exports.TestEnvironment = TestEnvironment;