import itertools
from datetime import timedelta
from decimal import Decimal
from random import choice  # noqa
from unittest.mock import patch

from django.db import connection
from django.utils.timezone import now

import pytest

from model_bakery import baker
from model_bakery.exceptions import InvalidQuantityException, RecipeIteratorEmpty
from model_bakery.recipe import Recipe, RecipeForeignKey, foreign_key, seq
from model_bakery.timezone import tz_aware
from tests.generic.baker_recipes import SmallDogRecipe, pug
from tests.generic.models import (
    TEST_TIME,
    Dog,
    DummyBlankFieldsModel,
    DummyNumbersModel,
    LonelyPerson,
    ModelWithAutoNowFields,
    Person,
    Profile,
    User,
)

recipe_attrs = {
    "name": "John Doe",
    "nickname": "joe",
    "age": 18,
    "bio": "Someone in the crowd",
    "birthday": now().date(),
    "appointment": now(),
    "blog": "https://joe.example.com",
    "days_since_last_login": 4,
    "birth_time": now(),
    "data": {"one": 1},
}
person_recipe = Recipe(Person, **recipe_attrs)
user_recipe = Recipe(User)
lonely_person_recipe = Recipe(LonelyPerson)


def test_import_seq_from_recipe():
    """Import seq method directly from recipe module."""
    try:
        from model_bakery.recipe import seq  # NoQA
    except ImportError:
        pytest.fail(f"{ImportError.__name__} raised")


def test_import_recipes():
    """Test imports works both for full import paths and for `app_name.recipe_name` strings."""
    assert baker.prepare_recipe("generic.dog"), baker.prepare_recipe(
        "tests.generic.dog"
    )


