def test_atomic_add_and_delete_issue_with_watchers(self, number,
issue_data, user_data):
issue_data['created_by'] = user_data
issue_data['watched_by'] = {'add': self.get_users_data(flat=True)}
resp = self.post(self.ISSUE_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(len(self.deserialize(resp).get('watched_by')), 10)
pk = self.get_pk(resp)
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
issue_data['watched_by'] = {
'add':
self.get_users_data(flat=True),
'remove': [
obj.get('id')
for obj in self.deserialize(resp).get('watched_by')
][:5]
}
resp = self.put('%s%s/' % (self.ISSUE_API_URL, pk), data=issue_data)
assert_equal(len(self.deserialize(resp).get('watched_by')), 15)
issue_data['watched_by'] = self.get_users_data(flat=True)
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
resp = self.put('%s%s/' % (self.ISSUE_API_URL, pk), data=issue_data)
assert_equal(len(self.deserialize(resp).get('watched_by')), 10)
def test_create_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.deserialize(resp)['id']
resp = self.get(self.USER_API_URL)
assert_equal(len(self.deserialize(resp)), 1)
assert_valid_JSON_response(self.get('%s%s/' % (self.USER_API_URL, pk)))
def test_partial_update_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
assert_http_bad_request(self.put('%s%s/' % (self.USER_API_URL, pk), data={}))
assert_valid_JSON_response(self.patch('%s%s/' % (self.USER_API_URL, pk), data={}))
def test_atomic_add_issues_by_m2m_reverse(self, number, issue_data,
user_data):
user_data['watchedIssues'] = {
'add': (self.get_issue_data(), self.get_issue_data(),
self.get_issue_data())
}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
watched_issues = self.deserialize(resp)['watchedIssues']
assert_equal(len(watched_issues), 3)
assert_equal(Issue.objects.all().count(), 3)
watched_issues_ids = [
watched_issue['id'] for watched_issue in watched_issues
]
for issue in Issue.objects.all():
assert_equal(
list(issue.watched_by.values_list('email', flat=True)),
[user_data['email']])
user_data2 = self.get_user_data()
user_data2['watchedIssues'] = watched_issues_ids
resp = self.post(self.USER_API_URL, data=user_data2)
assert_valid_JSON_created_response(resp)
watched_issues = self.deserialize(resp)['watchedIssues']
assert_equal(len(watched_issues), 3)
assert_equal(Issue.objects.all().count(), 3)
for issue in Issue.objects.all():
assert_equal(
list(issue.watched_by.values_list('email', flat=True)),
[user_data['email'], user_data2['email']])
def test_reverse_with_defined_field_created_issues_renamed(self, number, issue_data, user_data):
issues_before_count = Issue.objects.all().count()
user_data['created_issues_renamed'] = (self.get_issue_data(), self.get_issue_data(), self.get_issue_data())
resp = self.post(self.USER_WITH_FORM_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 3, Issue.objects.all().count())
def test_atomic_set_issue_with_user_reverse(self, number, issue_data,
user_data):
issues_before_count = Issue.objects.all().count()
user_data['createdIssues'] = {'set': (issue_data, )}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 1, Issue.objects.all().count())
def test_create_issue_via_user_one_to_one_renamed(self, number, issue_data,
user_data):
issues_before_count = Issue.objects.all().count()
user_data['leading_issue_renamed'] = self.get_issue_data()
resp = self.post(self.USER_WITH_FORM_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 1, Issue.objects.all().count())
def test_atomic_add_and_delete_issues_with_reverse(self, number, issue_data, user_data):
issues_before_count = Issue.objects.all().count()
user_data['createdIssues'] = {'add': (self.get_issue_data(), self.get_issue_data(), self.get_issue_data())}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 3, Issue.objects.all().count())
user_pk = self.get_pk(resp)
first_issue_data = self.get_issue_data()
first_issue_data['solver'] = {'email': '*****@*****.**', 'createdIssues': [self.get_issue_data()]}
user_data['createdIssues'] = {'set': (first_issue_data, self.get_issue_data(), self.get_issue_data())}
resp = self.put('%s%s/' % (self.USER_API_URL, user_pk), data=user_data)
assert_equal(issues_before_count + 4, Issue.objects.all().count())
assert_valid_JSON_response(resp)
user_data['createdIssues'] = {'remove': list(Issue.objects.filter(created_by=user_pk).
values_list('pk', flat=True))}
resp = self.put('%s%s/' % (self.USER_API_URL, self.get_pk(resp)), data=user_data)
assert_valid_JSON_response(resp)
assert_equal(issues_before_count + 1, Issue.objects.all().count())
user_data['createdIssues'] = (self.get_issue_data(), self.get_issue_data(), self.get_issue_data())
resp = self.put('%s%s/' % (self.USER_API_URL, user_pk), data=user_data)
assert_equal(issues_before_count + 4, Issue.objects.all().count())
assert_valid_JSON_response(resp)
def test_read_user_general_fields_set_with_metaclass(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
resp = self.get(self.USER_API_URL)
output_data = self.deserialize(resp)
assert_equal(set(output_data[0].keys()), {'id', '_obj_name', 'email', 'firstName', 'lastName',
'watchedIssues', 'manualCreatedDate', 'watchedIssuesCount'})
def test_read_extra_field_header_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
headers = {'HTTP_X_FIELDS': 'email'}
resp = self.get(self.USER_API_URL, headers=headers)
for item_data in self.deserialize(resp):
assert_equal(set(item_data.keys()), {'email'})
def test_atomic_add_and_delete_issues_with_auto_reverse_fields_turned_off(self, number, issue_data, user_data):
issues_before_count = Issue.objects.all().count()
user_data['createdIssues'] = {'add': (self.get_issue_data(), self.get_issue_data(), self.get_issue_data())}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count, Issue.objects.all().count())
def test_create_user_via_renamed_field(self, number, issue_data, user_data):
users_before_count = User.objects.all().count()
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
resp = self.post(self.ISSUE_WITH_FORM_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 2, User.objects.all().count())
def test_create_user_via_renamed_field(self, number, issue_data,
user_data):
users_before_count = User.objects.all().count()
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
resp = self.post(self.ISSUE_WITH_FORM_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 2, User.objects.all().count())
def test_filename_and_content_type_can_be_evaluated_from_file_content(self, number, data):
data['contract'] = {
'content': base64.b64encode(
('Contract of %s code: šří+áýšé' % data['email']).encode('utf-8')
).decode('utf-8')
}
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_in('.txt', self.deserialize(resp)['contract']['filename'])
def test_read_user_extra_fields_set_with_metaclass(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
headers = {'HTTP_X_FIELDS': 'is_superuser'}
resp = self.get(self.USER_API_URL, headers=headers)
output_data = self.deserialize(resp)
assert_equal(set(output_data[0].keys()), {'isSuperuser'})
def test_create_issue_should_tags_be_parsed_as_a_list(self):
issue_data = self.get_issue_data()
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
issue_data['tags_list'] = ['taga', 'tagb']
resp = self.post(self.ISSUE_WITH_FORM_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(Issue.objects.last().tags, 'taga|tagb')
def test_read_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
resp = self.get('%s%s/' % (self.USER_API_URL, pk),)
output_data = self.deserialize(resp)
assert_equal(output_data.get('email'), data.get('email'))
assert_equal(output_data.get('id'), pk)
def test_create_issue_should_tags_be_parsed_as_a_list(self):
issue_data = self.get_issue_data()
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
issue_data['tags_list'] = ['taga', 'tagb']
resp = self.post(self.ISSUE_WITH_FORM_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(Issue.objects.last().tags, 'taga|tagb')
def test_create_user_with_file_url(self, number, data):
resp = self.get_file_url_response(data)
assert_valid_JSON_created_response(resp)
data = self.deserialize(resp)
assert_not_equal(data['contract'], None)
assert_in('filename', data['contract'])
assert_in('url', data['contract'])
assert_equal(data['contract']['content_type'], 'application/pdf')
def test_filename_and_content_type_can_be_evaluated_from_file_content(
self, number, data):
data['contract'] = {
'content':
base64.b64encode(('Contract of %s code: šří+áýšé' %
data['email']).encode('utf-8')).decode('utf-8')
}
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_in('.txt', self.deserialize(resp)['contract']['filename'])
def test_reverse_with_defined_field_created_issues_renamed(
self, number, issue_data, user_data):
issues_before_count = Issue.objects.all().count()
user_data['created_issues_renamed'] = (self.get_issue_data(),
self.get_issue_data(),
self.get_issue_data())
resp = self.post(self.USER_WITH_FORM_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 3, Issue.objects.all().count())
def test_read_user_detailed_fields_set_with_metaclass(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
resp = self.get('%s%s/' % (self.USER_API_URL, pk),)
output_data = self.deserialize(resp)
assert_equal(set(output_data.keys()), {'id', 'createdAt', '_obj_name', 'email', 'contract',
'solvingIssue', 'firstName', 'lastName', 'watchedIssues',
'manualCreatedDate'})
def test_create_user_with_file_url(self, number, data):
resp = self.get_file_url_response(data)
assert_valid_JSON_created_response(resp)
data = self.deserialize(resp)
assert_not_equal(data['contract'], None)
assert_in('filename', data['contract'])
assert_in('url', data['contract'])
assert_equal(data['contract']['content_type'], 'application/pdf')
def test_atomic_update_issue_with_user(self, number, data):
users_before_count = User.objects.all().count()
resp = self.post(self.ISSUE_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 2, User.objects.all().count())
data['created_by'] = self.get_user_data()
data['created_by']['id'] = self.deserialize(resp)['created_by']['id']
data['leader'] = self.get_user_data()
resp = self.post(self.ISSUE_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 3, User.objects.all().count())
def test_atomic_update_issue_with_user(self, number, data):
users_before_count = User.objects.all().count()
resp = self.post(self.ISSUE_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 2, User.objects.all().count())
data['created_by'] = self.get_user_data()
data['created_by']['id'] = self.deserialize(resp)['created_by']['id']
data['leader'] = self.get_user_data()
resp = self.post(self.ISSUE_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 3, User.objects.all().count())
def test_atomic_add_and_delete_issues_with_auto_reverse_fields_turned_off(
self, number, issue_data, user_data):
issues_before_count = Issue.objects.all().count()
user_data['createdIssues'] = {
'add': (self.get_issue_data(), self.get_issue_data(),
self.get_issue_data())
}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count, Issue.objects.all().count())
def test_update_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
data['email'] = 'updated_%s' % data['email']
resp = self.put('%s%s/' % (self.USER_API_URL, pk), data=data)
assert_valid_JSON_response(resp)
assert_equal(self.deserialize(resp).get('email'), data['email'])
resp = self.get(self.USER_API_URL)
assert_equal(len(self.deserialize(resp)), 1)
def test_read_user_with_more_headers_accept_types(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
for accept_type in self.ACCEPT_TYPES:
resp = self.get(self.USER_API_URL, headers={'HTTP_ACCEPT': accept_type})
assert_in(accept_type, resp['Content-Type'])
resp = self.get('%s%s/' % (self.USER_API_URL, pk), headers={'HTTP_ACCEPT': accept_type})
assert_true(accept_type in resp['Content-Type'])
resp = self.get('%s1050/' % self.USER_API_URL, headers={'HTTP_ACCEPT': accept_type})
assert_true(accept_type in resp['Content-Type'])
assert_http_not_found(resp)
def test_not_allowed_requests(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
resp = self.post('%s%s/' % (self.USER_API_URL, pk), data=data)
assert_http_method_not_allowed(resp)
resp = self.delete(self.USER_API_URL)
assert_http_method_not_allowed(resp)
resp = self.put(self.USER_API_URL, data=data)
assert_http_method_not_allowed(resp)
def test_delete_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
resp = self.delete('%s%s/' % (self.USER_API_URL, pk))
assert_http_accepted(resp)
resp = self.get(self.USER_API_URL)
assert_equal(len(self.deserialize(resp)), 0)
resp = self.delete('%s%s/' % (self.USER_API_URL, pk))
assert_http_not_found(resp)
def test_update_error_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
assert_valid_JSON_response(self.put('{}{}/'.format(self.USER_API_URL, pk),
data={'email': '*****@*****.**'}))
assert_http_bad_request(
self.put('{}{}/'.format(self.USER_API_URL, pk), data={'email': 'invalid_email'})
)
assert_http_not_found(self.put('{}{}/'.format(self.USER_API_URL, 0), data={}))
def test_read_field_header_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
pk = self.get_pk(resp)
headers = {'HTTP_X_FIELDS': 'email,id'}
resp = self.get('%s%s/' % (self.USER_API_URL, pk), headers=headers)
output_data = self.deserialize(resp)
assert_equal(set(output_data.keys()), {'email', 'id'})
resp = self.get(self.USER_API_URL, headers=headers)
assert_equal(int(resp['X-Total']), 1)
for item_data in self.deserialize(resp):
assert_equal(set(item_data.keys()), {'email', 'id'})
def test_create_user_with_file_and_not_defined_content_type(self, number, data):
data['contract'] = {
'filename': 'contract.txt',
'content': base64.b64encode(
('Contract of %s code: šří+áýšé' % data['email']).encode('utf-8')
).decode('utf-8')
}
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
data = self.deserialize(resp)
assert_not_equal(data['contract'], None)
assert_in('filename', data['contract'])
assert_in('url', data['contract'])
assert_equal(data['contract']['content_type'], 'text/plain')
def test_issue_can_be_created_only_via_user(self):
before_issue_count = Issue.objects.count()
user_data = self.get_user_data()
issue_data = self.get_issue_data(exclude=['leader'])
user_data['leading_issue'] = issue_data
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(Issue.objects.count(), before_issue_count + 1)
resp = self.post(self.ISSUE_API_URL, data=self.get_issue_data())
assert_http_forbidden(resp)
assert_equal(Issue.objects.count(), before_issue_count + 1)
def test_atomic_set_issue_with_watchers(self, number, issue_data, user_data):
users_before_count = User.objects.all().count()
issue_data['created_by'] = user_data
issue_data['watched_by'] = self.get_users_data(flat=True)
resp = self.post(self.ISSUE_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 12, User.objects.all().count())
issue_data['leader'] = self.get_user_data()
issue_data['created_by'] = self.get_user_data()
issue_data['watched_by'] = {'set': self.get_users_data(flat=True)}
resp = self.post(self.ISSUE_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 24, User.objects.all().count())
def test_create_user_with_file_and_not_defined_content_type(
self, number, data):
data['contract'] = {
'filename':
'contract.txt',
'content':
base64.b64encode(('Contract of %s code: šří+áýšé' %
data['email']).encode('utf-8')).decode('utf-8')
}
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
data = self.deserialize(resp)
assert_not_equal(data['contract'], None)
assert_in('filename', data['contract'])
assert_in('url', data['contract'])
assert_equal(data['contract']['content_type'], 'text/plain')
def test_atomic_set_issue_with_watchers(self, number, issue_data,
user_data):
users_before_count = User.objects.all().count()
issue_data['created_by'] = user_data
issue_data['watched_by'] = self.get_users_data(flat=True)
resp = self.post(self.ISSUE_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 12, User.objects.all().count())
issue_data['leader'] = self.get_user_data()
issue_data['created_by'] = self.get_user_data()
issue_data['watched_by'] = {'set': self.get_users_data(flat=True)}
resp = self.post(self.ISSUE_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(users_before_count + 24, User.objects.all().count())
def test_atomic_add_and_delete_issues_with_reverse(self, number,
issue_data, user_data):
issues_before_count = Issue.objects.all().count()
user_data['createdIssues'] = {
'add': (self.get_issue_data(), self.get_issue_data(),
self.get_issue_data())
}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 3, Issue.objects.all().count())
user_pk = self.get_pk(resp)
first_issue_data = self.get_issue_data()
first_issue_data['solver'] = {
'email': '*****@*****.**',
'createdIssues': [self.get_issue_data()]
}
user_data['createdIssues'] = {
'set':
(first_issue_data, self.get_issue_data(), self.get_issue_data())
}
resp = self.put('%s%s/' % (self.USER_API_URL, user_pk), data=user_data)
assert_equal(issues_before_count + 4, Issue.objects.all().count())
assert_valid_JSON_response(resp)
user_data['createdIssues'] = {
'remove':
list(
Issue.objects.filter(created_by=user_pk).values_list(
'pk', flat=True))
}
resp = self.put('%s%s/' % (self.USER_API_URL, self.get_pk(resp)),
data=user_data)
assert_valid_JSON_response(resp)
assert_equal(issues_before_count + 1, Issue.objects.all().count())
user_data['createdIssues'] = (self.get_issue_data(),
self.get_issue_data(),
self.get_issue_data())
resp = self.put('%s%s/' % (self.USER_API_URL, user_pk), data=user_data)
assert_equal(issues_before_count + 4, Issue.objects.all().count())
assert_valid_JSON_response(resp)
def test_should_create_data_of_resource(self, resource_name, resource,
model):
for _ in range(self.iteration):
list_url = resource._resource_list_url()
request = self.get_request_with_user(self.r_factory.post(list_url))
if not resource(request).has_post_permission():
break
data, inst = self.get_serialized_data(request, resource)
count_before = model._default_manager.all().count()
resp = self.post(list_url, data=data)
count_after = model._default_manager.all().count()
assert_valid_JSON_created_response(
resp,
'REST create of model: {}\n response: {}'.format(model, resp))
assert_equal(count_before + 1, count_after)
def test_atomic_add_and_delete_issue_with_watchers(self, number, issue_data, user_data):
issue_data['created_by'] = user_data
issue_data['watched_by'] = {'add': self.get_users_data(flat=True)}
resp = self.post(self.ISSUE_API_URL, data=issue_data)
assert_valid_JSON_created_response(resp)
assert_equal(len(self.deserialize(resp).get('watched_by')), 10)
pk = self.get_pk(resp)
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
issue_data['watched_by'] = {'add': self.get_users_data(flat=True),
'remove': [obj.get('id') for obj in self.deserialize(resp).get('watched_by')][:5]}
resp = self.put('%s%s/' % (self.ISSUE_API_URL, pk), data=issue_data)
assert_equal(len(self.deserialize(resp).get('watched_by')), 15)
issue_data['watched_by'] = self.get_users_data(flat=True)
issue_data['created_by'] = self.get_user_data()
issue_data['leader'] = self.get_user_data()
resp = self.put('%s%s/' % (self.ISSUE_API_URL, pk), data=issue_data)
assert_equal(len(self.deserialize(resp).get('watched_by')), 10)
def test_atomic_add_issues_by_m2m_reverse(self, number, issue_data, user_data):
user_data['watchedIssues'] = {'add': (self.get_issue_data(), self.get_issue_data(), self.get_issue_data())}
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
watched_issues = self.deserialize(resp)['watchedIssues']
assert_equal(len(watched_issues), 3)
assert_equal(Issue.objects.all().count(), 3)
watched_issues_ids = [watched_issue['id'] for watched_issue in watched_issues]
for issue in Issue.objects.all():
assert_equal(list(issue.watched_by.values_list('email', flat=True)), [user_data['email']])
user_data2 = self.get_user_data()
user_data2['watchedIssues'] = watched_issues_ids
resp = self.post(self.USER_API_URL, data=user_data2)
assert_valid_JSON_created_response(resp)
watched_issues = self.deserialize(resp)['watchedIssues']
assert_equal(len(watched_issues), 3)
assert_equal(Issue.objects.all().count(), 3)
for issue in Issue.objects.all():
assert_equal(list(issue.watched_by.values_list('email', flat=True)),
[user_data['email'], user_data2['email']])
def test_create_issue_via_user_one_to_one(self, number, issue_data, user_data):
issues_before_count = Issue.objects.all().count()
issue_data['created_by'] = self.get_user_data()
user_data['leading_issue'] = issue_data
resp = self.post(self.USER_API_URL, data=user_data)
assert_valid_JSON_created_response(resp)
assert_equal(issues_before_count + 1, Issue.objects.all().count())
pk = self.get_pk(resp)
user_data = {'leading_issue': None}
resp = self.patch('%s%s/' % (self.USER_API_URL, pk), data=user_data)
assert_valid_JSON_response(resp)
assert_equal(issues_before_count, Issue.objects.all().count())
user_data = {'leading_issue': None}
resp = self.patch('%s%s/' % (self.USER_API_URL, pk), data=user_data)
assert_valid_JSON_response(resp)
assert_equal(issues_before_count, Issue.objects.all().count())
user_data = {'leading_issue': self.get_issue_data()}
resp = self.patch('%s%s/' % (self.USER_API_URL, pk), data=user_data)
assert_valid_JSON_response(resp)
assert_equal(issues_before_count + 1, Issue.objects.all().count())
def test_read_querystring_paginator_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
querystring = {'_offset': '0', '_base': '5'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_equal(len(self.deserialize(resp)), min(int(resp['x-total']), 5))
querystring = {'_offset': '2', '_base': '5'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_equal(len(self.deserialize(resp)), min(max(int(resp['x-total']) - 2, 0), 5))
querystring = {'_offset': '2', '_base': '-5'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_http_bad_request(resp)
querystring = {'_offset': '-2', '_base': '5'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_http_bad_request(resp)
querystring = {'_offset': 'error', '_base': 'error'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_http_bad_request(resp)
def test_read_headers_paginator_user(self, number, data):
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
headers = {'HTTP_X_OFFSET': '0', 'HTTP_X_BASE': '5'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_equal(len(self.deserialize(resp)), min(int(resp['x-total']), 5))
headers = {'HTTP_X_OFFSET': '2', 'HTTP_X_BASE': '5'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_equal(len(self.deserialize(resp)), min(max(int(resp['x-total']) - 2, 0), 5))
headers = {'HTTP_X_OFFSET': '2', 'HTTP_X_BASE': '-5'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_http_bad_request(resp)
headers = {'HTTP_X_OFFSET': '-2', 'HTTP_X_BASE': '5'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_http_bad_request(resp)
headers = {'HTTP_X_OFFSET': 'error', 'HTTP_X_BASE': 'error'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_http_bad_request(resp)
def test_create_user_with_created_at(self, number, data):
data['manualCreatedDate'] = '2017-01-20T23:30:00+01:00'
resp = self.post(self.USER_API_URL, data=data)
assert_valid_JSON_created_response(resp)
def test_camel_snake_case_transformation(self):
data = {'barBaz': 'testing data'}
resp = self.post(self.TEST_CC_API_URL, data=data)
assert_valid_JSON_created_response(resp)
assert_equal(data, self.deserialize(resp))
