def top_level(self, request, api_name=None):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
serializer = Serializer()
if api_name is None:
api_name = self.api_name
available_resources = dict((name, {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
}) for name in self._registry.iterkeys())
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def top_level(self, request, api_name=None):
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
available_resources[name] = {
'list_endpoint': self._build_reverse_url('api_dispatch_list', kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url('api_get_schema', kwargs={
'api_name': api_name,
'resource_name': name,
}),
}
if request.GET.get('include_schemas', False) is not False:
available_resources[name]['schema_detailed'] = self._registry[name].build_schema()
desired_format = determine_format(request, serializer)
options = {}
if 'text/javascript' in desired_format:
callback = request.GET.get('callback', 'callback')
if not is_valid_jsonp_callback_value(callback):
raise BadRequest('JSONP callback name is invalid.')
options['callback'] = callback
serialized = serializer.serialize(available_resources, desired_format, options)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def obj_update(self, bundle, skip_errors=False, **kwargs):
from tastypie.serializers import Serializer
from models import ProgramFeature
serdes = Serializer()
deserialized = None
try:
deserialized = serdes.deserialize(bundle.request.body, format=bundle.request.META.get('CONTENT_TYPE', 'application/json'))
except Exception:
deserialized = None
if deserialized is None:
return ImmediateHttpResponse(response = http.HttpBadRequest('Empty update data'))
time_difference = datetime.strptime(deserialized['new_end_time'], "%Y-%m-%d %H:%M:%S") - datetime.strptime(deserialized['old_end_time'], "%Y-%m-%d %H:%M:%S")
Presentation.objects.filter(startTime__gte=deserialized['old_end_time']).update(startTime=F('startTime') + time_difference)
Presentation.objects.filter(startTime__gte=deserialized['old_end_time']).update(endTime=F('endTime') + time_difference)
later_presentations = Presentation.objects.filter(startTime__gte=deserialized['old_end_time'])
changed_presentation = Presentation.objects.get(startTime=deserialized['old_start_time'])
changed_presentation.startTime = deserialized['new_start_time']
changed_presentation.endTime = deserialized['new_end_time']
changed_presentation.save()
def serialized(self, request, api_name=None, desired_format=None):
"""
Nabbed from top_level of the parent class
Would be nice if this was abstracted as it's good for auto discovery
to be rendered as json on initial page load
"""
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
if desired_format is None:
desired_format = determine_format(request, serializer)
for name in sorted(self._registry.keys()):
available_resources[name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list",
kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
}
return serializer.serialize(available_resources, desired_format)
def index(request):
"""
Page shell for the client-side application.
Bootstraps read-once data onto the page.
"""
serializer = Serializer()
cr = CategoryResource()
categories = list(Category.objects.annotate(dataset_count=Count('datasets')))
bundles = [cr.build_bundle(obj=c) for c in categories]
categories_bootstrap = [cr.full_dehydrate(b) for b in bundles]
uncategorized = Category(
id=settings.PANDA_UNCATEGORIZED_ID,
slug=settings.PANDA_UNCATEGORIZED_SLUG,
name=settings.PANDA_UNCATEGORIZED_NAME)
uncategorized.__dict__['dataset_count'] = Dataset.objects.filter(categories=None).count()
uncategorized_bundle = cr.full_dehydrate(cr.build_bundle(obj=uncategorized))
categories_bootstrap.append(uncategorized_bundle)
return render_to_response('index.html', {
'settings': settings,
'demo_mode': int(config_value('MISC', 'DEMO_MODE')),
'bootstrap_data': serializer.to_json({
'categories': categories_bootstrap
})
})
def dbDecode(dataString):
assert_arg_type(dataString, basestring)
## this logic is poor - I believe the best way is to define a standard set of
## representation formats and use try..except clauses to parse the incoming string
## according to the defined formats (formats: text, json, xml)
## For now we treat it as a default of text
## use tastypie's serializer to do the testing
from tastypie.serializers import Serializer
## instantiate a serializer to test
serdes = Serializer()
dataobj = None
val = None
try:
val = serdes.from_xml(dataString)
except Exception:
val = None
if val is None:
try:
from django.utils import simplejson
#val = serdes.from_json(dataString)
val = simplejson.loads(dataString, encoding='utf-8')
except Exception, ex:
val = None
if not isinstance(val, (dict, list)):
val = str(dataString)
dataobj = Data(val, data_format = Data.TEXT)
else:
dataobj = Data(val, data_format = Data.JSON)
def obj_update(self, bundle, skip_errors=False, **kwargs):
"""
Could be an intentional action that the default obj_update treats DoesNotExist and MultipleObjectReturned
as acceptable exceptions which get transformed into a CREATE operation.
We don't want such a behavior. So we catch does exceptions and throw an BadRequest message
"""
from tastypie.serializers import Serializer
try:
serdes = Serializer()
deserialized = None
try:
deserialized = serdes.deserialize(bundle.request.raw_post_data,
format=bundle.request.META.get('CONTENT_TYPE', 'application/json'))
except Exception:
deserialized = None
del serdes
if deserialized is None:
return ImmediateHttpResponse(response = http.HttpBadRequest())
if 'unregister_c2dm' in deserialized and deserialized['unregister_c2dm'] == True:
bundle.data['c2dm_id'] = None
updated_bundle = super(UserResource, self).obj_update(bundle, skip_errors=skip_errors, **kwargs)
return updated_bundle
except (NotFound, MultipleObjectsReturned):
raise ImmediateHttpResponse(response = http.HttpBadRequest())
def test_to_xml(self):
serializer = Serializer()
sample_1 = self.get_sample1()
self.assertEqual(
serializer.to_xml(sample_1),
"<?xml version='1.0' encoding='utf-8'?>\n<response><age type=\"integer\">27</age><name>Daniel</name><date_joined>2010-03-27</date_joined></response>",
)
def login(request, **kwargs):
# self.method_check(request, allowed=['post'])
# self.is_authenticated(request)
# self.throttle_check(request)
developer_key = request.GET.get('developer_key')
username = request.GET.get('username')
password = request.GET.get('password')
if not developer_key or not username or not password:
return HttpUnauthorized()
try:
dev_key = DeveloperApiKey.objects.get(key=developer_key, approved=True)
except DeveloperApiKey.DoesNotExist:
return HttpUnauthorized()
user = authenticate(username=username, password=password)
if user:
try:
key = UserApiKey.objects.get(user=user, developer_key=dev_key)
except UserApiKey.DoesNotExist:
key = UserApiKey(user=user, developer_key=dev_key)
key.save()
# self.log_throttled_access(request)
serializer = Serializer()
desired_format = determine_format(request, serializer)
serialized = serializer.serialize({'key' : key.key}, desired_format)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
else:
return HttpUnauthorized()
def tastypie_resource_serialize(data):
data_resource = get_resource_class(type(data))
bundle = data_resource.build_bundle(obj=data, request=None)
bundle.request.path = "/"
serialized = Serializer().serialize(data_resource.full_dehydrate(bundle).data)
serialized = serialized.replace("'", '\\"')
return serialized
def send_invitation(request):
"""
Send an invitation to another person via email. NOT TESTED YET
"""
if request.user.is_authenticated() and request.user.is_active:
if 'email' in request.POST:
email = request.POST['email']
else:
return HttpResponseBadRequest('Mandatory email parameter not provided.')
if 'message' in request.POST:
message = request.POST['message']
else:
message = 'Tritt score.it bei und sehe deine Handballergebnisse online!'
profile = None
if 'profile' in request.POST:
serializer = Serializer()
profile = serializer.deserialize(request.POST['profile'])
subject = '{0} {1} lädt dich zu Score.it ein!'.format(request.user.first_name, request.user.last_name)
if profile:
profile_link = 'http://score-it.de/?a=invite&p={0}'.format(profile.id)
body = '{0} {1} hat ein Spielerprofil bei Score.it für dich erstellt. Melde dich jetzt bei Score.it an, um deine Handballergebnisse online abzurufen! Zum anmelden, klicke einfach folgenden Link: {3}'.format(request.user.first_name, request.user.last_name, profile_link)
else:
body = '{0} {1} hat dir eine Einladung zu der Sportplatform Score.it geschickt:<br>{2}Um dich anzumelden, besuche einfach http://score-it.de/!'.format(request.user.first_name, request.user.last_name, message)
sender = '*****@*****.**'
recipients = [email]
send_mail(subject, body, sender, recipients)
return HttpResponse('')
else:
return HttpUnauthorized('Authentication through active user required.')
def test_to_json_decimal_list_dict(self):
serializer = Serializer()
resource = self.another_obj_list[0]
self.assertEqual(
serializer.to_json(resource),
'{"aliases": ["Mr. Smith", "John Doe"], "content": "This is my very first post using my shiny new API. Pretty sweet, huh?", "created": "2010-03-30T20:05:00", "id": "1", "is_active": true, "meta": {"threat": "high"}, "owed": "102.57", "resource_uri": "", "slug": "first-post", "title": "First Post!", "updated": "2010-03-30T20:05:00"}',
)
def test_to_xml_single(self):
serializer = Serializer()
resource = self.obj_list[0]
self.assertEqual(
serializer.to_xml(resource),
"<?xml version='1.0' encoding='utf-8'?>\n<object><updated>2010-03-30T20:05:00</updated><created>2010-03-30T20:05:00</created><title>First Post!</title><is_active type=\"boolean\">True</is_active><slug>first-post</slug><content>This is my very first post using my shiny new API. Pretty sweet, huh?</content><id>1</id><resource_uri></resource_uri></object>",
)
def test_to_json_single(self):
serializer = Serializer()
resource = self.obj_list[0]
self.assertEqual(
serializer.to_json(resource),
'{"content": "This is my very first post using my shiny new API. Pretty sweet, huh?", "created": "2010-03-30T20:05:00", "id": "1", "is_active": true, "resource_uri": "", "slug": "first-post", "title": "First Post!", "updated": "2010-03-30T20:05:00"}',
)
def top_level(self, request, api_name=None):
"""
A view that returns a serialized list of all resources registers
to the ``Api``. Useful for discovery.
"""
serializer = Serializer()
available_resources = {}
if api_name is None:
api_name = self.api_name
for name in sorted(self._registry.keys()):
available_resources[name] = {
'list_endpoint': self._build_reverse_url("api_dispatch_list", kwargs={
'api_name': api_name,
'resource_name': name,
}),
'schema': self._build_reverse_url("api_get_schema", kwargs={
'api_name': api_name,
'resource_name': name,
}),
}
desired_format = determine_format(request, serializer)
serialized = serializer.serialize(available_resources, desired_format)
return HttpResponse(content=serialized, content_type=build_content_type(desired_format))
def build_response(self):
from tastypie.serializers import Serializer
serializer = Serializer()
return HttpResponse(
content=serializer.serialize(self.response_data),
content_type=build_content_type('application/json')
)
def test_to_xml2(self):
serializer = Serializer()
sample_2 = self.get_sample2()
self.assertEqual(
serializer.to_xml(sample_2),
'<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<response><somelist type="list"><value>hello</value><value type="integer">1</value><value type="null"/></somelist><somehash type="hash"><pi type="float">3.14</pi><foo>bar</foo></somehash><false type="boolean">False</false><true type="boolean">True</true><somestring>hello</somestring></response>',
)
def index(request):
"""
Page shell for the client-side application.
Bootstraps read-once data onto the page.
"""
serializer = Serializer()
cr = CategoryResource()
categories = list(Category.objects.annotate(dataset_count=Count('datasets')))
bundles = [cr.build_bundle(obj=c) for c in categories]
categories_bootstrap = [cr.full_dehydrate(b) for b in bundles]
uncategorized = Category(
id=settings.PANDA_UNCATEGORIZED_ID,
slug=settings.PANDA_UNCATEGORIZED_SLUG,
name=settings.PANDA_UNCATEGORIZED_NAME)
uncategorized.__dict__['dataset_count'] = Dataset.objects.filter(categories=None).count()
uncategorized_bundle = cr.full_dehydrate(cr.build_bundle(obj=uncategorized))
categories_bootstrap.append(uncategorized_bundle)
return render_to_response('index.html', {
'settings': settings,
'max_upload_size': int(config_value('MISC', 'MAX_UPLOAD_SIZE')),
'email_enabled': int(config_value('EMAIL', 'EMAIL_ENABLED')),
'demo_mode_enabled': int(config_value('MISC', 'DEMO_MODE_ENABLED')),
'bootstrap_data': serializer.to_json({
'categories': categories_bootstrap
}),
'moment_lang_code': settings.MOMENT_LANGUAGE_MAPPING.get(settings.LANGUAGE_CODE, None),
})
def test_from_json(self):
serializer = Serializer()
sample_1 = serializer.from_json('{"age": 27, "date_joined": "2010-03-27", "name": "Daniel"}')
self.assertEqual(len(sample_1), 3)
self.assertEqual(sample_1["name"], "Daniel")
self.assertEqual(sample_1["age"], 27)
self.assertEqual(sample_1["date_joined"], u"2010-03-27")
def test_to_plist(self):
serializer = Serializer()
sample_1 = self.get_sample1()
self.assertEqual(
serializer.to_plist(sample_1),
"bplist00bybiplist1.0\x00\xd3\x01\x02\x03\x04\x05\x06SageTname[date_joined\x10\x1bf\x00D\x00a\x00n\x00i\x00e\x00lZ2010-03-27\x15\x1c %13@\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00K",
)
def test_to_xml_nested(self):
serializer = Serializer()
resource = self.obj_list[0]
data = {"stuff": {"foo": "bar", "object": resource}}
self.assertEqual(
serializer.to_xml(data),
"<?xml version='1.0' encoding='utf-8'?>\n<response><stuff type=\"hash\"><foo>bar</foo><object><updated>2010-03-30T20:05:00</updated><created>2010-03-30T20:05:00</created><title>First Post!</title><is_active type=\"boolean\">True</is_active><slug>first-post</slug><content>This is my very first post using my shiny new API. Pretty sweet, huh?</content><id>1</id><resource_uri></resource_uri></object></stuff></response>",
)
def test_to_plist(self):
if not biplist:
return
serializer = Serializer()
sample_1 = self.get_sample1()
self.assertEqual(serializer.to_plist(sample_1), 'bplist00bybiplist1.0\x00\xd4\x01\x02\x03\x04\x05\x06\x07\x08WsnowmanSageTname[date_joineda&\x03\x10\x1bf\x00D\x00a\x00n\x00i\x00e\x00lZ2010-03-27\x15\x1e&*/;>@M\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X')
def test_to_json_nested(self):
serializer = Serializer()
resource = self.obj_list[0]
data = {"stuff": {"foo": "bar", "object": resource}}
self.assertEqual(
serializer.to_json(data),
'{"stuff": {"foo": "bar", "object": {"content": "This is my very first post using my shiny new API. Pretty sweet, huh?", "created": "2010-03-30T20:05:00", "id": "1", "is_active": true, "resource_uri": "", "slug": "first-post", "title": "First Post!", "updated": "2010-03-30T20:05:00"}}}',
)
def test_from_json(self):
serializer = Serializer()
sample_1 = serializer.from_json('{"age": 27, "date_joined": "2010-03-27", "name": "Daniel"}')
self.assertEqual(len(sample_1), 3)
self.assertEqual(sample_1['name'], 'Daniel')
self.assertEqual(sample_1['age'], 27)
self.assertEqual(sample_1['date_joined'], u'2010-03-27')
def test_to_plist(self):
if not biplist:
return
serializer = Serializer()
sample_1 = self.get_sample1()
self.assertTrue(serializer.to_plist(sample_1).startswith(b'bplist00bybiplist1.0'))
def test_from_plist(self):
serializer = Serializer()
sample_1 = serializer.from_plist('bplist00bybiplist1.0\x00\xd3\x01\x02\x03\x04\x05\x06SageTname[date_joined\x10\x1bf\x00D\x00a\x00n\x00i\x00e\x00lZ2010-03-27\x15\x1c %13@\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00K')
self.assertEqual(len(sample_1), 3)
self.assertEqual(sample_1['name'], 'Daniel')
self.assertEqual(sample_1['age'], 27)
self.assertEqual(sample_1['date_joined'], u'2010-03-27')
def test_to_jsonp(self):
serializer = Serializer()
sample_1 = self.get_sample1()
options = {'callback': 'myCallback'}
serialized = serializer.to_jsonp(sample_1, options=options)
serialized_json = serializer.to_json(sample_1)
self.assertEqual('myCallback(%s)' % serialized_json,
serialized)
def test_from_plist(self):
serializer = Serializer()
sample_1 = serializer.from_plist(b'bplist00bybiplist1.0\x00\xd4\x01\x02\x03\x04\x05\x06\x07\x08WsnowmanSageTname[date_joineda&\x03\x10\x1bf\x00D\x00a\x00n\x00i\x00e\x00lZ2010-03-27\x15\x1e&*/;>@M\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\t\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00X')
self.assertEqual(len(sample_1), 4)
self.assertEqual(sample_1['name'], 'Daniel')
self.assertEqual(sample_1['age'], 27)
self.assertEqual(sample_1['date_joined'], '2010-03-27')
self.assertEqual(sample_1['snowman'], u'☃')
def test_round_trip_xml(self):
serializer = Serializer()
sample_data = self.get_sample2()
serialized = serializer.to_xml(sample_data)
# "response" tags need to be changed to "request" to deserialize properly.
# A string substitution works here.
serialized = serialized.replace('response', 'request')
unserialized = serializer.from_xml(serialized)
self.assertEqual(sample_data, unserialized)
def test_to_xml_nested(self):
serializer = Serializer()
resource = self.obj_list[0]
data = {
'stuff': {
'foo': 'bar',
'object': resource,
}
}
self.assertEqual(serializer.to_xml(data), '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<response><stuff type="hash"><foo>bar</foo><object><updated>2010-03-30T20:05:00</updated><created>2010-03-30T20:05:00</created><title>First Post!</title><is_active type="boolean">True</is_active><slug>first-post</slug><content>This is my very first post using my shiny new API. Pretty sweet, huh?</content><id>1</id><resource_uri></resource_uri></object></stuff></response>')
def test_format_time(self):
serializer = Serializer()
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
'02:31:33')
serializer = Serializer(datetime_formatting='iso-8601')
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
'02:31:33')
serializer = Serializer(datetime_formatting='rfc-2822')
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
u'02:31:33 -0600')
serializer = Serializer(datetime_formatting='random-garbage')
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
'02:31:33')
# Stow.
old_format = getattr(settings, 'TASTYPIE_DATETIME_FORMATTING',
'iso-8601')
settings.TASTYPIE_DATETIME_FORMATTING = 'iso-8601'
serializer = Serializer()
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
'02:31:33')
settings.TASTYPIE_DATETIME_FORMATTING = 'rfc-2822'
serializer = Serializer()
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
u'02:31:33 -0600')
settings.TASTYPIE_DATETIME_FORMATTING = 'random-garbage'
serializer = Serializer()
self.assertEqual(serializer.format_time(datetime.time(2, 31, 33)),
'02:31:33')
# Restore.
settings.TASTYPIE_DATETIME_FORMATTING = old_format
class Meta:
queryset = User.objects.all()
resource_name = 'user'
excludes = ['email', 'password', 'is_active', 'is_staff', 'is_superuser', 'last_login', 'date_joined', 'id']
serializer = Serializer(formats=['json'])
def test_format_date(self):
serializer = Serializer()
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
'2010-12-16')
serializer = Serializer(datetime_formatting='iso-8601')
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
'2010-12-16')
serializer = Serializer(datetime_formatting='rfc-2822')
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
u'16 Dec 2010')
serializer = Serializer(datetime_formatting='random-garbage')
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
'2010-12-16')
# Stow.
old_format = getattr(settings, 'TASTYPIE_DATETIME_FORMATTING',
'iso-8601')
settings.TASTYPIE_DATETIME_FORMATTING = 'iso-8601'
serializer = Serializer()
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
'2010-12-16')
settings.TASTYPIE_DATETIME_FORMATTING = 'rfc-2822'
serializer = Serializer()
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
u'16 Dec 2010')
settings.TASTYPIE_DATETIME_FORMATTING = 'random-garbage'
serializer = Serializer()
self.assertEqual(serializer.format_date(datetime.date(2010, 12, 16)),
'2010-12-16')
# Restore.
settings.TASTYPIE_DATETIME_FORMATTING = old_format
def test_from_xml2(self):
serializer = Serializer()
data = '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<request><somelist type="list"><value>hello</value><value type="integer">1</value><value type="null"/></somelist><somehash type="hash"><pi type="float">3.14</pi><foo>bar</foo></somehash><false type="boolean">False</false><true type="boolean">True</true><somestring>hello</somestring></request>'
self.assertEqual(serializer.from_xml(data), self.get_sample2())
class Meta:
queryset = Region.objects.all()
resource_name = 'regions'
serializer = Serializer(formats=['xml', 'json'])
class Meta:
queryset = Country.objects.all()
resource_name = 'countries'
excludes = ['polygon', 'code']
include_resource_uri = False
serializer = Serializer(formats=['xml', 'json'])
def test_init(self):
serializer_1 = Serializer()
self.assertEqual(serializer_1.formats,
['json', 'jsonp', 'xml', 'yaml', 'html', 'plist'])
self.assertEqual(
serializer_1.content_types, {
'xml': 'application/xml',
'yaml': 'text/yaml',
'json': 'application/json',
'jsonp': 'text/javascript',
'html': 'text/html',
'plist': 'application/x-plist'
})
self.assertEqual(serializer_1.supported_formats, [
'application/json', 'text/javascript', 'application/xml',
'text/yaml', 'text/html', 'application/x-plist'
])
serializer_2 = Serializer(formats=['json', 'xml'])
self.assertEqual(serializer_2.formats, ['json', 'xml'])
self.assertEqual(
serializer_2.content_types, {
'xml': 'application/xml',
'yaml': 'text/yaml',
'json': 'application/json',
'jsonp': 'text/javascript',
'html': 'text/html',
'plist': 'application/x-plist'
})
self.assertEqual(serializer_2.supported_formats,
['application/json', 'application/xml'])
serializer_3 = Serializer(formats=['json', 'xml'],
content_types={
'json': 'text/json',
'xml': 'application/xml'
})
self.assertEqual(serializer_3.formats, ['json', 'xml'])
self.assertEqual(serializer_3.content_types, {
'xml': 'application/xml',
'json': 'text/json'
})
self.assertEqual(serializer_3.supported_formats,
['text/json', 'application/xml'])
serializer_4 = Serializer(formats=['plist', 'json'],
content_types={
'plist': 'application/x-plist',
'json': 'application/json'
})
self.assertEqual(serializer_4.formats, ['plist', 'json'])
self.assertEqual(serializer_4.content_types, {
'plist': 'application/x-plist',
'json': 'application/json'
})
self.assertEqual(serializer_4.supported_formats,
['application/x-plist', 'application/json'])
self.assertRaises(ImproperlyConfigured,
Serializer,
formats=['json', 'xml'],
content_types={'json': 'text/json'})
class Meta:
queryset = Indicator.objects.all()
resource_name = 'indicator'
include_resource_uri = False
serializer = Serializer(formats=['xml', 'json'])
class ResourceTestCase(TestCase):
"""
A useful base class for the start of testing Tastypie APIs.
"""
def setUp(self):
super(ResourceTestCase, self).setUp()
self.serializer = Serializer()
self.api_client = TestApiClient()
def get_credentials(self):
"""
A convenience method for the user as a way to shorten up the
often repetitious calls to create the same authentication.
Raises ``NotImplementedError`` by default.
Usage::
class MyResourceTestCase(ResourceTestCase):
def get_credentials(self):
return self.create_basic('daniel', 'pass')
# Then the usual tests...
"""
raise NotImplementedError(
"You must return the class for your Resource to test.")
def create_basic(self, username, password):
"""
Creates & returns the HTTP ``Authorization`` header for use with BASIC
Auth.
"""
import base64
return 'Basic %s' % base64.b64encode(':'.join([username, password]))
def create_apikey(self, username, api_key):
"""
Creates & returns the HTTP ``Authorization`` header for use with
``ApiKeyAuthentication``.
"""
return 'ApiKey %s:%s' % (username, api_key)
def create_digest(self, username, api_key, method, uri):
"""
Creates & returns the HTTP ``Authorization`` header for use with Digest
Auth.
"""
from tastypie.authentication import hmac, sha1, uuid, python_digest
new_uuid = uuid.uuid4()
opaque = hmac.new(str(new_uuid), digestmod=sha1).hexdigest()
return python_digest.build_authorization_request(
username,
method.upper(),
uri,
1, # nonce_count
digest_challenge=python_digest.build_digest_challenge(
time.time(), getattr(settings, 'SECRET_KEY', ''),
'django-tastypie', opaque, False),
password=api_key)
def create_oauth(self, user):
"""
Creates & returns the HTTP ``Authorization`` header for use with Oauth.
"""
from oauth_provider.models import Consumer, Token, Resource
# Necessary setup for ``oauth_provider``.
resource, _ = Resource.objects.get_or_create(
url='test', defaults={'name': 'Test Resource'})
consumer, _ = Consumer.objects.get_or_create(key='123',
defaults={
'name':
'Test',
'description':
'Testing...'
})
token, _ = Token.objects.get_or_create(key='foo',
token_type=Token.ACCESS,
defaults={
'consumer': consumer,
'resource': resource,
'secret': '',
'user': user,
})
# Then generate the header.
oauth_data = {
'oauth_consumer_key': '123',
'oauth_nonce': 'abc',
'oauth_signature': '&',
'oauth_signature_method': 'PLAINTEXT',
'oauth_timestamp': str(int(time.time())),
'oauth_token': 'foo',
}
return 'OAuth %s' % ','.join(
[key + '=' + value for key, value in oauth_data.items()])
def assertHttpOK(self, resp):
"""
Ensures the response is returning a HTTP 200.
"""
return self.assertEqual(resp.status_code, 200)
def assertHttpCreated(self, resp):
"""
Ensures the response is returning a HTTP 201.
"""
return self.assertEqual(resp.status_code, 201)
def assertHttpAccepted(self, resp):
"""
Ensures the response is returning either a HTTP 202 or a HTTP 204.
"""
return self.assertTrue(resp.status_code in [202, 204],
'status_code is %s' % resp.status_code)
def assertHttpMultipleChoices(self, resp):
"""
Ensures the response is returning a HTTP 300.
"""
return self.assertEqual(resp.status_code, 300)
def assertHttpSeeOther(self, resp):
"""
Ensures the response is returning a HTTP 303.
"""
return self.assertEqual(resp.status_code, 303)
def assertHttpNotModified(self, resp):
"""
Ensures the response is returning a HTTP 304.
"""
return self.assertEqual(resp.status_code, 304)
def assertHttpBadRequest(self, resp):
"""
Ensures the response is returning a HTTP 400.
"""
return self.assertEqual(resp.status_code, 400)
def assertHttpUnauthorized(self, resp):
"""
Ensures the response is returning a HTTP 401.
"""
return self.assertEqual(resp.status_code, 401)
def assertHttpForbidden(self, resp):
"""
Ensures the response is returning a HTTP 403.
"""
return self.assertEqual(resp.status_code, 403)
def assertHttpNotFound(self, resp):
"""
Ensures the response is returning a HTTP 404.
"""
return self.assertEqual(resp.status_code, 404)
def assertHttpMethodNotAllowed(self, resp):
"""
Ensures the response is returning a HTTP 405.
"""
return self.assertEqual(resp.status_code, 405)
def assertHttpConflict(self, resp):
"""
Ensures the response is returning a HTTP 409.
"""
return self.assertEqual(resp.status_code, 409)
def assertHttpGone(self, resp):
"""
Ensures the response is returning a HTTP 410.
"""
return self.assertEqual(resp.status_code, 410)
def assertHttpTooManyRequests(self, resp):
"""
Ensures the response is returning a HTTP 429.
"""
return self.assertEqual(resp.status_code, 429)
def assertHttpApplicationError(self, resp):
"""
Ensures the response is returning a HTTP 500.
"""
return self.assertEqual(resp.status_code, 500)
def assertHttpNotImplemented(self, resp):
"""
Ensures the response is returning a HTTP 501.
"""
return self.assertEqual(resp.status_code, 501)
def assertValidJSON(self, data):
"""
Given the provided ``data`` as a string, ensures that it is valid JSON &
can be loaded properly.
"""
# Just try the load. If it throws an exception, the test case will fail.
self.serializer.from_json(data)
def assertValidXML(self, data):
"""
Given the provided ``data`` as a string, ensures that it is valid XML &
can be loaded properly.
"""
# Just try the load. If it throws an exception, the test case will fail.
self.serializer.from_xml(data)
def assertValidYAML(self, data):
"""
Given the provided ``data`` as a string, ensures that it is valid YAML &
can be loaded properly.
"""
# Just try the load. If it throws an exception, the test case will fail.
self.serializer.from_yaml(data)
def assertValidPlist(self, data):
"""
Given the provided ``data`` as a string, ensures that it is valid
binary plist & can be loaded properly.
"""
# Just try the load. If it throws an exception, the test case will fail.
self.serializer.from_plist(data)
def assertValidJSONResponse(self, resp):
"""
Given a ``HttpResponse`` coming back from using the ``client``, assert that
you get back:
* An HTTP 200
* The correct content-type (``application/json``)
* The content is valid JSON
"""
self.assertHttpOK(resp)
self.assertTrue(resp['Content-Type'].startswith('application/json'))
self.assertValidJSON(resp.content)
def assertValidXMLResponse(self, resp):
"""
Given a ``HttpResponse`` coming back from using the ``client``, assert that
you get back:
* An HTTP 200
* The correct content-type (``application/xml``)
* The content is valid XML
"""
self.assertHttpOK(resp)
self.assertTrue(resp['Content-Type'].startswith('application/xml'))
self.assertValidXML(resp.content)
def assertValidYAMLResponse(self, resp):
"""
Given a ``HttpResponse`` coming back from using the ``client``, assert that
you get back:
* An HTTP 200
* The correct content-type (``text/yaml``)
* The content is valid YAML
"""
self.assertHttpOK(resp)
self.assertTrue(resp['Content-Type'].startswith('text/yaml'))
self.assertValidYAML(resp.content)
def assertValidPlistResponse(self, resp):
"""
Given a ``HttpResponse`` coming back from using the ``client``, assert that
you get back:
* An HTTP 200
* The correct content-type (``application/x-plist``)
* The content is valid binary plist data
"""
self.assertHttpOK(resp)
self.assertTrue(resp['Content-Type'].startswith('application/x-plist'))
self.assertValidPlist(resp.content)
def deserialize(self, resp):
"""
Given a ``HttpResponse`` coming back from using the ``client``, this method
checks the ``Content-Type`` header & attempts to deserialize the data based on
that.
It returns a Python datastructure (typically a ``dict``) of the serialized data.
"""
return self.serializer.deserialize(resp.content,
format=resp['Content-Type'])
def serialize(self, data, format='application/json'):
"""
Given a Python datastructure (typically a ``dict``) & a desired content-type,
this method will return a serialized string of that data.
"""
return self.serializer.serialize(data, format=format)
def assertKeys(self, data, expected):
"""
This method ensures that the keys of the ``data`` match up to the keys of
``expected``.
It covers the (extremely) common case where you want to make sure the keys of
a response match up to what is expected. This is typically less fragile than
testing the full structure, which can be prone to data changes.
"""
self.assertEqual(sorted(data.keys()), sorted(expected))
json_indent = 2
def to_json(self, data, options=None):
options = options or {}
data = self.to_simple(data, options)
return json.dumps(data,
cls=json.JSONEncoder,
sort_keys=True,
ensure_ascii=False,
indent=self.json_indent) + "\n"
if settings.DEBUG:
default_serializer = PrettyJSONSerializer()
else:
default_serializer = Serializer()
class SearchObject(object):
def __init__(self, hits=None, id=None):
self.hits = hits
self.id = id
class SearchAppResource(Resource):
"""Tastypie resource for simple-search"""
hits = fields.ApiField(attribute='hits', null=True)
class Meta:
resource_name = 'simple-search'
list_allowed_methods = ['get']
def setUp(self):
super(ResourceTestCase, self).setUp()
self.serializer = Serializer()
self.api_client = TestApiClient()
class TestApiClient(object):
def __init__(self, serializer=None):
"""
Sets up a fresh ``TestApiClient`` instance.
If you are employing a custom serializer, you can pass the class to the
``serializer=`` kwarg.
"""
self.client = Client()
self.serializer = serializer
if not self.serializer:
self.serializer = Serializer()
def get_content_type(self, short_format):
"""
Given a short name (such as ``json`` or ``xml``), returns the full content-type
for it (``application/json`` or ``application/xml`` in this case).
"""
return self.serializer.content_types.get(short_format, 'json')
def get(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``GET`` request to the provided URI.
Optionally accepts a ``data`` kwarg, which in the case of ``GET``, lets you
send along ``GET`` parameters. This is useful when testing filtering or other
things that read off the ``GET`` params. Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.get('/api/v1/entry/1/', data={'format': 'json', 'title__startswith': 'a', 'limit': 20, 'offset': 60})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['HTTP_ACCEPT'] = content_type
# GET & DELETE are the only times we don't serialize the data.
if data is not None:
kwargs['data'] = data
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.get(uri, **kwargs)
def post(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``POST`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``POST`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.post('/api/v1/entry/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data,
format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.post(uri, **kwargs)
def put(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``PUT`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``PUT`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.put('/api/v1/entry/1/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data,
format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.put(uri, **kwargs)
def patch(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``PATCH`` request to the provided URI.
Optionally accepts a ``data`` kwarg. **Unlike** ``GET``, in ``PATCH`` the
``data`` gets serialized & sent as the body instead of becoming part of the URI.
Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.patch('/api/v1/entry/1/', data={
'created': '2012-05-01T20:02:36',
'slug': 'another-post',
'title': 'Another Post',
'user': '******',
})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
if data is not None:
kwargs['data'] = self.serializer.serialize(data,
format=content_type)
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
# This hurts because Django doesn't support PATCH natively.
parsed = urlparse(uri)
r = {
'CONTENT_LENGTH': len(kwargs['data']),
'CONTENT_TYPE': content_type,
'PATH_INFO': self.client._get_path(parsed),
'QUERY_STRING': parsed[4],
'REQUEST_METHOD': 'PATCH',
'wsgi.input': FakePayload(kwargs['data']),
}
r.update(kwargs)
return self.client.request(**r)
def delete(self,
uri,
format='json',
data=None,
authentication=None,
**kwargs):
"""
Performs a simulated ``DELETE`` request to the provided URI.
Optionally accepts a ``data`` kwarg, which in the case of ``DELETE``, lets you
send along ``DELETE`` parameters. This is useful when testing filtering or other
things that read off the ``DELETE`` params. Example::
from tastypie.test import TestApiClient
client = TestApiClient()
response = client.delete('/api/v1/entry/1/', data={'format': 'json'})
Optionally accepts an ``authentication`` kwarg, which should be an HTTP header
with the correct authentication data already setup.
All other ``**kwargs`` passed in get passed through to the Django
``TestClient``. See https://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client
for details.
"""
content_type = self.get_content_type(format)
kwargs['content_type'] = content_type
# GET & DELETE are the only times we don't serialize the data.
if data is not None:
kwargs['data'] = data
if authentication is not None:
kwargs['HTTP_AUTHORIZATION'] = authentication
return self.client.delete(uri, **kwargs)
def test_format_datetime(self):
serializer = Serializer()
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
'2010-12-16T02:31:33')
serializer = Serializer(datetime_formatting='iso-8601')
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
'2010-12-16T02:31:33')
serializer = Serializer(datetime_formatting='iso-8601-strict')
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33, 10)),
'2010-12-16T02:31:33')
serializer = Serializer(datetime_formatting='rfc-2822')
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
u'Thu, 16 Dec 2010 02:31:33 -0600')
serializer = Serializer(datetime_formatting='random-garbage')
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
'2010-12-16T02:31:33')
# Stow.
old_format = getattr(settings, 'TASTYPIE_DATETIME_FORMATTING',
'iso-8601')
settings.TASTYPIE_DATETIME_FORMATTING = 'iso-8601'
serializer = Serializer()
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
'2010-12-16T02:31:33')
settings.TASTYPIE_DATETIME_FORMATTING = 'iso-8601-strict'
serializer = Serializer()
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33, 10)),
'2010-12-16T02:31:33')
settings.TASTYPIE_DATETIME_FORMATTING = 'rfc-2822'
serializer = Serializer()
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
u'Thu, 16 Dec 2010 02:31:33 -0600')
settings.TASTYPIE_DATETIME_FORMATTING = 'random-garbage'
serializer = Serializer()
self.assertEqual(
serializer.format_datetime(
datetime.datetime(2010, 12, 16, 2, 31, 33)),
'2010-12-16T02:31:33')
# Restore.
settings.TASTYPIE_DATETIME_FORMATTING = old_format
class Meta:
queryset = UserProfile.objects.all()
resource_name = 'profile'
serializer = Serializer(formats=['json'])
def test_to_json_multirepr(self):
serializer = Serializer()
self.assertEqual(
serializer.to_json(self.obj_list),
'[{"content": "This is my very first post using my shiny new API. Pretty sweet, huh?", "created": "2010-03-30T20:05:00", "id": 1, "is_active": true, "resource_uri": "", "slug": "first-post", "title": "First Post!", "updated": "2010-03-30T20:05:00"}, {"content": "The dog ate my cat today. He looks seriously uncomfortable.", "created": "2010-03-31T20:05:00", "id": 2, "is_active": true, "resource_uri": "", "slug": "another-post", "title": "Another Post", "updated": "2010-03-31T20:05:00"}, {"content": "My neighborhood\'s been kinda weird lately, especially after the lava flow took out the corner store. Granny can hardly outrun the magma with her walker.", "created": "2010-04-01T20:05:00", "id": 4, "is_active": true, "resource_uri": "", "slug": "recent-volcanic-activity", "title": "Recent Volcanic Activity.", "updated": "2010-04-01T20:05:00"}, {"content": "Man, the second eruption came on fast. Granny didn\'t have a chance. On the upshot, I was able to save her walker and I got a cool shawl out of the deal!", "created": "2010-04-02T10:05:00", "id": 6, "is_active": true, "resource_uri": "", "slug": "grannys-gone", "title": "Granny\'s Gone", "updated": "2010-04-02T10:05:00"}]'
)
def _call(cls, host, cmd, args):
cls.calls.append((cmd, args))
cls.host_calls[host.fqdn].append((cmd, args))
if not cls.succeed:
cls._fail(host.fqdn)
if (cmd, args) in cls.fail_commands:
cls._fail(host.fqdn)
mock_server = cls.mock_servers[host.address]
log.info("invoke_agent %s %s %s" % (host, cmd, args))
# This isn't really accurate because lnet is scanned asynchonously, but it is as close as we can get today
# Fixme: Also I know think this is writing to the wrong thing and should be changing the mock_server entries.
# to lnet_up, I guess the mock_server needs an lnet state really, rather than relying on nids present.
if cmd == "load_lnet":
synthetic_lnet_configuration(host, mock_server["nids"])
return
elif cmd == "device_plugin":
# Only returns nid info today.
return create_synthetic_device_info(host, mock_server, args["plugin"])
elif cmd == "format_target":
inode_size = None
if "mkfsoptions" in args:
inode_arg = re.search("-I (\d+)", args["mkfsoptions"])
if inode_arg:
inode_size = int(inode_arg.group(1).__str__())
if inode_size is None:
# A 'foo' value
inode_size = 777
return {
"uuid": uuid.uuid1().__str__(),
"inode_count": 666,
"inode_size": inode_size,
"filesystem_type": "ext4",
}
elif cmd == "stop_target":
ha_label = args["ha_label"]
target = ManagedTarget.objects.get(ha_label=ha_label)
return agent_result_ok
elif cmd == "start_target":
ha_label = args["ha_label"]
target = ManagedTarget.objects.get(ha_label=ha_label)
return agent_result(target.primary_host.nodename)
elif cmd == "register_target":
# Assume mount paths are "/mnt/testfs-OST0001" style
mount_point = args["mount_point"]
label = re.search("/mnt/([^\s]+)", mount_point).group(1)
return {"label": label}
elif cmd == "detect_scan":
return mock_server["detect-scan"]
elif cmd == "install_packages":
return agent_result([])
elif cmd == "register_server":
api_client = TestApiClient()
old_is_authenticated = CsrfAuthentication.is_authenticated
try:
CsrfAuthentication.is_authenticated = mock.Mock(return_value=True)
api_client.client.login(username="******", password="******")
fqdn = cls.mock_servers[host]["fqdn"]
response = api_client.post(
args["url"] + "register/%s/" % args["secret"],
data={
"address": host,
"fqdn": fqdn,
"nodename": cls.mock_servers[host]["nodename"],
"capabilities": ["manage_targets"],
"version": cls.version,
"csr": helper.generate_csr(fqdn),
},
)
assert response.status_code == 201
registration_data = Serializer().deserialize(response.content, format=response["Content-Type"])
print("MockAgent.invoke returning %s" % registration_data)
return registration_data
finally:
CsrfAuthentication.is_authenticated = old_is_authenticated
elif cmd == "kernel_status":
return {"running": "fake_kernel-0.1", "required": "fake_kernel-0.1", "available": ["fake_kernel-0.1"]}
elif cmd == "selinux_status":
return {"status": "Disabled"}
elif cmd == "reboot_server":
now = IMLDateTime.utcnow()
log.info("rebooting %s; updating boot_time to %s" % (host, now))
job_scheduler_notify.notify(host, now, {"boot_time": now})
elif "socket.gethostbyname(socket.gethostname())" in cmd:
if not mock_server["tests"]["hostname_valid"]:
return "127.0.0.1"
else:
return mock_server["address"]
elif "print os.uname()[1]" in cmd:
return "%s\n%s" % (mock_server["nodename"], mock_server["fqdn"])
elif "socket.getfqdn()" in cmd:
return mock_server["fqdn"]
elif "ping" in cmd:
result = (0 if mock_server["tests"]["reverse_resolve"] else 2) + (
0 if mock_server["tests"]["reverse_ping"] else 1
)
return result
elif "ElectricFence" in cmd:
return 0 if mock_server["tests"]["yum_can_update"] else 1
elif "openssl version -a" in cmd:
return 0 if mock_server["tests"]["openssl"] else 1
elif "curl -k https" in cmd:
return json.dumps({"host_id": host.id, "command_id": 0})
elif cmd in [
"configure_pacemaker",
"unconfigure_pacemaker",
"configure_target_store",
"unconfigure_target_store",
"deregister_server",
"restart_agent",
"shutdown_server",
"host_corosync_config",
"check_block_device",
"set_conf_param",
"purge_configuration",
]:
return None
elif cmd in [
"configure_target_ha",
"unconfigure_target_ha",
"start_lnet",
"stop_lnet",
"unload_lnet",
"unconfigure_lnet",
"configure_corosync",
"unconfigure_corosync",
"start_corosync",
"stop_corosync",
"start_pacemaker",
"stop_pacemaker",
"configure_ntp",
"unconfigure_ntp",
"import_target",
"export_target",
"set_profile",
"update_profile",
"failover_target",
"failback_target",
"configure_network",
"open_firewall",
"close_firewall",
]:
return agent_result_ok
elif cmd == "get_corosync_autoconfig":
return agent_result(
{
"interfaces": {
"eth0": {"dedicated": False, "ipaddr": "192.168.0.1", "prefix": 24},
"eth1": {"dedicated": True, "ipaddr": "10.10.0.01", "prefix": 24},
},
"mcast_port": "666",
}
)
else:
assert False, (
"The %s command is not in the known list for MockAgentRpc. Please add it then when people modify it a simple text search will let them know to change it here as well."
% cmd
)
def test_to_xml_multirepr(self):
serializer = Serializer()
self.assertEqual(
serializer.to_xml(self.obj_list),
'<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<objects><object type="hash"><content>This is my very first post using my shiny new API. Pretty sweet, huh?</content><created>2010-03-30T20:05:00</created><id type="integer">1</id><is_active type="boolean">True</is_active><resource_uri></resource_uri><slug>first-post</slug><title>First Post!</title><updated>2010-03-30T20:05:00</updated></object><object type="hash"><content>The dog ate my cat today. He looks seriously uncomfortable.</content><created>2010-03-31T20:05:00</created><id type="integer">2</id><is_active type="boolean">True</is_active><resource_uri></resource_uri><slug>another-post</slug><title>Another Post</title><updated>2010-03-31T20:05:00</updated></object><object type="hash"><content>My neighborhood\'s been kinda weird lately, especially after the lava flow took out the corner store. Granny can hardly outrun the magma with her walker.</content><created>2010-04-01T20:05:00</created><id type="integer">4</id><is_active type="boolean">True</is_active><resource_uri></resource_uri><slug>recent-volcanic-activity</slug><title>Recent Volcanic Activity.</title><updated>2010-04-01T20:05:00</updated></object><object type="hash"><content>Man, the second eruption came on fast. Granny didn\'t have a chance. On the upshot, I was able to save her walker and I got a cool shawl out of the deal!</content><created>2010-04-02T10:05:00</created><id type="integer">6</id><is_active type="boolean">True</is_active><resource_uri></resource_uri><slug>grannys-gone</slug><title>Granny\'s Gone</title><updated>2010-04-02T10:05:00</updated></object></objects>'
)
class Meta:
queryset = Sector.objects.all()
resource_name = 'sectors'
serializer = Serializer(formats=['xml', 'json'])
def test_unsafe_yaml(self):
serializer = Serializer()
evil_data = UnsafeObject()
serialized = yaml.dump(evil_data)
self.assertRaises(yaml.constructor.ConstructorError,
serializer.from_yaml, serialized)
class Meta:
queryset = Country.objects.all()
resource_name = 'country-polygons'
excludes = ['dac_country_code', 'dac_region_code', 'dac_region_name', 'iso3', 'language']
include_resource_uri = False
serializer = Serializer(formats=['xml', 'json'])
def test_round_trip_yaml(self):
serializer = Serializer()
sample_data = self.get_sample2()
serialized = serializer.to_yaml(sample_data)
unserialized = serializer.from_yaml(serialized)
self.assertEqual(sample_data, unserialized)
class Meta:
queryset = Activity.objects.all()
resource_name = 'activity-list'
max_limit = 100
serializer = Serializer(formats=['xml', 'json'])
class Meta:
queryset = City.objects.all()
resource_name = 'cities'
include_resource_uri = False
serializer = Serializer(formats=['xml', 'json'])