@pytest.mark.django_db
class TestDefiningRecipes:
    def test_flat_model_make_recipe_with_the_correct_attributes(self):
        """Test a 'flat model' - without associations, like FK, M2M and O2O."""
        person = person_recipe.make()
        assert person.name == recipe_attrs["name"]
        assert person.nickname == recipe_attrs["nickname"]
        assert person.age == recipe_attrs["age"]
        assert person.bio == recipe_attrs["bio"]
        assert person.birthday == recipe_attrs["birthday"]
        assert person.appointment == recipe_attrs["appointment"]
        assert person.blog == recipe_attrs["blog"]
        assert person.days_since_last_login == recipe_attrs["days_since_last_login"]
        assert person.data is not recipe_attrs["data"]
        assert person.data == recipe_attrs["data"]
        assert person.id is not None

    def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
        person = person_recipe.prepare()
        assert person.name == recipe_attrs["name"]
        assert person.nickname == recipe_attrs["nickname"]
        assert person.age == recipe_attrs["age"]
        assert person.bio == recipe_attrs["bio"]
        assert person.birthday == recipe_attrs["birthday"]
        assert person.appointment == recipe_attrs["appointment"]
        assert person.blog == recipe_attrs["blog"]
        assert person.days_since_last_login == recipe_attrs["days_since_last_login"]
        assert person.data is not recipe_attrs["data"]
        assert person.data == recipe_attrs["data"]
        assert person.id is None

    def test_accepts_callable(self):
        r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: "callable!!")
        value = r.make().blank_char_field
        assert value == "callable!!"

    def test_always_calls_when_creating(self):
        with patch("tests.test_recipes.choice") as choice_mock:
            choice_mock.return_value = "foo"
            lst = ["foo", "bar", "spam", "eggs"]
            r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: choice_mock(lst))
            assert r.make().blank_char_field
            assert r.make().blank_char_field
            assert choice_mock.call_count == 2

    def test_always_calls_with_quantity(self):
        with patch("tests.test_recipes.choice") as choice_mock:
            choice_mock.return_value = "foo"
            lst = ["foo", "bar", "spam", "eggs"]
            r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: choice_mock(lst))
            r.make(_quantity=3)
            assert choice_mock.call_count == 3

    def test_make_recipes_with_args(self):
        """Overriding some fields values at recipe execution."""
        person = person_recipe.make(name="Guido", age=56)
        assert person.name != recipe_attrs["name"]
        assert person.name == "Guido"

        assert person.age != recipe_attrs["age"]
        assert person.age == 56

        assert person.nickname == recipe_attrs["nickname"]
        assert person.bio == recipe_attrs["bio"]
        assert person.birthday == recipe_attrs["birthday"]
        assert person.appointment == recipe_attrs["appointment"]
        assert person.blog == recipe_attrs["blog"]
        assert person.days_since_last_login == recipe_attrs["days_since_last_login"]
        assert person.id is not None

    def test_prepare_recipes_with_args(self):
        """Overriding some fields values at recipe execution."""
        person = person_recipe.prepare(name="Guido", age=56)
        assert person.name != recipe_attrs["name"]
        assert person.name == "Guido"

        assert person.age != recipe_attrs["age"]
        assert person.age == 56

        assert person.nickname == recipe_attrs["nickname"]
        assert person.bio == recipe_attrs["bio"]
        assert person.birthday == recipe_attrs["birthday"]
        assert person.appointment == recipe_attrs["appointment"]
        assert person.blog == recipe_attrs["blog"]
        assert person.days_since_last_login == recipe_attrs["days_since_last_login"]
        assert person.id is None

    def test_make_recipe_without_all_model_needed_data(self):
        person_recipe = Recipe(Person, name="John Doe")
        person = person_recipe.make()
        assert person.name == "John Doe"
        assert person.nickname
        assert person.age
        assert person.bio
        assert person.birthday
        assert person.appointment
        assert person.blog
        assert person.days_since_last_login
        assert person.id

    def test_prepare_recipe_without_all_model_needed_data(self):
        person_recipe = Recipe(Person, name="John Doe")
        person = person_recipe.prepare()
        assert person.name == "John Doe"
        assert person.nickname
        assert person.age
        assert person.bio
        assert person.birthday
        assert person.appointment
        assert person.blog
        assert person.days_since_last_login
        assert not person.id

    def test_defining_recipes_str(self):
        p = Recipe("generic.Person", name=seq("foo"))
        try:
            p.make(_quantity=5)
        except AttributeError as e:
            pytest.fail(f"{e}")

    def test_recipe_dict_attribute_isolation(self):
        person1 = person_recipe.make()
        person2 = person_recipe.make()
        person2.data["two"] = 2
        person3 = person_recipe.make()

        # Mutation on instances must have no side effect on their recipe definition,
        # or on other instances of the same recipe.
        assert person1.data == {"one": 1}
        assert person2.data == {"one": 1, "two": 2}
        assert person3.data == {"one": 1}

    @pytest.mark.skipif(
        connection.vendor != "postgresql", reason="PostgreSQL specific tests"
    )
    def test_recipe_list_attribute_isolation(self):
        pg_person_recipe = person_recipe.extend(acquaintances=[1, 2, 3])
        person1 = pg_person_recipe.make()
        person2 = pg_person_recipe.make()
        person2.acquaintances.append(4)
        person3 = pg_person_recipe.make()

        # Mutation on instances must have no side effect on their recipe definition,
        # or on other instances of the same recipe.
        assert person1.acquaintances == [1, 2, 3]
        assert person2.acquaintances == [1, 2, 3, 4]
        assert person3.acquaintances == [1, 2, 3]


