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_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_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_user_can_get_number_of_its_issues(self):
user = self.logged_user.user
resp = self.get(self.USER_ISSUES_API_URL % {'user_pk': user.pk})
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_equal(output['created'], 0)
assert_equal(output['watching'], 0)
def test_superuser_may_read_user_data(self):
[self.get_user_obj() for _ in range(5)]
resp = self.get(self.USER_API_URL)
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_equal(len(output), 6)
def test_override_extra_order_fields(self):
assert_http_bad_request(
self.get(build_url(self.USER_API_URL, order='created_at')))
assert_valid_JSON_response(
self.get(
build_url(self.USER_API_URL,
order='email,-solving_issue__short_description')))
def test_core_readonly_methods_should_be_returned(self):
user = self.get_user_obj()
IssueFactory(created_by=user)
resp = self.get('{}{}/?_fields=created_issues_count'.format(
self.USER_API_URL, user.pk))
assert_valid_JSON_response(resp)
assert_equal(resp.json()['created_issues_count'], 1)
def test_user_can_update_only_itself(self):
user = self.get_user_obj()
resp = self.put('%s%s/' % (self.USER_API_URL, user.pk), data={})
assert_http_not_found(resp)
user = self.logged_user.user
resp = self.put('%s%s/' % (self.USER_API_URL, user.pk), data={})
assert_valid_JSON_response(resp)
def test_user_can_read_all_user_data(self):
[self.get_user_obj() for _ in range(5)]
resp = self.get(self.USER_API_URL)
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_equal(len(output), 1)
assert_equal(output[0]['id'], self.logged_user.user.pk)
def test_user_can_read_only_itself(self):
resp = self.get(
('%s%s/') % (self.USER_API_URL, self.logged_user.user.pk))
assert_valid_JSON_response(resp)
user = self.get_user_obj()
resp = self.get(('%s%s/') % (self.USER_API_URL, user.pk))
assert_http_not_found(resp)
def test_issue_can_filter_only_with_readable_fields_and_extra_field(self):
assert_valid_JSON_response(
self.get(build_url(self.ISSUE_API_URL, filter='solver__created_at="1.1.2017"'))
)
assert_valid_JSON_response(self.get(build_url(self.ISSUE_API_URL, filter='created_at>"1.1.2017"')))
assert_http_bad_request(
self.get(build_url(self.ISSUE_API_URL, filter='solver__manual_created_date>"1.1.2017"'))
)
def test_order_by_decorator(self):
[IssueFactory(description=str(i)) for i in range(10)]
data = self.deserialize(self.get(build_url(self.ISSUE_API_URL, order='short_description')))
assert_equal([v['short_description'] for v in data], [str(i) for i in range(10)])
data = self.deserialize(self.get(build_url(self.ISSUE_API_URL, order='-short_description')))
assert_equal([v['short_description'] for v in data], [str(i) for i in range(10)][::-1])
assert_valid_JSON_response(self.get(build_url(self.USER_API_URL, order='solving_issue__short_description')))
assert_valid_JSON_response(self.get(build_url(self.USER_API_URL, order='-solving_issue__short_description')))
assert_http_bad_request(self.get(build_url(self.ISSUE_API_URL, order='description')))
def test_override_extra_filter_fields(self):
assert_http_bad_request(
self.get(
build_url(self.USER_API_URL,
filter='created_at__gt="1.1.1980"')))
assert_valid_JSON_response(
self.get(
build_url(self.USER_API_URL,
filter='email contains "*****@*****.**"')))
def test_camel_snake_case_nested(self):
resp = self.get(self.TEST_CC_API_URL)
assert_valid_JSON_response(resp)
data = {
'fooBar': 'foo bar',
'connected': {'fizBaz': 'test object property content'}
}
assert_equal(data, self.deserialize(resp))
def authorize(self, username, password):
resp = self.post(is_core_settings.LOGIN_API_URL,
data={
is_core_settings.USERNAME: username,
is_core_settings.PASSWORD: password
})
assert_valid_JSON_response(resp, 'REST authorization fail: %s' % resp)
self.default_headers[header_name_to_django(
settings.HEADER_NAME)] = (create_auth_header_value(
self.deserialize(resp).get('token')))
def test_issue_can_order_only_with_readable_fields_and_extra_field(self):
assert_valid_JSON_response(
self.get(build_url(self.ISSUE_API_URL,
order='solver__created_at')))
assert_valid_JSON_response(
self.get(build_url(self.ISSUE_API_URL, order='created_at')))
assert_http_bad_request(
self.get(
build_url(self.ISSUE_API_URL,
order='solver__manual_created_date')))
def test_user_can_read_all_user_data(self):
self.logged_user.user.perms.add_perm(
'core.issue_tracker.UserIsCore.read')
[self.get_user_obj() for _ in range(5)]
resp = self.get(self.USER_API_URL)
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_equal(len(output), 1)
assert_equal(output[0]['id'], self.logged_user.user.pk)
def test_rename_fields_should_not_be_nested(self):
resp = self.get(self.TEST_CC_API_URL)
assert_valid_JSON_response(resp)
data = {
'fooBar': 'foo bar',
'connected': {
'fiz_baz': 'test object property content'
}
}
assert_equal(data, self.deserialize(resp))
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_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_should_return_data_from_resource(self, resource_name, resource,
model):
for _ in range(self.iteration):
inst = self.new_instance(model)
url = resource._resource_url(inst.pk)
if not resource(self.get_request_with_user(
self.r_factory.get(url))).has_get_permission(obj=inst):
break
resp = self.get(url)
assert_valid_JSON_response(
resp, 'REST get of model: %s\n response: %s' % (model, resp))
def test_extra_sorter(self):
user1 = UserFactory()
user2 = UserFactory()
user3 = UserFactory()
user1.watched_issues.add(*(IssueFactory() for _ in range(2)))
user3.watched_issues.add(*(IssueFactory() for _ in range(5)))
users_pks = {user1.pk, user2.pk, user3.pk}
resp = self.get(build_url(self.USER_API_URL, order='watched_issues_count'))
assert_valid_JSON_response(resp)
assert_equal(self.get_pk_list(resp, only_pks=users_pks), [user2.pk, user1.pk, user3.pk])
resp = self.get(build_url(self.USER_API_URL, order='-watched_issues_count'))
assert_valid_JSON_response(resp)
assert_equal(self.get_pk_list(resp, only_pks=users_pks), [user3.pk, user1.pk, user2.pk])
def test_user_headers_ordering_by_id(self):
[self.get_user_obj() for _ in range(10)]
headers = {'HTTP_X_ORDER': 'id'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
pk_list = [obj.get('id') for obj in output]
assert_true(all(pk_list[i] < pk_list[i + 1] for i in range(len(pk_list) - 1)))
headers = {'HTTP_X_ORDER': '-id'}
resp = self.get(self.USER_API_URL, headers=headers)
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
pk_list = [obj.get('id') for obj in output]
assert_true(all(pk_list[i] > pk_list[i + 1] for i in range(len(pk_list) - 1)))
def test_user_querystring_ordering_by_id(self):
[self.get_user_obj() for _ in range(10)]
querystring = {'_order': 'id'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
pk_list = [obj.get('id') for obj in output]
assert_true(all(pk_list[i] < pk_list[i + 1] for i in range(len(pk_list) - 1)))
querystring = {'_order': '-id'}
resp = self.get('%s?%s' % (self.USER_API_URL, urlencode(querystring)))
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
pk_list = [obj.get('id') for obj in output]
assert_true(all(pk_list[i] > pk_list[i + 1] for i in range(len(pk_list) - 1)))
def test_should_update_data_of_resource(self, resource_name, resource,
model):
for _ in range(self.iteration):
inst_from = self.new_instance(model)
url = resource._resource_url(inst_from.pk)
request = self.get_request_with_user(self.r_factory.put(url))
if not resource(request).has_put_permission(obj=inst_from):
break
data, _ = self.get_serialized_data(request, resource, True)
resp = self.put(url, data=data)
assert_valid_JSON_response(
resp,
'REST update of model: {}\n response: {}'.format(model, resp))
def test_should_return_data_from_resource_list(self, resource_name,
resource, model):
list_url = resource._resource_list_url()
if not resource(
self.get_request_with_user(
self.r_factory.get(list_url))).has_get_permission():
return
resp = self.get(list_url)
started_total_count = int(resp['X-Total'])
for i in range(self.iteration):
self.new_instance(model)
resp = self.get(list_url)
assert_valid_JSON_response(
resp, 'REST get list of model: {}\n response: {}'.format(
model, resp))
assert_equal(int(resp['X-Total']) - i, started_total_count + 1)
def test_extra_sorter(self):
user1 = UserFactory()
user2 = UserFactory()
user3 = UserFactory()
user1.watched_issues.add(*(IssueFactory() for _ in range(2)))
user3.watched_issues.add(*(IssueFactory() for _ in range(5)))
users_pks = {user1.pk, user2.pk, user3.pk}
resp = self.get(
build_url(self.USER_API_URL, order='watched_issues_count'))
assert_valid_JSON_response(resp)
assert_equal(self.get_pk_list(resp, only_pks=users_pks),
[user2.pk, user1.pk, user3.pk])
resp = self.get(
build_url(self.USER_API_URL, order='-watched_issues_count'))
assert_valid_JSON_response(resp)
assert_equal(self.get_pk_list(resp, only_pks=users_pks),
[user3.pk, user1.pk, user2.pk])
def test_order_by_decorator(self):
[IssueFactory(description=str(i)) for i in range(10)]
data = self.deserialize(
self.get(build_url(self.ISSUE_API_URL, order='short_description')))
assert_equal([v['short_description'] for v in data],
[str(i) for i in range(10)])
data = self.deserialize(
self.get(build_url(self.ISSUE_API_URL,
order='-short_description')))
assert_equal([v['short_description'] for v in data],
[str(i) for i in range(10)][::-1])
assert_valid_JSON_response(
self.get(
build_url(self.USER_API_URL,
order='solving_issue__short_description')))
assert_valid_JSON_response(
self.get(
build_url(self.USER_API_URL,
order='-solving_issue__short_description')))
assert_http_bad_request(
self.get(build_url(self.ISSUE_API_URL, order='description')))
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_user_filtering_by_id(self):
users = [self.get_user_obj() for _ in range(10)]
resp = self.get('%s?id=%s' % (self.USER_API_URL, users[0].pk))
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_true(len(output), 1)
assert_true(output[0]['id'], 1)
resp = self.get('%s?id__lt=%s' % (self.USER_API_URL, users[2].pk))
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_true(len(output), 2)
resp = self.get('%s?id__lte=%s' % (self.USER_API_URL, users[2].pk))
assert_valid_JSON_response(resp)
output = self.deserialize(resp)
assert_true(len(output), 3)
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_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_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_superuser_can_add_update_user(self):
user = self.get_user_obj()
resp = self.put('%s%s/' % (self.USER_API_URL, user.pk), data={})
assert_valid_JSON_response(resp)
def test_should_return_data_for_get(self):
resp = self.get(self.EXTRA_API_URL)
assert_valid_JSON_response(resp)
def test_override_extra_filter_fields(self):
assert_http_bad_request(self.get(build_url(self.USER_API_URL, filter='created_at__gt="1.1.1980"')))
assert_valid_JSON_response(
self.get(build_url(self.USER_API_URL, filter='email contains "*****@*****.**"'))
)
def test_override_extra_order_fields(self):
assert_http_bad_request(self.get(build_url(self.USER_API_URL, order='created_at')))
assert_valid_JSON_response(
self.get(build_url(self.USER_API_URL, order='email,-solving_issue__short_description'))
)
