python-openstackclient 6.6.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

openstackclient/tests/unit/network/v2/test_router.py

@@ -25,9 +25,9 @@ from openstackclient.tests.unit import utils as tests_utils
 
 class TestRouter(network_fakes.TestNetworkV2):
     def setUp(self):
-        super(TestRouter, self).setUp()
+        super().setUp()
 
-        self.projects_mock = self.app.client_manager.identity.projects
+        self.projects_mock = self.identity_client.projects
 
 
 class TestAddPortToRouter(TestRouter):
@@ -39,12 +39,12 @@ class TestAddPortToRouter(TestRouter):
     )
 
     def setUp(self):
-        super(TestAddPortToRouter, self).setUp()
+        super().setUp()
 
         self.network_client.find_router = mock.Mock(return_value=self._router)
         self.network_client.find_port = mock.Mock(return_value=self._port)
 
-        self.cmd = router.AddPortToRouter(self.app, self.namespace)
+        self.cmd = router.AddPortToRouter(self.app, None)
 
     def test_add_port_no_option(self):
         arglist = []
@@ -75,7 +75,7 @@ class TestAddPortToRouter(TestRouter):
             self._router,
             **{
                 'port_id': self._router.port,
-            }
+            },
         )
         self.assertIsNone(result)
 
@@ -89,12 +89,12 @@ class TestAddSubnetToRouter(TestRouter):
     )
 
     def setUp(self):
-        super(TestAddSubnetToRouter, self).setUp()
+        super().setUp()
 
         self.network_client.find_router = mock.Mock(return_value=self._router)
         self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
 
-        self.cmd = router.AddSubnetToRouter(self.app, self.namespace)
+        self.cmd = router.AddSubnetToRouter(self.app, None)
 
     def test_add_subnet_no_option(self):
         arglist = []
@@ -130,6 +130,7 @@ class TestAddSubnetToRouter(TestRouter):
 class TestCreateRouter(TestRouter):
     # The new router created.
     new_router = network_fakes.FakeRouter.create_one_router()
+    _extensions = {'fake': network_fakes.create_one_extension()}
 
     columns = (
         'admin_state_up',
@@ -163,15 +164,17 @@ class TestCreateRouter(TestRouter):
     )
 
     def setUp(self):
-        super(TestCreateRouter, self).setUp()
+        super().setUp()
 
         self.network_client.create_router = mock.Mock(
             return_value=self.new_router
         )
         self.network_client.set_tags = mock.Mock(return_value=None)
-
+        self.network_client.find_extension = mock.Mock(
+            side_effect=lambda name: self._extensions.get(name)
+        )
         # Get the command object to test
-        self.cmd = router.CreateRouter(self.app, self.namespace)
+        self.cmd = router.CreateRouter(self.app, None)
 
     def test_create_no_options(self):
         arglist = []
@@ -228,9 +231,9 @@ class TestCreateRouter(TestRouter):
             ('enable', True),
             ('distributed', False),
             ('ha', False),
-            ('external_gateway', _network.name),
+            ('external_gateways', [_network.name]),
             ('enable_snat', True),
