From d404a6021c0ae0da9d02707e5c8979e4875a825c Mon Sep 17 00:00:00 2001 From: Sam Morrison Date: Mon, 23 Mar 2020 13:02:11 +1100 Subject: [PATCH] Add availability zone and availability zone profile resources to load balancer Change-Id: I979a5b84492e73f02417004fb74cf0523d2f9a20 --- doc/source/user/proxies/load_balancer_v2.rst | 25 +++ .../user/resources/load_balancer/index.rst | 2 + .../load_balancer/v2/availability_zone.rst | 13 ++ .../v2/availability_zone_profile.rst | 13 ++ openstack/load_balancer/v2/_proxy.py | 178 ++++++++++++++++++ .../load_balancer/v2/availability_zone.py | 43 +++++ .../v2/availability_zone_profile.py | 41 ++++ .../load_balancer/v2/test_load_balancer.py | 114 ++++++++++- .../load_balancer/test_availability_zone.py | 59 ++++++ .../test_availability_zone_profile.py | 59 ++++++ .../tests/unit/load_balancer/test_proxy.py | 51 +++++ ...d-az-to-loadbalancer-da9bf1baaedc89a4.yaml | 5 + 12 files changed, 599 insertions(+), 4 deletions(-) create mode 100644 doc/source/user/resources/load_balancer/v2/availability_zone.rst create mode 100644 doc/source/user/resources/load_balancer/v2/availability_zone_profile.rst create mode 100644 openstack/load_balancer/v2/availability_zone.py create mode 100644 openstack/load_balancer/v2/availability_zone_profile.py create mode 100644 openstack/tests/unit/load_balancer/test_availability_zone.py create mode 100644 openstack/tests/unit/load_balancer/test_availability_zone_profile.py create mode 100644 releasenotes/notes/add-az-to-loadbalancer-da9bf1baaedc89a4.yaml diff --git a/doc/source/user/proxies/load_balancer_v2.rst b/doc/source/user/proxies/load_balancer_v2.rst index 26e23881d..ea91fd87f 100644 --- a/doc/source/user/proxies/load_balancer_v2.rst +++ b/doc/source/user/proxies/load_balancer_v2.rst @@ -150,3 +150,28 @@ Amphora Operations .. automethod:: openstack.load_balancer.v2._proxy.Proxy.find_amphora .. automethod:: openstack.load_balancer.v2._proxy.Proxy.configure_amphora .. automethod:: openstack.load_balancer.v2._proxy.Proxy.failover_amphora + +Availability Zone Profile Operations +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. autoclass:: openstack.load_balancer.v2._proxy.Proxy + + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.create_availability_zone_profile + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.get_availability_zone_profile + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.availability_zone_profiles + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.delete_availability_zone_profile + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.find_availability_zone_profile + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.update_availability_zone_profile + +Availability Zone Operations +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. autoclass:: openstack.load_balancer.v2._proxy.Proxy + + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.create_availability_zone + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.get_availability_zone + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.availability_zones + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.delete_availability_zone + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.find_availability_zone + .. automethod:: openstack.load_balancer.v2._proxy.Proxy.update_availability_zone + diff --git a/doc/source/user/resources/load_balancer/index.rst b/doc/source/user/resources/load_balancer/index.rst index c34a7783f..1eebf3787 100644 --- a/doc/source/user/resources/load_balancer/index.rst +++ b/doc/source/user/resources/load_balancer/index.rst @@ -16,3 +16,5 @@ Load Balancer Resources v2/flavor v2/quota v2/amphora + v2/availability_zone_profile + v2/availability_zone diff --git a/doc/source/user/resources/load_balancer/v2/availability_zone.rst b/doc/source/user/resources/load_balancer/v2/availability_zone.rst new file mode 100644 index 000000000..8f8889b50 --- /dev/null +++ b/doc/source/user/resources/load_balancer/v2/availability_zone.rst @@ -0,0 +1,13 @@ +openstack.load_balancer.v2.availability_zone +============================================ + +.. automodule:: openstack.load_balancer.v2.availability_zone + +The AvailabilityZone Class +-------------------------- + +The ``AvailabilityZone`` class inherits from +:class:`~openstack.resource.Resource`. + +.. autoclass:: openstack.load_balancer.v2.availability_zone.AvailabilityZone + :members: diff --git a/doc/source/user/resources/load_balancer/v2/availability_zone_profile.rst b/doc/source/user/resources/load_balancer/v2/availability_zone_profile.rst new file mode 100644 index 000000000..0aa2c6a3b --- /dev/null +++ b/doc/source/user/resources/load_balancer/v2/availability_zone_profile.rst @@ -0,0 +1,13 @@ +openstack.load_balancer.v2.availability_zone_profile +==================================================== + +.. automodule:: openstack.load_balancer.v2.availability_zone_profile + +The AvailabilityZoneProfile Class +--------------------------------- + +The ``AvailabilityZoneProfile`` class inherits from +:class:`~openstack.resource.Resource`. + +.. autoclass:: openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile + :members: diff --git a/openstack/load_balancer/v2/_proxy.py b/openstack/load_balancer/v2/_proxy.py index 6b1f8c7e2..1b9ae05dd 100644 --- a/openstack/load_balancer/v2/_proxy.py +++ b/openstack/load_balancer/v2/_proxy.py @@ -11,6 +11,9 @@ # under the License. from openstack.load_balancer.v2 import amphora as _amphora +from openstack.load_balancer.v2 import availability_zone as _availability_zone +from openstack.load_balancer.v2 import availability_zone_profile as \ + _availability_zone_profile from openstack.load_balancer.v2 import flavor as _flavor from openstack.load_balancer.v2 import flavor_profile as _flavor_profile from openstack.load_balancer.v2 import health_monitor as _hm @@ -1005,3 +1008,178 @@ class Proxy(proxy.Proxy): :returns: ``None`` """ return self._update(_amphora.AmphoraFailover, amphora_id=amphora_id) + + def create_availability_zone_profile(self, **attrs): + """Create a new availability zone profile from attributes + + :param dict attrs: Keyword arguments which will be used to create + a :class:`~openstack.load_balancer.v2. + availability_zone_profile.AvailabilityZoneProfile`, + comprised of the properties on the + AvailabilityZoneProfile class. + + :returns: The results of profile creation creation + :rtype: :class:`~openstack.load_balancer.v2.availability_zone_profile. + AvailabilityZoneProfile` + """ + return self._create(_availability_zone_profile.AvailabilityZoneProfile, + **attrs) + + def get_availability_zone_profile(self, *attrs): + """Get an availability zone profile + + :param availability_zone_profile: The value can be the name of an + availability_zone profile + or :class:`~openstack.load_balancer.v2.availability_zone_profile. + AvailabilityZoneProfile` instance. + + :returns: One + :class:`~openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile` + """ + return self._get(_availability_zone_profile.AvailabilityZoneProfile, + *attrs) + + def availability_zone_profiles(self, **query): + """Retrieve a generator of availability zone profiles + + :returns: A generator of availability zone profiles instances + """ + return self._list(_availability_zone_profile.AvailabilityZoneProfile, + **query) + + def delete_availability_zone_profile(self, availability_zone_profile, + ignore_missing=True): + """Delete an availability zone profile + + :param availability_zone_profile: The availability_zone_profile can be + either the name or a + :class:`~openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile` + instance + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be raised when + the availability zone profile does not exist. + When set to ``True``, no exception will be set when attempting to + delete a nonexistent availability zone profile. + + :returns: ``None`` + """ + self._delete(_availability_zone_profile.AvailabilityZoneProfile, + availability_zone_profile, ignore_missing=ignore_missing) + + def find_availability_zone_profile(self, name_or_id, ignore_missing=True): + """Find a single availability zone profile + + :param name_or_id: The name or ID of a availability zone profile + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be raised + when the availability zone profile does not exist. + When set to ``True``, no exception will be set when attempting + to delete a nonexistent availability zone profile. + + :returns: ``None`` + """ + return self._find(_availability_zone_profile.AvailabilityZoneProfile, + name_or_id, ignore_missing=ignore_missing) + + def update_availability_zone_profile(self, availability_zone_profile, + **attrs): + """Update an availability zone profile + + :param availability_zone_profile: The availability_zone_profile can be + either the name or a + :class:`~openstack.load_balancer.v2.availability_zone_profile.AvailabilityZoneProfile` + instance + :param dict attrs: The attributes to update on the availability_zone + profile represented by + ``availability_zone_profile``. + + :returns: The updated availability zone profile + :rtype: :class:`~openstack.load_balancer.v2.availability_zone_profile. + AvailabilityZoneProfile` + """ + return self._update(_availability_zone_profile.AvailabilityZoneProfile, + availability_zone_profile, **attrs) + + def create_availability_zone(self, **attrs): + """Create a new availability zone from attributes + + :param dict attrs: Keyword arguments which will be used to create + a :class:`~openstack.load_balancer.v2. + availability_zone.AvailabilityZone`, comprised of + the properties on the AvailabilityZoneclass. + + :returns: The results of availability_zone creation creation + :rtype: + :class:`~openstack.load_balancer.v2.availability_zone.AvailabilityZone` + """ + return self._create(_availability_zone.AvailabilityZone, **attrs) + + def get_availability_zone(self, *attrs): + """Get an availability zone + + :param availability_zone: The value can be the name of a + availability_zone or + :class:`~openstack.load_balancer.v2.availability_zone.AvailabilityZone` + instance. + + :returns: One + :class:`~openstack.load_balancer.v2.availability_zone.AvailabilityZone` + """ + return self._get(_availability_zone.AvailabilityZone, *attrs) + + def availability_zones(self, **query): + """Retrieve a generator of availability zones + + :returns: A generator of availability zone instances + """ + return self._list(_availability_zone.AvailabilityZone, **query) + + def delete_availability_zone(self, availability_zone, ignore_missing=True): + """Delete an availability_zone + + :param availability_zone: The availability_zone can be either the name + or a + :class:`~openstack.load_balancer.v2.availability_zone.AvailabilityZone` + instance + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be raised when + the availability zone does not exist. + When set to ``True``, no exception will be set when attempting to + delete a nonexistent availability zone. + + :returns: ``None`` + """ + self._delete(_availability_zone.AvailabilityZone, availability_zone, + ignore_missing=ignore_missing) + + def find_availability_zone(self, name_or_id, ignore_missing=True): + """Find a single availability zone + + :param name_or_id: The name or ID of a availability zone + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be raised + when the availability zone does not exist. + When set to ``True``, no exception will be set when attempting + to delete a nonexistent availability zone. + + :returns: ``None`` + """ + return self._find(_availability_zone.AvailabilityZone, name_or_id, + ignore_missing=ignore_missing) + + def update_availability_zone(self, availability_zone, **attrs): + """Update an availability zone + + :param availability_zone: The availability_zone can be either the name + or a + :class:`~openstack.load_balancer.v2.availability_zone.AvailabilityZone` + instance + :param dict attrs: The attributes to update on the availability_zone + represented by ``availability_zone``. + + :returns: The updated availability_zone + :rtype: + :class:`~openstack.load_balancer.v2.availability_zone.AvailabilityZone` + """ + return self._update(_availability_zone.AvailabilityZone, + availability_zone, **attrs) diff --git a/openstack/load_balancer/v2/availability_zone.py b/openstack/load_balancer/v2/availability_zone.py new file mode 100644 index 000000000..9be7a4167 --- /dev/null +++ b/openstack/load_balancer/v2/availability_zone.py @@ -0,0 +1,43 @@ +# +# 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. + +from openstack import resource + + +class AvailabilityZone(resource.Resource): + resource_key = 'availability_zone' + resources_key = 'availability_zones' + base_path = '/lbaas/availabilityzones' + + # capabilities + allow_create = True + allow_fetch = True + allow_commit = True + allow_delete = True + allow_list = True + + _query_mapping = resource.QueryParameters( + 'name', 'description', 'availability_zone_profile_id', + is_enabled='enabled' + ) + + # Properties + #: The name of the availability zone. + name = resource.Body('name') + #: The availability zone description. + description = resource.Body('description') + #: The associated availability zone profile ID + availability_zone_profile_id = resource.Body( + 'availability_zone_profile_id') + #: Whether the availability zone is enabled for use or not. + is_enabled = resource.Body('enabled') diff --git a/openstack/load_balancer/v2/availability_zone_profile.py b/openstack/load_balancer/v2/availability_zone_profile.py new file mode 100644 index 000000000..dbe72e616 --- /dev/null +++ b/openstack/load_balancer/v2/availability_zone_profile.py @@ -0,0 +1,41 @@ +# +# 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. + +from openstack import resource + + +class AvailabilityZoneProfile(resource.Resource): + resource_key = 'availability_zone_profile' + resources_key = 'availability_zone_profiles' + base_path = '/lbaas/availabilityzoneprofiles' + + # capabilities + allow_create = True + allow_fetch = True + allow_commit = True + allow_delete = True + allow_list = True + + _query_mapping = resource.QueryParameters( + 'id', 'name', 'provider_name', 'availability_zone_data' + ) + + # Properties + #: The ID of the availability zone profile. + id = resource.Body('id') + #: The name of the availability zone profile. + name = resource.Body('name') + #: The provider this availability zone profile is for. + provider_name = resource.Body('provider_name') + #: The JSON string containing the availability zone metadata. + availability_zone_data = resource.Body('availability_zone_data') diff --git a/openstack/tests/functional/load_balancer/v2/test_load_balancer.py b/openstack/tests/functional/load_balancer/v2/test_load_balancer.py index daae3b619..72d4d4bec 100644 --- a/openstack/tests/functional/load_balancer/v2/test_load_balancer.py +++ b/openstack/tests/functional/load_balancer/v2/test_load_balancer.py @@ -10,6 +10,8 @@ # License for the specific language governing permissions and limitations # under the License. +from openstack.load_balancer.v2 import availability_zone +from openstack.load_balancer.v2 import availability_zone_profile from openstack.load_balancer.v2 import flavor from openstack.load_balancer.v2 import flavor_profile from openstack.load_balancer.v2 import health_monitor @@ -35,6 +37,7 @@ class TestLoadBalancer(base.BaseFunctionalTest): PROJECT_ID = None FLAVOR_PROFILE_ID = None FLAVOR_ID = None + AVAILABILITY_ZONE_PROFILE_ID = None AMPHORA_ID = None PROTOCOL = 'HTTP' PROTOCOL_PORT = 80 @@ -52,6 +55,7 @@ class TestLoadBalancer(base.BaseFunctionalTest): L7RULE_VALUE = 'example' AMPHORA = 'amphora' FLAVOR_DATA = '{"loadbalancer_topology": "SINGLE"}' + AVAILABILITY_ZONE_DATA = '{"compute_zone": "nova"}' DESCRIPTION = 'Test description' _wait_for_timeout_key = 'OPENSTACKSDK_FUNC_TEST_TIMEOUT_LOAD_BALANCER' @@ -71,8 +75,11 @@ class TestLoadBalancer(base.BaseFunctionalTest): self.MEMBER_NAME = self.getUniqueString() self.POOL_NAME = self.getUniqueString() self.UPDATE_NAME = self.getUniqueString() + self.UPDATE_DESCRIPTION = self.getUniqueString() self.FLAVOR_PROFILE_NAME = self.getUniqueString() self.FLAVOR_NAME = self.getUniqueString() + self.AVAILABILITY_ZONE_PROFILE_NAME = self.getUniqueString() + self.AVAILABILITY_ZONE_NAME = self.getUniqueString() subnets = list(self.conn.network.subnets()) self.VIP_SUBNET_ID = subnets[0].id self.PROJECT_ID = self.conn.session.get_project_id() @@ -85,12 +92,12 @@ class TestLoadBalancer(base.BaseFunctionalTest): assert isinstance(test_quota, quota.Quota) self.assertEqual(self.PROJECT_ID, test_quota.id) - test_profile = self.conn.load_balancer.create_flavor_profile( + test_flavor_profile = self.conn.load_balancer.create_flavor_profile( name=self.FLAVOR_PROFILE_NAME, provider_name=self.AMPHORA, flavor_data=self.FLAVOR_DATA) - assert isinstance(test_profile, flavor_profile.FlavorProfile) - self.assertEqual(self.FLAVOR_PROFILE_NAME, test_profile.name) - self.FLAVOR_PROFILE_ID = test_profile.id + assert isinstance(test_flavor_profile, flavor_profile.FlavorProfile) + self.assertEqual(self.FLAVOR_PROFILE_NAME, test_flavor_profile.name) + self.FLAVOR_PROFILE_ID = test_flavor_profile.id test_flavor = self.conn.load_balancer.create_flavor( name=self.FLAVOR_NAME, flavor_profile_id=self.FLAVOR_PROFILE_ID, @@ -99,6 +106,24 @@ class TestLoadBalancer(base.BaseFunctionalTest): self.assertEqual(self.FLAVOR_NAME, test_flavor.name) self.FLAVOR_ID = test_flavor.id + test_az_profile = \ + self.conn.load_balancer.create_availability_zone_profile( + name=self.AVAILABILITY_ZONE_PROFILE_NAME, + provider_name=self.AMPHORA, + availability_zone_data=self.AVAILABILITY_ZONE_DATA) + assert isinstance(test_az_profile, + availability_zone_profile.AvailabilityZoneProfile) + self.assertEqual(self.AVAILABILITY_ZONE_PROFILE_NAME, + test_az_profile.name) + self.AVAILABILITY_ZONE_PROFILE_ID = test_az_profile.id + + test_az = self.conn.load_balancer.create_availability_zone( + name=self.AVAILABILITY_ZONE_NAME, + availability_zone_profile_id=self.AVAILABILITY_ZONE_PROFILE_ID, + is_enabled=True, description=self.DESCRIPTION) + assert isinstance(test_az, availability_zone.AvailabilityZone) + self.assertEqual(self.AVAILABILITY_ZONE_NAME, test_az.name) + test_lb = self.conn.load_balancer.create_load_balancer( name=self.LB_NAME, vip_subnet_id=self.VIP_SUBNET_ID, project_id=self.PROJECT_ID) @@ -218,6 +243,12 @@ class TestLoadBalancer(base.BaseFunctionalTest): self.conn.load_balancer.delete_flavor_profile(self.FLAVOR_PROFILE_ID, ignore_missing=False) + self.conn.load_balancer.delete_availability_zone( + self.AVAILABILITY_ZONE_NAME, ignore_missing=False) + + self.conn.load_balancer.delete_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_ID, ignore_missing=False) + def test_lb_find(self): test_lb = self.conn.load_balancer.find_load_balancer(self.LB_NAME) self.assertEqual(self.LB_ID, test_lb.id) @@ -593,3 +624,78 @@ class TestLoadBalancer(base.BaseFunctionalTest): self.conn.load_balancer.failover_amphora(self.AMPHORA_ID) test_amp = self.conn.load_balancer.get_amphora(self.AMPHORA_ID) self.assertEqual(self.AMPHORA_ID, test_amp.id) + + def test_availability_zone_profile_find(self): + test_profile = self.conn.load_balancer.find_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_NAME) + self.assertEqual(self.AVAILABILITY_ZONE_PROFILE_ID, test_profile.id) + + def test_availability_zone_profile_get(self): + test_availability_zone_profile = \ + self.conn.load_balancer.get_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_ID) + self.assertEqual(self.AVAILABILITY_ZONE_PROFILE_NAME, + test_availability_zone_profile.name) + self.assertEqual(self.AVAILABILITY_ZONE_PROFILE_ID, + test_availability_zone_profile.id) + self.assertEqual(self.AMPHORA, + test_availability_zone_profile.provider_name) + self.assertEqual(self.AVAILABILITY_ZONE_DATA, + test_availability_zone_profile.availability_zone_data) + + def test_availability_zone_profile_list(self): + names = [az.name for az in + self.conn.load_balancer.availability_zone_profiles()] + self.assertIn(self.AVAILABILITY_ZONE_PROFILE_NAME, names) + + def test_availability_zone_profile_update(self): + self.conn.load_balancer.update_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_ID, name=self.UPDATE_NAME) + test_availability_zone_profile = \ + self.conn.load_balancer.get_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_ID) + self.assertEqual(self.UPDATE_NAME, test_availability_zone_profile.name) + + self.conn.load_balancer.update_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_ID, + name=self.AVAILABILITY_ZONE_PROFILE_NAME) + test_availability_zone_profile = \ + self.conn.load_balancer.get_availability_zone_profile( + self.AVAILABILITY_ZONE_PROFILE_ID) + self.assertEqual(self.AVAILABILITY_ZONE_PROFILE_NAME, + test_availability_zone_profile.name) + + def test_availability_zone_find(self): + test_availability_zone = \ + self.conn.load_balancer.find_availability_zone( + self.AVAILABILITY_ZONE_NAME) + self.assertEqual(self.AVAILABILITY_ZONE_NAME, + test_availability_zone.name) + + def test_availability_zone_get(self): + test_availability_zone = self.conn.load_balancer.get_availability_zone( + self.AVAILABILITY_ZONE_NAME) + self.assertEqual(self.AVAILABILITY_ZONE_NAME, + test_availability_zone.name) + self.assertEqual(self.DESCRIPTION, test_availability_zone.description) + self.assertEqual(self.AVAILABILITY_ZONE_PROFILE_ID, + test_availability_zone.availability_zone_profile_id) + + def test_availability_zone_list(self): + names = [az.name for az in + self.conn.load_balancer.availability_zones()] + self.assertIn(self.AVAILABILITY_ZONE_NAME, names) + + def test_availability_zone_update(self): + self.conn.load_balancer.update_availability_zone( + self.AVAILABILITY_ZONE_NAME, description=self.UPDATE_DESCRIPTION) + test_availability_zone = self.conn.load_balancer.get_availability_zone( + self.AVAILABILITY_ZONE_NAME) + self.assertEqual(self.UPDATE_DESCRIPTION, + test_availability_zone.description) + + self.conn.load_balancer.update_availability_zone( + self.AVAILABILITY_ZONE_NAME, description=self.DESCRIPTION) + test_availability_zone = self.conn.load_balancer.get_availability_zone( + self.AVAILABILITY_ZONE_NAME) + self.assertEqual(self.DESCRIPTION, test_availability_zone.description) diff --git a/openstack/tests/unit/load_balancer/test_availability_zone.py b/openstack/tests/unit/load_balancer/test_availability_zone.py new file mode 100644 index 000000000..3417ee734 --- /dev/null +++ b/openstack/tests/unit/load_balancer/test_availability_zone.py @@ -0,0 +1,59 @@ +# +# 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. + +from openstack.tests.unit import base +import uuid + +from openstack.load_balancer.v2 import availability_zone + +AVAILABILITY_ZONE_PROFILE_ID = uuid.uuid4() +EXAMPLE = { + 'name': 'strawberry', + 'description': 'tasty', + 'is_enabled': False, + 'availability_zone_profile_id': AVAILABILITY_ZONE_PROFILE_ID} + + +class TestAvailabilityZone(base.TestCase): + + def test_basic(self): + test_availability_zone = availability_zone.AvailabilityZone() + self.assertEqual('availability_zone', + test_availability_zone.resource_key) + self.assertEqual('availability_zones', + test_availability_zone.resources_key) + self.assertEqual('/lbaas/availabilityzones', + test_availability_zone.base_path) + self.assertTrue(test_availability_zone.allow_create) + self.assertTrue(test_availability_zone.allow_fetch) + self.assertTrue(test_availability_zone.allow_commit) + self.assertTrue(test_availability_zone.allow_delete) + self.assertTrue(test_availability_zone.allow_list) + + def test_make_it(self): + test_availability_zone = availability_zone.AvailabilityZone(**EXAMPLE) + self.assertEqual(EXAMPLE['name'], test_availability_zone.name) + self.assertEqual(EXAMPLE['description'], + test_availability_zone.description) + self.assertFalse(test_availability_zone.is_enabled) + self.assertEqual(EXAMPLE['availability_zone_profile_id'], + test_availability_zone.availability_zone_profile_id) + + self.assertDictEqual( + {'limit': 'limit', + 'marker': 'marker', + 'name': 'name', + 'description': 'description', + 'is_enabled': 'enabled', + 'availability_zone_profile_id': 'availability_zone_profile_id'}, + test_availability_zone._query_mapping._mapping) diff --git a/openstack/tests/unit/load_balancer/test_availability_zone_profile.py b/openstack/tests/unit/load_balancer/test_availability_zone_profile.py new file mode 100644 index 000000000..82d1c0b9d --- /dev/null +++ b/openstack/tests/unit/load_balancer/test_availability_zone_profile.py @@ -0,0 +1,59 @@ +# +# 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. + +from openstack.tests.unit import base +import uuid + +from openstack.load_balancer.v2 import availability_zone_profile + +IDENTIFIER = uuid.uuid4() +EXAMPLE = { + 'id': IDENTIFIER, + 'name': 'acidic', + 'provider_name': 'best', + 'availability_zone_data': '{"loadbalancer_topology": "SINGLE"}'} + + +class TestAvailabilityZoneProfile(base.TestCase): + + def test_basic(self): + test_profile = availability_zone_profile.AvailabilityZoneProfile() + self.assertEqual('availability_zone_profile', + test_profile.resource_key) + self.assertEqual('availability_zone_profiles', + test_profile.resources_key) + self.assertEqual('/lbaas/availabilityzoneprofiles', + test_profile.base_path) + self.assertTrue(test_profile.allow_create) + self.assertTrue(test_profile.allow_fetch) + self.assertTrue(test_profile.allow_commit) + self.assertTrue(test_profile.allow_delete) + self.assertTrue(test_profile.allow_list) + + def test_make_it(self): + test_profile = availability_zone_profile.AvailabilityZoneProfile( + **EXAMPLE) + self.assertEqual(EXAMPLE['id'], test_profile.id) + self.assertEqual(EXAMPLE['name'], test_profile.name) + self.assertEqual(EXAMPLE['provider_name'], test_profile.provider_name) + self.assertEqual(EXAMPLE['availability_zone_data'], + test_profile.availability_zone_data) + + self.assertDictEqual( + {'limit': 'limit', + 'marker': 'marker', + 'id': 'id', + 'name': 'name', + 'provider_name': 'provider_name', + 'availability_zone_data': 'availability_zone_data'}, + test_profile._query_mapping._mapping) diff --git a/openstack/tests/unit/load_balancer/test_proxy.py b/openstack/tests/unit/load_balancer/test_proxy.py index 0f90b6a66..954d47740 100644 --- a/openstack/tests/unit/load_balancer/test_proxy.py +++ b/openstack/tests/unit/load_balancer/test_proxy.py @@ -15,6 +15,8 @@ import mock from openstack.load_balancer.v2 import _proxy from openstack.load_balancer.v2 import amphora +from openstack.load_balancer.v2 import availability_zone +from openstack.load_balancer.v2 import availability_zone_profile from openstack.load_balancer.v2 import flavor from openstack.load_balancer.v2 import flavor_profile from openstack.load_balancer.v2 import health_monitor @@ -388,3 +390,52 @@ class TestLoadBalancerProxy(test_proxy_base.TestProxyBase): value=[self.AMPHORA_ID], expected_args=[], expected_kwargs={'amphora_id': self.AMPHORA_ID}) + + def test_availability_zone_profiles(self): + self.verify_list(self.proxy.availability_zone_profiles, + availability_zone_profile.AvailabilityZoneProfile) + + def test_availability_zone_profile_get(self): + self.verify_get(self.proxy.get_availability_zone_profile, + availability_zone_profile.AvailabilityZoneProfile) + + def test_availability_zone_profile_create(self): + self.verify_create(self.proxy.create_availability_zone_profile, + availability_zone_profile.AvailabilityZoneProfile) + + def test_availability_zone_profile_delete(self): + self.verify_delete(self.proxy.delete_availability_zone_profile, + availability_zone_profile.AvailabilityZoneProfile, + True) + + def test_availability_zone_profile_find(self): + self.verify_find(self.proxy.find_availability_zone_profile, + availability_zone_profile.AvailabilityZoneProfile) + + def test_availability_zone_profile_update(self): + self.verify_update(self.proxy.update_availability_zone_profile, + availability_zone_profile.AvailabilityZoneProfile) + + def test_availability_zones(self): + self.verify_list(self.proxy.availability_zones, + availability_zone.AvailabilityZone) + + def test_availability_zone_get(self): + self.verify_get(self.proxy.get_availability_zone, + availability_zone.AvailabilityZone) + + def test_availability_zone_create(self): + self.verify_create(self.proxy.create_availability_zone, + availability_zone.AvailabilityZone) + + def test_availability_zone_delete(self): + self.verify_delete(self.proxy.delete_availability_zone, + availability_zone.AvailabilityZone, True) + + def test_availability_zone_find(self): + self.verify_find(self.proxy.find_availability_zone, + availability_zone.AvailabilityZone) + + def test_availability_zone_update(self): + self.verify_update(self.proxy.update_availability_zone, + availability_zone.AvailabilityZone) diff --git a/releasenotes/notes/add-az-to-loadbalancer-da9bf1baaedc89a4.yaml b/releasenotes/notes/add-az-to-loadbalancer-da9bf1baaedc89a4.yaml new file mode 100644 index 000000000..321d4a0f1 --- /dev/null +++ b/releasenotes/notes/add-az-to-loadbalancer-da9bf1baaedc89a4.yaml @@ -0,0 +1,5 @@ +--- +features: + - | + Adds Octavia (load_balancer) support for the availability zone and + availability zone profile APIs.