def test_auto_ip_pool_no_reuse(self, mock_has_service,
                                   mock_attach_ip_to_server,
                                   mock__neutron_create_floating_ip,
                                   mock_keystone_session, mock_nova_client):
        mock_has_service.return_value = True
        fip = _utils.normalize_neutron_floating_ips(
            self.mock_floating_ip_list_rep['floatingips'])[0]
        mock__neutron_create_floating_ip.return_value = fip
        mock_keystone_session.get_project_id.return_value = \
            '4969c491a3c74ee4af974e6d800c62df'
        fake_server = meta.obj_to_dict(fakes.FakeServer('1234', '', 'ACTIVE'))

        self.client.add_ips_to_server(fake_server,
                                      ip_pool='my-network',
                                      reuse=False)

        mock__neutron_create_floating_ip.assert_called_once_with(
            network_name_or_id='my-network',
            server=None,
            fixed_address=None,
            nat_destination=None,
            wait=False,
            timeout=60)
        mock_attach_ip_to_server.assert_called_once_with(server=fake_server,
                                                         fixed_address=None,
                                                         floating_ip=fip,
                                                         wait=False,
                                                         timeout=mock.ANY)
    def setUp(self):
        super(TestFloatingIP, self).setUp()
        # floating_ip_source='neutron' is default for OpenStackCloud()
        config = os_client_config.OpenStackConfig()
        self.client = OpenStackCloud(cloud_config=config.get_one_cloud(
            validate=False))

        self.fake_server = meta.obj_to_dict(
            fakes.FakeServer('server-id',
                             '',
                             'ACTIVE',
                             addresses={
                                 u'test_pnztt_net': [{
                                     u'OS-EXT-IPS:type':
                                     u'fixed',
                                     u'addr':
                                     '192.0.2.129',
                                     u'version':
                                     4,
                                     u'OS-EXT-IPS-MAC:mac_addr':
                                     u'fa:16:3e:ae:7d:42'
                                 }]
                             }))
        self.floating_ip = _utils.normalize_neutron_floating_ips(
            self.mock_floating_ip_list_rep['floatingips'])[0]
