def test_can_edit_update_object_within_time_limit(self):
self.force_auth(self.superuser)
url = reverse('ticket-detail', args=[self.ticket.id])
data = {'data': {
'type': format_relation_name('Ticket'),
'id': self.ticket.id,
'attributes': {
'priority': 3
}
}}
response = self.client.patch(url, json.dumps(data), content_type='application/vnd.api+json')
self.assertEqual(response.status_code, 200, response.content.decode())
response_json_data = json.loads(response.rendered_content.decode())
print(response.content.decode())
update_id = response_json_data['data']['relationships']['updates']['data'][0]['id']
url = reverse('update-detail', args=[update_id])
data = {'data': {
'type': format_relation_name('Update'),
'id': update_id,
'attributes': {
'body': "Test comment on changes"
}
}}
response = self.client.patch(url, json.dumps(data), content_type='application/vnd.api+json')
self.assertEqual(response.status_code, 200, response.content.decode())
def test_cannot_edit_update_object_after_time_limit(self):
allowed_delay = settings.TICKET_UPDATE_ALLOW_EDIT_DURATION
def fake_now():
return datetime.datetime.now(tz=pytz.utc) - datetime.timedelta(seconds=allowed_delay + 1)
self.force_auth(self.superuser)
url = reverse('ticket-detail', args=[self.ticket.id])
data = {'data': {
'type': format_relation_name('Ticket'),
'id': self.ticket.id,
'attributes': {
'priority': 3
}
}}
with mock.patch('service.models.update.timezone.now', fake_now):
# create Update object whose created_by is in the past
response = self.client.patch(url, json.dumps(data), content_type='application/vnd.api+json')
self.assertEqual(response.status_code, 200, response.content.decode())
response_json_data = json.loads(response.content.decode())
update_id = response_json_data['data']['relationships']['updates']['data'][0]['id']
url = reverse('update-detail', args=[update_id])
data = {'data': {
'type': format_relation_name('Update'),
'id': update_id,
'attributes': {
'body': "Test comment on changes"
}
}}
response = self.client.patch(url, json.dumps(data), content_type='application/vnd.api+json')
self.assertEqual(response.status_code, 403, response.content.decode())
def test_get_blog_relationship_entry_set(self):
response = self.client.get('/blogs/{}/relationships/entry_set'.format(
self.blog.id))
expected_data = [{
'type': format_relation_name('Entry'),
'id': str(self.first_entry.id)
}, {
'type': format_relation_name('Entry'),
'id': str(self.second_entry.id)
}]
assert response.data == expected_data
def update(self, instance, validated_data):
changed_fields = dict()
for field, value in validated_data.items():
if value != getattr(instance, field):
if isinstance(self.fields.get(field),
serializers.PrimaryKeyRelatedField):
changed_fields[field] = value.id
else:
changed_fields[field] = value
if len(changed_fields) > 0:
update_serializer = UpdateSerializer(
from_ticket=True,
data={
'ticket': {
'type': format_relation_name('Ticket'),
'id': instance.id
},
'changed_fields': changed_fields
},
context=self.context)
update_serializer.is_valid(raise_exception=True)
update_serializer.save()
instance = Ticket.objects.get(pk=instance.pk)
return instance
def test_delete_one_to_many_relationship_with_not_null_constraint(self):
url = '/entries/{}/relationships/comment_set'.format(self.first_entry.id)
request_data = {
'data': [{'type': format_relation_name('Comment'), 'id': str(self.first_comment.id)}, ]
}
response = self.client.delete(url, data=json.dumps(request_data), content_type='application/vnd.api+json')
assert response.status_code == 409, response.content.decode()
def get_resource_type_from_serializer(serializer):
try:
# Check the meta class for resource_name
return serializer.Meta.resource_name
except AttributeError:
# Use the serializer model then pluralize and format
return format_relation_name(serializer.Meta.model.__name__)
def to_representation(self, value):
if getattr(self, 'pk_field', None) is not None:
pk = self.pk_field.to_representation(value.pk)
else:
pk = value.pk
return OrderedDict([('type', format_relation_name(get_resource_type_from_instance(value))), ('id', str(pk))])
def test_delete_to_many_relationship_with_change(self):
url = '/authors/{}/relationships/comment_set'.format(self.author.id)
request_data = {
'data': [{'type': format_relation_name('Comment'), 'id': str(self.second_comment.id)}, ]
}
response = self.client.delete(url, data=json.dumps(request_data), content_type='application/vnd.api+json')
assert response.status_code == 200, response.content.decode()
def test_delete_to_one_relationship_should_fail(self):
url = '/entries/{}/relationships/blog'.format(self.first_entry.id)
request_data = {
'data': {'type': format_relation_name('Blog'), 'id': str(self.other_blog.id)}
}
response = self.client.delete(url, data=json.dumps(request_data), content_type='application/vnd.api+json')
assert response.status_code == 405, response.content.decode()
def test_data_in_correct_format_when_instantiated_with_queryset(self):
qs = Author.objects.all()
serializer = ResourceIdentifierObjectSerializer(instance=qs, many=True)
type_string = format_relation_name('Author')
author_pks = Author.objects.values_list('pk', flat=True)
expected_data = [{'type': type_string, 'id': str(pk)} for pk in author_pks]
assert serializer.data == expected_data
def test_deserialize_primitive_data_blog(self):
initial_data = {
'type': format_relation_name('Blog'),
'id': str(self.blog.id)
}
serializer = ResourceIdentifierObjectSerializer(data=initial_data, model_class=Blog)
self.assertTrue(serializer.is_valid(), msg=serializer.errors)
assert serializer.validated_data == self.blog
def test_get_to_many_relationship_self_link(self):
url = '/authors/{}/relationships/comment_set'.format(self.author.id)
response = self.client.get(url)
expected_data = {
'links': {'self': 'http://testserver/authors/1/relationships/comment_set'},
'data': [{'id': str(self.second_comment.id), 'type': format_relation_name('Comment')}]
}
assert json.loads(response.content.decode('utf-8')) == expected_data
def to_internal_value(self, data):
if data['type'] != format_relation_name(self.model_class.__name__):
self.fail('incorrect_model_type', model_type=self.model_class, received_type=data['type'])
pk = data['id']
try:
return self.model_class.objects.get(pk=pk)
except ObjectDoesNotExist:
self.fail('does_not_exist', pk_value=pk)
except (TypeError, ValueError):
self.fail('incorrect_type', data_type=type(data['pk']).__name__)
def test_patch_to_one_relationship(self):
url = '/entries/{}/relationships/blog'.format(self.first_entry.id)
request_data = {
'data': {'type': format_relation_name('Blog'), 'id': str(self.other_blog.id)}
}
response = self.client.patch(url, data=json.dumps(request_data), content_type='application/vnd.api+json')
assert response.status_code == 200, response.content.decode()
response = self.client.get(url)
assert response.data == request_data['data']
def test_deserialize_many(self):
type_string = format_relation_name('Author')
author_pks = Author.objects.values_list('pk', flat=True)
initial_data = [{'type': type_string, 'id': str(pk)} for pk in author_pks]
serializer = ResourceIdentifierObjectSerializer(data=initial_data, model_class=Author, many=True)
self.assertTrue(serializer.is_valid(), msg=serializer.errors)
print(serializer.data)
def to_representation(self, value):
if getattr(self, 'pk_field', None) is not None:
pk = self.pk_field.to_representation(value.pk)
else:
pk = value.pk
return OrderedDict([
('type',
format_relation_name(get_resource_type_from_instance(value))),
('id', str(pk))
])
def test_data_in_correct_format_when_instantiated_with_entry_object(self):
serializer = EntryFKSerializer(instance={'entry': self.entry})
expected_data = {
'type': format_relation_name('Entry'),
'id': str(self.entry.id)
}
actual_data = serializer.data['entry']
self.assertEqual(actual_data, expected_data)
def test_data_in_correct_format_when_instantiated_with_blog_object(self):
serializer = BlogFKSerializer(instance={'blog': self.blog})
expected_data = {
'type': format_relation_name('Blog'),
'id': str(self.blog.id)
}
actual_data = serializer.data['blog']
self.assertEqual(actual_data, expected_data)
def test_deserialize_primitive_data_blog(self):
serializer = BlogFKSerializer(data={
'blog': {
'type': format_relation_name('Blog'),
'id': str(self.blog.id)
}
}
)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data['blog'], self.blog)
def test_deserialize_many_to_many_relation(self):
type_string = format_relation_name('Author')
author_pks = Author.objects.values_list('pk', flat=True)
authors = [{'type': type_string, 'id': pk} for pk in author_pks]
serializer = EntryModelSerializer(data={'authors': authors, 'comment_set': []})
self.assertTrue(serializer.is_valid())
self.assertEqual(len(serializer.validated_data['authors']), Author.objects.count())
for author in serializer.validated_data['authors']:
self.assertIsInstance(author, Author)
def test_serialize_many_to_many_relation(self):
serializer = EntryModelSerializer(instance=self.entry)
type_string = format_relation_name('Author')
author_pks = Author.objects.values_list('pk', flat=True)
expected_data = [{'type': type_string, 'id': str(pk)} for pk in author_pks]
self.assertEqual(
serializer.data['authors'],
expected_data
)
def to_internal_value(self, data):
if data['type'] != format_relation_name(self.model_class.__name__):
self.fail('incorrect_model_type',
model_type=self.model_class,
received_type=data['type'])
pk = data['id']
try:
return self.model_class.objects.get(pk=pk)
except ObjectDoesNotExist:
self.fail('does_not_exist', pk_value=pk)
except (TypeError, ValueError):
self.fail('incorrect_type', data_type=type(data['pk']).__name__)
def test_delete_to_one_relationship_should_fail(self):
url = '/entries/{}/relationships/blog'.format(self.first_entry.id)
request_data = {
'data': {
'type': format_relation_name('Blog'),
'id': str(self.other_blog.id)
}
}
response = self.client.delete(url,
data=json.dumps(request_data),
content_type='application/vnd.api+json')
assert response.status_code == 405, response.content.decode()
def test_returns_current_person(self):
self.authenticate_without_otp()
response = self.client.get('/api/me')
self.assertEqual(
response.status_code,
status.HTTP_200_OK,
get_response_info_string(response)
)
response_data = json.loads(response.content.decode())
self.assertEqual(response_data['data']['type'], format_relation_name('Person'))
self.assertEqual(response_data['data']['id'], str(self.current_person.id))
def test_get_entry_relationship_blog(self):
url = reverse('entry-relationships',
kwargs={
'pk': self.first_entry.id,
'related_field': 'blog'
})
response = self.client.get(url)
expected_data = {
'type': format_relation_name('Blog'),
'id': str(self.first_entry.blog.id)
}
assert response.data == expected_data
def test_delete_to_many_relationship_with_change(self):
url = '/authors/{}/relationships/comment_set'.format(self.author.id)
request_data = {
'data': [
{
'type': format_relation_name('Comment'),
'id': str(self.second_comment.id)
},
]
}
response = self.client.delete(url,
data=json.dumps(request_data),
content_type='application/vnd.api+json')
assert response.status_code == 200, response.content.decode()
def test_get_to_many_relationship_self_link(self):
url = '/authors/{}/relationships/comment_set'.format(self.author.id)
response = self.client.get(url)
expected_data = {
'links': {
'self': 'http://testserver/authors/1/relationships/comment_set'
},
'data': [{
'id': str(self.second_comment.id),
'type': format_relation_name('Comment')
}]
}
assert json.loads(response.content.decode('utf-8')) == expected_data
def test_patch_to_one_relationship(self):
url = '/entries/{}/relationships/blog'.format(self.first_entry.id)
request_data = {
'data': {
'type': format_relation_name('Blog'),
'id': str(self.other_blog.id)
}
}
response = self.client.patch(url,
data=json.dumps(request_data),
content_type='application/vnd.api+json')
assert response.status_code == 200, response.content.decode()
response = self.client.get(url)
assert response.data == request_data['data']
def test_delete_one_to_many_relationship_with_not_null_constraint(self):
url = '/entries/{}/relationships/comment_set'.format(
self.first_entry.id)
request_data = {
'data': [
{
'type': format_relation_name('Comment'),
'id': str(self.first_comment.id)
},
]
}
response = self.client.delete(url,
data=json.dumps(request_data),
content_type='application/vnd.api+json')
assert response.status_code == 409, response.content.decode()
def to_representation(self, instance):
return {
'type':
format_relation_name(get_resource_type_from_instance(instance)),
'id': str(instance.pk)
}
def test_get_blog_relationship_entry_set(self):
response = self.client.get('/blogs/{}/relationships/entry_set'.format(self.blog.id))
expected_data = [{'type': format_relation_name('Entry'), 'id': str(self.first_entry.id)},
{'type': format_relation_name('Entry'), 'id': str(self.second_entry.id)}]
assert response.data == expected_data
def test_data_in_correct_format_when_instantiated_with_entry_object(self):
serializer = ResourceIdentifierObjectSerializer(instance=self.entry)
expected_data = {'type': format_relation_name('Entry'), 'id': str(self.entry.id)}
assert serializer.data == expected_data
def test_format_relation_name():
assert utils.format_relation_name('first_name', 'capitalize') == 'FirstNames'
assert utils.format_relation_name('first_name', 'camelize') == 'firstNames'
def to_representation(self, instance):
return {
'type': format_relation_name(get_resource_type_from_instance(instance)),
'id': str(instance.pk)
}
def get_resource_name(self):
if not hasattr(self, '_resource_name'):
instance = getattr(self.get_object(), self.kwargs['related_field'])
self._resource_name = format_relation_name(get_resource_type_from_instance(instance))
return self._resource_name
def get_resource_name(self):
if not hasattr(self, '_resource_name'):
instance = getattr(self.get_object(), self.kwargs['related_field'])
self._resource_name = format_relation_name(
get_resource_type_from_instance(instance))
return self._resource_name
def test_get_entry_relationship_blog(self):
url = reverse('entry-relationships', kwargs={'pk': self.first_entry.id, 'related_field': 'blog'})
response = self.client.get(url)
expected_data = {'type': format_relation_name('Blog'), 'id': str(self.first_entry.blog.id)}
assert response.data == expected_data
def test_format_relation_name():
assert utils.format_relation_name('first_name',
'capitalize') == 'FirstNames'
assert utils.format_relation_name('first_name', 'camelize') == 'firstNames'
