FM / v2

/usr/lib/python2.6/site-packages/openstackclient/tests/network/v2/

/usr/lib/python2.6/site-packages/openstackclient/tests/network/v2

Name	Size	Mode	Actions
fakes.py	1225	0644	edit dl rm
fakes.pyc	1249	0644	edit dl rm
test_floating_ip.py	13703	0644	edit dl rm
test_floating_ip.pyc	14099	0644	edit dl rm
test_network.py	15290	0644	edit dl rm
test_network.pyc	13559	0644	edit dl rm
test_port.py	13157	0644	edit dl rm
test_port.pyc	13438	0644	edit dl rm
test_router.py	19139	0644	edit dl rm
test_router.pyc	19811	0644	edit dl rm
test_security_group.py	21183	0644	edit dl rm
test_security_group.pyc	20746	0644	edit dl rm
test_security_group_rule.py	31882	0644	edit dl rm
test_security_group_rule.pyc	26396	0644	edit dl rm
test_subnet.py	22185	0644	edit dl rm
test_subnet.pyc	17157	0644	edit dl rm
test_subnet_pool.py	17473	0644	edit dl rm
test_subnet_pool.pyc	16224	0644	edit dl rm
__init__.py	0	0644	edit dl rm
__init__.pyc	176	0644	edit dl rm

Edit: /usr/lib/python2.6/site-packages/openstackclient/tests/network/v2/test_router.py (19139B)

#   Licensed under the Apache License, Version 2.0 (the "License"); you may
#   not use this file except in compliance with the License. You may obtain
#   a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#   License for the specific language governing permissions and limitations
#   under the License.
#

import mock

from openstackclient.common import exceptions
from openstackclient.common import utils as osc_utils
from openstackclient.network.v2 import router
from openstackclient.tests.network.v2 import fakes as network_fakes
from openstackclient.tests import utils as tests_utils

class TestRouter(network_fakes.TestNetworkV2):

def setUp(self):
        super(TestRouter, self).setUp()

# Get a shortcut to the network client
        self.network = self.app.client_manager.network

class TestAddPortToRouter(TestRouter):
    '''Add port to Router '''

_port = network_fakes.FakePort.create_one_port()
    _router = network_fakes.FakeRouter.create_one_router(
        attrs={'port': _port.id})

def setUp(self):
        super(TestAddPortToRouter, self).setUp()
        self.network.router_add_interface = mock.Mock()
        self.cmd = router.AddPortToRouter(self.app, self.namespace)
        self.network.find_router = mock.Mock(return_value=self._router)
        self.network.find_port = mock.Mock(return_value=self._port)

def test_add_port_no_option(self):
        arglist = []
        verifylist = []

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_add_port_required_options(self):
        arglist = [
            self._router.id,
            self._router.port,
        ]
        verifylist = [
            ('router', self._router.id),
            ('port', self._router.port),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)

self.network.router_add_interface.assert_called_with(self._router, **{
            'port_id': self._router.port,
        })
        self.assertIsNone(result)

class TestAddSubnetToRouter(TestRouter):
    '''Add subnet to Router '''

_subnet = network_fakes.FakeSubnet.create_one_subnet()
    _router = network_fakes.FakeRouter.create_one_router(
        attrs={'subnet': _subnet.id})

def setUp(self):
        super(TestAddSubnetToRouter, self).setUp()
        self.network.router_add_interface = mock.Mock()
        self.cmd = router.AddSubnetToRouter(self.app, self.namespace)
        self.network.find_router = mock.Mock(return_value=self._router)
        self.network.find_subnet = mock.Mock(return_value=self._subnet)

def test_add_subnet_no_option(self):
        arglist = []
        verifylist = []

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_add_subnet_required_options(self):
        arglist = [
            self._router.id,
            self._router.subnet,
        ]
        verifylist = [
            ('router', self._router.id),
            ('subnet', self._router.subnet),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)
        self.network.router_add_interface.assert_called_with(
            self._router, **{'subnet_id': self._router.subnet})

self.assertIsNone(result)

class TestCreateRouter(TestRouter):

# The new router created.
    new_router = network_fakes.FakeRouter.create_one_router()

columns = (
        'admin_state_up',
        'availability_zone_hints',
        'availability_zones',
        'distributed',
        'external_gateway_info',
        'ha',
        'id',
        'name',
        'project_id',
        'routes',
        'status',
    )
    data = (
        router._format_admin_state(new_router.admin_state_up),
        osc_utils.format_list(new_router.availability_zone_hints),
        osc_utils.format_list(new_router.availability_zones),
        new_router.distributed,
        router._format_external_gateway_info(new_router.external_gateway_info),
        new_router.ha,
        new_router.id,
        new_router.name,
        new_router.tenant_id,
        new_router.routes,
        new_router.status,
    )

def setUp(self):
        super(TestCreateRouter, self).setUp()

self.network.create_router = mock.Mock(return_value=self.new_router)

# Get the command object to test
        self.cmd = router.CreateRouter(self.app, self.namespace)

