More tests. Removed one API call because it was a duplicate.

django-openstack/django_openstack/api.py

@@ -310,11 +310,6 @@ def flavor_get(request, flavor_id):
 def flavor_list(request):
     return [Flavor(f) for f in extras_api(request).flavors.list()]
 
-
-def flavor_list_admin(request):
-    return [Flavor(f) for f in extras_api(request).flavors.list()]
-
-
 # this method is currently unused in django_openstack
 def image_all_metadata(request):
     images = glance_api(request).get_images_detailed()

django-openstack/django_openstack/syspanel/views/flavors.py

@@ -81,7 +81,7 @@ def index(request):
 
     flavors = []
     try:
-        flavors = api.flavor_list_admin(request)
+        flavors = api.flavor_list(request)
     except api_exceptions.ApiException, e:
         LOG.error('ApiException while fetching usage info', exc_info=True)
         messages.error(request, 'Unable to get usage info: %s' % e.message)

django-openstack/django_openstack/tests/api_tests.py

@@ -18,6 +18,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import cloudfiles
 import mox
 
 from django import http
@@ -25,19 +26,25 @@ from django import test
 from django.conf import settings
 from django.utils import unittest
 from django_openstack import api
+from glance import client as glance_client
 from mox import IsA
 from openstack import compute as OSCompute
 from openstackx import admin as OSAdmin
 from openstackx import auth as OSAuth
+from openstackx import extras as OSExtras
 
 
+TEST_CONSOLE_KIND = 'vnc'
+TEST_HOSTNAME = 'hostname'
+TEST_INSTANCE_ID = '2'
 TEST_PASSWORD = '12345'
+TEST_PORT = 8000
 TEST_RETURN = 'retValue'
 TEST_TENANT_DESCRIPTION = 'tenantDescription'
 TEST_TENANT_ID = '1234'
 TEST_TOKEN = 'aToken'
 TEST_TOKEN_ID = 'userId'
-TEST_URL = 'http://testserver/something/v1.0'
+TEST_URL = 'http://%s:%s/something/v1.0' % (TEST_HOSTNAME, TEST_PORT)
 TEST_USERNAME = 'testUser'
 
 class Server(object):
@@ -266,13 +273,55 @@ class ServerWrapperTests(test.TestCase):
 
         self.mox.VerifyAll()
 
-class AdminApiTests(test.TestCase):
+class AccountApiTests(test.TestCase):
     def setUp(self):
         self.mox = mox.Mox()
+        self.request = http.HttpRequest()
+        self.request.session = dict()
+        self.request.session['token'] = TEST_TOKEN
 
     def tearDown(self):
         self.mox.UnsetStubs()
 
+    def stub_account_api(self):
+        self.mox.StubOutWithMock(api, 'account_api')
+        account_api = self.mox.CreateMock(OSExtras.Account)
+        api.account_api(IsA(http.HttpRequest)).AndReturn(account_api)
+        return account_api
+
+    def test_get_account_api(self):
+        self.mox.StubOutClassWithMocks(OSExtras, 'Account')
+        OSExtras.Account(auth_token=TEST_TOKEN, management_url=TEST_URL)
+
+        self.mox.StubOutWithMock(api, 'url_for')
+        api.url_for(IsA(http.HttpRequest), 'keystone', True).AndReturn(TEST_URL)
+        api.url_for(IsA(http.HttpRequest), 'keystone', True).AndReturn(TEST_URL)
+
+        self.mox.ReplayAll()
+
+        self.assertIsNotNone(api.account_api(self.request))
+
+        self.mox.VerifyAll()
+
+
+
+class AdminApiTests(test.TestCase):
+    def setUp(self):
+        self.mox = mox.Mox()
+        self.request = http.HttpRequest()
+        self.request.session = dict()
+        self.request.session['token'] = TEST_TOKEN
+
+    def tearDown(self):
+        self.mox.UnsetStubs()
+
+    def stub_admin_api(self, count=1):
+        self.mox.StubOutWithMock(api, 'admin_api')
+        admin_api = self.mox.CreateMock(OSAdmin.Admin)
+        for i in range(count):
+            api.admin_api(IsA(http.HttpRequest)).AndReturn(admin_api)
+        return admin_api
+
     def test_get_admin_api(self):
         self.mox.StubOutClassWithMocks(OSAdmin, 'Admin')
         OSAdmin.Admin(auth_token=TEST_TOKEN, management_url=TEST_URL)
