Python recipe.Recipe类代码示例

class AddressResponseTests(TestCase):

    def setUp(self):
        self.recipe = Recipe(
            FormFieldResponse,
            form_field__kind='address',
            form_field__details={'required': True}
        )

    def test_should_pass_when_required_and_only_addr2_blank(self):
        field_response = self.recipe.prepare(details={
            'addressLine1': 'x', 'city': 'x', 'state': 'x', 'zip': 'x'
        })
        self.assertEqual(field_response.clean(), None)

    def test_should_not_pass_when_required_and_any_field_but_addr2_blank(self):
        field_response = self.recipe.prepare(details={
            'addressLine1': '', 'city': 'x', 'state': 'x', 'zip': 'x'
        })
        self.assertRaises(ValidationError, field_response.clean)

    def test_should_pass_when_not_required_and_all_fields_blank(self):
        field_response = self.recipe.prepare()
        field_response.form_field.details['required'] = False
        self.assertEqual(field_response.clean(), None)

class LongAnswerResponseTests(TestCase):

    def setUp(self):
        self.recipe = Recipe(
            FormFieldResponse,
            form_field__kind='long-answer',
            form_field__details={'required': True}
        )

    def test_should_pass_when_required_and_answer_not_blank(self):
        field_response = self.recipe.prepare(details={'answer': 'ok'})
        self.assertEqual(field_response.clean(), None)

    def test_should_not_pass_when_required_and_answer_not_provided(self):
        field_response = self.recipe.prepare(details={})
        self.assertRaises(ValidationError, field_response.clean)

    def test_should_not_pass_when_required_and_answer_blank(self):
        field_response = self.recipe.prepare(details={'answer': ''})
        self.assertRaises(ValidationError, field_response.clean)

    def test_should_pass_when_not_required_and_answer_not_provided(self):
        field_response = self.recipe.prepare(details={})
        field_response.form_field.details['required'] = False
        self.assertEqual(field_response.clean(), None)

    def test_should_pass_when_not_required_and_answer_blank(self):
        field_response = self.recipe.prepare(details={'answer': ''})
        field_response.form_field.details['required'] = False
        self.assertEqual(field_response.clean(), None)

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

 def test_always_calls_with_quantity(self):
     with patch('test.generic.tests.test_recipes.choice') as choice_mock:
         l = ['foo', 'bar', 'spam', 'eggs']
         r = Recipe(DummyBlankFieldsModel,
             blank_char_field = lambda: choice(l)
         )
         r.make(_quantity=3)
         self.assertEqual(choice_mock.call_count, 3)

    def test_defining_recipes_str(self):
        from model_mommy.recipe import seq

        p = Recipe("generic.Person", name=seq("foo"))
        try:
            p.make(_quantity=5)
        except AttributeError as e:
            self.fail("%s" % e)

 def leg_setup(self):
     self.survey_recipe = Recipe(models.Commutersurvey)
     self.all_modes = models.Mode.objects.all()
     self.leg_recipe = Recipe(
         models.Leg,
         checkin = self.survey_recipe.make(),
         mode = cycle(self.all_modes)
     )

 def setUp(self):
     last_hour = datetime.now() - timedelta(hours=1)
     # Next hour has 1 minute more because the delay between
     # the creation of the event and the test execution
     next_hour = datetime.now() + timedelta(minutes=61)
     self.event_last_hour = Recipe(Event, ends=last_hour, published=True)
     self.event_next_hour = Recipe(Event, ends=next_hour, published=True)
     self.event_unpublished = Recipe(Event, ends=next_hour, published=False)

 def test_defining_recipes_str(self):
     from model_mommy.recipe import seq
     p = Recipe('generic.Person',
         name=seq('foo')
     )
     try:
         p.make(_quantity=5)
     except AttributeError, e:
         self.fail('%s' %e)

    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)

 def test_always_calls_when_creating(self):
     with patch('test.generic.tests.test_recipes.choice') as choice_mock:
         choice.return_value = 'foo'
         l = ['foo', 'bar', 'spam', 'eggs']
         r = Recipe(DummyBlankFieldsModel,
             blank_char_field = lambda: choice(l)
         )
         r.make().blank_char_field
         r.make().blank_char_field
         self.assertEqual(choice_mock.call_count, 2)

    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!")
        self.assertEqual(r.make().blank_text_field, "not an iterator, so don't iterate!")

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

 def test_prepare_recipe_without_all_model_needed_data(self):
     person_recipe = Recipe(Person, name='John Doe')
     person = person_recipe.prepare()
     self.assertEqual('John Doe', person.name)
     self.assertTrue(person.nickname)
     self.assertTrue(person.age)
     self.assertTrue(person.bio)
     self.assertTrue(person.birthday)
     self.assertTrue(person.appointment)
     self.assertTrue(person.blog)
     self.assertTrue(person.wanted_games_qtd)
     self.assertFalse(person.id)

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

        dog = dog_recipe.prepare(owner__name='Zezin')
        self.assertEqual(Person.objects.count(), 1)
        self.assertEqual(dog.owner.name, 'Zezin')

 def setUp(self):
     self.endereco_base = 'Rua Baronesa, 175'
     self.cidade_base = 'Rio de Janeiro'
     self.lat_base = -22.8950148
     self.lng_base = -43.3542673
     self.imovel = mommy.make(Imovel)
     self.basic_imovel_recipe = Recipe(Imovel, latitude=None, longitude=None)
     imoveis_recipe = Recipe(Imovel,
                             endereco=self.endereco_base,
                             cidade=self.cidade_base,
                             latitude=self.lat_base,
                             longitude=self.lng_base,
                             disponivel=cycle([False, True])
                             )
     # Cria 9 imóveis alterando disponíveis e indisponíveis
     imoveis_recipe.make(_quantity=9)