test: jest.fn

Author: arnaud-moncel

packages/datasource-customizer/test/plugins/import-field.test.ts

@@ -42,7 +42,7 @@ describe('importField', () => {
     const { dataSource } = setupMocks();
     const dataSourceCustomizer = new DataSourceCustomizer({
       ignoreMissingSchemaElementErrors: false,
-      restartAgentFunction: async () => {},
+      restartAgentFunction: jest.fn(),
     });
     dataSourceCustomizer.addDataSource(async () => dataSource);
 

packages/datasource-mongo/test/index.integration.test.ts

@@ -148,10 +148,7 @@ describe('Datasource Mongo', () => {
           },
         });
 
-        const dataSource = await factory(
-          () => {},
-          async () => {},
-        );
+        const dataSource = await factory(jest.fn(), jest.fn());
 
         expect(dataSource.collections).toHaveLength(2);
         expect(dataSource.collections.map(c => c.name)).toEqual(

packages/datasource-mongoose/test/index.test.ts

@@ -12,10 +12,7 @@ describe('exports', () => {
 
   it('createMongooseDataSource should return a datasource factory', async () => {
     const factory = createMongooseDataSource(mongoose.connection, {});
-    const dataSource = await factory(
-      () => {},
-      async () => {},
-    );
+    const dataSource = await factory(jest.fn(), jest.fn());
 
     expect(factory).toBeInstanceOf(Function);
     expect(dataSource).toBeInstanceOf(MongooseDatasource);

packages/datasource-replica/test/integrations/factories.ts

@@ -25,5 +25,5 @@ export const makeReplicaDataSource = async (
 ): Promise<DataSource> => {
   const replicaFactory = createReplicaDataSource(options ?? {});
 
-  return replicaFactory(logger ?? makeLogger(), async () => {});
+  return replicaFactory(logger ?? makeLogger(), jest.fn());
 };

packages/datasource-sequelize/test/integration/aggregation/count.integration.test.ts

@@ -52,10 +52,7 @@ describe('Count', () => {
             { name: null },
           ]);
 
-          const datasource = await createSequelizeDataSource(sequelize)(
-            undefined as any,
-            async () => {},
-          );
+          const datasource = await createSequelizeDataSource(sequelize)(jest.fn(), jest.fn());
           collection = datasource.getCollection('User') as SequelizeCollection;
         }, 30_000);
 

packages/datasource-sequelize/test/integration/list/filter.integration.test.ts

@@ -442,10 +442,7 @@ describe('Filter tests on collection', () => {
             { tags: null },
           ]);
 
-          const datasource = await createSequelizeDataSource(sequelize)(
-            undefined as any,
-            async () => {},
-          );
+          const datasource = await createSequelizeDataSource(sequelize)(jest.fn(), jest.fn());
           collection = datasource.getCollection('Objects') as SequelizeCollection;
         });
 

packages/datasource-sql/src/connection/connection-options.js

@@ -0,0 +1,67 @@
+"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 };
+    }
+};
+exports.__esModule = true;
+var errors_1 = require("./errors");
+/** Test connection. If this doesn't resolve after 10s, throw a timeout error */
+function testConnectionWithTimeOut(sequelize, databaseUri, timeout) {
+    var _a;
+    if (timeout === void 0) { timeout = 10000; }
+    return __awaiter(this, void 0, void 0, function () {
+        var timeoutId, timeoutPromise;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    timeoutPromise = new Promise(function (resolve, reject) {
+                        timeoutId = setTimeout(function () {
+                            reject(new errors_1.DatabaseConnectError('Connection to database timed out', databaseUri));
+                        }, timeout);
+                    });
+                    return [4 /*yield*/, Promise.race([
+                            (_a = sequelize.authenticate()) === null || _a === void 0 ? void 0 : _a["finally"](function () {
+                                clearTimeout(timeoutId);
+                            }),
+                            timeoutPromise,
+                        ])];
+                case 1:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports["default"] = testConnectionWithTimeOut;

packages/datasource-sql/src/connection/connection-tester.js

@@ -0,0 +1,88 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.SshForwardError = exports.SshConnectError = exports.ProxyForwardError = exports.ProxyConnectError = exports.DatabaseConnectError = void 0;
+/* eslint-disable max-classes-per-file */
+var datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+var BaseError = /** @class */ (function (_super) {
+    __extends(BaseError, _super);
+    function BaseError(message, debugUri, details) {
+        var _this = _super.call(this, details ? "".concat(message, "\n").concat(details) : message) || this;
+        _this.details = details;
+        _this.debugUri = debugUri;
+        return _this;
+    }
+    return BaseError;
+}(datasource_toolkit_1.BusinessError));
+var DatabaseConnectError = /** @class */ (function (_super) {
+    __extends(DatabaseConnectError, _super);
+    function DatabaseConnectError(message, debugDatabaseUri, source) {
+        if (source === void 0) { source = 'Database'; }
+        var _this = this;
+        // remove tcp protocol because its not added by the user
+        var sanitizedUri = debugDatabaseUri.replace('tcp://', '');
+        _this = _super.call(this, "Unable to connect to the given uri: ".concat(sanitizedUri, "."), sanitizedUri, message) || this;
+        _this.source = source;
+        return _this;
+    }
+    return DatabaseConnectError;
+}(BaseError));
+exports.DatabaseConnectError = DatabaseConnectError;
+var ProxyConnectError = /** @class */ (function (_super) {
+    __extends(ProxyConnectError, _super);
+    function ProxyConnectError(message, debugProxyUri) {
+        var _this = _super.call(this, "Your proxy has encountered an error. Unable to connect to the given uri: ".concat(debugProxyUri, "."), debugProxyUri, message) || this;
+        _this.source = 'Proxy';
+        return _this;
+    }
+    return ProxyConnectError;
+}(BaseError));
+exports.ProxyConnectError = ProxyConnectError;
+var ProxyForwardError = /** @class */ (function (_super) {
+    __extends(ProxyForwardError, _super);
+    function ProxyForwardError(message, debugForwardedUri) {
+        var _this = _super.call(this, "Your proxy forwarded connection has encountered an error." +
+            "Unable to connect to the given uri: ".concat(debugForwardedUri, "."), debugForwardedUri, message) || this;
+        _this.source = 'Proxy';
+        return _this;
+    }
+    return ProxyForwardError;
+}(BaseError));
+exports.ProxyForwardError = ProxyForwardError;
+var SshConnectError = /** @class */ (function (_super) {
+    __extends(SshConnectError, _super);
+    function SshConnectError(message, debugSshUri, source) {
+        if (source === void 0) { source = 'Ssh'; }
+        var _this = _super.call(this, "Your ssh connection has encountered an error. " +
+            "Unable to connect to the given ssh uri: ".concat(debugSshUri), debugSshUri, message) || this;
+        _this.source = source;
+        return _this;
+    }
+    return SshConnectError;
+}(BaseError));
+exports.SshConnectError = SshConnectError;
+var SshForwardError = /** @class */ (function (_super) {
+    __extends(SshForwardError, _super);
+    function SshForwardError(message, debugForwardedUri) {
+        var _this = _super.call(this, "Your ssh forward connection has encountered an error. " +
+            "Unable to connect to the given ssh uri: ".concat(debugForwardedUri), debugForwardedUri, message) || this;
+        _this.source = 'Ssh';
+        return _this;
+    }
+    return SshForwardError;
+}(BaseError));
+exports.SshForwardError = SshForwardError;

packages/datasource-sql/src/connection/errors.js

@@ -0,0 +1,28 @@
+"use strict";
+exports.__esModule = true;
+var sequelize_1 = require("sequelize");
+var errors_1 = require("./errors");
+function handleErrors(error, options) {
+    if (error instanceof errors_1.ProxyForwardError) {
+        // means that the ssh is not reachable
+        if (options.sshOptions) {
+            throw new errors_1.SshConnectError(null, error.debugUri, 'Proxy');
+        }
+        else {
+            // if there is no sshOptions, then the database is the destination and
+            // it means that the database is not reachable
+            throw new errors_1.DatabaseConnectError(null, error.debugUri, 'Proxy');
+        }
+    }
+    // it means that the database is not reachable
+    if (error instanceof errors_1.SshForwardError) {
+        throw new errors_1.DatabaseConnectError(null, error.debugUri, 'Ssh');
+    }
+    if (error instanceof sequelize_1.BaseError) {
+        var nameWithoutSequelize = error.name.replace('Sequelize', '');
+        var nameWithSpaces = nameWithoutSequelize.replace(/([a-z])([A-Z])/g, function (_, m1, m2) { return "".concat(m1, " ").concat(m2.toLowerCase()); });
+        throw new errors_1.DatabaseConnectError("".concat(nameWithSpaces, ": ").concat(error.message), options.debugDatabaseUri);
+    }
+    throw error;
+}
+exports["default"] = handleErrors;