-            ('fixed_ip', [{'ip-address': '2001:db8::1'}]),
+            ('fixed_ips', [{'ip-address': '2001:db8::1'}]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -381,13 +384,15 @@ class TestCreateRouter(TestRouter):
     def test_create_with_no_tag(self):
         self._test_create_with_tag(add_tags=False)
 
-    def test_create_with_flavor_id(self):
+    def test_create_with_flavor_id_or_name(self):
         _flavor = network_fakes.create_one_network_flavor()
+        self.network_client.find_flavor = mock.Mock(return_value=_flavor)
         arglist = [
             self.new_router.name,
             '--flavor-id',
             _flavor.id,
         ]
+        arglist_with_name = [self.new_router.name, '--flavor-id', _flavor.name]
         verifylist = [
             ('name', self.new_router.name),
             ('enable', True),
@@ -407,13 +412,103 @@ class TestCreateRouter(TestRouter):
         self.assertEqual(self.columns, columns)
         self.assertCountEqual(self.data, data)
 
+        self.network_client.create_router.reset_mock()
+        verifylist_w_name = [
+            ('name', self.new_router.name),
+            ('enable', True),
+            ('distributed', False),
+            ('ha', False),
+            ('flavor_id', _flavor.name),
+        ]
+        parsed_args_w_name = self.check_parser(
+            self.cmd, arglist_with_name, verifylist_w_name
+        )
+        columns, data = self.cmd.take_action(parsed_args_w_name)
+        self.network_client.create_router.assert_called_once_with(
+            **{
+                'admin_state_up': True,
+                'name': self.new_router.name,
+                'flavor_id': _flavor.id,
+            }
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertCountEqual(self.data, data)
+
+    def test_create_with_enable_default_route_bfd(self):
+        self.network_client.find_extension = mock.Mock(
+            return_value=network_fakes.create_one_extension(
+                attrs={'name': 'external-gateway-multihoming'}
+            )
+        )
+        arglist = [self.new_router.name, '--enable-default-route-bfd']
+        verifylist = [
+            ('name', self.new_router.name),
+            ('enable_default_route_bfd', True),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+        self.network_client.create_router.assert_called_once_with(
+            name=self.new_router.name,
+            admin_state_up=True,
+            enable_default_route_bfd=True,
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertCountEqual(self.data, data)
+
+    def test_create_with_enable_default_route_bfd_no_extension(self):
+        arglist = [self.new_router.name, '--enable-default-route-bfd']
+        verifylist = [
+            ('name', self.new_router.name),
+            ('enable_default_route_bfd', True),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(
+            exceptions.CommandError,
+            self.cmd.take_action,
+            parsed_args,
+        )
+
+    def test_create_with_enable_default_route_ecmp(self):
+        self.network_client.find_extension = mock.Mock(
+            return_value=network_fakes.create_one_extension(
+                attrs={'name': 'external-gateway-multihoming'}
+            )
+        )
+        arglist = [self.new_router.name, '--enable-default-route-ecmp']
+        verifylist = [
+            ('name', self.new_router.name),
+            ('enable_default_route_ecmp', True),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+        self.network_client.create_router.assert_called_once_with(
+            name=self.new_router.name,
+            admin_state_up=True,
+            enable_default_route_ecmp=True,
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertCountEqual(self.data, data)
+
+    def test_create_with_enable_default_route_ecmp_no_extension(self):
+        arglist = [self.new_router.name, '--enable-default-route-ecmp']
+        verifylist = [
+            ('name', self.new_router.name),
+            ('enable_default_route_ecmp', True),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(
+            exceptions.CommandError,
+            self.cmd.take_action,
+            parsed_args,
+        )
+
 
 class TestDeleteRouter(TestRouter):
     # The routers to delete.
     _routers = network_fakes.FakeRouter.create_routers(count=2)
 
     def setUp(self):
-        super(TestDeleteRouter, self).setUp()
+        super().setUp()
 
         self.network_client.delete_router = mock.Mock(return_value=None)
 
@@ -422,7 +517,7 @@ class TestDeleteRouter(TestRouter):
         )
 
         # Get the command object to test
-        self.cmd = router.DeleteRouter(self.app, self.namespace)
+        self.cmd = router.DeleteRouter(self.app, None)
 
     def test_router_delete(self):
         arglist = [
@@ -571,10 +666,10 @@ class TestListRouter(TestRouter):
         )
 
     def setUp(self):
-        super(TestListRouter, self).setUp()
+        super().setUp()
 
         # Get the command object to test
-        self.cmd = router.ListRouter(self.app, self.namespace)
+        self.cmd = router.ListRouter(self.app, None)
 
         self.network_client.agent_hosted_routers = mock.Mock(
             return_value=self.routers
@@ -834,12 +929,12 @@ class TestRemovePortFromRouter(TestRouter):
     )
 
     def setUp(self):
-        super(TestRemovePortFromRouter, self).setUp()
+        super().setUp()
 
         self.network_client.find_router = mock.Mock(return_value=self._router)
         self.network_client.find_port = mock.Mock(return_value=self._port)
 
-        self.cmd = router.RemovePortFromRouter(self.app, self.namespace)
+        self.cmd = router.RemovePortFromRouter(self.app, None)
 
     def test_remove_port_no_option(self):
         arglist = []
@@ -881,12 +976,12 @@ class TestRemoveSubnetFromRouter(TestRouter):
     )
 
     def setUp(self):
-        super(TestRemoveSubnetFromRouter, self).setUp()
+        super().setUp()
 
         self.network_client.find_router = mock.Mock(return_value=self._router)
         self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
 
-        self.cmd = router.RemoveSubnetFromRouter(self.app, self.namespace)
+        self.cmd = router.RemoveSubnetFromRouter(self.app, None)
 
     def test_remove_subnet_no_option(self):
         arglist = []
@@ -922,11 +1017,11 @@ class TestAddExtraRoutesToRouter(TestRouter):
     _router = network_fakes.FakeRouter.create_one_router()
 
     def setUp(self):
-        super(TestAddExtraRoutesToRouter, self).setUp()
+        super().setUp()
         self.network_client.add_extra_routes_to_router = mock.Mock(
             return_value=self._router
         )
-        self.cmd = router.AddExtraRoutesToRouter(self.app, self.namespace)
+        self.cmd = router.AddExtraRoutesToRouter(self.app, None)
         self.network_client.find_router = mock.Mock(return_value=self._router)
 
     def test_add_no_extra_route(self):
@@ -1011,11 +1106,11 @@ class TestRemoveExtraRoutesFromRouter(TestRouter):
     _router = network_fakes.FakeRouter.create_one_router()
 
     def setUp(self):
-        super(TestRemoveExtraRoutesFromRouter, self).setUp()
+        super().setUp()
         self.network_client.remove_extra_routes_from_router = mock.Mock(
             return_value=self._router
         )
-        self.cmd = router.RemoveExtraRoutesFromRouter(self.app, self.namespace)
+        self.cmd = router.RemoveExtraRoutesFromRouter(self.app, None)
         self.network_client.find_router = mock.Mock(return_value=self._router)
 
     def test_remove_no_extra_route(self):
@@ -1100,13 +1195,16 @@ class TestSetRouter(TestRouter):
     # The router to set.
     _default_route = {'destination': '10.20.20.0/24', 'nexthop': '10.20.30.1'}
     _network = network_fakes.create_one_network()
-    _subnet = network_fakes.FakeSubnet.create_one_subnet()
+    _subnet = network_fakes.FakeSubnet.create_one_subnet(
+        attrs={'network_id': _network.id}
+    )
     _router = network_fakes.FakeRouter.create_one_router(
         attrs={'routes': [_default_route], 'tags': ['green', 'red']}
     )
+    _extensions = {'fake': network_fakes.create_one_extension()}
 
     def setUp(self):
-        super(TestSetRouter, self).setUp()
+        super().setUp()
         self.network_client.update_router = mock.Mock(return_value=None)
         self.network_client.set_tags = mock.Mock(return_value=None)
         self.network_client.find_router = mock.Mock(return_value=self._router)
@@ -1114,9 +1212,11 @@ class TestSetRouter(TestRouter):
             return_value=self._network
         )
         self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
-
+        self.network_client.find_extension = mock.Mock(
+            side_effect=lambda name: self._extensions.get(name)
+        )
         # Get the command object to test
-        self.cmd = router.SetRouter(self.app, self.namespace)
+        self.cmd = router.SetRouter(self.app, None)
 
     def test_set_this(self):
         arglist = [
@@ -1297,7 +1397,7 @@ class TestSetRouter(TestRouter):
             self._router.id,
         ]
         verifylist = [
-            ('fixed_ip', [{'subnet': "'abc'"}]),
+            ('fixed_ips', [{'subnet': "'abc'"}]),
             ('router', self._router.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1312,7 +1412,7 @@ class TestSetRouter(TestRouter):
             self._router.id,
         ]
         verifylist = [
-            ('external_gateway', self._network.id),
+            ('external_gateways', [self._network.id]),
             ('router', self._router.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1320,7 +1420,7 @@ class TestSetRouter(TestRouter):
         result = self.cmd.take_action(parsed_args)
         self.network_client.update_router.assert_called_with(
             self._router,
-            **{'external_gateway_info': {'network_id': self._network.id}}
+            **{'external_gateway_info': {'network_id': self._network.id}},
         )
         self.assertIsNone(result)
 
@@ -1335,8 +1435,8 @@ class TestSetRouter(TestRouter):
         ]
         verifylist = [
             ('router', self._router.id),
-            ('external_gateway', self._network.id),
-            ('fixed_ip', [{'subnet': "'abc'"}]),
+            ('external_gateways', [self._network.id]),
+            ('fixed_ips', [{'subnet': "'abc'"}]),
             ('enable_snat', True),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1354,7 +1454,7 @@ class TestSetRouter(TestRouter):
                     ],
                     'enable_snat': True,
                 }
-            }
+            },
         )
         self.assertIsNone(result)
 
@@ -1369,8 +1469,8 @@ class TestSetRouter(TestRouter):
         ]
         verifylist = [
             ('router', self._router.id),
-            ('external_gateway', self._network.id),
-            ('fixed_ip', [{'ip-address': "10.0.1.1"}]),
+            ('external_gateways', [self._network.id]),
+            ('fixed_ips', [{'ip-address': "10.0.1.1"}]),
             ('enable_snat', True),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1388,7 +1488,7 @@ class TestSetRouter(TestRouter):
                     ],
                     'enable_snat': True,
                 }
-            }
+            },
         )
         self.assertIsNone(result)
 
