Beispiel #1
0
def test_find_matching_sg_rule(impl):
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', None, False)
    lb.address = '1.1.1.1'

    impl.list_sg_rules.return_value = [{'Port Range': None, 'IP Range': None}]
    assert lb._find_matching_sg_rule('sg_id')

    impl.list_sg_rules.return_value = [{'Port Range': '60:90', 'IP Range': ''}]
    assert lb._find_matching_sg_rule('sg_id')

    impl.list_sg_rules.return_value = [{
        'Port Range': '',
        'IP Range': '1.0.0.0/8'
    }]
    assert lb._find_matching_sg_rule('sg_id')

    impl.list_sg_rules.return_value = [{
        'Port Range': '81:90',
        'IP Range': ''
    }, {
        'Port Range': '',
        'IP Range': '2.0.0.0/8'
    }]
    assert not lb._find_matching_sg_rule('sg_id')

    impl.list_sg_rules.return_value = []
    assert not lb._find_matching_sg_rule('sg_id')
def test_create_recover(impl):
    openstack.kv().get.return_value = None
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', 'net', True)
    impl.list_loadbalancers.return_value = [
        {'name': 'openstack-integrator-1234-app'}]
    impl.show_loadbalancer.return_value = {'id': '2345',
                                           'provisioning_status': 'ACTIVE',
                                           'vip_address': '1.1.1.1',
                                           'vip_port_id': '4321'}
    impl.find_secgrp.return_value = 'sg_id'
    impl.list_sg_rules.return_value = [{'Port Range': '', 'IP Range': ''}]
    impl.get_port_sec_enabled.return_value = False
    impl.list_listeners.return_value = [
        {'name': 'openstack-integrator-1234-app'}]
    impl.list_pools.return_value = [
        {'name': 'openstack-integrator-1234-app'}]
    impl.list_fips.return_value = [
        {'Fixed IP Address': '2.2.2.2', 'Floating IP Address': '3.3.3.3'},
        {'Fixed IP Address': '1.1.1.1', 'Floating IP Address': '4.4.4.4'},
    ]
    impl.list_members.return_value = ['members']
    lb.create()
    assert lb.sg_id is None
    assert lb.fip == '4.4.4.4'
    assert lb.address == '1.1.1.1'
    assert lb.members == ['members']
    assert lb.is_created
    assert not impl.create_loadbalancer.called
    assert not impl.create_secgrp.called
    assert not impl.create_listener.called
    assert not impl.create_pool.called
    assert not impl.create_fip.called
def test_delete_loadbalancer(impl, kv):
    kv().get.return_value = None
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', 'net', True)
    lb.delete()

    impl.get_port_sec_enabled.assert_called_once()
    impl.delete_loadbalancer.assert_called_once()
    openstack.kv().unset.assert_called_with(
        "created_lbs.openstack-integrator-1234-app")
def test_create_new(impl, log_err):
    openstack.kv().get.return_value = None
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', None, False)
    assert not lb.is_created
    lb.name = 'name'
    impl.list_loadbalancers.return_value = []
    impl.create_loadbalancer.return_value = {
        'id': '1234',
        'vip_address': '1.1.1.1',
        'vip_port_id': '4321'
    }
    impl.show_loadbalancer.return_value = {'provisioning_status': 'ACTIVE'}
    impl.show_pool.return_value = {'provisioning_status': 'ACTIVE'}
    impl.find_secgrp.side_effect = ['sg_id', 'member_sg_id']
    impl.list_listeners.return_value = []
    impl.list_pools.return_value = []
    impl.list_members.return_value = [('member', '6443')]
    impl.list_sg_rules.return_value = []
    impl.get_port_sec_enabled.return_value = True
    impl.get_subnet_cidr.return_value = '1.1.1.1/32'
    impl.create_secgrp.return_value = 'member_sg_id'
    lb.create()
    assert lb.sg_id is None
    assert lb.member_sg_id == 'member_sg_id'
    assert lb.fip is None
    assert lb.address == '1.1.1.1'
    assert lb.members == [('member', '6443')]
    assert lb.is_created
    assert impl.create_loadbalancer.called
    assert not impl.create_secgrp.called
    assert not impl.set_port_secgrp.called
    assert impl.create_listener.called
    assert impl.create_pool.called
    assert not impl.list_fips.called
    assert not impl.create_fip.called

    impl.find_secgrp.side_effect = ['sg_id', None]
    lb.create()
    impl.create_secgrp.assert_called_with('name-members')

    impl.find_secgrp.side_effect = None
    impl.find_secgrp.return_value = None
    with pytest.raises(openstack.OpenStackLBError):
        lb.create()
    openstack.log_err.assert_called_with('Unable to find default '
                                         'security group')

    lb.fip_net = 'net'
    lb.manage_secgrps = True
    impl.create_secgrp.return_value = 'sg_id'
    impl.list_fips.return_value = []
    lb.create()
    assert lb.sg_id == 'sg_id'
    impl.create_secgrp.assert_has_calls(
        [mock.call('name'), mock.call('name-members')])
    impl.set_port_secgrp.assert_called_with('4321', 'sg_id')
    impl.create_fip.assert_called_with('1.1.1.1', '4321')
