def test_register(self):
"Registering a new serializer populates the full registry. Refs #14823"
serializers.register_serializer('json3', 'django.core.serializers.json')
public_formats = serializers.get_public_serializer_formats()
self.assertIn('json3', public_formats)
self.assertIn('json2', public_formats)
self.assertIn('xml', public_formats)
def test_register(self):
"Registering a new serializer populates the full registry. Refs #14823"
serializers.register_serializer("json3", "django.core.serializers.json")
public_formats = serializers.get_public_serializer_formats()
self.assertIn("json3", public_formats)
self.assertIn("json2", public_formats)
self.assertIn("xml", public_formats)
def test_register(self):
"Registering a new serializer populates the full registry. Refs #14823"
serializers.register_serializer("json3", "django.core.serializers.json")
public_formats = serializers.get_public_serializer_formats()
self.assertIn("json3", public_formats)
self.assertIn("json2", public_formats)
self.assertIn("xml", public_formats)
def test_register(self):
"Registering a new serializer populates the full registry. Refs #14823"
serializers.register_serializer('json3', 'django.core.serializers.json')
public_formats = serializers.get_public_serializer_formats()
self.assertIn('json3', public_formats)
self.assertIn('json2', public_formats)
self.assertIn('xml', public_formats)
def test_unregister(self):
"Unregistering a serializer doesn't cause the registry to be repopulated. Refs #14823"
serializers.unregister_serializer('xml')
serializers.register_serializer('json3', 'django.core.serializers.json')
public_formats = serializers.get_public_serializer_formats()
self.assertNotIn('xml', public_formats)
self.assertIn('json3', public_formats)
def test_unregister(self):
"Unregistering a serializer doesn't cause the registry to be repopulated. Refs #14823"
serializers.unregister_serializer('xml')
serializers.register_serializer('json3', 'django.core.serializers.json')
public_formats = serializers.get_public_serializer_formats()
self.assertNotIn('xml', public_formats)
self.assertIn('json3', public_formats)
def run(cls, instance):
from django.core.serializers import register_serializer, serialize
from django.db.models import Model
if not isinstance(instance, Model):
raise SkipBackend()
register_serializer('bluedata', 'apification.utils.django_serializer')
fake_qs = instance.__class__.objects.none()
fake_qs.result_cache = [instance]
return serialize("bluedata", fake_qs)[0]
def test_unregister(self):
"""
Unregistering a serializer doesn't cause the registry to be
repopulated.
"""
serializers.unregister_serializer("xml")
serializers.register_serializer("json3", "django.core.serializers.json")
public_formats = serializers.get_public_serializer_formats()
self.assertNotIn("xml", public_formats)
self.assertIn("json3", public_formats)
def test_custom_serializer(self):
register_serializer('custom', 'examples.django_roa_client.serializers')
initial_roa_format_setting = settings.ROA_FORMAT
settings.ROA_FORMAT = 'custom'
page = RemotePage.objects.create(title=u'A custom serialized page')
self.assertEqual(repr(page), '<RemotePage: A custom serialized page (1)>')
r = Resource('http://127.0.0.1:8081/django_roa_server/remotepage/', filters=ROA_FILTERS)
response = r.get(**{'format': 'custom'})
self.assertEqual(repr(response.body_string()), '\'<?xml version="1.0" encoding="utf-8"?>\\n<django-test version="1.0">\\n <object pk="1" model="django_roa_server.remotepage">\\n <field type="CharField" name="title">A custom serialized page</field>\\n </object>\\n</django-test>\'')
self.assertEqual(len(RemotePage.objects.all()), 1)
page = RemotePage.objects.get(id=page.id)
self.assertEqual(repr(page), '<RemotePage: A custom serialized page (1)>')
settings.ROA_FORMAT = initial_roa_format_setting
def ready(self):
"""
Load modules returned by `get_load_modules_when_ready` by default
when app is ready.
"""
super().ready()
serializers.register_serializer("json", "ralph.lib.serializers")
package = self.module.__name__
for module in self.get_load_modules_when_ready():
try:
import_module('{}.{}'.format(package, module))
except ImportError:
pass
def test_custom_serializer(self):
register_serializer('custom', 'examples.django_roa_client.serializers')
initial_roa_format_setting = settings.ROA_FORMAT
settings.ROA_FORMAT = 'custom'
page = RemotePage.objects.create(title=u'A custom serialized page')
self.assertEqual(repr(page),
'<RemotePage: A custom serialized page (1)>')
r = Resource('http://127.0.0.1:8081/django_roa_server/remotepage/',
filters=ROA_FILTERS)
response = r.get(**{'format': 'custom'})
self.assertEqual(
repr(response.body_string()),
'\'<?xml version="1.0" encoding="utf-8"?>\\n<django-test version="1.0">\\n <object pk="1" model="django_roa_server.remotepage">\\n <field type="CharField" name="title">A custom serialized page</field>\\n </object>\\n</django-test>\''
)
self.assertEqual(len(RemotePage.objects.all()), 1)
page = RemotePage.objects.get(id=page.id)
self.assertEqual(repr(page),
'<RemotePage: A custom serialized page (1)>')
settings.ROA_FORMAT = initial_roa_format_setting
def ready(self):
"""
Register dbdiff.serializers.json and set debug.
Enables debug if a DBDIFF_DEBUG environment variable is found.
It is important to use serializers which dump data in a predictible way
because this app relies on diff between an expected - user-generated
and versioned - fixture and dumped database data. This method also
overrides the default json serializer with dbdiff's.
When dbdiff is installed, ``dumpdata`` will use its serializers which
have predictible output and cross-database support, so fixtures dumped
without dbdiff installed will have to be regenerated after dbdiff is
installed to be usable with dbdiff.
"""
self.debug = os.environ.get('DBDIFF_DEBUG', False)
register_serializer('json', 'dbdiff.serializers.json')
patch_transaction_test_case()
class ReviewTestCase(TestCase):
register_serializer('yml', 'django.core.serializers.pyyaml')
fixtures = [
'api/tests/fixtures/user.yml', 'api/tests/fixtures/climb.yml',
'api/tests/fixtures/review.yml'
]
def setUp(self):
self.client = APIClient()
self.factory = APIRequestFactory()
def test_review_viewset_list_route(self):
request = self.factory.get('/api/review')
view = ReviewViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 5)
def test_review_viewset_list_route_filters_by_climb(self):
request = self.factory.get('/api/review?climb=1')
view = ReviewViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_review_viewset_list_route_filters_by_user(self):
request = self.factory.get('/api/review?user=1')
view = ReviewViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_review_viewset_list_route_for_auth_user(self):
request = self.factory.get('/api/review/me')
view = ReviewViewSet.as_view(actions={'get': 'me'})
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_review_viewset_list_route_for_auth_user_with_auth_error(self):
request = self.factory.get('/api/review/me')
view = ReviewViewSet.as_view(actions={'get': 'me'})
response = view(request)
self.assertEqual(response.status_code, 403)
def test_review_viewset_retrieve_route(self):
request = self.factory.get('/api/review')
view = ReviewViewSet.as_view(actions={'get': 'retrieve'})
response = view(request, pk=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(
set(response.data.keys()),
set([
'id', 'climb', 'user', 'text', 'score', 'created_at',
'updated_at'
]))
self.assertEqual(response.data['climb'], 1)
def test_review_viewset_create_route(self):
view = ReviewViewSet.as_view(actions={'post': 'create'})
data = {'climb': 3, 'score': 4, 'text': "Review"}
request = self.factory.post('/api/review', data=data, format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['climb'], 3)
self.assertEqual(response.data['score'], 4)
def test_review_viewset_create_route_with_invalid_data(self):
view = ReviewViewSet.as_view(actions={'post': 'create'})
data = {'climb': 3, 'score': 8, 'text': "Review"}
request = self.factory.post('/api/review', data=data, format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()), set(['score']))
def test_review_viewset_create_route_with_invalid_repeat_data(self):
view = ReviewViewSet.as_view(actions={'post': 'create'})
data = {'climb': 1, 'score': 2, 'text': "Review"}
request = self.factory.post('/api/review', data=data, format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 400)
def test_review_viewset_fails_to_create_if_no_user_is_authenticated(self):
view = ReviewViewSet.as_view(actions={'post': 'create'})
data = {'climb': 3, 'score': 4, 'text': "Review"}
request = self.factory.post('/api/review', data=data, format='json')
response = view(request)
self.assertEqual(response.status_code, 401)
def test_review_viewset_update_route_updates_data(self):
view = ReviewViewSet.as_view(actions={'put': 'update'})
data = {
'score': 4,
}
request = self.factory.put('/api/review', data=data)
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['score'], 4)
self.assertEqual(response.data['climb'], 1)
def test_review_viewset_update_route_fails_to_update_if_no_user_autenticated(
self):
view = ReviewViewSet.as_view(actions={'put': 'update'})
data = {
'score': 4,
}
request = self.factory.put('/api/review', data=data)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_review_viewset_update_route_fails_to_update_if_wrong_user_autenticated(
self):
view = ReviewViewSet.as_view(actions={'put': 'update'})
data = {
'score': 4,
}
request = self.factory.put('/api/review', data=data)
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
def test_review_viewset_destroy_route(self):
view = ReviewViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/review')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 204)
def test_review_viewset_delete_route_fails_if_no_user_autenticated(self):
view = ReviewViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/review')
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_review_viewset_update_route_fails_if_wrong_user_autenticated(
self):
view = ReviewViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/review')
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
from django.core.serializers import register_serializer
register_serializer('roughage', 'roughage.serializers')
from roughage.base import Seed
__all__ = ['Seed']
CompactCsvSerializer = Serializer
def parser(stream, **options):
reader = CsvReader(stream)
headers = reader.next()
label, pk = headers[0].split(':')
yield {label: [pk] + headers[1:]}
for row in reader:
yield row
class Deserializer(compact_python.Deserializer):
"Deserialize a stream or string of compact CSV into DeserializedValuesObject instances."
multiple_streams = True
def __init__(self, stream_or_string, **options):
if isinstance(stream_or_string, bytes):
stream_or_string = stream_or_string.decode('utf-8')
if isinstance(stream_or_string, six.string_types):
self.stream = six.StringIO(stream_or_string)
else:
self.stream = stream_or_string
super(Deserializer, self).__init__(parser(self.stream), **options)
CompactCsvDeserializer = Deserializer
register_serializer('compact_csv', __name__)
CompactYamlSerializer = Serializer
def parser(stream):
lines = []
for line in iter(stream.readline, ''):
if len(lines) >= 1000 and line.startswith('-'):
for obj in yaml.load(''.join(lines)):
yield obj
lines = []
lines.append(line)
for obj in yaml.load(''.join(lines), Loader=SafeLoader):
yield obj
class Deserializer(compact_python.Deserializer):
"Deserialize a stream or string of compact YAML into DeserializedValuesObject instances."
def __init__(self, stream_or_string, **options):
if isinstance(stream_or_string, bytes):
stream_or_string = stream_or_string.decode('utf-8')
if isinstance(stream_or_string, six.string_types):
self.stream = six.StringIO(stream_or_string)
else:
self.stream = stream_or_string
super(Deserializer, self).__init__(parser(self.stream), **options)
CompactYamlDeserializer = Deserializer
register_serializer('compact_yaml', __name__)
delegate_position_form_factory,
FeeForm,
DatePenaltyForm,
)
from regimun_app.models import Conference, Committee, Country, DelegatePosition, School, Payment, Fee, DatePenalty
from regimun_app.utils import UnicodeCSVDictReader
from regimun_app.views.school_admin import is_school_registered
from regimun_app.views.secretariat_admin import secretariat_authenticate
import csv
import exceptions
import inspect
import settings
import string
if "jsondisplay" not in get_serializer_formats():
register_serializer("jsondisplay", "regimun_app.serializers.DisplayNameJsonSerializer")
@login_required
def conference_ajax_functions(request, conference_slug, func_name):
conference = get_object_or_404(Conference, url_name=conference_slug)
func_name = string.replace(func_name, "-", "_")
if (
secretariat_authenticate(request, conference)
and func_name in globals()
and inspect.isfunction(globals()[func_name])
):
return_value = globals()[func_name](request, conference)
if return_value != None:
if isinstance(return_value, HttpResponse):
from django.db.models.loading import get_model
from django.db.models.fields.related import ManyToManyField, RelatedField
from django.db.models.query import QuerySet
from django.core.serializers import deserialize, register_serializer
from django.contrib.contenttypes.models import ContentType
from django.db.models.signals import post_save, pre_delete, pre_save, post_delete
from django.utils.encoding import force_text
from reversion.models import Revision, Version, VERSION_ADD, VERSION_CHANGE, VERSION_DELETE, has_int_pk, pre_revision_commit, post_revision_commit
from celery import current_app
from celery.contrib.methods import task_method
from celery.utils.log import get_task_logger
from celery import current_task
logger = get_task_logger(__name__)
register_serializer('yaml_custom_m2m', "reversion.serializer.yaml_serializer_custom")
was_changed_message = u'Изменен {0}:'
changes_template = u"\t- {verbose_name}: \"{value_from}\" -> \"{value_to}\""
no_value_message = u'Нет значения.'
saved_without_changes_message = u"Сохранен без изменений {0}."
was_created_message = u'Создан {0}.'
was_deleted_message = u'Удален {0}.'
def get_object_smart_repr(object):
return u"{0} {1}".format(force_text(object._meta.verbose_name.capitalize()), force_text(object.__unicode__()))
class VersionAdapter(object):
def json_deserializer():
get_serializer_formats()
from django.core.serializers import _serializers
register_serializer('json', 'tb_website.serializers', _serializers)
from django.core.serializers import register_serializer
from django.db.models.base import ModelBase
from django.db.models.loading import get_app, get_models
from django.db.models.query import QuerySet
from nicedjango._compat import basestring
from nicedjango.graph.dumper import Dumper
from nicedjango.graph.loader import Loader
from nicedjango.graph.node import Node
from nicedjango.graph.utils import nodes_as_string, sort_nodes
from nicedjango.utils import coerce_tuple, divide_model_def, queryset_from_def, RememberingSet
from nicedjango.utils.py.iter import filter_attrs
from nicedjango.utils.py.string import divide_string
register_serializer('compact_csv', 'nicedjango.serializers.compact_csv')
register_serializer('compact_python', 'nicedjango.serializers.compact_python')
register_serializer('compact_yaml', 'nicedjango.serializers.compact_yaml')
__all__ = ['ModelGraph']
class ModelGraph(object):
def __init__(self, queries=None, relations=None, app=None, chunksize=100000):
self.nodes = {}
self.includes = set()
self._new_nodes = RememberingSet()
if app:
if queries or relations:
raise ValueError('queries or relations can\'t be defined '
# coding=utf-8
from django.core import serializers
serializers.register_serializer('json', 'djmoney.serializers')
def parser(stream):
lines = []
for line in iter(stream.readline, ''):
if len(lines) >= 1000 and line.startswith('-'):
for obj in yaml.load(''.join(lines)):
yield obj
lines = []
lines.append(line)
for obj in yaml.load(''.join(lines), Loader=SafeLoader):
yield obj
class Deserializer(compact_python.Deserializer):
"Deserialize a stream or string of compact YAML into DeserializedValuesObject instances."
def __init__(self, stream_or_string, **options):
if isinstance(stream_or_string, bytes):
stream_or_string = stream_or_string.decode('utf-8')
if isinstance(stream_or_string, six.string_types):
self.stream = six.StringIO(stream_or_string)
else:
self.stream = stream_or_string
super(Deserializer, self).__init__(parser(self.stream), **options)
CompactYamlDeserializer = Deserializer
register_serializer('compact_yaml', __name__)
import copy
from django.db import models
from django.core import serializers
from django.core.exceptions import ValidationError
from django.utils import timezone
WING_JSON_FORMAT = 'wing_json'
serializers.register_serializer(WING_JSON_FORMAT, __package__ + '.serializer_json')
def create_model_from_request(mod, request):
if request.method == 'GET':
data = request.GET
elif request.method == 'POST':
data = request.POST
else:
raise Exception('unsupported method')
return create_model_from_dict(mod, data)
ESCAPE_KEYS = ['id']
def create_model_from_dict(mod, dicta):
m = mod()
for k, v in dicta.items():
if k in ESCAPE_KEYS:
continue
if hasattr(m, k):
obj = self.model._default_manager.db_manager(using).get_by_natural_key(*self.identifier)
return obj
except self.model.DoesNotExist:
# Pass, since it could be a list of PKs
pass
# Is self.identifier the PK value of an instance of the related model?
else:
try:
obj = self.model._default_manager.db_manager(using).get(pk=self.identifier)
return obj
except self.model.DoesNotExist:
raise RelatedObjectError('No %s objects with primary key %s exist.' % \
(self.model._meta.object_name, self.identifier)
)
class DelayedMilkmanDelivery(dict):
"""
No-op dictionary subclass to aid in identifying the use of Milkman in the
loader methods. Not the most pythonic way, relying on isinstance for it,
but the least work to fit this in with the logic that existed before
Milkman support.
"""
pass
from django.core.serializers import register_serializer
# Not thread safe according to the register_serializer docstring, don't know
# if it matters here or not.
register_serializer('class', 'class_fixtures.serializer')
from regimun_app.forms import jEditableForm, BasicConferenceInfoForm, \
NewCommitteeForm, NewCountryForm, UploadFileForm, NewPaymentForm, \
delegate_position_form_factory, FeeForm, DatePenaltyForm
from regimun_app.models import Conference, Committee, Country, DelegatePosition, \
School, Payment, Fee, DatePenalty
from regimun_app.utils import UnicodeCSVDictReader
from regimun_app.views.school_admin import is_school_registered
from regimun_app.views.secretariat_admin import secretariat_authenticate
import csv
import exceptions
import inspect
import settings
import string
if 'jsondisplay' not in get_serializer_formats():
register_serializer('jsondisplay', 'regimun_app.serializers.DisplayNameJsonSerializer')
@login_required
def conference_ajax_functions(request, conference_slug, func_name):
conference = get_object_or_404(Conference, url_name=conference_slug)
func_name = string.replace(func_name, "-", "_")
if secretariat_authenticate(request, conference) and func_name in globals() and inspect.isfunction(globals()[func_name]):
return_value = globals()[func_name](request, conference)
if return_value != None:
if isinstance(return_value, HttpResponse):
return return_value
else:
return HttpResponse(return_value, mimetype='application/javascript')
#return HttpResponse("<html><body>" + return_value + "</body></html>")
class AchievementTestCase(TestCase):
register_serializer('yml', 'django.core.serializers.pyyaml')
fixtures = [
'api/tests/fixtures/user.yml', 'api/tests/fixtures/climb.yml',
'api/tests/fixtures/achievement.yml'
]
def setUp(self):
self.client = APIClient()
self.factory = APIRequestFactory()
def test_achievement_viewset_list_route(self):
request = self.factory.get('/api/achievement')
view = AchievementViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 6)
def test_achievement_viewset_list_route_filters_by_climb(self):
request = self.factory.get('/api/achievement?climb=1')
view = AchievementViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_achievement_viewset_list_route_filters_by_user(self):
request = self.factory.get('/api/achievement?user=1')
view = AchievementViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 4)
def test_achievement_viewset_list_route_for_auth_user(self):
request = self.factory.get('/api/achievement/me')
view = AchievementViewSet.as_view(actions={'get': 'me'})
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(len(response.data['results']), 4)
def test_achievement_viewset_list_route_for_auth_user_with_auth_error(
self):
request = self.factory.get('/api/achievement/me')
view = AchievementViewSet.as_view(actions={'get': 'me'})
response = view(request)
self.assertEqual(response.status_code, 403)
def test_achievement_viewset_retrieve_route(self):
request = self.factory.get('/api/achievement')
view = AchievementViewSet.as_view(actions={'get': 'retrieve'})
response = view(request, pk=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(
set(response.data.keys()),
set(['id', 'climb', 'user', 'time', 'date', 'created_at']))
self.assertEqual(response.data['climb'], 1)
def test_achievement_viewset_create_route(self):
view = AchievementViewSet.as_view(actions={'post': 'create'})
data = {'climb': 1, 'time': 3600, 'date': "2019-02-12"}
request = self.factory.post('/api/achievement',
data=data,
format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['climb'], 1)
def test_achievement_viewset_create_route_with_undefined_required_data(
self):
view = AchievementViewSet.as_view(actions={'post': 'create'})
data = {'time': 3600, 'date': "2019-02-12"}
request = self.factory.post('/api/achievement',
data=data,
format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()), set(['climb']))
def test_achievement_viewset_create_route_with_undefined_non_required_data(
self):
view = AchievementViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 1,
}
request = self.factory.post('/api/achievement',
data=data,
format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['climb'], 1)
self.assertEqual(response.data['time'], None)
self.assertEqual(response.data['date'], str(date.today()))
def test_achievement_viewset_fails_to_create_if_no_user_is_authenticated(
self):
view = AchievementViewSet.as_view(actions={'post': 'create'})
data = {'climb': 1, 'time': 3600, 'date': "2019-02-12"}
request = self.factory.post('/api/achievement',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 401)
def test_achievement_viewset_update_route_updates_data(self):
view = AchievementViewSet.as_view(actions={'put': 'update'})
data = {'time': 1000}
request = self.factory.put('/api/achievement', data=data)
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['time'], 1000)
self.assertEqual(response.data['climb'], 1)
def test_achievement_viewset_update_route_fails_to_update_if_no_user_autenticated(
self):
view = AchievementViewSet.as_view(actions={'put': 'update'})
data = {'time': 1000}
request = self.factory.put('/api/achievement', data=data)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_achievement_viewset_update_route_fails_to_update_if_wrong_user_autenticated(
self):
view = AchievementViewSet.as_view(actions={'put': 'update'})
data = {'time': 1000}
request = self.factory.put('/api/achievement', data=data)
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
def test_achievement_viewset_destroy_route(self):
view = AchievementViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/achievement')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 204)
def test_achievement_viewset_delete_route_fails_if_no_user_autenticated(
self):
view = AchievementViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/achievement')
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_achievement_viewset_update_route_fails_if_wrong_user_autenticated(
self):
view = AchievementViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/achievement')
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
# -*- coding: utf-8 -*-
from django.core import serializers
serializers.register_serializer("json", "djmoney.serializers")
from django.core.serializers import register_serializer
register_serializer("xlsx", 'expenses.core.serializers.excel')
from django.core import serializers as serializers
serializers.register_serializer("json", 'djmoney.serializers')
if app_model in self:
self[app_model] += (mod,)
else:
self[app_model] = (mod,)
def get_for_model(self, app_model):
try:
return self[app_model]
except KeyError:
return ()
transform = Transformer()
# Django's
register_serializer("xml", "django.core.serializers.xml_serializer")
# Wad O' Stuff
register_serializer("python","apibuilder.wadofstuff.python")
register_serializer("json", "apibuilder.wadofstuff.json")
# Extras
register_serializer('html','apibuilder.serializers.html')
register_serializer('csv','apibuilder.serializers.csv_')
register_serializer('pickle','apibuilder.serializers.pickle')
try:
register_serializer("yaml", "django.core.serializers.pyyaml")
except ImportError:
pass
try:
class BookmarkTestCase(TestCase):
register_serializer('yml', 'django.core.serializers.pyyaml')
fixtures = [
'api/tests/fixtures/user.yml', 'api/tests/fixtures/climb.yml',
'api/tests/fixtures/bookmark.yml'
]
def setUp(self):
self.client = APIClient()
self.factory = APIRequestFactory()
def test_bookmark_viewset_list_route(self):
request = self.factory.get('/api/bookmark')
view = BookmarkViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 4)
def test_bookmark_viewset_list_route_fills_climb_data(self):
request = self.factory.get('/api/bookmark')
view = BookmarkViewSet.as_view(actions={'get': 'list'})
response = view(request)
climb = response.data['results'][0]['climb']
self.assertEqual(
set(climb.keys()),
set([
'id', 'name', 'altitude', 'extent', 'gradient', 'gain',
'distance', 'center'
]))
def test_bookmark_viewset_list_route_filters_by_climb(self):
request = self.factory.get('/api/bookmark?climb=1')
view = BookmarkViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_bookmark_viewset_list_route_filters_by_user(self):
request = self.factory.get('/api/bookmark?user=1')
view = BookmarkViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_bookmark_viewset_list_route_for_auth_user(self):
request = self.factory.get('/api/bookmark/me')
view = BookmarkViewSet.as_view(actions={'get': 'me'})
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(len(response.data['results']), 2)
def test_bookmark_viewset_list_route_for_auth_user_with_auth_error(self):
request = self.factory.get('/api/bookmark/me')
view = BookmarkViewSet.as_view(actions={'get': 'me'})
response = view(request)
self.assertEqual(response.status_code, 403)
def test_bookmark_viewset_retrieve_route(self):
request = self.factory.get('/api/bookmark')
view = BookmarkViewSet.as_view(actions={'get': 'retrieve'})
response = view(request, pk=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(response.data.keys()),
set(['id', 'climb', 'user', 'created_at']))
self.assertEqual(response.data['user'], 1)
def test_bookmark_viewset_create_route(self):
view = BookmarkViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 3,
}
request = self.factory.post('/api/bookmark', data=data, format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['climb'], 3)
def test_bookmark_viewset_fails_to_create_if_data_is_a_duplicate(self):
view = BookmarkViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 1,
}
request = self.factory.post('/api/bookmark', data=data, format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 400)
def test_booomark_viewset_fails_to_create_if_no_user_is_authenticated(
self):
view = BookmarkViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 1,
}
request = self.factory.post('/api/bookmark', data=data, format='json')
response = view(request)
self.assertEqual(response.status_code, 401)
def test_bookmark_viewset_destroy_route(self):
view = BookmarkViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/bookmark')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 204)
def test_bookmark_viewset_delete_route_fails_if_no_user_autenticated(self):
view = BookmarkViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/bookmark')
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_bookmark_viewset_update_route_fails_if_wrong_user_autenticated(
self):
view = BookmarkViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/bookmark')
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
def ready(self):
register_serializer('yml', 'django.core.serializers.pyyaml')
from django.core.serializers import register_serializer
register_serializer('json-no-escape', 'serializers.json_no_escape')
from django.core.serializers import register_serializer
register_serializer('pure', 'pure_natural.serializers.pure')
# Grand-parent super
return super(compact_python.Serializer, self).getvalue()
CompactCsvSerializer = Serializer
def parser(stream, **options):
reader = CsvReader(stream)
headers = reader.next()
label, pk = headers[0].split(':')
yield {label: [pk] + headers[1:]}
for row in reader:
yield row
class Deserializer(compact_python.Deserializer):
"Deserialize a stream or string of compact CSV into DeserializedValuesObject instances."
multiple_streams = True
def __init__(self, stream_or_string, **options):
if isinstance(stream_or_string, bytes):
stream_or_string = stream_or_string.decode('utf-8')
if isinstance(stream_or_string, six.string_types):
self.stream = six.StringIO(stream_or_string)
else:
self.stream = stream_or_string
super(Deserializer, self).__init__(parser(self.stream), **options)
CompactCsvDeserializer = Deserializer
register_serializer('compact_csv', __name__)
class ClimbTestCase(TestCase):
register_serializer('yml', 'django.core.serializers.pyyaml')
fixtures = [
'api/tests/fixtures/user.yml',
'api/tests/fixtures/climb.yml'
]
def setUp(self):
self.client = APIClient()
self.factory = APIRequestFactory()
self.test_climb = Climb.objects.get(id=1)
self.listSerializer = ClimbListSerializer(instance=self.test_climb)
self.oneSerializer = ClimbOneSerializer(instance=self.test_climb)
self.altimeterSerializer = AltimeterSerializer(instance=self.test_climb)
def test_climb_peak_name(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.peak_name, "Santillana")
def test_climb_virtual_name(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.name, "Santillana por Ohanes")
def test_climb_virtual_altitude(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.altitude, 1358.0)
def test_climb_virtual_extent(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.extent, (-2.754625, 37.005069, -2.718852, 37.090495))
def test_climb_virtual_gradient(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.gradient, 4.910263399292802)
def test_climb_virtual_gain(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.gain, 887.0)
def test_climb_virtual_distance(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.distance, 18.064204053243856)
def test_climb_virtual_center(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(climb.center, {
"type": "Point",
"coordinates": [
-2.731412423189668,
37.04294132621043
]
})
def test_climb_virtual_kilometers_points(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(len(climb.kilometers),20)
self.assertEqual(climb.kilometers[1], {
"altitude": 512.0,
"distance": 1.0,
"kmGradient": 4.1
})
self.assertEqual(climb.kilometers[19],{
"altitude": 1358.0,
"distance": 18.064204053243856,
"kmGradient": 2.887914419236268
})
def test_climb_virtual_area(self):
climb = Climb.objects.get(pk=1)
self.assertEqual(len(climb.area),182)
self.assertEqual(climb.area[0],{
'altitude': 471.0,
'distance': 0.0,
'x': 0.0,
'y': 0.0
})
self.assertEqual(climb.area[-1],{
"altitude": 1358.0,
"distance": 18.064204053243856,
"x": 18.064204053243856,
"y": 887.0
})
def test_list_serializer_contains_expected_geo_fields(self):
data = self.listSerializer.data
self.assertEqual(set(data.keys()), set(['id','type','geometry','properties']))
def test_properties_contains_expected_in_list_serializer(self):
data = self.listSerializer.data
self.assertEqual(data['properties'],{ 'name': 'Santillana por Ohanes' })
def test_list_serializer_contains_geojson_point(self):
data = self.listSerializer.data
self.assertEqual(data['geometry']['coordinates'],[-2.719262, 37.005069, 471.0])
self.assertEqual(data['geometry']['type'], 'Point')
def test_one_serializer_contains_expected_geo_fields(self):
data = self.oneSerializer.data
self.assertEqual(set(data.keys()), set(['id','type','geometry','properties']))
def test_properties_contains_expected_in_one_serializer(self):
data = self.oneSerializer.data
self.assertEqual(set(data['properties'].keys()), set(['name', 'location', 'altitude', 'extent', 'gradient', 'gain',
'distance', 'center', 'area', 'kilometers']))
def test_one_serializer_contains_geojson_point(self):
data = self.oneSerializer.data
self.assertEqual(data['geometry']['type'], 'LineString')
self.assertEqual(len(data['geometry']['coordinates']),670)
def test_altimeter_serializer_contains_expected_fields(self):
data = self.altimeterSerializer.data
self.assertEqual(set(data.keys()), set(['id', 'name', 'altitude', 'extent', 'gradient', 'gain',
'distance', 'center', 'kilometers', 'area']))
def test_climb_viewset_list_route(self):
request = self.factory.get('/api/climb')
view = ClimbViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['type'],"FeatureCollection")
self.assertEqual(len(response.data['features']),3)
def test_climb_viewset_retrieve_route(self):
request = self.factory.get('/api/climb')
view = ClimbViewSet.as_view(actions={'get': 'retrieve'})
response = view(request,pk=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(response.data.keys()), set(['id','type','geometry','properties']))
def test_climb_viewset_create_route(self):
view = ClimbViewSet.as_view(actions={'post': 'create'})
data = {
'climb_name': 'Climb',
'peak_name': 'The Top',
'path': [(0,0,10),(0.5,0.5,50),(1,1,100),(1.5,1.5,150)],
'start': [0,0,10],
'location': [0,0,10],
'summit': [1.5,1.5,150]
}
request = self.factory.post('/api/climb', data=data, format='json')
auth_user = User.objects.get(id=1)
force_authenticate(request,user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['properties']["name"],"The Top por Climb")
def test_climb_viewset_fails_to_create_if_no_user_is_authenticated(self):
view = ClimbViewSet.as_view(actions={'post': 'create'})
data = {
'climb_name': 'Climb',
'peak_name': 'The Top',
'path': [(0,0,10),(0.5,0.5,50),(1,1,100),(1.5,1.5,150)],
'start': [0,0,10],
'location': [0,0,10],
'summit': [1.5,1.5,150]
}
request = self.factory.post('/api/climb', data=data, format='json')
response = view(request)
self.assertEqual(response.status_code, 401)
def test_climb_viewset_update_route_updates_data(self):
view = ClimbViewSet.as_view(actions={'put': 'update'})
data = {
'climb_name':"Ohanes pueblo",
'peak_name':"Santillia de Almeria",
}
request = self.factory.put('/api/climb', data=data)
auth_user = User.objects.get(id=1)
force_authenticate(request,user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['properties']['name'],'Santillia de Almeria por Ohanes pueblo')
def test_climb_viewset_update_route_fails_to_update_if_no_user_autenticated(self):
view = ClimbViewSet.as_view(actions={'put': 'update'})
data = {
'climb_name':"Ohanes pueblo",
'peak_name':"Santillia de Almeria",
}
request = self.factory.put('/api/climb', data=data)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_climb_viewset_update_route_fails_to_update_if_wrong_user_autenticated(self):
view = ClimbViewSet.as_view(actions={'put': 'update'})
data = {
'climb_name':"Ohanes pueblo",
'peak_name':"Santillia de Almeria",
}
request = self.factory.put('/api/climb', data=data)
wrong_user = User.objects.get(id=2)
force_authenticate(request,user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
def test_climb_viewset_destroy_route(self):
view = ClimbViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/climb')
auth_user = User.objects.get(id=1)
force_authenticate(request,user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 204)
def test_climb_viewset_delete_route_fails_if_no_user_autenticated(self):
view = ClimbViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/climb')
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_climb_viewset_update_route_fails_if_wrong_user_autenticated(self):
view = ClimbViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/climb')
wrong_user = User.objects.get(id=2)
force_authenticate(request,user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
NewCommitteeForm, NewCountryForm, UploadFileForm, NewPaymentForm, \
delegate_position_form_factory, FeeForm, DatePenaltyForm
from regimun_app.models import Conference, Committee, Country, DelegatePosition, \
School, Payment, Fee, DatePenalty
from regimun_app.utils import UnicodeCSVDictReader
from regimun_app.views.school_admin import is_school_registered
from regimun_app.views.secretariat_admin import secretariat_authenticate
import csv
import exceptions
import inspect
import string
from django.conf import settings
if 'jsondisplay' not in get_serializer_formats():
register_serializer('jsondisplay', 'regimun_app.serializers.DisplayNameJsonSerializer')
@login_required
def conference_ajax_functions(request, conference_slug, func_name):
conference = get_object_or_404(Conference, url_name=conference_slug)
func_name = string.replace(func_name, "-", "_")
if secretariat_authenticate(request, conference) and func_name in globals() and inspect.isfunction(globals()[func_name]):
return_value = globals()[func_name](request, conference)
if return_value != None:
if isinstance(return_value, HttpResponse):
return return_value
else:
return HttpResponse(return_value, mimetype='application/javascript')
#return HttpResponse("<html><body>" + return_value + "</body></html>")
class AuthTestCase(TestCase):
register_serializer('yml', 'django.core.serializers.pyyaml')
fixtures = ['api/tests/fixtures/user.yml']
def setUp(self):
self.client = APIClient()
self.factory = APIRequestFactory()
def test_registration_viewset_creates_user(self):
view = RegistrationView.as_view()
data = {
'email': '*****@*****.**',
'password': '******',
'username': '******'
}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(set(response.data.keys()),
set(['email', 'username', 'token', 'refresh_token']))
def test_registration_viewset_errors_with_missing_email(self):
view = RegistrationView.as_view()
data = {'password': '******', 'username': '******'}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()), set(['email']))
def test_registration_viewset_errors_with_invalid_email(self):
view = RegistrationView.as_view()
data = {
'email': 'user2email.com',
'password': '******',
'username': '******'
}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()), set(['email']))
def test_registration_viewset_errors_with_missing_username(self):
view = RegistrationView.as_view()
data = {
'email': '*****@*****.**',
'password': '******',
}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()),
set(['username']))
def test_registration_viewset_errors_with_missing_password(self):
view = RegistrationView.as_view()
data = {'email': '*****@*****.**', 'username': '******'}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()),
set(['password']))
def test_registration_viewset_errors_with_duplicate_email(self):
view = RegistrationView.as_view()
data = {
'email': '*****@*****.**',
'username': '******',
'password': '******'
}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()), set(['email']))
def test_registration_viewset_errors_with_duplicate_username(self):
view = RegistrationView.as_view()
data = {
'email': '*****@*****.**',
'username': '******',
'password': '******'
}
request = self.factory.post('/api/auth/register',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(set(response.data['errors'].keys()),
set(['username']))
def test_login_viewset_logins_user(self):
view = LoginView.as_view()
data = {'email': '*****@*****.**', 'password': '******'}
request = self.factory.post('/api/auth/login',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(response.data.keys()),
set(['email', 'username', 'token', 'refresh_token']))
def test_login_viewset_fails_with_incorrect_password(self):
view = LoginView.as_view()
data = {'email': '*****@*****.**', 'password': '******'}
request = self.factory.post('/api/auth/login',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
def test_refresh_viewset_refreshes_users_token(self):
view = RefreshView.as_view()
data = {
'refresh_token':
"b'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNTgwMjM1MjI0fQ.WF2NjpSJOYrIZ9dBK_eClBXi0VX9zxCVpkPCZ61NRXo'",
}
request = self.factory.post('/api/auth/refresh',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(response.data.keys()),
set(['email', 'username', 'token', 'refresh_token']))
self.assertEqual(response.data['email'], '*****@*****.**')
def test_refresh_viewset_fails_with_incorrect_refresh_token(self):
view = RefreshView.as_view()
data = {'refresh_token': 'a-nonsense-string'}
request = self.factory.post('/api/auth/refresh',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
def test_forgot_password_viewset_sets_refresh_token(self):
view = ForgotPasswordView.as_view()
data = {
'email': "*****@*****.**",
}
request = self.factory.post('/api/auth/forgot-password',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 200)
user_model = User.objects.get(id=2)
self.assertIsNotNone(user_model.reset_password_token)
def test_forgot_password_viewset_fails_with_invalid_email(self):
view = ForgotPasswordView.as_view()
data = {
'email': "*****@*****.**",
}
request = self.factory.post('/api/auth/forgot-password',
data=data,
format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
def test_reset_password_viewset_sets_new_password(self):
forgotPasswordView = ForgotPasswordView.as_view()
requestTokenData = {'email': "*****@*****.**"}
requestToken = self.factory.post('/api/auth/forgot-password',
data=requestTokenData,
format='json')
forgotPasswordView(requestToken)
user_model = User.objects.get(id=1)
token = user_model.reset_password_token
view = ResetPasswordView.as_view()
url = "/api/auth/reset-password?id={}&token={}".format(1, token)
data = {
'password': "******",
}
request = self.factory.post(url, data=data, format='json')
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(set(response.data.keys()),
set(['email', 'username', 'token', 'refresh_token']))
user_model = User.objects.get(id=1)
self.assertIsNone(user_model.reset_password_token)
def test_reset_password_viewset_fails_with_no_password_passed(self):
forgotPasswordView = ForgotPasswordView.as_view()
requestTokenData = {'email': "*****@*****.**"}
requestToken = self.factory.post('/api/auth/forgot-password',
data=requestTokenData,
format='json')
forgotPasswordView(requestToken)
user_model = User.objects.get(id=1)
token = user_model.reset_password_token
view = ResetPasswordView.as_view()
url = "/api/auth/reset-password?id={}&token={}".format(1, token)
request = self.factory.post(url, data={}, format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
def test_reset_password_viewset_fails_with_invalid_token_data(self):
view = ResetPasswordView.as_view()
url = "/api/auth/reset-password?id={}&token={}".format(2, "nothing")
data = {
'password': "******",
}
request = self.factory.post(url, data=data, format='json')
response = view(request)
self.assertEqual(response.status_code, 400)
# Little hack to prevent serializer from picking up fields we don't want
self._selected_fields = self.selected_fields
self.selected_fields = obj.__public__.keys()
def end_object(self, obj):
if hasattr(self, '_selected_fields'):
self.selected_fields = self._selected_fields
del self._selected_fields
if hasattr(obj, '__public__'):
current = self._current
data = {}
for attr, alias in obj.__public__.iteritems():
if attr in current:
data[alias] = current[attr]
elif hasattr(obj, attr):
attribute = getattr(obj, attr)
if callable(attribute):
data[alias] = attribute()
else:
data[alias] = attribute
self._current = data
super(Serializer, self).end_object(obj)
def get_dump_object(self, obj):
return self._current
register_serializer('public', 'mozbadges.utils.serializers.public')
# -*- coding: utf-8 -*-
from django.core import serializers
serializers.register_serializer('json', 'djmoney.serializers')
from django.core.serializers import register_serializer
register_serializer("xlsx", 'django_excel_fixture.serializers.xlsx_serializer')
from django.core.serializers import register_serializer
from django.db.models.base import ModelBase
from django.db.models.loading import get_app, get_models
from django.db.models.query import QuerySet
from nicedjango._compat import basestring
from nicedjango.graph.dumper import Dumper
from nicedjango.graph.loader import Loader
from nicedjango.graph.node import Node
from nicedjango.graph.utils import nodes_as_string, sort_nodes
from nicedjango.utils import coerce_tuple, divide_model_def, queryset_from_def, RememberingSet
from nicedjango.utils.py.iter import filter_attrs
from nicedjango.utils.py.string import divide_string
register_serializer('compact_csv', 'nicedjango.serializers.compact_csv')
register_serializer('compact_python', 'nicedjango.serializers.compact_python')
register_serializer('compact_yaml', 'nicedjango.serializers.compact_yaml')
__all__ = ['ModelGraph']
class ModelGraph(object):
def __init__(self,
queries=None,
relations=None,
app=None,
chunksize=100000):
self.nodes = {}
self.includes = set()
self._new_nodes = RememberingSet()
class PhotoTestCase(TestCase):
register_serializer('yml', 'django.core.serializers.pyyaml')
fixtures = [
'api/tests/fixtures/user.yml', 'api/tests/fixtures/climb.yml',
'api/tests/fixtures/photo.yml'
]
def setUp(self):
self.client = APIClient()
self.factory = APIRequestFactory()
self.image_url = '/home/david/Sites/cycling_climbs_api/api/tests/fixtures/image.jpeg'
self.pdf_url = '/home/david/Sites/cycling_climbs_api/api/tests/fixtures/image.pdf'
def test_photo_virtual_url(self):
photo = Photo.objects.get(pk=1)
self.assertEqual(photo.url,
settings.BASE_URL + "assets/1/photos/20200128-183635")
def test_properties_contains_expected_in_serializer(self):
photo = Photo.objects.get(id=1)
serializer = PhotoSerializer(instance=photo)
self.assertEqual(
set(serializer.data.keys()),
set([
'id', 'climb', 'user', 'text', 'path', 'url', 'fileType',
'fileSize', 'created_at'
]))
def test_photo_viewset_list_route(self):
request = self.factory.get('/api/photo')
view = PhotoViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 9)
def test_photo_viewset_list_route_filters_by_climb(self):
request = self.factory.get('/api/photo?climb=1')
view = PhotoViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 5)
def test_photo_viewset_list_route_filters_by_user(self):
request = self.factory.get('/api/photo?user=1')
view = PhotoViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 7)
def test_photo_viewset_list_route_filters_by_user_and_climb(self):
request = self.factory.get('/api/photo?user=1&climb=1')
view = PhotoViewSet.as_view(actions={'get': 'list'})
response = view(request)
self.assertEqual(len(response.data['results']), 4)
def test_photo_viewset_list_route_for_auth_user(self):
request = self.factory.get('/api/photo/me')
view = PhotoViewSet.as_view(actions={'get': 'me'})
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(len(response.data['results']), 7)
def test_photo_viewset_list_route_for_auth_user_with_auth_error(self):
request = self.factory.get('/api/photo/me')
view = PhotoViewSet.as_view(actions={'get': 'me'})
response = view(request)
self.assertEqual(response.status_code, 403)
def test_photo_viewset_retrieve_route(self):
request = self.factory.get('/api/photo')
view = PhotoViewSet.as_view(actions={'get': 'retrieve'})
response = view(request, pk=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(
set(response.data.keys()),
set([
'id', 'climb', 'user', 'text', 'path', 'url', 'fileType',
'fileSize', 'created_at'
]))
self.assertEqual(response.data['climb'], 1)
def test_photo_viewset_create_route(self):
view = PhotoViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 1,
}
request = self.factory.post('/api/photo/',
data=data,
format='multipart')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
with File(open(self.image_url, "rb")) as f:
request.FILES['photo'] = f
response = view(request)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['climb'], 1)
self.assertEqual(
set(response.data.keys()),
set([
'id', 'climb', 'user', 'url', 'text', 'path', 'fileType',
'fileSize', 'created_at'
]))
def test_photo_viewset_create_route_fails_with_wrong_file_type(self):
view = PhotoViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 1,
}
request = self.factory.post('/api/photo/',
data=data,
format='multipart')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
with File(open(self.pdf_url, "rb")) as f:
request.FILES['photo'] = f
response = view(request)
self.assertEqual(response.status_code, 406)
self.assertEqual(response.data['detail'],
"Image can only be jpeg or png")
def test_photo_viewset_create_route_fails_with_missing_file(self):
view = PhotoViewSet.as_view(actions={'post': 'create'})
data = {
'climb': 1,
}
request = self.factory.post('/api/photo/',
data=data,
format='multipart')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request)
self.assertEqual(response.status_code, 406)
self.assertEqual(response.data['detail'],
"No photo was attached to the request")
def test_photo_viewset_fails_to_create_if_no_user_is_authenticated(self):
view = PhotoViewSet.as_view(actions={'post': 'create'})
data = {
'file': 'image.jpeg',
'climb': 1,
}
request = self.factory.post('/api/photo',
data=data,
format='multipart')
response = view(request)
self.assertEqual(response.status_code, 401)
def test_photo_viewset_update_route_updates_data(self):
view = PhotoViewSet.as_view(actions={'put': 'update'})
data = {
'text': 'some text',
}
request = self.factory.put('/api/photo', data=data)
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['text'], 'some text')
self.assertEqual(response.data['climb'], 1)
def test_photo_viewset_update_route_fails_to_update_if_no_user_autenticated(
self):
view = PhotoViewSet.as_view(actions={'put': 'update'})
data = {
'text': 'some text',
}
request = self.factory.put('/api/photo', data=data)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_photo_viewset_update_route_fails_to_update_if_wrong_user_autenticated(
self):
view = PhotoViewSet.as_view(actions={'put': 'update'})
data = {
'text': 'some text',
}
request = self.factory.put('/api/photo', data=data)
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
def test_photo_viewset_destroy_route(self):
view = PhotoViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/photo')
auth_user = User.objects.get(id=1)
force_authenticate(request, user=auth_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 204)
def test_photo_viewset_delete_route_fails_if_no_user_autenticated(self):
view = PhotoViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/photo')
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 401)
def test_photo_viewset_update_route_fails_if_wrong_user_autenticated(self):
view = PhotoViewSet.as_view(actions={'delete': 'destroy'})
request = self.factory.delete('/api/photo')
wrong_user = User.objects.get(id=2)
force_authenticate(request, user=wrong_user)
response = view(request, pk=1, format='json')
self.assertEqual(response.status_code, 403)
def test_register(self):
"Registering a new serializer populates the full registry. Refs #14823"
serializers.register_serializer('xliff', 'xliff.xliff_serializer')
public_formats = serializers.get_public_serializer_formats()
self.assertIn('xliff', public_formats)
def test_register(self):
"Registering a new serializer populates the full registry. Refs #14823"
serializers.register_serializer('xliff', 'xliff.xliff_serializer')
public_formats = serializers.get_public_serializer_formats()
self.assertIn('xliff', public_formats)
from django.core import serializers
from django.utils import simplejson as json
from django.http import HttpResponse
from django.views.generic import View
from django.core.serializers.json import Serializer as JsonSerializer, DjangoJSONEncoder
class Serializer(JsonSerializer):
def end_serialization(self):
if json.__version__.split('.') >= ['2', '1', '3']:
# Use JS strings to represent Python Decimal instances (ticket #16850)
self.options.update({'use_decimal': False})
data = { 'result': self.objects }
json.dump(data, self.stream, cls=DjangoJSONEncoder, **self.options)
serializers.register_serializer('jsonrpc', Serializer)
class JSONResponseMixin(object):
def render_to_response(self, context):
"Returns a JSON response containing 'context' as payload"
if not hasattr(context,'__iter__'): context = (context,)
response = HttpResponse(mimetype='application/json')
serializers.serialize('jsonrpc', context, stream=response)
return response
class JSONResponseView(JSONResponseMixin, View):
def post(self, request, *args, **kwargs):
#print request.is_ajax()
if( request.META.get('CONTENT_TYPE','').split(';')[0] == 'application/json'
and hasattr(self, 'get_context_data')
and callable(self.get_context_data)
):
