pydantic_form/tests/conftest.py

import pytest
import factory
from collections import namedtuple
from wtforms import Form, fields
from werkzeug.datastructures import ImmutableMultiDict
from pydantic_form import PydanticForm
from pydantic import BaseModel, ValidationError


ScenarioClasses = namedtuple(
    "ScenarioClasses",
    ['wtf_form', 'pydantic_form', 'schema', 'data_factory', 'bad_data_factory', 'keys']
)

ScenarioInstances = namedtuple(
    "ScenarioInstances",
    [
        'wtf', 'wtf_formdata',
        'pydantic', 'pydantic_formdata',
        'formdata', 'data',
        'schema'
    ]
)


@pytest.fixture(scope="session")
def instance_factory():
    def _factory(scenario_classes, data):
        formdata = ImmutableMultiDict(data)
        try:
            schema_instance = scenario_classes.schema(**data)
        except ValidationError as e:
            schema_instance = None
        return ScenarioInstances(
            scenario_classes.wtf_form(data=data),
            scenario_classes.wtf_form(formdata=formdata),
            scenario_classes.pydantic_form(data=data),
            scenario_classes.pydantic_form(formdata=formdata),
            formdata,
            data,
            schema_instance
        )
    return _factory

simple_keys = [('integer',), ('string',)]

class SimpleSchema(BaseModel):
    integer: int
    string: str


class SimpleWTForm(Form):
    _schema = SimpleSchema

    integer = fields.IntegerField()
    string = fields.StringField()


class SimpleForm(SimpleWTForm, PydanticForm):
    _schema = SimpleSchema


@pytest.fixture(scope="session")
def scenario_classes_simple():
    return ScenarioClasses(
        SimpleWTForm, SimpleForm,
        SimpleSchema,
        SimpleDataFactory, SimpleBadDataFactory,
        simple_keys
    )


class SimpleDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pyint')
    string = factory.Faker('pystr')

class SimpleBadDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pystr')
    string = factory.Faker('pyint')


@pytest.fixture
def scenario_simple(instance_factory, scenario_classes_simple):
    return instance_factory(scenario_classes_simple, SimpleDataFactory())


@pytest.fixture
def scenario_simple_bad(instance_factory, scenario_classes_simple):
    return instance_factory(scenario_classes_simple, SimpleBadDataFactory())


nested_keys = [('integer',), ('nested', 'integer'), ('nested', 'string')]

class NestedSchema(BaseModel):
    integer: int
    nested: SimpleSchema


class NestedWTForm(Form):
    _schema = NestedSchema

    integer = fields.IntegerField()
    nested = fields.FormField(form_class=SimpleForm)


class NestedForm(NestedWTForm, PydanticForm):
    _schema = NestedSchema


class NestedDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pyint')
    nested = factory.SubFactory(SimpleDataFactory)


class NestedBadDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pystr')
    nested = factory.SubFactory(SimpleBadDataFactory)


@pytest.fixture(scope="session")
def scenario_classes_nested():
    return ScenarioClasses(
        NestedWTForm, NestedForm,
        NestedSchema,
        NestedDataFactory, NestedBadDataFactory,
        nested_keys
    )


@pytest.fixture
def scenario_nested(instance_factory, scenario_classes_nested):
    return instance_factory(scenario_classes_nested, NestedDataFactory())


@pytest.fixture
def scenario_nested_bad(instance_factory, scenario_classes_nested):
    return instance_factory(scenario_classes_nested, NestedBadDataFactory())