@pytest.mark.django_db
class TestExecutingRecipes:
    """Tests for calling recipes defined in baker_recipes.py."""

    def test_model_with_foreign_key(self):
        dog = baker.make_recipe("tests.generic.dog")
        assert dog.breed == "Pug"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id

        dog = baker.prepare_recipe("tests.generic.dog")
        assert dog.breed == "Pug"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id is None

        dog = baker.prepare_recipe("tests.generic.dog", _save_related=True)
        assert dog.breed == "Pug"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id

        dogs = baker.make_recipe("tests.generic.dog", _quantity=2)
        owner = dogs[0].owner
        for dog in dogs:
            assert dog.breed == "Pug"
            assert dog.owner == owner

    def test_model_with_foreign_key_as_str(self):
        dog = baker.make_recipe("tests.generic.other_dog")
        assert dog.breed == "Basset"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id

        dog = baker.prepare_recipe("tests.generic.other_dog")
        assert dog.breed == "Basset"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id is None

    def test_model_with_foreign_key_as_unicode(self):
        dog = baker.make_recipe("tests.generic.other_dog_unicode")
        assert dog.breed == "Basset"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id

        dog = baker.prepare_recipe("tests.generic.other_dog_unicode")
        assert dog.breed == "Basset"
        assert isinstance(dog.owner, Person)
        assert dog.owner.id is None

    def test_make_recipe(self):
        person = baker.make_recipe("tests.generic.person")
        assert isinstance(person, Person)
        assert person.id

    def test_make_recipe_with_quantity_parameter(self):
        people = baker.make_recipe("tests.generic.person", _quantity=3)
        assert len(people) == 3
        for person in people:
            assert isinstance(person, Person)
            assert person.id

    def test_make_extended_recipe(self):
        extended_dog = baker.make_recipe("tests.generic.extended_dog")
        assert extended_dog.breed == "Super basset"
        # No side effects happened due to a recipe extension
        base_dog = baker.make_recipe("tests.generic.dog")
        assert base_dog.breed == "Pug"

    def test_extended_recipe_type(self):
        assert isinstance(pug, SmallDogRecipe)

    def test_save_related_instances_on_prepare_recipe(self):
        dog = baker.prepare_recipe("tests.generic.homeless_dog")
        assert not dog.id
        assert not dog.owner_id

        dog = baker.prepare_recipe("tests.generic.homeless_dog", _save_related=True)
        assert not dog.id
        assert dog.owner.id

    def test_make_recipe_with_quantity_parameter_respecting_model_args(self):
        people = baker.make_recipe(
            "tests.generic.person", _quantity=3, name="Dennis Ritchie", age=70
        )
        assert len(people) == 3
        for person in people:
            assert person.name == "Dennis Ritchie"
            assert person.age == 70

    def test_make_recipe_raises_correct_exception_if_invalid_quantity(self):
        with pytest.raises(InvalidQuantityException):
            baker.make_recipe("tests.generic.person", _quantity="hi")
        with pytest.raises(InvalidQuantityException):
            baker.make_recipe("tests.generic.person", _quantity=-1)

    def test_prepare_recipe_with_foreign_key(self):
        person_recipe = Recipe(Person, name="John Doe")
        dog_recipe = Recipe(
            Dog,
            owner=foreign_key(person_recipe),
        )
        dog = dog_recipe.prepare()

        assert dog.id is None
        assert dog.owner.id is None

    def test_prepare_recipe_with_quantity_parameter(self):
        people = baker.prepare_recipe("tests.generic.person", _quantity=3)
        assert len(people) == 3
        for person in people:
            assert isinstance(person, Person)
            assert person.id is None

    def test_prepare_recipe_with_quantity_parameter_respecting_model_args(self):
        people = baker.prepare_recipe(
            "tests.generic.person", _quantity=3, name="Dennis Ritchie", age=70
        )
        assert len(people) == 3
        for person in people:
            assert person.name == "Dennis Ritchie"
            assert person.age == 70

    def test_prepare_recipe_raises_correct_exception_if_invalid_quantity(self):
        with pytest.raises(InvalidQuantityException):
            baker.prepare_recipe("tests.generic.person", _quantity="hi")
        with pytest.raises(InvalidQuantityException):
            baker.prepare_recipe("tests.generic.person", _quantity=-1)

    def test_prepare_recipe(self):
        person = baker.prepare_recipe("tests.generic.person")
        assert isinstance(person, Person)
        assert not person.id

    def test_make_recipe_with_args(self):
        person = baker.make_recipe(
            "tests.generic.person", name="Dennis Ritchie", age=70
        )
        assert person.name == "Dennis Ritchie"
        assert person.age == 70

    def test_prepare_recipe_with_args(self):
        person = baker.prepare_recipe(
            "tests.generic.person", name="Dennis Ritchie", age=70
        )
        assert person.name == "Dennis Ritchie"
        assert person.age == 70

    def test_import_recipe_inside_deeper_modules(self):
        recipe_name = "tests.generic.tests.sub_package.person"
        person = baker.prepare_recipe(recipe_name)
        assert person.name == "John Deeper"

    def test_pass_save_kwargs(self):
        owner = baker.make(Person)

        dog = baker.make_recipe(
            "tests.generic.overwritten_save", _save_kwargs={"owner": owner}
        )
        assert owner == dog.owner

    def test_pass_save_kwargs_in_recipe_definition(self):
        dog = baker.make_recipe("tests.generic.with_save_kwargs")
        assert dog.breed == "updated_breed"

    def test_ip_fields_with_start(self):
        first, second = baker.make_recipe("tests.generic.ip_fields", _quantity=2)

        assert first.ipv4_field == "127.0.0.2"
        assert first.ipv6_field == "2001:12f8:0:28::4"
        assert second.ipv4_field == "127.0.0.4"
        assert second.ipv6_field == "2001:12f8:0:28::6"