Beispiel #5
0
def test_find(impl, log_err):
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', None, False)
    lb.name = 'lb'
    item1 = {'id': 1, 'name': 'not-lb'}
    item2 = {'id': 2, 'name': 'lb'}
    item3 = {'id': 3, 'name': 'lb'}
    assert lb._find('foo', [item1]) is None
    assert lb._find('foo', [item1, item2]) == item2
    with pytest.raises(openstack.OpenStackLBError):
        lb._find('foo', [item1, item2, item3])
    log_err.assert_called_with('Multiple {} found: {}', 'foo', 'lb')
def test_wait_not_pending(impl):
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', None, False)
    test_func = mock.Mock(side_effect=[
        {'provisioning_status': 'PENDING_CREATE'},
        {'provisioning_status': 'PENDING_UPDATE'},
        {'provisioning_status': 'PENDING_DELETE'},
        {'provisioning_status': 'ACTIVE'},
    ])
    lb._wait_not_pending(test_func)
    assert sleep.call_count == 3

    test_func = mock.Mock(return_value={
        'provisioning_status': 'PENDING_DELETE',
    })
    with pytest.raises(openstack.OpenStackLBError):
        lb._wait_not_pending(test_func)
def test_update_members(impl, _openstack):
    lb = openstack.LoadBalancer('app', '80', 'subnet', 'alg', None, False)
    lb.address = '1.1.1.1'
    impl.show_pool.return_value = {'provisioning_status': 'ACTIVE'}
    impl.list_sg_rules.return_value = []
    lb.members = {(1, 2), (3, 4)}
    lb.update_members({(1, 2), (3, 4)})
    assert not impl.delete_member.called
    assert not impl.create_member.called
    assert not impl.create_sg_rule.called

    lb.members = {(1, 2), (3, 4)}
    lb.update_members({(1, 2), (3, 4), (5, 6)})
    assert not impl.delete_member.called
    assert impl.create_member.called
    assert lb.members == {(1, 2), (3, 4), (5, 6)}
    assert impl.create_sg_rule.called

    impl.create_member.reset_mock()
    impl.create_sg_rule.reset_mock()
    lb.members = {(1, 2), (3, 4)}
    lb.update_members({(1, 2)})
    assert impl.delete_member.called
    assert not impl.create_member.called
    assert not impl.create_sg_rule.called

    impl.delete_member.reset_mock()
    lb.members = {(1, 2), (3, 4)}
    lb.update_members({(5, 6)})
    assert impl.delete_member.called
    assert impl.create_member.called

    impl.delete_member.side_effect = subprocess.CalledProcessError(1, 'cmd')
    lb.members = {(1, 2), (3, 4)}
    with pytest.raises(openstack.OpenStackLBError):
        lb.update_members(set())

    impl.delete_member.side_effect = AssertionError('should not be called')
    impl.create_member.side_effect = subprocess.CalledProcessError(1, 'cmd')
    impl.list_members.return_value = set()
    lb.members = set()
    with pytest.raises(openstack.OpenStackLBError):
        lb.update_members({(1, 2)})