def get(self, request, format=None):
return Response(
OrderedDict(
(
(
"peering",
rest_reverse(
"peering-api:api-root", request=request, format=format
),
),
(
"peeringdb",
rest_reverse(
"peeringdb-api:api-root", request=request, format=format
),
),
(
"utils",
rest_reverse(
"utils-api:api-root", request=request, format=format
),
),
)
)
)
def get(self, request, format=None):
return Response(dict(
notes=rest_reverse('main:note-list', request=request, format=format),
notecategories=rest_reverse('main:category-list', request=request,
format=format),
notepikusers=rest_reverse('main:notepikuser-list', request=request,
format=format),
))
def api_root(request, format=None):
return Response({
"Cinemas":
rest_reverse("cinemas", request=request, format=format),
"Movies":
rest_reverse("movies", request=request, format=format),
"Screenings":
rest_reverse("screenings", request=request, format=format),
})
def api_root(request, format=None):
return Response({
'users':
rest_reverse('RedditApp:user-list', request=request, format=format),
'subs':
rest_reverse('RedditApp:subblueit-list',
request=request,
format=format),
'posts':
rest_reverse('RedditApp:post-list', request=request, format=format),
'comments':
rest_reverse('RedditApp:comment-list', request=request, format=format)
})
def api_root_view(request, format=None):
return Response({
'User Register':
rest_reverse('user-registration', request=request, format=format),
'User Log In':
rest_reverse('user-login', request=request, format=format),
'Task List':
rest_reverse('task-list', request=request, format=format),
'Task Create':
rest_reverse('task-create', request=request, format=format),
'Get Task':
rest_reverse('task-get', request=request, format=format)
})
def test_destroy_load_missing(self):
# non-existent loading data cannot be deleted
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, "abcdef"])
self.client.force_login(self.user)
response = self.client.delete(url)
assert response.status_code == status.HTTP_404_NOT_FOUND
def confirm_solicitud(request, token, template=None, source=None):
encoded_string = urlsafe_base64_decode(token)
folio = encoded_string.split('=')[1]
context = {}
try:
clients = ['verifica', 'drivemee']
solicitud = models.Solicitud.objects.get(
folio=folio, status='pendiente', client__deviceToken__in=clients)
# solicitud = models.Solicitud.objects.get(folio=folio, client__deviceToken__in=clients)
except:
return HttpResponseRedirect(reverse('drivemee:index'))
if solicitud.client.deviceToken == 'verifica':
template = 'drivemee/verifica_confirm_solicitud.html'
elif solicitud.client.deviceToken == 'drivemee':
template = 'drivemee/drivemee-confirm-solicitud.html'
solicitud.status = 'abierto'
solicitud.timestamp_confirmacion = timezone.now()
solicitud.save()
context['folio'] = solicitud.internal_folio()
url = rest_reverse('drivemee:solicitud-detail',
args=('agencia', 'activo', solicitud.folio),
request=request)
utilities.send_lead_email(solicitud, request)
slackbot.send_message('Nuevo lead: ' + url, channel='#leadsvalet')
return render(request, template, context)
def test_get(self, version=None, **kwargs):
if not version:
version = self.version
url = rest_reverse('version-detail', kwargs={'pk': version.pk})
res = self.client.get(url, kwargs)
data = res.data
features = data['features']
eq_(res.status_code, 200)
# Test values on Version object.
eq_(data['version'], version.version)
eq_(data['developer_name'], version.developer_name)
eq_(data['is_current_version'],
version == self.app.current_version)
eq_(data['app'], reverse('api_dispatch_detail', kwargs={
'resource_name': 'app',
'api_name': 'apps',
'pk': self.app.pk}
))
for key in features:
ok_(getattr(version.features, 'has_' + key))
def report(self, request, pk=None):
force = request.query_params.get("force", False)
delayed_report, created = self.__return_delayed_report(request)
if created or force:
prepare_report.delay(delayed_report.pk)
data = {"message": "OK", "url": rest_reverse('delayedreport-detail', args=[delayed_report.pk], request=request)}
return Response(data, status=status.HTTP_202_ACCEPTED)
def test_get_units(self):
self.assertEqual(Unit.mock_objects.count(), 2)
response = self.client.get(rest_reverse('mock:unit-list'), follow=True)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content,
"""
{
"count": 2,
"next": null,
"previous": null,
"results": [
{
"id": 1,
"name": "Mon premier labo",
"acronym": "MPL",
"authors": []
},
{
"id": 2,
"name": "Mon institut",
"acronym": "MI",
"authors": []
}
]
}
""")
self.assertEqual(Unit.mock_objects.count(), 2)
def test_fake_argument_is_respected(self):
test_status_code = 300
# first test the standard
response = self.client.get(rest_reverse('mock:unit-detail',
args=[1]), follow=True)
self.assertNotEqual(response.status_code, test_status_code)
response = self.client.get(rest_reverse('mock:unit-detail',
args=[1]) +
'?fake=%s' % test_status_code,
follow=True)
self.assertEqual(response.status_code, test_status_code)
def test_destroy_load_no_permission(self):
# users without permissions cannot delete in-process loading data
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, "abcdef"])
self.client.force_login(UserFactory())
response = self.client.delete(url)
assert response.status_code == status.HTTP_403_FORBIDDEN
def test_get(self, version=None, **kwargs):
if not version:
version = self.version
url = rest_reverse('version-detail', kwargs={'pk': version.pk})
res = self.client.get(url, kwargs)
data = res.data
features = data['features']
eq_(res.status_code, 200)
# Test values on Version object.
eq_(data['version'], version.version)
eq_(data['developer_name'], version.developer_name)
eq_(data['is_current_version'],
version == self.app.current_version)
eq_(data['app'], reverse('api_dispatch_detail', kwargs={
'resource_name': 'app',
'api_name': 'apps',
'pk': self.app.pk}
))
for key in features:
ok_(getattr(version.features, 'has_' + key))
def pdf_file(self, obj):
pdf_ref = rest_reverse(
'invoice-pdf',
kwargs={'uuid': obj.uuid.hex},
)
return format_html('<a href="%s">download</a>' % pdf_ref)
def test_get_units(self):
self.assertEqual(Unit.mock_objects.count(), 2)
response = self.client.get(rest_reverse('mock:unit-list'),
follow=True)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content,
"""
{
"count": 2,
"next": null,
"previous": null,
"results": [
{
"id": 1,
"name": "Name1"
},
{
"id": 2,
"name": "Name2"
}
]
}
""")
self.assertEqual(Unit.mock_objects.count(), 2)
def test_update_load_no_permission(self):
# users without permissions cannot update in-process loading data
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, "abcdef"])
self.client.force_login(UserFactory())
response = self.client.patch(url, format="multipart")
assert response.status_code == status.HTTP_403_FORBIDDEN
def test_get_greetings(self):
self.assertEqual(Greeting.mock_objects.count(), 2)
response = self.client.get(rest_reverse('mock:greeting-list'),
follow=True)
self.assertEqual(response.status_code, 200)
# as order matter, do the order before the check
id_values = list(Greeting.mock_objects.all())
id_values = sorted(id_values, key=lambda tup: tup.pk, reverse=True)
self.assertJSONEqual(
response.content, """
{
"count": 2,
"next": null,
"previous": null,
"results": [
{
"id": %s,
"name": "%s"
},
{
"id": %s,
"name": "%s"
}
]
}
""" % (id_values[0].pk, id_values[0].name,
id_values[1].pk, id_values[1].name))
self.assertEqual(Greeting.mock_objects.count(), 2)
def test_put_greeting(self):
before_count = Greeting.mock_objects.count()
response = self.client.put(rest_reverse('mock:greeting-detail',
args=[1]),
"""
{
"name": "newName"
}
""",
content_type='application/json',
follow=True)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(
response.content, """
{
"id": 1,
"name": "newName"
}
""")
# no new object in the 'mock' db
self.assertEqual(Greeting.mock_objects.count(), before_count)
self.assertNotEqual(Greeting.mock_objects.get(pk=1).name, 'newName')
def test_post_greeting(self):
before_count = Greeting.mock_objects.count()
response = self.client.post(rest_reverse('mock:greeting-list'),
"""
{
"name": "Toto"
}
""",
content_type='application/json',
follow=True)
self.assertEqual(response.status_code, 201)
self.assertJSONEqual(
response.content, """
{
"id": 3,
"name": "Toto"
}
""")
# yes, since it's the mock service, the response is as if something was
# created, but the DB is as before
self.assertEqual(Greeting.mock_objects.count(), before_count)
with self.assertRaises(Greeting.DoesNotExist):
Greeting.mock_objects.get(name='Toto')
def test_update_load_does_not_exist(self):
# non-existent loading data cannot be updated
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, "abcdef"])
self.client.force_login(self.user)
response = self.client.patch(url, format="multipart")
assert response.status_code == status.HTTP_404_NOT_FOUND
def test_post_unit(self):
before_count = Unit.mock_objects.count()
response = self.client.post(rest_reverse('mock:unit-list'),
"""
{
"name": "Toto",
"acronym": "TOTO"
}
""",
content_type='application/json',
follow=True)
self.assertEqual(response.status_code, 201)
self.assertJSONEqual(response.content,
"""
{
"id": 3,
"name": "Toto",
"acronym": "TOTO",
"authors": []
}
""")
# yes, since it's the mock service, the response is as if something was
# created, but the DB is as before
self.assertEqual(Unit.mock_objects.count(), before_count)
with self.assertRaises(Unit.DoesNotExist):
Unit.mock_objects.get(name='Toto')
def test_put_unit(self):
before_count = Unit.mock_objects.count()
response = self.client.put(rest_reverse('mock:unit-detail',
args=[1]),
"""
{
"name": "newName",
"acronym": "newAcro"
}
""",
content_type='application/json',
follow=True)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content,
"""
{
"id": 1,
"name": "newName",
"acronym": "newAcro",
"authors": []
}
""")
# no new object in the 'mock' db
self.assertEqual(Unit.mock_objects.count(), before_count)
self.assertNotEqual(Unit.mock_objects.get(pk=1).name, 'newName')
self.assertNotEqual(Unit.mock_objects.get(pk=1).acronym, 'newAcro')
def get_namespace(name, request, format):
return (
name,
rest_reverse(f"{name}-api:api-root",
request=request,
format=format),
)
def do_patch(self, data=None, client=None):
if data is None:
data = {}
if client is None:
client = self.client
url = rest_reverse("version-status", kwargs={"pk": self.version.pk})
res = self.client.patch(url, data=json.dumps(data), content_type="application/json")
return data, res
def test_fake_argument_is_respected(self):
test_status_code = 300
# first test the standard
response = self.client.get(rest_reverse('mock:greeting-detail',
args=[1]),
follow=True)
self.assertNotEqual(response.status_code, test_status_code)
response = self.client.get(
rest_reverse('mock:greeting-detail', args=[1]) +
'?fake=%s' % test_status_code,
follow=True)
self.assertEqual(response.status_code, test_status_code)
def test_get_non_public(self):
self.app.update(status=amo.STATUS_PENDING)
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 403)
res = self.anon.get(url)
eq_(res.status_code, 403)
def test_get_non_public(self):
self.app.update(status=mkt.STATUS_PENDING)
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 403)
res = self.anon.get(url)
eq_(res.status_code, 403)
def test_update_load_no_parameters(self):
# updating loading data with no changed parameters is fine
load = LoadRequest(study_uuid=self.study.uuid)
load.store()
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, load.request])
self.client.force_login(self.user)
response = self.client.patch(url, format="multipart")
assert response.status_code == status.HTTP_202_ACCEPTED
def test_create_load_without_upload(self):
# trying to post with all required options but no upload is OK
url = rest_reverse("rest:study_load-list", args=[self.study.pk])
payload = self._build_common_payload()
self.client.force_login(self.user)
with patch("edd.load.tasks.wizard_parse_and_resolve") as task:
response = self.client.post(url, payload, format="multipart")
assert response.status_code == status.HTTP_200_OK
task.delay.assert_not_called()
def patch(self, features=None):
data = {
'features': features or ['fm', 'mp3'],
'developer_name': "Cee's Vans"
}
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.patch(url, data=json.dumps(data),
content_type='application/json')
return data, res
def do_patch(self, data=None, client=None):
if data is None:
data = {}
if client is None:
client = self.client
url = rest_reverse('version-status', kwargs={'pk': self.version.pk})
res = self.client.patch(url, data=json.dumps(data),
content_type='application/json')
return data, res
def patch(self, mock_has_permission, features=None, auth=True):
mock_has_permission.return_value = auth
data = {"features": features or ["fm", "mp3"], "developer_name": "Cee's Vans"}
url = rest_reverse("version-detail", kwargs={"pk": self.version.pk})
# Uses PUT because Django's test client didn't support PATCH until
# bug #17797 was resolved.
res = self.client.put(url, data=json.dumps(data), content_type="application/json")
return data, res
def get_url(self, obj, view_name, request, format):
url_kwargs = {
"parent_lookup_suite__job_id": obj.suite.job_id,
"parent_lookup_suite_id": obj.suite_id,
"pk": obj.pk,
}
return rest_reverse(
view_name, kwargs=url_kwargs, request=request, format=format
)
def patch(self, features=None):
data = {
'features': features or ['fm', 'mp3'],
'developer_name': "Cee's Vans"
}
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.patch(url, data=json.dumps(data),
content_type='application/json')
return data, res
def get_url(self, obj, view_name, request, format):
try:
project_status = ProjectStatus.objects.get(pk=obj.pk)
return rest_reverse(view_name,
kwargs={'pk': project_status.build.pk},
request=request,
format=format)
except ProjectStatus.DoesNotExist:
return None
def test_destroy_load(self):
# users with permissions can delete in-process loading data
load = LoadRequest(study_uuid=self.study.uuid)
load.store()
url = rest_reverse("rest:study_load-detail",
args=[self.study.pk, load.request])
self.client.force_login(self.user)
response = self.client.delete(url)
assert response.status_code == status.HTTP_200_OK
def test_create_load_simulated_unknown_error(self):
# simulate an unexpected error (AttributeError) and verify proper response
url = rest_reverse("rest:study_load-list", args=[self.study.pk])
payload = self._build_common_payload()
payload.update(file=BytesIO(b"some file content"))
self.client.force_login(self.user)
with patch("edd.load.rest.views.LoadRequest.store") as store:
store.side_effect = AttributeError
response = self.client.post(url, payload, format="multipart")
assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
def save_model(self, request, obj, form, change):
is_update = obj.created_at is not None
obj.save(using=self.using)
# Save the object to the warehouse as well.
headers = {'Content-Type': 'application/json'}
data = model_to_dict(
obj,
fields=(
'id',
'company',
'address',
'status',
'deliver_by',
),
)
if is_update:
url = request.build_absolute_uri(
rest_reverse(
'warehouse:order-detail',
args=[obj.id],
))
resp = requests.patch(
url,
data=json.dumps(data, cls=CustomJsonEncoder),
headers=headers,
)
else:
url = request.build_absolute_uri(
rest_reverse('warehouse:order-list', ))
resp = requests.post(
url,
data=json.dumps(data, cls=CustomJsonEncoder),
headers=headers,
)
self.logger.debug(
'Store order saved to warehouse status: {}; reason: {}'.format(
resp.status_code,
resp.reason,
), )
def test_app_delete(self):
"""Deleted apps should result in a 404 for the version API."""
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 200)
self.app.delete()
res = self.client.get(url)
eq_(res.status_code, 404)
def put(self, request, question_id, answer_id):
statsd.incr('view_question_n_answer_views_AnswerDetail_PUT')
q, a = self.get_q_n_a(question_id, answer_id)
if a.user_id != request.user.id:
return Response(
{
'Unauthorized':
'You\'re not allowed to update an answer that was posted by others.'
},
status=status.HTTP_400_BAD_REQUEST)
serializer = AnswerSerializer(a, data=request.data)
if serializer.is_valid():
serializer.save()
# TODO
if not settings.TESTING:
sns_msg = {
'on':
'answer_updated',
'question_id':
question_id,
'question_creator_email':
q.user.username,
'question_text':
q.question_text,
'question_url':
rest_reverse('get_put_del_a_question',
args=[question_id],
request=request),
'answer_id':
serializer.data.get('answer_id'),
'answer_text':
serializer.data.get('answer_text'),
'answer_url':
rest_reverse('get_put_del_an_answer',
args=[question_id, answer_id],
request=request)
}
sns.publish(TopicArn=settings.AWS_SNS_TOPIC_ARN,
Message=json.dumps(sns_msg))
else:
print('Testing - Update an answer')
return Response(status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_app_delete(self):
"""Deleted apps should result in a 404 for the version API."""
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 200)
self.app.delete()
res = self.client.get(url)
eq_(res.status_code, 404)
def test_create_load_multiple_permission(self):
# users with multiple group permissions are OK
url = rest_reverse("rest:study_load-list", args=[self.study.pk])
payload = self._build_common_payload()
user = self._add_groups_permission()
self.client.force_login(user)
with patch("edd.load.tasks.wizard_parse_and_resolve") as task:
response = self.client.post(url, payload, format="multipart")
assert response.status_code == status.HTTP_200_OK
task.delay.assert_not_called()
def test_app_delete(self):
"""Deleted apps should result in a 404 for the version API."""
url = rest_reverse("version-detail", kwargs={"pk": self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 200)
self.create_switch("soft_delete")
self.app.delete()
res = self.client.get(url)
eq_(res.status_code, 404)
def test_delete_unit(self):
self.assertTrue(Unit.mock_objects.get(id=1))
response = self.client.delete(rest_reverse('mock:unit-detail',
args=[1]),
follow=True)
self.assertEqual(response.status_code, 204)
# and the object still exists in the 'mock' db (rollbacked)
self.assertTrue(Unit.mock_objects.get(id=1))
def patch(self, features=None):
data = {
'features': features or ['fm', 'mp3'],
'developer_name': "Cee's Vans"
}
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
# Uses PUT because Django's test client didn't support PATCH until
# bug #17797 was resolved.
res = self.client.put(url, data=json.dumps(data),
content_type='application/json')
return data, res
def js_config(request):
"""
Javascript config context processor. Provides urls and
backend-defined settings to be loaded in javascript.
:param request:
:return:
"""
config = {
'latest_tweets_endpoint': rest_reverse(
'twitter_streamer:api:tweets-latest'),
'tweets_list_endpoint': rest_reverse(
'twitter_streamer:api:tweets-list'),
'admin_vote_endpoint': url_reverse(
'twitter_streamer:admin_vote'),
'search_endpoint': url_reverse(
'search:tweet_search'),
'tweet_page_size': settings.TWEET_PAGE_SIZE,
'is_staff': request.user.is_staff
}
return {'js_config': json.dumps(config)}
def test_get_unit_1(self):
response = self.client.get(rest_reverse('mock:unit-detail',
args=[1]),
follow=True)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content,
"""
{
"id": 1,
"name": "Name1"
}
""")
def _get_url(object_type, rdn_value=None): # API URL
"""
<RegexURLPattern servers-detail ^servers/(?P<name>[^/]+)/$>,
<RegexURLPattern servers-aliases ^servers/(?P<name>[^/]+)/aliases/$>,
<RegexURLPattern servers-resources ^servers/(?P<name>[^/]+)/resources/$>,
<RegexURLPattern servers-sudoers ^servers/(?P<name>[^/]+)/sudoers/$>,
<RegexURLPattern servers-users ^servers/(?P<name>[^/]+)/users/$>,
"""
try:
return rest_reverse('%s-detail' % object_type.__class__.__name__.lower(), args=[getattr(object_type, 'name', object_type)])
except NoReverseMatch, e:
# TODO: Resource-model needs API entry
print e
return '/'
def test_get_unit_1(self):
response = self.client.get(rest_reverse('mock:unit-detail',
args=[1]),
follow=True)
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content,
"""
{
"id": 1,
"name": "Mon premier labo",
"acronym": "MPL",
"authors": []
}
""")
def test_fake_argument_dont_do_the_action(self):
test_status_code = 300
before_count = Unit.mock_objects.count()
response = self.client.post(rest_reverse('mock:unit-list') +
'?fake=%s' % test_status_code,
"""
{
"name": "Toto"
}
""",
content_type='application/json')
self.assertEqual(response.status_code, test_status_code)
self.assertEqual(Unit.mock_objects.count(), before_count)
def test_get(self, version=None, **kwargs):
if not version:
version = self.version
url = rest_reverse("version-detail", kwargs={"pk": version.pk})
res = self.client.get(url, kwargs)
data = res.data
features = data["features"]
eq_(res.status_code, 200)
# Test values on Version object.
eq_(data["version"], version.version)
eq_(data["developer_name"], version.developer_name)
eq_(data["is_current_version"], version == self.app.current_version)
eq_(data["app"], reverse("app-detail", kwargs={"pk": self.app.pk}))
for key in features:
ok_(getattr(version.features, "has_" + key))
def get(self, request, format=None):
code='testcode'
urls = {
'main': rest_reverse('api_main', request=request, format=format),
'viersion': rest_reverse('api_version', request=request, format=format),
'api_file': rest_reverse('api_file', kwargs={'code': 'code'}, request=request, format=format),
'api_file_info': reverse('api_file_info', kwargs={'code': 'code'}),
'api_file_list': reverse('api_file_list', kwargs={'id_rule': 1}),
'api_revision_count': reverse('api_revision_count', kwargs={'document': 'code'}),
'api_rules': rest_reverse('api_rules', request=request, format=format),
'api_rules_detail': reverse('api_rules_detail', kwargs={'id_rule': '1'}),
'api_tags': reverse('api_tags', kwargs={'id_rule': '1'}),
'api_plugins': rest_reverse('api_plugins', request=request, format=format),
'api_mdt': rest_reverse('api_mdt', request=request, format=format),
'api_parallel': rest_reverse('api_parallel', request=request, format=format),
'api_thumbnail': reverse('api_thumbnail', kwargs={'code': 'code'}),
'api_file_deprecated': reverse('api_file_deprecated', kwargs={'code': 'code'}),
}
return Response(urls)
def test_get_non_app(self):
self.app.update(type=amo.ADDON_PERSONA)
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 404)
def test_get_owner_non_public(self):
self.app.update(status=mkt.STATUS_PENDING)
self.app.webappuser_set.create(user=self.user)
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 200)
def test_get_reviewer_non_public(self):
self.app.update(status=mkt.STATUS_PENDING)
self.grant_permission(self.profile, 'Apps:Review')
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.get(url)
eq_(res.status_code, 200)
def test_has_cors(self):
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
self.assertCORS(self.client.get(url), 'get', 'put', 'patch')
def test_delete(self):
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
res = self.client.delete(url)
eq_(res.status_code, 405)
def test_get_deleted_app(self):
url = rest_reverse('version-detail', kwargs={'pk': self.version.pk})
self.app.delete()
res = self.client.get(url)
eq_(res.status_code, 404)
def patch(self, features=None):
data = {"features": features or ["fm", "mp3"], "developer_name": "Cee's Vans"}
url = rest_reverse("version-detail", kwargs={"pk": self.version.pk})
res = self.client.patch(url, data=json.dumps(data), content_type="application/json")
return data, res
def get(self, request):
return Response({
'projects': rest_reverse('project_list', request=request),
'organisations': rest_reverse('organisation_list', request=request),
})