chore: remove half of the tests, too big a PR

Author: brennj

src/tests/jsonLogic.test.js

@@ -6,7 +6,6 @@ import {
   multiRuleSchema,
   schemaSelfContainedValueForMaximumMinimumValues,
   schemaSelfContainedValueForTitleWithNoTemplate,
-  schemaWhereValidationAndComputedValueIsAppliedOnNormalThenStatement,
   schemaWithChecksAndThenValidationsOnThen,
   schemaWithComputedAttributeThatDoesntExist,
   schemaWithComputedAttributeThatDoesntExistDescription,
@@ -17,21 +16,18 @@ import {
   schemaWithDeepVarThatDoesNotExist,
   schemaWithDeepVarThatDoesNotExistOnFieldset,
   schemaWithGreaterThanChecksForThreeFields,
-  schemaWithIfStatementWithComputedValuesAndValidationChecks,
   schemaWithInlineMultipleRulesForComputedAttributes,
   schemaWithInlineRuleForComputedAttributeWithCopy,
   schemaWithInlinedRuleOnComputedAttributeThatReferencesUnknownVar,
   schemaWithJSFLogicAndInlineRule,
   schemaWithMissingComputedValue,
   schemaWithMissingRule,
   schemaWithMissingValueInlineRule,
-  schemaWithMultipleComputedValueChecks,
   schemaWithNativeAndJSONLogicChecks,
   schemaWithNonRequiredField,
   schemaWithPropertiesCheckAndValidationsInAIf,
   schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset,
   schemaWithTwoRules,
-  schemaWithTwoValidationsWhereOneOfThemIsAppliedConditionally,
   schemaWithValidationThatDoesNotExistOnProperty,
   schemaWithVarThatDoesNotExist,
 } from './jsonLogicFixtures';
@@ -396,72 +392,6 @@ describe('cross-value validations', () => {
         undefined
       );
     });