@@ -1403,8 +1503,8 @@ class TestSetRouter(TestRouter):
         ]
         verifylist = [
             ('router', self._router.id),
-            ('external_gateway', self._network.id),
-            ('fixed_ip', [{'subnet': "'abc'", 'ip-address': "10.0.1.1"}]),
+            ('external_gateways', [self._network.id]),
+            ('fixed_ips', [{'subnet': "'abc'", 'ip-address': "10.0.1.1"}]),
             ('enable_snat', True),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1423,7 +1523,7 @@ class TestSetRouter(TestRouter):
                     ],
                     'enable_snat': True,
                 }
-            }
+            },
         )
         self.assertIsNone(result)
 
@@ -1468,7 +1568,7 @@ class TestSetRouter(TestRouter):
         ]
         verifylist = [
             ('router', self._router.id),
-            ('external_gateway', self._network.id),
+            ('external_gateways', [self._network.id]),
             ('qos_policy', qos_policy.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1481,7 +1581,7 @@ class TestSetRouter(TestRouter):
                     'network_id': self._network.id,
                     'qos_policy_id': qos_policy.id,
                 }
-            }
+            },
         )
         self.assertIsNone(result)
 
@@ -1494,7 +1594,7 @@ class TestSetRouter(TestRouter):
         ]
         verifylist = [
             ('router', self._router.id),
-            ('external_gateway', self._network.id),
+            ('external_gateways', [self._network.id]),
             ('no_qos_policy', True),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1507,7 +1607,7 @@ class TestSetRouter(TestRouter):
                     'network_id': self._network.id,
                     'qos_policy_id': None,
                 }
