pydantic_form/tests/test_process.py

import pytest
from wtforms import FormField

from pydantic_form.translator import iter_form
from pydantic_form.utils import recursive_get, formdata_mangle


@pytest.fixture
def data(request, scenario):
    return getattr(scenario.data_factory, request.param)()


SCENARIOS = [
    'scenario_simple',
    'scenario_simple_list',
    'scenario_nested',
    'scenario_nested_list',
    'scenario_double_nested'
]

@pytest.mark.parametrize(
    'kwargs_factory',
    [
        lambda data: {'data': data},
        lambda data: {'formdata': formdata_mangle(data)},
        lambda data: data,
    ], ids=[
        'data', 'formdata', 'kwargs'
    ]
)
@pytest.mark.parametrize(
    'data',
    ['valid', 'bad'],
    indirect=True
)
@pytest.mark.parametrize(
    'scenario',
    SCENARIOS,
    indirect=True
)
def test_process_data(scenario, data, kwargs_factory):
    form = scenario.form()
    kwargs = kwargs_factory(data)
    form.process(**kwargs)
    assert form.data == data


@pytest.mark.parametrize(
    'data',
    ['valid'],
    indirect=True
)
@pytest.mark.parametrize(
    'scenario',
    SCENARIOS,
    indirect=True
)
def test_validate_valid(scenario, data):
    form = scenario.form(data=data)
    assert form.validate()

    form = scenario.form()
    form.process(data=data)
    assert form.validate()


@pytest.mark.parametrize(
    'data',
    ['bad'],
    indirect=True
)
@pytest.mark.parametrize(
    'scenario',
    SCENARIOS,
    indirect=True
)
def test_validate_bad(scenario, data):
    form = scenario.form(data=data)
    assert not form.validate()

    form = scenario.form()
    form.process(data=data)
    assert not form.validate()


@pytest.mark.parametrize(
    'data',
    ['valid'],
    indirect=True
)
@pytest.mark.parametrize(
    'scenario',
    SCENARIOS,
    indirect=True
)
def test_errors_valid(scenario, data):
    form = scenario.form(data=data)
    assert form.errors == {}

import pprint
@pytest.mark.parametrize(
    'data, errors_factory',
    [
        ('bad', lambda s: s.errors.bad),
        ('missing', lambda s: s.errors.missing),
    ],
    indirect=['data']
)
@pytest.mark.parametrize(
    'scenario',
    SCENARIOS,
    indirect=True
)
def test_errors_invalid(scenario, data, errors_factory):
    form = scenario.form(data=data)

    form.validate()
    assert form.errors
    print()
    pprint.pprint(form.translator.errors)
    pprint.pprint(form.errors)
    for k, expected in errors_factory(scenario).items():
        print(k, expected)
        field_errors = recursive_get(form.errors, *k)
        if isinstance(expected, list):
            errors = [e['type'] for e_list in field_errors for e in e_list]
            assert errors == expected

        else:
            errors = [e['type'] for e in field_errors]
            assert len(errors) == 1
            assert errors[0] == expected
from pydantic_form.translator import SchemaToForm

@pytest.mark.parametrize(
    'data',
    ['valid'],
    indirect=True
)
@pytest.mark.parametrize(
    'scenario',
    SCENARIOS,
    indirect=True
)
def test_baked_instance(scenario, data):
    form = scenario.form(data=data)

    form.validate()

    assert hasattr(form, '_baked_instance')
    assert form._baked_instance is not None
    assert form._baked_instance.dict() == data

    for key, sub_form in iter_form(form, leafs_only=False):

        print(key, sub_form)
        sub_form = SchemaToForm.get_field(form, key)
        print(key, sub_form)
        if isinstance(sub_form, FormField):
            print('?')
            assert hasattr(sub_form, '_baked_instance')
            assert sub_form._baked_instance is not None
            assert sub_form._baked_instance.dict() == recursive_get(data, *key)