npm package diff
Package: @forge/sql
Versions: 2.1.0 - 2.2.0-next.0
File: package/out/__test__/sql.test.js
Index: package/out/__test__/sql.test.js
===================================================================
--- package/out/__test__/sql.test.js
+++ package/out/__test__/sql.test.js
@@ -1,33 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
+const node_fetch_1 = require("node-fetch");
const api_1 = require("@forge/api");
const sql_1 = require("../sql");
const sql_statement_1 = require("../sql-statement");
+const response_handler_1 = require("../utils/response-handler");
jest.mock('@forge/api');
-jest.mock('../sql-statement');
-jest.mock('../utils/response-handler', () => ({
- ApiError: jest.fn(),
- getResponseBody: jest.fn()
-}));
describe('SqlClient', () => {
let sqlClient;
let mockFetch;
- let mockSqlStatement;
- let mockGetResponseBody;
beforeEach(() => {
sqlClient = new sql_1.SqlClient();
mockFetch = jest.fn();
api_1.__fetchProduct.mockReturnValue(mockFetch);
- mockSqlStatement = {
- bindParams: jest.fn().mockReturnThis(),
- execute: jest.fn()
- };
- sql_statement_1.SqlStatement.mockImplementation(() => mockSqlStatement);
- mockGetResponseBody = jest.fn();
- jest.requireMock('../utils/response-handler').getResponseBody = mockGetResponseBody;
jest.clearAllMocks();
});
+ function mockFetchExecute(rows) {
+ const body = { rows };
+ const response = new node_fetch_1.Response(JSON.stringify(body), { status: 200 });
+ mockFetch.mockResolvedValue(response);
+ return body;
+ }
describe('sendRequest', () => {
it('should send a request with the correct options and return the response', async () => {
const mockResponse = { ok: true, status: 200 };
mockFetch.mockResolvedValue(mockResponse);
@@ -66,84 +60,60 @@
});
});
describe('storageApi', () => {
it('should send a request and return the response body', async () => {
- const mockResponse = { text: jest.fn().mockResolvedValue(JSON.stringify({ response: { rows: [] } })) };
- mockFetch.mockResolvedValue(mockResponse);
- mockGetResponseBody.mockResolvedValue({ rows: [] });
+ mockFetchExecute([]);
const result = await sqlClient.storageApi('SELECT * FROM test');
expect(mockFetch).toHaveBeenCalledWith('api/v1/execute', {
method: 'POST',
body: JSON.stringify({ query: 'SELECT * FROM test', params: [], method: 'all' }),
redirect: 'follow',
headers: { 'Content-Type': 'application/json' }
});
- expect(mockGetResponseBody).toHaveBeenCalledWith(mockResponse);
expect(result).toEqual({ rows: [] });
});
it('should send a request with parameters and method', async () => {
- const mockResponse = { text: jest.fn().mockResolvedValue(JSON.stringify({ response: { rows: [] } })) };
- mockFetch.mockResolvedValue(mockResponse);
- mockGetResponseBody.mockResolvedValue({ rows: [] });
+ mockFetchExecute([]);
const params = [1];
const result = await sqlClient.storageApi('SELECT * FROM test WHERE id = ?', params, 'one');
expect(mockFetch).toHaveBeenCalledWith('api/v1/execute', {
method: 'POST',
body: JSON.stringify({ query: 'SELECT * FROM test WHERE id = ?', params, method: 'one' }),
redirect: 'follow',
headers: { 'Content-Type': 'application/json' }
});
- expect(mockGetResponseBody).toHaveBeenCalledWith(mockResponse);
expect(result).toEqual({ rows: [] });
});
it('should handle errors from getResponseBody', async () => {
- const mockResponse = { text: jest.fn().mockResolvedValue('Invalid JSON') };
- mockFetch.mockResolvedValue(mockResponse);
- const mockError = new Error('Invalid JSON');
- mockGetResponseBody.mockRejectedValue(mockError);
- await expect(sqlClient.storageApi('INVALID SQL QUERY')).rejects.toThrow(mockError);
- expect(mockFetch).toHaveBeenCalledWith('api/v1/execute', expect.any(Object));
- expect(mockGetResponseBody).toHaveBeenCalledWith(mockResponse);
+ const responseText = 'Invalid JSON';
+ const response = new node_fetch_1.Response(responseText, { status: 200 });
+ mockFetch.mockResolvedValue(response);
+ await expect(sqlClient.storageApi('INVALID SQL QUERY')).rejects.toThrow(`Unexpected error. Response was not valid JSON: ${responseText}`);
});
});
describe('prepare', () => {
- it('should return a SqlStatement instance', () => {
- const statement = sqlClient.prepare('SELECT * FROM test');
- expect(statement).toBe(mockSqlStatement);
- expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('SELECT * FROM test', expect.any(Function));
+ it('should return a SqlStatement instance with query', () => {
+ const statement = sqlClient.prepare('INSERT INTO test VALUES (?, ?)');
+ expect(statement).toBeInstanceOf(sql_statement_1.SqlStatement);
+ expect(statement.query).toBe('INSERT INTO test VALUES (?, ?)');
});
- it('should pass the correct query to SqlStatement', () => {
- sqlClient.prepare('INSERT INTO test VALUES (?, ?)');
- expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('INSERT INTO test VALUES (?, ?)', expect.any(Function));
- });
- it('should pass the storageApi method to SqlStatement', () => {
- sqlClient.prepare('SELECT * FROM test');
- const passedFunction = sql_statement_1.SqlStatement.mock.calls[0][1];
- expect(typeof passedFunction).toBe('function');
- });
});
describe('execute', () => {
it('should execute a query and return the result', async () => {
- const mockResult = { rows: [{ id: 1, name: 'Test' }] };
- mockSqlStatement.execute.mockResolvedValue(mockResult);
+ const expectedResult = mockFetchExecute([{ id: 1, name: 'Test' }]);
const result = await sqlClient.executeRaw('SELECT * FROM test');
- expect(result).toEqual(mockResult);
- expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('SELECT * FROM test', expect.any(Function));
- expect(mockSqlStatement.execute).toHaveBeenCalled();
+ expect(result).toEqual(expectedResult);
});
it('should execute a query with parameters', async () => {
- const mockResult = { rows: [{ id: 1, name: 'Test' }] };
- mockSqlStatement.execute.mockResolvedValue(mockResult);
- const result = await sqlClient.prepare('SELECT * FROM test WHERE id = ?').bindParams(1).execute();
+ const mockResult = mockFetchExecute([{ id: 1, name: 'Test' }]);
+ const result = await sqlClient
+ .prepare('SELECT * FROM test WHERE id = ?')
+ .bindParams(1)
+ .execute();
expect(result).toEqual(mockResult);
- expect(mockSqlStatement.bindParams).toHaveBeenCalledWith(1);
- expect(mockSqlStatement.execute).toHaveBeenCalled();
});
it('should handle API errors', async () => {
- const mockApiError1 = new Error('INVALID SQL QUERY');
- mockSqlStatement.execute.mockRejectedValueOnce(mockApiError1);
- await expect(sqlClient.executeRaw('INVALID SQL QUERY')).rejects.toThrow(mockApiError1);
- expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('INVALID SQL QUERY', expect.any(Function));
- expect(mockSqlStatement.execute).toHaveBeenCalled();
+ mockFetch.mockResolvedValue(new node_fetch_1.Response(JSON.stringify({ code: 'INVALID_QUERY', message: 'Invalid SQL query' }), { status: 400 }));
+ await expect(sqlClient.executeRaw('INVALID SQL QUERY')).rejects.toThrow(new response_handler_1.ApiError(400, 'INVALID_QUERY', 'Invalid SQL query'));
});
});
});