@@ -281,16 +330,54 @@ class AdminApiTests(test.TestCase):
         api.url_for(IsA(http.HttpRequest), 'nova', True).AndReturn(TEST_URL)
         api.url_for(IsA(http.HttpRequest), 'nova', True).AndReturn(TEST_URL)
 
-        request = http.HttpRequest()
+        self.mox.ReplayAll()
-        request.session = dict()
+
-        request.session['token'] = TEST_TOKEN
+        self.assertIsNotNone(api.admin_api(self.request))
+
+        self.mox.VerifyAll()
+
+    def test_flavor_create(self):
+        FLAVOR_DISK = 1000
+        FLAVOR_ID = 6
+        FLAVOR_MEMORY = 1024
+        FLAVOR_NAME = 'newFlavor'
+        FLAVOR_VCPU = 2
+
+        admin_api = self.stub_admin_api()
+
+        admin_api.flavors = self.mox.CreateMockAnything()
+        admin_api.flavors.create(FLAVOR_NAME, FLAVOR_MEMORY, FLAVOR_VCPU,
+                                 FLAVOR_DISK, FLAVOR_ID).AndReturn(TEST_RETURN)
 
         self.mox.ReplayAll()
 
-        self.assertIsNotNone(api.admin_api(request))
+        ret_val = api.flavor_create(self.request, FLAVOR_NAME,
+                                    str(FLAVOR_MEMORY), str(FLAVOR_VCPU),
+                                    str(FLAVOR_DISK), FLAVOR_ID)
+
+        self.assertIsInstance(ret_val, api.Flavor)
+        self.assertEqual(ret_val._apiresource, TEST_RETURN)
 
         self.mox.VerifyAll()
 
+    def test_flavor_delete(self):
+        FLAVOR_ID = 6
+
+        admin_api = self.stub_admin_api(count=2)
+
+        admin_api.flavors = self.mox.CreateMockAnything()
+        admin_api.flavors.delete(FLAVOR_ID, False)
+        admin_api.flavors.delete(FLAVOR_ID, True)
+
+        self.mox.ReplayAll()
+
+        ret_val = api.flavor_delete(self.request, FLAVOR_ID)
+        self.assertIsNone(ret_val)
+
+        ret_val = api.flavor_delete(self.request, FLAVOR_ID, purge=True)
+        self.assertIsNone(ret_val)
+
+
 class AuthApiTests(test.TestCase):
     def setUp(self):
         self.mox = mox.Mox()
@@ -415,10 +502,20 @@ class AuthApiTests(test.TestCase):
 class ComputeApiTests(test.TestCase):
     def setUp(self):
         self.mox = mox.Mox()
+        self.request = http.HttpRequest()
+        self.request.session = {}
+        self.request.session['token'] = TEST_TOKEN
 
     def tearDown(self):
         self.mox.UnsetStubs()
 
+    def stub_compute_api(self, count=1):
+        self.mox.StubOutWithMock(api, 'compute_api')
+        compute_api = self.mox.CreateMock(OSCompute.Compute)
+        for i in range(count):
+            api.compute_api(IsA(http.HttpRequest)).AndReturn(compute_api)
+        return compute_api
+
     def test_get_compute_api(self):
         class ComputeClient(object):
             __slots__ = ['auth_token', 'management_url']
@@ -435,13 +532,9 @@ class ComputeApiTests(test.TestCase):
         api.url_for(IsA(http.HttpRequest), 'nova').AndReturn(TEST_URL)
         api.url_for(IsA(http.HttpRequest), 'nova').AndReturn(TEST_URL)
 
-        request = http.HttpRequest()
-        request.session = {}
-        request.session['token'] = TEST_TOKEN
-
         self.mox.ReplayAll()
 
-        compute_api = api.compute_api(request)
+        compute_api = api.compute_api(self.request)
 
         self.assertIsNotNone(compute_api)
         self.assertEqual(compute_api.client.auth_token, TEST_TOKEN)
