@bitblit/ratchet-common 6.0.146-alpha → 6.0.148-alpha

package/src/transform/built-in-transforms.ts

@@ -0,0 +1,214 @@
+/*
+    Some useful transforms for the transform ratchet
+*/
+
+import { TransformRule } from './transform-rule.js';
+import { Logger } from '../logger/logger.js';
+import { NumberRatchet } from '../lang/number-ratchet.js';
+import { DateTime } from 'luxon';
+
+export class BuiltInTransforms {
+  public static keysOnly(rule: TransformRule): TransformRule {
+    return {
+      transform(value: any, isKey: boolean, context: any): any {
+        return isKey ? rule.transform(value, isKey, context) : value;
+      },
+    } as TransformRule;
+  }
+
+  public static valuesOnly(rule: TransformRule): TransformRule {
+    return {
+      transform(value: any, isKey: boolean, context: any): any {
+        return !isKey ? rule.transform(value, isKey, context) : value;
+      },
+    } as TransformRule;
+  }
+
+  public static stringReplaceTransform(input: string, output: string): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        return value == input ? output : value;
+      },
+    } as TransformRule;
+  }
+
+  public static stripStringTransform(input: string): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        return value == input ? null : value;
+      },
+    } as TransformRule;
+  }
+
+  public static retainAll(input: string[]): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        return input.indexOf(value) == -1 ? null : value;
+      },
+    } as TransformRule;
+  }
+
+  public static removeAll(input: string[]): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        return input.indexOf(value) > -1 ? null : value;
+      },
+    } as TransformRule;
+  }
+
+  public static snakeToCamelCase(): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        let rval = value;
+        if (typeof value == 'string') {
+          // Taken, mainly, from https://stackoverflow.com/questions/4969605/javascript-regexp-to-camelcase-a-hyphened-css-property
+          rval = value.replace(/_([a-z0-9])/gi, function (s, group1) {
+            return group1.toUpperCase();
+          });
+        }
+        return rval;
+      },
+    } as TransformRule;
+  }
+
+  public static stringToNumber(): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        let rval = value;
+        if (typeof value == 'string') {
+          const num: number = NumberRatchet.safeNumber(value);
+          if (num !== null) {
+            rval = num;
+          }
+        }
+        return rval;
+      },
+    } as TransformRule;
+  }
+
+  public static camelToSnakeCase(): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        let rval = value;
+        if (typeof value == 'string') {
+          // https://stackoverflow.com/questions/30521224/javascript-convert-pascalcase-to-underscore-case
+          rval = value
+            .replace(/\.?([A-Z]+)/g, function (x, y) {
+              return '_' + y.toLowerCase();
+            })
+            .replace(/^_/, '');
+        }
+        return rval;
+      },
+    } as TransformRule;
+  }
+
+  public static concatenateToNewField(newFieldName: string, oldFieldNamesInOrder: string[], abortIfFieldMissing = true): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        if (typeof value == 'object') {
+          let rval = '';
+          oldFieldNamesInOrder.forEach((n) => {
+            if (rval != null) {
+              const temp = value[n];
+              if (temp == null && abortIfFieldMissing) {
+                rval = null;
+              } else {
+                rval = temp == null ? rval : rval + String(temp);
+              }
+            }
+          });
+          if (rval != null) {
+            value[newFieldName] = rval;
+            // Dynamic-safe(r) since we are outside the loop
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            oldFieldNamesInOrder.forEach((n) => delete value[n]);
+          }
+        }
+        return value;
+      },
+    } as TransformRule;
+  }
+
+  public static numberToBool(fieldNames: string[]): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        if (typeof value == 'object') {
+          fieldNames.forEach((n) => {
+            const oldVal = value[n];
+            if (typeof oldVal == 'number') {
+              const newVal = 0 != oldVal;
+              value[n] = newVal;
+            }
+          });
+        }
+        return value;
+      },
+    } as TransformRule;
+  }
+
+  public static boolToNumber(fieldNames: string[]): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        if (typeof value == 'object') {
+          fieldNames.forEach((n) => {
+            const oldVal = value[n];
+            if (typeof oldVal == 'boolean') {
+              const newVal = oldVal ? 1 : 0;
+              value[n] = newVal;
+            }
+          });
+        }
+        return value;
+      },
+    } as TransformRule;
+  }
+
+  public static makeDuplicateField(oldName: string, newName: string): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        if (typeof value == 'object') {
+          const oldVal = value[oldName];
+          if (oldVal != null) {
+            value[newName] = oldVal;
+          }
+        }
+        return value;
+      },
+    } as TransformRule;
+  }
+
+  public static addField(name: string, valueToAdd: string): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        if (typeof value == 'object') {
+          value[name] = valueToAdd;
+        }
+        return value;
+      },
+    } as TransformRule;
+  }
+
+  // Moment formats, https://momentjs.com/docs/#/parsing/
+  public static reformatDateFields(fieldNames: string[], oldFormat: string, newFormat: string): TransformRule {
+    return {
+      transform(value: any, _isKey: boolean, _context: any): any {
+        if (typeof value == 'object') {
+          fieldNames.forEach((key) => {
+            const oldValue = value[key];
+            if (oldValue != null) {
+              try {
+                const parsed: DateTime = DateTime.fromFormat(oldValue, oldFormat);
+                const newValue: string = parsed.toFormat(newFormat);
+                value[key] = newValue;
+              } catch (err) {
+                Logger.warn('Failed to reparse date %s in format %s : %s', oldValue, oldFormat, err);
+              }
+            }
+          });
+        }
+        return value;
+      },
+    } as TransformRule;
+  }
+}

