feat: Adds LockedMigration error.

src/factory.test.ts

@@ -2,6 +2,7 @@ import * as sourceMapSupport from 'source-map-support';
 sourceMapSupport.install();
 
 import factoryTest from './factoryTest';
+import LockedMigrationsError from './utils/errors/LockedMigrationsError';
 import ProcessedMigration from './utils/types/ProcessedMigration';
 
 let processedMigrations: ProcessedMigration[] = []; // tslint:disable-line:no-let
@@ -16,7 +17,7 @@ factoryTest({
   },
   lockMigrations: async () => {
     if (hasLockedMigrations) {
-      throw new Error();
+      throw new LockedMigrationsError();
     }
     hasLockedMigrations = true;
   },

src/migrate/test.ts

@@ -4,6 +4,7 @@ import 'mocha'; // tslint:disable-line:no-import-side-effect
 import factory from '../factory';
 import RepoFacade from '../RepoFacade';
 import FailingMigrationError from '../utils/errors/FailingMigrationError';
+import LockedMigrationsError from '../utils/errors/LockedMigrationsError';
 import createMigrationProcess from '../utils/tests/createMigrationProcess';
 import createTestUpMigration from '../utils/tests/createTestUpMigration';
 import MigrationDictionary from '../utils/types/MigrationDictionary';
@@ -71,5 +72,11 @@ export default (repo: RepoFacade) => {
       assert.equal(skippedMigration.getProcessed(), false);
       assert.equal(unskippedMigration.getProcessed(), true);
     });
+
+    it('should error when migrations are locked', async () => {
+      const service = createService({});
+      const promise = Promise.all([service.migrate(), service.migrate()]);
+      await assertRejects(promise, LockedMigrationsError);
+    });
   });
 };

src/migrateByKey/test.ts

@@ -4,13 +4,15 @@ import 'mocha'; // tslint:disable-line:no-import-side-effect
 import factory from '../factory';
 import RepoFacade from '../RepoFacade';
 import FailingMigrationError from '../utils/errors/FailingMigrationError';
+import LockedMigrationsError from '../utils/errors/LockedMigrationsError';
 import MissingMigrationError from '../utils/errors/MissingMigrationError';
 import ProcessedMigrationError from '../utils/errors/ProcessedMigrationError';
 import createMigrationProcess from '../utils/tests/createMigrationProcess';
 import createTestUpMigration from '../utils/tests/createTestUpMigration';
 import MigrationDictionary from '../utils/types/MigrationDictionary';
 
 export default (repo: RepoFacade) => {
+  const successfulMigration = createTestUpMigration();
   const failingMigration = createTestUpMigration(() => { throw new Error(); });
 
   const createService = (migrations: MigrationDictionary) => {
@@ -54,5 +56,14 @@ export default (repo: RepoFacade) => {
       await service.migrateByKey({ key: 'testMigration', force: true });
       assert.equal(getProcessed(), true);
     });
+
+    it('should error when migrations are locked', async () => {
+      const service = createService({ successfulMigration });
+      const promise = Promise.all([
+        service.migrateByKey({ key: 'successfulMigration' }),
+        service.migrateByKey({ key: 'successfulMigration' }),
+      ]);
+      await assertRejects(promise, LockedMigrationsError);
+    });
   });
 };

src/rollback/test.ts

@@ -4,6 +4,7 @@ import 'mocha'; // tslint:disable-line:no-import-side-effect
 import factory from '../factory';
 import RepoFacade from '../RepoFacade';
 import FailingMigrationError from '../utils/errors/FailingMigrationError';
+import LockedMigrationsError from '../utils/errors/LockedMigrationsError';
 import MissingMigrationError from '../utils/errors/MissingMigrationError';
 import createMigrationProcess from '../utils/tests/createMigrationProcess';
 import createTestDownMigration from '../utils/tests/createTestDownMigration';
@@ -83,5 +84,11 @@ export default (repo: RepoFacade) => {
       assert.equal(skippedMigration.getProcessed(), false);
       assert.equal(unskippedMigration.getProcessed(), true);
     });
+
+    it('should error when migrations are locked', async () => {
+      const service = createService({});
+      const promise = Promise.all([service.rollback(), service.rollback()]);
+      await assertRejects(promise, LockedMigrationsError);
+    });
   });
 };

src/rollbackByKey/test.ts

@@ -4,12 +4,14 @@ import 'mocha'; // tslint:disable-line:no-import-side-effect
 import factory from '../factory';
 import RepoFacade from '../RepoFacade';
 import FailingMigrationError from '../utils/errors/FailingMigrationError';
+import LockedMigrationsError from '../utils/errors/LockedMigrationsError';
 import UnprocessedMigrationError from '../utils/errors/UnprocessedMigrationError';
 import createMigrationProcess from '../utils/tests/createMigrationProcess';
 import createTestDownMigration from '../utils/tests/createTestDownMigration';
 import MigrationDictionary from '../utils/types/MigrationDictionary';
 
 export default (repo: RepoFacade) => {
+  const successfulMigration = createTestDownMigration();
   const failingMigration = createTestDownMigration(() => { throw new Error(); });
 
   const createService = (migrations: MigrationDictionary) => {
@@ -53,5 +55,15 @@ export default (repo: RepoFacade) => {
       await service.rollbackByKey({ key: 'testMigration', force: true });
       assert.equal(getProcessed(), true);
     });
+
+    it('should error when migrations are locked', async () => {
+      const service = createService({ successfulMigration });
+      await service.migrate();
+      const promise = Promise.all([
+        service.rollbackByKey({ key: 'successfulMigration' }),
+        service.rollbackByKey({ key: 'successfulMigration' }),
+      ]);
+      await assertRejects(promise, LockedMigrationsError);
+    });
   });
 };

src/utils/errors/LockedMigrationsError.ts

@@ -0,0 +1,8 @@
+// tslint:disable:no-class
+import { BaseError } from 'make-error';
+
+export default class LockedMigrationsError extends BaseError {
+  constructor() {
+    super();
+  }
+}