fix(rollback): Fixes the order of rollling back. (#10)

Author: ryasmi

src/migrate/test.ts

@@ -3,6 +3,7 @@ import * as assertRejects from 'assert-rejects';
 import 'mocha'; // tslint:disable-line:no-import-side-effect
 import DuplicateKeyError from '../utils/errors/DuplicateKeyError';
 import FailingMigrationError from '../utils/errors/FailingMigrationError';
+import assertDateOrder from '../utils/tests/assertDateOrder';
 import assertLocked from '../utils/tests/assertLocked';
 import createMigrationProcess from '../utils/tests/createMigrationProcess';
 import createTestUpMigration from '../utils/tests/createTestUpMigration';
@@ -39,18 +40,25 @@ const testMigrate: TestFactory = (createService) => {
       await assertRejects(promise, FailingMigrationError);
     });
 
-    it('should process migrations', async () => {
-      const { process, getProcessed } = createMigrationProcess();
-      const service = createService([createTestUpMigration(process)]);
+    it('should process migrations in order', async () => {
+      const firstProcess = createMigrationProcess();
+      const secondProcess = createMigrationProcess();
+      const service = createService([
+        createTestUpMigration(firstProcess.process, 'firstMigration'),
+        createTestUpMigration(secondProcess.process, 'secondMigration'),
+      ]);
       await service.migrate();
-      assert.equal(getProcessed(), true);
+      assert.notEqual(firstProcess.getProcessed(), undefined);
+      assert.notEqual(secondProcess.getProcessed(), undefined);
+      const processes = [firstProcess.getProcessed(), secondProcess.getProcessed()];
+      assertDateOrder(processes as Date[]);
     });
 
     it('should not reprocess migrations', async () => {
       const { process, getProcessed } = createMigrationProcess();
       await createService([createTestUpMigration()]).migrate();
       await createService([createTestUpMigration(process)]).migrate();
-      assert.equal(getProcessed(), false);
+      assert.equal(getProcessed(), undefined);
     });
 
     it('should skip processed migrations after unprocessed migrations', async () => {
@@ -61,8 +69,8 @@ const testMigrate: TestFactory = (createService) => {
         createTestUpMigration(unskippedProcess.process),
         createTestUpMigration(skippedProcess.process, skippableKey),
       ]).migrate();
-      assert.equal(skippedProcess.getProcessed(), false);
-      assert.equal(unskippedProcess.getProcessed(), true);
+      assert.equal(skippedProcess.getProcessed(), undefined);
+      assert.notEqual(unskippedProcess.getProcessed(), undefined);
     });
 
     it('should skip processed migrations before unprocessed migrations', async () => {
@@ -73,8 +81,8 @@ const testMigrate: TestFactory = (createService) => {
         createTestUpMigration(skippedProcess.process, skippableKey),
         createTestUpMigration(unskippedProcess.process),
       ]).migrate();
-      assert.equal(skippedProcess.getProcessed(), false);
-      assert.equal(unskippedProcess.getProcessed(), true);
+      assert.equal(skippedProcess.getProcessed(), undefined);
+      assert.notEqual(unskippedProcess.getProcessed(), undefined);
     });
 
     it('should error when migrations are locked', async () => {

src/migrateByKey/test.ts

@@ -42,7 +42,7 @@ const testMigrateByKey: TestFactory = (createService) => {
       const { process, getProcessed } = createMigrationProcess();
       const service = createService([createTestUpMigration(process)]);
       await service.migrateByKey({ key: testMigrationKey });
-      assert.equal(getProcessed(), true);
+      assert.notEqual(getProcessed(), undefined);
     });
 
     it('should error when reprocessing migrations without force', async () => {
@@ -51,15 +51,15 @@ const testMigrateByKey: TestFactory = (createService) => {
       const service = createService([createTestUpMigration(process)]);
       const promise = service.migrateByKey({ key: testMigrationKey });
       await assertRejects(promise, ProcessedMigrationError);
-      assert.equal(getProcessed(), false);
+      assert.equal(getProcessed(), undefined);
     });
 
     it('should reprocess migration when using force', async () => {
       const { process, getProcessed } = createMigrationProcess();
       await createService([createTestUpMigration()]).migrate();
       const service = createService([createTestUpMigration(process)]);
       await service.migrateByKey({ key: testMigrationKey, force: true });
-      assert.equal(getProcessed(), true);
+      assert.notEqual(getProcessed(), undefined);
     });
 
     it('should error when migrations are locked', async () => {

src/rollback/index.ts

@@ -8,7 +8,7 @@ import Signature, { Opts } from './Signature';
 export default (config: FacadeConfig): Signature => {
   return async ({ dryRun = false }: Opts = {}) => {
     await handleLocks(config, async () => {
-      const lastBatchKeys = await getLastBatchKeys(config);
+      const lastBatchKeys = (await getLastBatchKeys(config)).reverse();
 
       await Promise.resolve(reduce(lastBatchKeys, async (_result, key) => {
         await rollbackKey({ config, key, dryRun });

src/rollback/test.ts

@@ -5,6 +5,7 @@ import 'mocha'; // tslint:disable-line:no-import-side-effect
 import DuplicateKeyError from '../utils/errors/DuplicateKeyError';
 import FailingMigrationError from '../utils/errors/FailingMigrationError';
 import MissingMigrationError from '../utils/errors/MissingMigrationError';
+import assertDateOrder from '../utils/tests/assertDateOrder';
 import assertLocked from '../utils/tests/assertLocked';
 import createMigrationProcess from '../utils/tests/createMigrationProcess';
 import createTestDownMigration from '../utils/tests/createTestDownMigration';
@@ -57,19 +58,26 @@ const testRollback: TestFactory = (createService) => {
       await assertRejects(promise, FailingMigrationError);
     });
 
-    it('should process rollback for a processed migration', async () => {
-      const { process, getProcessed } = createMigrationProcess();
-      const service = createService([createTestDownMigration(process)]);
+    it('should process rollbacks for processed migrations in reverse order', async () => {
+      const firstProcess = createMigrationProcess();
+      const secondProcess = createMigrationProcess();
+      const service = createService([
+        createTestDownMigration(firstProcess.process, 'firstMigration'),
+        createTestDownMigration(secondProcess.process, 'secondMigration'),
+      ]);
       await service.migrate();
       await service.rollback();
-      assert.equal(getProcessed(), true);
+      assert.notEqual(firstProcess.getProcessed(), undefined);
+      assert.notEqual(secondProcess.getProcessed(), undefined);
+      const processes = [secondProcess.getProcessed(), firstProcess.getProcessed()];
+      assertDateOrder(processes as Date[]);
     });
 
     it('should not process rollback for a unprocessed migration', async () => {
       const { process, getProcessed } = createMigrationProcess();
       const service = createService([createTestDownMigration(process)]);
       await service.rollback();
-      assert.equal(getProcessed(), false);
+      assert.equal(getProcessed(), undefined);
     });
 
     it('should skip unprocessed migrations after processed migrations', async () => {
@@ -80,8 +88,8 @@ const testRollback: TestFactory = (createService) => {
         createTestDownMigration(unskippedProcess.process, unskippableKey),
         createTestDownMigration(skippedProcess.process),
       ]).rollback();
-      assert.equal(skippedProcess.getProcessed(), false);
-      assert.equal(unskippedProcess.getProcessed(), true);
+      assert.equal(skippedProcess.getProcessed(), undefined);
+      assert.notEqual(unskippedProcess.getProcessed(), undefined);
     });
 
     it('should skip unprocessed migrations before processed migrations', async () => {
@@ -92,8 +100,8 @@ const testRollback: TestFactory = (createService) => {
         createTestDownMigration(skippedProcess.process),
         createTestDownMigration(unskippedProcess.process, unskippableKey),
       ]).rollback();
-      assert.equal(skippedProcess.getProcessed(), false);
-      assert.equal(unskippedProcess.getProcessed(), true);
+      assert.equal(skippedProcess.getProcessed(), undefined);
+      assert.notEqual(unskippedProcess.getProcessed(), undefined);
     });
 
     it('should error when migrations are locked', async () => {

src/rollbackByKey/test.ts

@@ -46,22 +46,22 @@ const testRollbackByKey: TestFactory = (createService) => {
       const service = createService([createTestDownMigration(process)]);
       await service.migrate();
       await service.rollbackByKey({ key: testMigrationKey });
-      assert.equal(getProcessed(), true);
+      assert.notEqual(getProcessed(), undefined);
     });
 
     it('should error when rolling back unprocessed migrations without force', async () => {
       const { process, getProcessed } = createMigrationProcess();
       const service = createService([createTestDownMigration(process)]);
       const promise = service.rollbackByKey({ key: testMigrationKey });
       await assertRejects(promise, UnprocessedMigrationError);
-      assert.equal(getProcessed(), false);
+      assert.equal(getProcessed(), undefined);
     });
 
     it('should rollback when rolling back a unprocessed migration with force', async () => {
       const { process, getProcessed } = createMigrationProcess();
       const service = createService([createTestDownMigration(process)]);
       await service.rollbackByKey({ key: testMigrationKey, force: true });
-      assert.equal(getProcessed(), true);
+      assert.notEqual(getProcessed(), undefined);
     });
 
     it('should error when migrations are locked', async () => {

src/utils/tests/assertDateOrder.ts

@@ -0,0 +1,9 @@
+import * as assert from 'assert';
+
+export default (dates: Date[]) => {
+  const expectedDates = dates.map((date) => {
+    return date.toISOString();
+  });
+  const sortedDates = [...expectedDates].sort();
+  assert.deepEqual(sortedDates, expectedDates);
+};

src/utils/tests/createMigrationProcess.ts

@@ -1,7 +1,10 @@
+import { delay } from 'bluebird';
+
 export default () => {
-  let processed = false; // tslint:disable-line:no-let
-  const process = () => {
-    processed = true;
+  let processed: Date | undefined; // tslint:disable-line:no-let
+  const process = async () => {
+    await Promise.resolve(delay(1));
+    processed = new Date();
   };
   const getProcessed = () => {
     return processed;