-
-    it('Handle multiple computedValue checks by ANDing them together', () => {
-      const { handleValidation } = createHeadlessForm(schemaWithMultipleComputedValueChecks, {
-        strictInputType: false,
-      });
-      expect(handleValidation({}).formErrors).toEqual({
-        field_a: 'Required field',
-        field_b: 'Required field',
-      });
-      expect(handleValidation({ field_a: 10, field_b: 8 }).formErrors).toEqual({
-        field_c: 'Required field',
-      });
-      expect(handleValidation({ field_a: 10, field_b: 8, field_c: 0 }).formErrors).toEqual({
-        field_c: 'Must be two times B',
-      });
-      expect(handleValidation({ field_a: 10, field_b: 8, field_c: 17 }).formErrors).toEqual(
-        undefined
-      );
-    });
-
-    it('Handle having a true condition with both validations and computedValue checks', () => {
-      const { handleValidation } = createHeadlessForm(
-        schemaWithIfStatementWithComputedValuesAndValidationChecks,
-        { strictInputType: false }
-      );
-      expect(handleValidation({ field_a: 1, field_b: 1 }).formErrors).toEqual(undefined);
-      expect(handleValidation({ field_a: 10, field_b: 20 }).formErrors).toEqual(undefined);
-      expect(handleValidation({ field_a: 10, field_b: 9 }).formErrors).toEqual({
-        field_c: 'Required field',
-      });
-      expect(handleValidation({ field_a: 10, field_b: 9, field_c: 10 }).formErrors).toEqual(
-        undefined
-      );
-    });
-
-    it('Apply validations and computed values on normal if statement.', () => {
-      const { fields, handleValidation } = createHeadlessForm(
-        schemaWhereValidationAndComputedValueIsAppliedOnNormalThenStatement,
-        { strictInputType: false }
-      );
-      expect(handleValidation({ field_a: 0, field_b: 0 }).formErrors).toEqual(undefined);
-      expect(handleValidation({ field_a: 20, field_b: 0 }).formErrors).toEqual({
-        field_b: 'Must be greater than Field A + 10',
-      });
-      const [, fieldB] = fields;
-      expect(fieldB.label).toEqual('Must be greater than 30.');
-      expect(handleValidation({ field_a: 20, field_b: 31 }).formErrors).toEqual(undefined);
-    });
-
-    it('When we have a required validation on a top level property and another validation is added, both should be accounted for.', () => {
-      const { handleValidation } = createHeadlessForm(
-        schemaWithTwoValidationsWhereOneOfThemIsAppliedConditionally,
-        { strictInputType: false }
-      );
-      expect(handleValidation({ field_a: 10, field_b: 0 }).formErrors).toEqual({
-        field_b: 'Must be greater than A',
-      });
-      expect(handleValidation({ field_a: 10, field_b: 20 }).formErrors).toEqual(undefined);
-      expect(handleValidation({ field_a: 20, field_b: 10 }).formErrors).toEqual({
-        field_b: 'Must be greater than A',
-      });
-      expect(handleValidation({ field_a: 20, field_b: 21 }).formErrors).toEqual({
-        field_b: 'Must be greater than two times A',
-      });
-      expect(handleValidation({ field_a: 20, field_b: 41 }).formErrors).toEqual();
-    });
   });
 
   describe('Multiple validations', () => {

src/tests/jsonLogicFixtures.js

@@ -451,222 +451,6 @@ export const schemaWithComputedValueChecksInIf = {
   },
 };
 
-export const schemaWithMultipleComputedValueChecks = {
-  properties: {
-    field_a: {
-      type: 'number',
-    },
-    field_b: {
-      type: 'number',
-    },
-    field_c: {
-      type: 'number',
-    },
-  },
-  required: ['field_a', 'field_b'],
-  'x-jsf-logic': {
-    validations: {
-      double_b: {
-        errorMessage: 'Must be two times B',
-        rule: {
-          '>': [{ var: 'field_c' }, { '*': [{ var: 'field_b' }, 2] }],
-        },
-      },
-    },
-    computedValues: {
-      a_times_two: {
-        rule: {
-          '*': [{ var: 'field_a' }, 2],
-        },
-      },
-      mod_by_five: {
-        rule: {
-          '%': [{ var: 'field_b' }, 5],
-        },
-      },
-    },
-    allOf: [
-      {
-        if: {
-          computedValues: {
-            a_times_two: {
-              const: 20,
-            },
-            mod_by_five: {
-              const: 3,
-            },
-          },
-        },
-        then: {
-          required: ['field_c'],
-          properties: {
-            field_c: {
-              'x-jsf-logic-validations': ['double_b'],
-              title: 'Adding a title.',
-            },
-          },
-        },
-        else: {
-          properties: {
-            field_c: false,
-          },
-        },
-      },
-    ],
-  },
-};
-
-export const schemaWithIfStatementWithComputedValuesAndValidationChecks = {
-  properties: {
-    field_a: {
-      type: 'number',
-    },
-    field_b: {
-      type: 'number',
-    },
-    field_c: {
-      type: 'number',
-    },
-  },
-  required: ['field_a', 'field_b'],
-  'x-jsf-logic': {
-    validations: {
-      greater_than_b: {
-        rule: {
-          '>': [{ var: 'field_a' }, { var: 'field_b' }],
-        },
-      },
-    },
-    computedValues: {
-      a_times_two: {
-        rule: {
-          '*': [{ var: 'field_a' }, 2],
-        },
-      },
-    },
-    allOf: [
-      {
-        if: {
-          computedValues: {
-            a_times_two: {
-              const: 20,
-            },
-          },
-          validations: {
-            greater_than_b: {
-              const: true,
-            },
-          },
-        },
-        then: {
-          required: ['field_c'],
-        },
-        else: {
-          properties: {
-            field_c: false,
-          },
-        },
-      },
-    ],
-  },
-};
-
-export const schemaWhereValidationAndComputedValueIsAppliedOnNormalThenStatement = {
-  properties: {
-    field_a: {
-      type: 'number',
-    },
-    field_b: {
-      type: 'number',
-    },
-  },
-  'x-jsf-logic': {
-    computedValues: {
-      a_plus_ten: {
-        rule: {
-          '+': [{ var: 'field_a' }, 10],
-        },
-      },
-    },
-    validations: {
-      greater_than_a_plus_ten: {
-        errorMessage: 'Must be greater than Field A + 10',
-        rule: {
-          '>': [{ var: 'field_b' }, { '+': [{ var: 'field_a' }, 10] }],
-        },
-      },
-    },
-  },
-  allOf: [
-    {
-      if: {
-        properties: {
-          field_a: {
-            const: 20,
-          },
-        },
-      },
-      then: {
-        properties: {
-          field_b: {
-            'x-jsf-logic-computedAttrs': {
-              title: 'Must be greater than {{a_plus_ten}}.',
-            },
-            'x-jsf-logic-validations': ['greater_than_a_plus_ten'],
-          },
-        },
-      },
-    },
-  ],
-};
-
-export const schemaWithTwoValidationsWhereOneOfThemIsAppliedConditionally = {
-  required: ['field_a', 'field_b'],
-  properties: {
-    field_a: {
-      type: 'number',
-    },
-    field_b: {
-      type: 'number',
-      'x-jsf-logic-validations': ['greater_than_field_a'],
-    },
-  },
-  'x-jsf-logic': {
-    validations: {
-      greater_than_field_a: {
-        errorMessage: 'Must be greater than A',
-        rule: {
-          '>': [{ var: 'field_b' }, { var: 'field_a' }],
-        },
-      },
-      greater_than_two_times_a: {
-        errorMessage: 'Must be greater than two times A',
-        rule: {
-          '>': [{ var: 'field_b' }, { '*': [{ var: 'field_a' }, 2] }],
-        },
-      },
-    },
-  },
-  allOf: [
-    {
-      if: {
-        properties: {
-          field_a: {
-            const: 20,
-          },
-        },
-      },
-      then: {
-        properties: {
-          field_b: {
-            'x-jsf-logic-validations': ['greater_than_two_times_a'],
-          },
-        },
-      },
-    },
-  ],
-};
-
 export const multiRuleSchema = {
   properties: {
     field_a: {