@pytest.mark.django_db
class TestForeignKey:
    def test_foreign_key_method_returns_a_recipe_foreign_key_object(self):
        number_recipe = Recipe(DummyNumbersModel, float_field=1.6)
        obj = foreign_key(number_recipe)
        assert isinstance(obj, RecipeForeignKey)

    def test_not_accept_other_type(self):
        with pytest.raises(TypeError) as c:
            foreign_key(2)
        exception = c.value
        assert str(exception) == "Not a recipe"

    def test_load_from_other_module_recipe(self):
        dog = Recipe(Dog, owner=foreign_key("tests.generic.person")).make()
        assert dog.owner.name == "John Doe"

    def test_fail_load_invalid_recipe(self):
        with pytest.raises(AttributeError):
            foreign_key("tests.generic.nonexisting_recipe")

    def test_class_directly_with_string(self):
        with pytest.raises(TypeError):
            RecipeForeignKey("foo")

    def test_do_not_create_related_model(self):
        """It should not create another object when passing the object as argument."""
        person = baker.make_recipe("tests.generic.person")
        assert Person.objects.count() == 1
        baker.make_recipe("tests.generic.dog", owner=person)
        assert Person.objects.count() == 1
        baker.prepare_recipe("tests.generic.dog", owner=person)
        assert Person.objects.count() == 1

    def test_do_query_lookup_for_recipes_make_method(self):
        """It should not create another object when using query lookup syntax."""
        dog = baker.make_recipe("tests.generic.dog", owner__name="James")
        assert Person.objects.count() == 1
        assert dog.owner.name == "James"

    def test_do_query_lookup_for_recipes_prepare_method(self):
        """It should not create another object when using query lookup syntax."""
        dog = baker.prepare_recipe("tests.generic.dog", owner__name="James")
        assert dog.owner.name == "James"

    def test_do_query_lookup_empty_recipes(self):
        """It should not create another object when using query lookup syntax."""
        dog_recipe = Recipe(Dog)
        dog = dog_recipe.make(owner__name="James")
        assert Person.objects.count() == 1
        assert dog.owner.name == "James"

        dog = dog_recipe.prepare(owner__name="Zezin")
        assert Person.objects.count() == 1
        assert dog.owner.name == "Zezin"

    def test_related_models_recipes(self):
        lady = baker.make_recipe("tests.generic.dog_lady")
        assert lady.dog_set.count() == 2
        assert lady.dog_set.all()[0].breed == "Pug"
        assert lady.dog_set.all()[1].breed == "Basset"

    def test_related_models_recipes_make_mutiple(self):
        ladies = baker.make_recipe("tests.generic.dog_lady", _quantity=2)
        assert ladies[0].dog_set.count() == 2
        assert ladies[1].dog_set.count() == 2

    def test_nullable_related(self):
        nullable = baker.make_recipe("tests.generic.nullable_related")
        assert nullable.dummynullfieldsmodel_set.count() == 1

    def test_chained_related(self):
        movie = baker.make_recipe("tests.generic.movie_with_cast")
        assert movie.cast_members.count() == 2

    def test_one_to_one_relationship(self):
        lonely_people = baker.make_recipe("tests.generic.lonely_person", _quantity=2)
        friend_ids = {x.only_friend.id for x in lonely_people}
        assert len(friend_ids) == 2


@pytest.mark.django_db
class TestM2MField:
    def test_create_many_to_many(self):
        dog = baker.make_recipe("tests.generic.dog_with_friends")
        assert len(dog.friends_with.all()) == 2
        for friend in dog.friends_with.all():
            assert friend.breed == "Pug"
            assert friend.owner.name == "John Doe"

    def test_create_nested(self):
        dog = baker.make_recipe("tests.generic.dog_with_more_friends")
        assert len(dog.friends_with.all()) == 1
        friend = dog.friends_with.all()[0]
        assert len(friend.friends_with.all()) == 2


