Initial tests for sequential conditions.

packages/taco/test/conditions/sequential.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it } from 'vitest';
+
+import { CompoundConditionType } from '../../src/conditions/compound-condition';
+import { SUPPORTED_CHAIN_IDS } from '../../src/conditions/const';
+import {
+  ConditionVariableProps,
+  SequentialCondition,
+  SequentialConditionProps,
+  sequentialConditionSchema,
+  SequentialConditionType,
+} from '../../src/conditions/sequential';
+import {
+  testCompoundConditionObj,
+  testContractConditionObj,
+  testRpcConditionObj,
+  testSequentialConditionObj,
+  testTimeConditionObj,
+} from '../test-utils';
+
+describe('validation', () => {
+  const rpcConditionVariable: ConditionVariableProps = {
+    varName: 'rpc',
+    condition: testRpcConditionObj,
+  };
+  const timeConditionVariable: ConditionVariableProps = {
+    varName: 'time',
+    condition: testTimeConditionObj,
+  };
+  const contractConditionVariable: ConditionVariableProps = {
+    varName: 'contract',
+    condition: testContractConditionObj,
+  };
+  const compoundConditionVariable: ConditionVariableProps = {
+    varName: 'compound',
+    condition: testCompoundConditionObj,
+  };
+  const sequentialConditionVariable: ConditionVariableProps = {
+    varName: 'nestedSequential',
+    condition: testSequentialConditionObj,
+  };
+
+  it('rejects no varName', () => {
+    const result = SequentialCondition.validate(sequentialConditionSchema, {
+      conditionVariables: [
+        rpcConditionVariable,
+        {
+          condition: testTimeConditionObj,
+        },
+      ],
+    });
+
+    expect(result.error).toBeDefined();
+    expect(result.data).toBeUndefined();
+    expect(result.error?.format()).toMatchObject({
+      conditionVariables: {
+        '1': {
+          varName: {
+            _errors: ['Required'],
+          },
+        },
+      },
+    });
+  });
+
+  it('rejects > max number of condition variables', () => {
+    const tooManyConditionVariables = new Array(6);
+    for (let i = 0; i < tooManyConditionVariables.length; i++) {
+      tooManyConditionVariables[i] = {
+        varName: `var${i}`,
+        condition: testRpcConditionObj,
+      };
+    }
+    const result = SequentialCondition.validate(sequentialConditionSchema, {
+      conditionVariables: tooManyConditionVariables,
+    });
+
+    expect(result.error).toBeDefined();
+    expect(result.data).toBeUndefined();
+    expect(result.error?.format()).toMatchObject({
+      conditionVariables: {
+        _errors: [`Array must contain at most 5 element(s)`],
+      },
+    });
+  });
+
+  it('accepts nested compound conditions', () => {
+    const conditionObj = {
+      conditionType: SequentialConditionType,
+      conditionVariables: [
+        rpcConditionVariable,
+        timeConditionVariable,
+        contractConditionVariable,
+        compoundConditionVariable,
+      ],
+    };
+    const result = SequentialCondition.validate(
+      sequentialConditionSchema,
+      conditionObj,
+    );
+    expect(result.error).toBeUndefined();
+    expect(result.data).toEqual({
+      conditionType: SequentialConditionType,
+      conditionVariables: [
+        rpcConditionVariable,
+        timeConditionVariable,
+        contractConditionVariable,
+        compoundConditionVariable,
+      ],
+    });
+  });
+
+  it('accepts nested sequential and compound conditions', () => {
+    const conditionObj = {
+      conditionType: SequentialConditionType,
+      conditionVariables: [
+        rpcConditionVariable,
+        timeConditionVariable,
+        contractConditionVariable,
+        compoundConditionVariable,
+        sequentialConditionVariable,
+      ],
+    };
+    const result = SequentialCondition.validate(
+      sequentialConditionSchema,
+      conditionObj,
+    );
+    expect(result.error).toBeUndefined();
+    expect(result.data).toEqual({
+      conditionType: SequentialConditionType,
+      conditionVariables: [
+        rpcConditionVariable,
+        timeConditionVariable,
+        contractConditionVariable,
+        compoundConditionVariable,
+        sequentialConditionVariable,
+      ],
+    });
+  });
+
+  it('limits max depth of nested compound condition', () => {
+    const result = SequentialCondition.validate(sequentialConditionSchema, {
+      conditionVariables: [
+        rpcConditionVariable,
+        contractConditionVariable,
+        {
+          varName: 'compound',
+          condition: {
+            conditionType: CompoundConditionType,
+            operator: 'not',
+            operands: [
+              {
+                conditionType: CompoundConditionType,
+                operator: 'and',
+                operands: [testTimeConditionObj, testRpcConditionObj],
+              },
+            ],
+          },
+        },
+      ],
+    });
+    expect(result.error).toBeDefined();
+    expect(result.data).toBeUndefined();
+    expect(result.error?.format()).toMatchObject({
+      conditionVariables: {
+        _errors: [`Exceeded max nested depth of 2 for multi-condition type`],
+      },
+    });
+  });
+
+  it('limits max depth of nested sequential condition', () => {
+    const result = SequentialCondition.validate(sequentialConditionSchema, {
+      conditionVariables: [
+        rpcConditionVariable,
+        contractConditionVariable,
+        {
+          varName: 'sequentialNested',
+          condition: {
+            conditionType: SequentialConditionType,
+            conditionVariables: [
+              timeConditionVariable,
+              sequentialConditionVariable,
+            ],
+          },
+        },
+      ],
+    });
+    expect(result.error).toBeDefined();
+    expect(result.data).toBeUndefined();
+    expect(result.error?.format()).toMatchObject({
+      conditionVariables: {
+        _errors: ['Exceeded max nested depth of 2 for multi-condition type'],
+      },
+    });
+  });
+
+  it('accepts on a valid multichain condition schema', () => {
+    const multichainCondition: SequentialConditionProps = {
+      conditionType: SequentialConditionType,
+      conditionVariables: SUPPORTED_CHAIN_IDS.map((chain) => ({
+        varName: `chain_${chain}`,
+        condition: {
+          ...testRpcConditionObj,
+          chain,
+        },
+      })),
+    };
+
+    const result = SequentialCondition.validate(
+      sequentialConditionSchema,
+      multichainCondition,
+    );
+
+    expect(result.error).toBeUndefined();
+    expect(result.data).toEqual(multichainCondition);
+  });
+
+  it('rejects an invalid multichain condition schema', () => {
+    const badMultichainCondition: SequentialConditionProps = {
+      conditionType: SequentialConditionType,
+      conditionVariables: [
+        {
+          varName: 'chain_1',
+          condition: {
+            ...testRpcConditionObj,
+            chain: 1,
+          },
+        },
+        {
+          varName: 'chain_137',
+          condition: {
+            ...testRpcConditionObj,
+            chain: 137,
+          },
+        },
+        {
+          varName: `invalid_chain`,
+          condition: {
+            ...testRpcConditionObj,
+            chain: -1,
+          },
+        },
+      ],
+    };
+
+    const result = SequentialCondition.validate(
+      sequentialConditionSchema,
+      badMultichainCondition,
+    );
+
+    expect(result.error).toBeDefined();
+    expect(result.data).toBeUndefined();
+  });
+
+  it('infers default condition type from constructor', () => {
+    const condition = new SequentialCondition({
+      conditionVariables: [
+        contractConditionVariable,
+        timeConditionVariable,
+        rpcConditionVariable,
+      ],
+    });
+    expect(condition.value.conditionType).toEqual(SequentialConditionType);
+  });
+});

packages/taco/test/test-utils.ts

@@ -48,6 +48,10 @@ import {
   TimeConditionProps,
   TimeConditionType,
 } from '../src/conditions/base/time';
+import {
+  CompoundConditionProps,
+  CompoundConditionType,
+} from '../src/conditions/compound-condition';
 import { ConditionExpression } from '../src/conditions/condition-expr';
 import { ERC721Balance } from '../src/conditions/predefined/erc721';
 import {
@@ -245,6 +249,16 @@ export const testContractConditionObj: ContractConditionProps = {
   returnValueTest: testReturnValueTest,
 };
 
+export const testCompoundConditionObj: CompoundConditionProps = {
+  conditionType: CompoundConditionType,
+  operator: 'or',
+  operands: [
+    testRpcConditionObj,
+    testTimeConditionObj,
+    testContractConditionObj,
+  ],
+};
+
 export const testSequentialConditionObj: SequentialConditionProps = {
   conditionType: SequentialConditionType,
   conditionVariables: [