package/src/transform/transform-ratchet.spec.ts

@@ -0,0 +1,134 @@
+import { TransformRatchet } from './transform-ratchet.js';
+import { BuiltInTransforms } from './built-in-transforms.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#formatBytes', function () {
+  const srcData = {
+    key1: 'value1',
+    key2: 'value2',
+    dateKey1: '1995-02-01',
+    intKey1: 0,
+    intKey2: 1,
+    boolKey1: true,
+    boolKey2: false,
+    camelSnake: 'this is a camel case',
+    subKey: {
+      key1: 'subValue1',
+      key2: 'subValue2',
+      convertToNumberInner: '42',
+    },
+    convertToNumber: '1',
+    convertToNumberAlso: '20',
+  };
+
+  const srcUnderData = {
+    new_key_1: 'value1',
+    sub_key: {
+      new_key_2: 'value2',
+    },
+  };
+
+  test('should convert camel to snakecase', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.keysOnly(BuiltInTransforms.camelToSnakeCase())]);
+    expect(result['dateKey1']).toBeUndefined();
+    expect(result['intKey1']).toBeUndefined();
+    expect(result['intKey2']).toBeUndefined();
+    expect(result['boolKey1']).toBeUndefined();
+    expect(result['boolKey2']).toBeUndefined();
+    expect(result['subKey']).toBeUndefined();
+    expect(result['date_key1']).toBeTruthy();
+    expect(result['int_key1']).toEqual(0);
+    expect(result['int_key2']).toBeTruthy();
+    expect(result['bool_key1']).toBeTruthy();
+    expect(result['bool_key1']).toBeTruthy();
+    expect(result['sub_key']).toBeTruthy();
+  });
+
+  test('should duplicate key1 into key3', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.makeDuplicateField('key1', 'key3')]);
+    expect(result.key1).toEqual('value1');
+    expect(result.key3).toEqual('value1');
+  });
+
+  test('should create a new field named key3', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.addField('key3', 'value3')]);
+    expect(result.key1).toEqual('value1');
+    expect(result.key3).toEqual('value3');
+  });
+
+  test('should reformat the date in dateField1 to MM-dd-yyyy', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.reformatDateFields(['dateKey1'], 'yyyy-MM-dd', 'MM/dd/yyyy')]);
+    expect(result.dateKey1).toEqual('02/01/1995');
+  });
+
+  test('should convert numbers to booleans', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.numberToBool(['intKey1', 'intKey2'])]);
+    expect(result.key1).toEqual('value1');
+    expect(result.intKey1).toEqual(false);
+    expect(result.intKey2).toEqual(true);
+  });
+
+  test('should convert booleans to number', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.boolToNumber(['boolKey1', 'boolKey2'])]);
+    expect(result.key1).toEqual('value1');
+    expect(result.boolKey1).toEqual(1);
+    expect(result.boolKey2).toEqual(0);
+  });
+
+  test('should concatenate key1 and key2 into key3', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.concatenateToNewField('key3', ['key1', 'key2'])]);
+    expect(result.key1).toBeUndefined();
+    expect(result.key2).toBeUndefined();
+    expect(result.key3).toEqual('value1value2');
+    expect(result.subKey.key1).toBeUndefined();
+    expect(result.subKey.key2).toBeUndefined();
+    expect(result.subKey.key3).toEqual('subValue1subValue2');
+  });
+
+  test('should strip a key correctly', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.stripStringTransform('key1')]);
+    expect(result.key1).toBeUndefined();
+  });
+
+  test('should rename a key correctly', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.stringReplaceTransform('key1', 'newKey1')]);
+    expect(result.key1).toBeUndefined();
+    expect(result.newKey1).toEqual('value1');
+    expect(result.subKey.key1).toBeUndefined();
+    expect(result.subKey.newKey1).toEqual('subValue1');
+  });
+
+  test('should retain only key1 and key2', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.keysOnly(BuiltInTransforms.retainAll(['key1', 'key2']))]);
+    expect(result.key1).toBeTruthy();
+    expect(result.key2).toBeTruthy();
+    expect(result.intKey1).toBeUndefined();
+    expect(result.boolKey1).toBeUndefined();
+    expect(result.subKey).toBeUndefined();
+  });
+
+  test('should remove only key1 and key2', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.keysOnly(BuiltInTransforms.removeAll(['key1', 'key2']))]);
+    expect(result.key1).toBeUndefined();
+    expect(result.key2).toBeUndefined();
+    expect(result.intKey1).toEqual(0);
+    expect(result.boolKey1).toBeTruthy();
+    expect(result.subKey).toBeTruthy();
+  });
+
+  test('should convert snake to camelcase', function () {
+    const result = TransformRatchet.transform(srcUnderData, [BuiltInTransforms.keysOnly(BuiltInTransforms.snakeToCamelCase())]);
+    expect(result['new_key_1']).toBeUndefined();
+    expect(result['sub_key']).toBeUndefined();
+    expect(result.newKey1).toBeTruthy();
+    expect(result.subKey).toBeTruthy();
+    expect(result.subKey.newKey2).toBeTruthy();
+  });
+
+  test('should convert strings to numbers', function () {
+    const result = TransformRatchet.transform(srcData, [BuiltInTransforms.valuesOnly(BuiltInTransforms.stringToNumber())]);
+    expect(result['convertToNumber']).toEqual(1);
+    expect(result['convertToNumberAlso']).toEqual(20);
+    expect(result['subKey']['convertToNumberInner']).toEqual(42);
+  });
+});

