def test_only_superuser_may_add_user(self):
USERNAME = '******'
resp = self.post('%sadd/' % self.USER_UI_URL, data={'add-is-user-username': USERNAME,
'add-is-user-password': '******'})
assert_http_forbidden(resp)
assert_false(User.objects.filter(username=USERNAME).exists())
def test_only_superuser_may_add_user(self):
USERNAME = '******'
resp = self.post('%sadd/' % self.USER_UI_URL, data={'add-is-user-username': USERNAME,
'add-is-user-password': '******'})
assert_http_forbidden(resp)
assert_false(User.objects.filter(username=USERNAME).exists())
def test_model_diff(self):
obj = DiffModel.objects.create(name='test',
datetime=timezone.now(),
number=2)
assert_false(obj.has_changed)
obj.name = 'test2'
assert_true(obj.has_changed)
assert_equal(set(obj.changed_fields.keys()), {'name'})
assert_equal((obj.changed_fields['name'].initial,
obj.changed_fields['name'].current), ('test', 'test2'))
obj.name = 'test'
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
obj.name = 'test2'
obj.number = 3
obj.datetime = obj.datetime + timedelta(days=2)
assert_true(obj.has_changed)
assert_equal(set(obj.changed_fields.keys()),
{'name', 'number', 'datetime'})
obj.save()
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
def test_smart_model_clean_atomic_post_delete(self):
class AtomicPostDeleteTestProxySmartModel(TestProxySmartModel):
class Meta:
proxy = True
verbose_name = 'testmodel'
verbose_name_plural = 'testmodels'
class SmartMeta:
is_cleaned_pre_save = False
is_cleaned_post_delete = True
is_delete_atomic = True
obj = AtomicPostDeleteTestProxySmartModel.objects.create(name=10 * 'a')
obj_pk = obj.pk
assert_raises(PersistenceException, obj.delete)
assert_true(
AtomicPostDeleteTestProxySmartModel.objects.filter(
pk=obj_pk).exists())
obj = AtomicPostDeleteTestProxySmartModel.objects.create(name=10 * 'a')
obj_pk = obj.pk
obj.delete(is_cleaned_post_delete=False)
assert_false(
AtomicPostDeleteTestProxySmartModel.objects.filter(
pk=obj_pk).exists())
def test_smart_model_clean_atomic_post_save(self):
class AtomicPostSaveTestProxySmartModel(TestProxySmartModel):
class Meta:
proxy = True
verbose_name = 'testmodel'
verbose_name_plural = 'testmodels'
class SmartMeta:
is_cleaned_pre_save = False
is_cleaned_post_save = True
is_save_atomic = True
assert_false(
AtomicPostSaveTestProxySmartModel.objects.filter(name=10 *
'a').exists())
assert_raises(PersistenceException,
AtomicPostSaveTestProxySmartModel.objects.create,
name=10 * 'a')
assert_false(
AtomicPostSaveTestProxySmartModel.objects.filter(name=10 *
'a').exists())
obj = AtomicPostSaveTestProxySmartModel.objects.create(name=9 * 'a')
obj.name = 11 * 'a'
assert_raises(PersistenceException, obj.save)
assert_equal(
len(AtomicPostSaveTestProxySmartModel.objects.get(pk=obj.pk).name),
9)
obj.name = 12 * 'a'
obj.save(is_cleaned_post_save=False)
assert_equal(
len(AtomicPostSaveTestProxySmartModel.objects.get(pk=obj.pk).name),
12)
def test_superuser_should_update_is_superuser(self):
user = self.logged_user.user
resp = self.put('%s%s/' % (self.USER_API_URL, user.pk),
data={'is_superuser': False})
assert_valid_JSON_response(resp)
user.refresh_from_db()
assert_false(user.is_superuser)
def test_smart_model_changed_fields(self):
obj = TestProxySmartModel.objects.create(name='a')
changed_fields = DynamicChangedFields(obj)
assert_equal(len(changed_fields), 0)
obj.name = 'b'
assert_equal(len(changed_fields), 1)
assert_equal(changed_fields['name'].initial, 'a')
assert_equal(changed_fields['name'].current, 'b')
static_changed_fields = changed_fields.get_static_changes()
obj.save()
# Initial values is not changed
assert_equal(len(changed_fields), 2)
assert_equal(len(static_changed_fields), 1)
assert_equal(set(changed_fields.keys()), {'name', 'changed_at'})
assert_equal(set(static_changed_fields.keys()), {'name'})
assert_equal(changed_fields['name'].initial, 'a')
assert_equal(changed_fields['name'].current, 'b')
assert_true(changed_fields.has_any_key('name', 'crated_at'))
assert_false(changed_fields.has_any_key('invalid', 'crated_at'))
assert_raises(AttributeError, changed_fields.__delitem__, 'name')
assert_raises(AttributeError, changed_fields.clear)
assert_raises(AttributeError, changed_fields.pop, 'name')
obj.name = 'b'
def test_user_should_be_authorized_with_two_factor_authentication(
self, user):
login_resp = self.post(self.UI_TWO_FACTOR_LOGIN_URL, {
'username': '******',
'password': '******'
})
assert_http_redirect(login_resp)
resp_location = login_resp['Location']
assert_equal(resp_location[:resp_location.find('?')],
settings.TWO_FACTOR_REDIRECT_URL)
assert_false(login_resp.wsgi_request.user.is_authenticated)
token = login_resp.wsgi_request.token
assert_true(token.two_factor_code is not None)
assert_false(token.is_authenticated)
# the code value needs to be overwritted, so that its value could be used for next request
token.two_factor_code = make_password('12345',
salt=Token.TWO_FACTOR_CODE_SALT)
token.save()
code_check_resp = self.post(self.UI_CODE_CHECK_LOGIN_URL,
{'code': '12345'})
assert_http_redirect(code_check_resp)
assert_equal(code_check_resp['location'], '/accounts/profile/')
assert_true(code_check_resp.wsgi_request.token.is_authenticated)
assert_true(code_check_resp.wsgi_request.user.is_authenticated)
assert_equal(code_check_resp.wsgi_request.user, user)
def test_smart_model_changed_fields(self):
obj = TestProxySmartModel.objects.create(name='a')
changed_fields = DynamicChangedFields(obj)
assert_equal(len(changed_fields), 0)
obj.name = 'b'
assert_equal(len(changed_fields), 1)
assert_equal(changed_fields['name'].initial, 'a')
assert_equal(changed_fields['name'].current, 'b')
static_changed_fields = changed_fields.get_static_changes()
obj.save()
# Initial values is not changed
assert_equal(len(changed_fields), 2)
assert_equal(len(static_changed_fields), 1)
assert_equal(set(changed_fields.keys()), {'name', 'changed_at'})
assert_equal(set(static_changed_fields.keys()), {'name'})
assert_equal(changed_fields['name'].initial, 'a')
assert_equal(changed_fields['name'].current, 'b')
assert_true(changed_fields.has_any_key('name', 'crated_at'))
assert_false(changed_fields.has_any_key('invalid', 'crated_at'))
assert_raises(AttributeError, changed_fields.__delitem__, 'name')
assert_raises(AttributeError, changed_fields.clear)
assert_raises(AttributeError, changed_fields.pop, 'name')
obj.name = 'b'
def test_smart_model_initial_values_should_be_deferred_for_partly_loaded_instance(
self):
obj = DiffModel.objects.only('name').get(pk=DiffModel.objects.create(
name='test', datetime=timezone.now(), number=2).pk)
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
assert_false(obj.is_adding)
assert_true(obj.is_changing)
assert_true(
all(v is Deferred for k, v in obj.initial_values.items()
if k not in {'id', 'name'}))
assert_true(
all(not bool(v) for k, v in obj.initial_values.items()
if k not in {'id', 'name'}))
assert_equal(obj.number, 2)
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
assert_equal(obj.initial_values['number'], 2)
obj.datetime = timezone.now()
assert_equal(obj.initial_values['datetime'], Deferred)
assert_true(obj.changed_fields)
assert_equal(obj.changed_fields.keys(), {'datetime'})
assert_equal(str(Deferred), 'deferred')
def test_key_generator_values_should_be_able_to_change(self, user):
token = VerificationToken.objects.deactivate_and_create(
user, key_generator_kwargs={
'length': 100,
'allowed_chars': 'abc'
})
assert_equal(len(token.key), 100)
assert_false(set(token.key) - set('abc'))
def test_request_body_truncation_should_be_turned_off(self):
self.post('/admin/login/',
data={
'username': 2000 * 'a',
'password': 2000 * 'b'
})
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(len(input_logged_request.request_body), 4183)
assert_false(input_logged_request.request_body.endswith('...'))
def test_json_request_should_be_truncated_with_another_method(self):
self.c.post('/admin/login/', data=json.dumps({'a': 50 * 'a', 'b': 50 * 'b'}),
content_type='application/json')
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(
json.loads(input_logged_request.request_body),
json.loads('{"a": "aaaaaaa...", "b": "bbbbbbb..."}')
)
assert_false(input_logged_request.request_body.endswith('...'))
def test_response_body_truncation_should_be_turned_off(self):
resp = self.post('/admin/login/',
data={
'username': 20 * 'a',
'password': 20 * 'b'
})
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(input_logged_request.response_body, str(resp.content))
assert_false(input_logged_request.response_body.endswith('...'))
def test_smart_atomic_should_be_to_use_as_a_context_manager(self):
with assert_raises(RuntimeError):
with smart_atomic():
CSVRecord.objects.create(
name='test',
number=1
)
raise RuntimeError('test')
assert_false(CSVRecord.objects.exists())
def test_verification_token_should_be_created_and_old_one_should_be_deactivated(self, user):
token1 = VerificationToken.objects.deactivate_and_create(user)
assert_true(token1.is_valid)
assert_true(token1.is_active)
token2 = VerificationToken.objects.deactivate_and_create(user)
assert_true(token2.is_valid)
assert_true(token2.is_active)
token1.refresh_from_db()
assert_false(token1.is_valid)
assert_false(token1.is_active)
def test_user_should_log_and_logout_to_the_administration(self, user):
assert_http_redirect(self.get(self.INDEX_URL))
resp = self.post(self.LOGIN_URL, {'username': '******', 'password': '******'})
assert_http_redirect(resp)
assert_http_ok(self.get(self.INDEX_URL))
assert_in('Authorization', self.c.cookies)
assert_false(Token.objects.last().allowed_header)
assert_true(Token.objects.last().allowed_cookie)
assert_http_ok(self.get(self.LOGOUT_URL))
assert_http_redirect(self.get(self.INDEX_URL))
def test_user_should_be_authorized_via_cookie(self, user):
assert_http_redirect(self.get(self.INDEX_URL))
resp = self.post(self.UI_LOGIN_URL, {
'username': '******',
'password': '******'
})
assert_http_redirect(resp)
assert_http_ok(self.get(self.INDEX_URL))
assert_in('Authorization', self.c.cookies)
assert_false(Token.objects.last().allowed_header)
assert_true(Token.objects.last().allowed_cookie)
def test_comparator(self):
obj1 = ComparableModel.objects.create(name='test')
obj2 = ComparableModel.objects.create(name='test')
obj3 = ComparableModel.objects.create(name='test2')
comparator = NameComparator()
assert_true(obj1.equals(obj2, comparator))
assert_true(obj2.equals(obj1, comparator))
assert_false(obj1.equals(obj3, comparator))
assert_false(obj3.equals(obj1, comparator))
def test_comparator(self):
obj1 = ComparableModel.objects.create(name='test')
obj2 = ComparableModel.objects.create(name='test')
obj3 = ComparableModel.objects.create(name='test2')
comparator = NameComparator()
assert_true(obj1.equals(obj2, comparator))
assert_true(obj2.equals(obj1, comparator))
assert_false(obj1.equals(obj3, comparator))
assert_false(obj3.equals(obj1, comparator))
def test_json_request_should_be_truncated_with_another_method(self):
self.c.post('/admin/login/',
data=json.dumps({
'a': 50 * 'a',
'b': 50 * 'b'
}),
content_type='application/json')
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(json.loads(input_logged_request.request_body),
json.loads('{"a": "aaaaaaa...", "b": "bbbbbbb..."}'))
assert_false(input_logged_request.request_body.endswith('...'))
def test_chamber_atomic_should_ignore_errors(self):
with assert_raises(RuntimeError):
with smart_atomic():
TestSmartModel.objects.create(name='test')
raise RuntimeError
assert_false(TestSmartModel.objects.exists())
with assert_raises(RuntimeError):
with smart_atomic(ignore_errors=(RuntimeError, )):
TestSmartModel.objects.create(name='test')
raise RuntimeError
assert_true(TestSmartModel.objects.exists())
def test_smart_model_post_save(self):
assert_raises(PersistenceException, TestPostProxySmartModel.objects.create)
obj = TestPostProxySmartModel.objects.create(name=10 * 'a')
assert_equal(obj.name, 'test post save')
assert_false(TestPreProxySmartModel.objects.filter(name='test post save').exists())
assert_true(TestPreProxySmartModel.objects.filter(name=10 * 'a').exists())
obj.save()
assert_true(TestPreProxySmartModel.objects.filter(name='test post save').exists())
obj.name = 10 * 'a'
obj.save()
assert_equal(obj.name, 'test post save')
assert_false(TestPreProxySmartModel.objects.filter(name='test post save').exists())
def test_file_field_content_type(self):
# These files can be saved because it has supported type
for filename in ('all_fields_filled.csv', 'test.pdf'):
with open('data/{}'.format(filename), 'rb') as f:
assert_false(self.inst.file)
self.inst.file.save(filename, File(f))
assert_true(self.inst.file)
change_and_save(self.inst, file=None)
# Image file is not supported
with open('data/test2.jpg', 'rb') as f:
assert_false(self.inst.file)
assert_raises(PersistenceException, self.inst.file.save, 'image.jpeg', File(f))
def test_smat_atomic_should_be_to_use_as_a_decorator(self):
@smart_atomic
def change_object_and_raise_exception():
CSVRecord.objects.create(
name='test',
number=1
)
raise RuntimeError('test')
with assert_raises(RuntimeError):
change_object_and_raise_exception()
assert_false(CSVRecord.objects.exists())
def test_permissions_should_be_joined_with_operators(self):
obj_is_none = ObjIsNonePermission()
obj_is_not_none = ObjIsNotNonePermission()
obj_is_string = ObjIsStringPermission()
assert_true((obj_is_none | obj_is_not_none).has_permission(
'test', None, None, None))
assert_true((obj_is_none | obj_is_not_none).has_permission(
'test', None, None, ''))
assert_false((obj_is_none & obj_is_not_none).has_permission(
'test', None, None, None))
assert_false((obj_is_none & obj_is_not_none).has_permission(
'test', None, None, ''))
assert_true(
((obj_is_none | obj_is_string) & obj_is_not_none).has_permission(
'test', None, None, ''))
assert_true(
((obj_is_none & obj_is_string) | obj_is_not_none).has_permission(
'test', None, None, ''))
assert_false(
(obj_is_not_none | (obj_is_none & obj_is_string)).has_permission(
'test', None, None, None))
assert_true((~obj_is_none).has_permission('test', None, None, ''))
assert_false((~obj_is_not_none).has_permission('test', None, None, ''))
assert_true((obj_is_none & ~obj_is_not_none).has_permission(
'test', None, None, None))
def test_file_field_content_type(self):
# These files can be saved because it has supported type
for filename in ('all_fields_filled.csv', 'test.pdf'):
with open('data/{}'.format(filename), 'rb') as f:
assert_false(self.inst.file)
self.inst.file.save(filename, File(f))
assert_true(self.inst.file)
change_and_save(self.inst, file=None)
# Image file is not supported
with open('data/test2.jpg', 'rb') as f:
assert_false(self.inst.file)
assert_raises(PersistenceException, self.inst.file.save,
'image.jpeg', File(f))
def test_permissions_should_be_synchronized(self):
assert_false(Perm.objects.exists())
call_command('sync_permissions', stdout=StringIO())
assert_equal(Perm.objects.count(), 12)
model_names = {'user', 'issue', 'group'}
perm_names = {'create', 'read', 'update', 'delete'}
for model_name in model_names:
for perm_name in perm_names:
assert_equal(
Perm.objects.filter(type=PERM_TYPE_CORE,
codename='{}__{}'.format(
model_name, perm_name)).count(), 1)
def test_valid_verification_token_with_same_slug_should_exists(self, user):
token = VerificationToken.objects.deactivate_and_create(user, slug='a')
assert_true(
VerificationToken.objects.exists_valid(user,
slug='a',
key=token.key))
assert_false(
VerificationToken.objects.exists_valid(user,
slug='b',
key=token.key))
assert_false(
VerificationToken.objects.exists_valid(user,
slug='a',
key='invalid key'))
def test_json_request_should_be_truncated_with_another_method(self):
self.c.post('/admin/login/',
data=json.dumps({
'a': 50 * 'a',
'b': 50 * 'b'
}),
content_type='application/json')
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(
json.loads(input_logged_request.request_body),
json.loads('{"a": "%s%s", "b": "%s%s"}' %
((9 + TRUNCATION_DIFF) * 'a', TRUNCATION_CHAR,
(9 + TRUNCATION_DIFF) * 'b', TRUNCATION_CHAR)))
assert_false(
input_logged_request.request_body.endswith(TRUNCATION_CHAR))
def test_user_should_not_be_authorized_via_http_header_if_headers_are_turned_off(
self, user):
resp = self.post(self.API_LOGIN_URL, {
'username': '******',
'password': '******'
})
assert_http_ok(resp)
assert_in('token', resp.json())
assert_http_redirect(
self.get(self.INDEX_URL,
headers={
'HTTP_AUTHORIZATION':
'Bearer {}'.format(resp.json()['token'])
}))
assert_false(self.client.cookies)
def test_should_correctly_handle_unknown_ats_state(self):
responses.add(responses.POST, settings.ATS_URL, content_type='text/xml',
body=self.ATS_UNKNOW_STATE_RESPONSE, status=200)
sms1 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[0], **self.ATS_OUTPUT_SMS1)
sms2 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ[1], **self.ATS_OUTPUT_SMS2)
response = send_ats_requests(sms1, sms2)
with open('./var/log/ats_sms.log') as ats_log:
log_lines_count = sum(1 for _ in ats_log)
response_codes = parse_response_codes(response.text)
ats_log.seek(0)
log_lines = ats_log.readlines()
assert_equal(log_lines_count + 1, len(log_lines))
assert_true('999' in log_lines[-1])
assert_false(response_codes)
def test_should_correctly_handle_unknown_ats_state(self):
responses.add(responses.POST, settings.ATS_SMS_URL, content_type='text/xml',
body=self.ATS_UNKNOW_STATE_RESPONSE, status=200)
sms1 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ['uniq1'], **self.ATS_OUTPUT_SMS1)
sms2 = OutputSMSFactory(pk=self.ATS_TEST_UNIQ['uniq2'], **self.ATS_OUTPUT_SMS2)
response = send_ats_requests(sms1, sms2)
with open('./var/log/ats_sms.log') as ats_log:
log_lines_count = sum(1 for _ in ats_log)
response_codes = parse_response_codes(response.text)
ats_log.seek(0)
log_lines = ats_log.readlines()
assert_equal(log_lines_count + 1, len(log_lines))
assert_true('999' in log_lines[-1])
assert_false(response_codes)
def test_image_field_max_upload_size(self):
# File is can be stored
with open('data/test2.jpg', 'rb') as f:
assert_false(self.inst.image)
self.inst.image.save('test2.jpg', File(f))
assert_true(self.inst.image)
change_and_save(self.inst, image=None)
# File is too large to store
with open('data/test.jpg', 'rb') as f:
assert_false(self.inst.image)
assert_raises(PersistenceException, self.inst.image.save, 'image.jpeg', File(f))
# File has a wrong extension
with open('data/test2.jpg', 'rb') as f:
assert_raises(PersistenceException, self.inst.image.save, 'image.html', File(f))
def test_stale_waiting_celery_task_should_be_set_as_failed_with_command(
self):
sum_task.apply_async(args=(5, 8))
celery_task_log = CeleryTaskLog.objects.create(
celery_task_id='random id',
name='error_task',
queue_name='default',
input='',
task_args=[],
task_kwargs={},
estimated_time_of_first_arrival=now() - timedelta(minutes=5),
expires=now() - timedelta(minutes=4),
stale=now() - timedelta(minutes=3))
test_call_command('set_celery_task_log_state')
assert_equal(celery_task_log.refresh_from_db().state,
CeleryTaskLogState.EXPIRED)
assert_false(CeleryTaskLog.objects.filter_processing().exists())
def test_user_should_be_authorized_via_http_header(self, user):
assert_http_redirect(self.get(self.INDEX_URL))
resp = self.post(self.API_LOGIN_URL, {
'username': '******',
'password': '******'
})
assert_http_ok(resp)
assert_in('token', resp.json())
assert_http_ok(
self.get(self.INDEX_URL,
headers={
'HTTP_AUTHORIZATION':
'Bearer {}'.format(resp.json()['token'])
}))
assert_not_in('Authorization', self.c.cookies)
assert_true(Token.objects.last().allowed_header)
assert_false(Token.objects.last().allowed_cookie)
def test_user_should_be_authorized_from_token_and_uuid(self, user):
device_token = DeviceKey.objects.create_token(uuid=UUID, user=user)
resp = self.post(self.API_MOBILE_LOGIN_URL, {
'uuid': UUID,
'login_device_token': device_token
})
assert_http_ok(resp)
assert_in('token', resp.json())
assert_http_ok(
self.get(INDEX_URL,
headers={
'HTTP_AUTHORIZATION':
'Bearer {}'.format(resp.json()['token'])
}))
assert_not_in('Authorization', self.c.cookies)
assert_true(Token.objects.last().allowed_header)
assert_false(Token.objects.last().allowed_cookie)
def test_image_field_max_upload_size(self):
# File is can be stored
with open('data/test2.jpg', 'rb') as f:
assert_false(self.inst.image)
self.inst.image.save('test2.jpg', File(f))
assert_true(self.inst.image)
change_and_save(self.inst, image=None)
# File is too large to store
with open('data/test.jpg', 'rb') as f:
assert_false(self.inst.image)
assert_raises(PersistenceException, self.inst.image.save,
'image.jpeg', File(f))
# File has a wrong extension
with open('data/test2.jpg', 'rb') as f:
assert_raises(PersistenceException, self.inst.image.save,
'image.html', File(f))
def test_smart_model_clean_post_delete(self):
class PostDeleteTestProxySmartModel(TestProxySmartModel):
class Meta:
proxy = True
verbose_name = 'testmodel'
verbose_name_plural = 'testmodels'
class SmartMeta:
is_cleaned_pre_save = False
is_cleaned_post_delete = True
obj = PostDeleteTestProxySmartModel.objects.create(name=10 * 'a')
obj_pk = obj.pk
assert_raises(PersistenceException, obj.delete)
assert_false(PostDeleteTestProxySmartModel.objects.filter(pk=obj_pk).exists())
obj = PostDeleteTestProxySmartModel.objects.create(name=10 * 'a')
obj_pk = obj.pk
obj.delete(is_cleaned_post_delete=False)
assert_false(PostDeleteTestProxySmartModel.objects.filter(pk=obj_pk).exists())
def test_model_diff(self):
obj = DiffModel.objects.create(name='test', datetime=timezone.now(), number=2)
assert_false(obj.has_changed)
obj.name = 'test2'
assert_true(obj.has_changed)
assert_equal(set(obj.changed_fields.keys()), {'name'})
assert_equal((obj.changed_fields['name'].initial, obj.changed_fields['name'].current), ('test', 'test2'))
obj.name = 'test'
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
obj.name = 'test2'
obj.number = 3
obj.datetime = obj.datetime + timedelta(days=2)
assert_true(obj.has_changed)
assert_equal(set(obj.changed_fields.keys()), {'name', 'number', 'datetime'})
obj.save()
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
def test_smart_model_clean_post_save(self):
class PostSaveTestProxySmartModel(TestProxySmartModel):
class Meta:
proxy = True
verbose_name = 'testmodel'
verbose_name_plural = 'testmodels'
class SmartMeta:
is_cleaned_pre_save = False
is_cleaned_post_save = True
assert_false(PostSaveTestProxySmartModel.objects.filter(name=10 * 'a').exists())
assert_raises(PersistenceException, PostSaveTestProxySmartModel.objects.create, name=10 * 'a')
assert_true(PostSaveTestProxySmartModel.objects.filter(name=10 * 'a').exists())
obj = PostSaveTestProxySmartModel.objects.create(name=9 * 'a')
obj.name = 11 * 'a'
assert_raises(PersistenceException, obj.save)
assert_equal(len(PostSaveTestProxySmartModel.objects.get(pk=obj.pk).name), 11)
obj.name = 12 * 'a'
obj.save(is_cleaned_post_save=False)
assert_equal(len(PostSaveTestProxySmartModel.objects.get(pk=obj.pk).name), 12)
def test_rfs_bool(self):
assert_true(rfs(('a', 'b', 'b__c', 'b__g', ('d', ('e__f',)))))
assert_false(rfs())
assert_false(rfs(()))
assert_false(rfs({}))
def test_smart_model_initial_values_should_be_unknown_for_not_saved_instance(self):
obj = DiffModel(name='test', datetime=timezone.now(), number=2)
assert_true(obj.has_changed)
assert_true(obj.changed_fields)
assert_equal(set(obj.changed_fields.keys()), {'created_at', 'changed_at', 'id', 'datetime', 'name', 'number'})
assert_true(obj.is_adding)
assert_false(obj.is_changing)
assert_true(all(v is Unknown for v in obj.initial_values.values()))
assert_true(all(not bool(v) for v in obj.initial_values.values()))
obj.save()
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
assert_false(obj.is_adding)
assert_true(obj.is_changing)
assert_true(all(v is not Unknown for v in obj.initial_values.values()))
obj = DiffModel.objects.get(pk=obj.pk)
assert_false(obj.has_changed)
assert_false(obj.changed_fields)
assert_false(obj.is_adding)
assert_true(obj.is_changing)
assert_true(all(v is not Unknown for v in obj.initial_values.values()))
def test_allowed_content_type_should_be_turned_off(self):
self.get('/')
input_logged_request = InputLoggedRequest.objects.get()
assert_false(input_logged_request.response_body)
def test_decorated_view_with_hide_request_body_should_not_log_request_body(self):
self.post('/hide-request-body/', data={'a': 20 * 'a', 'b': 20 * 'b'})
input_logged_request = InputLoggedRequest.objects.get()
assert_false(input_logged_request.request_body)
def test_request_body_truncation_should_be_turned_off(self):
self.post('/admin/login/', data={'username': 2000 * 'a', 'password': 2000 * 'b'})
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(len(input_logged_request.request_body), 4183)
assert_false(input_logged_request.request_body.endswith('...'))
def test_response_body_truncation_should_be_turned_off(self):
resp = self.post('/admin/login/', data={'username': 20 * 'a', 'password': 20 * 'b'})
input_logged_request = InputLoggedRequest.objects.get()
assert_equal(input_logged_request.response_body, str(resp.content))
assert_false(input_logged_request.response_body.endswith('...'))