@@ -449,11 +542,202 @@ class ComputeApiTests(test.TestCase):
 
         self.mox.VerifyAll()
 
+    def test_flavor_get(self):
+        FLAVOR_ID = 6
+
+        compute_api = self.stub_compute_api()
+
+        compute_api.flavors = self.mox.CreateMockAnything()
+        compute_api.flavors.get(FLAVOR_ID).AndReturn(TEST_RETURN)
+
+        self.mox.ReplayAll()
+
+        ret_val = api.flavor_get(self.request, FLAVOR_ID)
+        self.assertIsInstance(ret_val, api.Flavor)
+        self.assertEqual(ret_val._apiresource, TEST_RETURN)
+
+        self.mox.VerifyAll()
+
+
+class ExtrasApiTests(test.TestCase):
+    def setUp(self):
+        self.mox = mox.Mox()
+        self.request = http.HttpRequest()
+        self.request.session = dict()
+        self.request.session['token'] = TEST_TOKEN
+
+    def tearDown(self):
+        self.mox.UnsetStubs()
+
+    def stub_extras_api(self, count=1):
+        self.mox.StubOutWithMock(api, 'extras_api')
+        extras_api = self.mox.CreateMock(OSExtras.Extras)
+        for i in range(count):
+            api.extras_api(IsA(http.HttpRequest)).AndReturn(extras_api)
+        return extras_api
+
+    def test_get_extras_api(self):
+        self.mox.StubOutClassWithMocks(OSExtras, 'Extras')
+        OSExtras.Extras(auth_token=TEST_TOKEN, management_url=TEST_URL)
+
+        self.mox.StubOutWithMock(api, 'url_for')
+        api.url_for(IsA(http.HttpRequest), 'nova').AndReturn(TEST_URL)
+        api.url_for(IsA(http.HttpRequest), 'nova').AndReturn(TEST_URL)
+
+        self.mox.ReplayAll()
+
+        self.assertIsNotNone(api.extras_api(self.request))
+        
+        self.mox.VerifyAll()
+
+    def test_console_create(self):
+        extras_api = self.stub_extras_api(count=2)
+        extras_api.consoles = self.mox.CreateMockAnything()
+        extras_api.consoles.create(TEST_INSTANCE_ID, TEST_CONSOLE_KIND).AndReturn(TEST_RETURN)
+        extras_api.consoles.create(TEST_INSTANCE_ID, None).AndReturn(TEST_RETURN + '2')
+
+        self.mox.ReplayAll()
+
+        ret_val = api.console_create(self.request, TEST_INSTANCE_ID, TEST_CONSOLE_KIND)
+        self.assertIsInstance(ret_val, api.Console)
+        self.assertEqual(ret_val._apiresource, TEST_RETURN)
+
+        ret_val = api.console_create(self.request, TEST_INSTANCE_ID)
+        self.assertIsInstance(ret_val, api.Console)
+        self.assertEqual(ret_val._apiresource, TEST_RETURN + '2')
+
+        self.mox.VerifyAll()
+
+    def test_flavor_list(self):
+        flavors = (TEST_RETURN, TEST_RETURN + '2')
+        extras_api = self.stub_extras_api()
+        extras_api.flavors = self.mox.CreateMockAnything()
+        extras_api.flavors.list().AndReturn(flavors)
+
+        self.mox.ReplayAll()
+
+        ret_val = api.flavor_list(self.request)
+
+        self.assertEqual(len(ret_val), len(flavors))
+        for flavor in ret_val:
+            self.assertIsInstance(flavor, api.Flavor)
+            self.assertIn(flavor._apiresource, flavors)
+
+        self.mox.VerifyAll()
+
 
 class GlanceApiTests(test.TestCase):
     def setUp(self):
         self.mox = mox.Mox()
 
+        self.request = http.HttpRequest()
+        self.request.session = dict()
+        self.request.session['token'] = TEST_TOKEN
+
     def tearDown(self):
         self.mox.UnsetStubs()
 