package/src/transform/transform-ratchet.ts

@@ -0,0 +1,88 @@
+/*
+    Functions for working with maps (dictionaries/objects in javascript)
+
+    For each entry:
+    1) Apply to key
+    2) If the key is now null, skip it, else:
+    2a) If the value is an array or map, recursively descend it
+    2b) Apply to value
+    3) If the value is now null, skip it.  Else, put into new result
+
+*/
+
+import { TransformRule } from './transform-rule.js';
+import { Logger } from '../logger/logger.js';
+
+export class TransformRatchet {
+  public static transform(toTransform: any, rules: TransformRule[] = []): any {
+    return TransformRatchet.transformGeneric(toTransform, rules, false, null);
+  }
+
+  private static transformGeneric(toTransform: any, rules: TransformRule[] = [], isKey: boolean, context: any): any {
+    let rval: any = null;
+    const type: string = typeof toTransform;
+    switch (type) {
+      case 'undefined':
+      case 'symbol':
+      case 'function':
+        rval = toTransform;
+        break;
+      case 'number':
+      case 'string':
+      case 'boolean':
+        rval = TransformRatchet.applyTransformToPrimitive(toTransform, rules, isKey, context);
+        break;
+      case 'object':
+        rval = TransformRatchet.applyTransformToObject(toTransform, rules, isKey, context);
+        break;
+      default:
+        throw new Error('Unrecognized type ' + type);
+    }
+    return rval;
+  }
+
+  private static applyTransformToObject(toTransform: any, rules: TransformRule[] = [], isKey: boolean, context: any = null) {
+    Logger.silly('Tranform: %j, %s, %j', toTransform, isKey, context);
+    let rval: any = null;
+    if (toTransform != null) {
+      if (Array.isArray(toTransform)) {
+        rval = [];
+        toTransform.forEach((val) => {
+          const newVal = TransformRatchet.transformGeneric(val, rules, isKey, toTransform);
+          if (newVal != null) {
+            rval.push(newVal);
+          }
+        });
+      } else {
+        // Its a complex object
+        rval = {};
+        Object.keys(toTransform).forEach((k) => {
+          // First, transform the key
+          const oldValue = toTransform[k];
+          const newKey = TransformRatchet.applyTransformToPrimitive(k, rules, true, toTransform);
+          if (newKey != null) {
+            // Recursively descend first
+            let newValue = TransformRatchet.transformGeneric(oldValue, rules, false, toTransform);
+            // Then apply to the object as a whole
+            newValue = TransformRatchet.applyTransformToPrimitive(newValue, rules, false, toTransform);
+
+            if (newValue != null) {
+              rval[newKey] = newValue;
+            }
+          }
+        });
+        // Finally, apply to the object itself
+        rval = TransformRatchet.applyTransformToPrimitive(rval, rules, false, toTransform);
+      }
+    }
+    return rval;
+  }
+
+  private static applyTransformToPrimitive(toTransform: any, rules: TransformRule[] = [], isKey: boolean, context: any) {
+    let rval: any = toTransform;
+    rules.forEach((r) => {
+      rval = rval == null ? null : r.transform(rval, isKey, context);
+    });
+    return rval;
+  }
+}