Пример #3
0
 def test_float_no_status(self):
     floating_ips = [{
         'fixed_ip_address': '10.0.0.4',
         'floating_ip_address': '172.24.4.229',
         'floating_network_id': 'my-network-id',
         'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda8',
         'port_id': None,
         'router_id': None,
         'tenant_id': '4969c491a3c74ee4af974e6d800c62df'
     }]
     normalized = _utils.normalize_neutron_floating_ips(floating_ips)
     self.assertEqual('UNKNOWN', normalized[0]['status'])
    def test_add_ip_from_pool(self, mock_has_service,
                              mock_available_floating_ip,
                              mock_attach_ip_to_server):
        mock_has_service.return_value = True
        mock_available_floating_ip.return_value = \
            _utils.normalize_neutron_floating_ips([
                self.mock_floating_ip_new_rep['floatingip']])[0]
        mock_attach_ip_to_server.return_value = self.fake_server

        server = self.client._add_ip_from_pool(server=self.fake_server,
                                               network='network-name',
                                               fixed_address='192.0.2.129')

        self.assertEqual(server, self.fake_server)
    def test_add_ip_from_pool(
            self, mock_has_service, mock_available_floating_ip,
            mock_attach_ip_to_server):
        mock_has_service.return_value = True
        mock_available_floating_ip.return_value = \
            _utils.normalize_neutron_floating_ips([
                self.mock_floating_ip_new_rep['floatingip']])[0]
        mock_attach_ip_to_server.return_value = self.fake_server

        server = self.client._add_ip_from_pool(
            server=self.fake_server,
            network='network-name',
            fixed_address='192.0.2.129')

        self.assertEqual(server, self.fake_server)
    def test_detach_ip_from_server(self, mock_has_service, mock_neutron_client,
                                   mock_get_floating_ip):
        mock_has_service.return_value = True
        mock_get_floating_ip.return_value = \
            _utils.normalize_neutron_floating_ips(
                self.mock_floating_ip_list_rep['floatingips'])[0]

        self.client.detach_ip_from_server(
            server_id='server-id',
            floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')

        mock_neutron_client.update_floatingip.assert_called_with(
            floatingip='2f245a7b-796b-4f26-9cf9-9e82d248fda7',
            body={'floatingip': {
                'port_id': None
            }})
    def test_add_ip_from_pool(self, mock_has_service,
                              mock_available_floating_ip,
                              mock_attach_ip_to_server):
        mock_has_service.return_value = True
        mock_available_floating_ip.return_value = \
            _utils.normalize_neutron_floating_ips([
                self.mock_floating_ip_new_rep['floatingip']])[0]
        mock_attach_ip_to_server.return_value = None

        ip = self.client.add_ip_from_pool(server_id='server-id',
                                          network='network-name',
                                          fixed_address='1.2.3.4')

        self.assertEqual(
            self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'],
            ip['floating_ip_address'])
    def test_add_ip_from_pool(
            self, mock_has_service, mock_available_floating_ip,
            mock_attach_ip_to_server):
        mock_has_service.return_value = True
        mock_available_floating_ip.return_value = \
            _utils.normalize_neutron_floating_ips([
                self.mock_floating_ip_new_rep['floatingip']])[0]
        mock_attach_ip_to_server.return_value = None

        ip = self.client.add_ip_from_pool(
            server_id='server-id',
            network='network-name',
            fixed_address='1.2.3.4')

        self.assertEqual(
            self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'],
            ip['floating_ip_address'])
    def setUp(self):
        super(TestFloatingIP, self).setUp()
        # floating_ip_source='neutron' is default for OpenStackCloud()
        config = os_client_config.OpenStackConfig()
        self.client = OpenStackCloud(
            cloud_config=config.get_one_cloud(validate=False))

        self.fake_server = meta.obj_to_dict(
            fakes.FakeServer(
                'server-id', '', 'ACTIVE',
                addresses={u'test_pnztt_net': [{
                    u'OS-EXT-IPS:type': u'fixed',
                    u'addr': '192.0.2.129',
                    u'version': 4,
                    u'OS-EXT-IPS-MAC:mac_addr':
                    u'fa:16:3e:ae:7d:42'}]}))
        self.floating_ip = _utils.normalize_neutron_floating_ips(
            self.mock_floating_ip_list_rep['floatingips'])[0]
    def test_detach_ip_from_server(
            self, mock_has_service, mock_neutron_client,
            mock_get_floating_ip):
        mock_has_service.return_value = True
        mock_get_floating_ip.return_value = \
            _utils.normalize_neutron_floating_ips(
                self.mock_floating_ip_list_rep['floatingips'])[0]

        self.client.detach_ip_from_server(
            server_id='server-id',
            floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7')

        mock_neutron_client.update_floatingip.assert_called_with(
            floatingip='2f245a7b-796b-4f26-9cf9-9e82d248fda7',
            body={
                'floatingip': {
                    'port_id': None
                }
            }
        )
Пример #11
0
    def setUp(self):
        super(TestFloatingIP, self).setUp()

        self.fake_server = meta.obj_to_dict(
            fakes.FakeServer('server-id',
                             '',
                             'ACTIVE',
                             addresses={
                                 u'test_pnztt_net': [{
                                     u'OS-EXT-IPS:type':
                                     u'fixed',
                                     u'addr':
                                     '192.0.2.129',
                                     u'version':
                                     4,
                                     u'OS-EXT-IPS-MAC:mac_addr':
                                     u'fa:16:3e:ae:7d:42'
                                 }]
                             }))
        self.floating_ip = _utils.normalize_neutron_floating_ips(
            self.mock_floating_ip_list_rep['floatingips'])[0]
Пример #12
0
    def test_auto_ip_pool_no_reuse(
            self, mock_has_service,
            mock_attach_ip_to_server,
            mock__neutron_create_floating_ip,
            mock_keystone_session,
            mock_nova_client):
        mock_has_service.return_value = True
        fip = _utils.normalize_neutron_floating_ips(
            self.mock_floating_ip_list_rep['floatingips'])[0]
        mock__neutron_create_floating_ip.return_value = fip
        mock_keystone_session.get_project_id.return_value = \
            '4969c491a3c74ee4af974e6d800c62df'
        fake_server = meta.obj_to_dict(fakes.FakeServer('1234', '', 'ACTIVE'))

        self.client.add_ips_to_server(
            fake_server, ip_pool='my-network', reuse=False)

        mock__neutron_create_floating_ip.assert_called_once_with(
            network_name_or_id='my-network', server=None,
            fixed_address=None, nat_destination=None, wait=False, timeout=60)
        mock_attach_ip_to_server.assert_called_once_with(
            server=fake_server, fixed_address=None,
            floating_ip=fip, wait=False, timeout=mock.ANY)