class ExamResource(Base):
# Controls what data is included in the serialized output.
school_preparer = FieldsPreparer(fields={
'id': 'id',
'name': 'name',
})
preparer = FieldsPreparer(
fields={
'id': 'id',
'time': 'time',
'total': 'total',
'desc': 'desc',
'office_name': 'office.office_name',
'office_id': 'office.id',
'status': 'status',
'lock': 'lock'
})
def is_authenticated(self):
return True
# GET /
def list(self):
office = Office.objects.get(id=int(self.request.GET['office_id']))
return Exam.objects.filter(office=office,
desc__contains=self.request.GET.get(
'search', ''))
# GET /pk/
def detail(self, pk):
return Exam.objects.get(id=pk)
# POST /
def create(self):
office = Office.objects.get(id=int(self.data['office_id']))
return Exam.objects.create(office=office,
time=self.data['time'],
desc=self.data['desc'],
total=self.data['total'])
# PUT /pk/
def update(self, pk):
try:
exam = Exam.objects.get(id=pk)
except Teacher.DoesNotExist:
exam = Exam()
exam.time = self.data['time'] if 'time' in self.data else exam.time
exam.desc = self.data['desc'] if 'desc' in self.data else exam.desc
exam.total = self.data['total'] if 'total' in self.data else exam.total
exam.lock = self.data['lock'] if 'lock' in self.data else exam.lock
exam.save()
return exam
# DELETE /pk/
def delete(self, pk):
Exam.objects.get(id=pk).delete()
class ConfigResource(Base):
# Controls what data is included in the serialized output.
office_preparer = FieldsPreparer(fields={
'id': 'id',
'name': 'name',
})
preparer = FieldsPreparer(fields={
'id': 'id',
'key':'key',
'value': 'value',
'desc':'desc',
})
def is_authenticated(self):
return True
# GET /
def list(self):
if 'rate' in self.request.GET:
query = self.request.GET
base1 = query['base']
rate1 = query['rate']
base = Config.objects.get(key='base')
base.value =base1
rate = Config.objects.get(key="rate")
rate.value = rate1
base.save()
rate.save()
return Config.objects.all()
# GET /pk/
def detail(self, pk):
pass
# POST /
def create(self):
pass
# PUT /pk/
def update(self, pk):
pass
# DELETE /pk/
def delete(self, pk):
Config.objects.get(id=pk).delete()
def setUp(self):
super(LookupDataTestCase, self).setUp()
self.preparer = FieldsPreparer(fields=None)
self.obj_data = InstaObj(
say='what',
count=453,
moof={
'buried': {
'id': 7,
'data': InstaObj(yes='no')
}
},
parent=None
)
self.dict_data = {
'hello': 'world',
'abc': 123,
'more': {
'things': 'here',
'nested': InstaObj(
awesome=True,
depth=3
),
},
'parent': None,
'who': [
{'name': 'Ford'},
{'name': 'Arthur'},
{'name': 'Beeblebrox'},
],
'dont': lambda: {
'panic': 'vogon',
},
}
def __init__(self, *args, **kwargs):
super(TicketResource, self).__init__(*args, **kwargs)
self.http_methods.update({'issue': {
'GET': 'issue',
}})
self.ticket_preparer = FieldsPreparer(
fields={'record_locator': 'record_locator'})
def test_prepare_subpreparer(self):
subpreparer = FieldsPreparer(fields={
'id': 'id',
'data': 'data',
})
preparer = FieldsPreparer(fields={
'flying': 'say',
'wale': SubPreparer('moof.buried', subpreparer),
})
preped = preparer.prepare(self.obj_data)
def test_prepare_subsubpreparer(self):
subsubpreparer = FieldsPreparer(fields={
'really': 'yes',
})
subpreparer = FieldsPreparer(fields={
'data': SubPreparer('data', subsubpreparer),
})
preparer = FieldsPreparer(fields={
'wale': SubPreparer('moof.buried', subpreparer),
})
preped = preparer.prepare(self.obj_data)
self.assertEqual(preped, {'wale': {'data': {'really': 'no'}}})
def test_prepare_collection_subpreparer(self):
subpreparer = FieldsPreparer(fields={
'name': 'name',
})
preparer = FieldsPreparer(fields={
'who': CollectionSubPreparer('who', subpreparer),
})
preped = preparer.prepare(self.dict_data)
self.assertEqual(preped, {'who': [
{'name': 'Ford'},
{'name': 'Arthur'},
{'name': 'Beeblebrox'},
]})
class UserResource(BaseResource):
details_preparer = FieldsPreparer(fields={'avatar': 'avatar'})
preparer = FieldsPreparer(
fields={
'id': 'id',
'first_name': 'first_name',
'last_name': 'last_name',
'email': 'email',
'details': SubPreparer('detail.first', details_preparer)
})
def detail(self):
return self.request.client
class UserResource(APIFilterMixin, APIOrderingMixin, DjangoResource):
preparer = FieldsPreparer(fields={
'username': '******',
'about': 'about',
'friends': 'get_all_friends'
})
allowed_fields_filter = [
'username',
'username__icontains',
'username__startswith',
'about__icontains',
]
allowed_fields_ordering = ['username']
def list(self):
return self.ordering(self.filter(User.objects.all()))
def is_authenticated(self):
return True
def detail(self, pk):
return User.objects.get(id=pk)
def create(self):
user = User.objects.create(username=self.data['username'],
about=self.data['about'])
user.friends.set([
User.objects.get(username=friend)
for friend in self.data['friends']
])
return user
def update(self, pk):
try:
user = User.objects.get(id=pk)
except User.DoesNotExist:
user = User()
user.username = self.data['username']
user.about = self.data['about']
user.save()
user.friends.set([
User.objects.get(username=friend)
for friend in self.data['friends']
])
return user
def delete(self, pk):
User.objects.get(id=pk).delete()
class VideoLikedResource(DjangoResource):
preparer = FieldsPreparer(fields={
'id': 'id',
'video_id': 'video.id',
'username': '******',
'create_time': 'create_time',
})
def is_authenticated(self):
return self.request.user.is_authenticated()
def create(self, video_id):
video = Video.objects.get(pk=int(video_id))
video_liked, created = VideoLiked.objects.get_or_create(video=video, user=self.request.user)
if not created:
video_liked.liked = self.data['liked']
video_liked.save()
return video_liked
def update(self, video_id, pk):
video_liked = VideoLiked.objects.get(pk=pk)
video_liked.liked = self.data['liked']
video_liked.save()
return video_liked
def delete_list(self, video_id):
return VideoLiked.objects.filter(user=self.request.user, video__id=video_id).delete()
def list(self, video_id):
return VideoLiked.objects.filter(video__id=int(video_id), liked=True)
class PatientResource(DjangoResource):
preparer = FieldsPreparer(fields={
'name': 'name',
'email': 'email',
})
def list(self):
return Patient.objects.all()
def create(self):
return Patient.objects.create(
name=self.data['name'],
email=self.data['email'],
)
def detail(self, pk):
return get_object_or_404(Patient, pk=pk)
def update(self, pk):
patient = self.detail(pk)
patient.name = self.data['name']
patient.email = self.email['email']
patient.save()
return patient
def delete(self, pk):
patient = self.detail(pk)
patient.delete()
return "Paciente Deletado"
def is_authenticated(self):
return True
class UserResourse(DjangoResource):
preparer = FieldsPreparer(fields={
'id': 'id',
'username': '******',
'about': 'about',})
def is_authenticated(self):
return True
def list(self):
return Users.objects.all()
def create(self):
return Users.objects.create(
username=self.data['username'],
about=self.data['about'])
def delete(self, pk):
Users.objects.get(id=pk).delete()
def update(self, pk):
user = Users.objects.get(id=pk)
user.username = self.data['username']
user.save()
user.about= self.data['about']
user.save()
return user
def wrapper(cls):
# Save the original init
clsinit = getattr(cls, '__init__', lambda self: None)
# Dirty trick, make the class belong to the type restful.Resource
cls = type(cls.__name__, (Resource, ), dict(cls.__dict__))
aliases = getattr(cls, 'aliases', None)
if isinstance(aliases, dict) and len(aliases) > 0:
cls.preparer = FieldsPreparer(fields=aliases)
# Rename self for using inside __init__
api = self
def __init__(self, *args, **kwargs):
# Call Resource constructor
super(cls, self).__init__(api)
# Initialize the instance
clsinit(self, *args, **kwargs)
cls.__init__ = __init__
# Add the resource to the API
cls.add_url_rules(self.app, prefix)
return cls
class PostResourse(DjangoResource):
preparer = FieldsPreparer(fields={
'id': 'id',
'text': 'text',
'author': 'user.username',
'posted_at': 'posted_at',
'likes':'likes' })
def is_authenticated(self):
return True
def list(self):
posts=Post.objects.all()
return posts
def create(self):
return Post.objects.create(
text=self.data['text'],
user=Users.objects.get(username=self.data['author']))
def delete(self, pk):
Post.objects.get(id=pk).delete()
def update(self, pk):
post = Post.objects.get(id=pk)
post.text = self.data['about']
post.save()
return post
class UserResource(Base):
# Controls what data is included in the serialized output.
preparer = FieldsPreparer(fields={
'id': 'id',
'role': 'role',
})
def is_authenticated(self):
return True
# GET /
def list(self):
return User.objects.all()
# GET /pk/
def detail(self, pk):
return User.objects.get(id=pk)
# POST /
def create(self):
pass
# PUT /pk/
def update(self, pk):
pass
# DELETE /pk/
def delete(self, pk):
pass
class SliceResource(DjangoResource):
preparer = FieldsPreparer(fields={
'id': 'id',
'origin': 'origin.name',
'destination': 'destination.name',
'price': 'price',
'currency': 'currency.code',
'quote_time': 'quote_time',
'outbound_flight_number':'outbound_flight.flight_no',
'outbound_flight_code':'outbound_flight.carrier_code',
'inbound_flight_number':'inbound_flight.flight_no',
'inbound_flight_code':'inbound_flight.carrier_code',
})
def list(self, *args, **kwargs):
return Slice.objects.all().order_by('price')
def detail(self, pk):
return Slice.objects.get(id=pk)
@classmethod
def urls(cls, name_prefix=None):
return patterns('',
url(r'^$', cls.as_view('list'), name='list_slices'),
url(r'^(?P<pk>\d+)/$', cls.as_detail('detail'), name='detail_slice'),
)
class Order(Base):
preparer = FieldsPreparer(
fields={
'id': 'id',
'student_name': 'student_id_fk.name',
'order_style': 'order_style',
'create_time': 'create_time',
'update_time': 'update_time'
})
def list(self):
return OiOrder.objects.all()
# 在order->sutdent 外建 这里id 逻辑上是å¦ç”Ÿid
def detail(self, pk):
student = UiStudent.objects.get(id=pk)
return OiOrder.objects.get(student=student)
def create(self):
pass
def update(self, pk):
pass
def delete(self, pk):
pass
class ProvisioningResource(BaseResource):
# This stuff isn't, strictly speaking, REST
# But it's close enough
preparer = FieldsPreparer(fields={
'uuid': 'uuid',
'name': 'name',
'token': 'token',
'deviceMAC': 'deviceMAC'
})
def is_authenticated(self):
# We use the provisioning password
return True
def create(self):
provisioning_password = self.data[
"provisioning_password"] if "provisioning_password" in self.data else ""
if DEVICE_PROVISIONING_PASSWORD != provisioning_password:
raise Unauthorized()
form = DeviceForm(self.data)
if form.is_valid():
try:
form = DeviceForm(
self.data,
instance=Device.objects.get(
deviceMAC=form.cleaned_data["deviceMAC"]))
except Device.DoesNotExist:
pass
return form.save()
else:
raise ValidationError(form.errors)
class ObjectResource(CustomFlaskResource):
preparer = AutoPreparer({
'type':
'type',
'attributes':
CollectionSubPreparer(
'attributes',
AutoPreparer({
'type': 'type',
'text': 'text',
'score': 'score',
})),
'links':
CollectionSubPreparer(
'links',
FieldsPreparer(
fields={
'external_id':
'external_id',
'platform':
SubPreparer('platform',
AutoPreparer({
'name': 'name',
'slug': 'slug'
}))
}))
})
def is_authenticated(self):
return True
def list(self):
return ExternalObject.query.all()
def detail(self, pk):
return ExternalObject.query.filter(ExternalObject.id == pk).one()
def create(self):
scrap_id = request.headers.get('x-scrap-id', None)
if scrap_id is None:
raise restless.exceptions.\
BadRequest('Missing `x-scrap-id` header')
try:
scrap = Scrap.query.filter(Scrap.id == scrap_id).one()
except NoResultFound:
raise restless.exceptions.NotFound('Scrap not found')
data = ExternalObject.normalize_dict(self.data)
if data['type'] is None:
raise restless.exceptions.BadRequest('Field "type" is required')
if data['relation'] is not None:
raise restless.exceptions.BadRequest(
'Field "relation" is not allowed on the root object')
obj = ExternalObject.insert_dict(data, scrap)
return obj
class QuestionResource(DjangoResource):
# Controls what data is included in the serialized output.
preparer = FieldsPreparer(fields={'id': 'id', 'question': 'question_text'})
# GET /
def list(self):
return Question.objects.all()
# GET /pk/
def detail(self, pk):
return Question.objects.get(id=pk)
# POST /
def create(self):
return Question.objects.create(question_text=self.data['question'], )
# PUT /pk/
def update(self, pk):
try:
question = Question.objects.get(id=pk)
except Question.DoesNotExist:
question = Question()
question.question_text = self.data['question']
question.save()
return question
# DELETE /pk/
def delete(self, pk):
Question.objects.get(id=pk).delete()
def preparer(self):
if not hasattr(self, '_preparer_cache'):
self._preparer_cache = FieldsPreparer(fields={
f.name: f.name
for f in self.model._meta.fields
})
return self._preparer_cache
class RoleResource(TownSquareResource):
model = Role
preparer = FieldsPreparer({
'id': 'id',
'name': 'name'
})
def setUp(self):
super(LookupDataTestCase, self).setUp()
self.preparer = FieldsPreparer(fields=None)
self.obj_data = InstaObj(
say='what',
count=453,
moof={
'buried': {
'id': 7,
'data': InstaObj(yes='no')
}
},
parent=None
)
self.dict_data = {
'hello': 'world',
'abc': 123,
'more': {
'things': 'here',
'nested': InstaObj(
awesome=True,
depth=3
),
},
'parent': None,
}
def test_prepare(self):
# Without fields.
data = {
'title': 'Cosmos',
'author': 'Carl Sagan',
'short_desc':
'A journey through the stars by an emminent astrophysist.',
'pub_date': '1980'
}
# Should be unmodified.
self.assertTrue(isinstance(self.res.preparer, Preparer))
self.assertEqual(self.res.prepare(data), data)
self.res.preparer = FieldsPreparer(fields={
'title': 'title',
'author': 'author',
'synopsis': 'short_desc',
})
self.assertEqual(
self.res.prepare(data), {
'author': 'Carl Sagan',
'synopsis':
'A journey through the stars by an emminent astrophysist.',
'title': 'Cosmos'
})
class ProcedureResource(DjangoResource):
preparer = FieldsPreparer(fields={
'name': 'name',
'description': 'description',
})
def list(self):
return Procedure.objects.all()
def create(self):
return Procedure.objects.create(
name=self.data['name'],
description=self.data['description'],
)
def detail(self, pk):
return get_object_or_404(Procedure, pk=pk)
def update(self, pk):
procedure = self.detail(pk)
procedure.name = self.data['name']
procedure.description = self.data['description']
procedure.save()
return procedure
def delete(self, pk):
procedure = self.detail(pk)
procedure.delete()
return "Procedimento Deletado"
def is_authenticated(self):
return True
class ProductResource(DjangoResource):
preparer = FieldsPreparer(
fields={
'id': 'entity_id',
'title': 'view.title',
'description': 'view.description',
'price': 'view.price',
'categories': 'view.categories'
})
def list(self):
return ProductProjection.objects.all()
def detail(self, pk):
return ProductProjection.objects.get(entity_id=pk)
def create(self):
event = ProductEvent.events_manager.create_event.save(self.data)
return ProductProjection.objects.get(entity_id=event.entity_id)
def update(self, pk):
self.data['entity_id'] = pk
event = ProductEvent.events_manager.update_event.save(self.data)
return ProductProjection.objects.get(entity_id=event.entity_id)
def delete(self, pk):
self.data['entity_id'] = pk
ProductEvent.events_manager.delete_event.save(self.data)
def office_preparer():
preparer = FieldsPreparer(fields={
'id': 'id',
'name': 'name',
'slug': 'slug',
})
return preparer
def test_serialize_detail(self):
# This isn't very unit-y, but we're also testing that we're using the
# right JSON encoder & that it can handle other data types.
data = {
'title':
'Cosmos',
'author':
'Carl Sagan',
'short_desc':
'A journey through the stars by an emminent astrophysist.',
}
self.res.preparer = FieldsPreparer(fields={
'title': 'title',
'author': 'author',
'synopsis': 'short_desc',
})
res = self.res.serialize_detail(data)
self.assertEqual(
json.loads(res), {
'author': 'Carl Sagan',
'synopsis':
'A journey through the stars by an emminent astrophysist.',
'title': 'Cosmos'
})
# Make sure we don't try to serialize a ``None``, which would fail.
self.assertEqual(self.res.serialize_detail(None), '')
class BetResource(BaseResource):
preparer = FieldsPreparer(
fields={
'id': 'id',
'bet': 'bet',
'rating': 'rating',
'participant_id': 'participant_id',
'race_date': 'participant.race.date.timestamp',
'horse_name': 'participant.horse.name',
'result': 'result',
'success': 'win',
})
def list(self):
return self.get_page(
Bet.objects.filter(client_id=self.request.client.id).all())
def wrap_list_response(self, data):
return {'bets': data}
@skip_prepare
def create(self, *args, **kwargs):
body = json.loads(self.request.body.decode("utf-8"))
print(body)
bet = Bet(bet=body['bet'], rating=body['rating'])
participant = Participation.objects.get(id=body['participant_id'])
bet.participant = participant
user = self.request.client
bet.client = user
bet.save()
return {'result': True}
class LivrosResource(DjangoResource):
preparer = FieldsPreparer(
fields={
'livro_id': 'id',
'livro_titulo': 'titulo',
'livro_autor': 'autor.nome',
'livro_paginas': 'num_paginas',
})
def is_authenticated(self):
return True
def list(self):
return Livro.objects.all()
def detail(self, pk):
return Livro.objects.get(id=pk)
def create(self):
autor = Autor.objects.get(id=self.data.get('autor', ''))
return Livro.objects.create(
autor=autor,
titulo=self.data.get('titulo', ''),
paginas=self.data.get('paginas', 0),
)
def update(self, pk):
livro = Livro.objects.get(id=pk)
livro.titulo = self.data.get('titulo', '')
livro.paginas = self.data.get('paginas', 0)
livro.save()
return livro
class ITSystemEventResource(DjangoResource):
def __init__(self, *args, **kwargs):
super(ITSystemEventResource, self).__init__(*args, **kwargs)
self.http_methods.update({
'current': {'GET': 'current'}
})
preparer = FieldsPreparer(fields={
'id': 'id',
'description': 'description',
'planned': 'planned',
'current': 'current',
})
def prepare(self, data):
prepped = super(ITSystemEventResource, self).prepare(data)
prepped['event_type'] = data.get_event_type_display()
# Output times as the local timezone.
tz = pytz.timezone(settings.TIME_ZONE)
prepped['start'] = data.start.astimezone(tz)
if data.end:
prepped['end'] = data.end.astimezone(tz)
else:
prepped['end'] = None
if data.duration:
prepped['duration_sec'] = data.duration.seconds
else:
prepped['duration_sec'] = None
if data.it_systems:
prepped['it_systems'] = [i.name for i in data.it_systems.all()]
else:
prepped['it_systems'] = None
if data.locations:
prepped['locations'] = [i.name for i in data.locations.all()]
else:
prepped['locations'] = None
return prepped
@skip_prepare
def current(self):
# Slightly-expensive query: iterate over each 'current' event and call save().
# This should automatically expire any events that need to be non-current.
for i in ITSystemEvent.objects.filter(current=True):
i.save()
# Return prepared data.
return {'objects': [self.prepare(data) for data in ITSystemEvent.objects.filter(current=True)]}
def list(self):
return ITSystemEvent.objects.all()
def detail(self, pk):
return ITSystemEvent.objects.get(pk=pk)
@classmethod
def urls(self, name_prefix=None):
urlpatterns = super(ITSystemEventResource, self).urls(name_prefix=name_prefix)
return [
url(r'^current/$', self.as_view('current'), name=self.build_url_name('current', name_prefix)),
] + urlpatterns
def __init__(self, *args, **kwargs):
super(TicketResource, self).__init__(*args, **kwargs)
self.http_methods.update({
'issue': {
'GET': 'issue',
}
})
self.ticket_preparer = FieldsPreparer(fields={
'record_locator': 'record_locator'
})
class TicketResource(DjangoResource):
def __init__(self, *args, **kwargs):
super(TicketResource, self).__init__(*args, **kwargs)
self.http_methods.update({
'issue': {
'GET': 'issue',
}
})
self.ticket_preparer = FieldsPreparer(fields={
'record_locator': 'record_locator'
})
def prepare_tickets(self, tickets):
locators = []
for t in tickets:
locators.append(self.ticket_preparer.prepare(t))
data = {
'locators': locators
}
return data
@skip_prepare
def issue(self, num_locators=1, zip_code=None):
if self.request and 'num_locators' in self.request.GET:
num_locators = self.request.GET.get('num_locators', 1)
num_locators = int(num_locators)
if self.request and 'zip' in self.request.GET:
zip_code = self.request.GET.get('zip', '00000')
tickets, _ = create_tickets(zip_code, num_locators)
response = self.prepare_tickets(tickets)
return response
# Finally, extend the URLs
@classmethod
def urls(cls, name_prefix=None):
urlpatterns = super(TicketResource, cls).urls(name_prefix=name_prefix)
new = [
url(
r'^issue/', cls.as_view('issue'),
name=cls.build_url_name('issue', name_prefix)),
] + urlpatterns
return new
class LookupDataTestCase(unittest.TestCase):
def setUp(self):
super(LookupDataTestCase, self).setUp()
self.preparer = FieldsPreparer(fields=None)
self.obj_data = InstaObj(
say='what',
count=453,
moof={
'buried': {
'id': 7,
'data': InstaObj(yes='no')
}
},
parent=None
)
self.dict_data = {
'hello': 'world',
'abc': 123,
'more': {
'things': 'here',
'nested': InstaObj(
awesome=True,
depth=3
),
},
'parent': None,
}
def test_dict_simple(self):
self.assertEqual(self.preparer.lookup_data('hello', self.dict_data), 'world')
self.assertEqual(self.preparer.lookup_data('abc', self.dict_data), 123)
def test_obj_simple(self):
self.assertEqual(self.preparer.lookup_data('say', self.obj_data), 'what')
self.assertEqual(self.preparer.lookup_data('count', self.obj_data), 453)
def test_dict_nested(self):
self.assertEqual(self.preparer.lookup_data('more.things', self.dict_data), 'here')
self.assertEqual(self.preparer.lookup_data('more.nested.depth', self.dict_data), 3)
def test_obj_nested(self):
self.assertEqual(self.preparer.lookup_data('moof.buried.id', self.obj_data), 7)
self.assertEqual(self.preparer.lookup_data('moof.buried.data.yes', self.obj_data), 'no')
def test_dict_miss(self):
with self.assertRaises(KeyError):
self.preparer.lookup_data('another', self.dict_data)
def test_obj_miss(self):
with self.assertRaises(AttributeError):
self.preparer.lookup_data('whee', self.obj_data)
def test_dict_nullable_fk(self):
self.assertEqual(self.preparer.lookup_data('parent.id', self.dict_data), None)
def test_obj_nullable_fk(self):
self.assertEqual(self.preparer.lookup_data('parent.id', self.obj_data), None)
def test_empty_lookup(self):
# We could possibly get here in the recursion.
self.assertEqual(self.preparer.lookup_data('', 'Last value'), 'Last value')
def test_complex_miss(self):
with self.assertRaises(AttributeError):
self.preparer.lookup_data('more.nested.nope', self.dict_data)
class LookupDataTestCase(unittest.TestCase):
def setUp(self):
super(LookupDataTestCase, self).setUp()
self.preparer = FieldsPreparer(fields=None)
self.obj_data = InstaObj(
say='what',
count=453,
moof={
'buried': {
'id': 7,
'data': InstaObj(yes='no')
}
},
parent=None
)
self.dict_data = {
'hello': 'world',
'abc': 123,
'more': {
'things': 'here',
'nested': InstaObj(
awesome=True,
depth=3
),
},
'parent': None,
'who': [
{'name': 'Ford'},
{'name': 'Arthur'},
{'name': 'Beeblebrox'},
],
'dont': lambda: {
'panic': 'vogon',
},
}
def test_dict_simple(self):
self.assertEqual(self.preparer.lookup_data('hello', self.dict_data), 'world')
self.assertEqual(self.preparer.lookup_data('abc', self.dict_data), 123)
def test_obj_simple(self):
self.assertEqual(self.preparer.lookup_data('say', self.obj_data), 'what')
self.assertEqual(self.preparer.lookup_data('count', self.obj_data), 453)
def test_dict_nested(self):
self.assertEqual(self.preparer.lookup_data('more.things', self.dict_data), 'here')
self.assertEqual(self.preparer.lookup_data('more.nested.depth', self.dict_data), 3)
def test_obj_nested(self):
self.assertEqual(self.preparer.lookup_data('moof.buried.id', self.obj_data), 7)
self.assertEqual(self.preparer.lookup_data('moof.buried.data.yes', self.obj_data), 'no')
def test_dict_miss(self):
with self.assertRaises(KeyError):
self.preparer.lookup_data('another', self.dict_data)
def test_obj_miss(self):
with self.assertRaises(AttributeError):
self.preparer.lookup_data('whee', self.obj_data)
def test_dict_nullable_fk(self):
self.assertIsNone(self.preparer.lookup_data('parent.id', self.dict_data))
def test_obj_nullable_fk(self):
self.assertIsNone(self.preparer.lookup_data('parent.id', self.obj_data))
def test_empty_lookup(self):
# We could possibly get here in the recursion.
self.assertEqual(self.preparer.lookup_data('', 'Last value'), 'Last value')
def test_complex_miss(self):
with self.assertRaises(AttributeError):
self.preparer.lookup_data('more.nested.nope', self.dict_data)
def test_obj_callable(self):
self.assertEqual(
self.preparer.lookup_data('dont.panic', self.obj_data),
'vogon',
)
def test_dict_callable(self):
self.assertEqual(
self.preparer.lookup_data('dont.panic', self.dict_data),
'vogon',
)
def test_prepare_simple(self):
preparer = FieldsPreparer(fields={
'flying': 'say',
})
preped = preparer.prepare(self.obj_data)
self.assertEqual(preped, {'flying': 'what'})
def test_prepare_subpreparer(self):
subpreparer = FieldsPreparer(fields={
'id': 'id',
'data': 'data',
})
preparer = FieldsPreparer(fields={
'flying': 'say',
'wale': SubPreparer('moof.buried', subpreparer),
})
preped = preparer.prepare(self.obj_data)
def test_prepare_subsubpreparer(self):
subsubpreparer = FieldsPreparer(fields={
'really': 'yes',
})
subpreparer = FieldsPreparer(fields={
'data': SubPreparer('data', subsubpreparer),
})
preparer = FieldsPreparer(fields={
'wale': SubPreparer('moof.buried', subpreparer),
})
preped = preparer.prepare(self.obj_data)
self.assertEqual(preped, {'wale': {'data': {'really': 'no'}}})
def test_prepare_collection_subpreparer(self):
subpreparer = FieldsPreparer(fields={
'name': 'name',
})
preparer = FieldsPreparer(fields={
'who': CollectionSubPreparer('who', subpreparer),
})
preped = preparer.prepare(self.dict_data)
self.assertEqual(preped, {'who': [
{'name': 'Ford'},
{'name': 'Arthur'},
{'name': 'Beeblebrox'},
]})
def test_prepare_simple(self):
preparer = FieldsPreparer(fields={
'flying': 'say',
})
preped = preparer.prepare(self.obj_data)
self.assertEqual(preped, {'flying': 'what'})
