text: #    Copyright 2019 Rackspace US Inc.  All rights reserved.
  #
  #    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 copy
  from operator import itemgetter
  from uuid import UUID
  
  from oslo_serialization import jsonutils
  from tempest import config
  from tempest.lib.common.utils import data_utils
  from tempest.lib import decorators
  from tempest.lib import exceptions
  
  from octavia_tempest_plugin.common import constants as const
  from octavia_tempest_plugin.tests import test_base
  
  CONF = config.CONF
  
  
  class FlavorProfileAPITest(test_base.LoadBalancerBaseTest):
      """Test the flavor profile object API."""
  
      @decorators.idempotent_id('d0e3a08e-d58a-4460-83ed-34307ca04cde')
      def test_flavor_profile_create(self):
          """Tests flavor profile create and basic show APIs.
  
          * Tests that users without the loadbalancer admin role cannot
            create flavor profiles.
          * Create a fully populated flavor profile.
          * Validate the response reflects the requested values.
          """
          # We have to do this here as the api_version and clients are not
          # setup in time to use a decorator or the skip_checks mixin
          if not self.lb_admin_flavor_profile_client.is_version_supported(
                  self.api_version, '2.6'):
              raise self.skipException('Flavor profiles are only available on '
                                       'Octavia API version 2.6 or newer.')
  
          flavor_profile_name = data_utils.rand_name(
              "lb_admin_flavorprofile1-create")
          flavor_data = {const.LOADBALANCER_TOPOLOGY: const.SINGLE}
          flavor_data_json = jsonutils.dumps(flavor_data)
  
          flavor_profile_kwargs = {
              const.NAME: flavor_profile_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data_json
          }
  
          # Test that a user without the load balancer admin role cannot
          # create a flavor profile
          if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
              self.assertRaises(
                  exceptions.Forbidden,
                  self.os_primary.flavor_profile_client.create_flavor_profile,
                  **flavor_profile_kwargs)
  
          # Happy path
          flavor_profile = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile[const.ID])
  
          UUID(flavor_profile[const.ID])
          self.assertEqual(flavor_profile_name, flavor_profile[const.NAME])
          self.assertEqual(CONF.load_balancer.provider,
                           flavor_profile[const.PROVIDER_NAME])
          self.assertEqual(flavor_data_json, flavor_profile[const.FLAVOR_DATA])
  
      @decorators.idempotent_id('c4e17fdf-849a-4132-93ae-dfca21ce4444')
      def test_flavor_profile_list(self):
          """Tests flavor profile list API and field filtering.
  
          * Create three flavor profiles.
          * Validates that non-admin accounts cannot list the flavor profiles.
          * List the flavor profiles using the default sort order.
          * List the flavor profiles using descending sort order.
          * List the flavor profiles using ascending sort order.
          * List the flavor profiles returning one field at a time.
          * List the flavor profiles returning two fields.
          * List the flavor profiles filtering to one of the three.
          * List the flavor profiles filtered, one field, and sorted.
          """
          # We have to do this here as the api_version and clients are not
          # setup in time to use a decorator or the skip_checks mixin
          if not self.lb_admin_flavor_profile_client.is_version_supported(
                  self.api_version, '2.6'):
              raise self.skipException('Flavor profiles are only available on '
                                       'Octavia API version 2.6 or newer.')
  
          # Create flavor profile 1
          flavor_profile1_name = data_utils.rand_name(
              "lb_admin_flavorprofile-list-1")
          flavor_data1 = {const.LOADBALANCER_TOPOLOGY: const.SINGLE}
          flavor_data1_json = jsonutils.dumps(flavor_data1)
  
          flavor_profile1_kwargs = {
              const.NAME: flavor_profile1_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data1_json
          }
          flavor_profile1 = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile1_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile1[const.ID])
  
          # Create flavor profile 2
          flavor_profile2_name = data_utils.rand_name(
              "lb_admin_flavorprofile-list-2")
          flavor_data2 = {const.LOADBALANCER_TOPOLOGY: const.ACTIVE_STANDBY}
          flavor_data2_json = jsonutils.dumps(flavor_data2)
  
          flavor_profile2_kwargs = {
              const.NAME: flavor_profile2_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data2_json
          }
          flavor_profile2 = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile2_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile2[const.ID])
  
          # Create flavor profile 3
          flavor_profile3_name = data_utils.rand_name(
              "lb_admin_flavorprofile-list-3")
          flavor_data3 = {const.LOADBALANCER_TOPOLOGY: const.SINGLE}
          flavor_data3_json = jsonutils.dumps(flavor_data3)
  
          flavor_profile3_kwargs = {
              const.NAME: flavor_profile3_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data3_json
          }
          flavor_profile3 = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile3_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile3[const.ID])
  
          # default sort order (by ID) reference list
          ref_id_list_asc = [flavor_profile1[const.ID],
                             flavor_profile2[const.ID],
                             flavor_profile3[const.ID]]
          ref_id_list_dsc = copy.deepcopy(ref_id_list_asc)
          ref_id_list_asc.sort()
          ref_id_list_dsc.sort(reverse=True)
  
          # Test that a user without the load balancer admin role cannot
          # list flavor profiles.
          if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
              self.assertRaises(
                  exceptions.Forbidden,
                  self.os_primary.flavor_profile_client.list_flavor_profiles)
  
          # Check the default sort order (by ID)
          profiles = self.lb_admin_flavor_profile_client.list_flavor_profiles()
          # Remove flavor profiles not used in this test
          profiles = [prof for prof in profiles
                      if 'lb_admin_flavorprofile-list' in prof[const.NAME]]
          self.assertEqual(3, len(profiles))
          self.assertEqual(ref_id_list_asc[0], profiles[0][const.ID])
          self.assertEqual(ref_id_list_asc[1], profiles[1][const.ID])
          self.assertEqual(ref_id_list_asc[2], profiles[2][const.ID])
  
          # Check the descending sort order by name
          profiles = self.lb_admin_flavor_profile_client.list_flavor_profiles(
              query_params='{sort}={name}:{order}'.format(
                  sort=const.SORT, name=const.NAME, order=const.DESC))
          # Remove flavor profiles not used in this test
          profiles = [prof for prof in profiles
                      if 'lb_admin_flavorprofile-list' in prof[const.NAME]]
          self.assertEqual(3, len(profiles))
          self.assertEqual(flavor_profile3_name, profiles[0][const.NAME])
          self.assertEqual(flavor_profile2_name, profiles[1][const.NAME])
          self.assertEqual(flavor_profile1_name, profiles[2][const.NAME])
  
          # Check the ascending sort order by name
          profiles = self.lb_admin_flavor_profile_client.list_flavor_profiles(
              query_params='{sort}={name}:{order}'.format(
                  sort=const.SORT, name=const.NAME, order=const.ASC))
          # Remove flavor profiles not used in this test
          profiles = [prof for prof in profiles
                      if 'lb_admin_flavorprofile-list' in prof[const.NAME]]
          self.assertEqual(3, len(profiles))
          self.assertEqual(flavor_profile1_name, profiles[0][const.NAME])
          self.assertEqual(flavor_profile2_name, profiles[1][const.NAME])
          self.assertEqual(flavor_profile3_name, profiles[2][const.NAME])
  
          ref_profiles = [flavor_profile1, flavor_profile2, flavor_profile3]
          sorted_profiles = sorted(ref_profiles, key=itemgetter(const.ID))
  
          # Test fields
          flavor_profile_client = self.lb_admin_flavor_profile_client
          for field in const.SHOW_FLAVOR_PROFILE_FIELDS:
              profiles = flavor_profile_client.list_flavor_profiles(
                  query_params='{fields}={field}&{fields}={name}'.format(
                      fields=const.FIELDS, field=field, name=const.NAME))
              # Remove flavor profiles not used in this test
              profiles = [prof for prof in profiles
                          if 'lb_admin_flavorprofile-list' in prof[const.NAME]]
  
              self.assertEqual(3, len(profiles))
              self.assertEqual(sorted_profiles[0][field], profiles[0][field])
              self.assertEqual(sorted_profiles[1][field], profiles[1][field])
              self.assertEqual(sorted_profiles[2][field], profiles[2][field])
  
          # Test filtering
          profile = self.lb_admin_flavor_profile_client.list_flavor_profiles(
              query_params='{name}={prof_name}'.format(
                  name=const.NAME,
                  prof_name=flavor_profile2[const.NAME]))
          self.assertEqual(1, len(profile))
          self.assertEqual(flavor_profile2[const.ID], profile[0][const.ID])
  
          # Test combined params
          profiles = self.lb_admin_flavor_profile_client.list_flavor_profiles(
              query_params='{provider_name}={provider}&{fields}={name}&'
                           '{sort}={ID}:{desc}'.format(
                               provider_name=const.PROVIDER_NAME,
                               provider=CONF.load_balancer.provider,
                               fields=const.FIELDS, name=const.NAME,
                               sort=const.SORT, ID=const.ID,
                               desc=const.DESC))
          # Remove flavor profiles not used in this test
          profiles = [prof for prof in profiles
                      if 'lb_admin_flavorprofile-list' in prof[const.NAME]]
          self.assertEqual(3, len(profiles))
          self.assertEqual(1, len(profiles[0]))
          self.assertEqual(sorted_profiles[2][const.NAME],
                           profiles[0][const.NAME])
          self.assertEqual(sorted_profiles[1][const.NAME],
                           profiles[1][const.NAME])
          self.assertEqual(sorted_profiles[0][const.NAME],
                           profiles[2][const.NAME])
  
      @decorators.idempotent_id('a2c2ff9a-fce1-42fd-8cfd-56dea31610f6')
      def test_flavor_profile_show(self):
          """Tests flavor profile show API.
  
          * Create a fully populated flavor profile.
          * Show flavor profile details.
          * Validate the show reflects the requested values.
          * Validates that non-lb-admin accounts cannot see the flavor profile.
          """
          # We have to do this here as the api_version and clients are not
          # setup in time to use a decorator or the skip_checks mixin
          if not self.lb_admin_flavor_profile_client.is_version_supported(
                  self.api_version, '2.6'):
              raise self.skipException('Flavor profiles are only available on '
                                       'Octavia API version 2.6 or newer.')
  
          flavor_profile_name = data_utils.rand_name(
              "lb_admin_flavorprofile1-show")
          flavor_data = {const.LOADBALANCER_TOPOLOGY: const.ACTIVE_STANDBY}
          flavor_data_json = jsonutils.dumps(flavor_data)
  
          flavor_profile_kwargs = {
              const.NAME: flavor_profile_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data_json
          }
  
          flavor_profile = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile[const.ID])
  
          # Test that a user without the load balancer admin role cannot
          # show a flavor profile
          if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
              self.assertRaises(
                  exceptions.Forbidden,
                  self.os_primary.flavor_profile_client.show_flavor_profile,
                  flavor_profile[const.ID])
  
          result = (
              self.lb_admin_flavor_profile_client.show_flavor_profile(
                  flavor_profile[const.ID]))
  
          self.assertEqual(flavor_profile_name, result[const.NAME])
          self.assertEqual(CONF.load_balancer.provider,
                           result[const.PROVIDER_NAME])
          self.assertEqual(flavor_data_json, result[const.FLAVOR_DATA])
  
      @decorators.idempotent_id('32a2e285-8dfc-485f-a450-a4d450d3c3ec')
      def test_flavor_profile_update(self):
          """Tests flavor profile update API.
  
          * Create a fully populated flavor profile.
          * Show flavor profile details.
          * Validate the show reflects the initial values.
          * Validates that non-admin accounts cannot update the flavor profile.
          * Update the flavor profile details.
          * Show flavor profile details.
          * Validate the show reflects the updated values.
          """
  
          # We have to do this here as the api_version and clients are not
          # setup in time to use a decorator or the skip_checks mixin
          if not self.lb_admin_flavor_profile_client.is_version_supported(
                  self.api_version, '2.6'):
              raise self.skipException('Flavor profiles are only available on '
                                       'Octavia API version 2.6 or newer.')
  
          flavor_profile_name = data_utils.rand_name(
              "lb_admin_flavorprofile1-update")
          flavor_data = {const.LOADBALANCER_TOPOLOGY: const.SINGLE}
          flavor_data_json = jsonutils.dumps(flavor_data)
  
          flavor_profile_kwargs = {
              const.NAME: flavor_profile_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data_json
          }
  
          flavor_profile = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile[const.ID])
  
          self.assertEqual(flavor_profile_name, flavor_profile[const.NAME])
          self.assertEqual(CONF.load_balancer.provider,
                           flavor_profile[const.PROVIDER_NAME])
          self.assertEqual(flavor_data_json, flavor_profile[const.FLAVOR_DATA])
  
          flavor_profile_name2 = data_utils.rand_name(
              "lb_admin_flavorprofile1-update2")
          flavor_data2 = {const.LOADBALANCER_TOPOLOGY: const.ACTIVE_STANDBY}
          flavor_data2_json = jsonutils.dumps(flavor_data2)
  
          # TODO(johnsom) Figure out a reliable second provider
          flavor_profile_updated_kwargs = {
              const.NAME: flavor_profile_name2,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data2_json
          }
  
          # Test that a user without the load balancer admin role cannot
          # create a flavor profile
          if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
              self.assertRaises(
                  exceptions.Forbidden,
                  self.os_primary.flavor_profile_client.update_flavor_profile,
                  flavor_profile[const.ID], **flavor_profile_updated_kwargs)
  
          result = self.lb_admin_flavor_profile_client.update_flavor_profile(
              flavor_profile[const.ID], **flavor_profile_updated_kwargs)
  
          self.assertEqual(flavor_profile_name2, result[const.NAME])
          self.assertEqual(CONF.load_balancer.provider,
                           result[const.PROVIDER_NAME])
          self.assertEqual(flavor_data2_json, result[const.FLAVOR_DATA])
  
          # Check that a show reflects the new values
          get_result = (
              self.lb_admin_flavor_profile_client.show_flavor_profile(
                  flavor_profile[const.ID]))
  
          self.assertEqual(flavor_profile_name2, get_result[const.NAME])
          self.assertEqual(CONF.load_balancer.provider,
                           get_result[const.PROVIDER_NAME])
          self.assertEqual(flavor_data2_json, get_result[const.FLAVOR_DATA])
  
      @decorators.idempotent_id('4c2eaacf-c2c8-422a-b7dc-a30ceba6bcd4')
      def test_flavor_profile_delete(self):
          """Tests flavor profile create and delete APIs.
  
          * Creates a flavor profile.
          * Validates that other accounts cannot delete the flavor profile.
          * Deletes the flavor profile.
          * Validates the flavor profile is in the DELETED state.
          """
          # We have to do this here as the api_version and clients are not
          # setup in time to use a decorator or the skip_checks mixin
          if not self.lb_admin_flavor_profile_client.is_version_supported(
                  self.api_version, '2.6'):
              raise self.skipException('Flavor profiles are only available on '
                                       'Octavia API version 2.6 or newer.')
  
          flavor_profile_name = data_utils.rand_name(
              "lb_admin_flavorprofile1-delete")
          flavor_data = {const.LOADBALANCER_TOPOLOGY: const.SINGLE}
          flavor_data_json = jsonutils.dumps(flavor_data)
  
          flavor_profile_kwargs = {
              const.NAME: flavor_profile_name,
              const.PROVIDER_NAME: CONF.load_balancer.provider,
              const.FLAVOR_DATA: flavor_data_json
          }
  
          flavor_profile = (
              self.lb_admin_flavor_profile_client.create_flavor_profile(
                  **flavor_profile_kwargs))
          self.addCleanup(
              self.lb_admin_flavor_profile_client.cleanup_flavor_profile,
              flavor_profile[const.ID])
  
          # Test that a user without the load balancer admin role cannot
          # delete a flavor profile
          if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
              self.assertRaises(
                  exceptions.Forbidden,
                  self.os_primary.flavor_profile_client.delete_flavor_profile,
                  flavor_profile[const.ID])
  
          # Happy path
          self.lb_admin_flavor_profile_client.delete_flavor_profile(
              flavor_profile[const.ID])
  
          self.assertRaises(
              exceptions.NotFound,
              self.lb_admin_flavor_profile_client.show_flavor_profile,
              flavor_profile[const.ID])
  