+    def stub_glance_api(self, count=1):
+        self.mox.StubOutWithMock(api, 'glance_api')
+        glance_api = self.mox.CreateMock(glance_client.Client)
+        for i in range(count):
+            api.glance_api(IsA(http.HttpRequest)).AndReturn(glance_api)
+        return glance_api
+
+    def test_get_glance_api(self):
+        self.mox.StubOutClassWithMocks(glance_client, 'Client')
+        glance_client.Client(TEST_HOSTNAME, TEST_PORT)
+
+
+        self.mox.StubOutWithMock(api, 'url_for')
+        api.url_for(IsA(http.HttpRequest), 'glance').AndReturn(TEST_URL)
+
+        self.mox.ReplayAll()
+
+        self.assertIsNotNone(api.glance_api(self.request))
+        
+        self.mox.VerifyAll()
+
+    def test_image_create(self):
+        IMAGE_FILE = 'someData'
+        IMAGE_META = {'metadata': 'foo'}
+
+        glance_api = self.stub_glance_api()
+        glance_api.add_image(IMAGE_META, IMAGE_FILE).AndReturn(TEST_RETURN)
+
+        self.mox.ReplayAll()
+
+        ret_val = api.image_create(self.request, IMAGE_META, IMAGE_FILE)
+
+        self.assertIsInstance(ret_val, api.Image)
+        self.assertEqual(ret_val._apidict, TEST_RETURN)
+
+        self.mox.VerifyAll()
+
+    def test_image_delete(self):
+        IMAGE_ID = '1'
+
+        glance_api = self.stub_glance_api()
+        glance_api.delete_image(IMAGE_ID).AndReturn(TEST_RETURN)
+
+        self.mox.ReplayAll()
+
+        ret_val = api.image_delete(self.request, IMAGE_ID)
+
+        self.assertEqual(ret_val, TEST_RETURN)
+
+        self.mox.VerifyAll()
+
+    def test_image_get(self):
+        IMAGE_ID = '1'
+
+        glance_api = self.stub_glance_api()
+        glance_api.get_image(IMAGE_ID).AndReturn([TEST_RETURN])
+
+        self.mox.ReplayAll()
+
+        ret_val = api.image_get(self.request, IMAGE_ID)
+
+        self.assertIsInstance(ret_val, api.Image)
+        self.assertEqual(ret_val._apidict, TEST_RETURN)
+        
+
+    def test_image_list_detailed(self):
+        images = (TEST_RETURN, TEST_RETURN + '2')
+        glance_api = self.stub_glance_api()
+        glance_api.get_images_detailed().AndReturn(images)
+
+        self.mox.ReplayAll()
+
+        ret_val = api.image_list_detailed(self.request)
+
+        self.assertEqual(len(ret_val), len(images))
+        for image in ret_val:
+            self.assertIsInstance(image, api.Image)
+            self.assertIn(image._apidict, images)
+
+        self.mox.VerifyAll()
+
+class SwiftApiTests(test.TestCase):
+    def setUp(self):
+        self.mox = mox.Mox()
+
+    def tearDown(self):
+        self.mox.UnsetStubs()
+
+    def test_get_swift_api(self):
+        self.mox.StubOutWithMock(cloudfiles, 'get_connection')
+
+        swiftuser = ':'.join((settings.SWIFT_ACCOUNT, settings.SWIFT_USER))
+        cloudfiles.get_connection(swiftuser,
+                                  settings.SWIFT_PASS,
+                                  authurl=settings.SWIFT_AUTHURL
+                                 ).AndReturn(TEST_RETURN)
+
+
+        self.mox.ReplayAll()
+
+        self.assertEqual(api.swift_api(), TEST_RETURN)
+
+        self.mox.VerifyAll()
+

django-openstack/django_openstack/tests/testsettings.py

@@ -65,3 +65,7 @@ NOSE_ARGS = ['--nocapture',
 MAILER_EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'
 EMAIL_BACKEND = MAILER_EMAIL_BACKEND
 
+SWIFT_ACCOUNT = 'test'
+SWIFT_USER = 'tester'
+SWIFT_PASS = 'testing'
+SWIFT_AUTHURL = 'http://swift/swiftapi/v1.0'