@pytest.mark.django_db
class TestSequences:
    def test_increment_for_strings(self):
        person = baker.make_recipe("tests.generic.serial_person")
        assert person.name == "joe1"
        person = baker.prepare_recipe("tests.generic.serial_person")
        assert person.name == "joe2"
        person = baker.make_recipe("tests.generic.serial_person")
        assert person.name == "joe3"

    def test_increment_for_strings_with_suffix(self):
        fred_person = person_recipe.extend(email=seq("fred", suffix="@example.com"))
        person = fred_person.make()
        assert person.email == "fred1@example.com"
        person = fred_person.make()
        assert person.email == "fred2@example.com"
        person = fred_person.make()
        assert person.email == "fred3@example.com"

    def test_increment_for_fks(self):
        profiles = baker.make(Profile, _quantity=3)
        start_id = profiles[0].id
        seq_user = user_recipe.extend(username="name", profile_id=seq(start_id))
        user = seq_user.make()
        assert user.profile_id == start_id + 1
        user = seq_user.make()
        assert user.profile_id == start_id + 2

    def test_increment_for_one_to_one(self):
        people = baker.make(Person, _quantity=3)
        start_id = people[0].id
        seq_lonely_person = lonely_person_recipe.extend(only_friend_id=seq(start_id))
        person = seq_lonely_person.make()
        assert person.only_friend_id == start_id + 1
        user = seq_lonely_person.make()
        assert user.only_friend_id == start_id + 2

    def test_increment_for_strings_with_bad_suffix(self):
        bob_person = person_recipe.extend(email=seq("bob", suffix=42))
        with pytest.raises(TypeError) as exc:
            bob_person.make()
            assert str(exc.value) == "Sequences suffix can only be a string"

    def test_increment_for_strings_with_suffix_and_start(self):
        fred_person = person_recipe.extend(
            email=seq("fred", start=5, suffix="@example.com")
        )
        person = fred_person.make()
        assert person.email == "fred5@example.com"
        person = fred_person.make()
        assert person.email == "fred6@example.com"
        person = fred_person.make()
        assert person.email == "fred7@example.com"

    def test_increment_for_numbers(self):
        dummy = baker.make_recipe("tests.generic.serial_numbers")
        assert dummy.default_int_field == 11
        assert dummy.default_decimal_field == Decimal("21.1")
        assert dummy.default_float_field == 2.23
        dummy = baker.make_recipe("tests.generic.serial_numbers")
        assert dummy.default_int_field == 12
        assert dummy.default_decimal_field == Decimal("22.1")
        assert dummy.default_float_field == 3.23
        dummy = baker.prepare_recipe("tests.generic.serial_numbers")
        assert dummy.default_int_field == 13
        assert dummy.default_decimal_field == Decimal("23.1")
        assert dummy.default_float_field == 4.23

    def test_increment_for_numbers_2(self):
        """Repeated test to ensure Sequences atomicity."""
        dummy = baker.make_recipe("tests.generic.serial_numbers")
        assert dummy.default_int_field == 11
        assert dummy.default_decimal_field == Decimal("21.1")
        assert dummy.default_float_field == 2.23
        dummy = baker.make_recipe("tests.generic.serial_numbers")
        assert dummy.default_int_field == 12
        assert dummy.default_decimal_field == Decimal("22.1")
        assert dummy.default_float_field == 3.23
        dummy = baker.prepare_recipe("tests.generic.serial_numbers")
        assert dummy.default_int_field == 13
        assert dummy.default_decimal_field == Decimal("23.1")
        assert dummy.default_float_field == 4.23

    def test_increment_for_numbers_with_suffix(self):
        with pytest.raises(TypeError) as exc:
            baker.make_recipe(
                "tests.generic.serial_numbers",
                default_int_field=seq(1, suffix="will not work"),
            )
            assert (
                str(exc.value)
                == "Sequences with suffix can only be used with text values"
            )

    def test_creates_unique_field_recipe_using_for_iterator(self):
        for i in range(1, 4):
            dummy = baker.make_recipe("tests.generic.dummy_unique_field")
            assert dummy.value == 10 + i

    def test_creates_unique_field_recipe_using_quantity_argument(self):
        dummies = baker.make_recipe("tests.generic.dummy_unique_field", _quantity=3)
        assert dummies[0].value == 11
        assert dummies[1].value == 12
        assert dummies[2].value == 13

    def test_increment_by_3(self):
        dummy = baker.make_recipe("tests.generic.serial_numbers_by")
        assert dummy.default_int_field == 13
        assert dummy.default_decimal_field == Decimal("22.5")
        assert dummy.default_float_field == pytest.approx(3.030000)
        dummy = baker.make_recipe("tests.generic.serial_numbers_by")
        assert dummy.default_int_field == 16
        assert dummy.default_decimal_field == Decimal("24.9")
        assert dummy.default_float_field == pytest.approx(4.83)
        dummy = baker.prepare_recipe("tests.generic.serial_numbers_by")
        assert dummy.default_int_field == 19
        assert dummy.default_decimal_field == Decimal("27.3")
        assert dummy.default_float_field == pytest.approx(6.63)

    def test_increment_by_timedelta(self):
        dummy = baker.make_recipe("tests.generic.serial_datetime")
        assert dummy.default_date_field == (TEST_TIME.date() + timedelta(days=1))
        assert dummy.default_date_time_field == tz_aware(TEST_TIME + timedelta(hours=3))
        assert dummy.default_time_field == (TEST_TIME + timedelta(seconds=15)).time()
        dummy = baker.make_recipe("tests.generic.serial_datetime")
        assert dummy.default_date_field == (TEST_TIME.date() + timedelta(days=2))
        assert dummy.default_date_time_field == tz_aware(TEST_TIME + timedelta(hours=6))
        assert dummy.default_time_field == (TEST_TIME + timedelta(seconds=30)).time()

    def test_increment_by_timedelta_seq_combined_with_quantity(self):
        quantity = 5
        entries = baker.make_recipe("tests.generic.serial_datetime", _quantity=quantity)
        for i, e in enumerate(entries):
            index = i + 1
            assert e.default_date_field == (
                TEST_TIME.date() + timedelta(days=1 * index)
            )
            assert e.default_date_time_field == tz_aware(
                TEST_TIME + timedelta(hours=3 * index)
            )
            assert (
                e.default_time_field
                == (TEST_TIME + timedelta(seconds=15 * index)).time()
            )

    def test_creates_unique_timedelta_recipe_using_quantity_argument(self):
        dummies = baker.make_recipe("tests.generic.serial_datetime", _quantity=3)
        assert dummies[0].default_date_field == TEST_TIME.date() + timedelta(days=1)
        assert dummies[1].default_date_field == TEST_TIME.date() + timedelta(days=2)
        assert dummies[2].default_date_field == TEST_TIME.date() + timedelta(days=3)

    def test_increment_after_override_definition_field(self):
        person = baker.make_recipe("tests.generic.serial_person", name="tom")
        assert person.name == "tom"
        person = baker.make_recipe("tests.generic.serial_person")
        assert person.name == "joe4"
        person = baker.prepare_recipe("tests.generic.serial_person")
        assert person.name == "joe5"


