def test_edit_todo_list(self):
# Create user
user = baker.make("User")
self.assertEqual(1, User.objects.count())
# Create todo list
baker.make("TodoList", owner=user)
self.assertEqual(1, TodoList.objects.count())
# Authenticate user
token, created = Token.objects.get_or_create(user=user)
self.assertTrue(created)
headers = {"HTTP_AUTHORIZATION": "Token " + token.key}
# Edit todo list successfully
sample = TodoListSerializer(baker.prepare("TodoList"))
url = reverse("todo_lists:todo_list_detail", kwargs={"pk": 1})
response = self.client.put(
path=url, content_type="application/json", data=sample.data, **headers
)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(sample.data["title"], response.data["title"])
self.assertEqual(sample.data["title"], TodoList.objects.get().title)
def test_update_profile(self):
# edit name
data = {'full_name': "Test User"}
response = self.PATCH(self.url_profile, HTTP_200_OK, data)
self.profile.refresh_from_db()
self.assertDictEqual(response.data, self.profile.serialize())
# edit everything
filled_profile = baker.prepare(models.Profile,
_fill_optional=True,
_save_related=True,
online=False,
location=models.Location.objects.get(
pk=models.Location.default_pk()))
new_data = filled_profile.serialize()
response = self.PATCH(self.url_profile, HTTP_200_OK, new_data)
self.profile.refresh_from_db()
self.assertDictEqual(response.data, self.profile.serialize())
# unauthenticated edit
self.client.credentials()
data = {'full_name': "Should not change"}
self.PATCH(self.url_profile, HTTP_401_UNAUTHORIZED, data)
self.profile.refresh_from_db()
self.assertNotEqual(data['full_name'], self.profile.full_name)
def test_update(self):
self.authorize()
# update fields one by one
for field, new_value in (('price', self.listing.price + 100),
('condition_new',
not self.listing.condition_new),
('title', "New Title"), ('description',
"New description."),
('category',
baker.make('Category',
name='valid',
rght=None).serialize()),
('location', {
'coordinates': "12.345678, 87.654321",
'address': "Addr"
})):
response = self.PATCH(self.listing_url, HTTP_200_OK,
{field: new_value})
self.assertIn(field, response.data)
self.assertEqual(response.data[field], new_value)
self.listing.refresh_from_db()
serialized = listing_serializer(self.listing)
self.assertEqual(serialized.data[field], new_value)
# update all at once
new_category = baker.make('Category',
name='another_valid_cat',
rght=None)
alter = baker.prepare('Listing', category=new_category)
serialized_alter = listing_serializer(alter)
data = {
field: serialized_alter.data[field]
for field in self.fields_to_test
}
patch_response = self.PATCH(self.listing_url, HTTP_200_OK, data)
self.assertDictContainsSubset(data, patch_response.data)
get_response = self.GET(self.listing_url, HTTP_200_OK)
self.assertEqual(patch_response.data, get_response.data)
def setUp(self):
self.enforcement_page = baker.prepare(EnforcementActionPage)
self.enforcement_page.public_enforcement_action = 'Sample Enforcement Action'
self.enforcement_page.initial_filing_date = date(2021, 1, 1)
self.enforcement_page.defendant_types = [
EnforcementActionDefendantType(defendant_type='Bank'),
EnforcementActionDefendantType(defendant_type='Non-Bank'),
]
self.enforcement_page.court = "CFPB Office of Administrative Adjudication"
self.enforcement_page.docket_numbers.add(
EnforcementActionDocket(docket_number='2021-CFPB-0001'))
self.enforcement_page.settled_or_contested_at_filing = 'Settled'
self.enforcement_page.products.add(
EnforcementActionProduct(
product='Other Consumer Products (Not Lending)'))
self.enforcement_page.at_risk_groups.add(
EnforcementActionAtRisk(at_risk_group='Students'))
self.enforcement_page.enforcement_dispositions.add(
EnforcementActionDisposition(
final_disposition="Sample Sample Action",
final_disposition_type="Final Order",
final_order_date="2021-02-02",
final_order_consumer_redress="333.00",
final_order_consumer_redress_suspended="444.00",
final_order_other_consumer_relief="555.00",
final_order_other_consumer_relief_suspended="666.00",
final_order_disgorgement="777.00",
final_order_disgorgement_suspended="888.00",
final_order_civil_money_penalty="999.00",
final_order_civil_money_penalty_suspended="111.00",
estimated_consumers_entitled_to_relief="Zero"))
self.enforcement_page.statuses.add(
EnforcementActionStatus(status='expired-terminated-dismissed'))
self.enforcement_page.statutes.add(
EnforcementActionStatute(statute='CLA'))
def test_delete_todo_requires_authorization(self):
# Create user
user = baker.make("User")
self.assertEqual(1, User.objects.count())
# Create todo list
todo_list = baker.make("TodoList", owner=user)
self.assertEqual(1, TodoList.objects.count())
# Create todo
todo = baker.make("Todo", todo_list=todo_list)
self.assertEqual(1, TodoList.objects.count())
# Edit todo successfully
sample = TodoSerializer(baker.prepare("Todo", todo_list=todo_list))
url = reverse("todo_lists:todo_detail",
kwargs={
"todo_list": todo_list.id,
"pk": todo.id
})
response = self.client.delete(path=url,
content_type="application/json",
data=sample.data)
self.assertEqual(status.HTTP_401_UNAUTHORIZED, response.status_code)
def test_schema_fields_types(self):
db_fields_to_rows_fields = {
"binary": fields.BinaryField,
"bool": fields.BoolField,
"date": fields.DateField,
"datetime": fields.DatetimeField,
"decimal": fields.DecimalField,
"email": fields.EmailField,
"float": fields.FloatField,
"integer": fields.IntegerField,
"json": fields.JSONField,
"string": fields.TextField,
"text": fields.TextField,
}
table = baker.make("core.Table")
field = baker.prepare("core.Field", table=table, name="table_column", dataset=table.dataset)
for db_field_type, rows_field_type in db_fields_to_rows_fields.items():
field.type = db_field_type
field.save()
table.refresh_from_db()
assert rows_field_type == table.schema["table_column"]
def setUp(self):
self.pieces = baker.make(Piece, _quantity=2)
self.users = baker.make(User, username=faker.name(), _quantity=2)
self.factory = APIRequestFactory()
self.user = baker.prepare(User, username=faker.name())
profile = baker.prepare(UserProfile)
self.user.profile = profile
self.user.save()
profile.user = self.user
profile.save()
self.demand1 = baker.make(Demand,
owner=self.user,
piece=self.pieces[0])
self.user2 = baker.prepare(User, username=faker.name())
profile2 = baker.prepare(UserProfile)
self.user2.profile = profile2
self.user2.save()
profile2.user = self.user2
profile2.save()
self.demand2 = baker.make(Demand,
owner=self.user2,
piece=self.pieces[1])
self.admin_user = baker.prepare(User,
username='******',
email='*****@*****.**',
password='******',
is_superuser=True,
is_staff=True)
profile3 = baker.prepare(UserProfile)
self.admin_user.profile = profile3
self.admin_user.save()
profile3.user = self.admin_user
profile3.save()
self.url = reverse('demand-list')
self.demand_data = {'status': 1}
def setUp(self):
self.preview_image = baker.prepare(CFGOVImage)
self.social_sharing_image = baker.prepare(CFGOVImage)
def test_fill_all_optional_when_preparing(self):
dummy = baker.prepare(models.DummyBlankFieldsModel,
_fill_optional=True)
assert len(dummy.blank_char_field) == 50
assert len(dummy.blank_text_field) == 300
def test_skip_blank_when_preparing_with_argument(self):
dummy = baker.prepare(models.DummyBlankFieldsModel,
_fill_optional=False)
assert dummy.blank_char_field == ""
assert dummy.blank_text_field == ""
def test_create_model_with_contenttype_field(self):
dummy = baker.prepare(models.DummyGenericForeignKeyModel)
assert isinstance(dummy, models.DummyGenericForeignKeyModel)
def test_raise_on_ambiguous_model_string(self):
with pytest.raises(AmbiguousModelName):
baker.prepare("Ambiguous")
def test_model_class(self):
obj = baker.prepare(models.Person)
assert isinstance(obj, models.Person)
def test_meta_image_no_images(self):
""" Meta image should be undefined if no image provided """
page = baker.prepare(CFGOVPage, social_sharing_image=None)
self.assertIsNone(page.meta_image)
def test_choices_field_many_to_many_property(self):
choices_set = baker.prepare('kit.Answer', _quantity=5)
question = baker.make('kit.Question', choices=choices_set)
self.assertEqual(question.choices.count(), 5)
def test_create_one_to_one(self):
lonely_person = baker.prepare(models.LonelyPerson, _save_related=True)
assert lonely_person.pk is None
assert lonely_person.only_friend.pk
def test_unicode_regression(self):
obj = baker.prepare("generic.Person")
assert isinstance(obj, models.Person)
def test_meta_image_only_social_sharing(self):
""" Meta image uses social sharing image if provided """
page = baker.prepare(CFGOVPage,
social_sharing_image=self.social_sharing_image)
self.assertEqual(page.meta_image, page.social_sharing_image)
def test_model_string(self):
obj = baker.prepare("Person")
assert isinstance(obj, models.Person)
def setUp(self):
self.company = baker.prepare(Company, trade_name='Coca Cola', cnpj='83.096.895/0001-37')
def test_ForeignKey_model_field_population_should_work_with_prepare(self):
dog = baker.prepare(models.Dog, breed="X1", owner__name="Bob")
assert "X1" == dog.breed
assert "Bob" == dog.owner.name
def _get_obj(self):
obj = self._obj or baker.prepare(self._cls.Meta.model,
_fill_optional=True)
return obj
def test_skip_blank_when_preparing(self):
dummy = baker.prepare(models.DummyBlankFieldsModel)
assert dummy.blank_char_field == ""
assert dummy.blank_text_field == ""
def test_app_model_string(self):
obj = baker.prepare('generic.Person')
assert isinstance(obj, models.Person)
def test_fill_field_optinal_when_preparing(self):
dummy = baker.prepare(models.DummyBlankFieldsModel,
_fill_optional=["blank_char_field"])
assert len(dummy.blank_char_field) == 50
def test_ForeignKey_model_field_population_should_work_with_prepare(self):
dog = baker.prepare(models.Dog, breed='X1', owner__name='Bob')
assert 'X1' == dog.breed
assert 'Bob' == dog.owner.name
def test_keeps_prepare_autovalues(self):
dummy = baker.prepare(models.DummyEmptyModel, id=543)
assert dummy.id == 543
dummy.save()
saved_dummy = models.DummyEmptyModel.objects.get()
assert saved_dummy.id == 543
def test_locked_contributor_questionnaire(self):
questionnaire = baker.prepare(Questionnaire,
is_locked=True,
type=Questionnaire.Type.CONTRIBUTOR)
self.assertRaises(ValidationError, questionnaire.clean)
def prepare_job_listing_page(self, **kwargs):
kwargs.setdefault('description', 'default')
kwargs.setdefault('division', self.division)
kwargs.setdefault('location', self.location)
return baker.prepare(JobListingPage, **kwargs)
def setUp(self):
self.uf = "PR"
self.cities_cases = [
{
"city": "Abatiá",
"confirmed": 9,
"deaths": 1
},
{
"city": "Adrianópolis",
"confirmed": 11,
"deaths": 2
},
{
"city": "Agudos do Sul",
"confirmed": 12,
"deaths": 3
},
{
"city": "Almirante Tamandaré",
"confirmed": 8,
"deaths": 4
},
{
"city": "Altamira do Paraná",
"confirmed": 13,
"deaths": 5
},
{
"city": "Alto Paraíso",
"confirmed": 47,
"deaths": 15
},
]
self.today = date.today()
self.undefined_data = {
"city": "Importados/Indefinidos",
"city_ibge_code": None,
"confirmed": 2,
"date": self.today.isoformat(),
"deaths": 2,
"place_type": "city",
"state": self.uf,
}
self.total_data = {
"city": None,
"city_ibge_code": 41,
"confirmed": 102,
"date": self.today.isoformat(),
"deaths": 32,
"place_type": "state",
"state": self.uf,
}
self.cities_data = [{
"city":
c["city"],
"city_ibge_code":
get_city_info(c["city"], self.uf).city_ibge_code,
"confirmed":
c["confirmed"],
"date":
self.today.isoformat(),
"deaths":
c["deaths"],
"place_type":
"city",
"state":
self.uf,
} for c in self.cities_cases]
self.spreadsheet = baker.prepare(StateSpreadsheet,
state=self.uf,
date=self.today)
