How to deterministically create the same objects

[Gitznik]

Hi there,

I'm trying to use polyfactory in combination with syrupy. I'm struggling with the issue that even if I set

    __allow_none_optionals__ = False
    __random__ = random.Random(10)
    __random_seed__ = 1
    __faker__ = Faker()

I still get different objects in each of my test, and (what's my bigger problem), I get different objects depending on how many of my tests I run.

Is it possible to set polyfactory up in a way that each build() always creates the exact same object? Or at least have the factory reset itself between tests, so only subsequent builds within the same test create different results?

Minimal Example:

This runs fine

from faker import Faker
import pytest
from polyfactory.factories.pydantic_factory import ModelFactory

from enum import Enum
from pydantic import BaseModel


class DataType(str, Enum):
    P_A = "A"
    P_B = "B"
    P_C = "C"


class Data(BaseModel):
    data_type: DataType
    value: int


class Report(BaseModel):
    inputs: list[Data]


class DataFactory(ModelFactory[Data]):
    __allow_none_optionals__ = False
    __random_seed__ = 1
    __set_as_default_factory_for_type__ = True


class ReportFactory(ModelFactory[Report]):
    __allow_none_optionals__ = False
    __random_seed__ = 1


@pytest.fixture(scope="function", autouse=True)
def faker_seed():
    return 42



def test_creation1(faker: Faker, faker_seed):
    ReportFactory.__faker__ = faker
    data = ReportFactory.build()
    assert data.model_dump(mode="json") == {
        "inputs": [{"data_type": "A", "value": 2201}]
    }


def test_creation2(faker: Faker, faker_seed):
    ReportFactory.__faker__ = faker
    data = ReportFactory.build()
    assert data.model_dump(mode="json") == {
        "inputs": [{"data_type": "C", "value": 9325}]
    }

if I now add

def test_creation0(faker: Faker, faker_seed):
    ReportFactory.__faker__ = faker
    data = ReportFactory.build()
    assert data.model_dump(mode="json") == {
        "inputs": [{"data_type": "A", "value": 2201}]
    }

both my existing tests fail, while this new one works. It essentially takes the result that otherwise test_creation1 would have had, which in turn takes the result that otherwise test_creation2 would have had.

[Alc-Was-Taken]

Heya, does #460 help?

[Gitznik]

Unfortunately, no. Running build in 2 different tests with that setup still creates 2 different results. They are deterministically the same every time, but they are different.
Say I create a 3rd test, that also runs that build, and that one runs first -> the data in the first 2 tests will now be different, which would fail the syrupy tests.

[vkcku]

You could do the following:

@pytest.fixture(autouse=True)
def seed_factories(faker: Faker) -> None:
    ModelFactory.__faker__ = faker
    ModelFactory.__random__.seed(1) # you could use `faker_seed` here as well

A few points to note:

• There is a seed_random method on the factories, but using that won't work as expected because that also reseeds the underlying Faker instance being used by the factory.
• If you've overriden the __faker__ or __random__ instance on any of the factories you've created, then this won't have any affect since then those factories will use that instance instead of the one from ModelFactory. In that case, you'll have to explicitly do the same as above for all those factories as well.

[Gitznik]

This did it, thank you!