Add payload test

Create listener, pool, healthmonitor and members.

Check that we can get payload through the load balancer.

zaza/openstack/charm_tests/octavia/tests.py

@@ -15,6 +15,7 @@
 """Encapsulate octavia testing."""
 
 import logging
+import subprocess
 import tenacity
 
 import zaza.openstack.charm_tests.test_utils as test_utils
@@ -51,6 +52,14 @@ class LBAASv2Test(test_utils.OpenStackBaseTest):
         keystone_session = openstack_utils.get_overcloud_keystone_session()
         neutron_client = openstack_utils.get_neutron_session_client(
             keystone_session)
+
+        # Get IP of the prepared payload instances
+        resp = neutron_client.list_ports(device_owner='compute:nova')
+        payload_ips = []
+        for port in resp['ports']:
+            payload_ips.append(port['fixed_ips'][0]['ip_address'])
+        self.assertTrue(len(payload_ips) > 0)
+
         resp = neutron_client.list_networks(name='private')
         subnet_id = resp['networks'][0]['subnets'][0]
         octavia_client = openstack_utils.get_octavia_session_client(
@@ -64,16 +73,106 @@ class LBAASv2Test(test_utils.OpenStackBaseTest):
                     'name': 'zaza-lb-0',
                 }})
         lb_id = result['loadbalancer']['id']
+        lb_vip_port_id = result['loadbalancer']['vip_port_id']
 
         @tenacity.retry(wait=tenacity.wait_fixed(1),
                         reraise=True, stop=tenacity.stop_after_delay(900))
-        def wait_for_loadbalancer(octavia_client, load_balancer_id):
-            resp = octavia_client.load_balancer_show(load_balancer_id)
-            if resp['provisioning_status'] != 'ACTIVE':
-                raise Exception('load balancer has not reached expected '
-                                'status: {}'.format(resp))
+        def wait_for_lb_resource(octavia_show_func, resource_id,
+                                 operating_status=None):
+            resp = octavia_show_func(resource_id)
+            logging.info(resp['provisioning_status'])
+            assert resp['provisioning_status'] == 'ACTIVE', (
+                'load balancer resource has not reached '
+                'expected provisioning status: {}'
+                .format(resp))
+            if operating_status:
+                logging.info(resp['operating_status'])
+                assert resp['operating_status'] == operating_status, (
+                    'load balancer resource has not reached '
+                    'expected operating status: {}'.format(resp))
+
             return resp
         logging.info('Awaiting loadbalancer to reach provisioning_status '
                      '"ACTIVE"')
-        resp = wait_for_loadbalancer(octavia_client, lb_id)
+        resp = wait_for_lb_resource(octavia_client.load_balancer_show, lb_id)
         logging.info(resp)
+
+        result = octavia_client.listener_create(
+            json={
+                'listener': {
+                    'loadbalancer_id': lb_id,
+                    'name': 'listener1',
+                    'protocol': 'HTTP',
+                    'protocol_port': 80
+                },
+            })
+        listener_id = result['listener']['id']
+        logging.info('Awaiting listener to reach provisioning_status '
+                     '"ACTIVE"')
+        resp = wait_for_lb_resource(octavia_client.listener_show, listener_id)
+        logging.info(resp)
+
+        result = octavia_client.pool_create(
+            json={
+                'pool': {
+                    'listener_id': listener_id,
+                    'name': 'pool1',
+                    'lb_algorithm': 'ROUND_ROBIN',
+                    'protocol': 'HTTP',
+                },
+            })
+        pool_id = result['pool']['id']
+        logging.info('Awaiting pool to reach provisioning_status '
+                     '"ACTIVE"')
+        resp = wait_for_lb_resource(octavia_client.pool_show, pool_id)
+        logging.info(resp)
+
+        result = octavia_client.health_monitor_create(
+            json={
+                'healthmonitor': {
+                    'pool_id': pool_id,
+                    'delay': 5,
+                    'max_retries': 4,
+                    'timeout': 10,
+                    'type': 'HTTP',
+                    'url_path': '/',
+                },
+            })
+        healthmonitor_id = result['healthmonitor']['id']
+        logging.info('Awaiting healthmonitor to reach provisioning_status '
+                     '"ACTIVE"')
+        resp = wait_for_lb_resource(octavia_client.health_monitor_show,
+                                    healthmonitor_id)
+        logging.info(resp)
+
+        for ip in payload_ips:
+            result = octavia_client.member_create(
+                pool_id=pool_id,
+                json={
+                    'member': {
+                        'subnet_id': subnet_id,
+                        'address': ip,
+                        'protocol_port': 80,
+                    },
+                })
+            member_id = result['member']['id']
+            logging.info('Awaiting member to reach provisioning_status '
+                         '"ACTIVE"')
+            resp = wait_for_lb_resource(
+                lambda x: octavia_client.member_show(
+                    pool_id=pool_id, member_id=x),
+                member_id,
+                operating_status='ONLINE')
+            logging.info(resp)
+
+        lb_fp = openstack_utils.create_floating_ip(
+            neutron_client, 'ext_net', port={'id': lb_vip_port_id})
+
+        @tenacity.retry(wait=tenacity.wait_fixed(1),
+                        reraise=True, stop=tenacity.stop_after_delay(900))
+        def get_payload():
+            return subprocess.check_output(
+                ['wget', '-O', '-',
+                 'http://{}/'.format(lb_fp['floating_ip_address'])],
+                universal_newlines=True)
+        assert 'This is the default welcome page' in get_payload()