def setUpClass(cls):
        # clear db
        models.User.objects.all().delete()
        models.Activity.objects.all().delete()

        cls.assertStrEqual = lambda cls, x, y: cls.assertEqual(str(x), str(y))

        employee = recipe.Recipe(models.Employee,
                                 id=1,
                                 first_name='Jan',
                                 last_name='Wójt')
        company = recipe.Recipe(models.CoffeeCompany,
                                id=2,
                                full_name='Kawa')
        activity1 = recipe.Recipe(models.Activity,
                                  id=1,
                                  creator=recipe.foreign_key(employee),
                                  target=recipe.foreign_key(company),
                                  content='Jan Wójt drinked coffee from Kawa')
        activity2 = recipe.Recipe(models.Activity,
                                  id=2,
                                  creator=recipe.foreign_key(company),
                                  target=recipe.foreign_key(employee),
                                  content='Kawa delivered product to Jan Wójt')

        employee.make()
        company.make()
        activity1.make()
        activity2.make()

 def test_returns_a_callable(self):
     number_recipe = Recipe(DummyNumbersModel,
         float_field = 1.6
     )
     method = foreign_key(number_recipe)
     self.assertTrue(callable(method))
     self.assertTrue(method.im_self, number_recipe)

    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()

        self.assertIsNone(dog.id)
        self.assertIsNone(dog.owner.id)

    pension=MoneyInterval('per_month', pennies=0),
    other_income=MoneyInterval('per_week', pennies=2200)
)
savings = Recipe(Savings)
deductions = Recipe(Deductions,
                    income_tax = MoneyInterval('per_week', pennies=2200),
                    national_insurance = MoneyInterval('per_4week', pennies=2200),
                    maintenance = MoneyInterval('per_year', pennies=2200),
                    childcare = MoneyInterval('per_week', pennies=2200),
                    mortgage = MoneyInterval('per_week', pennies=2200),
                    rent = MoneyInterval('per_week', pennies=2200)
                    )

person = Recipe(Person)
full_person = Recipe(Person,
    income=foreign_key(income),
    savings=foreign_key(savings),
    deductions=foreign_key(deductions)
)

eligibility_check = Recipe(EligibilityCheck,
    category=foreign_key(category),
    dependants_young=5, dependants_old=6,
    you=foreign_key(person),
    partner=foreign_key(person)
)

eligibility_check_yes = Recipe(EligibilityCheck,
    category=foreign_key(category),
    dependants_young=5, dependants_old=6,
    you=foreign_key(person),

    os.path.join(CUR_DIR, 'kenya_boundary.geojson'))


country_boundary_recipe = Recipe(
    WorldBorder,
    mpoly=_get_mpoly_from_geom(KENYA_BORDER[0].get_geoms()[0])
)


county_recipe = Recipe(
    County
)

county_boundary_recipe = Recipe(
    CountyBoundary,
    area=foreign_key(county_recipe),
    mpoly=_get_mpoly_from_geom(COUNTY_BORDER[0].get_geoms()[0])
)

constituency_recipe = Recipe(
    Constituency,
    county=foreign_key(county_recipe),
)

constituency_boundary_recipe = Recipe(
    ConstituencyBoundary,
    area=foreign_key(constituency_recipe),
    mpoly=_get_mpoly_from_geom(CONSTITUENCY_BORDER[0].get_geoms()[0])
)

an **object-oriented** computer programming language commonly used to
create interactive effects within *web browsers*.''',
    ''''# Python

