pydantic_form/tests/test_process.py

import pytest
from wtforms import FormField, FieldList

from pydantic_form.translator import iter_form, SchemaToForm
from pydantic_form.utils import recursive_get, formdata_mangle, nested_dict_iter, rgetattr
from unittest.mock import MagicMock, Mock

@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'
]


def make_mock(**attrs):
    m = Mock()
    for k, v in attrs.items():
        if isinstance(v, dict):
            setattr(m, k, make_mock(**v))
        else:
            setattr(m, k, v)
    return m


@pytest.mark.parametrize(
    'kwargs_factory',
    [
        lambda data: {'data': data},
        lambda data: {'formdata': formdata_mangle(data)},
        lambda data: {'obj': make_mock(**data)},
        lambda data: data,
    ], ids=[
        'data', 'formdata', 'obj', 'kwargs'
    ]
)
@pytest.mark.parametrize(
    'data',
    ['valid', 'bad', 'missing', 'mixed'],
    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)

    for key, value in nested_dict_iter(data, iter_list=True):
        assert SchemaToForm.get_item(form.data, key) == value


@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', 'missing', 'mixed'],
    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 == {}

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

    form.validate()
    assert form.errors
    assert form.errors.keys() == expected_errors.keys()

    for k, expected in nested_dict_iter(expected_errors, iter_list=True):
        field_errors = SchemaToForm.get_item(form.errors, k)
        errors = [e['type'] for e in field_errors]
        assert len(errors) == 1
        assert errors[0] == expected

    assert (
        dict(nested_dict_iter(form.errors)).keys()
        == dict(nested_dict_iter(expected_errors)).keys()
    )

@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):
        sub_form = SchemaToForm.get_field(form, key)
        if isinstance(sub_form, FormField):
            assert hasattr(sub_form, '_baked_instance')
            assert sub_form._baked_instance is not None
            assert sub_form._baked_instance.dict() == SchemaToForm.get_item(data, key)