-            }
+            },
         )
         self.assertIsNone(result)
 
@@ -1526,7 +1626,7 @@ class TestSetRouter(TestRouter):
         ]
         verifylist = [
             ('router', self._router.id),
-            ('external_gateway', self._network.id),
+            ('external_gateways', [self._network.id]),
             ('qos_policy', qos_policy.id),
             ('no_qos_policy', True),
         ]
@@ -1634,13 +1734,13 @@ class TestShowRouter(TestRouter):
     )
 
     def setUp(self):
-        super(TestShowRouter, self).setUp()
+        super().setUp()
 
         self.network_client.find_router = mock.Mock(return_value=self._router)
         self.network_client.ports = mock.Mock(return_value=[self._port])
 
         # Get the command object to test
-        self.cmd = router.ShowRouter(self.app, self.namespace)
+        self.cmd = router.ShowRouter(self.app, None)
 
     def test_show_no_options(self):
         arglist = []
@@ -1717,7 +1817,7 @@ class TestShowRouter(TestRouter):
 
 class TestUnsetRouter(TestRouter):
     def setUp(self):
-        super(TestUnsetRouter, self).setUp()
+        super().setUp()
         self.fake_network = network_fakes.create_one_network()
         self.fake_qos_policy = (
             network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
@@ -1747,8 +1847,15 @@ class TestUnsetRouter(TestRouter):
         )
         self.network_client.update_router = mock.Mock(return_value=None)
         self.network_client.set_tags = mock.Mock(return_value=None)
