@strictly/react-form 0.0.1

package/.out/core/mobx/specs/form_presenter.tests.js

@@ -0,0 +1,697 @@
+import { expectDefinedAndReturn } from '@strictly/base';
+import { booleanType, list, nullType, numberType, object, record, stringType, union, } from '@strictly/define';
+import { adapterFromTwoWayConverter, identityAdapter, } from 'core/mobx/field_adapter_builder';
+import { FormModel, FormPresenter, } from 'core/mobx/form_presenter';
+import { IntegerToStringConverter } from 'field_converters/integer_to_string_converter';
+import { NullableToBooleanConverter } from 'field_converters/nullable_to_boolean_converter';
+import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
+import { FieldConversionResult, } from 'types/field_converters';
+import { mock, mockClear, } from 'vitest-mock-extended';
+const IS_NAN_ERROR = 1;
+function createMockedAdapter({ convert, revert, create, }) {
+    const mockedAdapter = mock();
+    if (revert) {
+        mockedAdapter.revert?.mockImplementation(revert);
+    }
+    mockedAdapter.convert.mockImplementation(convert);
+    mockedAdapter.create.mockImplementation(create);
+    return mockedAdapter;
+}
+describe('all', function () {
+    const integerToStringAdapter = createMockedAdapter(adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0)));
+    const booleanToBooleanAdapter = createMockedAdapter(identityAdapter(false));
+    beforeEach(function () {
+        mockClear(integerToStringAdapter);
+        mockClear(booleanToBooleanAdapter);
+    });
+    describe('FlattenedTypePathsToConvertersOf', function () {
+        describe('record', function () {
+            const typeDef = record(numberType);
+            let t;
+            it('equals expected type', function () {
+                expectTypeOf(t).toEqualTypeOf();
+            });
+        });
+        describe('object', function () {
+            const typeDef = object()
+                .set('x', stringType)
+                .set('y', booleanType);
+            let t;
+            it('equals expected type', function () {
+                expectTypeOf(t).toEqualTypeOf();
+            });
+            it('matches representative adapters', function () {
+                expectTypeOf().toMatchTypeOf();
+            });
+            it('does not allow mismatched adapters', function () {
+                expectTypeOf().not.toMatchTypeOf();
+            });
+        });
+    });
+    describe('ValuePathsToAdaptersOf', function () {
+        describe('superset', function () {
+            const valuePathsToTypePaths = {
+                $: '$',
+                '$.a': '$.x',
+                '$.b': '$.y',
+                '$.c': '$.z',
+            };
+            let t;
+            it('equals expected type', function () {
+                expectTypeOf(t).toEqualTypeOf();
+            });
+        });
+    });
+    describe('FormModel', function () {
+        describe('literal', function () {
+            const typeDef = numberType;
+            const adapters = {
+                $: integerToStringAdapter,
+            };
+            let originalValue;
+            let model;
+            beforeEach(function () {
+                originalValue = 5;
+                model = new FormModel(typeDef, originalValue, adapters);
+            });
+            describe('accessors', function () {
+                it('gets the expected value', function () {
+                    const accessor = expectDefinedAndReturn(model.accessors.$);
+                    expect(accessor.value).toEqual(originalValue);
+                });
+                it('sets the underlying value', function () {
+                    const newValue = 1;
+                    const accessor = expectDefinedAndReturn(model.accessors.$);
+                    accessor.set(newValue);
+                    expect(model.value).toEqual(newValue);
+                });
+            });
+            describe('fields', function () {
+                it('equals expected value', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        $: expect.objectContaining({
+                            value: '5',
+                        }),
+                    }));
+                });
+                it('has the expected keys', function () {
+                    expect(Object.keys(model.fields)).toEqual(['$']);
+                });
+            });
+        });
+        describe('list', function () {
+            const typeDef = list(numberType);
+            const adapters = {
+                '$.*': integerToStringAdapter,
+            };
+            let value;
+            let model;
+            beforeEach(function () {
+                value = [
+                    1,
+                    4,
+                    17,
+                ];
+                model = new FormModel(typeDef, value, adapters);
+            });
+            describe('accessors', function () {
+                it.each([
+                    [
+                        '$.0',
+                        1,
+                    ],
+                    [
+                        '$.1',
+                        4,
+                    ],
+                    [
+                        '$.2',
+                        17,
+                    ],
+                ])('gets the expected values for %s', function (valuePath, value) {
+                    const accessor = expectDefinedAndReturn(model.accessors[valuePath]);
+                    expect(accessor.value).toEqual(value);
+                });
+                it('sets a value', function () {
+                    const accessor = expectDefinedAndReturn(model.accessors['$.0']);
+                    accessor.set(100);
+                    expect(model.value).toEqual([
+                        100,
+                        4,
+                        17,
+                    ]);
+                });
+            });
+        });
+        describe('record', function () {
+            const typeDef = record(numberType);
+            const converters = {
+                '$.*': integerToStringAdapter,
+                // '$.*': booleanToBooleanConverter,
+            };
+            let value;
+            let model;
+            beforeEach(function () {
+                value = {
+                    a: 1,
+                    b: 2,
+                };
+                model = new FormModel(typeDef, value, converters);
+            });
+            describe('accessors', function () {
+                it.each([
+                    [
+                        '$.a',
+                        1,
+                    ],
+                    [
+                        '$.b',
+                        2,
+                    ],
+                ])('gets the expected value for %s', function (valuePath, value) {
+                    const accessor = expectDefinedAndReturn(model.accessors[valuePath]);
+                    expect(accessor.value).toEqual(value);
+                });
+                it('sets a value', function () {
+                    const accessor = expectDefinedAndReturn(model.accessors['$.b']);
+                    const newValue = 100;
+                    accessor.set(newValue);
+                    expect(model.value.b).toEqual(newValue);
+                });
+            });
+            describe('fields', function () {
+                it('equals expected value', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        '$.a': expect.objectContaining({
+                            value: '1',
+                        }),
+                        '$.b': expect.objectContaining({
+                            value: '2',
+                        }),
+                    }));
+                });
+            });
+        });
+        describe('object', function () {
+            const typeDef = object()
+                .set('a', numberType)
+                .set('b', booleanType);
+            const converters = {
+                '$.a': integerToStringAdapter,
+                '$.b': booleanToBooleanAdapter,
+            };
+            let value;
+            let model;
+            beforeEach(function () {
+                value = {
+                    a: 1,
+                    b: true,
+                };
+                model = new FormModel(typeDef, value, converters);
+            });
+            describe('accessors', function () {
+                it.each([
+                    [
+                        '$.a',
+                        1,
+                    ],
+                    [
+                        '$.b',
+                        true,
+                    ],
+                ])('gets the expected value for %s', function (valuePath, value) {
+                    const accessor = expectDefinedAndReturn(model.accessors[valuePath]);
+                    expect(accessor.value).toEqual(value);
+                });
+                it('sets a value', function () {
+                    const accessor = expectDefinedAndReturn(model.accessors['$.b']);
+                    accessor.set(false);
+                    expect(model.value.b).toEqual(false);
+                });
+            });
+            describe('fields', function () {
+                it('equals expected value', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        '$.a': expect.objectContaining({
+                            value: '1',
+                        }),
+                        '$.b': expect.objectContaining({
+                            value: true,
+                        }),
+                    }));
+                });
+            });
+        });
+        // TODO union
+    });
+    describe('FormPresenter', function () {
+        describe('literal', function () {
+            const typeDef = numberType;
+            const adapters = {
+                $: integerToStringAdapter,
+            };
+            const presenter = new FormPresenter(typeDef, adapters);
+            const originalValue = 2;
+            let model;
+            beforeEach(function () {
+                model = presenter.createModel(originalValue);
+            });
+            describe('setFieldValueAndValidate', function () {
+                describe('success', function () {
+                    beforeEach(function () {
+                        presenter.setFieldValueAndValidate(model, '$', '1');
+                    });
+                    it('does set the underlying value', function () {
+                        expect(model.value).toEqual(1);
+                    });
+                    it('sets the fields', function () {
+                        expect(model.fields).toEqual(expect.objectContaining({
+                            $: expect.objectContaining({
+                                value: '1',
+                                // eslint-disable-next-line no-undefined
+                                error: undefined,
+                            }),
+                        }));
+                    });
+                });
+                describe('failure', function () {
+                    describe('conversion fails', function () {
+                        beforeEach(function () {
+                            presenter.setFieldValueAndValidate(model, '$', 'x');
+                        });
+                        it('does not set the underlying value', function () {
+                            expect(model.value).toEqual(originalValue);
+                        });
+                        it('sets the error state', function () {
+                            expect(model.fields).toEqual(expect.objectContaining({
+                                $: expect.objectContaining({
+                                    value: 'x',
+                                    error: IS_NAN_ERROR,
+                                }),
+                            }));
+                        });
+                    });
+                    describe('conversion succeeds, but validation fails', function () {
+                        const newValue = -1;
+                        const errorCode = 65;
+                        beforeEach(function () {
+                            integerToStringAdapter.revert?.mockReturnValueOnce({
+                                type: FieldConversionResult.Failure,
+                                error: errorCode,
+                                value: [newValue],
+                            });
+                            presenter.setFieldValueAndValidate(model, '$', '-1');
+                        });
+                        it('does set the underlying value', function () {
+                            expect(model.value).toEqual(newValue);
+                        });
+                        it('does update the field', function () {
+                            expect(model.fields).toEqual({
+                                $: expect.objectContaining({
+                                    value: '-1',
+                                    error: errorCode,
+                                    disabled: false,
+                                }),
+                            });
+                        });
+                    });
+                });
+            });
+            describe.each([
+                [
+                    '1',
+                    1,
+                ],
+                [
+                    'x',
+                    originalValue,
+                ],
+            ])('setFieldValue to %s', function (newValue, expectedValue) {
+                beforeEach(function () {
+                    presenter.setFieldValue(model, '$', newValue);
+                });
+                it('does set the underlying value', function () {
+                    expect(model.value).toEqual(expectedValue);
+                });
+                it('sets the field value', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        $: expect.objectContaining({
+                            value: newValue,
+                            // eslint-disable-next-line no-undefined
+                            error: undefined,
+                        }),
+                    }));
+                });
+            });
+        });
+        describe('list', function () {
+            const typeDef = list(numberType);
+            const converters = {
+                '$.*': integerToStringAdapter,
+            };
+            const presenter = new FormPresenter(typeDef, converters);
+            let originalValue;
+            let model;
+            beforeEach(function () {
+                originalValue = [
+                    1,
+                    3,
+                    7,
+                ];
+                model = presenter.createModel(originalValue);
+            });
+            describe('setFieldValueAndValidate', function () {
+                describe('success', function () {
+                    beforeEach(function () {
+                        presenter.setFieldValueAndValidate(model, '$.0', '100');
+                    });
+                    it('sets the underlying value', function () {
+                        expect(model.value).toEqual([
+                            100,
+                            3,
+                            7,
+                        ]);
+                    });
+                    it('sets the fields', function () {
+                        expect(model.fields).toEqual(expect.objectContaining({
+                            '$.0': expect.objectContaining({
+                                value: '100',
+                                // eslint-disable-next-line no-undefined
+                                error: undefined,
+                            }),
+                        }));
+                    });
+                });
+                describe('failure', function () {
+                    beforeEach(function () {
+                        presenter.setFieldValueAndValidate(model, '$.0', 'x');
+                    });
+                    it('does not set the underlying value', function () {
+                        expect(model.value).toEqual(originalValue);
+                    });
+                    it('sets the error state', function () {
+                        expect(model.fields).toEqual(expect.objectContaining({
+                            '$.0': expect.objectContaining({
+                                value: 'x',
+                                error: IS_NAN_ERROR,
+                            }),
+                        }));
+                    });
+                });
+            });
+            describe.each([
+                '1',
+                'x',
+            ])('setFieldValue to %s', function (newValue) {
+                beforeEach(function () {
+                    presenter.setFieldValue(model, '$.0', newValue);
+                });
+                it('does not set the underlying value', function () {
+                    expect(model.value).toEqual(originalValue);
+                });
+                it('sets the field value', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        '$.0': expect.objectContaining({
+                            value: newValue,
+                            // eslint-disable-next-line no-undefined
+                            error: undefined,
+                        }),
+                    }));
+                });
+            });
+            describe('validate', function () {
+                beforeEach(function () {
+                    presenter.setFieldValue(model, '$.0', 'x');
+                    presenter.setFieldValue(model, '$.1', '2');
+                    presenter.setFieldValue(model, '$.2', 'z');
+                    presenter.validateAll(model);
+                });
+                it('contains errors for all invalid fields', function () {
+                    expect(model.fields).toEqual(expect.objectContaining({
+                        '$.0': expect.objectContaining({
+                            value: 'x',
+                            error: IS_NAN_ERROR,
+                        }),
+                        '$.1': expect.objectContaining({
+                            value: '2',
+                            // eslint-disable-next-line no-undefined
+                            error: undefined,
+                        }),
+                        '$.2': expect.objectContaining({
+                            value: 'z',
+                            error: IS_NAN_ERROR,
+                        }),
+                    }));
+                });
+                it('sets the value only for valid fields', function () {
+                    expect(model.value).toEqual([
+                        1,
+                        2,
+                        7,
+                    ]);
+                });
+            });
+            // no longer passes context, but will pass context eventually again
+            describe('passes context', function () {
+                let contextCopy;
+                beforeEach(function () {
+                    integerToStringAdapter.revert.mockImplementationOnce(function (_value, _path, context) {
+                        contextCopy = [...context];
+                        return {
+                            type: FieldConversionResult.Success,
+                            value: 1,
+                        };
+                    });
+                });
+                it('supplies the full, previous context when converting', function () {
+                    presenter.setFieldValueAndValidate(model, '$.2', '4');
+                    expect(integerToStringAdapter.revert).toHaveBeenCalledOnce();
+                    expect(integerToStringAdapter.revert).toHaveBeenCalledWith('4', '$.2', 
+                    // uses the same pointer
+                    model.value);
+                });
+                it('supplies the context as it is at the time call', function () {
+                    expect(contextCopy).toEqual([
+                        1,
+                        3,
+                        7,
+                    ]);
+                });
+            });
+            describe('addListItem', function () {
+                describe('adds default to start of the list', function () {
+                    beforeEach(function () {
+                        model.errors['$.0'] = 0;
+                        model.errors['$.1'] = 1;
+                        model.errors['$.2'] = 2;
+                        presenter.addListItem(model, '$', null, 0);
+                    });
+                    it('adds the list item to the underlying value', function () {
+                        expect(model.value).toEqual([
+                            0,
+                            1,
+                            3,
+                            7,
+                        ]);
+                    });
+                    it.each([
+                        [
+                            '$.0',
+                            '0',
+                        ],
+                        [
+                            '$.1',
+                            '1',
+                        ],
+                        [
+                            '$.2',
+                            '3',
+                        ],
+                        [
+                            '$.3',
+                            '7',
+                        ],
+                    ])('it reports the value of field %s as %s', function (path, fieldValue) {
+                        expect(model.fields[path]?.value).toBe(fieldValue);
+                    });
+                    it.each([
+                        [
+                            '$.0',
+                            // eslint-disable-next-line no-undefined
+                            undefined,
+                        ],
+                        [
+                            '$.1',
+                            0,
+                        ],
+                        [
+                            '$.2',
+                            1,
+                        ],
+                        [
+                            '$.3',
+                            2,
+                        ],
+                    ])('it reports the error of field %s', function (path, error) {
+                        expect(model.fields[path]?.error).toBe(error);
+                    });
+                });
+                describe('add defined value', function () {
+                    beforeEach(function () {
+                        presenter.addListItem(model, '$', [5]);
+                    });
+                    it('adds the expected value at the end', function () {
+                        expect(model.fields).toEqual(expect.objectContaining({
+                            '$.0': expect.objectContaining({
+                                value: '1',
+                            }),
+                            '$.1': expect.objectContaining({
+                                value: '3',
+                            }),
+                            '$.2': expect.objectContaining({
+                                value: '7',
+                            }),
+                            '$.3': expect.objectContaining({
+                                value: '5',
+                            }),
+                        }));
+                    });
+                    it('updates the underlying value', function () {
+                        expect(model.value).toEqual([
+                            1,
+                            3,
+                            7,
+                            5,
+                        ]);
+                    });
+                });
+            });
+            describe('removeListItem', function () {
+                beforeEach(function () {
+                    model.errors['$.0'] = 0;
+                    model.errors['$.1'] = 1;
+                    model.errors['$.2'] = 2;
+                });
+                describe('remove first item', function () {
+                    beforeEach(function () {
+                        presenter.removeListItem(model, '$.0');
+                    });
+                    it('updates the underlying value', function () {
+                        expect(model.value).toEqual([
+                            3,
+                            7,
+                        ]);
+                    });
+                    it('updates the field values and errors', function () {
+                        expect(model.fields).toEqual({
+                            '$.0': expect.objectContaining({
+                                value: '3',
+                                error: 1,
+                            }),
+                            '$.1': expect.objectContaining({
+                                value: '7',
+                                error: 2,
+                            }),
+                        });
+                    });
+                });
+                describe('remove second item', function () {
+                    beforeEach(function () {
+                        presenter.removeListItem(model, '$.1');
+                    });
+                    it('updates the underlying value', function () {
+                        expect(model.value).toEqual([
+                            1,
+                            7,
+                        ]);
+                    });
+                    it('updates the field values and errors', function () {
+                        expect(model.fields).toEqual({
+                            '$.0': expect.objectContaining({
+                                value: '1',
+                                error: 0,
+                            }),
+                            '$.1': expect.objectContaining({
+                                value: '7',
+                                error: 2,
+                            }),
+                        });
+                    });
+                });
+            });
+        });
+        // TODO record / object
+        describe('union', function () {
+            describe('non-discriminated', function () {
+                const listOfNumbersTypeDef = list(numberType);
+                const typeDef = union()
+                    .add('null', nullType)
+                    .add('0', listOfNumbersTypeDef);
+                const adapters = {
+                    $: adapterFromTwoWayConverter(new NullableToBooleanConverter(typeDef, [1])),
+                    '$.*': integerToStringAdapter,
+                };
+                const presenter = new FormPresenter(typeDef, adapters);
+                let originalValue;
+                let model;
+                beforeEach(function () {
+                    originalValue = null;
+                    model = presenter.createModel(originalValue);
+                });
+                it('has the expected fields', function () {
+                    expect(model.fields).toEqual({
+                        $: {
+                            disabled: false,
+                            // eslint-disable-next-line no-undefined
+                            error: undefined,
+                            value: false,
+                            required: false,
+                        },
+                    });
+                });
+                describe('setFieldValueAndValidate', function () {
+                    describe('success', function () {
+                        beforeEach(function () {
+                            presenter.setFieldValueAndValidate(model, '$', true);
+                        });
+                        it('sets the underlying value', function () {
+                            expect(model.value).toEqual([1]);
+                        });
+                    });
+                });
+            });
+        });
+        describe('fake', function () {
+            const typeDef = numberType;
+            const converters = {
+                $: integerToStringAdapter,
+                '$.fake': booleanToBooleanAdapter,
+            };
+            const presenter = new FormPresenter(typeDef, converters);
+            let originalValue;
+            let model;
+            beforeEach(function () {
+                originalValue = 1;
+                model = presenter.createModel(originalValue);
+            });
+            it('returns the default value for the fake field', function () {
+                expect(model.fields['$.fake']).toEqual(expect.objectContaining({
+                    value: false,
+                }));
+            });
+            describe('setting fake field', function () {
+                beforeEach(function () {
+                    presenter.setFieldValue(model, '$.fake', true);
+                });
+                it('stores the new value', function () {
+                    expect(model.fields['$.fake']).toEqual(expect.objectContaining({
+                        value: true,
+                    }));
+                });
+                it('does not change the original value', function () {
+                    expect(model.value).toBe(originalValue);
+                });
+            });
+        });
+    });
+});