qapinterface/lib/__tests__/response-validator.test.js

Comprehensive API utilities for Node.js applications including authentication, security, request processing, and response handling with zero external dependencies

/**
 * Test suite for HTTP Response Validator utilities
 * Can be run with: node lib/__tests__/response-validator.test.js
 */

const { throwIfResNotOk, validateAndReturnResponse, isResponseOk, getResponseError } = require('../http/response-validator');
const TestRunner = require('./TestRunner');

const test = new TestRunner();

// Mock Response objects for testing
function createMockResponse(status, statusText = '', text = '', ok = null) {
  const mockResponse = {
    status,
    statusText,
    ok: ok !== null ? ok : (status >= 200 && status < 300),
    text: async () => text || statusText || `Status ${status}`
  };
  return mockResponse;
}

function createInvalidResponse() {
  return { status: 200 }; // Missing ok property
}

test.describe('HTTP Response Validator', () => {

  test.describe('throwIfResNotOk', () => {
    test.it('should not throw for ok response (200)', async () => {
      const response = createMockResponse(200, 'OK');
      let error = null;
      
      try {
        await throwIfResNotOk(response);
      } catch (e) {
        error = e;
      }
      
      test.expect(error === null).to.be.true;
    });

    test.it('should not throw for ok response (201)', async () => {
      const response = createMockResponse(201, 'Created');
      let error = null;
      
      try {
        await throwIfResNotOk(response);
      } catch (e) {
        error = e;
      }
      
      test.expect(error === null).to.be.true;
    });

    test.it('should throw for 404 response', async () => {
      const response = createMockResponse(404, 'Not Found');
      let error = null;
      
      try {
        await throwIfResNotOk(response);
      } catch (e) {
        error = e;
      }
      
      test.expect(error !== null).to.be.true;
      test.expect(error.message.includes('404')).to.be.true;
      test.expect(error.message.includes('Not Found')).to.be.true;
    });

    test.it('should throw for 500 response with custom text', async () => {
      const response = createMockResponse(500, 'Internal Server Error', 'Database connection failed');
      let error = null;
      
      try {
        await throwIfResNotOk(response);
      } catch (e) {
        error = e;
      }
      
      test.expect(error !== null).to.be.true;
      test.expect(error.message.includes('500')).to.be.true;
      test.expect(error.message.includes('Database connection failed')).to.be.true;
    });

    test.it('should throw error for null response', async () => {
      let error = null;
      
      try {
        await throwIfResNotOk(null);
      } catch (e) {
        error = e;
      }
      
      test.expect(error !== null).to.be.true;
      test.expect(error.message.includes('Response object is required')).to.be.true;
    });

    test.it('should throw error for invalid response object', async () => {
      const invalidResponse = createInvalidResponse();
      let error = null;
      
      try {
        await throwIfResNotOk(invalidResponse);
      } catch (e) {
        error = e;
      }
      
      test.expect(error !== null).to.be.true;
      test.expect(error.message.includes('Invalid Response object')).to.be.true;
    });
  });

  test.describe('validateAndReturnResponse', () => {
    test.it('should return response for ok status', async () => {
      const response = createMockResponse(200, 'OK');
      const result = await validateAndReturnResponse(response);
      test.expect(result).to.equal(response);
    });

    test.it('should throw for non-ok status', async () => {
      const response = createMockResponse(400, 'Bad Request');
      let error = null;
      
      try {
        await validateAndReturnResponse(response);
      } catch (e) {
        error = e;
      }
      
      test.expect(error !== null).to.be.true;
      test.expect(error.message.includes('400')).to.be.true;
    });
  });

  test.describe('isResponseOk', () => {
    test.it('should return true for ok response', () => {
      const response = createMockResponse(200, 'OK');
      test.expect(isResponseOk(response)).to.be.true;
    });

    test.it('should return false for non-ok response', () => {
      const response = createMockResponse(404, 'Not Found');
      test.expect(isResponseOk(response)).to.be.false;
    });

    test.it('should return false for null response', () => {
      test.expect(isResponseOk(null)).to.be.false;
    });

    test.it('should return false for invalid response', () => {
      const invalidResponse = createInvalidResponse();
      test.expect(isResponseOk(invalidResponse)).to.be.false;
    });
  });

  test.describe('getResponseError', () => {
    test.it('should return null for ok response', async () => {
      const response = createMockResponse(200, 'OK');
      const error = await getResponseError(response);
      test.expect(error === null).to.be.true;
    });

    test.it('should return error details for non-ok response', async () => {
      const response = createMockResponse(400, 'Bad Request', 'Invalid input data');
      const error = await getResponseError(response);
      
      test.expect(error !== null).to.be.true;
      test.expect(error.status).to.equal(400);
      test.expect(error.statusText).to.equal('Bad Request');
      test.expect(error.text).to.equal('Invalid input data');
    });

    test.it('should handle null response', async () => {
      const error = await getResponseError(null);
      
      test.expect(error !== null).to.be.true;
      test.expect(error.status).to.equal(0);
      test.expect(error.text.includes('null or undefined')).to.be.true;
    });
  });
});

(async () => {
  await test.run();
  const success = test.summary();
  process.exit(success ? 0 : 1);
})();