+        self._extensions = {'fake': network_fakes.create_one_extension()}
+        self.network_client.find_extension = mock.Mock(
+            side_effect=lambda name: self._extensions.get(name)
+        )
+        self.network_client.remove_external_gateways = mock.Mock(
+            return_value=None
+        )
         # Get the command object to test
-        self.cmd = router.UnsetRouter(self.app, self.namespace)
+        self.cmd = router.UnsetRouter(self.app, None)
 
     def test_unset_router_params(self):
         arglist = [
@@ -1799,7 +1906,7 @@ class TestUnsetRouter(TestRouter):
             '--external-gateway',
             self._testrouter.name,
         ]
-        verifylist = [('external_gateway', True)]
+        verifylist = [('external_gateways', True)]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
         attrs = {'external_gateway_info': {}}
@@ -1808,6 +1915,33 @@ class TestUnsetRouter(TestRouter):
         )
         self.assertIsNone(result)
 
+    def test_unset_router_external_gateway_multiple_supported(self):
+        # Add the relevant extension in order to test the alternate behavior.
+        self._extensions = {
+            'external-gateway-multihoming': network_fakes.create_one_extension(
+                attrs={'name': 'external-gateway-multihoming'}
+            )
+        }
+        arglist = [
+            '--external-gateway',
+            self._testrouter.name,
+        ]
+        verifylist = [('external_gateways', True)]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        # The removal of all gateways should be requested using the multiple
+        # gateways API.
+        self.network_client.remove_external_gateways.assert_called_once_with(
+            self._testrouter, body={'router': {'external_gateways': {}}}
+        )
+        # The compatibility API will also be called in order to potentially
+        # unset other parameters along with external_gateway_info which
+        # should already be empty at that point anyway.
+        self.network_client.update_router.assert_called_once_with(
+            self._testrouter, **{'external_gateway_info': {}}
+        )
+        self.assertIsNone(result)
+
     def _test_unset_tags(self, with_tags=True):
         if with_tags:
             arglist = ['--tag', 'red', '--tag', 'blue']
@@ -1895,3 +2029,539 @@ class TestUnsetRouter(TestRouter):
         self.assertRaises(
             exceptions.CommandError, self.cmd.take_action, parsed_args
         )
