@storyous/mongodb 1.0.7 → 1.0.8

package/__tests__/mongoLocker.test.ts

@@ -1,191 +0,0 @@
-import assert from 'assert';
-import { noop, pick, times } from 'lodash';
-import { beforeEach, describe, it } from 'mocha';
-import { Collection, MongoClient } from 'mongodb';
-import sinon from 'sinon';
-import {
-    getMongoLocker, LockCallback, LockerOptions, mongoLocker,
-} from '../lib';
-import { Key } from '../lib/mongoClient';
-import connectAndGetMongoClient from './getMongoClient';
-
-describe('packages/mongodb/mongoLocker', () => {
-
-    let mongoClient: MongoClient;
-    let collection: Collection;
-    const collectionName = 'customLocks';
-
-    beforeEach(async () => {
-        mongoClient = await connectAndGetMongoClient();
-        collection = mongoClient.db().collection(collectionName);
-        await collection.drop().catch(noop);
-    });
-
-    [
-        { description: 'default mongoLocker instance', locker: () => mongoLocker },
-        { description: 'custom getMongoLocker', locker: () => getMongoLocker(collection) },
-    ]
-        .forEach((suite) => {
-
-            describe(suite.description, () => {
-
-                let locker: (key: Key, callback: LockCallback<any>, options?: LockerOptions) => Promise<any>;
-
-                beforeEach(async () => {
-                    locker = await suite.locker();
-                });
-
-                it('should acquire and release a lock', async () => {
-
-                    let i = 0;
-                    const callback: any = sinon.spy(() => ++i);
-
-                    const result1 = await locker('AAA', callback);
-                    assert.strictEqual(result1, 1);
-
-                    const result2 = await locker('AAA', callback);
-                    assert.strictEqual(result2, 2);
-
-                    assert.deepStrictEqual(callback.callCount, 2);
-                });
-
-                it('should not be possible to acquire the lock twice at once', async () => {
-
-                    const callback = sinon.spy(() => new Promise((resolve) => { setTimeout(resolve, 50); }));
-                    const callLocker = () => locker('AAA', callback, { noLaterThan: 0 });
-
-                    const concurrency = 10;
-                    const promises = times(concurrency, callLocker);
-
-                    // Node 10 or less does not support allSettled. Going through good old cycle in such case
-                    if (Promise.allSettled) {
-                        await Promise.allSettled(promises); // just to get rid of UnhandledRejectionErrors
-                    } else {
-                    // just to get rid of UnhandledRejectionErrors
-                        promises.forEach((promise) => promise.catch(() => {}));
-
-                        for (let i = 0; i < promises.length; i++) {
-                            try {
-                            await promises[i]; // eslint-disable-line
-                            } catch (err) {
-                            // That's ok, we expect there can be errors
-                            }
-                        }
-                    }
-
-                    const stats = {
-                        resolved: 0,
-                        failed: 0,
-                    };
-
-                    for (const promise of promises) {
-                        try {
-                            await promise; // eslint-disable-line no-await-in-loop
-                            stats.resolved++;
-                        } catch (err: any) {
-                            assert(/The lock is already acquired./.test(err?.message));
-                            stats.failed++;
-                        }
-                    }
-
-                    assert.deepStrictEqual(callback.callCount, 1, 'The callback should be called only once');
-                    assert.deepStrictEqual(stats, {
-                        resolved: 1,
-                        failed: concurrency - 1,
-                    });
-                });
-
-                it('should propagate an error and release the lock if the callback fails', async () => {
-
-                    await assert.rejects(() => locker('AAA', async () => {
-                        throw new Error('Some error occurred');
-                    }), /Some error occurred/);
-
-                    const callback = sinon.spy();
-                    await locker('AAA', callback);
-
-                    assert.strictEqual(callback.callCount, 1);
-                });
-
-                it(
-                    'should be able to handle few concurrent tasks by waiting some time and acquire retries',
-                    async () => {
-                        const callTimes: Date[] = [];
-                        const callback = sinon.spy(async () => {
-                            callTimes.push(new Date());
-                            await new Promise((resolve) => { setTimeout(resolve, 150); });
-                            callTimes.push(new Date());
-                        }); // default retryDelay is 200
-
-                        const callLocker = () => locker('AAA', callback);
-
-                        await Promise.all(times(3, callLocker));
-
-                        assert.strictEqual(callback.callCount, 3);
-                        callTimes.forEach((time, i) => {
-                            if (i > 0) {
-                                assert(time > callTimes[i - 1], 'There was a parallel callback execution!');
-                            }
-                        });
-                    });
-
-                it('should be possible to override a lock which expired yet', async () => {
-                    const expireIn = 500;
-                    const array: number[] = [];
-                    const key = 'AAA';
-
-                    const firstCallPromise = locker(key, async () => {
-                        array.push(1);
-                        // the method last too long
-                        await new Promise((resolve) => { setTimeout(resolve, 2 * expireIn); });
-                        array.push(3);
-                    }, { expireIn });
-
-                    await new Promise((resolve) => { setTimeout(resolve, expireIn); });
-
-                    const secondCallPromise = locker('AAA', async () => {
-                        array.push(2);
-                    }, { expireIn });
-
-                    await Promise.all([firstCallPromise, secondCallPromise]);
-                    assert.deepStrictEqual(array, [1, 2, 3]);
-                });
-            });
-        });
-
-    describe('getMongoLocker', () => {
-        it('should create and TTL index on the right field', async () => {
-            await mongoClient.db()
-                .createCollection(collectionName);
-
-            let indexes = await collection.indexes();
-            assert.deepStrictEqual(indexes.length, 1); // ensure there is only mandatory _id index
-
-            const locker = await getMongoLocker(collection);
-            indexes = await collection.indexes();
-            assert.deepStrictEqual(indexes.length, 2, 'No or wrong indexes has been created!');
-            assert.deepStrictEqual(pick(indexes[1], 'key', 'expireAfterSeconds'), {
-                expireAfterSeconds: 0,
-                key: {
-                    expiresAt: 1,
-                },
-            }, 'No or wrong indexes has been created!');
-
-            const startedAt = new Date();
-            const someKey = 'someKey';
-            const expireIn = 55000;
-            await locker(someKey, async () => {
-                const document = await collection.findOne({});
-                assert.strictEqual(document?._id, someKey);
-                assert(
-                    document.expiresAt >= new Date(startedAt.getTime() + expireIn),
-                    'The expiresAt property has to be greater then startedAt + expiresIn',
-                );
-                assert(
-                    document.expiresAt < new Date(Date.now() + expireIn),
-                    'The acquiredAt property has to be younger then present + expiresIn',
-                );
-            }, { expireIn });
-        });
-    });
-});