package/src/transform/transform-rule.ts

@@ -0,0 +1,7 @@
+/*
+    Functions as input for the transformer
+*/
+
+export interface TransformRule {
+  transform(value: any, isKey: boolean, context: any): any;
+}

package/src/tx/transaction-configuration.ts

@@ -0,0 +1,8 @@
+import { TransactionResult } from './transaction-result.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+
+export interface TransactionConfiguration<T> {
+  stepLogLevel?: LoggerLevelName;
+  executeAfterRollback?(result: TransactionResult<T>): Promise<void>;
+  executeAfterRollbackFailure?(result: TransactionResult<T>): Promise<void>;
+}

package/src/tx/transaction-final-state.ts

@@ -0,0 +1,7 @@
+// NOTE: This is a psuedo-enum to fix some issues with Typescript enums.  See: https://exploringjs.com/tackling-ts/ch_enum-alternatives.html for details
+export const TransactionFinalState = {
+  Success: 'Success',
+  RolledBack: 'RolledBack',
+  RollbackFailed: 'RollbackFailed',
+};
+export type TransactionFinalState = (typeof TransactionFinalState)[keyof typeof TransactionFinalState];

package/src/tx/transaction-ratchet.spec.ts

@@ -0,0 +1,150 @@
+import { TransactionStep } from './transaction-step.js';
+import { TransactionRatchet } from './transaction-ratchet.js';
+import { TransactionResult } from './transaction-result.js';
+import { TransactionFinalState } from './transaction-final-state.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { describe, expect, test } from 'vitest';
+
+interface TestTransactionContext {
+  runningTotal: number;
+  failStep?: number;
+  failRollbackStep?: number;
+  postTxTracker?: number;
+}
+
+class TestTransactionStep implements TransactionStep<TestTransactionContext> {
+  async execute(context: TestTransactionContext, stepNumber?: number): Promise<void> {
+    context.runningTotal += stepNumber;
+    if (stepNumber === context?.failStep) {
+      throw new Error('Forced error at step ' + stepNumber);
+    }
+  }
+
+  async rollback(context: TestTransactionContext, stepNumber?: number): Promise<void> {
+    context.runningTotal -= stepNumber;
+    if (stepNumber === context?.failRollbackStep) {
+      throw new Error('Forced rollback error at step ' + stepNumber);
+    }
+  }
+}
+
+describe('#TransactionRatchet.execute', function () {
+  test('should return the right value when it executes successfully', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx);
+    expect(result).not.toBeNull();
+    expect(result.error).toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.Success);
+    expect(result.finalContext.runningTotal).toEqual(3);
+  });
+
+  test('should return the right value when it rolls back successfully fail step 2', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx);
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
+    expect(result.errorStep).toEqual(2);
+    expect(result.error).not.toBeUndefined();
+    expect(result.finalContext.runningTotal).toEqual(0);
+  });
+
+  test('should return the right value when it rolls back successfully fail step 1', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx);
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
+    expect(result.errorStep).toEqual(2);
+    expect(result.error).not.toBeUndefined();
+    expect(result.finalContext.runningTotal).toEqual(0);
+  });
+
+  test('should return the right value the rollback fails', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx);
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+    expect(result.finalContext.runningTotal).toEqual(0);
+    expect(result.errorStep).toEqual(2);
+    expect(result.rollbackErrorStep).toEqual(1);
+    expect(result.error).not.toBeUndefined();
+    expect(result.rollbackError).not.toBeUndefined();
+  });
+
+  test('should run the post-error handler when a failure happens', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx, {
+      executeAfterRollback: async (res) => {
+        res.finalContext.postTxTracker = 1;
+      },
+    });
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
+    expect(result.errorStep).toEqual(2);
+    expect(result.error).not.toBeUndefined();
+    expect(result.finalContext.postTxTracker).toEqual(1);
+  });
+
+  test('should run both post-error handler when a failure happens in both error and rollback', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx, {
+      executeAfterRollback: async (res) => {
+        res.finalContext.postTxTracker = 1;
+      },
+      executeAfterRollbackFailure: async (res) => {
+        res.finalContext.postTxTracker += 1;
+      },
+    });
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+    expect(result.errorStep).toEqual(2);
+    expect(result.error).not.toBeUndefined();
+    expect(result.finalContext.postTxTracker).toEqual(2);
+  });
+
+  test('should still return if a post-tx executor fails', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx, {
+      executeAfterRollback: async (res) => {
+        res.finalContext.postTxTracker = 1;
+      },
+      executeAfterRollbackFailure: async (res) => {
+        res.finalContext.postTxTracker += 1;
+        throw new Error('Forced tracker failure');
+      },
+    });
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+    expect(result.errorStep).toEqual(2);
+    expect(result.error).not.toBeUndefined();
+    expect(result.finalContext.postTxTracker).toEqual(2);
+  });
+
+  test('should work with transaction configuration that only provides read log level access', async () => {
+    const steps: TestTransactionStep[] = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
+    const ctx: TestTransactionContext = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
+    const result: TransactionResult<TestTransactionContext> = await TransactionRatchet.execute(steps, ctx, {
+      get stepLogLevel(): LoggerLevelName {
+        return LoggerLevelName.info;
+      },
+      executeAfterRollback: async (res) => {
+        res.finalContext.postTxTracker = 1;
+      },
+      executeAfterRollbackFailure: async (res) => {
+        res.finalContext.postTxTracker += 1;
+        throw new Error('Forced tracker failure');
+      },
+    });
+    expect(result).not.toBeUndefined();
+    expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
+    expect(result.errorStep).toEqual(2);
+    expect(result.error).not.toBeUndefined();
+    expect(result.finalContext.postTxTracker).toEqual(2);
+  });
+});