def test_create_no_options(self):
        arglist = []
        verifylist = []

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_create_default_options(self):
        arglist = [
            self.new_router.name,
        ]
        verifylist = [
            ('name', self.new_router.name),
            ('enable', True),
            ('distributed', False),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

columns, data = (self.cmd.take_action(parsed_args))

self.network.create_router.assert_called_once_with(**{
            'admin_state_up': True,
            'name': self.new_router.name,
        })
        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)

def test_create_with_AZ_hints(self):
        arglist = [
            self.new_router.name,
            '--availability-zone-hint', 'fake-az',
            '--availability-zone-hint', 'fake-az2',
        ]
        verifylist = [
            ('name', self.new_router.name),
            ('availability_zone_hints', ['fake-az', 'fake-az2']),
            ('enable', True),
            ('distributed', False),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

columns, data = (self.cmd.take_action(parsed_args))
        self.network.create_router.assert_called_once_with(**{
            'admin_state_up': True,
            'name': self.new_router.name,
            'availability_zone_hints': ['fake-az', 'fake-az2'],
        })

self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)

class TestDeleteRouter(TestRouter):

# The router to delete.
    _router = network_fakes.FakeRouter.create_one_router()

def setUp(self):
        super(TestDeleteRouter, self).setUp()

self.network.delete_router = mock.Mock(return_value=None)

self.network.find_router = mock.Mock(return_value=self._router)

# Get the command object to test
        self.cmd = router.DeleteRouter(self.app, self.namespace)

def test_delete(self):
        arglist = [
            self._router.name,
        ]
        verifylist = [
            ('router', [self._router.name]),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)
        self.network.delete_router.assert_called_once_with(self._router)
        self.assertIsNone(result)

class TestListRouter(TestRouter):

# The routers going to be listed up.
    routers = network_fakes.FakeRouter.create_routers(count=3)

columns = (
        'ID',
        'Name',
        'Status',
        'State',
        'Distributed',
        'HA',
        'Project',
    )
    columns_long = columns + (
        'Routes',
        'External gateway info',
        'Availability zones'
    )

data = []
    for r in routers:
        data.append((
            r.id,
            r.name,
            r.status,
            router._format_admin_state(r.admin_state_up),
            r.distributed,
            r.ha,
            r.tenant_id,
        ))
    data_long = []
    for i in range(0, len(routers)):
        r = routers[i]
        data_long.append(
            data[i] + (
                r.routes,
                router._format_external_gateway_info(r.external_gateway_info),
                osc_utils.format_list(r.availability_zones),
            )
        )

def setUp(self):
        super(TestListRouter, self).setUp()

# Get the command object to test
        self.cmd = router.ListRouter(self.app, self.namespace)

self.network.routers = mock.Mock(return_value=self.routers)

def test_router_list_no_options(self):
        arglist = []
        verifylist = [
            ('long', False),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

# In base command class Lister in cliff, abstract method take_action()
        # returns a tuple containing the column names and an iterable
        # containing the data to be listed.
        columns, data = self.cmd.take_action(parsed_args)

self.network.routers.assert_called_once_with()
        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, list(data))