a *high-level* **general-purpose** _programming language_.''',
]

user = Recipe(
    User,
    email="[email protected]",
    is_active=True
)

category = Recipe(
    Category,
    title=seq('Category'),
    author=foreign_key(user),
    description=cycle('description'),
    _quantity=3
)

article = Recipe(
    Article,
    title=seq('Article'),
    author=foreign_key(user),
    category=foreign_key(category),
    content=cycle(definitions),
    _quantity=5
)

serial_numbers_by = Recipe(DummyDefaultFieldsModel,
    default_decimal_field = seq(Decimal('20.1'), increment_by=Decimal('2.4')),
    default_int_field = seq(10, increment_by=3),
    default_float_field = seq(1.23, increment_by=1.8)
)

serial_datetime = Recipe(DummyDefaultFieldsModel,
    default_date_field = seq(TEST_TIME.date(), timedelta(days=1)),
    default_date_time_field = seq(TEST_TIME, timedelta(hours=3)),
    default_time_field = seq(TEST_TIME.time(), timedelta(seconds=15))
)

dog = Recipe(Dog,
    breed = 'Pug',
    owner = foreign_key(person)
)

other_dog = Recipe(Dog,
    breed = 'Basset',
    owner = foreign_key('person')
)

other_dog_unicode = Recipe(Dog,
    breed = 'Basset',
    owner = foreign_key(u('person'))
)

dummy_unique_field = Recipe(DummyUniqueIntegerFieldModel,
    value = seq(10),
)

    name = 'San Francisco',
    slug = 'san-francisco',
    description = 'San Francisco',
    timezone = '-8.0',
    city = 'San Francisco',
    country = 'US',
    continent = 'NA',
    lat = '0',
    lon = '0',
    private = True
    )

location_mars = Recipe(
    Location,
    name = 'Mars',
    slug = 'mars',
    description = 'Mars',
    timezone = '-8.0',
    city = 'Mars',
    country = 'US',
    continent = 'NA',
    lat = '0',
    lon = '0',
    capacity = '100'
    )

registration = Recipe(
    Registration,
    location = foreign_key(location),
    # user = foreign_key(user),
    )

REPORTER_NAME = 'rep'

public_ci = Recipe(CriticalIncident,
    incident = seq('Critical Incident '),
    public = True
)

published_incident = Recipe(PublishableIncident,
    publish = True,
    critical_incident__public = True,
    critical_incident__department__label = seq('Dept_'),
    critical_incident__department__reporter__user__username = seq(REPORTER_NAME),
)

translated_pi = Recipe(PublishableIncidentTranslation, 
    incident = seq('Published Incident '),
    master = foreign_key(published_incident)
)

reviewer = Recipe(Reviewer,
    user__username = seq('rev'),
    user__email = seq('[email protected]'),
)

reporter = Recipe(Reporter,
    user__username = seq(REPORTER_NAME))

department = Recipe(Department,
    label = seq('Dept_'),
    reporter__user__username = seq(REPORTER_NAME)
)

 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)
     self.assertIsInstance(obj, RecipeForeignKey)

from model_mommy.recipe import Recipe, seq, foreign_key
from ..models import Provider, ProviderAllocation, OutOfHoursRota, Staff, \
    Feedback, CSVUpload


provider = Recipe(Provider,
    name=seq('Name'),
)

staff = Recipe(Staff)

outofhoursrota = Recipe(OutOfHoursRota)

provider_allocation = Recipe(ProviderAllocation)

feedback = Recipe(Feedback, created_by=foreign_key(staff))

csvupload_determination = Recipe(CSVUpload,
                   body=[
                       u'2222222', u'0000', u'1A111A', u'A', u'Corgi',
                       u'01/01/1901', u'D', u'F', u'1', u'', u'', u'SW1A 1AA',
                       u'', u'SWAG', u'YOLO', u'', u'', u'', u'', u'', u'18',
                       u'99.5', u'', u'MOB', u'', u'', u'AAAA', u'', u'', u'',
                       u'NAR', u'', u'', u'TA'
                   ]
)


csvupload_case = \
    Recipe(CSVUpload,
           body=[

              email="[email protected]",
              )

# events; use defaults apart from dates
# override when using recipes, eg. mommy.make_recipe('future_event', cost=10)

event_type_PC = Recipe(EventType, event_type="CL", subtype=seq("Pole level class"))
event_type_PP = Recipe(EventType, event_type="CL", subtype=seq("Pole practice"))
event_type_WS = Recipe(EventType, event_type="EV", subtype=seq("Workshop"))
event_type_OE = Recipe(EventType, event_type="EV", subtype=seq("Other event"))
event_type_OC = Recipe(EventType, event_type="CL", subtype=seq("Other class"))
event_type_RH = Recipe(EventType, event_type="RH", subtype=seq("Room hire"))

future_EV = Recipe(Event,
                      date=future,
                      event_type=foreign_key(event_type_OE))

future_WS = Recipe(Event,
                   date=future,
                   event_type=foreign_key(event_type_WS))

future_PC = Recipe(Event,
                   date=future,
                   event_type=foreign_key(event_type_PC))
future_PP = Recipe(Event,
                   date=future,
                   event_type=foreign_key(event_type_PP))
future_CL = Recipe(Event,
                   date=future,
                   event_type=foreign_key(event_type_OC))
future_RH = Recipe(Event,

from model_mommy.recipe import Recipe, foreign_key

from ..models import ReasonForContacting, ReasonForContactingCategory

reasonforcontacting = Recipe(ReasonForContacting, _fill_optional=["user_agent", "referrer"])
reasonforcontacting_category = Recipe(
    ReasonForContactingCategory, reason_for_contacting=foreign_key(reasonforcontacting)
)

from django.contrib.auth.models import User

from kb.base import choices
from kb.models import Article, Category, Vote
from model_mommy.recipe import foreign_key, Recipe, related

person = Recipe(User)

draft_article = Recipe(Article,
                       title='Draft Article Title',
                       content='Draft Article Content',
                       publish_state=choices.PublishChoice.Draft,
                       created_by=foreign_key(person))

published_article = Recipe(Article,
                           title='Published Article Title',
                           content='Published Article Content',
                           publish_state=choices.PublishChoice.Published,
                           created_by=foreign_key(person))

category_without_articles = Recipe(Category,
                                   name='Category Without Articles Title',
                                   description='Category Without Articles Description')

category_with_articles = Recipe(Category,
                                name='Category With Articles Title',
                                description='Category With Articles Description',
                                articles=related('draft_article',
                                                 'published_article'))

vote = Recipe(Vote, article__content='Markdown')

from model_mommy.recipe import Recipe, foreign_key, seq

from project.account.mommy_recipes import domain
from .models import EmailDomain, EmailUser, EmailForward, EmailAlias, CatchAll

email_domain = Recipe(EmailDomain,
                      domain=foreign_key(domain),
                      )

email_user = Recipe(EmailUser,
                    domain=foreign_key(email_domain),
                    )

email_forward = Recipe(EmailForward,
                       user=foreign_key(email_user),
                       )

email_alias = Recipe(EmailAlias,
                     user=foreign_key(email_user),
                     )

catch_all = Recipe(CatchAll,
                   domain=foreign_key(email_domain),
                   user=foreign_key(email_user),
                   )

user = Recipe(User,
              username=seq("test_user"),
              password="password",
              email="[email protected]",
              )

# events; use defaults apart from dates
# override when using recipes, eg. mommy.make_recipe('future_event', cost=10)

event_type_YC = Recipe(EventType, event_type="CL", subtype=seq("Yoga class"))
event_type_WS = Recipe(EventType, event_type="EV", subtype=seq("Workshop"))

future_EV = Recipe(Event,
                      date=future,
                      event_type=foreign_key(event_type_YC))

future_WS = Recipe(Event,
                   date=future,
                   event_type=foreign_key(event_type_WS))

# past event
past_event = Recipe(Event,
                    date=past,
                    event_type=foreign_key(event_type_WS),
                    advance_payment_required=True,
                    cost=10,
                    payment_due_date=past-timedelta(10)
                    )

block = Recipe(Block)

belzonte = Recipe(
    Destino,
    titulo="Belo Horizonte"
)

rondonia = Recipe(
    Destino,
    titulo="Rondonia"
)

city_tour_bh = Recipe(
    Pacote,
    texto="Aproveite!",
    publicado=True,
    destaque=True,
    destino=foreign_key(belzonte),
    preco_por=100.40
)

city_tour_bh_despublicado = Recipe(
    Pacote,
    texto="Aproveite!",
    publicado=False,
    destaque=True,
)

city_tour_bh_sem_destaque = Recipe(
    Pacote,
    texto="Aproveite!",
    publicado=True,
    destaque=False,

from unipath import Path

from django.conf import settings
from django.core.files import File

from model_mommy.recipe import Recipe, foreign_key, related

import grunt.models as grunt_models
import ratings.models as ratings_models


django_file_path = Path(settings.APP_DIR, "grunt/tests/media/test-audio.wav")
assert django_file_path.exists()
django_file = File(open(django_file_path, "rb"))

chain = Recipe(grunt_models.Chain, name="mommy_chain")

seed = Recipe(grunt_models.Message, chain=foreign_key(chain), audio=django_file)

recording = Recipe(grunt_models.Message, chain=foreign_key(chain), parent=foreign_key(seed), audio=django_file)

survey = Recipe(ratings_models.Survey)

empty_question = Recipe(
    ratings_models.Question, survey=foreign_key(survey), given=foreign_key(recording), answer=foreign_key(seed)
)

response = Recipe(ratings_models.Response, question=foreign_key(empty_question), selection=foreign_key(seed))

from model_mommy.recipe import Recipe, foreign_key, related

import grunt.models as grunt_models
import ratings.models as ratings_models


django_file_path = Path(settings.APP_DIR, 'grunt/tests/media/test-audio.wav')
assert django_file_path.exists()
django_file = File(open(django_file_path, 'rb'))

chain = Recipe(grunt_models.Chain,
    name = 'mommy_chain')

seed = Recipe(grunt_models.Message,
    chain = foreign_key(chain),
    audio = django_file)

recording = Recipe(grunt_models.Message,
    chain = foreign_key(chain),
    parent = foreign_key(seed),
    audio = django_file)

question = Recipe(ratings_models.Question,
    # Needs to be a valid recording
    choices = related('seed', 'seed'),
    answer = foreign_key(seed))

response = Recipe(ratings_models.Response,
    question = foreign_key(question),
    selection = foreign_key(seed))

 def test_not_accept_other_type(self):
     with self.assertRaises(TypeError) as c:
         foreign_key(2)
     exception = c.exception
     self.assertEqual(str(exception), 'Not a recipe')