Add worker controller tests.

Add unit tests for the LBaaSController class. Also add check for
invalid algorithm.

libra/worker/controller.py

@@ -98,6 +98,10 @@ class LBaaSController(object):
                 algo = LoadBalancerDriver.ROUNDROBIN
             elif algo == 'LEAST_CONNECTIONS':
                 algo = LoadBalancerDriver.LEASTCONN
+            else:
+                self.logger.error("Invalid algorithm: %s" % algo)
+                self.msg[self.RESPONSE_FIELD] = self.RESPONSE_FAILURE
+                return self.msg
 
             try:
                 self.driver.set_algorithm(algo)

tests/mock_objects.py

@@ -29,6 +29,23 @@ class FakeOSServices(ServicesBase):
         pass
 
 
+class FakeFaultingOSServices(ServicesBase):
+    def service_stop(self):
+        raise Exception("fault")
+
+    def service_start(self):
+        raise Exception("fault")
+
+    def service_restart(self):
+        raise Exception("fault")
+
+    def write_config(self):
+        raise Exception("fault")
+
+    def remove_configs(self):
+        raise Exception("fault")
+
+
 class MockLoggingHandler(logging.Handler):
     """Mock logging handler to check for expected logs."""
 

tests/test_worker_controller.py

@@ -0,0 +1,108 @@
+import logging
+import mock_objects
+import unittest
+from libra.worker.controller import LBaaSController as c
+from libra.worker.drivers.haproxy.driver import HAProxyDriver
+
+
+class TestWorkerController(unittest.TestCase):
+    def setUp(self):
+        self.logger = logging.getLogger('test_worker_controller')
+        self.lh = mock_objects.MockLoggingHandler()
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.addHandler(self.lh)
+        self.driver = HAProxyDriver('mock_objects.FakeOSServices')
+
+    def tearDown(self):
+        pass
+
+    def testBadAction(self):
+        msg = {
+            c.ACTION_FIELD: 'BOGUS'
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_FAILURE)
+
+    def testCreate(self):
+        msg = {
+            c.ACTION_FIELD: 'CREATE',
+            'nodes': [
+                {
+                    'address': '10.0.0.1',
+                    'port': 80
+                }
+            ]
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_SUCCESS)
+
+    def testUpdate(self):
+        msg = {
+            c.ACTION_FIELD: 'CREATE',
+            'nodes': [
+                {
+                    'address': '10.0.0.1',
+                    'port': 80
+                }
+            ]
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_SUCCESS)
+
+    def testSuspend(self):
+        msg = {
+            c.ACTION_FIELD: 'SUSPEND'
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_SUCCESS)
+
+    def testEnable(self):
+        msg = {
+            c.ACTION_FIELD: 'ENABLE'
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_SUCCESS)
+
+    def testDelete(self):
+        msg = {
+            c.ACTION_FIELD: 'DELETE'
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_SUCCESS)
+
+    def testCreateMissingNodes(self):
+        msg = {
+            c.ACTION_FIELD: 'CREATE'
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn('badRequest', response)
+
+    def testBadAlgorithm(self):
+        msg = {
+            c.ACTION_FIELD: 'CREATE',
+            'algorithm': 'BOGUS',
+            'nodes': [
+                {
+                    'address': '10.0.0.1',
+                    'port': 80
+                }
+            ]
+        }
+        controller = c(self.logger, self.driver, msg)
+        response = controller.run()
+        self.assertIn(c.RESPONSE_FIELD, response)
+        self.assertEquals(response[c.RESPONSE_FIELD], c.RESPONSE_FAILURE)
+