def test_router_list_long(self):
        arglist = [
            '--long',
        ]
        verifylist = [
            ('long', True),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

self.network.routers.assert_called_once_with()
        self.assertEqual(self.columns_long, columns)
        self.assertEqual(self.data_long, list(data))

class TestRemovePortFromRouter(TestRouter):
    '''Remove port from a Router '''

_port = network_fakes.FakePort.create_one_port()
    _router = network_fakes.FakeRouter.create_one_router(
        attrs={'port': _port.id})

def setUp(self):
        super(TestRemovePortFromRouter, self).setUp()
        self.network.router_remove_interface = mock.Mock()
        self.cmd = router.RemovePortFromRouter(self.app, self.namespace)
        self.network.find_router = mock.Mock(return_value=self._router)
        self.network.find_port = mock.Mock(return_value=self._port)

def test_remove_port_no_option(self):
        arglist = []
        verifylist = []

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_remove_port_required_options(self):
        arglist = [
            self._router.id,
            self._router.port,
        ]
        verifylist = [
            ('router', self._router.id),
            ('port', self._router.port),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)

self.network.router_remove_interface.assert_called_with(
            self._router, **{'port_id': self._router.port})
        self.assertIsNone(result)

class TestRemoveSubnetFromRouter(TestRouter):
    '''Remove subnet from Router '''

_subnet = network_fakes.FakeSubnet.create_one_subnet()
    _router = network_fakes.FakeRouter.create_one_router(
        attrs={'subnet': _subnet.id})

def setUp(self):
        super(TestRemoveSubnetFromRouter, self).setUp()
        self.network.router_remove_interface = mock.Mock()
        self.cmd = router.RemoveSubnetFromRouter(self.app, self.namespace)
        self.network.find_router = mock.Mock(return_value=self._router)
        self.network.find_subnet = mock.Mock(return_value=self._subnet)

def test_remove_subnet_no_option(self):
        arglist = []
        verifylist = []

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_remove_subnet_required_options(self):
        arglist = [
            self._router.id,
            self._router.subnet,
        ]
        verifylist = [
            ('subnet', self._router.subnet),
            ('router', self._router.id),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)
        self.network.router_remove_interface.assert_called_with(
            self._router, **{'subnet_id': self._router.subnet})
        self.assertIsNone(result)

class TestSetRouter(TestRouter):

# The router to set.
    _router = network_fakes.FakeRouter.create_one_router()

def setUp(self):
        super(TestSetRouter, self).setUp()

self.network.update_router = mock.Mock(return_value=None)

self.network.find_router = mock.Mock(return_value=self._router)

# Get the command object to test
        self.cmd = router.SetRouter(self.app, self.namespace)

def test_set_this(self):
        arglist = [
            self._router.name,
            '--enable',
            '--distributed',
            '--name', 'noob',
        ]
        verifylist = [
            ('router', self._router.name),
            ('enable', True),
            ('distributed', True),
            ('name', 'noob'),
        ]

parsed_args = self.check_parser(self.cmd, arglist, verifylist)
        result = self.cmd.take_action(parsed_args)

attrs = {
            'admin_state_up': True,
            'distributed': True,
            'name': 'noob',
        }
        self.network.update_router.assert_called_once_with(
            self._router, **attrs)
        self.assertIsNone(result)

def test_set_that(self):
        arglist = [
            self._router.name,
            '--disable',
            '--centralized',
        ]
        verifylist = [
            ('router', self._router.name),
            ('disable', True),
            ('centralized', True),
        ]

parsed_args = self.check_parser(self.cmd, arglist, verifylist)
        result = self.cmd.take_action(parsed_args)

attrs = {
            'admin_state_up': False,
            'distributed': False,
        }
        self.network.update_router.assert_called_once_with(
            self._router, **attrs)
        self.assertIsNone(result)

def test_set_distributed_centralized(self):
        arglist = [
            self._router.name,
            '--distributed',
            '--centralized',
        ]
        verifylist = [
            ('router', self._router.name),
            ('distributed', True),
            ('distributed', False),
        ]

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_set_route(self):
        arglist = [
            self._router.name,
            '--route', 'destination=10.20.30.0/24,gateway=10.20.30.1',
        ]
        verifylist = [
            ('router', self._router.name),
            ('routes', [{'destination': '10.20.30.0/24',
                         'gateway': '10.20.30.1'}]),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)

attrs = {
            'routes': [{'destination': '10.20.30.0/24',
                        'gateway': '10.20.30.1'}],
        }
        self.network.update_router.assert_called_once_with(
            self._router, **attrs)
        self.assertIsNone(result)

def test_set_clear_routes(self):
        arglist = [
            self._router.name,
            '--clear-routes',
        ]
        verifylist = [
            ('router', self._router.name),
            ('clear_routes', True),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

result = self.cmd.take_action(parsed_args)

attrs = {
            'routes': [],
        }
        self.network.update_router.assert_called_once_with(
            self._router, **attrs)
        self.assertIsNone(result)

def test_set_route_clear_routes(self):
        arglist = [
            self._router.name,
            '--route', 'destination=10.20.30.0/24,gateway=10.20.30.1',
            '--clear-routes',
        ]
        verifylist = [
            ('router', self._router.name),
            ('routes', [{'destination': '10.20.30.0/24',
                         'gateway': '10.20.30.1'}]),
            ('clear_routes', True),
        ]

# Argument parse failing should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_set_nothing(self):
        arglist = [self._router.name, ]
        verifylist = [('router', self._router.name), ]

parsed_args = self.check_parser(self.cmd, arglist, verifylist)
        self.assertRaises(exceptions.CommandError, self.cmd.take_action,
                          parsed_args)

class TestShowRouter(TestRouter):

# The router to set.
    _router = network_fakes.FakeRouter.create_one_router()

columns = (
        'admin_state_up',
        'availability_zone_hints',
        'availability_zones',
        'distributed',
        'external_gateway_info',
        'ha',
        'id',
        'name',
        'project_id',
        'routes',
        'status',
    )
    data = (
        router._format_admin_state(_router.admin_state_up),
        osc_utils.format_list(_router.availability_zone_hints),
        osc_utils.format_list(_router.availability_zones),
        _router.distributed,
        router._format_external_gateway_info(_router.external_gateway_info),
        _router.ha,
        _router.id,
        _router.name,
        _router.tenant_id,
        _router.routes,
        _router.status,
    )

def setUp(self):
        super(TestShowRouter, self).setUp()

self.network.find_router = mock.Mock(return_value=self._router)

# Get the command object to test
        self.cmd = router.ShowRouter(self.app, self.namespace)

def test_show_no_options(self):
        arglist = []
        verifylist = []

# Missing required args should bail here
        self.assertRaises(tests_utils.ParserException, self.check_parser,
                          self.cmd, arglist, verifylist)

def test_show_all_options(self):
        arglist = [
            self._router.name,
        ]
        verifylist = [
            ('router', self._router.name),
        ]
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

columns, data = self.cmd.take_action(parsed_args)

self.network.find_router.assert_called_once_with(
            self._router.name, ignore_missing=False)
        self.assertEqual(tuple(self.columns), columns)
        self.assertEqual(self.data, data)

cmd: