class WindowSizeTests(TestCase):
def setUp(self):
# Every test needs access to the request factory.
self.factory = RequestFactory()
info_manager = InfoManager.InfoManager()
info_manager.init_information()
serverInfoMock = mock()
tenantInfoMock = mock()
tenantQuery = Models.TenantInfo.objects.create(tenantId="tenantId", windowsize=5)
when(serverInfoMock).objects().thenReturn(serverInfoMock)
when(tenantInfoMock).objects().thenReturn(tenantInfoMock)
when(tenantInfoMock).get(tenantId__exact="tenantId").thenReturn(tenantQuery)
info_manager.setInformations(serverInfoMock, tenantInfoMock)
myMock = mock()
mockedInfo = information.information("test", "test", "test", datetime.datetime.now(), "test")
validWindowSize = "4"
validWindowSizeValue = 5
invalidWindowSize = "notValidValue"
when(myMock).updateWindowSize("tenantId", validWindowSizeValue).thenReturn(mockedInfo)
when(myMock).updateWindowSize("tenantId", invalidWindowSize).thenReturn(None)
when(myMock).parse("{\"windowsize\": %s}" % validWindowSize).thenReturn(mockedInfo)
when(myMock).parse("{\"windowsize\": %s}" % invalidWindowSize).thenReturn(None)
self.general = GeneralView()
@patch('cloto.manager.InfoManager.logger')
def test_update_window(self, mock_logging):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": 4}", "application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 200)
self.assertTrue(mock_logging.info.called)
def test_not_update_window(self):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": notValidValue}", "application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 400)
def test_not_update_window2(self):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": -1}", "application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 400)
class Test(unittest.TestCase):
def setUp(self):
self.store = CharmeMiddleware.get_store(debug = True)
self.graph = 'submitted'
self.identifier = '%s/%s' % (getattr(settings, 'SPARQL_DATA'),
self.graph)
self.g = Graph(store=self.store, identifier=self.identifier)
self.factory = RequestFactory()
def tearDown(self):
for res in self.g:
self.g.remove(res)
def test_PUT(self):
#self.test_insert_anotation()
graph = format_graphIRI('submitted')
request = self.factory.put('/endpoint?graph=%s' % graph,
data = turtle_usecase1,
content_type = 'text/turtle')
response = endpoint(request)
self.assert_(response.status_code in [200, 204], "HTTPResponse has status_code: %s"
% response.status_code)
class RestAuthMiddlewareTests(TestCase):
def setUp(self):
self.handler = handlers.JSONContentHandler()
self.extra = {
'HTTP_ACCEPT': self.handler.mime,
'REMOTE_USER': '******',
'content_type': self.handler.mime,
}
self.factory = RequestFactory()
self.mw = RestAuthMiddleware()
def tearDown(self):
Service.objects.all().delete()
def test_post_missing_content_type(self):
content = self.handler.marshal_dict({'user': username1})
request = self.factory.post('/users/', content, **self.extra)
del request.META['CONTENT_TYPE']
resp = self.mw.process_request(request)
self.assertEqual(resp.status_code, http_client.UNSUPPORTED_MEDIA_TYPE)
def test_put_missing_content_type(self):
content = self.handler.marshal_dict({'user': username1})
request = self.factory.put('/users/', content, **self.extra)
del request.META['CONTENT_TYPE']
resp = self.mw.process_request(request)
self.assertEqual(resp.status_code, http_client.UNSUPPORTED_MEDIA_TYPE)
def create_request(method="get", **kwargs):
resource_link_id = kwargs.pop(
"resource_link_id", "2a8b2d3fa51ea413d19e480fb6c2eb085b7866a9"
)
session = {"LTI_LAUNCH": {}}
session["LTI_LAUNCH"][resource_link_id] = kwargs.pop("session")
params = kwargs.pop("params", {})
body = kwargs.pop("data", {})
url = kwargs.pop("url", "/foo")
request_factory = RequestFactory()
if method == "get":
request = request_factory.get(url, data=params, content_type="application/json")
elif method == "post":
request = request_factory.post(
url, data=json.dumps(body), content_type="application/json"
)
elif method == "put":
request = request_factory.put(
url, data=json.dumps(body), content_type="application/json"
)
elif method == "delete":
request = request_factory.delete(
url, data=json.dumps(body), content_type="application/json"
)
else:
raise Exception("invalid method: %s" % method)
request.session = session
setattr(request, "LTI", session.get("LTI_LAUNCH", {}).get(resource_link_id))
return request
class ApitilsViewsTests(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_get_ok(self):
request = self.factory.get('/apiview/')
response = APIView.as_view()(request)
self.assertEqual(response.status_code, 200)
def test_post_ok(self):
request = self.factory.post('/apiview/', {'foo': 'bar'})
response = APIView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.content, '{"foo": "bar"}')
def test_put_ok(self):
request = self.factory.put(
'/apiview/',
'{"foo": "bar"}',
content_type='application/json'
)
response = APIView.as_view()(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.content, '{"foo": "bar"}')
class MImgTest(unittest.TestCase):
def setUp(self) -> None:
self.request = RequestFactory()
# --------- Use case 1 ----------------
# Scenario 1
def getTest1(self):
MImg.objects.create(path='media/images/blue.jpg',
content=Image,
name='blue')
request = self.request.get('image/blue')
response = views.ImgHandler.as_view(request)
self.assertEqual(response.status_code, 200)
# Scenario 2
def getTest2(self):
request = self.request.get('image/blue')
response = views.ImgHandler.as_view(request)
self.assertEqual(response.status_code, 404)
# --------- Use case 2 ----------------
# Scenario 1
def postTest(self):
request = self.request.post('image/blue')
response = views.ImgHandler.as_view(request)
self.assertEqual(response.status_code, 200)
# Scenario 2
def putTest(self):
request = self.request.put('image/blue')
response = views.ImgHandler.as_view(request)
self.assertEqual(response.status_code, 200)
class RestAuthMiddlewareTests(TestCase):
def setUp(self):
self.handler = handlers.json()
self.extra = {
'HTTP_ACCEPT': self.handler.mime,
'REMOTE_USER': '******',
'content_type': self.handler.mime,
}
self.factory = RequestFactory()
self.mw = RestAuthMiddleware()
def tearDown(self):
Service.objects.all().delete()
def test_post_missing_content_type(self):
content = self.handler.marshal_dict({'user': username1})
request = self.factory.post('/users/', content, **self.extra)
del request.META['CONTENT_TYPE']
resp = self.mw.process_request(request)
self.assertEqual(resp.status_code, http_client.UNSUPPORTED_MEDIA_TYPE)
def test_put_missing_content_type(self):
content = self.handler.marshal_dict({'user': username1})
request = self.factory.put('/users/', content, **self.extra)
del request.META['CONTENT_TYPE']
resp = self.mw.process_request(request)
self.assertEqual(resp.status_code, http_client.UNSUPPORTED_MEDIA_TYPE)
class LoginUserTest(MockedCloudTestCase):
def setUp(self):
super(LoginUserTest, self).setUp()
self.factory = RequestFactory()
# Create an user to check login attempts against
self.existing_user = User.objects.create_user(username='******', cloud_fqdn='existingserver')
def tearDown(self):
self.existing_user.delete()
def test_login_good_credentials(self):
good_creds={'username': '******',
'password': '******',
'cloud_fqdn': 'existingserver',}
request = self.factory.post(reverse(login_user), data=good_creds)
self.do_session_middleware_stuff(request)
resp = login_user(request)
self.assertEqual(resp.status_code, 200)
def test_login_bad_credentials(self):
bad_creds={'username': '******',
'password': '******',
'cloud_fqdn': 'existingserver',}
request = self.factory.post(reverse(login_user), data=bad_creds)
self.do_session_middleware_stuff(request)
# Set mocked backend to fail authentication
self.set_auth_result(False)
resp = login_user(request)
self.assertEqual(resp.status_code, 401)
def test_login_missing_credentials(self):
missing_creds={'username': '******',
'cloud_fqdn': 'existingserver',}
request = self.factory.post(reverse(login_user), data=missing_creds)
resp = login_user(request)
self.assertEqual(resp.status_code, 400)
def test_login_bad_methods(self):
get_request = self.factory.get(reverse(login_user))
resp = login_user(get_request)
self.assertEqual(resp.status_code, 405)
put_request = self.factory.put(reverse(login_user))
resp = login_user(put_request)
self.assertEqual(resp.status_code, 405)
delete_request = self.factory.delete(reverse(login_user))
resp = login_user(delete_request)
self.assertEqual(resp.status_code, 405)
def test_login_no_persistent_session(self):
good_creds={'username': '******',
'password': '******',
'cloud_fqdn': 'existingserver',
'persistent_session': 'False'}
resp = self.client.post(reverse(login_user), good_creds)
self.assertEqual(resp.status_code, 200)
session_cookie = self.client.cookies['sessionid']
self.assertEqual(session_cookie['expires'], "")
class PatientTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
Patient.objects.create(name="Kazim", lastname="Kazim", age=34)
Patient.objects.create(name="Tahm", lastname="Kench", age=91)
def test_get_method(self):
request = self.factory.get('/hospital/patient/')
response = patient_single(request, 1)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.content,
JsonResponse({
"name": "Kazim",
"lastname": "Kazim",
"age": 34
}).content)
def test_put_method(self):
request = self.factory.put('/hospital/patient/',
json.dumps({"name": "Salih"}),
content_type='application/json')
response = patient_single(request, 1)
self.assertEqual(response.status_code, 200)
patient = Patient.objects.filter(id=int(1)).first()
self.assertEqual("Salih", patient.name)
def test_post_method(self):
request = self.factory.post('/hospital/patient',
json.dumps({
"name": "Muhittin",
"lastname": "Yilmaz",
"age": 50
}),
content_type='application/json')
response = patient(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content,
JsonResponse({
"status": "OK",
"message": ""
}).content)
def test_delete_method(self):
request = self.factory.delete('/hospital/patient',
json.dumps({"name": "Kazim"}),
content_type='application/json')
response = patient_single(request, 1)
self.assertEqual(response.status_code, 200)
patient = Patient.objects.filter(id=int(1)).first()
self.assertEqual(response.content,
JsonResponse({
"status": "OK",
"message": ""
}).content)
def tearDown(self):
Patient.objects.all().delete()
class OrganizationChangeTestCase(TestCase):
tags = ('fiware-ut-25',)
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create_user(username='******', email='', password='******')
# Create testing request
self.data = {
'organization': 'test_org'
}
self.request = self.factory.put(
'/administration/organizations/change',
json.dumps(self.data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
self.request.user = self.user
def test_organization_change(self):
org = Organization.objects.create(
name='test_org'
)
# Update user profile info
self.user.userprofile.organizations.append({
'organization': org.pk
})
self.user.userprofile.save()
response = views.change_current_organization(self.request)
self.user = User.objects.get(username='******')
self.assertEquals(self.user.userprofile.current_organization.pk, org.pk)
body_response = json.loads(response.content)
self.assertEquals(response.status_code, 200)
self.assertEquals(body_response['message'], 'OK')
self.assertEquals(body_response['result'], 'correct')
def test_organization_change_errors(self):
errors = [
'Not found',
'Forbidden'
]
for i in [0, 1]:
if i == 1:
Organization.objects.create(
name='test_org'
)
response = views.change_current_organization(self.request)
body_response = json.loads(response.content)
self.assertEquals(body_response['message'], errors[i])
self.assertEquals(body_response['result'], 'error')
class UserRepoSyncTest(TestCase):
#
# These are kind of terrible now. They test for a forbidden response is
# legit, but we're short circuiting the POST to sync as to not make
# an external request to GitHub.
#
fixtures = ['gitspatial/fixtures/test_data.json']
def setUp(self):
self.sal = User.objects.get(id=6)
self.jason = User.objects.get(id=5)
self.factory = RequestFactory()
def test_user_can_sync_own_repo(self):
request = self.factory.post('/user/repo/22/sync?testing=1')
request.user = self.jason
response = user_repo_sync(request, repo_id=22)
self.assertEqual(response.status_code, 201)
def test_user_cannot_sync_others_repo(self):
request = self.factory.post('/user/repo/22/sync')
request.user = self.sal
response = user_repo_sync(request, repo_id=22)
self.assertEqual(response.status_code, 403)
def test_user_can_unsync_own_repo(self):
request = self.factory.delete('/user/repo/22/sync?testing=1')
request.user = self.jason
response = user_repo_sync(request, repo_id=22)
self.assertEqual(response.status_code, 204)
def test_user_cannot_unsync_others_repo(self):
request = self.factory.delete('/user/repo/22/sync')
request.user = self.sal
response = user_repo_sync(request, repo_id=22)
self.assertEqual(response.status_code, 403)
def test_invalid_method_put(self):
request = self.factory.put('/user/repo/22/sync?testing=1')
request.user = self.jason
response = user_repo_sync(request, repo_id=22)
self.assertEqual(response.status_code, 405)
def test_invalid_method_get(self):
request = self.factory.get('/user/repo/22/sync?testing=1')
request.user = self.jason
response = user_repo_sync(request, repo_id=22)
self.assertEqual(response.status_code, 405)
def test_user_repo_sync_dne(self):
request = self.factory.post('/user/repo/99999/sync')
request.user = self.jason
try:
response = user_repo_sync(request, repo_id=99999)
except Exception as exc:
pass
self.assertTrue(isinstance(exc, Http404))
class CBVTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
dict_response = dict(foo='bar')
self.dict_response = dict_response
@jsonp
class DictResponse(View):
def get(self, request):
return dict_response
@jsonp
class InvalidResponseFormat(View):
def get(self, request):
return []
self.simple_dict_view = DictResponse.as_view()
self.invalid_view = InvalidResponseFormat.as_view()
def assert_content_and_content_type(self, response, callback):
self.assertContains(response, callback)
self.assertContains(response, json.dumps(self.dict_response))
self.assertEqual(response['Content-Type'], APPLICATION_JS)
def test_correct_response(self):
callback = 'isThereASpoon'
response = self.simple_dict_view(
request=self.factory.get('/fake.json?jsonp={0}'.format(callback)))
self.assert_content_and_content_type(response, callback)
def test_method_not_allowed(self):
callback = 'isThereASpoon'
put_response = self.simple_dict_view(
request=self.factory.put('/fake.json?jsonp={0}'.format(callback)))
post_response = self.simple_dict_view(
request=self.factory.post('/fake.json?jsonp={0}'.format(callback)))
delete_response = self.simple_dict_view(request=self.factory.delete(
'/fake.json?jsonp={0}'.format(callback)))
for r in [put_response, post_response, delete_response]:
self.assertIsInstance(r, HttpResponseNotAllowed)
def test_invalid_response_format(self):
callback = 'howMuchIsTheFish'
self.assertRaises(
NotImplementedError,
lambda: self.invalid_view(request=self.factory.get(
'/fake.json?jsonp={0}'.format(callback))))
def test_no_callback(self):
response = self.simple_dict_view(
request=self.factory.get('/fake.json?'))
self.assertIsInstance(response, HttpResponseBadRequest)
class FBVTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.dict_response = dict(foo='bar')
@jsonp
def simple_dict_view(request):
return self.dict_response
@jsonp
def simple_http_response_view(request):
return HttpResponse(json.dumps(self.dict_response))
self.simple_dict_view = simple_dict_view
self.simple_http_response_view = simple_http_response_view
def assert_content_and_content_type(self, response, callback):
self.assertContains(response, callback)
self.assertContains(response, json.dumps(self.dict_response))
self.assertEqual(response['Content-Type'], APPLICATION_JS)
def test_response_correct_format_from_dict(self):
callback = 'showMeTheMoney'
request = self.factory.get('/fake.json?callback={0}'.format(callback))
response = self.simple_dict_view(request)
self.assertContains(
response, '{0}({1})'.format(callback,
json.dumps(self.dict_response)))
self.assertEqual(APPLICATION_JS, response['Content-Type'])
def test_response_correct_from_http_response(self):
callback = 'whatsMyAgeAgain'
response = self.simple_http_response_view(
self.factory.get('/fake.json?callback={0}'.format(callback)))
self.assert_content_and_content_type(response, callback)
def test_with_different_callback_param_name(self):
callback = 'giveMeNovocaine'
response = self.simple_http_response_view(
request=self.factory.get('/fake.json?jsonp={0}'.format(callback)))
self.assert_content_and_content_type(response, callback)
def test_method_not_allowed(self):
callback = 'isThereASpoon'
put_response = self.simple_dict_view(
request=self.factory.put('/fake.json?jsonp={0}'.format(callback)))
post_response = self.simple_dict_view(
request=self.factory.post('/fake.json?jsonp={0}'.format(callback)))
delete_response = self.simple_dict_view(request=self.factory.delete(
'/fake.json?jsonp={0}'.format(callback)))
for r in [put_response, post_response, delete_response]:
self.assertIsInstance(r, HttpResponseNotAllowed)
class OrganizationChangeTestCase(TestCase):
tags = ('fiware-ut-25', )
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create_user(username='******',
email='',
password='******')
# Create testing request
self.data = {'organization': 'test_org'}
self.request = self.factory.put('/administration/organizations/change',
json.dumps(self.data),
content_type='application/json',
HTTP_ACCEPT='application/json')
self.request.user = self.user
def test_organization_change(self):
org = Organization.objects.create(name='test_org')
# Update user profile info
self.user.userprofile.organizations.append({'organization': org.pk})
self.user.userprofile.save()
response = views.change_current_organization(self.request)
self.user = User.objects.get(username='******')
self.assertEquals(self.user.userprofile.current_organization.pk,
org.pk)
body_response = json.loads(response.content)
self.assertEquals(response.status_code, 200)
self.assertEquals(body_response['message'], 'OK')
self.assertEquals(body_response['result'], 'correct')
def test_organization_change_errors(self):
errors = ['Not found', 'Forbidden']
for i in [0, 1]:
if i == 1:
Organization.objects.create(name='test_org')
response = views.change_current_organization(self.request)
body_response = json.loads(response.content)
self.assertEquals(body_response['message'], errors[i])
self.assertEquals(body_response['result'], 'error')
class FBVTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.dict_response = dict(foo='bar')
@jsonp
def simple_dict_view(request):
return self.dict_response
@jsonp
def simple_http_response_view(request):
return HttpResponse(json.dumps(self.dict_response))
self.simple_dict_view = simple_dict_view
self.simple_http_response_view = simple_http_response_view
def assert_content_and_content_type(self, response, callback):
self.assertContains(response, callback)
self.assertContains(response, json.dumps(self.dict_response))
self.assertEqual(response['Content-Type'], APPLICATION_JS)
def test_response_correct_format_from_dict(self):
callback = 'showMeTheMoney'
request = self.factory.get('/fake.json?callback={0}'.format(callback))
response = self.simple_dict_view(request)
self.assertContains(response, '{0}({1})'.format(callback, json.dumps(self.dict_response)))
self.assertEqual(APPLICATION_JS, response['Content-Type'])
def test_response_correct_from_http_response(self):
callback = 'whatsMyAgeAgain'
response = self.simple_http_response_view(self.factory.get('/fake.json?callback={0}'.format(callback)))
self.assert_content_and_content_type(response, callback)
def test_with_different_callback_param_name(self):
callback = 'giveMeNovocaine'
response = self.simple_http_response_view(request=self.factory.get('/fake.json?jsonp={0}'.format(callback)))
self.assert_content_and_content_type(response, callback)
def test_method_not_allowed(self):
callback = 'isThereASpoon'
put_response = self.simple_dict_view(request=self.factory.put('/fake.json?jsonp={0}'.format(callback)))
post_response = self.simple_dict_view(request=self.factory.post('/fake.json?jsonp={0}'.format(callback)))
delete_response = self.simple_dict_view(request=self.factory.delete('/fake.json?jsonp={0}'.format(callback)))
for r in [put_response, post_response, delete_response]:
self.assertIsInstance(r, HttpResponseNotAllowed)
class CBVTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
dict_response = dict(foo='bar')
self.dict_response = dict_response
@jsonp
class DictResponse(View):
def get(self, request):
return dict_response
@jsonp
class InvalidResponseFormat(View):
def get(self, request):
return []
self.simple_dict_view = DictResponse.as_view()
self.invalid_view = InvalidResponseFormat.as_view()
def assert_content_and_content_type(self, response, callback):
self.assertContains(response, callback)
self.assertContains(response, json.dumps(self.dict_response))
self.assertEqual(response['Content-Type'], APPLICATION_JS)
def test_correct_response(self):
callback = 'isThereASpoon'
response = self.simple_dict_view(request=self.factory.get('/fake.json?jsonp={0}'.format(callback)))
self.assert_content_and_content_type(response, callback)
def test_method_not_allowed(self):
callback = 'isThereASpoon'
put_response = self.simple_dict_view(request=self.factory.put('/fake.json?jsonp={0}'.format(callback)))
post_response = self.simple_dict_view(request=self.factory.post('/fake.json?jsonp={0}'.format(callback)))
delete_response = self.simple_dict_view(request=self.factory.delete('/fake.json?jsonp={0}'.format(callback)))
for r in [put_response, post_response, delete_response]:
self.assertIsInstance(r, HttpResponseNotAllowed)
def test_invalid_response_format(self):
callback = 'howMuchIsTheFish'
self.assertRaises(NotImplementedError,
lambda: self.invalid_view(request=self.factory.get('/fake.json?jsonp={0}'.format(callback))))
def test_no_callback(self):
response = self.simple_dict_view(request=self.factory.get('/fake.json?'))
self.assertIsInstance(response, HttpResponseBadRequest)
class DepartmentTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
Department.objects.create(name="yuz kafa bas")
Department.objects.create(name="deliler kismi")
def test_get_method(self):
request = self.factory.get('/hospital/department/')
response = department_single(request, 1)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content,
JsonResponse({
"name": "yuz kafa bas"
}).content)
def test_get_all(self):
request = self.factory.get('/hospital/department/')
response = department(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.content,
JsonResponse(
{
"departments": [{
"name": "yuz kafa bas"
}, {
"name": "deliler kismi"
}]
},
safe=False).content)
def test_put_method(self):
request = self.factory.put('/hospital/department/',
json.dumps({"name": "tirnak burun sac"}),
content_type='application/json')
response = department_single(request, 1)
self.assertEqual(response.status_code, 200)
department = Department.objects.filter(id=int(1)).first()
self.assertEqual("tirnak burun sac", department.name)
def tearDown(self):
Department.objects.all().delete()
def create_request(method='get', **kwargs):
resource_link_id = kwargs.pop('resource_link_id', "2a8b2d3fa51ea413d19e480fb6c2eb085b7866a9")
session = {"LTI_LAUNCH": {}}
session['LTI_LAUNCH'][resource_link_id] = kwargs.pop('session')
params = kwargs.pop('params', {})
body = kwargs.pop('data', {})
url = kwargs.pop('url', '/foo')
request_factory = RequestFactory()
if method == 'get':
request = request_factory.get(url, data=params, content_type='application/json')
elif method == 'post':
request = request_factory.post(url, data=json.dumps(body), content_type='application/json')
elif method == 'put':
request = request_factory.put(url, data=json.dumps(body), content_type='application/json')
elif method == 'delete':
request = request_factory.delete(url, data=json.dumps(body), content_type='application/json')
else:
raise Exception("invalid method: %s" % method)
request.session = session
setattr(request, 'LTI', session.get('LTI_LAUNCH', {}).get(resource_link_id))
return request
class WindowSizeTests(TestCase):
def setUp(self):
# Every test needs access to the request factory.
self.factory = RequestFactory()
info_manager = InfoManager.InfoManager()
info_manager.init_information()
serverInfoMock = mock()
tenantInfoMock = mock()
tenantQuery = Models.TenantInfo.objects.create(tenantId="tenantId", windowsize=5)
when(serverInfoMock).objects().thenReturn(serverInfoMock)
when(tenantInfoMock).objects().thenReturn(tenantInfoMock)
when(tenantInfoMock).get(tenantId__exact="tenantId").thenReturn(tenantQuery)
info_manager.setInformations(serverInfoMock, tenantInfoMock)
myMock = mock()
mockedInfo = information.information("test", "test", "test", datetime.datetime.now(), "test")
validWindowSize = "4"
self.validWindowSizeValue = 5
self.new_windowsize_value = 4
invalidWindowSize = "notValidValue"
when(myMock).updateWindowSize("tenantId", self.validWindowSizeValue).thenReturn(mockedInfo)
when(myMock).updateWindowSize("tenantId", invalidWindowSize).thenReturn(None)
when(myMock).parse("{\"windowsize\": %s}" % validWindowSize).thenReturn(mockedInfo)
when(myMock).parse("{\"windowsize\": %s}" % invalidWindowSize).thenReturn(None)
self.general = GeneralView()
@patch('fiware_cloto.cloto.manager.InfoManager.logger')
@patch('fiware_cloto.cloto.manager.InfoManager.pika')
def test_update_window(self, mock_pika, mock_logging):
"""Test if server updates the window size of a tenant.
"""
request_check_init = self.factory.get('/v1.0/tenantId/')
response_check_init = self.general.GET(request_check_init, "tenantId")
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": " + str(self.new_windowsize_value)
+ "}", "application/json")
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 200)
request_check_final = self.factory.get('/v1.0/tenantId/')
response_check_final = self.general.GET(request_check_final, "tenantId")
window_size_init = json.loads(response_check_init.content)["windowsize"]
window_size_final = json.loads(response_check_final.content)["windowsize"]
self.assertEqual(window_size_init, self.validWindowSizeValue)
self.assertEqual(window_size_final, self.new_windowsize_value)
self.assertTrue(mock_logging.info.called)
self.assertTrue(mock_pika.BlockingConnection.called)
@patch('fiware_cloto.cloto.manager.InfoManager.logger')
def test_update_window_fail_connection(self, mock_logging):
"""Test if Publish a message related to the windowsize in the rabbitmq fails when there is
no connection to rabbit.
"""
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": " + str(self.new_windowsize_value)
+ "}", "application/json")
try:
response = self.general.PUT(request, "tenantId")
except Exception as ex:
self.assertRaises(ex)
self.assertTrue(mock_logging.info.called)
def test_not_update_window(self):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": notValidValue}", "application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 400)
def test_not_update_window2(self):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": -1}", "application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 400)
@skip
def testPublishingConnectionNone(self):
""" Test if method fails when tries to publish a message with AMQP connection equal to None.
"""
queue = InfoManager.InfoManager()
queue.connection = None
expectedvalue = "AMQP connection not properly created..."
message = "tenantId " + str(self.validWindowSizeValue)
try:
queue.publish_message(message)
except (Exception), err:
self.assertEqual(expectedvalue, err.message)
class ResourceTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_default(self):
"Tests for the default Resource which is very limited."
# Default resource
resource = Resource()
# Populated implicitly via the metaclass..
self.assertEqual(resource.allowed_methods, ("OPTIONS",))
# OPTIONS is successful, default response with no content is a 204
request = self.factory.options("/")
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
# Try another non-default method
request = self.factory.get("/")
response = resource(request)
self.assertEqual(response.status_code, codes.method_not_allowed)
self.assertEqual(response["Allow"], "OPTIONS")
def test_default_head(self):
class GetResource(Resource):
def get(self, request):
return {}
resource = GetResource()
request = self.factory.head("/")
response = resource(request)
self.assertEqual(response.status_code, codes.ok)
self.assertEqual(response["Content-Type"], "application/json")
self.assertEqual(response.content, b"")
def test_default_patch(self):
# Resources supporting PATCH requests should have an additional
# header in the response from an OPTIONS request
class PatchResource(Resource):
def patch(self, request):
pass
resource = PatchResource()
request = self.factory.options("/")
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Accept-Patch"], "application/json")
self.assertEqual(response["Content-Type"], "application/json")
def test_service_unavailable(self):
"Test service unavailability."
class IndefiniteUnavailableResource(Resource):
unavailable = True
resource = IndefiniteUnavailableResource()
# Simply setting `unavailable` to True will provide a 'Retry-After'
# header
request = self.factory.request()
response = resource(request)
self.assertEqual(response.status_code, codes.service_unavailable)
self.assertTrue("Retry-After" not in response)
self.assertEqual(response["Content-Type"], "application/json")
def test_service_unavailable_retry_seconds(self):
"Test service unavailability with seconds."
class DeltaUnavailableResource(Resource):
unavailable = 20
resource = DeltaUnavailableResource()
# Set unavailable, but with a specific number of seconds to retry
# after
request = self.factory.request()
response = resource(request)
self.assertEqual(response.status_code, codes.service_unavailable)
self.assertEqual(response["Retry-After"], "20")
self.assertEqual(response["Content-Type"], "application/json")
def test_service_unavailable_retry_date(self):
"Test service unavailability with date."
from datetime import datetime, timedelta
from django.utils.http import http_date
future = datetime.now() + timedelta(seconds=20)
class DatetimeUnavailableResource(Resource):
unavailable = future
resource = DatetimeUnavailableResource()
request = self.factory.request()
response = resource(request)
self.assertEqual(response.status_code, codes.service_unavailable)
self.assertEqual(response["Retry-After"], http_date(timegm(future.utctimetuple())))
self.assertEqual(response["Content-Type"], "application/json")
def test_unsupported_media_type(self):
"Test various Content-* combinations."
class NoOpResource(Resource):
def post(self, request, *args, **kwargs):
pass
resource = NoOpResource()
# Works.. default accept-type is application/json
request = self.factory.post("/", data=b'{"message": "hello w\xc3\xb6"}', content_type="application/json")
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Content-Type"], "application/json")
# Does not work.. XML not accepted by default
request = self.factory.post("/", data="<message>hello world</message>", content_type="application/xml")
response = resource(request)
self.assertEqual(response.status_code, codes.unsupported_media_type)
self.assertEqual(response["Content-Type"], "application/json")
def test_not_acceptable(self):
"Test Accept header."
class ReadOnlyResource(Resource):
def get(self, request, *args, **kwargs):
return {}
resource = ReadOnlyResource()
# No accept-type is specified, defaults to highest priority one
# for resource
request = self.factory.request()
response = resource(request)
self.assertEqual(response.status_code, codes.ok)
self.assertEqual(response["Content-Type"], "application/json")
# Explicit accept header, application/json wins since it's equal
# priority and supported
request = self.factory.request(HTTP_ACCEPT="application/json,application/xml;q=0.9,*/*;q=0.8")
response = resource(request)
self.assertEqual(response.status_code, codes.ok)
self.assertEqual(response["Content-Type"], "application/json")
# No acceptable type list, */* has an explicit quality of 0 which
# does not allow the server to use an alternate content-type
request = self.factory.request(HTTP_ACCEPT="text/html,application/xhtml+xml," "application/xml;q=0.9,*/*;q=0")
response = resource(request)
self.assertEqual(response.status_code, codes.not_acceptable)
self.assertEqual(response["Content-Type"], "application/json")
# Like the first one, but an explicit "anything goes"
request = self.factory.request(HTTP_ACCEPT="*/*")
response = resource(request)
self.assertEqual(response.status_code, codes.ok)
self.assertEqual(response["Content-Type"], "application/json")
def test_request_entity_too_large(self):
"Test request entity too large."
class TinyResource(Resource):
max_request_entity_length = 20
def post(self, request, *args, **kwargs):
pass
resource = TinyResource()
# No problem..
request = self.factory.post("/", data='{"message": "hello"}', content_type="application/json")
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Content-Type"], "application/json")
# Too large
request = self.factory.post("/", data='{"message": "hello world"}', content_type="application/json")
response = resource(request)
self.assertEqual(response.status_code, codes.request_entity_too_large)
self.assertEqual(response["Content-Type"], "application/json")
def test_too_many_requests(self):
"""Test a global rate limiting implementation.
This test will take 3 seconds to run to mimic request handling over
time.
"""
import time
from datetime import datetime
class RateLimitResource(Resource):
# Maximum of 10 requests within a 2 second window
rate_limit_count = 10
rate_limit_seconds = 2
# Keep track of requests globally for the resource.. only for test
# purposes, not thread-safe
request_frame_start = datetime.now()
request_count = 0
# Implement rate-limiting logic
def is_too_many_requests(self, request, *args, **kwargs):
# Since the start of the frame, calculate the amount of time
# that has passed
interval = (datetime.now() - self.request_frame_start).seconds
# Increment the request count
self.request_count += 1
# Reset frame if the interval is greater than the rate limit
# seconds, i.e on the 3rd second in this test
if interval > self.rate_limit_seconds:
self.request_frame_start = datetime.now()
self.request_count = 1
# ..otherwise throttle if the count is greater than the limit
elif self.request_count > self.rate_limit_count:
return True
return False
resource = RateLimitResource()
request = self.factory.request(REQUEST_METHOD="OPTIONS")
# First ten requests are ok
for _ in range(0, 10):
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Content-Type"], "application/json")
# Mimic a slight delay
time.sleep(1)
# Another 10 all get throttled..
for _ in range(0, 10):
response = resource(request)
self.assertEqual(response.status_code, codes.too_many_requests)
self.assertEqual(response["Content-Type"], "application/json")
# Another two seconds exceeds the frame, should be good to go
time.sleep(2)
for _ in range(0, 10):
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Content-Type"], "application/json")
def test_precondition_required(self):
""""Reject non-idempotent requests without the use of a conditional
header."""
class PreconditionResource(Resource):
# Either etags or last-modified must be used otherwise it
# is not enforced
use_etags = True
require_conditional_request = True
def patch(self, request):
pass
def put(self, request):
pass
def delete(self, request):
pass
def get_etag(self, request, *args, **kwargs):
return "abc123"
resource = PreconditionResource()
# Non-idempotent requests fail without a conditional header, these
# responses should not be cached
request = self.factory.put("/", data='{"message": "hello world"}', content_type="application/json")
response = resource(request)
self.assertEqual(response.status_code, codes.precondition_required)
self.assertEqual(response["Content-Type"], "application/json")
self.assertTrue("no-cache" in response["Cache-Control"])
self.assertTrue("must-revalidate" in response["Cache-Control"])
self.assertTrue("max-age=0" in response["Cache-Control"])
# Add the correct header for testing the Etag
request = self.factory.put(
"/", data='{"message": "hello world"}', content_type="application/json", HTTP_IF_MATCH="abc123"
)
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Content-Type"], "application/json")
# Idempotent requests, such as DELETE, succeed..
request = self.factory.delete("/")
response = resource(request)
self.assertEqual(response.status_code, codes.no_content)
self.assertEqual(response["Content-Type"], "application/json")
def test_precondition_failed_etag(self):
"Test precondition using etags."
class PreconditionResource(Resource):
use_etags = True
def put(self, request):
pass
def get(self, request):
return {}
def get_etag(self, request, *args, **kwargs):
return "abc123"
resource = PreconditionResource()
# Send a non-safe request with an incorrect Etag.. fail
request = self.factory.put(
"/", data='{"message": "hello world"}', content_type="application/json", HTTP_IF_MATCH='"def456"'
)
response = resource(request)
self.assertEqual(response.status_code, codes.precondition_failed)
self.assertEqual(response["Content-Type"], "application/json")
self.assertTrue("no-cache" in response["Cache-Control"])
self.assertTrue("must-revalidate" in response["Cache-Control"])
self.assertTrue("max-age=0" in response["Cache-Control"])
# Incorrect Etag match on GET, updated content is returned
request = self.factory.get("/", HTTP_IF_NONE_MATCH='"def456"')
response = resource(request)
self.assertEqual(response.status_code, codes.ok)
self.assertEqual(response["Content-Type"], "application/json")
# Successful Etag match on GET, resource not modified
request = self.factory.get("/", HTTP_IF_NONE_MATCH='"abc123"')
response = resource(request)
self.assertEqual(response.status_code, codes.not_modified)
self.assertEqual(response["Content-Type"], "application/json")
def test_precondition_failed_last_modified(self):
"Test precondition using last-modified dates."
from datetime import datetime, timedelta
from django.utils.http import http_date
last_modified_date = datetime.now()
class PreconditionResource(Resource):
use_etags = False
use_last_modified = True
def put(self, request):
pass
def get(self, request):
return {}
def get_last_modified(self, request, *args, **kwargs):
return last_modified_date
resource = PreconditionResource()
# Send non-safe request with a old last-modified date.. fail
if_modified_since = http_date(timegm((last_modified_date - timedelta(seconds=10)).utctimetuple()))
request = self.factory.put(
"/",
data='{"message": "hello world"}',
content_type="application/json",
HTTP_IF_UNMODIFIED_SINCE=if_modified_since,
)
response = resource(request)
self.assertEqual(response.status_code, codes.precondition_failed)
self.assertEqual(response["Content-Type"], "application/json")
self.assertTrue("no-cache" in response["Cache-Control"])
self.assertTrue("must-revalidate" in response["Cache-Control"])
self.assertTrue("max-age=0" in response["Cache-Control"])
# Old last-modified on GET, updated content is returned
if_modified_since = http_date(timegm((last_modified_date - timedelta(seconds=10)).utctimetuple()))
request = self.factory.get("/", HTTP_IF_MODIFIED_SINCE=if_modified_since)
response = resource(request)
self.assertEqual(response.status_code, codes.ok)
self.assertEqual(response["Content-Type"], "application/json")
# Mimic future request on GET, resource not modified
if_modified_since = http_date(timegm((last_modified_date + timedelta(seconds=20)).utctimetuple()))
request = self.factory.get("/", HTTP_IF_MODIFIED_SINCE=if_modified_since)
response = resource(request)
self.assertEqual(response.status_code, codes.not_modified)
self.assertEqual(response["Content-Type"], "application/json")
def test_cache_control_default(self):
class CacheableResource(Resource):
def get(self, request):
return {}
resource = CacheableResource()
request = self.factory.get("/")
response = resource(request)
self.assertFalse("Cache-Control" in response)
self.assertEqual(response["Content-Type"], "application/json")
def test_cache_control_seconds(self):
class CacheableResource(Resource):
cache_max_age = 60 * 60 # 1 hour
def get(self, request):
return {}
resource = CacheableResource()
request = self.factory.get("/")
response = resource(request)
self.assertEqual(response["Cache-Control"], "max-age=3600")
self.assertEqual(response["Content-Type"], "application/json")
def test_cache_control_date(self):
from datetime import datetime, timedelta
from django.utils.http import http_date
class CacheableResource(Resource):
cache_type = "private"
cache_max_age = timedelta(seconds=60 * 60) # 1 hour
def get(self, request):
return {}
resource = CacheableResource()
request = self.factory.get("/")
response = resource(request)
self.assertEqual(response["Cache-Control"], "private")
self.assertEqual(response["Expires"], http_date(timegm((datetime.now() + timedelta(hours=1)).utctimetuple())))
self.assertEqual(response["Content-Type"], "application/json")
class DRYRestPermissionsTests(TestCase):
def setUp(self):
self.action_set = ['retrieve', 'list', 'create', 'destroy', 'update', 'partial_update', 'custom_action1', 'custom_action2']
self.factory = RequestFactory()
self.request_retrieve = Request(self.factory.get('/dummy/1'))
self.request_list = Request(self.factory.get('/dummy'))
self.request_create = Request(self.factory.post('/dummy'), {})
self.request_destroy = Request(self.factory.delete('/dummy/1'))
self.request_update = Request(self.factory.put('/dummy/1', {}))
self.request_partial_update = Request(self.factory.patch('/dummy/1', {}))
self.request_custom_action1 = Request(self.factory.get('/dummy/custom_action1'))
self.request_custom_action2 = Request(self.factory.post('/dummy/custom_action2', {}))
def _run_permission_checks(self, view, obj, assert_value):
for action in self.action_set:
view.action = action
request_name = "request_{action}".format(action=action)
result = view.dummy_check_permission(getattr(self, request_name), obj)
self.assertEqual(result, assert_value)
def _run_dry_permission_field_checks(self, view, obj, assert_specific, assert_base):
serializer = view.get_serializer_class()()
# dummy request
serializer.context['request'] = self.request_retrieve
representation = serializer.to_representation(obj)
for action in [action for action in self.action_set if action not in ['partial_update', 'list']]:
has_permission = representation['permissions'].get(action, None)
self.assertEqual(has_permission, assert_specific, "Action '%s' %s != %s" % (action, has_permission, assert_specific))
for action in ['read', 'write']:
has_permission = representation['permissions'].get(action, None)
self.assertEqual(has_permission, assert_base, "Action '%s' %s != %s" % (action, has_permission, assert_base))
def test_true_base_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), None, True)
def test_false_base_object_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin):
base_object_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), None, False)
def test_false_base_global_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin):
base_global_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), None, False)
def test_true_specific_permissions(self):
class TestModel(
DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
base_global_allowed = False
base_object_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, False)
def test_true_base_not_defined_permissions(self):
class TestModel(DummyModel, SpecificObjectMixin, SpecificGlobalMixin):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, None)
def test_false_specific_object_permissions(self):
class TestModel(
DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
specific_object_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), False, True)
def test_false_specific_global_permissions(self):
class TestModel(
DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
specific_global_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), False, True)
def test_true_no_global_permissions(self):
class TestModel(
DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
base_global_allowed = False
specific_global_allowed = False
class TestSerializer(DummySerializer):
permissions = DRYPermissionsField(object_only=True, additional_actions=['custom_action1', 'custom_action2'])
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
permission_classes = (DRYObjectPermissions, )
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, True)
def test_true_no_object_permissions(self):
class TestModel(
DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
base_object_allowed = False
specific_object_allowed = False
class TestSerializer(DummySerializer):
permissions = DRYPermissionsField(global_only=True, additional_actions=['custom_action1', 'custom_action2'])
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
permission_classes = (DRYGlobalPermissions, )
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, True)
def test_list_filter_backend(self):
class DummyFilter(object):
pass
class TestModel(DummyModel):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestFilterBackend(DRYPermissionFiltersBase):
def filter_list_queryset(self, request, queryset, view):
return DummyFilter()
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
queryset = TestModel.objects.all()
filter_backends = (TestFilterBackend,)
view = TestViewSet()
view.request = self.request_list
view.action = 'list'
view.kwargs = []
query_set = view.filter_queryset(view.get_queryset())
self.assertEqual(query_set.__class__, DummyFilter)
def test_action_filter_backend(self):
class DummyFilter(object):
pass
class TestModel(DummyModel):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestFilterBackend(DRYPermissionFiltersBase):
action_routing = True
def filter_list_queryset(self, request, queryset, view):
return None
def filter_custom_action1_queryset(self, request, queryset, view):
return DummyFilter()
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
queryset = TestModel.objects.all()
filter_backends = (TestFilterBackend,)
view = TestViewSet()
view.request = self.request_custom_action1
view.action = 'custom_action1'
view.kwargs = []
query_set = view.filter_queryset(view.get_queryset())
self.assertEqual(query_set.__class__, DummyFilter)
class TestAuthView(TestCase):
endpoint = reverse('twitter_oauth_ios:auth_view')
user_model = get_user_model()
def setUp(self):
self.auth_view = AuthView.as_view()
self.factory = RequestFactory()
self.parameter = {
"user_id": 1111111111,
"oauth_token": "1111111111-this_is_test_oauth_token",
"oauth_token_secret": "this_is_test_oauth_token_secret",
"screen_name": "test_screen_name",
}
def tearDown(self):
self.factory = None
self.parameter = None
call_command('flush', interactive=False)
def test_not_allow_method(self):
request = self.factory.post(self.endpoint, self.parameter)
request.content_type = 'application/json'
response = self.auth_view(request)
self.assertEqual(response.status_code, 405)
def test_failure_put(self):
request = self.factory.put(self.endpoint, {})
request.content_type = 'application/json'
response = self.auth_view(request)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'result': 'error'})
self.assertEqual(response.status_code, 400)
def test_success_create_put(self):
user = self.user_model.objects.create_user(
username=self.parameter['screen_name'],
first_name='This is display_name',
is_active=True)
user.save()
extra_data = {
'auth_time': int(datetime.now().strftime('%s')),
'id': self.parameter['user_id'],
'access_token': {
'oauth_token': self.parameter['oauth_token'],
'oauth_token_secret': self.parameter['oauth_token_secret'],
'user_id': self.parameter['user_id'],
'screen_name': self.parameter['screen_name']
}
}
user_social_auth = UserSocialAuth(user=user,
provider='twitter',
uid=self.parameter['user_id'],
extra_data=extra_data)
user_social_auth.save()
with patch('requests.get') as patcher:
mock_json = Mock()
mock_json.json.return_value = {'name': 'This is display_name'}
patcher.return_value = mock_json
request = self.factory.put(self.endpoint,
json.dumps(self.parameter))
request.content_type = 'application/json'
response = self.auth_view(request)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'result': 'success'})
self.assertEqual(response.status_code, 200)
def test_success_update_put(self):
user = self.user_model.objects.create_user(
username=self.parameter['screen_name'],
first_name='This is display_name',
is_active=True)
user.save()
extra_data = {
'auth_time': int(datetime.now().strftime('%s')),
'id': self.parameter['user_id'],
'access_token': {
'oauth_token': self.parameter['oauth_token'],
'oauth_token_secret': self.parameter['oauth_token_secret'],
'user_id': self.parameter['user_id'],
'screen_name': self.parameter['screen_name']
}
}
user_social_auth = UserSocialAuth(user=user,
provider='twitter',
uid=self.parameter['user_id'],
extra_data=extra_data)
user_social_auth.save()
with patch('requests.get') as patcher:
mock_json = Mock()
mock_json.json.return_value = {'name': 'This is display_name'}
patcher.return_value = mock_json
request = self.factory.put(self.endpoint,
json.dumps(self.parameter))
request.content_type = 'application/json'
response = self.auth_view(request)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'result': 'success'})
self.assertEqual(response.status_code, 200)
class ViewTest(unittest.TestCase):
"""
Tests for BackboneAPIView.
Note that django.contrib.auth must be in INSTALLED_APPS for these to work.
"""
def setUp(self):
self.factory = RequestFactory()
self.view = ReadOnlyView.as_view()
self.writable_view = FullView.as_view()
self.user1 = User.objects.create(username='******',
first_name='Test',
last_name='One')
def tearDown(self):
User.objects.all().delete()
def add_two_more_users(self):
self.user2 = User.objects.create(username='******',
first_name='Test',
last_name='Two')
self.user3 = User.objects.create(username='******',
first_name='Test',
last_name='Three')
def test_collection_get(self):
request = self.factory.get('/users/')
response = self.view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
# Ensure response json deserializes to a 1-item list:
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 1)
self.assertEqual(response_data[0]['username'], self.user1.username)
# Try again with a few more users in the database:
self.add_two_more_users()
response = self.view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 3)
# With User model's default ordering (by id), user3 should be last:
self.assertEqual(response_data[2]['username'], self.user3.username)
# Test pagination:
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 2)
# Page 2 should only have one item:
request = self.factory.get('/users/?p=2')
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 1)
def test_single_item_get(self):
request = self.factory.get('/users/1')
response = self.view(
request, id='1') # Simulate a urlconf passing in the 'id' kwarg
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, dict))
self.assertEqual(response_data['username'], self.user1.username)
# Ensure 404s are raised for non-existent items:
request = self.factory.get('/users/7')
self.assertRaises(Http404, lambda: self.view(request, id='7'))
def test_post(self):
request = self.factory.post('/users')
response = self.view(request)
self.assertEqual(
response.status_code,
405) # "Method not supported" if no add_form_class specified
# Testing BackboneAPIView subclasses that support POST via add_form_class:
# If no JSON provided in POST body, return HTTP 400:
response = self.writable_view(request)
self.assertEqual(response.status_code, 400)
# Test the case where invalid input is given (leading to form errors):
request = self.factory.post('/users',
'{"wrong_field": "xyz"}',
content_type='application/json')
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'ERROR: validation failed')
# If valid JSON was provided, a new instance should be created:
request = self.factory.post('/users',
'{"username": "******"}',
content_type='application/json')
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
self.assert_(User.objects.get(username='******'))
response_json = json.loads(response.content)
self.assertEqual(response_json['username'], 'post_test')
def test_put(self):
request = self.factory.put('/users/1')
response = self.view(request, id='1')
self.assertEqual(
response.status_code,
405) # "Method not supported" if no edit_form_class specified
# PUT is also not supported for collections (when no id is provided):
request = self.factory.put('/users')
response = self.writable_view(request)
self.assertEqual(response.status_code, 405)
# If no JSON in PUT body, return HTTP 400:
response = self.writable_view(request, id='1')
self.assertEqual(response.status_code, 400)
# Raise 404 if an object with the given id doesn't exist:
request = self.factory.put('/users/27',
'{"username": "******"}',
content_type='application/json')
self.assertRaises(Http404,
lambda: self.writable_view(request, id='27'))
# If the object exists and an edit_form_class is supplied, it actually does something:
request = self.factory.put('/users/1',
'{"username": "******"}',
content_type='application/json')
response = self.writable_view(request, id='1')
self.assertEqual(response.status_code, 200)
self.assertEqual(User.objects.get(id=1).username, 'put_test')
response_json = json.loads(response.content)
self.assertEqual(response_json['username'], 'put_test')
# Test the case where invalid input is given (leading to form errors):
request = self.factory.put('/users/1',
'{"wrong_field": "xyz"}',
content_type='application/json')
response = self.writable_view(request, id='1')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'ERROR: validation failed')
def test_delete(self):
# Delete is not supported for collections:
request = self.factory.delete('/users')
response = self.view(request)
self.assertEqual(response.status_code, 405)
self.assertEqual(User.objects.filter(id=1).count(), 1)
# But it is supported for single items (specified by id):
request = self.factory.delete('/users/1')
response = self.view(request, id='1')
self.assertEqual(response.status_code, 200)
self.assertEqual(User.objects.filter(id=1).count(), 0)
# Should raise 404 if we try to access a deleted resource again:
request = self.factory.delete('/users/1')
self.assertRaises(Http404, lambda: self.view(request, id='1'))
class ResourceEntryTestCase(TestCase):
tags = ('offering-api', )
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create_user(username='******',
email='',
password='******')
self.user.userprofile.get_current_roles = MagicMock(
name='get_current_roles')
self.user.userprofile.get_current_roles.return_value = [
'provider', 'customer'
]
self.user.userprofile.save()
# Create resource model mock
self.resource = MagicMock()
self.resource.provider = self.user.userprofile.current_organization
views.OfferingResource = MagicMock()
views.OfferingResource.objects.get.return_value = self.resource
@classmethod
def tearDownClass(cls):
from wstore.offerings import offerings_management
reload(offerings_management)
reload(views)
super(ResourceEntryTestCase, cls).tearDownClass()
def tearDown(self):
views.json = json
def _not_found(self):
views.OfferingResource.objects.get.side_effect = Exception('Not found')
def _no_provider(self):
self.user.userprofile.get_current_roles.return_value = ['customer']
def _exception_update(self):
views.update_resource.side_effect = Exception('Exception in call')
def _exception_upgrade(self):
views.upgrade_resource.side_effect = Exception('Exception in call')
def _exception_delete(self):
views.delete_resource.side_effect = Exception('Exception in call')
def _invalid_json(self):
views.json = MagicMock()
views.json.loads.side_effect = Exception('Invalid content')
@parameterized.expand([
(RESOURCE_DATA, 200, 'OK'),
(RESOURCE_DATA, 400, 'Invalid content', _invalid_json, 'error'),
(RESOURCE_DATA, 403, 'Forbidden', _no_provider, 'error'),
(RESOURCE_DATA, 400, 'Exception in call', _exception_update, 'error')
])
def test_resource_update_api(self,
data,
code,
msg,
side_effect=None,
status='correct'):
views.update_resource = MagicMock(name='update_resource')
if side_effect:
side_effect(self)
request = self.factory.put(
'/api/offering/resources/test_user/test_resource/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json')
request.user = self.user
res_entry = views.ResourceEntry(permitted_methods=('PUT', 'POST',
'DELETE'))
response = res_entry.update(request, 'test_user', 'test_resource',
'1.0')
self.assertEqual(response.status_code, code)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEquals(type(body_response), dict)
self.assertEquals(body_response['message'], msg)
self.assertEquals(body_response['result'], status)
# Check call to update method if needed
if status != 'error':
views.update_resource.assert_called_once_with(
self.resource, self.user, data)
@parameterized.expand([
(RESOURCE_DATA, 200, 'OK'), (RESOURCE_DATA, 200, 'OK', True),
(RESOURCE_DATA, 400, 'Invalid content', False, _invalid_json, True),
(RESOURCE_DATA, 400, 'Invalid content', True, _invalid_json, True),
(RESOURCE_DATA, 404, 'Resource not found', False, _not_found, True),
(RESOURCE_DATA, 403, 'Forbidden', False, _no_provider, True),
(RESOURCE_DATA, 400, 'Exception in call', False, _exception_upgrade,
True)
])
def test_resource_upgrade_api(self,
data,
code,
msg,
file_=False,
side_effect=None,
error=False):
# Mock update method
views.upgrade_resource = MagicMock(name='upgrade_resource')
if side_effect:
side_effect(self)
content = json.dumps(data)
content_type = 'application/json'
if file_:
f = StringIO()
f.name = 'test_file.txt'
f.write('test file')
content = {'json': json.dumps(data), 'file': f}
content_type = MULTIPART_CONTENT
request = self.factory.post(
'/api/offering/resources/test_user/test_resource/1.0',
content,
content_type=content_type,
HTTP_ACCEPT='application/json')
request.user = self.user
res_entry = views.ResourceEntry(permitted_methods=('PUT', 'POST',
'DELETE'))
response = res_entry.create(request, 'test_user', 'test_resource',
'1.0')
self.assertEqual(response.status_code, code)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], msg)
if not error:
if not file_:
views.upgrade_resource.assert_called_once_with(
self.resource, self.user, data)
else:
expected_file = request.FILES[
'file'] # The type change when loaded
views.upgrade_resource.assert_called_once_with(
self.resource, self.user, data, expected_file)
self.assertEqual(body_response['result'], 'correct')
else:
self.assertEqual(body_response['result'], 'error')
@parameterized.expand([(204, 'No Content'),
(404, 'Resource not found', _not_found, True),
(403, 'Forbidden', _no_provider, True),
(400, 'Exception in call', _exception_delete, True)]
)
def test_resource_deletion_api(self,
code,
msg,
side_effect=None,
error=False):
# Mock delete resource method
views.delete_resource = MagicMock(name='delete_resource')
if side_effect:
side_effect(self)
request = self.factory.delete(
'/api/offering/resources/test_user/test_resource/1.0',
HTTP_ACCEPT='application/json')
request.user = self.user
res_entry = views.ResourceEntry(permitted_methods=('POST', 'DELETE'))
response = res_entry.delete(request, 'test_user', 'test_resource',
'1.0')
self.assertEqual(response.status_code, code)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], msg)
if not error:
views.delete_resource.assert_called_once_with(
self.resource, self.user)
self.assertEqual(body_response['result'], 'correct')
else:
self.assertEqual(body_response['result'], 'error')
class OfferingEntryTestCase(TestCase):
tags = ('offering-api', )
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create_user(username='******',
email='',
password='******')
@classmethod
def tearDownClass(cls):
from wstore.offerings import offerings_management
reload(offerings_management)
reload(views)
super(OfferingEntryTestCase, cls).tearDownClass()
def test_get_offering(self):
return_value = {
'name': 'test_offering',
'owner_organization': 'test_user',
'owner_admin_user_id': 'test_user',
'version': '1.0',
'state': 'published',
'description_url': 'http://repository.com/collection/usdl',
'rating': 0,
'comments': [],
'tags': [],
'image_url': 'media/image.png',
'related_images': [],
'creation_date': '2013-05-01 10:00:00',
'publication_date': '2013-06-03 10:00:00',
'resources': []
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.get_offering_info = MagicMock(name='get_offering_info')
views.get_offering_info.return_value = return_value
request = self.factory.get(
'/api/offering/offerings/test_user/test_offering/1.0')
request.user = self.user
# Call the view
offering = Offering.objects.create(
name='test_offering',
owner_organization=Organization.objects.get(name='test_user'),
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00')
response = offering_entry.read(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
views.get_offering_info.assert_called_once_with(offering, self.user)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-type'),
'application/json; charset=UTF-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['name'], 'test_offering')
self.assertEqual(body_response['owner_organization'], 'test_user')
self.assertEqual(body_response['owner_admin_user_id'], 'test_user')
def test_get_offering_not_found(self):
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.get_offering_info = MagicMock(name='get_offering_info')
request = self.factory.get(
'/api/offering/offerings/test_user/test_offering/1.0',
HTTP_ACCEPT='application/json')
request.user = self.user
response = offering_entry.read(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
self.assertFalse(views.get_offering_info.called)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Offering not found')
self.assertEqual(body_response['result'], 'error')
def test_get_offering_exception(self):
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.get_offering_info = MagicMock(name='get_offering_info')
views.get_offering_info.side_effect = Exception(
'Error getting offering')
request = self.factory.get(
'/api/offering/offerings/test_user/test_offering/1.0',
HTTP_ACCEPT='application/json')
request.user = self.user
offering = Offering.objects.create(
name='test_offering',
owner_organization=Organization.objects.get(name='test_user'),
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00')
response = offering_entry.read(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
views.get_offering_info.assert_called_once_with(offering, self.user)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Error getting offering')
self.assertEqual(body_response['result'], 'error')
def test_offering_update(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.update_offering = MagicMock(name='update_offering')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json')
request.user = self.user
# Call the view
offering = Offering.objects.create(
name='test_offering',
owner_organization=Organization.objects.get(name='test_user'),
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00')
response = offering_entry.update(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
views.update_offering.assert_called_once_with(self.user, offering,
data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'OK')
self.assertEqual(body_response['result'], 'correct')
def test_offering_update_not_found(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.update_offering = MagicMock(name='update_offering')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json')
request.user = self.user
response = offering_entry.update(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
self.assertFalse(views.update_offering.called)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Offering not found')
self.assertEqual(body_response['result'], 'error')
def test_offering_update_not_provider(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.update_offering = MagicMock(name='update_offering')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json')
request.user = self.user
org = Organization.objects.get(name='test_user')
# Call the view
Offering.objects.create(name='test_offering',
owner_organization=org,
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00')
# Mock offering functions to obtain that the user is not owner
views.Offering.is_owner = MagicMock(name='is_owner')
views.Offering.is_owner.return_value = False
org.managers = []
org.save()
response = offering_entry.update(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
self.assertFalse(views.update_offering.called)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'],
'You are not allowed to edit the current offering')
self.assertEqual(body_response['result'], 'error')
def test_offering_update_exception(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT',
'DELETE'))
views.update_offering = MagicMock(name='update_offering')
views.update_offering.side_effect = Exception('Update error')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json')
request.user = self.user
org = Organization.objects.get(name='test_user')
# Call the view
offering = Offering.objects.create(name='test_offering',
owner_organization=org,
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00')
response = offering_entry.update(request, 'test_user', 'test_offering',
'1.0')
# Check correct call
views.update_offering.assert_called_once_with(self.user, offering,
data)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.get('Content-type'),
'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Update error')
self.assertEqual(body_response['result'], 'error')
class OfferingEntryTestCase(TestCase):
tags = ('offering-api',)
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create_user(username='******', email='', password='******')
@classmethod
def tearDownClass(cls):
from wstore.offerings import offerings_management
reload(offerings_management)
reload(views)
super(OfferingEntryTestCase, cls).tearDownClass()
def test_get_offering(self):
return_value = {
'name': 'test_offering',
'owner_organization': 'test_user',
'owner_admin_user_id': 'test_user',
'version': '1.0',
'state': 'published',
'description_url': 'http://repository.com/collection/usdl',
'rating': 0,
'comments': [],
'tags': [],
'image_url': 'media/image.png',
'related_images': [],
'creation_date': '2013-05-01 10:00:00',
'publication_date': '2013-06-03 10:00:00',
'resources': []
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.get_offering_info = MagicMock(name='get_offering_info')
views.get_offering_info.return_value = return_value
request = self.factory.get('/api/offering/offerings/test_user/test_offering/1.0')
request.user = self.user
# Call the view
offering = Offering.objects.create(
name='test_offering',
owner_organization=Organization.objects.get(name='test_user'),
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00'
)
response = offering_entry.read(request, 'test_user', 'test_offering', '1.0')
# Check correct call
views.get_offering_info.assert_called_once_with(offering, self.user)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-type'), 'application/json; charset=UTF-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['name'], 'test_offering')
self.assertEqual(body_response['owner_organization'], 'test_user')
self.assertEqual(body_response['owner_admin_user_id'], 'test_user')
def test_get_offering_not_found(self):
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.get_offering_info = MagicMock(name='get_offering_info')
request = self.factory.get('/api/offering/offerings/test_user/test_offering/1.0', HTTP_ACCEPT='application/json')
request.user = self.user
response = offering_entry.read(request, 'test_user', 'test_offering', '1.0')
# Check correct call
self.assertFalse(views.get_offering_info.called)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Offering not found')
self.assertEqual(body_response['result'], 'error')
def test_get_offering_exception(self):
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.get_offering_info = MagicMock(name='get_offering_info')
views.get_offering_info.side_effect = Exception('Error getting offering')
request = self.factory.get('/api/offering/offerings/test_user/test_offering/1.0', HTTP_ACCEPT='application/json')
request.user = self.user
offering = Offering.objects.create(
name='test_offering',
owner_organization=Organization.objects.get(name='test_user'),
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00'
)
response = offering_entry.read(request, 'test_user', 'test_offering', '1.0')
# Check correct call
views.get_offering_info.assert_called_once_with(offering, self.user)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Error getting offering')
self.assertEqual(body_response['result'], 'error')
def test_offering_update(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.update_offering = MagicMock(name='update_offering')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
request.user = self.user
# Call the view
offering = Offering.objects.create(
name='test_offering',
owner_organization=Organization.objects.get(name='test_user'),
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00'
)
response = offering_entry.update(request, 'test_user', 'test_offering', '1.0')
# Check correct call
views.update_offering.assert_called_once_with(self.user, offering, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'OK')
self.assertEqual(body_response['result'], 'correct')
def test_offering_update_not_found(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.update_offering = MagicMock(name='update_offering')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
request.user = self.user
response = offering_entry.update(request, 'test_user', 'test_offering', '1.0')
# Check correct call
self.assertFalse(views.update_offering.called)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Offering not found')
self.assertEqual(body_response['result'], 'error')
def test_offering_update_not_provider(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.update_offering = MagicMock(name='update_offering')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
request.user = self.user
org = Organization.objects.get(name='test_user')
# Call the view
Offering.objects.create(
name='test_offering',
owner_organization=org,
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00'
)
# Mock offering functions to obtain that the user is not owner
views.Offering.is_owner = MagicMock(name='is_owner')
views.Offering.is_owner.return_value = False
org.managers = []
org.save()
response = offering_entry.update(request, 'test_user', 'test_offering', '1.0')
# Check correct call
self.assertFalse(views.update_offering.called)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'You are not allowed to edit the current offering')
self.assertEqual(body_response['result'], 'error')
def test_offering_update_exception(self):
data = {
'name': 'test_offering',
'version': '1.0',
'description': 'test offering'
}
# Mock get offerings method
offering_entry = views.OfferingEntry(permitted_methods=('GET', 'PUT', 'DELETE'))
views.update_offering = MagicMock(name='update_offering')
views.update_offering.side_effect = Exception('Update error')
request = self.factory.put(
'/api/offering/offerings/test_user/test_offering/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
request.user = self.user
org = Organization.objects.get(name='test_user')
# Call the view
offering = Offering.objects.create(
name='test_offering',
owner_organization=org,
owner_admin_user=self.user,
version='1.0',
state='published',
description_url='',
resources=[],
comments=[],
tags=[],
image_url='',
related_images=[],
offering_description={},
notification_url='',
creation_date='2013-06-03 10:00:00'
)
response = offering_entry.update(request, 'test_user', 'test_offering', '1.0')
# Check correct call
views.update_offering.assert_called_once_with(self.user, offering, data)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], 'Update error')
self.assertEqual(body_response['result'], 'error')
class TestCompany(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_POST_company(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
response_content = literal_eval(response.content.decode('utf-8'))
db_query = literal_eval(
serializers.serialize("json", [Company.objects.get(pk=1)]))
self.assertEqual(response.status_code, 201)
self.assertEqual(response_content, id_1)
self.assertEqual(db_query[0]["fields"], base_company)
def test_POST_company_with_no_image_key(self):
request = self.factory.post('api/companies/',
base_company,
content_type='application/json')
response = api_companies(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_company_with_empty_image(self):
company_data = base_company_input.copy()
company_data["images"] = []
request = self.factory.post('api/companies/',
company_data,
content_type='application/json')
response = api_companies(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_company_with_no_name(self):
company_data = base_company_input.copy()
company_data.pop("name")
request = self.factory.post('api/companies/',
company_data,
content_type='application/json')
response = api_companies(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_company_with_empty_name(self):
company_data = base_company_input.copy()
company_data["name"] = " "
request = self.factory.post('api/companies/',
company_data,
content_type='application/json')
response = api_companies(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_GET_all_companies(self):
new_company = Company(**base_company).save()
new_company = Company(**base_company).save()
request = self.factory.get('api/companies/')
response = api_companies(request)
response_content = literal_eval(response.content.decode('utf-8'))
db_query = literal_eval(
serializers.serialize("json",
Company.objects.all(),
fields=("name")))
db_query[0]["fields"]["images"] = []
db_query[1]["fields"]["images"] = []
self.assertEqual(response.status_code, 200)
self.assertEqual(db_query, response_content)
def test_PUT_company(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
request = self.factory.put('api/companies/1/',
updated_company_input,
content_type='application/json')
response = api_companies_id(request, '1')
response_content = response.content.decode('utf-8')
company_object = Company.objects.get(pk=1)
db_query = literal_eval(serializers.serialize("json",
[company_object]))
self.assertEqual(response.status_code, 204)
self.assertEqual(db_query[0]["fields"], updated_company)
self.assertEqual(company_object.images()[0].link,
updated_company_input["images"][0])
def test_PUT_company_with_bad_id(self):
request = self.factory.put('api/companies/1/',
updated_company_input,
content_type='application/json')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_PUT_company_with_no_image_key(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
request = self.factory.put('api/companies/1/',
updated_company,
content_type='application/json')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 204)
self.assertEqual(response.content, b'')
def test_PUT_company_with_empty_image(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
company_data = base_company_input.copy()
company_data["images"] = []
request = self.factory.put('api/companies/1/',
company_data,
content_type='application/json')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_company_with_empty_name(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
company_data = base_company_input.copy()
company_data["name"] = " "
request = self.factory.put('api/companies/1/',
company_data,
content_type='application/json')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_GET_company(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
request = self.factory.get('api/companies/1/')
response = api_companies_id(request, '1')
company_object = Company.objects.get(pk=1)
db_query = literal_eval(serializers.serialize("json",
[company_object]))
response_content = literal_eval(response.content.decode('utf-8'))
image_link = response_content[0]["fields"].pop("images")
self.assertEqual(response.status_code, 200)
self.assertEqual(db_query, response_content)
self.assertEqual(company_object.images()[0].link, image_link[0])
def test_GET_with_bad_id(self):
request = self.factory.get('api/companies/1/')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_DELETE_company(self):
request = self.factory.post('api/companies/',
base_company_input,
content_type='application/json')
response = api_companies(request)
request = self.factory.delete('api/companies/1/')
response = api_companies_id(request, '1')
self.assertEqual(
len(Images.objects.filter(other_id=1, other_type='CP')), 0)
self.assertEqual(len(Company.objects.filter(pk=1)), 0)
self.assertEqual(response.status_code, 204)
def test_DELETE_with_bad_id(self):
request = self.factory.delete('api/companies/1/')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_GET_intersection_company_games(self):
new_company = Company(**base_company).save()
new_person = Person(**base_person)
new_person.save()
new_person.companies.add(1)
System(**base_system).save()
Genre(**base_genre).save()
new_game = Game(**base_game)
new_game.save()
new_game.genre.add(1)
new_game.people.add(1)
request = self.factory.get('api/companies/1/games/')
response = api_companies_games(request, 1)
response_content = response.content.decode('utf-8')
db_query = serializers.serialize("json",
Game.objects.filter(company=1),
fields=("name"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response_content, db_query)
def test_GET_intersection_company_games_with_bad_id(self):
request = self.factory.get('api/companies/1/games/')
response = api_companies_games(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_GET_intersection_company_people(self):
new_company = Company(**base_company).save()
new_person = Person(**base_person)
new_person.save()
new_person.companies.add(1)
request = self.factory.get('api/companies/1/people/')
response = api_companies_people(request, 1)
response_content = response.content.decode('utf-8')
db_query = serializers.serialize("json",
Person.objects.filter(companies=1),
fields=("name"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response_content, db_query)
def test_GET_intersection_company_people_with_bad_id(self):
request = self.factory.get('api/companies/1/people/')
response = api_companies_people(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
class TestGames(TestCase):
def setUp(self):
self.factory = RequestFactory()
def test_POST_game(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
response_content = literal_eval(response.content.decode('utf-8'))
db_query = literal_eval(
serializers.serialize("json", [Game.objects.get(pk=1)]))
self.assertEqual(response.status_code, 201)
self.assertEqual(response_content, id_1)
self.assertEqual(db_query[0]["fields"], base_game_output)
def test_POST_game_with_no_image_key(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("images")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_image(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["images"] = []
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_no_name(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("name")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_name(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["name"] = " "
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_no_video(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("videos")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_video(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["videos"] = []
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_no_company(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("company")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_company(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["company"] = None
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_invalid_company(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["company"] = 2
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_POST_game_with_no_people(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("people")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_people(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["people"] = []
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_invalid_people(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["people"] = [2]
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_POST_game_with_no_genre(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("genre")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_genre(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["genre"] = []
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_invalid_genre(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["genre"] = [2]
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_POST_game_with_no_system(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data.pop("system")
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_empty_system(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["system"] = None
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_POST_game_with_invalid_system(self):
setup_db_for_game()
game_data = base_game_input.copy()
game_data["system"] = 3
request = self.factory.post('api/games/',
game_data,
content_type='application/json')
response = api_games(request)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_GET_all_games(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
request = self.factory.get('api/games/')
response = api_games(request)
response_content = literal_eval(response.content.decode('utf-8'))
db_query = literal_eval(
serializers.serialize("json", Game.objects.all(), fields=("name")))
db_query[0]["fields"]["images"] = ["http://image.com"]
db_query[1]["fields"]["images"] = ["http://image.com"]
self.assertEqual(response.status_code, 200)
self.assertEqual(db_query, response_content)
def test_PUT_game(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
request = self.factory.put('api/games/1/',
updated_game_input,
content_type='application/json')
response = api_games_id(request, 1)
response_content = response.content.decode('utf-8')
game_object = Game.objects.get(pk=1)
db_query = literal_eval(serializers.serialize("json", [game_object]))
self.assertEqual(response.status_code, 204)
self.assertEqual(db_query[0]["fields"], updated_game)
self.assertEqual(game_object.images()[0].link,
updated_game_input["images"][0])
self.assertEqual(game_object.videos()[0].link,
updated_game_input["videos"][0])
def test_PUT_game_with_empty_image(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["images"] = []
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_empty_name(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["name"] = []
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_empty_video(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["videos"] = []
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_empty_company(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["company"] = None
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_invalid_company(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["company"] = 2
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_PUT_game_with_empty_people(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["people"] = []
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_invalid_people(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["people"] = [2]
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_PUT_game_with_empty_genre(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["genre"] = []
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_invalid_genre(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["people"] = [2]
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_PUT_game_with_empty_system(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["system"] = None
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, b'')
def test_PUT_game_with_invalid_system(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
game_data = base_game_input.copy()
game_data["system"] = "mitch"
request = self.factory.put('api/games/1/',
game_data,
content_type='application/json')
response = api_games_id(request, 1)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_GET_game(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
request = self.factory.get('api/games/1/')
response = api_games_id(request, '1')
game_object = Game.objects.get(pk=1)
db_query = literal_eval(serializers.serialize("json", [game_object]))
response_content = literal_eval(response.content.decode('utf-8'))
image_list = response_content[0]["fields"].pop("images")
video_list = response_content[0]["fields"].pop("videos")
response_content[0]["fields"]["genre"] = [1]
response_content[0]["fields"]["system"] = 1
self.assertEqual(response.status_code, 200)
self.assertEqual(db_query, response_content)
self.assertEqual(game_object.images()[0].link, image_list[0])
self.assertEqual(game_object.videos()[0].link, video_list[0])
def test_GET_game_with_bad_id(self):
request = self.factory.get('api/games/1/')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_DELETE_games(self):
setup_db_for_game()
request = self.factory.post('api/games/',
base_game_input,
content_type='application/json')
response = api_games(request)
request = self.factory.delete('api/games/1/')
response = api_games_id(request, '1')
self.assertEqual(
len(Images.objects.filter(other_id=1, other_type='GM')), 0)
self.assertEqual(
len(Images.objects.filter(other_id=1, other_type='GM')), 0)
self.assertEqual(len(Game.objects.filter(pk=1)), 0)
self.assertEqual(response.status_code, 204)
def test_DELETE_game_with_bad_id(self):
request = self.factory.delete('api/games/1/')
response = api_companies_id(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_GET_intersection_games_people(self):
setup_db_for_game()
new_game = Game(**base_game)
new_game.save()
new_game.genre.add(1)
new_game.people.add(1)
request = self.factory.get('api/games/1/people/')
response = api_games_people(request, 1)
response_content = response.content.decode('utf-8')
db_query = serializers.serialize("json",
Game.objects.get(pk=1).people.all(),
fields=("name"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response_content, db_query)
def test_GET_intersection_games_people_with_bad_id(self):
request = self.factory.get('api/games/1/people/')
response = api_games_people(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
def test_GET_intersection_games_companies(self):
setup_db_for_game()
new_game = Game(**base_game)
new_game.save()
new_game.genre.add(1)
new_game.people.add(1)
request = self.factory.get('api/games/1/companies/')
response = api_games_companies(request, 1)
response_content = response.content.decode('utf-8')
db_query = serializers.serialize("json",
[Game.objects.get(pk=1).company],
fields=("name"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response_content, db_query)
def test_GET_intersection_games_companies_with_bad_id(self):
request = self.factory.get('api/games/1/companies/')
response = api_games_people(request, '1')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content, b'')
class YourTestClass(TestCase):
employee_id = 22
employee_id_test = 44
body = {
"22": {
"employee_id": 22,
"first_name": "Foo1",
"last_name": "Bar2",
"department": "Central2 Tech"
}
}
body_neg = {
"-22": {
"employee_id": -22,
"first_name": "Foo1",
"last_name": "Bar2",
"department": "Central2 Tech"
}
}
post_error = {
'status code': 404,
'body': 'INVALID POST/WRONG DATA',
}
list_error = {
'status code': 404,
'body': 'Employee id: ' + str(employee_id_test) + ' not found',
}
body_reorder = {
"22": {
"first_name": "Foo1",
"employee_id": 22,
"last_name": "Bar2",
"department": "Central2 Tech"
}
}
body_empty = {}
post_duplicate_resp = {"status code": 404, "body": "DUPLICATE DATA"}
@classmethod
def setUp(self):
# Every test needs access to the request factory.
self.factory = RequestFactory()
def test_put(self):
request = self.factory.put('/emapi/addemployee/',
self.body,
content_type='application/json')
putresponse = post(request)
resultresponse = json.loads(putresponse.content.decode('ascii'))
self.assertDictEqual(resultresponse, self.body)
def test_duplicate_put(self):
request = self.factory.put('/emapi/addemployee/',
self.body,
content_type='application/json')
putresponse = post(request)
request = self.factory.put('/emapi/addemployee/',
self.body,
content_type='application/json')
putresponse = post(request)
resultresponse = json.loads(putresponse.content.decode('ascii'))
self.assertDictEqual(resultresponse, self.post_duplicate_resp)
def test_neg_put(self):
request = self.factory.put('/emapi/addemployee/',
self.body_neg,
content_type='application/json')
putresponse = post(request)
resultresponse = json.loads(putresponse.content.decode('ascii'))
self.assertDictEqual(resultresponse, self.post_error)
def test_empty_put(self):
request = self.factory.put('/emapi/addemployee/',
self.body_empty,
content_type='application/json')
putresponse = post(request)
resultresponse = json.loads(putresponse.content.decode('ascii'))
self.assertDictEqual(resultresponse, self.post_error)
def test_index(self):
putrequest = self.factory.put('/emapi/addemployee/',
self.body_reorder,
content_type='application/json')
putresponse = post(putrequest)
request = self.factory.get('/emapi/employees')
response = index(request)
self.assertEqual(response.status_code, 200)
resultresponse = json.loads(response.content.decode('ascii'))
putresultresponse = json.loads(response.content.decode('ascii'))
self.assertDictEqual(resultresponse, putresultresponse)
def test_list(self):
putrequest = self.factory.put('/emapi/addemployee/',
self.body,
content_type='application/json')
putresponse = post(putrequest)
request = self.factory.get('employee/<int:employee_id>/')
response = list(request, self.employee_id)
self.assertEqual(response.status_code, 200)
resultresponse = json.loads(response.content.decode('ascii'))
self.assertDictEqual(resultresponse, self.body)
def test_list_error(self):
putrequest = self.factory.put('/emapi/addemployee/',
self.body,
content_type='application/json')
putresponse = post(putrequest)
request = self.factory.get('employee/<int:employee_id>/')
response = list(request, self.employee_id_test)
self.assertEqual(response.status_code, 404)
resultresponse = json.loads(response.content.decode('ascii'))
self.assertDictEqual(resultresponse, self.list_error)
def test_invalid_http_put(self):
rf = RequestFactory()
request = rf.put('/api/interview')
response = handle_interview_request(request)
self.assertEqual(response.status_code, 405)
class ToolApiTestCase(TestCase):
def setUp(self):
# Set up a Request Factory
self.factory = RequestFactory()
# Set up a User
self.john = User(
username='******',
hashed_password='******',
salt='NaCl',
zip_code='00413',
email='*****@*****.**',
phone_number='1234567890',
default_pickup_arrangements='Drop in nearest mailbox.',
)
self.john.save()
# Set up a Tool
today = timezone.now()
self.sledge = Tool(
name="sledgehammer",
owner=self.john,
description="A sturdy sledgehammer.",
tool_type="hammer",
tool_pickup_arrangements="If you can lift it, you can have it.",
available_date=today,
)
self.sledge.save()
# Data for a modified tool
self.brokenSledge_info = {
"id": self.sledge.id,
"name": "broken sledgehammer",
"description": "Basically a stick.",
"tool_type": "1/2 hammer",
"in_community_shed": False,
"tool_pickup_arrangements": "Take it off my lawn.",
"tool_available": True,
}
# Data for a new tool
self.needles_info = {
"name": "Knitting Needles",
"description": "for making plush eldrich monstrosities",
"tool_type": "needle",
"in_community_shed": True,
"tool_pickup_arrangements": "Get it from the shed.",
"tool_available": True
}
# Mock session, where applicable
self.mock_session = \
{
"user" : \
{
"username" : self.john.username,
"id" : self.john.id,
"zip_code" : self.john.zip_code,
}
}
# Empty session, otherwise
self.empty_session = {}
def test_getById(self):
request = self.factory.get('/api/tool/')
request.session = self.mock_session
response = get_tool(request, self.sledge.id)
# Did we get a clean response?
self.assertEqual(response.status_code, 200)
# Did we get the right data?
# NOTE: Instead of the owner object, we'll be getting back
# the owner's username, and instead of a date object, we'll
# be getting a datetime in milliseconds.
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["name"], self.sledge.name)
self.assertEqual(
response_data["owner"],
self.sledge.owner.username,
)
self.assertEqual(
response_data["description"],
self.sledge.description,
)
self.assertEqual(
response_data["tool_type"],
self.sledge.tool_type,
)
self.assertEqual(
response_data["tool_pickup_arrangements"],
self.sledge.tool_pickup_arrangements,
)
self.assertEqual(
response_data["available_date"],
dt_to_milliseconds(self.sledge.available_date),
)
def test_createNewTool(self):
request = self.factory.post(path='/api/tool/',
data=json.dumps(self.needles_info),
content_type="application/json")
request.session = self.mock_session
response = update(request)
response_data = json.loads(response.content.decode("utf-8"))
# No way to know the new ID, but here's some stuff it isn't!
self.assertIsNotNone(response_data["id"])
self.assertNotEqual(response_data["id"], 0)
# Also no way to know the exact time of creation, but all that
# we care about right now is that it's in the past.
self.assertTrue(response_data["available_date"] -
dt_to_milliseconds(timezone.now()) < 0)
# And now the rest of the validation.
self.assertEqual(response_data["name"], self.needles_info["name"])
self.assertEqual(response_data["owner"], self.john.username)
self.assertEqual(response_data["description"],
self.needles_info["description"])
self.assertEqual(response_data["tool_type"],
self.needles_info["tool_type"])
self.assertEqual(response_data["in_community_shed"],
self.needles_info["in_community_shed"])
self.assertEqual(response_data["tool_pickup_arrangements"],
self.needles_info["tool_pickup_arrangements"])
self.assertTrue(response_data["tool_available"])
def test_updateTool(self):
request = self.factory.put(
path='/api/tool',
content_type="application/json",
data=json.dumps(self.brokenSledge_info),
)
request.session = self.mock_session
response = update(request)
# Did we get a clean response?
# print(response.content)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["id"], self.sledge.id)
self.assertEqual(response_data["name"], self.brokenSledge_info["name"])
self.assertEqual(response_data["owner"], self.john.username)
self.assertIsNotNone(response_data["available_date"])
self.assertEqual(response_data["description"],
self.brokenSledge_info["description"])
self.assertEqual(response_data["tool_type"],
self.brokenSledge_info["tool_type"])
def test_deleteTool_good(self):
# sanity check
self.assertIn(self.sledge, Tool.objects.all())
# call the delete route
request = self.factory.delete('/api/tool')
request.session = self.mock_session
response = get_tool(request, self.sledge.id)
response_data = json.loads(response.content.decode("utf-8"))
# is it gone?
self.assertTrue(response_data["success"])
self.assertNotIn(self.sledge, Tool.objects.all())
#@unittest.expectedFailure # system doesn't know how to handle nonexistant IDs
@unittest.skip #for submitting R2
def test_deleteTool_bad(self):
# try to delete a tool twice
request = self.factory.delete('/api/tool')
request.session = self.mock_session
response = get_tool(request, self.sledge.id) #first
response = get_tool(request, self.sledge.id) #second
response_data = json.loads(response.content.decode("utf-8"))
self.assertFalse(response_data["success"])
def test_getLocalTools(self):
request = self.factory.get('/api/tools/area')
# We need a user to have local tools to browse.
request.session = self.mock_session
response = local_tools(request)
response_data = json.loads(response.content.decode("utf-8"))
self.assertIn(tool_to_json(self.sledge), response_data)
def test_getPersonalTools(self):
request = self.factory.get('/api/tools')
# We need a user to have personal tools to browse.
request.session = self.mock_session
response = user_tools(request)
response_data = json.loads(response.content.decode("utf-8"))
self.assertIn(tool_to_json(self.sledge), response_data)
class TestPlaceTagInstanceView (APITestMixin, TestCase):
def setUp(self):
self.owner = User.objects.create_user(username='******', password='******', email='*****@*****.**')
self.submitter = User.objects.create_user(username='******', password='******', email='*****@*****.**')
self.dataset = DataSet.objects.create(slug='ds', owner=self.owner)
self.place = Place.objects.create(
dataset=self.dataset,
geometry='POINT(2 3)',
submitter=self.submitter,
data=json.dumps({
'type': 'ATM',
'name': 'K-Mart',
'private-secrets': 42
}),
)
self.tags = [
Tag.objects.create(
name="status",
dataset=self.dataset,
),
]
self.tags.extend([
Tag.objects.create(
name="approved",
dataset=self.dataset,
parent=self.tags[0]
),
Tag.objects.create(
name="rejected",
dataset=self.dataset,
parent=self.tags[0]
)
])
self.place_tag = PlaceTag.objects.create(
place=self.place,
submitter=self.submitter,
tag=self.tags[1],
note="I approve this place!"
)
self.origin = Origin.objects.create(pattern='def', dataset=self.dataset)
Origin.objects.create(pattern='def2', dataset=self.dataset)
self.unauthorized_user = User.objects.create_user(
username='******',
password='******'
)
self.authorized_user = User.objects.create_user(
username='******',
password='******'
)
group = Group.objects.create(
dataset=self.dataset,
name='mygroup'
)
group.submitters.add(self.authorized_user)
GroupPermission.objects.create(
group=group,
# TODO: rename this to 'resource':
submission_set='tags',
can_destroy=True,
can_update=True
)
unauthorized_group = Group.objects.create(
dataset=self.dataset,
name='badgroup'
)
unauthorized_group.submitters.add(self.unauthorized_user)
unauthorized_group.submitters.add(self.authorized_user)
GroupPermission.objects.create(
group=unauthorized_group,
# TODO: rename this to 'resource':
submission_set='tags',
)
self.request_kwargs = {
'owner_username': self.owner.username,
'dataset_slug': self.dataset.slug,
'place_id': self.place.id,
'place_tag_id': self.place_tag.id
}
self.factory = RequestFactory()
self.path = reverse('place-tag-detail', kwargs=self.request_kwargs)
self.view = PlaceTagInstanceView.as_view()
cache_buffer.reset()
django_cache.clear()
def tearDown(self):
User.objects.all().delete()
DataSet.objects.all().delete()
Place.objects.all().delete() # this should delete all of the PlaceTags as well, (via cascade)
Tag.objects.all().delete() # this should delete all of the PlaceTags as well, (via cascade)
# TODO: ensure that there are no more Tag or PlaceTag 's left
# PlaceTag.objects.all().delete()
cache_buffer.reset()
django_cache.clear()
def test_GET_response(self):
request = self.factory.get(self.path)
response = self.view(request, **self.request_kwargs)
data = json.loads(response.rendered_content)
# Check that the request was successful
self.assertStatusCode(response, 200)
# Check that the data attributes have been incorporated into the
# properties
self.assertEqual(data.get('note'), "I approve this place!")
# Check that the appropriate attributes are in the properties
self.assertIn('url', data)
self.assertIn('submitter', data)
self.assertIn('place', data)
self.assertIn('tag', data)
# Check that the URL is right
self.assertEqual(
data['url'],
'http://testserver' + reverse('place-tag-detail', args=[
self.owner.username, self.dataset.slug, self.place.id,
self.place_tag.id])
)
def test_GET_invalid_url(self):
# Make sure that we respond with 404 if a place_id is supplied, but for
# the wrong dataset or owner.
request_kwargs = {
'owner_username': '******',
'dataset_slug': self.dataset.slug,
'place_id': self.place.id,
'place_tag_id': self.place_tag.id
}
path = reverse('place-tag-detail', kwargs=request_kwargs)
request = self.factory.get(path)
response = self.view(request, **request_kwargs)
self.assertStatusCode(response, 404)
# TODO: implement this when caching is re-enabled:
# def test_GET_from_cache(self):
# path = reverse('submission-detail', kwargs=self.request_kwargs)
# request = self.factory.get(path)
# # Check that we make a finite number of queries
# #
# # ---- Checking data access permissions:
# #
# # - SELECT requested dataset and owner
# # - SELECT dataset permissions
# # - SELECT keys
# # - SELECT key permissions
# # - SELECT origins
# # - SELECT origin permissions
# #
# # ---- Build the data
# #
# # - SELECT * FROM sa_api_submission AS s
# # JOIN sa_api_submittedthing AS st ON (s.submittedthing_ptr_id = st.id)
# # JOIN sa_api_dataset AS ds ON (st.dataset_id = ds.id)
# # JOIN sa_api_submissionset AS ss ON (s.parent_id = ss.id)
# # JOIN sa_api_place AS p ON (ss.place_id = p.submittedthing_ptr_id)
# # JOIN sa_api_submittedthing AS pt ON (p.submittedthing_ptr_id = pt.id)
# # WHERE st.id = <self.submission.id>;
# #
# # - SELECT * FROM sa_api_attachment AS a
# # WHERE a.thing_id IN (<self.submission.id>);
# #
# with self.assertNumQueries(13):
# response = self.view(request, **self.request_kwargs)
# self.assertStatusCode(response, 200)
# path = reverse('submission-detail', kwargs=self.request_kwargs)
# request = self.factory.get(path)
# # Check that this performs no more queries than required for auth,
# # since the data's all cached
# with self.assertNumQueries(0):
# response = self.view(request, **self.request_kwargs)
# self.assertStatusCode(response, 200)
def test_DELETE_response(self):
#
# View should 401 when trying to delete when not authenticated
#
request = self.factory.delete(self.path)
response = self.view(request, **self.request_kwargs)
self.assertStatusCode(response, 401)
#
# View should 403 the place when user is unauthorized
#
request = self.factory.delete(self.path)
request.user = self.unauthorized_user
response = self.view(request, **self.request_kwargs)
self.assertStatusCode(response, 403)
#
# View should delete the place when owner is authenticated
#
request = self.factory.delete(self.path)
request.user = self.authorized_user
response = self.view(request, **self.request_kwargs)
# Check that the request was successful
self.assertStatusCode(response, 204)
# Check that no data was returned
self.assertIsNone(response.data)
def test_PUT_response(self):
submission_data = json.dumps({
'note': 'Revised comment',
})
# TODO: get json from django model, merge with submission data to fix PUT
# import ipdb
# ipdb.set_trace()
#
# View should 401 when trying to update when not authenticated
#
request = self.factory.put(self.path, data=submission_data, content_type='application/json')
response = self.view(request, **self.request_kwargs)
self.assertStatusCode(response, 401)
#
# View should 403 when trying to update when not authorized
#
# user = User.objects.create_user(username='******',
# password='******')
request = self.factory.put(self.path, data=submission_data, content_type='application/json')
request.user = self.unauthorized_user
request.META['HTTP_ORIGIN'] = self.origin.pattern
response = self.view(request, **self.request_kwargs)
self.assertStatusCode(response, 403)
# #
# # View should 200 when trying to update when authorized
# #
# request = self.factory.put(self.path, data=submission_data, content_type='application/json')
# request.user = self.authorized_user
# request.META['HTTP_ORIGIN'] = self.origin.pattern
# response = self.view(request, **self.request_kwargs)
# self.assertStatusCode(response, 403)
def test_PATCH_response(self):
submission_data = json.dumps({
'note': 'Revised comment',
})
#
# View should update the place when user is authenticated
#
request = self.factory.patch(self.path, data=submission_data, content_type='application/json')
request.user = self.authorized_user
request.META['HTTP_ORIGIN'] = self.origin.pattern
response = self.view(request, **self.request_kwargs)
# # Check that the request was successful
self.assertStatusCode(response, 200)
data = json.loads(response.rendered_content)
# Check that the data attributes have been incorporated into the
# properties
self.assertEqual(data.get('note'), 'Revised comment')
class DecoratorTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
def _finalize_response(self, request, response, *args, **kwargs):
response.request = request
return APIView.finalize_response(self, request, response, *args, **kwargs)
def test_wrap_view(self):
@api_view(['GET'])
def view(request):
return Response({})
self.assertTrue(isinstance(view.cls_instance, APIView))
def test_calling_method(self):
@api_view(['GET'])
def view(request):
return Response({})
request = self.factory.get('/')
response = view(request)
self.assertEqual(response.status_code, 200)
request = self.factory.post('/')
response = view(request)
self.assertEqual(response.status_code, 405)
def test_calling_put_method(self):
@api_view(['GET', 'PUT'])
def view(request):
return Response({})
request = self.factory.put('/')
response = view(request)
self.assertEqual(response.status_code, 200)
request = self.factory.post('/')
response = view(request)
self.assertEqual(response.status_code, 405)
def test_renderer_classes(self):
@api_view(['GET'])
@renderer_classes([JSONRenderer])
def view(request):
return Response({})
request = self.factory.get('/')
response = view(request)
self.assertTrue(isinstance(response.accepted_renderer, JSONRenderer))
def test_parser_classes(self):
@api_view(['GET'])
@parser_classes([JSONParser])
def view(request):
self.assertEqual(len(request.parsers), 1)
self.assertTrue(isinstance(request.parsers[0],
JSONParser))
return Response({})
request = self.factory.get('/')
view(request)
def test_authentication_classes(self):
@api_view(['GET'])
@authentication_classes([BasicAuthentication])
def view(request):
self.assertEqual(len(request.authenticators), 1)
self.assertTrue(isinstance(request.authenticators[0],
BasicAuthentication))
return Response({})
request = self.factory.get('/')
view(request)
def test_permission_classes(self):
@api_view(['GET'])
@permission_classes([IsAuthenticated])
def view(request):
return Response({})
request = self.factory.get('/')
response = view(request)
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN)
def test_throttle_classes(self):
class OncePerDayUserThrottle(UserRateThrottle):
rate = '1/day'
@api_view(['GET'])
@throttle_classes([OncePerDayUserThrottle])
def view(request):
return Response({})
request = self.factory.get('/')
response = view(request)
self.assertEquals(response.status_code, status.HTTP_200_OK)
response = view(request)
self.assertEquals(response.status_code, status.HTTP_429_TOO_MANY_REQUESTS)
class FilesViewTest(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.user = create_user()
# The various files views are a little tricky to invoke. We would
# like to just use self.client.get() but we can't because we need
# to install a custom HTTP_X_AUTH_TOKEN header. So, instead we use
# RequestFactory to assemble the request and then we pass that
# request directly into the account() view function.
#
# Here are some helper functions to make that more convenient
def account_view_get(self,
use_invalid_token=False,
query=''):
url = reverse('account', kwargs={'account_id': self.user.account.id})
url += query
request = self.factory.get(url)
if (use_invalid_token):
request.META['HTTP_X_AUTH_TOKEN'] = 'bogus'
else:
request.META['HTTP_X_AUTH_TOKEN'] = self.user.token
return account(request, self.user.account.id)
def container_view_put(self, container_name):
url = reverse('container',
kwargs={'account_id': self.user.account.id,
'container_name': container_name})
request = self.factory.put(url)
request.META['HTTP_X_AUTH_TOKEN'] = self.user.token
return container(request, self.user.account.id, container_name)
def container_view_get(self, container_name, use_invalid_token=False):
request = self.factory.get(
reverse('container',
kwargs={'account_id': self.user.account.id,
'container_name': container_name}))
if (use_invalid_token):
request.META['HTTP_X_AUTH_TOKEN'] = 'bogus'
else:
request.META['HTTP_X_AUTH_TOKEN'] = self.user.token
return container(request, self.user.account.id, container_name)
def file_view_put(self, container_name, path):
url = reverse('file',
kwargs={'account_id': self.user.account.id,
'container_name': container_name,
'path': path})
request = self.factory.put(url)
request.META['HTTP_X_AUTH_TOKEN'] = self.user.token
return container(request, self.user.account.id, container_name, path)
def file_view_delete(self, container_name, path):
url = reverse('file',
kwargs={'account_id': self.user.account.id,
'container_name': container_name,
'path': path})
request = self.factory.delete(url)
request.META['HTTP_X_AUTH_TOKEN'] = self.user.token
return container(request, self.user.account.id, container_name, path)
def file_view_get(self, container_name, path='', query=''):
url = reverse('file',
kwargs={'account_id': self.user.account.id,
'container_name': container_name,
'path': path})
url += query
request = self.factory.get(url)
request.META['HTTP_X_AUTH_TOKEN'] = self.user.token
return container(request, self.user.account.id, container_name, path)
def test_account_authorized(self):
"""Verify that the account view requires a valid token."""
# First attempt to connect with an invalid token. This should fail.
response = self.account_view_get(use_invalid_token=True)
self.assertEquals(response.status_code, 401)
# Then, try again with the correct token, which should work
response = self.account_view_get()
self.assertEquals(response.status_code, 200)
self.assertJSONEqual(response.content, "[]")
def test_account_ordered(self):
"""Ensure that containers are listed in alphabetical order."""
acc = self.user.account
SlowishContainer.objects.create(account=acc, name='foo')
SlowishContainer.objects.create(account=acc, name='bar')
SlowishContainer.objects.create(account=acc, name='baz')
response = self.account_view_get()
self.assertJSONEqual(
response.content,
'[{"count": 0, "bytes": 0, "name": "bar"},'
'{"count": 0, "bytes": 0, "name": "baz"},'
'{"count": 0, "bytes": 0, "name": "foo"}]')
def test_account_range(self):
"""Test marker and end_marker parameters when listing containers."""
account = self.user.account
names = ['this', 'is', 'a', 'collection', 'of', 'container',
'names', 'in', 'no', 'particular', 'order']
for name in names:
SlowishContainer.objects.create(account=account, name=name)
response = self.account_view_get(query="?marker=order")
self.assertJSONEqual(
response.content,
'[{"count": 0, "bytes": 0, "name": "particular"},'
'{"count": 0, "bytes": 0, "name": "this"}]')
response = self.account_view_get(query="?end_marker=container")
self.assertJSONEqual(
response.content,
'[{"count": 0, "bytes": 0, "name": "a"},'
'{"count": 0, "bytes": 0, "name": "collection"}]')
response = self.account_view_get(
query="?marker=container&end_marker=names")
self.assertJSONEqual(
response.content,
'[{"count": 0, "bytes": 0, "name": "in"},'
'{"count": 0, "bytes": 0, "name": "is"}]')
def test_account_content(self):
"""Verify the json response content from the account view."""
# With no containers, we expect an empty list
response = self.account_view_get()
self.assertJSONEqual(response.content, "[]")
def test_container_authorized(self):
"""Verify that the container view requires a valid token."""
SlowishContainer.objects.create(
account=self.user.account,
name='test')
# First attempt to connect with an invalid token. This should fail.
response = self.container_view_get('test', use_invalid_token=True)
self.assertEquals(response.status_code, 401)
# Then, try again with the correct token, which should work
response = self.container_view_get('test')
self.assertEquals(response.status_code, 200)
def test_container_create(self):
"""Verify we can create a new container."""
# Prior to creation, there shold be an empty list of containers
response = self.account_view_get()
self.assertJSONEqual(response.content, "[]")
# Issue a PUT request to create a new container (returns a
# status of 201==Created)
response = self.container_view_put('new_container')
self.assertEquals(response.status_code, 201)
# Trying to create again is fine and gives a 200==OK status
response = self.container_view_put('new_container')
self.assertEquals(response.status_code, 200)
# Verify that the newly created container now appears in the
# list of containers
response = self.account_view_get()
self.assertJSONEqual(
response.content,
'[{"count": 0, "bytes": 0, "name": "new_container"}]')
# Test the __unicode__ method within SlowishContainer
container = SlowishContainer.objects.get(name="new_container")
self.assertEquals(str(container), "new_container (in account 1234)")
def test_file_create(self):
"""Verify we can create a file within a container."""
# Create a container
self.container_view_put('container')
# Create a file within that container (returns status of
# 201==Created)
response = self.file_view_put('container', 'path/to/file')
self.assertEquals(response.status_code, 201)
# Trying to create again is fine and gives a 200=OK status
response = self.file_view_put('container', 'path/to/file')
self.assertEquals(response.status_code, 200)
# Test the __unicode__ method within SlowishFile
file = SlowishFile.objects.get(path="path/to/file")
self.assertEquals(
str(file),
"path/to/file (in container container (in account 1234))")
# Create a couple of more files
self.file_view_put("container", "another/file")
self.file_view_put("container", "and/yet/one/more")
# Query list of files in container
response = self.file_view_get("container")
self.assertEquals(response.status_code, 200)
self.assertJSONEqual(
response.content,
'[{"bytes": 0, "content_type": "application/directory",'
'"name": "and/yet/one/more"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "another/file"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "path/to/file"}]')
def test_files_range(self):
"""Verify marker and end_marker parameters for file list."""
container = SlowishContainer.objects.create(
account=self.user.account,
name="blob")
names = ['this', 'is', 'a', 'collection', 'of', 'file',
'names', 'in', 'no', 'particular', 'order']
for name in names:
SlowishFile.objects.create(
container=container,
path=name)
response = self.file_view_get("blob", query="?marker=order")
self.assertJSONEqual(
response.content,
'[{"bytes": 0, "content_type": "application/directory",'
'"name": "particular"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "this"}]')
response = self.file_view_get("blob", query="?end_marker=file")
self.assertJSONEqual(
response.content,
'[{"bytes": 0, "content_type": "application/directory",'
'"name": "a"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "collection"}]')
response = self.file_view_get(
"blob",
query="?marker=file&end_marker=names")
self.assertJSONEqual(
response.content,
'[{"bytes": 0, "content_type": "application/directory",'
'"name": "in"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "is"}]')
def test_files_prefix(self):
"""Verify query of files matching a prefix."""
# Create several files in a container
self.container_view_put("containter")
self.file_view_put("container", "this/file/is/your/file")
self.file_view_put("container", "this/file/is/my/file")
self.file_view_put("container", "from/california")
self.file_view_put("container", "to/the/new/york/island")
self.file_view_put("container", "this/file/is/made/for/you/and/me")
# List only those files matching a prefix
response = self.file_view_get("container", query="?prefix=this/file")
self.assertJSONEqual(
response.content,
'[{"bytes": 0, "content_type": "application/directory",'
'"name": "this/file/is/made/for/you/and/me"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "this/file/is/my/file"},'
'{"bytes": 0, "content_type": "application/directory",'
'"name": "this/file/is/your/file"}]')
# We don't yet support getting file contents, but we can at least
# ask about directory objects that we have stored as files within
# a container.
def test_directory_get(self):
"""Verify that a specific file in a container can be queried."""
self.container_view_put('container')
self.file_view_put('container', 'path/to/file')
# Verify file query returns successful status
response = self.file_view_get("container", "path/to/file")
self.assertEquals(response.status_code, 200)
# And a non-existent file should fail
response = self.file_view_get("container", "does/not/exist")
self.assertEquals(response.status_code, 404)
def test_file_delete(self):
"""Verify we can delete a file from a container."""
# Create some files in a container
self.container_view_put("crew")
self.file_view_put("crew", "one_shirt")
self.file_view_put("crew", "two_shirt")
self.file_view_put("crew", "red_shirt")
self.file_view_put("crew", "blue_shirt")
# Verify presence of added files
response = self.file_view_get("crew", "red_shirt")
self.assertEquals(response.status_code, 200)
response = self.file_view_get("crew", "blue_shirt")
self.assertEquals(response.status_code, 200)
# Delete a file (I know you saw this coming)
response = self.file_view_delete("crew", "red_shirt")
self.assertEquals(response.status_code, 204)
# Verify deletion only of the single file
response = self.file_view_get("crew", "red_shirt")
self.assertEquals(response.status_code, 404)
response = self.file_view_get("crew", "blue_shirt")
self.assertEquals(response.status_code, 200)
# Attempt to delete again should fail
response = self.file_view_delete("crew", "red_shirt")
self.assertEquals(response.status_code, 404)
def test_container_does_not_exist(self):
"""Verify a 404 status for a non-existent container."""
with self.assertRaises(Http404):
self.container_view_get('does_not_exist')
class BorrowTransactionApiTestCase(TestCase):
def setUp(self):
# Set up a Request Factory
self.factory = RequestFactory()
# Make some basic objects to play with.
self.parrot = User.create_new_user("Parrot", "password", "03545",
"*****@*****.**", "1234567890",
"Pining for the fjords.")
self.penguin = User.create_new_user('Penguin', 'password', '03545',
'*****@*****.**', '5555551234',
'It\'s on the telly.')
self.polarbear = User.create_new_user('Polarbear', 'password', '00000',
'*****@*****.**',
'5555551234',
'Pick it up at the north pole')
self.nail = Tool.create_new_tool(
"Rusty Nail",
toolownerID=self.parrot.id,
tooldescription="Holding up a stuffed parrot",
tooltype="nail",
toolshed=False,
pickup_info="Rip it out of the cage.",
tool_available=True)
self.zilly = Tool.create_new_tool(
"Warhammer of Zillyhoo",
toolownerID=self.parrot.id,
tooldescription="Its majesty makes you weep.",
tooltype="hammer",
toolshed=False,
pickup_info="Some time travel required.",
tool_available=True)
self.scraper = Tool.create_new_tool(
"Ice Scraper",
toolownerID=self.penguin.id,
tooldescription="An ice scraper for your car",
tooltype="ice scraper",
toolshed=False,
pickup_info="Pick it up at the south pole.",
tool_available=True)
#cutting this out in case we lose points for that dumb runtime warning
@unittest.skip
def test_requestBorrowTransaction(self):
# Penguin borrows nail from parrot
jsondata = {
'toolId':
self.nail.id,
'borrower_message':
"i need dis",
# NOTE: Python throws a nasty runtime error here because it
# can't tell whether the milliseconds are timezone-aware.
# Nothing I can do about this, just ignore the warning.
'date':
dt_to_milliseconds(timezone.datetime(
year=3000,
month=4,
day=13,
)),
}
request = self.factory.post(
path='/api/borrowTransaction',
data=json.dumps(jsondata),
content_type="application/json",
)
request.session = {'user': {'id': self.penguin.id}}
response = api.borrowTransaction(request)
#print(response.content)
self.assertEqual(response.status_code, 200)
"""
@unittest.skip # this is not actually required behavior
def test_requestBorrowTransaction_differentzones(self):
# Polar bear borrows ice scraper from penguin
# note that polar bears and penguins do not live in the same
# place
jsondata = {
'toolId' : self.scraper.id,
'borrower_message' : "i need dis",
'date' : dt_to_milliseconds(timezone.datetime(
tzinfo = timezone.UTC,
year = 3000,
month = 4,
day = 13,
)),
}
request = self.factory.post(
path = '/api/borrowTransaction',
data = json.dumps(jsondata),
content_type = "application/json",
)
request.session = {
'user' : {
'id' : self.polarbear.id
}
}
response = api.borrowTransaction(request)
#print(response.content)
self.assertNotEqual(response.status_code, 200)
"""
@unittest.skip #not ready yet
def test_getUnresolvedBorrowTransactions(self):
request = self.factory.get(
path='/api/borrowTransaction/requestPending')
@unittest.skip #not ready yet
def test_resolveBorrowRequest(self):
request = self.factory.post('/api/borrowTransaction/resolve')
@unittest.skip #not ready yet
def test_getRejectedRequests(self):
request = self.factory.get(path='/api/borrowTransaction/rejected/:id')
@unittest.skip #not ready yet
def test_requestEndBorrowTransaction(self):
request = self.factory.put('/api/borrowTransaction')
@unittest.skip #not ready yet
def test_getEndBorrowTransactionRequests(self):
request = self.factory.get(path='/api/borrowTransaction/endRequests')
@unittest.skip #not ready yet
def test_resolveEndBorrowTransaction(self):
request = self.factory.delete(
path='/api/borrowTransaction/:transactionId')
@unittest.skip #not ready yet
def test_getToolsUserIsBorrowing(self):
request = self.factory.put(
path='/api/borrowTransaction/borrowing/:userId')
@unittest.skip #not ready yet
def test_getToolsUserIsLending(self):
request = self.factory.get(
path='/api/borrowTransaction/borrowed/:userId')
@unittest.skip #not ready yet
def test_getAllCommunityHistory(self):
request = self.factory.get(
path='/api/borrowTransaction/community/:zip')
@unittest.skip #not ready yet
def test_getAllReturnPendingBorrowTransactionsInCommunityShed(self):
request = self.factory.get(
path='/api/borrowTransaction/pendingCommunity')
class PageViewTest(TestCase):
fixtures = ['gitspatial/fixtures/test_data.json']
def setUp(self):
self.sal = User.objects.get(id=6)
self.jason = User.objects.get(id=5)
self.factory = RequestFactory()
def test_user_landing(self):
request = self.factory.get('/user')
request.user = self.sal
response = user_landing(request)
self.assertEqual(response.status_code, 200)
def test_user_cannot_view_others_repo(self):
request = self.factory.get('/user/repo/22')
request.user = self.sal
response = user_repo(request, 22)
self.assertEqual(response.status_code, 403)
def test_user_can_view_own_repo(self):
request = self.factory.get('/user/repo/22')
request.user = self.jason
response = user_repo(request, 22)
self.assertEqual(response.status_code, 200)
def test_user_cannot_view_others_feature_set(self):
request = self.factory.get('/user/feature_set/3')
request.user = self.sal
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 403)
def test_user_can_view_own_feature_set(self):
request = self.factory.get('/user/feature_set/3')
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 200)
def test_feature_set_rename(self):
request = self.factory.put('/user/feature_set/3', data='name=name&value=cats&pk=3')
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 200)
def test_feature_set_rename_no_value(self):
request = self.factory.put('/user/feature_set/3', data='name=name&pk=3')
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 400)
def test_feature_set_rename_value_too_long(self):
value = ''.join(random.choice(string.lowercase) for i in range(1003))
request = self.factory.put('/user/feature_set/3', data='name=name&value={0}&pk=3'.format(value))
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 400)
def test_page_too_high_redirects(self):
request = self.factory.get('/user/feature_set/3?page=99999')
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 302)
def test_string_page_redirects(self):
request = self.factory.get('/user/feature_set/3?page=lobster')
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 302)
def test_0_page_redirects(self):
request = self.factory.get('/user/feature_set/3?page=0')
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 302)
def test_feature_set_syncing(self):
request = self.factory.get('/user/feature_set/3')
fs = FeatureSet.objects.get(id=3)
fs.sync_status = FeatureSet.SYNCING
fs.save()
request.user = self.jason
response = user_feature_set(request, 3)
self.assertEqual(response.status_code, 200)
def test_unknown_repo_404s(self):
# A 404 actually raises an exception, so we have to catch it to prove we 404'd. Lame.
exc = None
request = self.factory.get('/user/repo/99999')
request.user = self.jason
try:
response = user_repo(request, 99999)
except Exception as exc:
pass
self.assertTrue(isinstance(exc, Http404))
def test_unknown_feature_set_404s(self):
# A 404 actually raises an exception, so we have to catch it to prove we 404'd. Lame.
exc = None
request = self.factory.get('/user/feature_set/99999')
request.user = self.jason
try:
response = user_feature_set(request, 99999)
except Exception as exc:
pass
self.assertTrue(isinstance(exc, Http404))
class SwiftTestCase(TestCase):
def setUp(self):
# Every test needs access to the request factory.
# Using rest_framework's APIRequestFactory: http://www.django-rest-framework.org/api-guide/testing/
self.api_factory = APIRequestFactory()
self.simple_factory = RequestFactory()
self.r = redis.Redis(connection_pool=settings.REDIS_CON_POOL)
# initializations
self.create_storage_policies()
self.create_proxy_sorting()
self.create_nodes()
def tearDown(self):
self.r.flushdb()
def test_tenants_list_with_method_not_allowed(self):
""" Test that DELETE requests to tenants_list() return METHOD_NOT_ALLOWED """
request = self.api_factory.delete('/swift/tenants')
request.META['HTTP_X_AUTH_TOKEN'] = 'fake_token'
response = tenants_list(request)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_storage_policy_list_with_method_not_allowed(self):
""" Test that DELETE requests to storage_policy_list() return METHOD_NOT_ALLOWED """
request = self.api_factory.delete('/swift/storage_policies')
response = storage_policy_list(request)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_storage_policies_with_method_not_allowed(self):
""" Test that GET requests to storage_policies() return METHOD_NOT_ALLOWED """
request = self.api_factory.get('/swift/spolicies')
response = storage_policies(request)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_locality_list_with_method_not_allowed(self):
""" Test that POST requests to locality_list() return METHOD_NOT_ALLOWED """
request = self.api_factory.post(
'/swift/locality/123456789abcdef/container1/object1.txt')
response = locality_list(request, '123456789abcdef', 'container1',
'object1.txt')
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_sort_list_with_method_not_allowed(self):
""" Test that DELETE requests to sort_list() return METHOD_NOT_ALLOWED """
request = self.api_factory.delete('/swift/sort_nodes')
response = sort_list(request)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_sort_detail_with_method_not_allowed(self):
""" Test that POST requests to sort_list() return METHOD_NOT_ALLOWED """
request = self.api_factory.post('/swift/sort_nodes/5')
response = sort_detail(request, 5)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_get_all_proxy_sortings_ok(self):
request = self.api_factory.get('/swift/sort_nodes')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertNotEqual(response.content, "[]")
proxy_sortings = json.loads(response.content)
self.assertEqual(len(proxy_sortings), 1)
self.assertEqual(proxy_sortings[0]['name'], 'FakeProxySorting')
def test_create_proxy_sorting_ok(self):
# Create a second proxy sorting
proxy_sorting_data = {
'name': 'SecondProxySorting',
'criterion': 'second_criterion'
}
request = self.api_factory.post('/swift/sort_nodes',
proxy_sorting_data,
format='json')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Retrieve the list and check there are 2 elements
request = self.api_factory.get('/swift/sort_nodes')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
proxy_sortings = json.loads(response.content)
self.assertEqual(len(proxy_sortings), 2)
def test_create_proxy_sorting_with_empty_dict(self):
# Create an empty proxy sorting
request = self.api_factory.post('/swift/sort_nodes', {}, format='json')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_create_proxy_sorting_with_empty_data(self):
# Create an empty proxy sorting
request = self.api_factory.post('/swift/sort_nodes', '', format='json')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_create_proxy_sorting_with_unparseable_data(self):
# Create an empty proxy sorting
unparseable_data = '{{{{[[[[.....'
request = self.simple_factory.post('/swift/sort_nodes',
unparseable_data,
'application/json')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
# TODO Add the following tests
# def test_create_proxy_sorting_with_not_allowed_parameters(self):
# def test_create_proxy_sorting_without_a_required_parameter(self):
def test_get_proxy_sorting_ok(self):
request = self.api_factory.get('/swift/sort_nodes/1')
response = sort_detail(request, 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
proxy_sorting = json.loads(response.content)
self.assertEqual(proxy_sorting['name'], 'FakeProxySorting')
self.assertEqual(proxy_sorting['criterion'], 'fake_criterion')
def test_update_proxy_sorting_ok(self):
proxy_sorting_data = {
'name': 'FakeProxySortingChanged',
'criterion': 'criterion changed'
}
request = self.api_factory.put('/swift/sort_nodes/1',
proxy_sorting_data,
format='json')
response = sort_detail(request, 1)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Check it has been updated
request = self.api_factory.get('/swift/sort_nodes/1')
response = sort_detail(request, 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
proxy_sorting = json.loads(response.content)
self.assertEqual(proxy_sorting['name'], 'FakeProxySortingChanged')
self.assertEqual(proxy_sorting['criterion'], 'criterion changed')
def test_update_proxy_sorting_with_empty_data(self):
request = self.api_factory.put('/swift/sort_nodes/1', {},
format='json')
response = sort_detail(request, 1)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_update_proxy_sorting_with_unparseable_data(self):
unparseable_data = '{{{{[[[[.....'
request = self.simple_factory.put('/swift/sort_nodes/1',
unparseable_data, 'application/json')
response = sort_detail(request, 1)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_delete_proxy_sorting_ok(self):
request = self.api_factory.delete('/swift/sort_nodes/1')
response = sort_detail(request, 1)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# Retrieve the list and check there are 0 elements
request = self.api_factory.get('/swift/sort_nodes')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.content, '[]')
def test_storage_policy_list_ok(self):
""" Test that GET requests to storage_policy_list() return METHOD_NOT_ALLOWED """
request = self.api_factory.get('/swift/storage_policies')
response = storage_policy_list(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
storage_policies_json = json.loads(response.content)
self.assertEqual(len(storage_policies_json), 5)
#
# Nodes
#
def test_node_list_with_method_not_allowed(self):
request = self.api_factory.delete('/swift/nodes')
response = node_list(request)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_list_nodes_ok(self):
request = self.api_factory.get('/swift/nodes')
response = node_list(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertNotEqual(response.content, "[]")
nodes = json.loads(response.content)
self.assertEqual(len(nodes), 3)
node_names = [node['name'] for node in nodes]
self.assertTrue('controller' in node_names)
self.assertTrue('storagenode1' in node_names)
self.assertTrue('storagenode2' in node_names)
a_device = nodes[0]['devices'].keys()[0]
self.assertIsNotNone(nodes[0]['devices'][a_device]['free'])
def test_node_detail_with_method_not_allowed(self):
node_name = 'storagenode1'
# POST is not supported
request = self.api_factory.post('/swift/nodes/' + node_name)
response = node_detail(request, node_name)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
def test_get_node_detail_ok(self):
node_name = 'storagenode1'
request = self.api_factory.get('/swift/nodes/' + node_name)
response = node_detail(request, node_name)
node = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(node['name'], 'storagenode1')
def test_get_node_detail_with_non_existent_node_name(self):
node_name = 'storagenode1000'
request = self.api_factory.get('/swift/nodes/' + node_name)
response = node_detail(request, node_name)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_node_detail_ok(self):
node_name = 'storagenode1'
request = self.api_factory.delete('/swift/nodes/' + node_name)
response = node_detail(request, node_name)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
# Verify it was deleted
request = self.api_factory.get('/swift/nodes/' + node_name)
response = node_detail(request, node_name)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
#
# Aux functions
#
def create_storage_policies(self):
self.r.hmset("storage-policy:0", {
'name': 'allnodes',
'default': 'yes',
'policy_type': 'replication'
})
self.r.hmset("storage-policy:1", {
'name': 'storage4',
'default': 'no',
'policy_type': 'replication'
})
self.r.hmset("storage-policy:2", {
'name': 's0y1',
'default': 'no',
'policy_type': 'replication'
})
self.r.hmset("storage-policy:3", {
'name': 's3y4',
'default': 'no',
'policy_type': 'replication'
})
self.r.hmset("storage-policy:4", {
'name': 's5y6',
'default': 'no',
'policy_type': 'replication'
})
def create_proxy_sorting(self):
proxy_sorting_data = {
'name': 'FakeProxySorting',
'criterion': 'fake_criterion'
}
request = self.api_factory.post('/swift/sort_nodes',
proxy_sorting_data,
format='json')
response = sort_list(request)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def create_nodes(self):
self.r.hmset(
'node:controller', {
'ip': '192.168.2.1',
'last_ping': '1467623304.332646',
'type': 'proxy',
'name': 'controller',
'devices':
'{"sdb1": {"free": 16832876544, "size": 16832880640}}'
})
self.r.hmset(
'node:storagenode1', {
'ip': '192.168.2.2',
'last_ping': '1467623304.332646',
'type': 'object',
'name': 'storagenode1',
'devices':
'{"sdb1": {"free": 16832876544, "size": 16832880640}}'
})
self.r.hmset(
'node:storagenode2', {
'ip': '192.168.2.3',
'last_ping': '1467623304.332646',
'type': 'object',
'name': 'storagenode2',
'devices':
'{"sdb1": {"free": 16832876544, "size": 16832880640}}'
})
class ViewTest(unittest.TestCase):
"""
Tests for BackboneAPIView.
Note that django.contrib.auth must be in INSTALLED_APPS for these to work.
"""
def setUp(self):
self.factory = RequestFactory()
self.view = ReadOnlyView.as_view()
self.writable_view = FullView.as_view()
self.user1 = User.objects.create(username='******', first_name='Test', last_name='One')
def tearDown(self):
User.objects.all().delete()
def add_two_more_users(self):
self.user2 = User.objects.create(username='******', first_name='Test', last_name='Two')
self.user3 = User.objects.create(username='******', first_name='Test', last_name='Three')
def test_collection_get(self):
request = self.factory.get('/users/')
response = self.view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
# Ensure response json deserializes to a 1-item list:
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 1)
self.assertEqual(response_data[0]['username'], self.user1.username)
# Try again with a few more users in the database:
self.add_two_more_users()
response = self.view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 3)
# With User model's default ordering (by id), user3 should be last:
self.assertEqual(response_data[2]['username'], self.user3.username)
# Test pagination:
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 2)
# Page 2 should only have one item:
request = self.factory.get('/users/?p=2')
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, list))
self.assertEqual(len(response_data), 1)
def test_single_item_get(self):
request = self.factory.get('/users/1')
response = self.view(request, id='1') # Simulate a urlconf passing in the 'id' kwarg
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content)
self.assert_(isinstance(response_data, dict))
self.assertEqual(response_data['username'], self.user1.username)
# Ensure 404s are raised for non-existent items:
request = self.factory.get('/users/7')
self.assertRaises(Http404, lambda: self.view(request, id='7'))
def test_post(self):
request = self.factory.post('/users')
response = self.view(request)
self.assertEqual(response.status_code, 405) # "Method not supported" if no add_form_class specified
# Testing BackboneAPIView subclasses that support POST via add_form_class:
# If no JSON provided in POST body, return HTTP 400:
response = self.writable_view(request)
self.assertEqual(response.status_code, 400)
# Test the case where invalid input is given (leading to form errors):
request = self.factory.post('/users', '{"wrong_field": "xyz"}', content_type='application/json')
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'ERROR: validation failed')
# If valid JSON was provided, a new instance should be created:
request = self.factory.post('/users', '{"username": "******"}', content_type='application/json')
response = self.writable_view(request)
self.assertEqual(response.status_code, 200)
self.assert_(User.objects.get(username='******'))
response_json = json.loads(response.content)
self.assertEqual(response_json['username'], 'post_test')
def test_put(self):
request = self.factory.put('/users/1')
response = self.view(request, id='1')
self.assertEqual(response.status_code, 405) # "Method not supported" if no edit_form_class specified
# PUT is also not supported for collections (when no id is provided):
request = self.factory.put('/users')
response = self.writable_view(request)
self.assertEqual(response.status_code, 405)
# If no JSON in PUT body, return HTTP 400:
response = self.writable_view(request, id='1')
self.assertEqual(response.status_code, 400)
# Raise 404 if an object with the given id doesn't exist:
request = self.factory.put('/users/27', '{"username": "******"}', content_type='application/json')
self.assertRaises(Http404, lambda: self.writable_view(request, id='27'))
# If the object exists and an edit_form_class is supplied, it actually does something:
request = self.factory.put('/users/1', '{"username": "******"}', content_type='application/json')
response = self.writable_view(request, id='1')
self.assertEqual(response.status_code, 200)
self.assertEqual(User.objects.get(id=1).username, 'put_test')
response_json = json.loads(response.content)
self.assertEqual(response_json['username'], 'put_test')
# Test the case where invalid input is given (leading to form errors):
request = self.factory.put('/users/1', '{"wrong_field": "xyz"}', content_type='application/json')
response = self.writable_view(request, id='1')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, 'ERROR: validation failed')
def test_delete(self):
# Delete is not supported for collections:
request = self.factory.delete('/users')
response = self.view(request)
self.assertEqual(response.status_code, 405)
self.assertEqual(User.objects.filter(id=1).count(), 1)
# But it is supported for single items (specified by id):
request = self.factory.delete('/users/1')
response = self.view(request, id='1')
self.assertEqual(response.status_code, 200)
self.assertEqual(User.objects.filter(id=1).count(), 0)
# Should raise 404 if we try to access a deleted resource again:
request = self.factory.delete('/users/1')
self.assertRaises(Http404, lambda: self.view(request, id='1'))
class NotificationViewDeviceTokenReceiveTest(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.device_token = '8a0d7cba3ffad34bd3dcb37728080a95d6ee78a83a68ead033614acbab9b7e76'
self.uuid = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
def tearDown(self):
DeviceToken.objects.all().delete()
def test_device_token_receive_with_all_parameter(self):
parameter = {
'device_token': self.device_token,
'uuid': self.uuid,
'sandbox': True
}
request = self.factory.put('/receive/', json.dumps(parameter))
request.content_type = 'application/json'
response = device_token_receive(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'result': 'success'})
def test_device_token_receive_with_only_device_token(self):
parameter = {'device_token': self.device_token}
request = self.factory.put('/receive/', json.dumps(parameter))
request.content_type = 'application/json'
response = device_token_receive(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'error': 'Bad Request'})
def test_device_token_receive_with_only_uuid(self):
parameter = {'uuid': self.uuid}
request = self.factory.put('/receive/', json.dumps(parameter))
request.content_type = 'application/json'
response = device_token_receive(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'error': 'Bad Request'})
def test_device_token_receive_with_only_sandbox(self):
parameter = {'sandbox': True}
request = self.factory.put('/receive/', json.dumps(parameter))
request.content_type = 'application/json'
response = device_token_receive(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'error': 'Bad Request'})
def test_device_token_receive_without_parameter(self):
request = self.factory.put('/receive/')
response = device_token_receive(request)
self.assertEqual(response.status_code, 400)
self.assertEqual(json.loads(response.content.decode('utf-8')),
{'error': 'Bad Request'})
def test_device_token_receive_with_twice(self):
device_token = DeviceToken()
device_token.device_token = '8a0d7cba3ffad34bd3dcb37728080a95d6ee78a83a68ead033614acbab9b7e76'
device_token.uuid = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
device_token.save()
parameter = {
'device_token':
'ec203ae05072eaa39474fd4bd06c3b36344602295078615cef67fcbdb7e94aef',
'uuid': 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX',
'sandbox': True
}
request = self.factory.put('/receive/', json.dumps(parameter))
request.content_type = 'application/json'
response = device_token_receive(request)
self.assertEqual(response.status_code, 200)
get_device_token = DeviceToken.objects.get(
uuid='XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX')
self.assertNotEqual(device_token.device_token,
get_device_token.device_token)
self.assertEqual(
get_device_token.device_token,
'ec203ae05072eaa39474fd4bd06c3b36344602295078615cef67fcbdb7e94aef')
self.assertEqual(get_device_token.uuid,
'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX')
def test_device_token_receive_method_get(self):
request = self.factory.get('/receive/')
response = device_token_receive(request)
self.assertEqual(response.status_code, 405)
def test_device_token_receive_method_post(self):
request = self.factory.post('/receive/')
response = device_token_receive(request)
self.assertEqual(response.status_code, 405)
def test_device_token_receive_method_delete(self):
request = self.factory.delete('/receive/')
response = device_token_receive(request)
self.assertEqual(response.status_code, 405)
class TestBulkAPIView(TestCase):
def setUp(self):
super(TestBulkAPIView, self).setUp()
self.view = SimpleBulkAPIView.as_view()
self.request = RequestFactory()
def test_get(self):
"""
Test that GET request is successful on bulk view.
"""
response = self.view(self.request.get(''))
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_post_single(self):
"""
Test that POST request with single resource only creates a single resource.
"""
response = self.view(self.request.post(
'',
json.dumps({'contents': 'hello world', 'number': 1}),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(SimpleModel.objects.count(), 1)
self.assertEqual(SimpleModel.objects.get().contents, 'hello world')
def test_post_bulk(self):
"""
Test that POST request with multiple resources creates all posted resources.
"""
response = self.view(self.request.post(
'',
json.dumps([
{'contents': 'hello world', 'number': 1},
{'contents': 'hello mars', 'number': 2},
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(list(SimpleModel.objects.all().values_list('contents', flat=True)), [
'hello world',
'hello mars',
])
def test_put(self):
"""
Test that PUT request updates all submitted resources.
"""
obj1 = SimpleModel.objects.create(contents='hello world', number=1)
obj2 = SimpleModel.objects.create(contents='hello mars', number=2)
response = self.view(self.request.put(
'',
json.dumps([
{'contents': 'foo', 'number': 3, 'id': obj1.pk},
{'contents': 'bar', 'number': 4, 'id': obj2.pk},
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(
list(SimpleModel.objects.all().values_list('id', 'contents', 'number')),
[
(obj1.pk, 'foo', 3),
(obj2.pk, 'bar', 4),
]
)
def test_put_without_update_key(self):
"""
Test that PUT request updates all submitted resources.
"""
response = self.view(self.request.put(
'',
json.dumps([
{'contents': 'foo', 'number': 3},
{'contents': 'rainbows', 'number': 4}, # multiple objects without id
{'contents': 'bar', 'number': 4, 'id': 555}, # non-existing id
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_patch(self):
"""
Test that PATCH request partially updates all submitted resources.
"""
obj1 = SimpleModel.objects.create(contents='hello world', number=1)
obj2 = SimpleModel.objects.create(contents='hello mars', number=2)
response = self.view(self.request.patch(
'',
json.dumps([
{'contents': 'foo', 'id': obj1.pk},
{'contents': 'bar', 'id': obj2.pk},
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(
list(SimpleModel.objects.all().values_list('id', 'contents', 'number')),
[
(obj1.pk, 'foo', 1),
(obj2.pk, 'bar', 2),
]
)
def test_delete_not_filtered(self):
"""
Test that DELETE is not allowed when results are not filtered.
"""
SimpleModel.objects.create(contents='hello world', number=1)
SimpleModel.objects.create(contents='hello mars', number=10)
response = self.view(self.request.delete(''))
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_delete_filtered(self):
"""
Test that DELETE removes all filtered resources.
"""
SimpleModel.objects.create(contents='hello world', number=1)
SimpleModel.objects.create(contents='hello mars', number=10)
response = FilteredBulkAPIView.as_view()(self.request.delete(''))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(SimpleModel.objects.count(), 1)
self.assertEqual(SimpleModel.objects.get().contents, 'hello world')
def test_options(self):
"""
Test that OPTIONS request is successful on bulk view.
"""
response = self.view(self.request.options(''))
self.assertEqual(response.status_code, status.HTTP_200_OK)
class DRYRestPermissionsTests(TestCase):
def setUp(self):
self.action_set = [
'retrieve', 'list', 'create', 'destroy', 'update',
'partial_update', 'custom_action1', 'custom_action2'
]
self.factory = RequestFactory()
self.request_retrieve = Request(self.factory.get('/dummy/1'))
self.request_list = Request(self.factory.get('/dummy'))
self.request_create = Request(self.factory.post('/dummy'), {})
self.request_destroy = Request(self.factory.delete('/dummy/1'))
self.request_update = Request(self.factory.put('/dummy/1', {}))
self.request_partial_update = Request(
self.factory.patch('/dummy/1', {}))
self.request_custom_action1 = Request(
self.factory.get('/dummy/custom_action1'))
self.request_custom_action2 = Request(
self.factory.post('/dummy/custom_action2', {}))
def _run_permission_checks(self, view, obj, assert_value):
for action in self.action_set:
view.action = action
request_name = "request_{action}".format(action=action)
result = view.dummy_check_permission(getattr(self, request_name),
obj)
self.assertEqual(result, assert_value)
def _run_dry_permission_field_checks(self, view, obj, assert_specific,
assert_base):
serializer = view.get_serializer_class()()
# dummy request
serializer.context['request'] = self.request_retrieve
representation = serializer.to_representation(obj)
for action in [
action for action in self.action_set
if action not in ['partial_update', 'list']
]:
has_permission = representation['permissions'].get(action, None)
self.assertEqual(
has_permission, assert_specific, "Action '%s' %s != %s" %
(action, has_permission, assert_specific))
for action in ['read', 'write']:
has_permission = representation['permissions'].get(action, None)
self.assertEqual(
has_permission, assert_base,
"Action '%s' %s != %s" % (action, has_permission, assert_base))
def test_true_base_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), None, True)
def test_false_base_object_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin):
base_object_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), None, False)
def test_false_base_global_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin):
base_global_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), None, False)
def test_true_specific_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
base_global_allowed = False
base_object_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, False)
def test_true_base_not_defined_permissions(self):
class TestModel(DummyModel, SpecificObjectMixin, SpecificGlobalMixin):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, None)
def test_false_specific_object_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
specific_object_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), False, True)
def test_false_specific_global_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
specific_global_allowed = False
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
view = TestViewSet()
self._run_permission_checks(view, TestModel(), False)
self._run_dry_permission_field_checks(view, TestModel(), False, True)
def test_true_no_global_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
base_global_allowed = False
specific_global_allowed = False
class TestSerializer(DummySerializer):
permissions = DRYPermissionsField(
object_only=True,
additional_actions=['custom_action1', 'custom_action2'])
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
permission_classes = (DRYObjectPermissions, )
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, True)
def test_true_no_object_permissions(self):
class TestModel(DummyModel, BaseObjectMixin, BaseGlobalMixin,
SpecificObjectMixin, SpecificGlobalMixin):
base_object_allowed = False
specific_object_allowed = False
class TestSerializer(DummySerializer):
permissions = DRYPermissionsField(
global_only=True,
additional_actions=['custom_action1', 'custom_action2'])
class Meta:
model = TestModel
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
permission_classes = (DRYGlobalPermissions, )
view = TestViewSet()
self._run_permission_checks(view, TestModel(), True)
self._run_dry_permission_field_checks(view, TestModel(), True, True)
def test_list_filter_backend(self):
class DummyFilter(object):
pass
class TestModel(DummyModel):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestFilterBackend(DRYPermissionFiltersBase):
def filter_list_queryset(self, request, queryset, view):
return DummyFilter()
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
queryset = TestModel.objects.all()
filter_backends = (TestFilterBackend, )
view = TestViewSet()
view.request = self.request_list
view.action = 'list'
view.kwargs = []
query_set = view.filter_queryset(view.get_queryset())
self.assertEqual(query_set.__class__, DummyFilter)
def test_action_filter_backend(self):
class DummyFilter(object):
pass
class TestModel(DummyModel):
pass
class TestSerializer(DummySerializer):
class Meta:
model = TestModel
class TestFilterBackend(DRYPermissionFiltersBase):
action_routing = True
def filter_list_queryset(self, request, queryset, view):
return None
def filter_custom_action1_queryset(self, request, queryset, view):
return DummyFilter()
class TestViewSet(DummyViewSet):
serializer_class = TestSerializer
queryset = TestModel.objects.all()
filter_backends = (TestFilterBackend, )
view = TestViewSet()
view.request = self.request_custom_action1
view.action = 'custom_action1'
view.kwargs = []
query_set = view.filter_queryset(view.get_queryset())
self.assertEqual(query_set.__class__, DummyFilter)
class ToolApiTestCase(TestCase):
def setUp(self):
# Set up a Request Factory
self.factory = RequestFactory()
# Set up a User
self.john = User(
username='******',
hashed_password = '******',
salt = 'NaCl',
zip_code = '00413',
email = '*****@*****.**',
phone_number = '1234567890',
default_pickup_arrangements =
'Drop in nearest mailbox.',
)
self.john.save()
# Set up a Tool
today = timezone.now()
self.sledge = Tool(
name = "sledgehammer",
owner = self.john,
description = "A sturdy sledgehammer.",
tool_type = "hammer",
tool_pickup_arrangements =
"If you can lift it, you can have it.",
available_date = today,
)
self.sledge.save()
# Data for a modified tool
self.brokenSledge_info = {
"id" : self.sledge.id,
"name" : "broken sledgehammer",
"description" : "Basically a stick.",
"tool_type" : "1/2 hammer",
"in_community_shed" : False,
"tool_pickup_arrangements" : "Take it off my lawn.",
"tool_available" : True,
}
# Data for a new tool
self.needles_info = {
"name" : "Knitting Needles",
"description" : "for making plush eldrich monstrosities",
"tool_type" : "needle",
"in_community_shed" : True,
"tool_pickup_arrangements" : "Get it from the shed.",
"tool_available" : True
}
# Mock session, where applicable
self.mock_session = \
{
"user" : \
{
"username" : self.john.username,
"id" : self.john.id,
"zip_code" : self.john.zip_code,
}
}
# Empty session, otherwise
self.empty_session = { }
def test_getById(self):
request = self.factory.get('/api/tool/')
request.session = self.mock_session
response = get_tool(request, self.sledge.id)
# Did we get a clean response?
self.assertEqual(response.status_code, 200)
# Did we get the right data?
# NOTE: Instead of the owner object, we'll be getting back
# the owner's username, and instead of a date object, we'll
# be getting a datetime in milliseconds.
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["name"], self.sledge.name)
self.assertEqual(response_data["owner"],
self.sledge.owner.username,
)
self.assertEqual(response_data["description"],
self.sledge.description,
)
self.assertEqual(response_data["tool_type"],
self.sledge.tool_type,
)
self.assertEqual(response_data["tool_pickup_arrangements"],
self.sledge.tool_pickup_arrangements,
)
self.assertEqual(response_data["available_date"],
dt_to_milliseconds(self.sledge.available_date),
)
def test_createNewTool(self):
request = self.factory.post(
path = '/api/tool/',
data = json.dumps(self.needles_info),
content_type = "application/json"
)
request.session = self.mock_session
response = update(request)
response_data = json.loads(response.content.decode("utf-8"))
# No way to know the new ID, but here's some stuff it isn't!
self.assertIsNotNone(response_data["id"])
self.assertNotEqual(response_data["id"], 0)
# Also no way to know the exact time of creation, but all that
# we care about right now is that it's in the past.
self.assertTrue(response_data["available_date"] -
dt_to_milliseconds(timezone.now()) < 0 )
# And now the rest of the validation.
self.assertEqual(response_data["name"],
self.needles_info["name"])
self.assertEqual(response_data["owner"],
self.john.username)
self.assertEqual(response_data["description"],
self.needles_info["description"])
self.assertEqual(response_data["tool_type"],
self.needles_info["tool_type"])
self.assertEqual(response_data["in_community_shed"],
self.needles_info["in_community_shed"])
self.assertEqual(response_data["tool_pickup_arrangements"],
self.needles_info["tool_pickup_arrangements"])
self.assertTrue(response_data["tool_available"])
def test_updateTool(self):
request = self.factory.put(
path = '/api/tool',
content_type = "application/json",
data = json.dumps(self.brokenSledge_info),
)
request.session = self.mock_session
response = update(request)
# Did we get a clean response?
# print(response.content)
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["id"], self.sledge.id)
self.assertEqual(response_data["name"],
self.brokenSledge_info["name"])
self.assertEqual(response_data["owner"],
self.john.username)
self.assertIsNotNone(response_data["available_date"])
self.assertEqual(response_data["description"],
self.brokenSledge_info["description"])
self.assertEqual(response_data["tool_type"],
self.brokenSledge_info["tool_type"])
def test_deleteTool_good(self):
# sanity check
self.assertIn(self.sledge, Tool.objects.all())
# call the delete route
request = self.factory.delete('/api/tool')
request.session = self.mock_session
response = get_tool(request, self.sledge.id)
response_data = json.loads(response.content.decode("utf-8"))
# is it gone?
self.assertTrue(response_data["success"])
self.assertNotIn(self.sledge, Tool.objects.all())
#@unittest.expectedFailure # system doesn't know how to handle nonexistant IDs
@unittest.skip #for submitting R2
def test_deleteTool_bad(self):
# try to delete a tool twice
request = self.factory.delete('/api/tool')
request.session = self.mock_session
response = get_tool(request, self.sledge.id) #first
response = get_tool(request, self.sledge.id) #second
response_data = json.loads(response.content.decode("utf-8"))
self.assertFalse(response_data["success"])
def test_getLocalTools(self):
request = self.factory.get('/api/tools/area')
# We need a user to have local tools to browse.
request.session = self.mock_session
response = local_tools(request)
response_data = json.loads(response.content.decode("utf-8"))
self.assertIn(tool_to_json(self.sledge), response_data)
def test_getPersonalTools(self):
request = self.factory.get('/api/tools')
# We need a user to have personal tools to browse.
request.session = self.mock_session
response = user_tools(request)
response_data = json.loads(response.content.decode("utf-8"))
self.assertIn(tool_to_json(self.sledge), response_data)
class ResourceHttpMethodsTestCase(BaseTestCase):
def setUp(self):
super(ResourceHttpMethodsTestCase, self).setUp()
self.factory = RequestFactory()
TestResource = type("TestResource", (Resource,), {"model": Book})
TestResource.preprocess(Api())
self.collection_resource = TestResource(TestResource.as_list_view()["routes"])
self.element_resource = TestResource(TestResource.as_detail_view()["routes"])
def get_response(self, request, resource, params={}, content_type="application/json", status=200):
response = resource.handle_request(request, **params)
assert response.status_code == status, response.status_code
assert content_type in response["Content-Type"], response
if content_type == "application/json":
return simplejson.loads(response.content)
return response.content
def test_show_method(self):
request = self.factory.get("/books/")
self.element_method_test(request, "detail")
def test_update_method(self):
request = self.factory.post("/books/1")
self.element_method_test(request, "update")
request = self.factory.put("/books/1")
self.element_method_test(request, "update")
def test_destroy_method(self):
request = self.factory.delete("/books/")
self.element_method_test(request, "destroy")
def element_method_test(self, request, method):
setattr(self.element_resource, method, element_return_list)
content = self.get_response(request, self.element_resource, params={"pk": 1})
assert isinstance(content, list)
setattr(self.element_resource, method, element_return_str)
content = self.get_response(request, self.element_resource, params={"pk": 1}, content_type="text/html")
assert isinstance(content, str)
setattr(self.element_resource, method, element_return_int)
content = self.get_response(request, self.element_resource, params={"pk": 1}, content_type="text/html")
assert not content
setattr(self.element_resource, method, element_return_dict)
content = self.get_response(request, self.element_resource, params={"pk": 1})
assert isinstance(content, dict)
assert "Objects" not in content
assert "Meta" not in content
setattr(self.element_resource, method, element_return_none)
content = self.get_response(request, self.element_resource, params={"pk": 1}, content_type="text/html")
assert not content
setattr(self.element_resource, method, element_return_queryset)
content = self.get_response(request, self.element_resource, params={"pk": 1})
assert isinstance(content, list)
setattr(self.element_resource, method, element_return_modelinstance)
content = self.get_response(request, self.element_resource, params={"pk": 1})
assert isinstance(content, dict)
assert "Objects" not in content
assert "Meta" not in content
setattr(self.element_resource, method, element_return_valuesset)
content = self.get_response(request, self.element_resource, params={"pk": 1})
assert isinstance(content, list)
setattr(self.element_resource, method, element_return_tuple)
content = self.get_response(
request, self.element_resource, params={"pk": 1}, status=500, content_type="text/html"
)
assert isinstance(content, str)
def test_list_method(self):
def get_response_content(list_function, **kwargs):
self.collection_resource.list = list_function
return self.get_response(request, self.collection_resource, **kwargs)
request = self.factory.get("/books/")
content = get_response_content(list_return_list)
assert isinstance(content, dict)
assert "Objects" in content
assert "Meta" in content
content = get_response_content(list_return_str, content_type="text/html")
assert isinstance(content, str)
content = get_response_content(list_return_int, content_type="text/html")
assert not content
content = get_response_content(list_return_dict)
assert isinstance(content, dict)
assert "Objects" not in content
assert "Meta" not in content
content = get_response_content(list_return_none, content_type="text/html")
assert not content
content = get_response_content(list_return_queryset)
assert isinstance(content, dict)
assert "Objects" in content
assert "Meta" in content
content = get_response_content(list_return_modelinstance)
assert isinstance(content, dict)
assert "Objects" not in content
assert "Meta" not in content
content = get_response_content(list_return_valuesset)
assert isinstance(content, dict)
assert "Objects" in content
content = get_response_content(list_return_tuple, status=500, content_type="text/html")
assert isinstance(content, str)
def test_create_method(self):
def get_response_content(create_function, **kwargs):
self.collection_resource.create = create_function
return self.get_response(request, self.collection_resource, **kwargs)
request = self.factory.post("/books/")
content = get_response_content(create_return_list)
assert isinstance(content, list)
content = get_response_content(create_return_str, content_type="text/html")
assert isinstance(content, str)
content = get_response_content(create_return_int, content_type="text/html")
assert not content
content = get_response_content(create_return_dict)
assert isinstance(content, dict)
assert "Objects" not in content
assert "Meta" not in content
content = get_response_content(create_return_none, content_type="text/html")
assert not content
content = get_response_content(create_return_queryset)
assert isinstance(content, list)
content = get_response_content(create_return_modelinstance)
assert isinstance(content, dict)
content = get_response_content(create_return_valuesset)
assert isinstance(content, list)
content = get_response_content(create_return_tuple, status=500, content_type="text/html")
assert isinstance(content, str)
from django.test.client import encode_multipart, RequestFactory
factory = RequestFactory()
data = {'title': 'remember to email dave'}
content = encode_multipart('BoUnDaRyStRiNg', data)
content_type = 'multipart/form-data; boundary=BoUnDaRyStRiNg'
request = factory.put('/list_nc/', content, content_type=content_type)
class TestRatingResource(BaseSegmentsTest):
"""Tests on RatingResource"""
def setUp(self):
super(TestRatingResource, self).setUp()
self.req = RequestFactory()
def test_parsers(self):
from project.resources import RatingInstanceView, RatingJSONParser
from djangorestframework.parsers import JSONParser
from StringIO import StringIO
self.assertEqual(len(RatingInstanceView.parsers), 4)
self.assertNotIn(JSONParser, RatingInstanceView.parsers)
self.assertIn(RatingJSONParser, RatingInstanceView.parsers)
parser = RatingJSONParser(None) # None for the view
json_string = StringIO(
'{"criterion":3,"question":"How much do you like it?","score":"4","segment":456,"block_index":5239,"url":"http://localhost:8000/ratings/13","id":13}'
)
self.assertNotIn(u'id', parser.parse(json_string))
def test_read(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment = Segment.objects.create(id=123)
rating = Rating.objects.create(criterion=criterion,
segment1=segment,
block1_index=2,
segment2=segment,
block2_index=2,
score=5)
from project.resources import RatingInstanceView
request = self.req.get('/ratings/{}'.format(rating.id))
view = RatingInstanceView()
response = view.get(request, rating.id)
self.assertEquals(rating, response)
def test_delete(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment = Segment.objects.create(id=123)
Rating.objects.all().delete()
rating = Rating.objects.create(criterion=criterion,
segment1=segment,
block1_index=2,
segment2=segment,
block2_index=2,
score=5)
from project.resources import RatingInstanceView
request = self.req.delete('/ratings/{}'.format(rating.id))
view = RatingInstanceView()
response = view.delete(request, rating.id)
assert_equal(Rating.objects.count(), 0)
def test_update(self):
from project.models import Rating, Criterion, Segment
criterion1 = Criterion.objects.create(prompt='Hello?')
criterion2 = Criterion.objects.create(prompt='Goodbye!')
segment1 = Segment.objects.create(id=123)
segment2 = Segment.objects.create(id=456)
rating = Rating.objects.create(criterion=criterion1,
segment1=segment1,
block1_index=2,
segment2=segment1,
block2_index=2,
score=5)
from project.resources import RatingInstanceView
request = self.req.put('/ratings/{}'.format(rating.id),
data={
'segment2': segment2.id,
'block2_index': 14,
'segment1': segment2.id,
'block1_index': 14,
'criterion': criterion2.id,
'score': 2
})
view = RatingInstanceView()
view.request = request
response = view.put(request, rating.id)
self.assertEquals(rating, response)
self.assertEqual(response.criterion, criterion2)
self.assertEqual(response.segment2, segment2)
self.assertEqual(response.block2_index, 14)
self.assertEqual(response.score, 2)
def test_create(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment1 = Segment.objects.create(id=123)
segment2 = Segment.objects.create(id=456)
Rating.objects.all().delete()
from project.resources import RatingListView
request = self.req.post('/ratings/',
data={
'segment1': segment1.id,
'block1_index': 7,
'segment2': segment2.id,
'block2_index': 14,
'criterion': criterion.id,
'score': 2
})
view = RatingListView()
view.request = request
response = view.post(request)
self.assertEquals(Rating.objects.count(), 1)
self.assertEqual(response.cleaned_content.criterion, criterion)
self.assertEqual(response.cleaned_content.segment1, segment1)
self.assertEqual(response.cleaned_content.block1_index, 7)
self.assertEqual(response.cleaned_content.score, 2)
class TagViewTestCase(TestCase):
tags = ('tagging', 'fiware-ut-30')
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create(
username='******',
email='*****@*****.**',
first_name='test',
last_name='user'
)
self.user.set_password('passwd')
def tearDown(self):
reload(views)
TestCase.tearDown(self)
def _get_offering(self, owner_organization=None, name=None, version=None):
if name!= 'test_offering':
raise Exception('')
off_object = MagicMock()
off_object.tags = ['tag3', 'tag4']
return off_object
@parameterized.expand([
({'organization': 'test_org', 'name': 'test_offering', 'version': '1.0'},'recommend', False, ['tag1', 'tag2'], 200),
({'organization': 'test_org', 'name': 'test_offering', 'version': '1.0'}, None, False, ['tag3', 'tag4'], 200),
({'organization': 'test_org', 'name': 'not_found', 'version': '1.0'}, None, True, 'Not found', 404),
({'organization': 'test_org', 'name': 'test_offering', 'version': '1.0'}, 'invalid', True, 'Invalid action', 400)
])
def test_tag_retrieving(self, off_data, action, error, response_content, code):
# Create mocks
org = MagicMock()
org.objects.get = MagicMock()
org.objects.get.return_value = MagicMock()
offering = MagicMock()
offering.objects.get = self._get_offering
rec_manager = MagicMock()
rec_manager_instance = MagicMock()
rec_manager_instance.get_recommended_tags = MagicMock()
rec_manager_instance.get_recommended_tags.return_value = [('tag1', '0.5'),('tag2', '0.5')]
rec_manager.return_value = rec_manager_instance
views.Organization = org
views.Offering = offering
views.RecommendationManager = rec_manager
# Create the view
tag_collection = views.TagCollection(permitted_methods=('GET', 'PUT'))
url = '/api/offering/offerings/' + off_data['organization'] +'/' + off_data['name'] + '/' + off_data['version'] +'/tags'
if action:
url += '?action=' + action
request = self.factory.get(url,HTTP_ACCEPT='application/json; charset=utf-8')
request.user = self.user
# Get HTTP response
response = tag_collection.read(request, off_data['organization'], off_data['name'], off_data['version'])
parsed_response = json.loads(response.content)
# Check response
self.assertEqual(response.status_code, code)
if not error:
self.assertEquals(len(parsed_response['tags']), len(response_content))
for tag in response_content:
self.assertTrue(tag in parsed_response['tags'])
else:
self.assertEqual(parsed_response['message'], response_content)
self.assertEqual(parsed_response['result'], 'error')
@parameterized.expand([
({'organization': 'test_org', 'name': 'test_offering', 'version': '1.0'}, 'correct', 'OK', 200),
({'organization': 'test_org', 'name': 'test_offering', 'version': '1.0'}, 'error', 'Forbidden', 403),
({'organization': 'test_org', 'name': 'not_found', 'version': '1.0'}, 'error', 'Not found', 404),
({'organization': 'test_org', 'name': 'test_offering', 'version': '1.0'}, 'error', 'Exception', 400)
])
def test_tag_update(self, off_data, result, response_content, code):
# Create mocks
org = Organization.objects.create(name='test_org')
offering = MagicMock()
offering.objects.get = self._get_offering
tag_manager = MagicMock()
tag_manager_instance = MagicMock()
tag_manager_instance.update_tags = MagicMock()
if code != 403:
self.user.userprofile.current_organization = org
self.user.userprofile.save()
if code == 400:
tag_manager_instance.update_tags.side_effect = Exception(response_content)
tag_manager.return_value = tag_manager_instance
views.Offering = offering
views.Organization = Organization
views.TagManager = tag_manager
# Create the view
tag_collection = views.TagCollection(permitted_methods=('GET', 'PUT'))
url = '/api/offering/offerings/' + off_data['organization'] +'/' + off_data['name'] + '/' + off_data['version'] +'/tags'
data = {'tags': ['tag1', 'tag2']}
request = self.factory.put(
url,
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
request.user = self.user
response = tag_collection.update(request, off_data['organization'], off_data['name'], off_data['version'])
parsed_response = json.loads(response.content)
# Check response
self.assertEqual(response.status_code, code)
self.assertEqual(parsed_response['message'], response_content)
self.assertEqual(parsed_response['result'], result)
class LoginUserTest(MockedCloudTestCase):
def setUp(self):
super(LoginUserTest, self).setUp()
self.factory = RequestFactory()
# Create an user to check login attempts against
self.existing_user = User.objects.create_user(
username='******', cloud_fqdn='existingserver')
def tearDown(self):
self.existing_user.delete()
def test_login_good_credentials(self):
good_creds = {
'username': '******',
'password': '******',
'cloud_fqdn': 'existingserver',
}
request = self.factory.post(reverse(login_user), data=good_creds)
self.do_session_middleware_stuff(request)
resp = login_user(request)
self.assertEqual(resp.status_code, 200)
def test_login_bad_credentials(self):
bad_creds = {
'username': '******',
'password': '******',
'cloud_fqdn': 'existingserver',
}
request = self.factory.post(reverse(login_user), data=bad_creds)
self.do_session_middleware_stuff(request)
# Set mocked backend to fail authentication
self.set_auth_result(False)
resp = login_user(request)
self.assertEqual(resp.status_code, 401)
def test_login_missing_credentials(self):
missing_creds = {
'username': '******',
'cloud_fqdn': 'existingserver',
}
request = self.factory.post(reverse(login_user), data=missing_creds)
resp = login_user(request)
self.assertEqual(resp.status_code, 400)
def test_login_bad_methods(self):
get_request = self.factory.get(reverse(login_user))
resp = login_user(get_request)
self.assertEqual(resp.status_code, 405)
put_request = self.factory.put(reverse(login_user))
resp = login_user(put_request)
self.assertEqual(resp.status_code, 405)
delete_request = self.factory.delete(reverse(login_user))
resp = login_user(delete_request)
self.assertEqual(resp.status_code, 405)
def test_login_no_persistent_session(self):
good_creds = {
'username': '******',
'password': '******',
'cloud_fqdn': 'existingserver',
'persistent_session': 'False'
}
resp = self.client.post(reverse(login_user), good_creds)
self.assertEqual(resp.status_code, 200)
session_cookie = self.client.cookies['sessionid']
self.assertEqual(session_cookie['expires'], "")
class ResourceEntryTestCase(TestCase):
tags = ('offering-api',)
def setUp(self):
# Create request factory
self.factory = RequestFactory()
# Create testing user
self.user = User.objects.create_user(username='******', email='', password='******')
self.user.userprofile.get_current_roles = MagicMock(name='get_current_roles')
self.user.userprofile.get_current_roles.return_value = ['provider', 'customer']
self.user.userprofile.save()
# Create resource model mock
self.resource = MagicMock()
self.resource.provider = self.user.userprofile.current_organization
views.OfferingResource = MagicMock()
views.OfferingResource.objects.get.return_value = self.resource
@classmethod
def tearDownClass(cls):
from wstore.offerings import offerings_management
reload(offerings_management)
reload(views)
super(ResourceEntryTestCase, cls).tearDownClass()
def tearDown(self):
views.json = json
def _not_found(self):
views.OfferingResource.objects.get.side_effect = Exception('Not found')
def _no_provider(self):
self.user.userprofile.get_current_roles.return_value = ['customer']
def _exception_update(self):
views.update_resource.side_effect = Exception('Exception in call')
def _exception_upgrade(self):
views.upgrade_resource.side_effect = Exception('Exception in call')
def _exception_delete(self):
views.delete_resource.side_effect = Exception('Exception in call')
def _invalid_json(self):
views.json = MagicMock()
views.json.loads.side_effect = Exception('Invalid content')
@parameterized.expand([
(RESOURCE_DATA, 200, 'OK'),
(RESOURCE_DATA, 400, 'Invalid content', _invalid_json, 'error'),
(RESOURCE_DATA, 403, 'Forbidden', _no_provider, 'error'),
(RESOURCE_DATA, 400, 'Exception in call', _exception_update, 'error')
])
def test_resource_update_api(self, data, code, msg, side_effect=None, status='correct'):
views.update_resource = MagicMock(name='update_resource')
if side_effect:
side_effect(self)
request = self.factory.put(
'/api/offering/resources/test_user/test_resource/1.0',
json.dumps(data),
content_type='application/json',
HTTP_ACCEPT='application/json'
)
request.user = self.user
res_entry = views.ResourceEntry(permitted_methods=('PUT', 'POST', 'DELETE'))
response = res_entry.update(request, 'test_user', 'test_resource', '1.0')
self.assertEqual(response.status_code, code)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEquals(type(body_response), dict)
self.assertEquals(body_response['message'], msg)
self.assertEquals(body_response['result'], status)
# Check call to update method if needed
if status != 'error':
views.update_resource.assert_called_once_with(self.resource, self.user, data)
@parameterized.expand([
(RESOURCE_DATA, 200, 'OK'),
(RESOURCE_DATA, 200, 'OK', True),
(RESOURCE_DATA, 400, 'Invalid content', False, _invalid_json, True),
(RESOURCE_DATA, 400, 'Invalid content', True, _invalid_json, True),
(RESOURCE_DATA, 404, 'Resource not found', False, _not_found, True),
(RESOURCE_DATA, 403, 'Forbidden', False, _no_provider, True),
(RESOURCE_DATA, 400, 'Exception in call', False, _exception_upgrade, True)
])
def test_resource_upgrade_api(self, data, code, msg, file_=False, side_effect=None, error=False):
# Mock update method
views.upgrade_resource = MagicMock(name='upgrade_resource')
if side_effect:
side_effect(self)
content = json.dumps(data)
content_type = 'application/json'
if file_:
f = StringIO()
f.name = 'test_file.txt'
f.write('test file')
content = {
'json': json.dumps(data),
'file': f
}
content_type = MULTIPART_CONTENT
request = self.factory.post(
'/api/offering/resources/test_user/test_resource/1.0',
content,
content_type=content_type,
HTTP_ACCEPT='application/json'
)
request.user = self.user
res_entry = views.ResourceEntry(permitted_methods=('PUT', 'POST', 'DELETE'))
response = res_entry.create(request, 'test_user', 'test_resource', '1.0')
self.assertEqual(response.status_code, code)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], msg)
if not error:
if not file_:
views.upgrade_resource.assert_called_once_with(self.resource, self.user, data)
else:
expected_file = request.FILES['file'] # The type change when loaded
views.upgrade_resource.assert_called_once_with(self.resource, self.user, data, expected_file)
self.assertEqual(body_response['result'], 'correct')
else:
self.assertEqual(body_response['result'], 'error')
@parameterized.expand([
(204, 'No Content'),
(404, 'Resource not found', _not_found, True),
(403, 'Forbidden', _no_provider, True),
(400, 'Exception in call', _exception_delete, True)
])
def test_resource_deletion_api(self, code, msg, side_effect=None, error=False):
# Mock delete resource method
views.delete_resource = MagicMock(name='delete_resource')
if side_effect:
side_effect(self)
request = self.factory.delete(
'/api/offering/resources/test_user/test_resource/1.0',
HTTP_ACCEPT='application/json'
)
request.user = self.user
res_entry = views.ResourceEntry(permitted_methods=('POST', 'DELETE'))
response = res_entry.delete(request, 'test_user', 'test_resource', '1.0')
self.assertEqual(response.status_code, code)
self.assertEqual(response.get('Content-type'), 'application/json; charset=utf-8')
body_response = json.loads(response.content)
self.assertEqual(type(body_response), dict)
self.assertEqual(body_response['message'], msg)
if not error:
views.delete_resource.assert_called_once_with(self.resource, self.user)
self.assertEqual(body_response['result'], 'correct')
else:
self.assertEqual(body_response['result'], 'error')
class TestBulkAPIView(TestCase):
def setUp(self):
super(TestBulkAPIView, self).setUp()
self.view = SimpleBulkAPIView.as_view()
self.request = RequestFactory()
def test_get(self):
"""
Test that GET request is successful on bulk view.
"""
response = self.view(self.request.get(''))
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_post_single(self):
"""
Test that POST request with single resource only creates a single resource.
"""
response = self.view(
self.request.post(
'',
json.dumps({
'contents': 'hello world',
'number': 1
}),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(SimpleModel.objects.count(), 1)
self.assertEqual(SimpleModel.objects.get().contents, 'hello world')
def test_post_bulk(self):
"""
Test that POST request with multiple resources creates all posted resources.
"""
response = self.view(
self.request.post(
'',
json.dumps([
{
'contents': 'hello world',
'number': 1
},
{
'contents': 'hello mars',
'number': 2
},
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(
list(SimpleModel.objects.all().values_list('contents', flat=True)),
[
'hello world',
'hello mars',
])
def test_put(self):
"""
Test that PUT request updates all submitted resources.
"""
obj1 = SimpleModel.objects.create(contents='hello world', number=1)
obj2 = SimpleModel.objects.create(contents='hello mars', number=2)
response = self.view(
self.request.put(
'',
json.dumps([
{
'contents': 'foo',
'number': 3,
'id': obj1.pk
},
{
'contents': 'bar',
'number': 4,
'id': obj2.pk
},
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(
list(SimpleModel.objects.all().values_list('id', 'contents',
'number')), [
(obj1.pk, 'foo', 3),
(obj2.pk, 'bar', 4),
])
def test_put_without_update_key(self):
"""
Test that PUT request updates all submitted resources.
"""
response = self.view(
self.request.put(
'',
json.dumps([
{
'contents': 'foo',
'number': 3
},
{
'contents': 'rainbows',
'number': 4
}, # multiple objects without id
{
'contents': 'bar',
'number': 4,
'id': 555
}, # non-existing id
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_patch(self):
"""
Test that PATCH request partially updates all submitted resources.
"""
obj1 = SimpleModel.objects.create(contents='hello world', number=1)
obj2 = SimpleModel.objects.create(contents='hello mars', number=2)
response = self.view(
self.request.patch(
'',
json.dumps([
{
'contents': 'foo',
'id': obj1.pk
},
{
'contents': 'bar',
'id': obj2.pk
},
]),
content_type='application/json',
))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(SimpleModel.objects.count(), 2)
self.assertEqual(
list(SimpleModel.objects.all().values_list('id', 'contents',
'number')), [
(obj1.pk, 'foo', 1),
(obj2.pk, 'bar', 2),
])
def test_delete_not_filtered(self):
"""
Test that DELETE is not allowed when results are not filtered.
"""
SimpleModel.objects.create(contents='hello world', number=1)
SimpleModel.objects.create(contents='hello mars', number=10)
response = self.view(self.request.delete(''))
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_delete_filtered(self):
"""
Test that DELETE removes all filtered resources.
"""
SimpleModel.objects.create(contents='hello world', number=1)
SimpleModel.objects.create(contents='hello mars', number=10)
response = FilteredBulkAPIView.as_view()(self.request.delete(''))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(SimpleModel.objects.count(), 1)
self.assertEqual(SimpleModel.objects.get().contents, 'hello world')
def test_options(self):
"""
Test that OPTIONS request is successful on bulk view.
"""
response = self.view(self.request.options(''))
self.assertEqual(response.status_code, status.HTTP_200_OK)
class TestRatingResource(BaseSegmentsTest):
"""Tests on RatingResource"""
def setUp(self):
super(TestRatingResource, self).setUp()
self.req = RequestFactory()
def test_parsers(self):
from project.resources import RatingInstanceView, RatingJSONParser
from djangorestframework.parsers import JSONParser
from StringIO import StringIO
self.assertEqual(len(RatingInstanceView.parsers), 4)
self.assertNotIn(JSONParser, RatingInstanceView.parsers)
self.assertIn(RatingJSONParser, RatingInstanceView.parsers)
parser = RatingJSONParser(None) # None for the view
json_string = StringIO('{"criterion":3,"question":"How much do you like it?","score":"4","segment":456,"block_index":5239,"url":"http://localhost:8000/ratings/13","id":13}')
self.assertNotIn(u'id', parser.parse(json_string))
def test_read(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment = Segment.objects.create(id=123)
rating = Rating.objects.create(criterion=criterion, segment1=segment, block1_index=2, segment2=segment, block2_index=2, score=5)
from project.resources import RatingInstanceView
request = self.req.get('/ratings/{}'.format(rating.id))
view = RatingInstanceView()
response = view.get(request, rating.id)
self.assertEquals(rating, response)
def test_delete(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment = Segment.objects.create(id=123)
Rating.objects.all().delete()
rating = Rating.objects.create(criterion=criterion, segment1=segment, block1_index=2, segment2=segment, block2_index=2, score=5)
from project.resources import RatingInstanceView
request = self.req.delete('/ratings/{}'.format(rating.id))
view = RatingInstanceView()
response = view.delete(request, rating.id)
assert_equal(Rating.objects.count(), 0)
def test_update(self):
from project.models import Rating, Criterion, Segment
criterion1 = Criterion.objects.create(prompt='Hello?')
criterion2 = Criterion.objects.create(prompt='Goodbye!')
segment1 = Segment.objects.create(id=123)
segment2 = Segment.objects.create(id=456)
rating = Rating.objects.create(criterion=criterion1, segment1=segment1, block1_index=2, segment2=segment1, block2_index=2, score=5)
from project.resources import RatingInstanceView
request = self.req.put('/ratings/{}'.format(rating.id), data={
'segment2': segment2.id,
'block2_index': 14,
'segment1': segment2.id,
'block1_index': 14,
'criterion': criterion2.id,
'score': 2})
view = RatingInstanceView()
view.request = request
response = view.put(request, rating.id)
self.assertEquals(rating, response)
self.assertEqual(response.criterion, criterion2)
self.assertEqual(response.segment2, segment2)
self.assertEqual(response.block2_index, 14)
self.assertEqual(response.score, 2)
def test_create(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment1 = Segment.objects.create(id=123)
segment2 = Segment.objects.create(id=456)
Rating.objects.all().delete()
from project.resources import RatingListView
request = self.req.post('/ratings/', data={
'segment1': segment1.id,
'block1_index': 7,
'segment2': segment2.id,
'block2_index': 14,
'criterion': criterion.id,
'score': 2})
view = RatingListView()
view.request = request
response = view.post(request)
self.assertEquals(Rating.objects.count(), 1)
self.assertEqual(response.cleaned_content.criterion, criterion)
self.assertEqual(response.cleaned_content.segment1, segment1)
self.assertEqual(response.cleaned_content.block1_index, 7)
self.assertEqual(response.cleaned_content.score, 2)
class WindowSizeTests(TestCase):
def setUp(self):
# Every test needs access to the request factory.
self.factory = RequestFactory()
info_manager = InfoManager.InfoManager()
info_manager.init_information()
serverInfoMock = mock()
tenantInfoMock = mock()
tenantQuery = Models.TenantInfo.objects.create(tenantId="tenantId",
windowsize=5)
when(serverInfoMock).objects().thenReturn(serverInfoMock)
when(tenantInfoMock).objects().thenReturn(tenantInfoMock)
when(tenantInfoMock).get(
tenantId__exact="tenantId").thenReturn(tenantQuery)
info_manager.setInformations(serverInfoMock, tenantInfoMock)
myMock = mock()
mockedInfo = information.information("test", "test", "test",
datetime.datetime.now(), "test")
validWindowSize = "4"
validWindowSizeValue = 5
invalidWindowSize = "notValidValue"
when(myMock).updateWindowSize(
"tenantId", validWindowSizeValue).thenReturn(mockedInfo)
when(myMock).updateWindowSize("tenantId",
invalidWindowSize).thenReturn(None)
when(myMock).parse("{\"windowsize\": %s}" %
validWindowSize).thenReturn(mockedInfo)
when(myMock).parse("{\"windowsize\": %s}" %
invalidWindowSize).thenReturn(None)
self.general = GeneralView()
@patch('cloto.manager.InfoManager.logger')
def test_update_window(self, mock_logging):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": 4}",
"application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 200)
self.assertTrue(mock_logging.info.called)
def test_not_update_window(self):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/',
"{\"windowsize\": notValidValue}",
"application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 400)
def test_not_update_window2(self):
# Create an instance of a GET request.
request = self.factory.put('/v1.0/tenantId/', "{\"windowsize\": -1}",
"application/json")
# Test my_view() as if it were deployed at /customer/details
response = self.general.PUT(request, "tenantId")
self.assertEqual(response.status_code, 400)
class UserApiTestCase(TestCase):
def setUp(self):
# Set up a Request Factory
self.factory = RequestFactory()
# Set up some Users
self.john = User.create_new_user(
u = 'John',
p = 'hehehe',
zip_c = '00413',
e = '*****@*****.**',
pn = '4134131996',
pa = 'mailbox',
)
self.john.save()
# Mock session, where applicable
self.mock_session = \
{
"user" : api.user_to_json(self.john)
}
# Session with no data
self.empty_session = { }
# Accurate login credentials
self.good_login = \
{
'username' : self.john.username,
'password' : "hehehe",
}
# New user form
self.add_jade = \
{
'username' : "Jade",
'password' : "tanglebuddies",
'confirm_password' : "tanglebuddies",
'zip_code' : '00413',
'email' : "*****@*****.**",
'phone_number' : "4131211995",
'default_pickup_arrangements' : "time shenanigans",
}
# Change user form
self.edit_john = \
{
'zip_code' : '00612',
'email' : "*****@*****.**",
'phone_number' : '4134132009',
'default_pickup_arrangements' : "parcel pixys",
}
def test_getSelf(self):
# Generate the request
request = self.factory.get('/api/user/')
request.session = self.mock_session
response = api.user(request)
# Did we get a clean response?
self.assertEqual(response.status_code, 200)
# Did we get the right data?
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["id"], self.john.id)
self.assertEqual(response_data["username"], self.john.username)
self.assertEqual(response_data["zip_code"], self.john.zip_code)
self.assertEqual(response_data["email"], self.john.email)
self.assertEqual(response_data["phone_number"],
self.john.phone_number)
self.assertEqual(response_data["default_pickup_arrangements"],
self.john.default_pickup_arrangements)
self.assertEqual(response_data["is_shed_coordinator"],
self.john.is_shed_coordinator)
self.assertEqual(response_data["is_admin"], self.john.is_admin)
def test_login(self):
# Generate the request
request = self.factory.post(
path = '/api/login/',
data = json.dumps(self.good_login),
content_type = "application/json",
)
request.session = self.empty_session
response = api.login(request)
# Did we get a clean response?
self.assertEqual(response.status_code, 200)
# Did we get the right data?
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["id"], self.john.id)
self.assertEqual(response_data["username"], self.john.username)
self.assertEqual(response_data["zip_code"], self.john.zip_code)
self.assertEqual(response_data["email"], self.john.email)
self.assertEqual(response_data["phone_number"],
self.john.phone_number)
self.assertEqual(response_data["default_pickup_arrangements"],
self.john.default_pickup_arrangements)
self.assertEqual(response_data["is_shed_coordinator"],
self.john.is_shed_coordinator)
self.assertEqual(response_data["is_admin"], self.john.is_admin)
def test_createNewUser(self):
# Generate the request
request = self.factory.post(
path = '/api/user/',
data = json.dumps(self.add_jade),
content_type = "application/json",
)
request.session = self.empty_session
response = api.user(request)
# Did we get a clean response?
self.assertEqual(response.status_code, 200)
# Did we get the right data?
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data['username'],
self.add_jade['username'])
self.assertEqual(response_data['zip_code'],
self.add_jade['zip_code'])
self.assertEqual(response_data['email'], self.add_jade['email'])
self.assertEqual(response_data['phone_number'],
self.add_jade['phone_number'])
self.assertEqual(response_data['default_pickup_arrangements'],
self.add_jade['default_pickup_arrangements'])
# We don't know the ID, but we know it has to be different.
self.assertNotEqual(response_data['id'], self.john.id)
# Only the first user in each zone should be the coordinator.
self.assertNotEqual(response_data['is_shed_coordinator'],
self.john.is_shed_coordinator)
# New users should not be admins by default.
self.assertEqual(response_data['is_admin'],
False)
def test_userProfileEdit(self):
# Generate the request
request = self.factory.put(
path = '/api/user/',
data = json.dumps(self.edit_john),
content_type = "application/json",
)
request.session = self.mock_session
response = api.userById(request, self.john.id)
# Did we get a clean response?
self.assertIsNotNone(response)
self.assertEqual(response.status_code, 200)
# Did the data change?
response_data = json.loads(response.content.decode("utf-8"))
self.assertEqual(response_data["id"], self.john.id)
self.assertEqual(response_data["username"], self.john.username)
self.assertNotEqual(response_data["zip_code"], self.john.zip_code)
self.assertNotEqual(response_data["email"], self.john.email)
self.assertNotEqual(response_data["phone_number"],
self.john.phone_number)
self.assertNotEqual(response_data["default_pickup_arrangements"],
self.john.default_pickup_arrangements)
#self.assertEqual(response_data["is_shed_coordinator"],
# self.john.is_shed_coordinator)
self.assertEqual(response_data["is_admin"], self.john.is_admin)
@unittest.skip #not ready yet
def test_deleteUserProfile(self):
request = self.factory.delete('/api/user/:id')
@unittest.skip #not ready yet
def test_getUsersInZipcode(self):
request = self.factory.get('/api/user/zip/:zip_code')
@unittest.skip #not ready yet
def test_changePassword(self):
request = self.factory.put('/api/changePassword')
@unittest.skip #not ready yet
def test_logout(self):
request = self.factory.get('/api/user/logout')
@unittest.skip #not ready yet
def test_getAdmins(self):
request = self.factory.get('/api/admins')
@unittest.skip #not ready yet
def test_changeShedCoordinator(self):
request = self.factory.put('/api/admin/shedCoordinator')
class BorrowTransactionApiTestCase(TestCase):
def setUp(self):
# Set up a Request Factory
self.factory = RequestFactory()
# Make some basic objects to play with.
self.parrot = User.create_new_user( "Parrot",
"password",
"03545",
"*****@*****.**",
"1234567890",
"Pining for the fjords."
)
self.penguin = User.create_new_user( 'Penguin',
'password',
'03545',
'*****@*****.**',
'5555551234',
'It\'s on the telly.')
self.polarbear = User.create_new_user( 'Polarbear',
'password',
'00000',
'*****@*****.**',
'5555551234',
'Pick it up at the north pole'
)
self.nail = Tool.create_new_tool( "Rusty Nail",
toolownerID = self.parrot.id,
tooldescription = "Holding up a stuffed parrot",
tooltype = "nail",
toolshed = False,
pickup_info = "Rip it out of the cage.",
tool_available= True
)
self.zilly = Tool.create_new_tool( "Warhammer of Zillyhoo",
toolownerID = self.parrot.id,
tooldescription = "Its majesty makes you weep.",
tooltype = "hammer",
toolshed = False,
pickup_info = "Some time travel required.",
tool_available= True
)
self.scraper = Tool.create_new_tool( "Ice Scraper",
toolownerID = self.penguin.id,
tooldescription = "An ice scraper for your car",
tooltype = "ice scraper",
toolshed = False,
pickup_info = "Pick it up at the south pole.",
tool_available= True
)
#cutting this out in case we lose points for that dumb runtime warning
@unittest.skip
def test_requestBorrowTransaction(self):
# Penguin borrows nail from parrot
jsondata = {
'toolId' : self.nail.id,
'borrower_message' : "i need dis",
# NOTE: Python throws a nasty runtime error here because it
# can't tell whether the milliseconds are timezone-aware.
# Nothing I can do about this, just ignore the warning.
'date' : dt_to_milliseconds(timezone.datetime(
year = 3000,
month = 4,
day = 13,
)),
}
request = self.factory.post(
path = '/api/borrowTransaction',
data = json.dumps(jsondata),
content_type = "application/json",
)
request.session = {
'user' : {
'id' : self.penguin.id
}
}
response = api.borrowTransaction(request)
#print(response.content)
self.assertEqual(response.status_code, 200)
"""
@unittest.skip # this is not actually required behavior
def test_requestBorrowTransaction_differentzones(self):
# Polar bear borrows ice scraper from penguin
# note that polar bears and penguins do not live in the same
# place
jsondata = {
'toolId' : self.scraper.id,
'borrower_message' : "i need dis",
'date' : dt_to_milliseconds(timezone.datetime(
tzinfo = timezone.UTC,
year = 3000,
month = 4,
day = 13,
)),
}
request = self.factory.post(
path = '/api/borrowTransaction',
data = json.dumps(jsondata),
content_type = "application/json",
)
request.session = {
'user' : {
'id' : self.polarbear.id
}
}
response = api.borrowTransaction(request)
#print(response.content)
self.assertNotEqual(response.status_code, 200)
"""
@unittest.skip #not ready yet
def test_getUnresolvedBorrowTransactions(self):
request = self.factory.get(
path = '/api/borrowTransaction/requestPending'
)
@unittest.skip #not ready yet
def test_resolveBorrowRequest(self):
request = self.factory.post('/api/borrowTransaction/resolve')
@unittest.skip #not ready yet
def test_getRejectedRequests(self):
request = self.factory.get(
path = '/api/borrowTransaction/rejected/:id'
)
@unittest.skip #not ready yet
def test_requestEndBorrowTransaction(self):
request = self.factory.put('/api/borrowTransaction')
@unittest.skip #not ready yet
def test_getEndBorrowTransactionRequests(self):
request = self.factory.get(
path = '/api/borrowTransaction/endRequests'
)
@unittest.skip #not ready yet
def test_resolveEndBorrowTransaction(self):
request = self.factory.delete(
path = '/api/borrowTransaction/:transactionId'
)
@unittest.skip #not ready yet
def test_getToolsUserIsBorrowing(self):
request = self.factory.put(
path = '/api/borrowTransaction/borrowing/:userId'
)
@unittest.skip #not ready yet
def test_getToolsUserIsLending(self):
request = self.factory.get(
path = '/api/borrowTransaction/borrowed/:userId'
)
@unittest.skip #not ready yet
def test_getAllCommunityHistory(self):
request = self.factory.get(
path = '/api/borrowTransaction/community/:zip'
)
@unittest.skip #not ready yet
def test_getAllReturnPendingBorrowTransactionsInCommunityShed(self):
request = self.factory.get(
path = '/api/borrowTransaction/pendingCommunity'
)
class TestRatingResource(TestCase):
"""Tests on RatingResource"""
def setUp(self):
super(TestRatingResource, self).setUp()
# Create the segments table manually, since we're not managing it with
# the ORM. This SQL comes from running ``manage.py sqlall project`` at
# the command line.
segments_table_sql = """
CREATE TABLE "philly_street_osm_line" (
"osm_id" integer NOT NULL PRIMARY KEY
)
;
SELECT AddGeometryColumn('philly_street_osm_line', 'way', 900913, 'LINESTRING', 2);
CREATE INDEX "philly_street_osm_line_way_id" ON "philly_street_osm_line" USING GIST ( "way" GIST_GEOMETRY_OPS );
COMMIT;
"""
from django.db import connection
cursor = connection.cursor()
cursor.execute(segments_table_sql)
from project.models import Segment
Segment.objects.all().delete()
self.req = RequestFactory()
def tearDown(self):
super(TestRatingResource, self).tearDown()
from django.db import connection
cursor = connection.cursor()
cursor.execute("""
DROP TABLE philly_street_osm_line;
COMMIT;
""")
def test_parsers(self):
from project.resources import RatingInstanceView, RatingJSONParser
from djangorestframework.parsers import JSONParser
from StringIO import StringIO
self.assertEqual(len(RatingInstanceView.parsers), 4)
self.assertNotIn(JSONParser, RatingInstanceView.parsers)
self.assertIn(RatingJSONParser, RatingInstanceView.parsers)
parser = RatingJSONParser(None) # None for the view
json_string = StringIO('{"criterion":3,"question":"How much do you like it?","score":"4","segment":456,"block_index":5239,"url":"http://localhost:8000/ratings/13","id":13}')
self.assertNotIn(u'id', parser.parse(json_string))
def test_read(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment = Segment.objects.create(id=123)
rating = Rating.objects.create(criterion=criterion, segment1=segment, block1_index=2, segment2=segment, block2_index=2, score=5)
from project.resources import RatingInstanceView
request = self.req.get('/ratings/{}'.format(rating.id))
view = RatingInstanceView()
response = view.get(request, rating.id)
self.assertEquals(rating, response)
def test_delete(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment = Segment.objects.create(id=123)
rating = Rating.objects.create(criterion=criterion, segment1=segment, block1_index=2, segment2=segment, block2_index=2, score=5)
assert_equal(Rating.objects.count(), 1)
from project.resources import RatingInstanceView
request = self.req.delete('/ratings/{}'.format(rating.id))
view = RatingInstanceView()
response = view.delete(request, rating.id)
assert_equal(Rating.objects.count(), 0)
def test_update(self):
from project.models import Rating, Criterion, Segment
criterion1 = Criterion.objects.create(prompt='Hello?')
criterion2 = Criterion.objects.create(prompt='Goodbye!')
segment1 = Segment.objects.create(id=123)
segment2 = Segment.objects.create(id=456)
rating = Rating.objects.create(criterion=criterion1, segment1=segment1, block1_index=2, segment2=segment1, block2_index=2, score=5)
from project.resources import RatingInstanceView
request = self.req.put('/ratings/{}'.format(rating.id), data={
'segment2': segment2.id,
'block2_index': 14,
'segment1': segment2.id,
'block1_index': 14,
'criterion': criterion2.id,
'score': 2})
view = RatingInstanceView()
view.request = request
response = view.put(request, rating.id)
self.assertEquals(rating, response)
self.assertEqual(response.criterion, criterion2)
self.assertEqual(response.segment2, segment2)
self.assertEqual(response.block2_index, 14)
self.assertEqual(response.score, 2)
def test_create(self):
from project.models import Rating, Criterion, Segment
criterion = Criterion.objects.create(prompt='Hello?')
segment1 = Segment.objects.create(id=123)
segment2 = Segment.objects.create(id=456)
assert_equal(Rating.objects.count(), 0)
from project.resources import RatingListView
request = self.req.post('/ratings/', data={
'segment1': segment1.id,
'block1_index': 7,
'segment2': segment2.id,
'block2_index': 14,
'criterion': criterion.id,
'score': 2})
view = RatingListView()
view.request = request
response = view.post(request)
self.assertEquals(Rating.objects.count(), 1)
self.assertEqual(response.cleaned_content.criterion, criterion)
self.assertEqual(response.cleaned_content.segment1, segment1)
self.assertEqual(response.cleaned_content.block1_index, 7)
self.assertEqual(response.cleaned_content.score, 2)
