def docker_controller(with_envvars=True, with_labels=True, **kw): """ Generate a DockerController model with (optional) envvars and labels. """ # The slug is used in places where whitespace and colons are problematic, # so we remove them from the generated value. # TODO: Build a proper SlugField strategy. # TODO: Figure out why the field validation isn't being applied. # Slugs must be domain-name friendly - used in the "generic" domain slug = text(string.ascii_letters + string.digits + '-') kw.setdefault("slug", slug) kw.setdefault("owner", models(User, is_active=just(True))) kw.setdefault("organization", models(Organization, slug=slug)) # Prevent Hypothesis from generating domains with invalid characters domain_urls = text(string.ascii_letters + string.digits + '-.') kw.setdefault("domain_urls", domain_urls) # The model generator sees `controller_ptr` (from the PolymorphicModel # magic) as a mandatory field and objects if we don't provide a value for # it. controller = models(DockerController, controller_ptr=default_value, **kw) if with_envvars: controller = controller.flatmap(add_envvars) if with_labels: controller = controller.flatmap(add_labels) return controller
class MessageEventTestCase(TestCase): @given(random_MessageEvents=st.lists(models(MessageEvent, username=models(User), event=models(Event) ))) def test_all_MessageEvents_return_name(self, random_MessageEvents): for random_MessageEvent in random_MessageEvents: self.assertEquals(random_MessageEvent.event.name, str(random_MessageEvent))
class EventTestCase(TestCase): @given(random_events=st.lists(models(Event))) def test_all_events_return_name(self, random_events): for random_event in random_events: self.assertEquals(random_event.name, str(random_event)) @given(random_events=st.lists(models(Event))) def test_get_absolute_url(self, random_events): for random_event in random_events: self.assertEquals(random_event.get_absolute_url(), reverse('event-detail', args=[str(random_event.id)]))
def test_foreign_key_primary(self, buf): # Regression test for #1307 company_strategy = models(Company, name=just('test')) strategy = models(CompanyExtension, company=company_strategy, self_modifying=just(2)) try: ConjectureData.for_buffer(buf).draw(strategy) except HypothesisException as e: reject() # Draw again with the same buffer. This will cause a duplicate # primary key. ConjectureData.for_buffer(buf).draw(strategy) assert CompanyExtension.objects.all().count() == 1
class TestReportHypo(TestCase): @given(sampled_from(['csv', 'xlsx', 'ods']), lists( models(Report, comment=characters(blacklist_categories=['Cc', 'Cs']), task=builds(TaskFactory.create), user=builds(UserFactory.create), date=dates( min_date=date(2000, 1, 1), max_date=date(2100, 1, 1), ), duration=timedeltas(min_delta=timedelta(0), max_delta=timedelta(days=1))), min_size=1, max_size=5, )) @settings(timeout=5, suppress_health_check=[HealthCheck.too_slow]) def test_report_export(self, file_type, reports): get_user_model().objects.create_user(username='******', password='******') client = JSONAPIClient() client.login('test', '1234qwer') url = reverse('report-export') with self.assertNumQueries(4): user_res = client.get(url, data={'file_type': file_type}) assert user_res.status_code == HTTP_200_OK book = pyexcel.get_book(file_content=user_res.content, file_type=file_type) # bookdict is a dict of tuples(name, content) sheet = book.bookdict.popitem()[1] assert len(sheet) == len(reports) + 1
def add_labels(controller): """ Generate some MarathonLabel models for the given controller. We discard these once we've made them because they're in the database. """ labels = lists(models(MarathonLabel, controller=just(controller))) return labels.map(lambda _: controller)
def add_labels(controller): """ Generate some MarathonLabel models for the given controller. We discard these once we've made them because they're in the database. """ labels = lists(models(MarathonLabel, controller=just(controller))) return labels.map(lambda _: controller)
def add_envvars(controller): """ Generate some EnvVariable models for the given controller. We discard these once we've made them because they're in the database. """ envvars = lists(models(EnvVariable, controller=just(controller))) return envvars.map(lambda _: controller)
def add_envvars(controller): """ Generate some EnvVariable models for the given controller. We discard these once we've made them because they're in the database. """ envvars = lists(models(EnvVariable, controller=just(controller))) return envvars.map(lambda _: controller)
def rubric_with_questions(min_questions: int=None, max_questions: int=None, average_questions: int=10) -> SearchStrategy: def add_questions(rubric: Rubric) -> SearchStrategy: return lists(elements=questions(rubric), min_size=min_questions, max_size=max_questions, average_size=average_questions, unique=True).flatmap(lambda _: just(rubric)) return models(Rubric).flatmap(add_questions)
def test_foreign_key_primary(self, buf): # Regression test for #1307 company_strategy = models( Company, name=just('test') ) strategy = models( CompanyExtension, company=company_strategy, self_modifying=just(2) ) try: ConjectureData.for_buffer(buf).draw(strategy) except HypothesisException as e: reject() # Draw again with the same buffer. This will cause a duplicate # primary key. ConjectureData.for_buffer(buf).draw(strategy) assert CompanyExtension.objects.all().count() == 1
class TestGetsBasicModels(TestCase): @given(models(Company)) def test_is_company(self, company): self.assertIsInstance(company, Company) self.assertIsNotNone(company.pk) @given(models(Store, company=models(Company))) def test_can_get_a_store(self, store): assert store.company.pk @given(lists(models(Company))) def test_can_get_multiple_models_with_unique_field(self, companies): assume(len(companies) > 1) for c in companies: self.assertIsNotNone(c.pk) self.assertEqual(len({c.pk for c in companies}), len({c.name for c in companies})) @given(models(Customer)) def test_is_customer(self, customer): self.assertIsInstance(customer, Customer) self.assertIsNotNone(customer.pk) self.assertIsNotNone(customer.email) @given(models(CouldBeCharming)) def test_is_not_charming(self, not_charming): self.assertIsInstance(not_charming, CouldBeCharming) self.assertIsNotNone(not_charming.pk) self.assertIsNone(not_charming.charm) @given(models(SelfLoop)) def test_sl(self, sl): self.assertIsNone(sl.me) @given(lists(models(ManyInts))) def test_no_overflow_in_integer(self, manyints): pass @given(models(Customish)) def test_custom_field(self, x): assert x.customish == 'a' def test_mandatory_fields_are_mandatory(self): self.assertRaises(InvalidArgument, models, Store)
class TestRestrictedFields(TestCase): @given(models(RestrictedFields)) def test_constructs_valid_instance(self, instance): self.assertTrue(isinstance(instance, RestrictedFields)) instance.full_clean() self.assertLessEqual(len(instance.text_field_4), 4) self.assertLessEqual(len(instance.char_field_4), 4) self.assertIn(instance.choice_field_text, ('foo', 'bar')) self.assertIn(instance.choice_field_int, (1, 2)) self.assertIn(instance.null_choice_field_int, (1, 2, None)) self.assertEqual(instance.even_number_field % 2, 0) self.assertTrue(instance.non_blank_text_field)
class TestFieldType(TestCase): """A class that randomly select an article object from the data base and tests the field types for each parameter """ @settings(suppress_health_check=[ HealthCheck.filter_too_much, HealthCheck.too_slow ]) @given(models(Article, date=models(Year)), models(Author), models(Label), models(Strategies), models(KeyWord)) def test_with_hypothesis(self, article, author, label, strategy, key_word): article.author.add(author) article.labels.add(label) article.list_strategies.add(strategy) article.key_word.add(key_word) self.assertTrue(author.article_set.filter(author=author).exists()) self.assertTrue(label.article_set.filter(labels=label).exists()) self.assertTrue( strategy.article_set.filter(list_strategies=strategy).exists()) self.assertTrue( key_word.article_set.filter(key_word=key_word).exists()) self.assertEqual(type(article.title), str) self.assertEqual(type(article.date.year), int) self.assertEqual(type(article.abstract), str) self.assertEqual(type(article.key), str) self.assertEqual(type(article.pages), str) self.assertEqual(type(article.journal), str) self.assertEqual(type(article.read), bool) self.assertEqual(type(author.name), str) self.assertEqual(type(label.label), str) self.assertEqual(type(strategy.description), str) self.assertLessEqual(len(strategy.strategy_name), 300)
def setUp(self): users = [ models(User).example() for _ in range(CommissionApiTest.USERS_NUMBER) ] test_commissions = [ models(Commission, date_added=default_value, orderer=just(choice(users)), status=default_value, price=default_value).example() for _ in range(CommissionApiTest.COMMISSIONS_NUMBER) ] CommissionApiTest.AUTH_USER = User.objects.create_user( CommissionApiTest.USER_SECRET, '*****@*****.**', CommissionApiTest.USER_SECRET) CommissionApiTest.OTHER_AUTH_USER = User.objects.create_user( CommissionApiTest.OTHER_USER_SECRET, '*****@*****.**', CommissionApiTest.OTHER_USER_SECRET)
def docker_controller(with_envvars=True, with_labels=True, **kw): """ Generate a DockerController model with (optional) envvars and labels. """ # The slug is used in places where whitespace and colons are problematic, # so we remove them from the generated value. # TODO: Build a proper SlugField strategy. # TODO: Figure out why the field validation isn't being applied. # Slugs must be domain-name friendly - used in the "generic" domain slug = text(string.ascii_letters + string.digits + '-') kw.setdefault("slug", slug) kw.setdefault("owner", models(User, is_active=just(True))) kw.setdefault("organization", models(Organization, slug=slug)) # Prevent Hypothesis from generating domains with invalid characters domain_urls = text(string.ascii_letters + string.digits + '-.') kw.setdefault("domain_urls", domain_urls) # Prevent Hypothesis from generating vhosts with invalid characters rabbitmq_vhost_name = text(string.ascii_letters + string.digits + '-.') kw.setdefault("rabbitmq_vhost_name", rabbitmq_vhost_name) # Prevent Hypothesis from generating usernames with invalid characters rabbitmq_vhost_username = text(string.ascii_letters + string.digits + '-.') kw.setdefault("rabbitmq_vhost_username", rabbitmq_vhost_username) # The model generator sees `controller_ptr` (from the PolymorphicModel # magic) as a mandatory field and objects if we don't provide a value for # it. controller = models(DockerController, controller_ptr=default_value, **kw) if with_envvars: controller = controller.flatmap(add_envvars) if with_labels: controller = controller.flatmap(add_labels) return controller
}, "age": { "description": "Age", "type": "integer", "minimum": 0 } }, "required": ["firstName", "lastName"] } EXAMPLE_BAD_SCHEMA1 = "{'why is a string in a dict?'}" EXAMPLE_BAD_SCHEMA2 = "\"[]\"" EXAMPLE_BAD_SCHEMA3 = "\"af[]23\"" UserGenerator = models(User, username=strategies.text(max_size=30), first_name=strategies.text( max_size=30), last_name=strategies.text(max_size=30), email=strategies.just('*****@*****.**')) SurveyGenerator = models(Survey, schema=strategies.just( EXAMPLE_SCHEMA), created_by=UserGenerator) SurveyGoalData = strategies.fixed_dictionaries(mapping={ 'schema': strategies.one_of( strategies.just(EXAMPLE_SCHEMA), strategies.text(), strategies.just(EXAMPLE_BAD_SCHEMA1), strategies.just(EXAMPLE_BAD_SCHEMA2), strategies.just(EXAMPLE_BAD_SCHEMA3), ), 'created_by': strategies.integers(), 'name': strategies.text(),
Strategies for generation test objects using Hypothesis (http://hypothesis.works/) """ from hypothesis import strategies as st from hypothesis.extra.django.models import models from projects.tests.factories import ClaimFactory from projects.models import Project, Nomination, Claim from core.tests.factories import ResourceFactory def generate_with_claims(nomination): """ Magic formula for generating with dependent models. cf. http://hypothesis.readthedocs.io/en/latest/django.html#generating-child-models """ return st.lists( builds(ClaimFactory, nomination=st.just(nomination), collection=st.builds(CollectionFactory)), min_size=0, average_size=2, ).map(lambda _: nomination) nominations = models( Nomination, project=models(Project), resource=st.builds(ResourceFactory), ).flatmap(generate_with_claims)
def generate_phone_registration(candidate): return models(model=UserRegistration, mobile_number=phone_strategy_clean, candidate=just(candidate))
parsed_number = phonenumbers.parse(number, 'DE') assert phonenumbers.is_valid_number_for_region( parsed_number, 'de'), parsed_number return True phone_strategy = builds(target=create_mobile_number) phone_strategy_clean = phone_strategy.filter(lambda x: valid_mobile_number(x)) candidate_dict = {'model': Candidate, 'first_name': name_strategy, 'last_name': name_strategy, 'date_of_birth': date_strategy} candidate = models(**candidate_dict) def generate_email_registration(candidate): return models(model=UserRegistration, email=email_strategy, candidate=just(candidate)) candidate_with_email = models(**candidate_dict).flatmap( generate_email_registration) def generate_phone_registration(candidate): return models(model=UserRegistration, mobile_number=phone_strategy_clean, candidate=just(candidate))
# This Source Code Form is subject to the terms of the Mozilla Public License, # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at http://mozilla.org/MPL/2.0/. # END HEADER from __future__ import division, print_function, absolute_import from django.test import TestCase from hypothesis.strategies import just, lists from tests.django.toystore.models import Store, Company, Customer from hypothesis.extra.django.models import models from hypothesis.extra.django.fixtures import fixture a_company = fixture(models(Company), lambda c: c.name) a_different_company = fixture(models(Company), lambda c: len(c.name) > len(a_company().name)) another_company = fixture(models(Company), lambda c: c.name) some_companies = fixture(lists(models(Company)), lambda ls: len({c.pk for c in ls}) >= 5) def with_some_stores(company): child_strategy = lists(models(Store, company=just(company)), min_size=1) return child_strategy.map(lambda _: company) a_company_with_some_stores = fixture(models(Company).flatmap(with_some_stores), lambda x: x.store_set.count() >= 2)
def test_can_get_examples(self): for _ in range(200): models(Company).example()
class TestGetsBasicModels(TestCase): @given(models(Company)) def test_is_company(self, company): self.assertIsInstance(company, Company) self.assertIsNotNone(company.pk) @given(models(Store, company=models(Company))) def test_can_get_a_store(self, store): assert store.company.pk @given(lists(models(Company))) def test_can_get_multiple_models_with_unique_field(self, companies): assume(len(companies) > 1) for c in companies: self.assertIsNotNone(c.pk) self.assertEqual(len({c.pk for c in companies}), len({c.name for c in companies})) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(models(Customer)) def test_is_customer(self, customer): self.assertIsInstance(customer, Customer) self.assertIsNotNone(customer.pk) self.assertIsNotNone(customer.email) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(models(Customer)) def test_tz_presence(self, customer): if django_settings.USE_TZ: self.assertIsNotNone(customer.birthday.tzinfo) else: self.assertIsNone(customer.birthday.tzinfo) @given(models(CouldBeCharming)) def test_is_not_charming(self, not_charming): self.assertIsInstance(not_charming, CouldBeCharming) self.assertIsNotNone(not_charming.pk) self.assertIsNone(not_charming.charm) @given(models(SelfLoop)) def test_sl(self, sl): self.assertIsNone(sl.me) @given(lists(models(ManyNumerics))) def test_no_overflow_in_integer(self, manyints): pass @given(models(Customish)) def test_custom_field(self, x): assert x.customish == u'a' def test_mandatory_fields_are_mandatory(self): self.assertRaises(InvalidArgument, models, Store) def test_mandatory_computed_fields_are_mandatory(self): self.assertRaises(InvalidArgument, models, MandatoryComputed) def test_mandatory_computed_fields_may_not_be_provided(self): mc = models(MandatoryComputed, company=models(Company)) self.assertRaises(RuntimeError, mc.example) @given(models(MandatoryComputed, company=default_value)) def test_mandatory_computed_field_default(self, x): assert x.company.name == x.name + u'_company' @given(models(CustomishDefault)) def test_customish_default_generated(self, x): assert x.customish == u'a' @given(models(CustomishDefault, customish=default_value)) def test_customish_default_not_generated(self, x): assert x.customish == u'b' @given(models(OddFields)) def test_odd_fields(self, x): assert isinstance(x.uuid, UUID) assert isinstance(x.slug, text_type) assert u' ' not in x.slug assert isinstance(x.ipv4, str) assert len(x.ipv4.split('.')) == 4 assert all(int(i) in range(256) for i in x.ipv4.split('.')) assert isinstance(x.ipv6, text_type) assert set(x.ipv6).issubset(set(u'0123456789abcdefABCDEF:.')) @given(models(ManyTimes)) def test_time_fields(self, x): assert isinstance(x.time, dt.time) assert isinstance(x.date, dt.date) assert isinstance(x.duration, dt.timedelta) @given(models(Company)) def test_no_null_in_charfield(self, x): # regression test for #1045. Company just has a convenient CharField. assert u'\x00' not in x.name @given(binary(min_size=10)) def test_foreign_key_primary(self, buf): # Regression test for #1307 company_strategy = models(Company, name=just('test')) strategy = models(CompanyExtension, company=company_strategy, self_modifying=just(2)) try: ConjectureData.for_buffer(buf).draw(strategy) except HypothesisException as e: reject() # Draw again with the same buffer. This will cause a duplicate # primary key. ConjectureData.for_buffer(buf).draw(strategy) assert CompanyExtension.objects.all().count() == 1
import pytest from django.shortcuts import reverse from django.contrib.auth.models import User from hypothesis import given from hypothesis.extra.django.models import models from blog.models import Post HTTP_200_OK = 200 @pytest.mark.django_db def test_post_ok(client): response = client.get(reverse('post-list')) assert response.status_code == HTTP_200_OK assert response.context_data['view'].__class__.__name__ == 'PostListView' @given(post=models(Post, author=models(User))) @pytest.mark.django_db def test_post_detail_ok(client, post): url = reverse('post-detail', kwargs={"slug": post.slug}) response = client.get(url) assert response.status_code == HTTP_200_OK
def test_mandatory_computed_fields_are_mandatory_old(self): with self.assertRaises(InvalidArgument): models(MandatoryComputed).example()
class TestUser(TestCase): @given(models.models(User)) def test_get_absolute_url(self, user): user.get_absolute_url()
def test_mandatory_computed_fields_may_not_be_provided(self): mc = models(MandatoryComputed, company=models(Company)) self.assertRaises(RuntimeError, mc.example)
def test_mandatory_fields_are_mandatory_old(self): self.assertRaises(InvalidArgument, models(Store).example)
class TestGetsBasicModels(TestCase): @given(models(Company)) def test_is_company(self, company): self.assertIsInstance(company, Company) self.assertIsNotNone(company.pk) @given(models(Store, company=models(Company))) def test_can_get_a_store(self, store): assert store.company.pk @given(lists(models(Company))) def test_can_get_multiple_models_with_unique_field(self, companies): assume(len(companies) > 1) for c in companies: self.assertIsNotNone(c.pk) self.assertEqual( len({c.pk for c in companies}), len({c.name for c in companies}) ) @given(models(Customer)) def test_is_customer(self, customer): self.assertIsInstance(customer, Customer) self.assertIsNotNone(customer.pk) self.assertIsNotNone(customer.email) @given(models(CouldBeCharming)) def test_is_not_charming(self, not_charming): self.assertIsInstance(not_charming, CouldBeCharming) self.assertIsNotNone(not_charming.pk) self.assertIsNone(not_charming.charm) @given(models(SelfLoop)) def test_sl(self, sl): self.assertIsNone(sl.me) @given(lists(models(ManyInts))) def test_no_overflow_in_integer(self, manyints): pass @given(models(Customish)) def test_custom_field(self, x): assert x.customish == u'a' def test_mandatory_fields_are_mandatory(self): self.assertRaises(InvalidArgument, models, Store) def test_mandatory_computed_fields_are_mandatory(self): self.assertRaises(InvalidArgument, models, MandatoryComputed) def test_mandatory_computed_fields_may_not_be_provided(self): mc = models(MandatoryComputed, company=models(Company)) self.assertRaises(RuntimeError, mc.example) @given(models(MandatoryComputed, company=default_value)) def test_mandatory_computed_field_default(self, x): assert x.company.name == x.name + u'_company' @given(models(CustomishDefault)) def test_customish_default_generated(self, x): assert x.customish == u'a' @given(models(CustomishDefault, customish=default_value)) def test_customish_default_not_generated(self, x): assert x.customish == u'b'
# v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at http://mozilla.org/MPL/2.0/. # # END HEADER from __future__ import division, print_function, absolute_import from django.test import TestCase from hypothesis.strategies import just, lists from tests.django.toystore.models import Store, Company, Customer from hypothesis.extra.django.models import models from hypothesis.extra.django.fixtures import fixture a_company = fixture( models(Company), lambda c: c.name, ) a_different_company = fixture(models(Company), lambda c: len(c.name) > len(a_company().name)) another_company = fixture( models(Company), lambda c: c.name, ) some_companies = fixture(lists(models(Company)), lambda ls: len({c.pk for c in ls}) >= 5)
def test_mandatory_computed_fields_may_not_be_provided(self): mc = models(MandatoryComputed, company=models(Company)) self.assertRaises(RuntimeError, mc.example)
# This Source Code Form is subject to the terms of the Mozilla Public License, # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at http://mozilla.org/MPL/2.0/. # END HEADER from __future__ import division, print_function, absolute_import from django.test import TestCase from hypothesis.strategies import just, lists from tests.django.toystore.models import Store, Company, Customer from hypothesis.extra.django.models import models from hypothesis.extra.django.fixtures import fixture a_company = fixture( models(Company), lambda c: c.name, ) a_different_company = fixture( models(Company), lambda c: len(c.name) > len(a_company().name) ) another_company = fixture( models(Company), lambda c: c.name, ) some_companies = fixture( lists(models(Company)),
def generate_email_and_phone_registration(candidate): return models(model=UserRegistration, email=email_strategy, mobile_number=phone_strategy_clean, candidate=just(candidate))
def with_some_stores(company): child_strategy = lists( models(Store, company=just(company)), min_size=1 ) return child_strategy.map(lambda _: company)
class TestValidatorInference(TestCase): @given(models(User)) def test_user_issue_1112_regression(self, user): assert user.username
def test_mandatory_fields_are_mandatory(self): with self.assertRaises(InvalidArgument): models(Store)
def generate_email_registration(candidate): return models(model=UserRegistration, email=email_strategy, candidate=just(candidate))
parsed_number, 'de'), parsed_number return True phone_strategy = builds(create_mobile_number, sampled_from(MOBILE_PHONE_PREFIXES), integers(min_value=1000000, max_value=99999999)).filter(lambda x: x is not None) phone_strategy_clean = phone_strategy.filter(lambda x: valid_mobile_number(x)) candidate_dict = {'model': Candidate, 'first_name': name_strategy, 'last_name': name_strategy, 'date_of_birth': date_strategy} candidate = models(**candidate_dict) def generate_email_registration(candidate): return models(model=UserRegistration, email=email_strategy, candidate=just(candidate)) candidate_with_email = models(**candidate_dict).flatmap( generate_email_registration) def generate_phone_registration(candidate): return models(model=UserRegistration, mobile_number=phone_strategy_clean,
def create_question(type_and_weight: tuple) -> SearchStrategy: return models(Question, rubric=just(rubric), question_type=just(type_and_weight[0]), weight=just(type_and_weight[1]), short_description=sane_text())
def generate_email_registration(candidate): return models(model=UserRegistration, email=email_strategy, candidate=just(candidate))
def test_mandatory_computed_fields_are_mandatory_old(self): with self.assertRaises(InvalidArgument): models(MandatoryComputed).example()
def test_creation(db): wallet = models(Wallet, user=models(User)).example() assert wallet
class TestGetsBasicModels(TestCase): @checks_deprecated_behaviour def test_add_default_field_mapping_is_deprecated(self): class UnregisteredCustomishField(CustomishField): """Just to get deprecation warning when registered.""" add_default_field_mapping(UnregisteredCustomishField, just(u"a")) with self.assertRaises(InvalidArgument): # Double-registering is an error, and registry is shared. register_field_strategy(UnregisteredCustomishField, just(u"a")) @given(from_model(Company)) def test_is_company(self, company): self.assertIsInstance(company, Company) self.assertIsNotNone(company.pk) @given(from_model(Store, company=from_model(Company))) def test_can_get_a_store(self, store): assert store.company.pk @given(lists(from_model(Company))) def test_can_get_multiple_models_with_unique_field(self, companies): assume(len(companies) > 1) for c in companies: self.assertIsNotNone(c.pk) self.assertEqual( len({c.pk for c in companies}), len({c.name for c in companies}) ) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(from_model(Customer)) def test_is_customer(self, customer): self.assertIsInstance(customer, Customer) self.assertIsNotNone(customer.pk) self.assertIsNotNone(customer.email) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(from_model(Customer)) def test_tz_presence(self, customer): if django_settings.USE_TZ: self.assertIsNotNone(customer.birthday.tzinfo) else: self.assertIsNone(customer.birthday.tzinfo) @given(from_model(CouldBeCharming)) def test_is_not_charming(self, not_charming): self.assertIsInstance(not_charming, CouldBeCharming) self.assertIsNotNone(not_charming.pk) self.assertIsNone(not_charming.charm) @given(from_model(SelfLoop)) def test_sl(self, sl): self.assertIsNone(sl.me) @given(lists(from_model(ManyNumerics))) def test_no_overflow_in_integer(self, manyints): pass @given(from_model(Customish)) def test_custom_field(self, x): assert x.customish == u"a" def test_mandatory_fields_are_mandatory(self): self.assertRaises(InvalidArgument, from_model(Store).example) @checks_deprecated_behaviour def test_mandatory_fields_are_mandatory_old(self): self.assertRaises(InvalidArgument, models(Store).example) def test_mandatory_computed_fields_are_mandatory(self): with self.assertRaises(InvalidArgument): from_model(MandatoryComputed).example() @checks_deprecated_behaviour def test_mandatory_computed_fields_are_mandatory_old(self): with self.assertRaises(InvalidArgument): models(MandatoryComputed).example() def test_mandatory_computed_fields_may_not_be_provided(self): mc = from_model(MandatoryComputed, company=from_model(Company)) self.assertRaises(RuntimeError, mc.example) @checks_deprecated_behaviour def test_mandatory_computed_fields_may_not_be_provided_old(self): mc = models(MandatoryComputed, company=models(Company)) self.assertRaises(RuntimeError, mc.example) @checks_deprecated_behaviour @given(models(MandatoryComputed, company=default_value)) def test_mandatory_computed_field_default(self, x): assert x.company.name == x.name + u"_company" @given(from_model(CustomishDefault, customish=infer)) def test_customish_default_overridden_by_infer(self, x): assert x.customish == u"a" @given(from_model(CustomishDefault, customish=infer)) def test_customish_infer_uses_registered_instead_of_default(self, x): assert x.customish == u"a" @checks_deprecated_behaviour @given(models(CustomishDefault, customish=default_value)) def test_customish_default_generated(self, x): assert x.customish == u"b" @given(from_model(OddFields)) def test_odd_fields(self, x): assert isinstance(x.uuid, UUID) assert isinstance(x.slug, text_type) assert u" " not in x.slug assert isinstance(x.ipv4, text_type) assert len(x.ipv4.split(".")) == 4 assert all(int(i) in range(256) for i in x.ipv4.split(".")) assert isinstance(x.ipv6, text_type) assert set(x.ipv6).issubset(set(u"0123456789abcdefABCDEF:.")) @given(from_model(ManyTimes)) def test_time_fields(self, x): assert isinstance(x.time, dt.time) assert isinstance(x.date, dt.date) assert isinstance(x.duration, dt.timedelta) @given(from_model(Company)) def test_no_null_in_charfield(self, x): # regression test for #1045. Company just has a convenient CharField. assert u"\x00" not in x.name @given(binary(min_size=10)) def test_foreign_key_primary(self, buf): # Regression test for #1307 company_strategy = from_model(Company, name=just("test")) strategy = from_model( CompanyExtension, company=company_strategy, self_modifying=just(2) ) try: ConjectureData.for_buffer(buf).draw(strategy) except HypothesisException: reject() # Draw again with the same buffer. This will cause a duplicate # primary key. ConjectureData.for_buffer(buf).draw(strategy) assert CompanyExtension.objects.all().count() == 1
def test_mandatory_fields_are_mandatory_old(self): self.assertRaises(InvalidArgument, models(Store).example)
def test_can_get_examples(self): for _ in range(200): models(Company).example()
"firstName": {"type": "string"}, "lastName": {"type": "string"}, "age": {"description": "Age", "type": "integer", "minimum": 0}, }, "required": ["firstName", "lastName"], } EXAMPLE_BAD_SCHEMA1 = "{'why is a string in a dict?'}" EXAMPLE_BAD_SCHEMA2 = '"[]"' EXAMPLE_BAD_SCHEMA3 = '"af[]23"' UserGenerator = models( User, username=strategies.text(max_size=30), first_name=strategies.text(max_size=30), last_name=strategies.text(max_size=30), email=strategies.just("*****@*****.**"), ) SurveyGenerator = models(Survey, schema=strategies.just(EXAMPLE_SCHEMA), created_by=UserGenerator) SurveyGoalData = strategies.fixed_dictionaries( mapping={ "schema": strategies.one_of( strategies.just(EXAMPLE_SCHEMA), strategies.text(), strategies.just(EXAMPLE_BAD_SCHEMA1), strategies.just(EXAMPLE_BAD_SCHEMA2), strategies.just(EXAMPLE_BAD_SCHEMA3),