mirror of
https://github.com/ansible/awx.git
synced 2024-11-01 08:21:15 +03:00
258 lines
10 KiB
Python
258 lines
10 KiB
Python
# FIXME: do not use ResourceTestCase
|
|
|
|
"""
|
|
This file demonstrates two different styles of tests (one doctest and one
|
|
unittest). These will both pass when you run "manage.py test".
|
|
|
|
Replace these with more appropriate tests for your application.
|
|
"""
|
|
|
|
|
|
import datetime
|
|
import json
|
|
|
|
from django.contrib.auth.models import User as DjangoUser
|
|
import django.test
|
|
from django.test.client import Client
|
|
|
|
from lib.main.models import User, Organization, Project
|
|
|
|
class BaseTest(django.test.TestCase):
|
|
|
|
def make_user(self, username, password, super_user=False):
|
|
django_user = None
|
|
if super_user:
|
|
django_user = DjangoUser.objects.create_superuser(username, "%s@example.com", password)
|
|
else:
|
|
django_user = DjangoUser.objects.create_user(username, "%s@example.com", password)
|
|
acom_user = User.objects.create(name=username, auth_user=django_user)
|
|
return (django_user, acom_user)
|
|
|
|
def make_organizations(self, count=1):
|
|
results = []
|
|
for x in range(0, count):
|
|
results.append(Organization.objects.create(name="org%s" % x, description="org%s" % x))
|
|
return results
|
|
|
|
def check_pagination_and_size(self, data, desired_count, previous=None, next=None):
|
|
self.assertEquals(data['count'], desired_count)
|
|
self.assertEquals(data['previous'], previous)
|
|
self.assertEquals(data['next'], next)
|
|
|
|
def setup_users(self):
|
|
# Create a user.
|
|
self.super_username = 'admin'
|
|
self.super_password = 'admin'
|
|
self.normal_username = 'normal'
|
|
self.normal_password = 'normal'
|
|
self.other_username = 'other'
|
|
self.other_password = 'other'
|
|
|
|
(self.super_django_user, self.super_acom_user) = self.make_user(self.super_username, self.super_password, super_user=True)
|
|
(self.normal_django_user, self.normal_acom_user) = self.make_user(self.normal_username, self.normal_password, super_user=False)
|
|
(self.other_django_user, self.other_acom_user) = self.make_user(self.other_username, self.other_password, super_user=False)
|
|
|
|
def get_super_credentials(self):
|
|
return (self.super_username, self.super_password)
|
|
|
|
def get_normal_credentials(self):
|
|
return (self.normal_username, self.normal_password)
|
|
|
|
def get_other_credentials(self):
|
|
return (self.other_username, self.other_password)
|
|
|
|
def get_invalid_credentials(self):
|
|
return ('random', 'combination')
|
|
|
|
def _generic_rest(self, url, data=None, expect=204, auth=None, method=None):
|
|
assert method is not None
|
|
if method != 'get':
|
|
assert data is not None
|
|
client = Client()
|
|
if auth:
|
|
client.login(username=auth[0], password=auth[1])
|
|
method = getattr(client,method)
|
|
response = None
|
|
if data is not None:
|
|
response = method(url, data=json.dumps(data))
|
|
else:
|
|
response = method(url)
|
|
if response.status_code == 500 and expect != 500:
|
|
assert False, "Failed: %s" % response.content
|
|
if expect is not None:
|
|
assert response.status_code == expect, "expected status %s, got %s for url=%s as auth=%s" % (expect, response.status_code, url, auth)
|
|
data = json.loads(response.content)
|
|
return data
|
|
|
|
def get(self, url, expect=200, auth=None):
|
|
return self._generic_rest(url, data=None, expect=expect, auth=auth, method='get')
|
|
|
|
def post(self, url, expect=204, auth=None):
|
|
return self._generic_rest(url, data=None, expect=expect, auth=auth, method='post')
|
|
|
|
def put(self, url, expect=200, auth=None):
|
|
return self._generic_rest(url, data=None, expect=expect, auth=auth, method='put')
|
|
|
|
def delete(self, url, expect=201, auth=None):
|
|
return self._generic_rest(url, data=None, expect=expect, auth=auth, method='delete')
|
|
|
|
class OrganizationsTest(BaseTest):
|
|
|
|
def collection(self):
|
|
return '/api/v1/organizations/'
|
|
|
|
def setUp(self):
|
|
self.setup_users()
|
|
self.organizations = self.make_organizations(10)
|
|
self.a_detail_url = "%s%s" % (self.collection(), self.organizations[0].pk)
|
|
self.b_detail_url = "%s%s" % (self.collection(), self.organizations[1].pk)
|
|
self.c_detail_url = "%s%s" % (self.collection(), self.organizations[2].pk)
|
|
|
|
# configuration:
|
|
# admin_user is an admin and regular user in all organizations
|
|
# other_user is all organizations
|
|
# normal_user is a user in organization 0, and an admin of organization 1
|
|
|
|
for x in self.organizations:
|
|
# NOTE: superuser does not have to be explicitly added to admin group
|
|
# x.admins.add(self.super_acom_user)
|
|
x.users.add(self.super_acom_user)
|
|
x.users.add(self.other_acom_user)
|
|
|
|
self.organizations[0].users.add(self.normal_acom_user)
|
|
self.organizations[0].users.add(self.normal_acom_user)
|
|
self.organizations[1].admins.add(self.normal_acom_user)
|
|
|
|
def test_get_list_unauthorzied(self):
|
|
|
|
# no credentials == 401
|
|
self.get(self.collection(), expect=401)
|
|
|
|
# wrong credentials == 401
|
|
self.get(self.collection(), expect=401, auth=self.get_invalid_credentials())
|
|
|
|
# superuser credentials == 200, full list
|
|
data = self.get(self.collection(), expect=200, auth=self.get_super_credentials())
|
|
self.check_pagination_and_size(data, 10, previous=None, next=None)
|
|
[self.assertTrue(key in data['results'][0]) for key in ['name', 'description', 'url' ]]
|
|
|
|
# normal credentials == 200, get only organizations that I am actually added to (there are 2)
|
|
data = self.get(self.collection(), expect=200, auth=self.get_normal_credentials())
|
|
self.check_pagination_and_size(data, 2, previous=None, next=None)
|
|
|
|
# no admin rights? get empty list
|
|
#resp = self.api_client.get(self.collection(), format='json', authentication=self.get_other_credentials())
|
|
#self.assertValidJSONResponse(resp)
|
|
#self.assertEqual(len(self.deserialize(resp)['objects']), 0)
|
|
|
|
def test_get_item(self):
|
|
return
|
|
|
|
# no credentials == 401
|
|
#self.assertHttpUnauthorized(self.api_client.get(self.a_detail_url, format='json'))
|
|
|
|
# wrong crendentials == 401
|
|
#self.assertHttpUnauthorized(self.api_client.get(self.c_detail_url, format='json', authentication=self.get_invalid_credentials())
|
|
|
|
# superuser credentials ==
|
|
pass
|
|
|
|
|
|
def test_get_item_subobjects_projects(self):
|
|
pass
|
|
|
|
def test_get_item_subobjects_users(self):
|
|
pass
|
|
|
|
def test_get_item_subobjects_admins(self):
|
|
pass
|
|
|
|
def test_post_item(self):
|
|
pass
|
|
|
|
def test_post_item_subobjects_projects(self):
|
|
pass
|
|
|
|
def test_post_item_subobjects_users(self):
|
|
pass
|
|
|
|
def test_post_item_subobjects_admins(self):
|
|
pass
|
|
|
|
def test_put_item(self):
|
|
pass
|
|
|
|
def test_put_item_subobjects_projects(self):
|
|
pass
|
|
|
|
def test_put_item_subobjects_users(self):
|
|
pass
|
|
|
|
def test_put_item_subobjects_admins(self):
|
|
pass
|
|
|
|
def test_delete_item(self):
|
|
pass
|
|
|
|
def test_delete_item_subobjects_projects(self):
|
|
pass
|
|
|
|
def test_delete_item_subobjects_users(self):
|
|
pass
|
|
|
|
def test_delete_item_subobjects_admins(self):
|
|
pass
|
|
|
|
# def test_get_list_xml(self):
|
|
# self.assertValidXMLResponse(self.api_client.get(self.collection(), format='xml', authentication=self.get_normal_credentials()))
|
|
#
|
|
# def test_get_detail_unauthenticated(self):
|
|
#
|
|
# def test_get_detail_json(self):
|
|
# resp = self.api_client.get(self.detail_url, format='json', authentication=self.get_credentials())
|
|
# self.assertValidJSONResponse(resp)
|
|
#
|
|
# # We use ``assertKeys`` here to just verify the keys, not all the data.
|
|
# self.assertKeys(self.deserialize(resp), ['created', 'slug', 'title', 'user'])
|
|
# self.assertEqual(self.deserialize(resp)['name'], 'First post')
|
|
#
|
|
# def test_get_detail_xml(self):
|
|
# self.assertValidXMLResponse(self.api_client.get(self.detail_url, format='xml', authentication=self.get_credentials()))
|
|
#
|
|
# def test_post_list_unauthenticated(self):
|
|
# self.assertHttpUnauthorized(self.api_client.post('/api/v1/entries/', format='json', data=self.post_data))
|
|
#
|
|
# def test_post_list(self):
|
|
# # Check how many are there first.
|
|
# self.assertEqual(Entry.objects.count(), 5)
|
|
# self.assertHttpCreated(self.api_client.post('/api/v1/entries/', format='json', data=self.post_data, authentication=self.get_credentials()))
|
|
# # Verify a new one has been added.
|
|
# self.assertEqual(Entry.objects.count(), 6)
|
|
#
|
|
# def test_put_detail_unauthenticated(self):
|
|
# self.assertHttpUnauthorized(self.api_client.put(self.detail_url, format='json', data={}))
|
|
#
|
|
# def test_put_detail(self):
|
|
# # Grab the current data & modify it slightly.
|
|
# original_data = self.deserialize(self.api_client.get(self.detail_url, format='json', authentication=self.get_credentials()))
|
|
# new_data = original_data.copy()
|
|
# new_data['title'] = 'Updated: First Post'
|
|
# new_data['created'] = '2012-05-01T20:06:12'
|
|
#
|
|
# self.assertEqual(Entry.objects.count(), 5)
|
|
# self.assertHttpAccepted(self.api_client.put(self.detail_url, format='json', data=new_data, authentication=self.get_credentials()))
|
|
# # Make sure the count hasn't changed & we did an update.
|
|
# self.assertEqual(Entry.objects.count(), 5)
|
|
# # Check for updated data.
|
|
# self.assertEqual(Entry.objects.get(pk=25).title, 'Updated: First Post')
|
|
# self.assertEqual(Entry.objects.get(pk=25).slug, 'first-post')
|
|
# self.assertEqual(Entry.objects.get(pk=25).created, datetime.datetime(2012, 3, 1, 13, 6, 12))
|
|
#
|
|
# def test_delete_detail_unauthenticated(self):
|
|
# self.assertHttpUnauthorized(self.api_client.delete(self.detail_url, format='json'))
|
|
#
|
|
# def test_delete_detail(self):
|
|
# self.assertEqual(Entry.objects.count(), 5)
|
|
# self.assertHttpAccepted(self.api_client.delete(self.detail_url, format='json', authentication=self.get_credentials()))
|
|
# self.assertEqual(Entry.objects.count(), 4)
|