+
+
+class TestGatewayOps(TestRouter):
+    def setUp(self):
+        super().setUp()
+        self._networks = []
+        self._network = network_fakes.create_one_network()
+        self._networks.append(self._network)
+
+        self._router = network_fakes.FakeRouter.create_one_router(
+            {
+                'external_gateway_info': {
+                    'network_id': self._network.id,
+                },
+            }
+        )
+        self._subnet = network_fakes.FakeSubnet.create_one_subnet(
+            attrs={'network_id': self._network.id}
+        )
+        self._extensions = {
+            'external-gateway-multihoming': network_fakes.create_one_extension(
+                attrs={'name': 'external-gateway-multihoming'}
+            )
+        }
+        self.network_client.find_extension = mock.Mock(
+            side_effect=lambda name: self._extensions.get(name)
+        )
+        self.network_client.find_router = mock.Mock(return_value=self._router)
+
+        def _find_network(name_or_id, ignore_missing):
+            for network in self._networks:
+                if name_or_id in (network.id, network.name):
+                    return network
+            if ignore_missing:
+                return None
+            raise Exception('Test resource not found')
+
+        self.network_client.find_network = mock.Mock(side_effect=_find_network)
+
+        self.network_client.find_subnet = mock.Mock(return_value=self._subnet)
+        self.network_client.add_external_gateways = mock.Mock(
+            return_value=None
+        )
+        self.network_client.remove_external_gateways = mock.Mock(
+            return_value=None
+        )
+
+
+class TestCreateMultipleGateways(TestGatewayOps):
+    _columns = (
+        'admin_state_up',
+        'availability_zone_hints',
+        'availability_zones',
+        'description',
+        'distributed',
+        'external_gateway_info',
+        'ha',
+        'id',
+        'name',
+        'project_id',
+        'routes',
+        'status',
+        'tags',
+    )
+
+    def setUp(self):
+        super().setUp()
+        self._second_network = network_fakes.create_one_network()
+        self._networks.append(self._second_network)
+
+        self.network_client.create_router = mock.Mock(
+            return_value=self._router
+        )
+        self.network_client.update_router = mock.Mock(return_value=None)
+        self.network_client.update_external_gateways = mock.Mock(
+            return_value=None
+        )
+
+        self._data = (
+            router.AdminStateColumn(self._router.admin_state_up),
+            format_columns.ListColumn(self._router.availability_zone_hints),
+            format_columns.ListColumn(self._router.availability_zones),
+            self._router.description,
+            self._router.distributed,
+            router.RouterInfoColumn(self._router.external_gateway_info),
+            self._router.ha,
+            self._router.id,
+            self._router.name,
+            self._router.project_id,
+            router.RoutesColumn(self._router.routes),
+            self._router.status,
+            format_columns.ListColumn(self._router.tags),
+        )
+        self.cmd = router.CreateRouter(self.app, None)
+
+    def test_create_one_gateway(self):
+        arglist = [
+            "--external-gateway",
+            self._network.id,
+            self._router.name,
+        ]
+        verifylist = [
+            ('name', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        columns, data = self.cmd.take_action(parsed_args)
+        self.network_client.update_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                        }
+                    ]
+                }
+            },
+        )
+        self.assertEqual(self._columns, columns)
+        self.assertCountEqual(self._data, data)
+
+    def test_create_multiple_gateways(self):
+        arglist = [
+            self._router.name,
+            "--external-gateway",
+            self._network.id,
+            "--external-gateway",
+            self._network.id,
+            "--external-gateway",
+            self._second_network.id,
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.1',
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.2',
+        ]
+        verifylist = [
+            ('name', self._router.name),
+            (
+                'external_gateways',
+                [self._network.id, self._network.id, self._second_network.id],
+            ),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        # The router will not have a gateway after the create call, but it
+        # will be added after the update call.
+        self.network_client.create_router.assert_called_once_with(
+            **{
+                'admin_state_up': True,
+                'name': self._router.name,
+            }
+        )
+        self.network_client.update_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.1',
+                                }
+                            ],
+                        },
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.2',
+                                }
+                            ],
+                        },
+                        {
+                            'network_id': self._second_network.id,
+                        },
+                    ]
+                }
+            },
+        )
+        self.assertEqual(self._columns, columns)
+        self.assertCountEqual(self._data, data)
+
+
+class TestUpdateMultipleGateways(TestGatewayOps):
+    def setUp(self):
+        super().setUp()
+        self._second_network = network_fakes.create_one_network()
+        self._networks.append(self._second_network)
+
+        self.network_client.update_router = mock.Mock(return_value=None)
+        self.network_client.update_external_gateways = mock.Mock(
+            return_value=None
+        )
+        self.cmd = router.SetRouter(self.app, None)
+
+    def test_update_one_gateway(self):
+        arglist = [
+            "--external-gateway",
+            self._network.id,
+            "--no-qos-policy",
+            self._router.name,
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+            ('no_qos_policy', True),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.update_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {'network_id': self._network.id, 'qos_policy_id': None}
+                    ]
+                }
+            },
+        )
+        self.assertIsNone(result)
+
+    def test_update_multiple_gateways(self):
+        arglist = [
+            self._router.name,
+            "--external-gateway",
+            self._network.id,
+            "--external-gateway",
+            self._network.id,
+            "--external-gateway",
+            self._second_network.id,
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.1',
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.2',
+            "--no-qos-policy",
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            (
+                'external_gateways',
+                [self._network.id, self._network.id, self._second_network.id],
+            ),
+            ('no_qos_policy', True),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.update_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.1',
+                                }
+                            ],
+                            'qos_policy_id': None,
+                        },
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.2',
+                                }
+                            ],
+                            'qos_policy_id': None,
+                        },
+                        {
+                            'network_id': self._second_network.id,
+                            'qos_policy_id': None,
+                        },
+                    ]
+                }
+            },
+        )
+        self.assertIsNone(result)
+
+
+class TestAddGatewayRouter(TestGatewayOps):
+    def setUp(self):
+        super().setUp()
+        # Get the command object to test
+        self.cmd = router.AddGatewayToRouter(self.app, None)
+
+        self.network_client.add_external_gateways.return_value = self._router
+
+    def test_add_gateway_network_only(self):
+        arglist = [
+            self._router.name,
+            self._network.id,
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.add_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [{'network_id': self._network.id}]
+                }
+            },
+        )
+        self.assertEqual(result[1][result[0].index('id')], self._router.id)
+
+    def test_add_gateway_network_fixed_ip(self):
+        arglist = [
+            self._router.name,
+            self._network.id,
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.1',
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.add_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.1',
+                                }
+                            ],
+                        }
+                    ]
+                }
+            },
+        )
+        self.assertEqual(result[1][result[0].index('id')], self._router.id)
+
+    def test_add_gateway_network_multiple_fixed_ips(self):
+        arglist = [
+            self._router.name,
+            self._network.id,
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.1',
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.2',
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+            (
+                'fixed_ips',
+                [
+                    {'ip-address': '10.0.1.1', 'subnet': self._subnet.id},
+                    {'ip-address': '10.0.1.2', 'subnet': self._subnet.id},
+                ],
+            ),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.add_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.1',
+                                },
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.2',
+                                },
+                            ],
+                        }
+                    ]
+                }
+            },
+        )
+        self.assertEqual(result[1][result[0].index('id')], self._router.id)
+
+    def test_add_gateway_network_only_no_extension(self):
+        self._extensions = {}
+        arglist = [
+            self._router.name,
+            self._network.id,
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(
+            exceptions.CommandError, self.cmd.take_action, parsed_args
+        )
+
+
+class TestRemoveGatewayRouter(TestGatewayOps):
+    def setUp(self):
+        super().setUp()
+        # Get the command object to test
+        self.cmd = router.RemoveGatewayFromRouter(self.app, None)
+
+        self.network_client.remove_external_gateways.return_value = (
+            self._router
+        )
+
+    def test_remove_gateway_network_only(self):
+        arglist = [
+            self._router.name,
+            self._network.id,
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.remove_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [{'network_id': self._network.id}]
+                }
+            },
+        )
+        self.assertEqual(result[1][result[0].index('id')], self._router.id)
+
+    def test_remove_gateway_network_fixed_ip(self):
+        arglist = [
+            self._router.name,
+            self._network.id,
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.1',
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.remove_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.1',
+                                }
+                            ],
+                        }
+                    ]
+                }
+            },
+        )
+        self.assertEqual(result[1][result[0].index('id')], self._router.id)
+
+    def test_remove_gateway_network_multiple_fixed_ips(self):
+        arglist = [
+            self._router.name,
+            self._network.id,
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.1',
+            '--fixed-ip',
+            f'subnet={self._subnet.id},ip-address=10.0.1.2',
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+            (
+                'fixed_ips',
+                [
+                    {'ip-address': '10.0.1.1', 'subnet': self._subnet.id},
+                    {'ip-address': '10.0.1.2', 'subnet': self._subnet.id},
+                ],
+            ),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network_client.remove_external_gateways.assert_called_with(
+            self._router,
+            body={
+                'router': {
+                    'external_gateways': [
+                        {
+                            'network_id': self._network.id,
+                            'external_fixed_ips': [
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.1',
+                                },
+                                {
+                                    'subnet_id': self._subnet.id,
+                                    'ip_address': '10.0.1.2',
+                                },
+                            ],
+                        }
+                    ]
+                }
+            },
+        )
+        self.assertEqual(result[1][result[0].index('id')], self._router.id)
+
+    def test_remove_gateway_network_only_no_extension(self):
+        self._extensions = {}
+        arglist = [
+            self._router.name,
+            self._network.id,
+        ]
+        verifylist = [
+            ('router', self._router.name),
+            ('external_gateways', [self._network.id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(
+            exceptions.CommandError, self.cmd.take_action, parsed_args
+        )