package/__tests__/runMigration.test.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./getMongoClient");
-const assert_1 = __importDefault(require("assert"));
-const mocha_1 = require("mocha");
-const winston_1 = require("winston");
-const lib_1 = require("../lib");
-(0, mocha_1.describe)('packages/mongodb/migrations', () => {
-    (0, mocha_1.before)(async () => {
-        await lib_1.appData._collection.deleteOne({ _id: 'migrations' });
-    });
-    (0, mocha_1.it)('should runMigrations works', async () => {
-        await (0, lib_1.runMigrations)((0, winston_1.createLogger)(), `${__dirname}/migrations`, { safeMigration: false });
-        const migration = await lib_1.appData.getDocument('migrations');
-        assert_1.default.deepStrictEqual(migration?.lastRun, '1642152064249-test.js');
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuTWlncmF0aW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJydW5NaWdyYXRpb24udGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDRCQUEwQjtBQUMxQixvREFBNEI7QUFDNUIsaUNBQTZDO0FBQzdDLHFDQUF1QztBQUN2QyxnQ0FBZ0Q7QUFFaEQsSUFBQSxnQkFBUSxFQUFDLDZCQUE2QixFQUFFLEdBQUcsRUFBRTtJQUN6QyxJQUFBLGNBQU0sRUFBQyxLQUFLLElBQUksRUFBRTtRQUNkLE1BQU0sYUFBTyxDQUFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsRUFBRSxHQUFHLEVBQUUsWUFBWSxFQUFFLENBQUMsQ0FBQztJQUMvRCxDQUFDLENBQUMsQ0FBQztJQUVILElBQUEsVUFBRSxFQUFDLDRCQUE0QixFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ3hDLE1BQU0sSUFBQSxtQkFBYSxFQUNmLElBQUEsc0JBQVksR0FBRSxFQUNkLEdBQUcsU0FBUyxhQUFhLEVBQ3pCLEVBQUUsYUFBYSxFQUFFLEtBQUssRUFBRSxDQUMzQixDQUFDO1FBRUYsTUFBTSxTQUFTLEdBQUcsTUFBTSxhQUFPLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzFELGdCQUFNLENBQUMsZUFBZSxDQUFDLFNBQVMsRUFBRSxPQUFPLEVBQUUsdUJBQXVCLENBQUMsQ0FBQztJQUN4RSxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMsQ0FBQyxDQUFDIn0=

package/__tests__/runMigration.test.ts

@@ -1,22 +0,0 @@
-import './getMongoClient';
-import assert from 'assert';
-import { before, describe, it } from 'mocha';
-import { createLogger } from 'winston';
-import { appData, runMigrations } from '../lib';
-
-describe('packages/mongodb/migrations', () => {
-    before(async () => {
-        await appData._collection.deleteOne({ _id: 'migrations' });
-    });
-
-    it('should runMigrations works', async () => {
-        await runMigrations(
-            createLogger(),
-            `${__dirname}/migrations`,
-            { safeMigration: false },
-        );
-
-        const migration = await appData.getDocument('migrations');
-        assert.deepStrictEqual(migration?.lastRun, '1642152064249-test.js');
-    });
-});

package/__tests__/withTransaction.test.js

@@ -1,40 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = __importDefault(require("assert"));
-const lodash_1 = require("lodash");
-const mocha_1 = require("mocha");
-const lib_1 = require("../lib");
-require('./getMongoClient');
-(0, mocha_1.describe)('packages/mongodb/withTransaction', () => {
-    let testCollection;
-    (0, mocha_1.beforeEach)(async () => {
-        testCollection = (0, lib_1.getCollection)('withTransactionTests');
-        await testCollection.drop().catch(lodash_1.noop);
-        await testCollection.insertOne({}); // ensure the collection is created before tests
-    });
-    (0, mocha_1.it)('should commit the transaction', async () => {
-        const expectedReturnValue = { some: 'value' };
-        const returnValue = await (0, lib_1.withTransaction)(async (session) => {
-            await testCollection.insertOne({}, { session });
-            await testCollection.insertOne({}, { session });
-            assert_1.default.equal(await testCollection.countDocuments({}, { session }), 3);
-            return expectedReturnValue;
-        });
-        assert_1.default.equal(await testCollection.countDocuments({}), 3, 'there should available documents after a commit');
-        assert_1.default.equal(returnValue, expectedReturnValue);
-    });
-    (0, mocha_1.it)('should rollback the transaction', async () => {
-        const error = new Error('some error');
-        await assert_1.default.rejects(() => (0, lib_1.withTransaction)(async (session) => {
-            await testCollection.insertOne({}, { session });
-            await testCollection.insertOne({}, { session });
-            assert_1.default.equal(await testCollection.countDocuments({}, { session }), 3);
-            throw error;
-        }), error);
-        assert_1.default.equal(await testCollection.countDocuments({}), 1, 'there should be no document after a rollback');
-    });
-});
-//# sourceMappingURL=data:application/json;base64,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

package/__tests__/withTransaction.test.ts

@@ -1,67 +0,0 @@
-import assert from 'assert';
-import { noop } from 'lodash';
-import { beforeEach, describe, it } from 'mocha';
-import { Collection } from 'mongodb';
-import { getCollection, withTransaction } from '../lib';
-
-require('./getMongoClient');
-
-describe('packages/mongodb/withTransaction', () => {
-
-    let testCollection: Collection<any>;
-    beforeEach(async () => {
-        testCollection = getCollection('withTransactionTests');
-        await testCollection.drop().catch(noop);
-        await testCollection.insertOne({}) as any; // ensure the collection is created before tests
-    });
-
-    it('should commit the transaction', async () => {
-
-        const expectedReturnValue = { some: 'value' };
-
-        const returnValue = await withTransaction(async (session) => {
-
-            await testCollection.insertOne({}, { session });
-            await testCollection.insertOne({}, { session });
-
-            assert.equal(
-                await testCollection.countDocuments({}, { session }),
-                3,
-            );
-
-            return expectedReturnValue;
-        });
-
-        assert.equal(
-            await testCollection.countDocuments({}),
-            3,
-            'there should available documents after a commit',
-        );
-
-        assert.equal(returnValue, expectedReturnValue);
-    });
-
-    it('should rollback the transaction', async () => {
-        const error = new Error('some error');
-
-        await assert.rejects(() => withTransaction(async (session) => {
-
-            await testCollection.insertOne({}, { session });
-            await testCollection.insertOne({}, { session });
-
-            assert.equal(
-                await testCollection.countDocuments({}, { session }),
-                3,
-            );
-
-            throw error;
-
-        }), error);
-
-        assert.equal(
-            await testCollection.countDocuments({}),
-            1,
-            'there should be no document after a rollback',
-        );
-    });
-});

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "include": [
-        "lib",
-        "__tests__"
-    ]
-}