@pytest.mark.django_db
class TestIterators:
    def test_accepts_generators(self):
        r = Recipe(DummyBlankFieldsModel, blank_char_field=itertools.cycle(["a", "b"]))
        assert r.make().blank_char_field == "a"
        assert r.make().blank_char_field == "b"
        assert r.make().blank_char_field == "a"

    def test_accepts_iterators(self):
        r = Recipe(DummyBlankFieldsModel, blank_char_field=iter(["a", "b", "c"]))
        assert r.make().blank_char_field == "a"
        assert r.make().blank_char_field == "b"
        assert r.make().blank_char_field == "c"

    def test_empty_iterator_exception(self):
        r = Recipe(DummyBlankFieldsModel, blank_char_field=iter(["a", "b"]))
        assert r.make().blank_char_field == "a"
        assert r.make().blank_char_field == "b"
        with pytest.raises(RecipeIteratorEmpty):
            r.make()

    def test_only_iterators_not_iteratables_are_iterated(self):
        """Ensure we only iterate explicit iterators.

        Consider "iterable" vs "iterator":

        Something like a string is "iterable", but not an "iterator". We don't
        want to iterate "iterables", only explicit "iterators".

        """
        r = Recipe(
            DummyBlankFieldsModel, blank_text_field="not an iterator, so don't iterate!"
        )
        assert r.make().blank_text_field == "not an iterator, so don't iterate!"


class TestAutoNowFields:
    @pytest.mark.django_db
    def test_make_with_auto_now_using_datetime_generator(self):
        delta = timedelta(minutes=1)

        def gen():
            idx = 0
            while True:
                idx += 1
                yield tz_aware(TEST_TIME) + idx * delta

        r = Recipe(
            ModelWithAutoNowFields,
            created=gen(),
        )

        assert r.make().created == tz_aware(TEST_TIME + 1 * delta)
        assert r.make().created == tz_aware(TEST_TIME + 2 * delta)

    @pytest.mark.django_db
    def test_make_with_auto_now_using_datetime_seq(self):
        delta = timedelta(minutes=1)
        r = Recipe(
            ModelWithAutoNowFields,
            created=seq(
                tz_aware(TEST_TIME),
                increment_by=delta,
            ),
        )

        assert r.make().created == tz_aware(TEST_TIME + 1 * delta)
        assert r.make().created == tz_aware(TEST_TIME + 2 * delta)