Esempio n. 1
0
    def test_ensure_l7_rule(self):
        cls = d_lbaasv2.LBaaSv2Driver
        m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
        expected_resp = mock.sentinel.expected_resp
        loadbalancer = mock.sentinel.expected_resp
        compare_type = 'EQUAL_TO'
        type = 'HOST_NAME'
        value = 'www.test.com'
        l7_policy = obj_lbaas.LBaaSL7Policy(
            id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C',
            name='TEST_NAME',
            project_id='TEST_PROJECT',
            listener_id='D4F35594-27EB-4F4C-930C-31DD40F53B77',
            redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')

        m_driver._ensure_provisioned.return_value = expected_resp

        cls.ensure_l7_rule(m_driver, loadbalancer, l7_policy, compare_type,
                           type, value)

        m_driver._ensure_provisioned.assert_called_once_with(
            loadbalancer, mock.ANY, m_driver._create_l7_rule,
            m_driver._find_l7_rule)
        l7rule = m_driver._ensure_provisioned.call_args[0][1]

        self.assertEqual(compare_type, l7rule.compare_type)
        self.assertEqual(type, l7rule.type)
        self.assertEqual(value, l7rule.value)
Esempio n. 2
0
    def test_create_l7policy(self):
        lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
        cls = d_lbaasv2.LBaaSv2Driver
        m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)

        l7_policy = obj_lbaas.LBaaSL7Policy(
            name='TEST_NAME',
            project_id='TEST_PROJECT',
            listener_id='D4F35594-27EB-4F4C-930C-31DD40F53B77',
            redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')

        l7policy_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F'
        req = {
            'l7policy': {
                'action': 'REDIRECT_TO_POOL',
                'listener_id': l7_policy.listener_id,
                'name': l7_policy.name,
                'project_id': l7_policy.project_id,
                'redirect_pool_id': l7_policy.redirect_pool_id
            }
        }
        resp = {'l7policy': {'id': l7policy_id}}
        lbaas.create_lbaas_l7policy.return_value = resp

        ret = cls._create_l7_policy(m_driver, l7_policy)
        lbaas.create_lbaas_l7policy.assert_called_once_with(req)
        for attr in l7_policy.obj_fields:
            self.assertEqual(getattr(l7_policy, attr), getattr(ret, attr))
        self.assertEqual(l7policy_id, ret.id)
Esempio n. 3
0
    def ensure_l7_policy(self, namespace, route_name, loadbalancer, pool,
                         listener_id):
        name = namespace + route_name
        l7_policy = obj_lbaas.LBaaSL7Policy(name=name,
                                            project_id=pool.project_id,
                                            listener_id=listener_id,
                                            redirect_pool_id=pool.id)

        return self._ensure_provisioned(loadbalancer, l7_policy,
                                        self._create_l7_policy,
                                        self._find_l7_policy)
    def test_sync_path_l7_rule(self):
        m_handler = mock.Mock(spec=h_route.OcpRouteHandler)
        m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer(
            id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C',
            project_id='TEST_PROJECT')
        m_handler._drv_lbaas = mock.Mock(spec=drv_base.LBaaSDriver)

        l7_policy = obj_lbaas.LBaaSL7Policy(
            id='00EE9E11-91C2-41CF-8FD4-7970579E6666',
            name='myname',
            listener_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45',
            redirect_pool_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46',
            project_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46')

        route_state = obj_route.RouteState(l7_policy=l7_policy)

        route = {
            'metadata': {
                'namespace': 'namespace',
                'name': 'name'
            },
            'spec': {
                'host': 'new.www.test.com',
                'path': '/nice_path',
                'to': {
                    'name': 'target_service'
                }
            }
        }

        route_spec = obj_route.RouteSpec(host='www.test.com',
                                         path=None,
                                         to_service='target_service')

        ret_p_l7_rule = obj_lbaas.LBaaSL7Rule(
            id='55559E11-91C2-41CF-8FD4-7970579E5C44',
            compare_type=OCP_ROUTE_PATH_COMP_TYPE,
            l7policy_id='55559E11-91C2-41CF-8FD4-7970579E5C45',
            type='PATH',
            value='/nice_path')

        m_handler._drv_lbaas.ensure_l7_rule.return_value = ret_p_l7_rule
        h_route.OcpRouteHandler._sync_path_l7_rule(m_handler, route,
                                                   route_spec, route_state)
        self.assertEqual(route_state.p_l7_rule, ret_p_l7_rule)
        m_handler._drv_lbaas.ensure_l7_rule.assert_called_once_with(
            m_handler._l7_router, route_state.l7_policy,
            OCP_ROUTE_PATH_COMP_TYPE, 'PATH', route['spec']['path'])
    def test_sync_l7_policy(self):
        m_handler = mock.Mock(spec=h_route.OcpRouteHandler)
        m_handler._l7_router = obj_lbaas.LBaaSLoadBalancer(
            id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C',
            project_id='TEST_PROJECT')
        m_handler._drv_lbaas = mock.Mock(spec=drv_base.LBaaSDriver)
        listener = obj_lbaas.LBaaSListener(
            id='123443545',
            name='TEST_NAME',
            project_id='TEST_PROJECT',
            protocol='TCP',
            port=80,
            loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C')
        m_handler._l7_router_listeners = {'80': listener}
        l7_policy = obj_lbaas.LBaaSL7Policy(
            id='00EE9E11-91C2-41CF-8FD4-7970579E5C44',
            name='myname',
            listener_id='00EE9E11-91C2-41CF-8FD4-7970579E5C45',
            redirect_pool_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46',
            project_id='00EE9E11-91C2-41CF-8FD4-7970579E5C46')

        route_state = obj_route.RouteState()
        m_handler._drv_lbaas.ensure_l7_policy.return_value = l7_policy

        route = {
            'metadata': {
                'namespace': 'namespace',
                'name': 'name'
            },
            'spec': {
                'host': 'www.test.com',
                'path': 'mypath',
                'to': {
                    'name': 'target_service'
                }
            }
        }
        route_spec = obj_route.RouteSpec(host='www.test.com1',
                                         path='mypath',
                                         to_service='target_service')

        h_route.OcpRouteHandler._sync_l7_policy(m_handler, route, route_spec,
                                                route_state)
        self.assertEqual(route_state.l7_policy, l7_policy)
Esempio n. 6
0
    def test_find_l7_policy_not_found(self):
        lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
        cls = d_lbaasv2.LBaaSv2Driver
        m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
        l7_policy = obj_lbaas.LBaaSL7Policy(
            name='TEST_NAME',
            project_id='TEST_PROJECT',
            listener_id='D4F35594-27EB-4F4C-930C-31DD40F53B77',
            redirect_pool_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1')

        resp = {'l7policies': []}
        lbaas.list_lbaas_l7policies.return_value = resp

        ret = cls._find_l7_policy(m_driver, l7_policy)
        lbaas.list_lbaas_l7policies.assert_called_once_with(
            name=l7_policy.name,
            project_id=l7_policy.project_id,
            redirect_pool_id=l7_policy.redirect_pool_id,
            listener_id=l7_policy.listener_id)
        self.assertIsNone(ret)