Merge "Adding functional test cases for Kubernetes APIs"

magnum/tests/contrib/post_test_hook.sh

@@ -70,7 +70,7 @@ nova keypair-add default
 
 # Run functional tests
 echo "Running magnum functional test suite"
-sudo -E -H -u jenkins tox -e functional
+sudo -E -H -u jenkins tox -e functional -- --concurrency=1
 EXIT_CODE=$?
 
 # Delete the keypair used in the functional test.

magnum/tests/functional/test_magnum_python_client.py

@@ -25,11 +25,12 @@ import time
 
 import fixtures
 
+from magnum.common.pythonk8sclient.client import ApivbetaApi
+from magnum.common.pythonk8sclient.client import swagger
+from magnum.tests import base
 from magnumclient.openstack.common.apiclient import exceptions
 from magnumclient.openstack.common import cliutils
-from magnumclient.v1 import client
+from magnumclient.v1 import client as v1client
-
-from magnum.tests import base
 
 
 class BaseMagnumClient(base.TestCase):
@@ -66,14 +67,14 @@ class BaseMagnumClient(base.TestCase):
 
         cls.image_id = image_id
         cls.nic_id = nic_id
-        cls.cs = client.Client(username=user,
+        cls.cs = v1client.Client(username=user,
-                               api_key=passwd,
+                                 api_key=passwd,
-                               project_id=tenant_id,
+                                 project_id=tenant_id,
-                               project_name=tenant,
+                                 project_name=tenant,
-                               auth_url=auth_url,
+                                 auth_url=auth_url,
-                               service_type='container',
+                                 service_type='container',
-                               region_name=region_name,
+                                 region_name=region_name,
-                               magnum_url=magnum_url)
+                                 magnum_url=magnum_url)
 
     @classmethod
     def _wait_on_status(cls, bay, wait_status, finish_status):
@@ -88,9 +89,9 @@ class BaseMagnumClient(base.TestCase):
                 raise Exception("Unknown Status : %s" % status)
 
     @classmethod
-    def _create_baymodel(cls):
+    def _create_baymodel(cls, name):
         baymodel = cls.cs.baymodels.create(
-            name='default',
+            name=name,
             keypair_id='default',
             external_network_id=cls.nic_id,
             image_id=cls.image_id,
@@ -101,9 +102,9 @@ class BaseMagnumClient(base.TestCase):
         return baymodel
 
     @classmethod
-    def _create_bay(cls, baymodel_uuid, wait=True):
+    def _create_bay(cls, name, baymodel_uuid, wait=True):
         bay = cls.cs.bays.create(
-            name='k8s',
+            name=name,
             baymodel_id=baymodel_uuid,
             node_count=None,
         )
@@ -149,7 +150,7 @@ class TestListResources(BaseMagnumClient):
 
 class TestBayModelResource(BaseMagnumClient):
     def test_bay_model_create_and_delete(self):
-        baymodel = self._create_baymodel()
+        baymodel = self._create_baymodel('testbaymodel')
         list = [item.uuid for item in self.cs.baymodels.list()]
         self.assertTrue(baymodel.uuid in list)
 
@@ -171,7 +172,7 @@ class TestBayResource(BaseMagnumClient):
         if test_timeout > 0:
             self.useFixture(fixtures.Timeout(test_timeout, gentle=True))
 
-        self.baymodel = self._create_baymodel()
+        self.baymodel = self._create_baymodel('testbay')
 
     def tearDown(self):
         super(TestBayResource, self).tearDown()
@@ -181,7 +182,7 @@ class TestBayResource(BaseMagnumClient):
             pass
 
     def test_bay_create_and_delete(self):
-        bay = self._create_bay(self.baymodel.uuid)
+        bay = self._create_bay('testbay', self.baymodel.uuid)
         list = [item.uuid for item in self.cs.bays.list()]
         self.assertTrue(bay.uuid in list)
 
@@ -196,8 +197,108 @@ class TestBayResource(BaseMagnumClient):
             self._wait_on_status(bay,
                                  ["CREATE_COMPLETE",
                                   "DELETE_IN_PROGRESS"],
-                                 ["DELETE_FAILED",
+                                 ["DELETE_FAILED", "CREATE_FAILED",
                                   "DELETE_COMPLETE"])
         except exceptions.NotFound:
             # if bay/get fails, the bay has been deleted already
             pass
+
+
+class TestKubernetesAPIs(BaseMagnumClient):
+    @classmethod
+    def setUpClass(cls):
+        super(TestKubernetesAPIs, cls).setUpClass()
+        cls.baymodel = cls._create_baymodel('testk8sAPI')
+        cls.bay = cls._create_bay('testk8sAPI', cls.baymodel.uuid)
+        kube_master_ip = cls.cs.bays.get(cls.bay.uuid).api_address
+        kube_master_url = 'http://%s:8080' % kube_master_ip
+        k8s_client = swagger.ApiClient(kube_master_url)
+        cls.k8s_api = ApivbetaApi.ApivbetaApi(k8s_client)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls._delete_bay(cls.bay.uuid)
+        try:
+            cls._wait_on_status(cls.bay,
+                                ["CREATE_COMPLETE",
+                                 "DELETE_IN_PROGRESS"],
+                                ["DELETE_FAILED", "CREATE_FAILED",
+                                 "DELETE_COMPLETE"])
+        except exceptions.NotFound:
+            pass
+        cls._delete_baymodel(cls.baymodel.uuid)
+
+    def test_pod_apis(self):
+        pod_manifest = {'apiVersion': 'v1beta3',
+                        'kind': 'Pod',
+                        'metadata': {'color': 'blue', 'name': 'test'},
+                        'spec': {'containers': [{'image': 'dockerfile/redis',
+                                 'name': 'redis'}]}}
+
+        resp = self.k8s_api.createPod(body=pod_manifest, namespaces='default')
+        self.assertEqual(resp.metadata['name'], 'test')
+        self.assertTrue(resp.status.phase)
+
+        resp = self.k8s_api.readPod(name='test', namespaces='default')
+        self.assertEqual(resp.metadata['name'], 'test')
+        self.assertTrue(resp.status.phase)
+
+        resp = self.k8s_api.deletePod(name='test', namespaces='default')
+        self.assertFalse(resp.phase)
+
+    def test_service_apis(self):
+        service_manifest = {'apiVersion': 'v1beta3',
+                            'kind': 'Service',
+                            'metadata': {'labels': {'name': 'frontend'},
+                                         'name': 'frontend',
+                                         'resourceversion': 'v1beta3'},
+                            'spec': {'ports': [{'port': 80,
+                                                'protocol': 'TCP',
+                                                'targetPort': 80}],
+                                     'selector': {'name': 'frontend'}}}
+
+        resp = self.k8s_api.createService(body=service_manifest,
+                                          namespaces='default')
+        self.assertEqual(resp.metadata['name'], 'frontend')
+        self.assertTrue(resp.status)
+
+        resp = self.k8s_api.readService(name='frontend', namespaces='default')
+        self.assertEqual(resp.metadata['name'], 'frontend')
+        self.assertTrue(resp.status)
+
+        resp = self.k8s_api.deleteService(name='frontend',
+                                          namespaces='default')
+        # TODO(madhuri) Currently the V1beta3_ServiceStatus
+        # has no attribute defined. Uncomment this assertion
+        # when the class is redefined to contain 'phase'.
+        # self.assertTrue(resp.phase)
+
+    def test_replication_controller_apis(self):
+        rc_manifest = {
+            'apiVersion': 'v1beta3',
+            'kind': 'ReplicationController',
+            'metadata': {'labels': {'name': 'frontend'},
+                         'name': 'frontend'},
+            'spec': {'replicas': 2,
+                     'selector': {'name': 'frontend'},
+                     'template': {'metadata': {
+                         'labels': {'name': 'frontend'}},
+                         'spec': {'containers': [{
+                             'image': 'nginx',
+                             'name': 'nginx',
+                             'ports': [{'containerPort': 80,
+                                        'protocol': 'TCP'}]}]}}}}
+
+        resp = self.k8s_api.createReplicationController(body=rc_manifest,
+                                                        namespaces='default')
+        self.assertEqual(resp.metadata['name'], 'frontend')
+        self.assertEqual(resp.spec.replicas, 2)
+
+        resp = self.k8s_api.readReplicationController(name='frontend',
+                                                      namespaces='default')
+        self.assertEqual(resp.metadata['name'], 'frontend')
+        self.assertEqual(resp.spec.replicas, 2)
+
+        resp = self.k8s_api.deleteReplicationController(name='frontend',
+                                                        namespaces='default')
+        self.assertFalse(resp.replicas)