openstack/manila
Code Issues Proposed changes

Merge "[Tempest] Stop using deprecated Tempest opts"

Browse Source
This commit is contained in:
Jenkins 2016-06-08 18:55:06 +00:00 committed by Gerrit Code Review
commit 8dd65682f9
22 changed files with 414 additions and 428 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
contrib/ci/post_test_hook.sh
View File

@ -23,7 +23,7 @@ sudo chmod -R o+rx $BASE/new/devstack/files
# Import devstack functions 'iniset', 'iniget' and 'trueorfalse' # Import devstack functions 'iniset', 'iniget' and 'trueorfalse'
source $BASE/new/devstack/functions source $BASE/new/devstack/functions
export TEMPEST_CONFIG=$BASE/new/tempest/etc/tempest.conf export TEMPEST_CONFIG=${TEMPEST_CONFIG:-$BASE/new/tempest/etc/tempest.conf}
# === Handle script arguments === # === Handle script arguments ===
@ -120,13 +120,14 @@ if [[ "$MULTITENANCY_ENABLED" == "False" ]]; then
# threads to avoid errors for Cinder volume creations that appear # threads to avoid errors for Cinder volume creations that appear
# because of lack of free space. # because of lack of free space.
MANILA_TEMPEST_CONCURRENCY=${MANILA_TEMPEST_CONCURRENCY:-8} MANILA_TEMPEST_CONCURRENCY=${MANILA_TEMPEST_CONCURRENCY:-8}
iniset $TEMPEST_CONFIG auth create_isolated_networks False
fi fi
# let us control if we die or not # let us control if we die or not
set +o errexit set +o errexit
cd $BASE/new/tempest cd $BASE/new/tempest
export MANILA_TEMPEST_CONCURRENCY=${MANILA_TEMPEST_CONCURRENCY:-20} export MANILA_TEMPEST_CONCURRENCY=${MANILA_TEMPEST_CONCURRENCY:-6}
export MANILA_TESTS=${MANILA_TESTS:-'manila_tempest_tests.tests.api'} export MANILA_TESTS=${MANILA_TESTS:-'manila_tempest_tests.tests.api'}
if [[ "$TEST_TYPE" == "scenario" ]]; then if [[ "$TEST_TYPE" == "scenario" ]]; then
@ -143,6 +144,7 @@ elif [[ "$DRIVER" == "generic" ]]; then
# per job using 'generic' share driver. # per job using 'generic' share driver.
iniset $TEMPEST_CONFIG share enable_protocols nfs iniset $TEMPEST_CONFIG share enable_protocols nfs
fi fi
MANILA_TESTS="(^manila_tempest_tests.tests.api)(?=.*\[.*\bbackend\b.*\])"
fi fi
if [[ "$DRIVER" == "lvm" ]]; then if [[ "$DRIVER" == "lvm" ]]; then
@ -193,30 +195,13 @@ iniset $TEMPEST_CONFIG share run_manage_unmanage_tests $RUN_MANILA_MANAGE_TESTS
# Enable manage/unmanage snapshot tests # Enable manage/unmanage snapshot tests
iniset $TEMPEST_CONFIG share run_manage_unmanage_snapshot_tests $RUN_MANILA_MANAGE_SNAPSHOT_TESTS iniset $TEMPEST_CONFIG share run_manage_unmanage_snapshot_tests $RUN_MANILA_MANAGE_SNAPSHOT_TESTS
# check if tempest plugin was installed correctly
echo 'import pkg_resources; print list(pkg_resources.iter_entry_points("tempest.test_plugins"))' | python
# Workaround for Tempest architectural changes
# See bugs:
# 1) https://bugs.launchpad.net/manila/+bug/1531049
# 2) https://bugs.launchpad.net/tempest/+bug/1524717
TEMPEST_CONFIG=${TEMPEST_CONFIG:-$TEMPEST_DIR/etc/tempest.conf}
ADMIN_TENANT_NAME=${ADMIN_TENANT_NAME:-"admin"}
ADMIN_DOMAIN_NAME=${ADMIN_DOMAIN_NAME:-"Default"}
ADMIN_PASSWORD=${ADMIN_PASSWORD:-"secretadmin"}
iniset $TEMPEST_CONFIG auth admin_username ${ADMIN_USERNAME:-"admin"}
iniset $TEMPEST_CONFIG auth admin_password $ADMIN_PASSWORD
iniset $TEMPEST_CONFIG auth admin_tenant_name $ADMIN_TENANT_NAME
iniset $TEMPEST_CONFIG auth admin_domain_name $ADMIN_DOMAIN_NAME
iniset $TEMPEST_CONFIG identity username ${TEMPEST_USERNAME:-"demo"}
iniset $TEMPEST_CONFIG identity password $ADMIN_PASSWORD
iniset $TEMPEST_CONFIG identity tenant_name ${TEMPEST_TENANT_NAME:-"demo"}
iniset $TEMPEST_CONFIG identity alt_username ${ALT_USERNAME:-"alt_demo"}
iniset $TEMPEST_CONFIG identity alt_password $ADMIN_PASSWORD
iniset $TEMPEST_CONFIG identity alt_tenant_name ${ALT_TENANT_NAME:-"alt_demo"}
iniset $TEMPEST_CONFIG validation ip_version_for_ssh 4 iniset $TEMPEST_CONFIG validation ip_version_for_ssh 4
iniset $TEMPEST_CONFIG validation network_for_ssh ${PRIVATE_NETWORK_NAME:-"private"} iniset $TEMPEST_CONFIG validation network_for_ssh ${PRIVATE_NETWORK_NAME:-"private"}
# check if tempest plugin was installed correctly
echo 'import pkg_resources; print list(pkg_resources.iter_entry_points("tempest.test_plugins"))' | python
ADMIN_DOMAIN_NAME=${ADMIN_DOMAIN_NAME:-"Default"}
export OS_PROJECT_DOMAIN_NAME=$ADMIN_DOMAIN_NAME export OS_PROJECT_DOMAIN_NAME=$ADMIN_DOMAIN_NAME
export OS_USER_DOMAIN_NAME=$ADMIN_DOMAIN_NAME export OS_USER_DOMAIN_NAME=$ADMIN_DOMAIN_NAME

8
contrib/ci/pre_test_hook.sh
View File

@ -21,6 +21,7 @@
source $BASE/new/devstack/functions source $BASE/new/devstack/functions
localrc_path=$BASE/new/devstack/localrc localrc_path=$BASE/new/devstack/localrc
local_conf_path=$BASE/new/devstack/local.conf
echo "DEVSTACK_GATE_TEMPEST_ALLOW_TENANT_ISOLATION=1" >> $localrc_path echo "DEVSTACK_GATE_TEMPEST_ALLOW_TENANT_ISOLATION=1" >> $localrc_path
echo "API_RATE_LIMIT=False" >> $localrc_path echo "API_RATE_LIMIT=False" >> $localrc_path
echo "TEMPEST_SERVICES+=,manila" >> $localrc_path echo "TEMPEST_SERVICES+=,manila" >> $localrc_path
@ -68,6 +69,9 @@ MANILA_SERVICE_IMAGE_ENABLED=False
if [[ "$DRIVER" == "generic" ]]; then if [[ "$DRIVER" == "generic" ]]; then
MANILA_SERVICE_IMAGE_ENABLED=True MANILA_SERVICE_IMAGE_ENABLED=True
echo "SHARE_DRIVER=manila.share.drivers.generic.GenericShareDriver" >> $localrc_path echo "SHARE_DRIVER=manila.share.drivers.generic.GenericShareDriver" >> $localrc_path
echo -e "[[post-config|${NOVA_CONF:-/etc/nova/nova.conf}]]\n[DEFAULT]\nquota_instances=30\n" >> $local_conf_path
echo -e "[[post-config|${NEUTRON_CONF:-/etc/neutron/neutron.conf}]]\n[DEFAULT]\nmax_fixed_ips_per_port=100\n" >> $local_conf_path
echo -e "[[post-config|${NEUTRON_CONF:-/etc/neutron/neutron.conf}]]\n[QUOTAS]\nquota_subnet=-1\n" >> $local_conf_path
elif [[ "$DRIVER" == "windows" ]]; then elif [[ "$DRIVER" == "windows" ]]; then
MANILA_SERVICE_IMAGE_ENABLED=True MANILA_SERVICE_IMAGE_ENABLED=True
echo "SHARE_DRIVER=manila.share.drivers.windows.windows_smb_driver.WindowsSMBDriver" >> $localrc_path echo "SHARE_DRIVER=manila.share.drivers.windows.windows_smb_driver.WindowsSMBDriver" >> $localrc_path
@ -96,6 +100,10 @@ echo 'ENABLE_ISOLATED_METADATA=True' >> $localrc_path
cd $BASE/new/neutron-fwaas cd $BASE/new/neutron-fwaas
git revert --no-edit a59df892d3f90f97c967a46b6c18e595d60a9b85 git revert --no-edit a59df892d3f90f97c967a46b6c18e595d60a9b85
echo "TEMPEST_USE_TEST_ACCOUNTS=True" >> $localrc_path
echo "TEMPEST_ALLOW_TENANT_ISOLATION=False" >> $localrc_path
echo "TEMPEST_CONCURRENCY=8" >> $localrc_path
# Go to Tempest dir and checkout stable commit to avoid possible # Go to Tempest dir and checkout stable commit to avoid possible
# incompatibilities for plugin stored in Manila repo. # incompatibilities for plugin stored in Manila repo.
cd $BASE/new/tempest cd $BASE/new/tempest

45
manila_tempest_tests/clients_share.py
View File

@ -1,45 +0,0 @@
# Copyright 2014 Mirantis 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.
from tempest import clients
from tempest.common import credentials_factory as common_creds
from manila_tempest_tests.services.share.json import shares_client
from manila_tempest_tests.services.share.v2.json import shares_client \
as shares_v2_client
class Manager(clients.Manager):
def __init__(
self,
credentials=common_creds.get_configured_credentials('user'),
service=None):
super(Manager, self).__init__(credentials, service)
self.shares_client = shares_client.SharesClient(self.auth_provider)
self.shares_v2_client = shares_v2_client.SharesV2Client(
self.auth_provider)
class AltManager(Manager):
def __init__(self, service=None):
super(AltManager, self).__init__(
common_creds.get_configured_credentials('alt_user'), service)
class AdminManager(Manager):
def __init__(self, service=None):
super(AdminManager, self).__init__(
common_creds.get_configured_credentials('identity_admin'),
service)

69
manila_tempest_tests/tests/api/admin/test_admin_actions_negative.py
View File

@ -13,42 +13,42 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest import config # noqa from tempest import config
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
import testtools # noqa import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
CONF = config.CONF CONF = config.CONF
class AdminActionsNegativeTest(base.BaseSharesAdminTest): class AdminActionsNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(AdminActionsNegativeTest, cls).resource_setup() super(AdminActionsNegativeTest, cls).resource_setup()
cls.sh = cls.create_share() cls.admin_client = cls.admin_shares_v2_client
cls.member_client = cls.shares_v2_client
cls.sh = cls.create_share(client=cls.admin_client)
cls.sh_instance = ( cls.sh_instance = (
cls.shares_v2_client.get_instances_of_share(cls.sh["id"])[0] cls.admin_client.get_instances_of_share(cls.sh["id"])[0]
) )
if CONF.share.run_snapshot_tests: if CONF.share.run_snapshot_tests:
cls.sn = cls.create_snapshot_wait_for_active(cls.sh["id"]) cls.sn = cls.create_snapshot_wait_for_active(
cls.member_shares_client = clients.Manager().shares_client cls.sh["id"], client=cls.admin_client)
cls.member_shares_v2_client = clients.Manager().shares_v2_client
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_reset_share_state_to_unacceptable_state(self): def test_reset_share_state_to_unacceptable_state(self):
self.assertRaises(lib_exc.BadRequest, self.assertRaises(lib_exc.BadRequest,
self.shares_client.reset_state, self.admin_client.reset_state,
self.sh["id"], status="fake") self.sh["id"], status="fake")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_reset_share_instance_state_to_unacceptable_state(self): def test_reset_share_instance_state_to_unacceptable_state(self):
self.assertRaises( self.assertRaises(
lib_exc.BadRequest, lib_exc.BadRequest,
self.shares_v2_client.reset_state, self.admin_client.reset_state,
self.sh_instance["id"], self.sh_instance["id"],
s_type="share_instances", s_type="share_instances",
status="fake" status="fake"
@ -59,21 +59,21 @@ class AdminActionsNegativeTest(base.BaseSharesAdminTest):
"Snapshot tests are disabled.") "Snapshot tests are disabled.")
def test_reset_snapshot_state_to_unacceptable_state(self): def test_reset_snapshot_state_to_unacceptable_state(self):
self.assertRaises(lib_exc.BadRequest, self.assertRaises(lib_exc.BadRequest,
self.shares_client.reset_state, self.admin_client.reset_state,
self.sn["id"], s_type="snapshots", status="fake") self.sn["id"], s_type="snapshots", status="fake")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_try_reset_share_state_with_member(self): def test_try_reset_share_state_with_member(self):
# Even if member from another tenant, it should be unauthorized # Even if member from another tenant, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.reset_state, self.member_client.reset_state,
self.sh["id"]) self.sh["id"])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_try_reset_share_instance_state_with_member(self): def test_try_reset_share_instance_state_with_member(self):
# Even if member from another tenant, it should be unauthorized # Even if member from another tenant, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_v2_client.reset_state, self.member_client.reset_state,
self.sh_instance["id"], s_type="share_instances") self.sh_instance["id"], s_type="share_instances")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@ -82,21 +82,21 @@ class AdminActionsNegativeTest(base.BaseSharesAdminTest):
def test_try_reset_snapshot_state_with_member(self): def test_try_reset_snapshot_state_with_member(self):
# Even if member from another tenant, it should be unauthorized # Even if member from another tenant, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.reset_state, self.member_client.reset_state,
self.sn["id"], s_type="snapshots") self.sn["id"], s_type="snapshots")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_try_force_delete_share_with_member(self): def test_try_force_delete_share_with_member(self):
# If a non-admin tries to do force_delete, it should be unauthorized # If a non-admin tries to do force_delete, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.force_delete, self.member_client.force_delete,
self.sh["id"]) self.sh["id"])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_try_force_delete_share_instance_with_member(self): def test_try_force_delete_share_instance_with_member(self):
# If a non-admin tries to do force_delete, it should be unauthorized # If a non-admin tries to do force_delete, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_v2_client.force_delete, self.member_client.force_delete,
self.sh_instance["id"], s_type="share_instances") self.sh_instance["id"], s_type="share_instances")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@ -105,14 +105,14 @@ class AdminActionsNegativeTest(base.BaseSharesAdminTest):
def test_try_force_delete_snapshot_with_member(self): def test_try_force_delete_snapshot_with_member(self):
# If a non-admin tries to do force_delete, it should be unauthorized # If a non-admin tries to do force_delete, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.force_delete, self.member_client.force_delete,
self.sn["id"], s_type="snapshots") self.sn["id"], s_type="snapshots")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
def test_try_get_share_instance_with_member(self): def test_try_get_share_instance_with_member(self):
# If a non-admin tries to get instance, it should be unauthorized # If a non-admin tries to get instance, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_v2_client.get_share_instance, self.member_client.get_share_instance,
self.sh_instance["id"]) self.sh_instance["id"])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@ -120,42 +120,43 @@ class AdminActionsNegativeTest(base.BaseSharesAdminTest):
# If a non-admin tries to list instances of given share, it should be # If a non-admin tries to list instances of given share, it should be
# unauthorized # unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_v2_client.get_instances_of_share, self.member_client.get_instances_of_share,
self.sh['id']) self.sh['id'])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@base.skip_if_microversion_lt("2.15") @base.skip_if_microversion_lt("2.15")
def test_reset_task_state_empty(self): def test_reset_task_state_empty(self):
self.assertRaises( self.assertRaises(
lib_exc.BadRequest, self.shares_v2_client.reset_task_state, lib_exc.BadRequest, self.admin_client.reset_task_state,
self.sh['id'], None) self.sh['id'], None)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@base.skip_if_microversion_lt("2.15") @base.skip_if_microversion_lt("2.15")
def test_reset_task_state_invalid_state(self): def test_reset_task_state_invalid_state(self):
self.assertRaises( self.assertRaises(
lib_exc.BadRequest, self.shares_v2_client.reset_task_state, lib_exc.BadRequest, self.admin_client.reset_task_state,
self.sh['id'], 'fake_state') self.sh['id'], 'fake_state')
class AdminActionsAPIOnlyNegativeTest(base.BaseSharesAdminTest): class AdminActionsAPIOnlyNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(AdminActionsAPIOnlyNegativeTest, cls).resource_setup() super(AdminActionsAPIOnlyNegativeTest, cls).resource_setup()
cls.member_shares_v2_client = clients.Manager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.member_client = cls.shares_v2_client
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_list_share_instance_with_member(self): def test_try_list_share_instance_with_member(self):
# If a non-admin tries to list instances, it should be unauthorized # If a non-admin tries to list instances, it should be unauthorized
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_v2_client.list_share_instances) self.member_client.list_share_instances)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@base.skip_if_microversion_lt("2.15") @base.skip_if_microversion_lt("2.15")
def test_reset_task_state_share_not_found(self): def test_reset_task_state_share_not_found(self):
self.assertRaises( self.assertRaises(
lib_exc.NotFound, self.shares_v2_client.reset_task_state, lib_exc.NotFound, self.admin_client.reset_task_state,
'fake_share', 'migration_error') 'fake_share', 'migration_error')
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -163,35 +164,35 @@ class AdminActionsAPIOnlyNegativeTest(base.BaseSharesAdminTest):
"Snapshot tests are disabled.") "Snapshot tests are disabled.")
def test_force_delete_nonexistent_snapshot(self): def test_force_delete_nonexistent_snapshot(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.force_delete, self.admin_client.force_delete,
"fake", "fake",
s_type="snapshots") s_type="snapshots")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_force_delete_nonexistent_share(self): def test_force_delete_nonexistent_share(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.force_delete, "fake") self.admin_client.force_delete, "fake")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_force_delete_nonexistent_share_instance(self): def test_force_delete_nonexistent_share_instance(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_v2_client.force_delete, self.admin_client.force_delete,
"fake", "fake",
s_type="share_instances") s_type="share_instances")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_reset_nonexistent_share_state(self): def test_reset_nonexistent_share_state(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.reset_state, "fake") self.admin_client.reset_state, "fake")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_reset_nonexistent_share_instance_state(self): def test_reset_nonexistent_share_instance_state(self):
self.assertRaises(lib_exc.NotFound, self.shares_v2_client.reset_state, self.assertRaises(lib_exc.NotFound, self.admin_client.reset_state,
"fake", s_type="share_instances") "fake", s_type="share_instances")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@testtools.skipUnless(CONF.share.run_snapshot_tests, @testtools.skipUnless(CONF.share.run_snapshot_tests,
"Snapshot tests are disabled.") "Snapshot tests are disabled.")
def test_reset_nonexistent_snapshot_state(self): def test_reset_nonexistent_snapshot_state(self):
self.assertRaises(lib_exc.NotFound, self.shares_client.reset_state, self.assertRaises(lib_exc.NotFound, self.admin_client.reset_state,
"fake", s_type="snapshots") "fake", s_type="snapshots")

13
manila_tempest_tests/tests/api/admin/test_export_locations.py
View File

@ -20,7 +20,6 @@ import six
from tempest import config from tempest import config
from tempest import test from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
from manila_tempest_tests import utils from manila_tempest_tests import utils
@ -30,16 +29,16 @@ LATEST_MICROVERSION = CONF.share.max_api_microversion
@base.skip_if_microversion_not_supported("2.9") @base.skip_if_microversion_not_supported("2.9")
@ddt.ddt @ddt.ddt
class ExportLocationsTest(base.BaseSharesAdminTest): class ExportLocationsTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ExportLocationsTest, cls).resource_setup() super(ExportLocationsTest, cls).resource_setup()
cls.admin_client = cls.shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.member_client = clients.Manager().shares_v2_client cls.member_client = cls.shares_v2_client
cls.share = cls.create_share() cls.share = cls.create_share(client=cls.admin_client)
cls.share = cls.shares_v2_client.get_share(cls.share['id']) cls.share = cls.admin_client.get_share(cls.share['id'])
cls.share_instances = cls.shares_v2_client.get_instances_of_share( cls.share_instances = cls.admin_client.get_instances_of_share(
cls.share['id']) cls.share['id'])
def _verify_export_location_structure( def _verify_export_location_structure(

13
manila_tempest_tests/tests/api/admin/test_export_locations_negative.py
View File

@ -17,23 +17,22 @@ from tempest import config
from tempest.lib import exceptions as lib_exc from tempest.lib import exceptions as lib_exc
from tempest import test from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
CONF = config.CONF CONF = config.CONF
@base.skip_if_microversion_not_supported("2.9") @base.skip_if_microversion_not_supported("2.9")
class ExportLocationsNegativeTest(base.BaseSharesAdminTest): class ExportLocationsNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ExportLocationsNegativeTest, cls).resource_setup() super(ExportLocationsNegativeTest, cls).resource_setup()
cls.admin_client = cls.shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.member_client = clients.Manager().shares_v2_client cls.member_client = cls.shares_v2_client
cls.share = cls.create_share() cls.share = cls.create_share(client=cls.admin_client)
cls.share = cls.shares_v2_client.get_share(cls.share['id']) cls.share = cls.admin_client.get_share(cls.share['id'])
cls.share_instances = cls.shares_v2_client.get_instances_of_share( cls.share_instances = cls.admin_client.get_instances_of_share(
cls.share['id']) cls.share['id'])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])

7
manila_tempest_tests/tests/api/admin/test_quotas.py
View File

@ -13,10 +13,9 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest import config # noqa from tempest import config
from tempest import test # noqa from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
CONF = config.CONF CONF = config.CONF
@ -29,7 +28,6 @@ class SharesAdminQuotasTest(base.BaseSharesAdminTest):
if not CONF.share.run_quota_tests: if not CONF.share.run_quota_tests:
msg = "Quota tests are disabled." msg = "Quota tests are disabled."
raise cls.skipException(msg) raise cls.skipException(msg)
cls.os = clients.AdminManager()
super(SharesAdminQuotasTest, cls).resource_setup() super(SharesAdminQuotasTest, cls).resource_setup()
cls.user_id = cls.shares_v2_client.user_id cls.user_id = cls.shares_v2_client.user_id
cls.tenant_id = cls.shares_v2_client.tenant_id cls.tenant_id = cls.shares_v2_client.tenant_id
@ -73,7 +71,6 @@ class SharesAdminQuotasUpdateTest(base.BaseSharesAdminTest):
if not CONF.share.run_quota_tests: if not CONF.share.run_quota_tests:
msg = "Quota tests are disabled." msg = "Quota tests are disabled."
raise cls.skipException(msg) raise cls.skipException(msg)
cls.os = clients.AdminManager()
super(SharesAdminQuotasUpdateTest, cls).resource_setup() super(SharesAdminQuotasUpdateTest, cls).resource_setup()
def setUp(self): def setUp(self):

9
manila_tempest_tests/tests/api/admin/test_quotas_negative.py
View File

@ -13,12 +13,10 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest import config # noqa from tempest import config
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
import testtools # noqa
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
CONF = config.CONF CONF = config.CONF
@ -33,7 +31,6 @@ class SharesAdminQuotasNegativeTest(base.BaseSharesAdminTest):
if not CONF.share.run_quota_tests: if not CONF.share.run_quota_tests:
msg = "Quota tests are disabled." msg = "Quota tests are disabled."
raise cls.skipException(msg) raise cls.skipException(msg)
cls.os = clients.AdminManager()
super(SharesAdminQuotasNegativeTest, cls).resource_setup() super(SharesAdminQuotasNegativeTest, cls).resource_setup()
cls.user_id = cls.shares_client.user_id cls.user_id = cls.shares_client.user_id
cls.tenant_id = cls.shares_client.tenant_id cls.tenant_id = cls.shares_client.tenant_id

52
manila_tempest_tests/tests/api/admin/test_replication.py
View File

@ -18,7 +18,6 @@ from tempest.lib.common.utils import data_utils
from tempest import test from tempest import test
import testtools import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.common import constants from manila_tempest_tests.common import constants
from manila_tempest_tests import share_exceptions from manila_tempest_tests import share_exceptions
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
@ -30,14 +29,15 @@ _MIN_SUPPORTED_MICROVERSION = '2.11'
@testtools.skipUnless(CONF.share.run_replication_tests, @testtools.skipUnless(CONF.share.run_replication_tests,
'Replication tests are disabled.') 'Replication tests are disabled.')
@base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION) @base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION)
class ReplicationAdminTest(base.BaseSharesAdminTest): class ReplicationAdminTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ReplicationAdminTest, cls).resource_setup() super(ReplicationAdminTest, cls).resource_setup()
# Create share_type # Create share_type
name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX) name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX)
cls.admin_client = clients.AdminManager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.member_client = cls.shares_v2_client
cls.replication_type = CONF.share.backend_replication_type cls.replication_type = CONF.share.backend_replication_type
if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES: if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES:
@ -57,8 +57,9 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
cls.share_type = share_type["share_type"] cls.share_type = share_type["share_type"]
# Create share with above share_type # Create share with above share_type
cls.share = cls.create_share(share_type_id=cls.share_type["id"], cls.share = cls.create_share(share_type_id=cls.share_type["id"],
availability_zone=cls.share_zone,) availability_zone=cls.share_zone,
cls.replica = cls.shares_v2_client.list_share_replicas( client=cls.admin_client)
cls.replica = cls.admin_client.list_share_replicas(
share_id=cls.share['id'])[0] share_id=cls.share['id'])[0]
@staticmethod @staticmethod
@ -75,14 +76,16 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
msg = "Option backend_replication_type should be one of (%s)!" msg = "Option backend_replication_type should be one of (%s)!"
raise self.skipException( raise self.skipException(
msg % ','.join(constants.REPLICATION_PROMOTION_CHOICES)) msg % ','.join(constants.REPLICATION_PROMOTION_CHOICES))
share = self.create_share(share_type_id=self.share_type['id']) share = self.create_share(
original_replica = self.shares_v2_client.list_share_replicas( share_type_id=self.share_type['id'], client=self.admin_client)
original_replica = self.admin_client.list_share_replicas(
share_id=share['id'])[0] share_id=share['id'])[0]
# NOTE(Yogi1): Cleanup needs to be disabled for replica that is # NOTE(Yogi1): Cleanup needs to be disabled for replica that is
# being promoted since it will become the 'primary'/'active' replica. # being promoted since it will become the 'primary'/'active' replica.
replica = self.create_share_replica(share["id"], self.replica_zone, replica = self.create_share_replica(
cleanup=False) share["id"], self.replica_zone, cleanup=False,
client=self.admin_client)
# List replicas # List replicas
replica_list = self.admin_client.list_share_replicas( replica_list = self.admin_client.list_share_replicas(
@ -96,7 +99,7 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
# Set replica_state to 'out_of_sync' # Set replica_state to 'out_of_sync'
self.admin_client.reset_share_replica_state( self.admin_client.reset_share_replica_state(
replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC) replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC)
self.shares_v2_client.wait_for_share_replica_status( self.admin_client.wait_for_share_replica_status(
replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC, replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC,
status_attr='replica_state') status_attr='replica_state')
@ -107,7 +110,7 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
self.addCleanup(self.delete_share_replica, original_replica['id']) self.addCleanup(self.delete_share_replica, original_replica['id'])
# Check if there is still only 1 'active' replica after promotion. # Check if there is still only 1 'active' replica after promotion.
replica_list = self.shares_v2_client.list_share_replicas( replica_list = self.admin_client.list_share_replicas(
share_id=self.share["id"]) share_id=self.share["id"])
new_active_replicas = self._filter_share_replica_list( new_active_replicas = self._filter_share_replica_list(
replica_list, constants.REPLICATION_STATE_ACTIVE) replica_list, constants.REPLICATION_STATE_ACTIVE)
@ -118,24 +121,25 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Test force deleting a replica that is in 'error_deleting' status.""" """Test force deleting a replica that is in 'error_deleting' status."""
replica = self.create_share_replica(self.share['id'], replica = self.create_share_replica(self.share['id'],
self.replica_zone, self.replica_zone,
cleanup_in_class=False) cleanup_in_class=False,
client=self.admin_client)
self.admin_client.reset_share_replica_status( self.admin_client.reset_share_replica_status(
replica['id'], constants.STATUS_ERROR_DELETING) replica['id'], constants.STATUS_ERROR_DELETING)
self.shares_v2_client.wait_for_share_replica_status( self.admin_client.wait_for_share_replica_status(
replica['id'], constants.STATUS_ERROR_DELETING) replica['id'], constants.STATUS_ERROR_DELETING)
self.admin_client.force_delete_share_replica(replica['id']) self.admin_client.force_delete_share_replica(replica['id'])
self.shares_v2_client.wait_for_resource_deletion( self.admin_client.wait_for_resource_deletion(replica_id=replica['id'])
replica_id=replica['id'])
@test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND])
def test_reset_share_replica_status(self): def test_reset_share_replica_status(self):
"""Test resetting a replica's 'status' attribute.""" """Test resetting a replica's 'status' attribute."""
replica = self.create_share_replica(self.share['id'], replica = self.create_share_replica(self.share['id'],
self.replica_zone, self.replica_zone,
cleanup_in_class=False) cleanup_in_class=False,
client=self.admin_client)
self.admin_client.reset_share_replica_status(replica['id'], self.admin_client.reset_share_replica_status(replica['id'],
constants.STATUS_ERROR) constants.STATUS_ERROR)
self.shares_v2_client.wait_for_share_replica_status( self.admin_client.wait_for_share_replica_status(
replica['id'], constants.STATUS_ERROR) replica['id'], constants.STATUS_ERROR)
@test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND])
@ -143,10 +147,11 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Test resetting a replica's 'replica_state' attribute.""" """Test resetting a replica's 'replica_state' attribute."""
replica = self.create_share_replica(self.share['id'], replica = self.create_share_replica(self.share['id'],
self.replica_zone, self.replica_zone,
cleanup_in_class=False) cleanup_in_class=False,
client=self.admin_client)
self.admin_client.reset_share_replica_state(replica['id'], self.admin_client.reset_share_replica_state(replica['id'],
constants.STATUS_ERROR) constants.STATUS_ERROR)
self.shares_v2_client.wait_for_share_replica_status( self.admin_client.wait_for_share_replica_status(
replica['id'], constants.STATUS_ERROR, status_attr='replica_state') replica['id'], constants.STATUS_ERROR, status_attr='replica_state')
@test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND])
@ -154,20 +159,21 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Test resyncing a replica.""" """Test resyncing a replica."""
replica = self.create_share_replica(self.share['id'], replica = self.create_share_replica(self.share['id'],
self.replica_zone, self.replica_zone,
cleanup_in_class=False) cleanup_in_class=False,
self.shares_v2_client.wait_for_share_replica_status( client=self.admin_client)
self.admin_client.wait_for_share_replica_status(
replica['id'], constants.REPLICATION_STATE_IN_SYNC, replica['id'], constants.REPLICATION_STATE_IN_SYNC,
status_attr='replica_state') status_attr='replica_state')
# Set replica_state to 'out_of_sync'. # Set replica_state to 'out_of_sync'.
self.admin_client.reset_share_replica_state( self.admin_client.reset_share_replica_state(
replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC) replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC)
self.shares_v2_client.wait_for_share_replica_status( self.admin_client.wait_for_share_replica_status(
replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC, replica['id'], constants.REPLICATION_STATE_OUT_OF_SYNC,
status_attr='replica_state') status_attr='replica_state')
# Attempt resync # Attempt resync
self.admin_client.resync_share_replica(replica['id']) self.admin_client.resync_share_replica(replica['id'])
self.shares_v2_client.wait_for_share_replica_status( self.admin_client.wait_for_share_replica_status(
replica['id'], constants.REPLICATION_STATE_IN_SYNC, replica['id'], constants.REPLICATION_STATE_IN_SYNC,
status_attr='replica_state') status_attr='replica_state')

78
manila_tempest_tests/tests/api/admin/test_replication_actions.py
View File

@ -16,7 +16,6 @@ from tempest.lib import exceptions as lib_exc
from tempest import test from tempest import test
import testtools import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.common import constants from manila_tempest_tests.common import constants
from manila_tempest_tests import share_exceptions from manila_tempest_tests import share_exceptions
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
@ -31,14 +30,15 @@ _MIN_SUPPORTED_MICROVERSION = '2.11'
CONF.share.multitenancy_enabled, CONF.share.multitenancy_enabled,
"Only for driver_handles_share_servers = False driver mode.") "Only for driver_handles_share_servers = False driver mode.")
@base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION) @base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION)
class ReplicationAdminTest(base.BaseSharesAdminTest): class ReplicationAdminTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ReplicationAdminTest, cls).resource_setup() super(ReplicationAdminTest, cls).resource_setup()
# Create share_type # Create share_type
name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX) name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX)
cls.admin_client = clients.AdminManager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.member_client = cls.shares_v2_client
cls.replication_type = CONF.share.backend_replication_type cls.replication_type = CONF.share.backend_replication_type
if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES: if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES:
@ -60,8 +60,9 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
# Create share with above share_type # Create share with above share_type
cls.share = cls.create_share(size=2, cls.share = cls.create_share(size=2,
share_type_id=cls.share_type["id"], share_type_id=cls.share_type["id"],
availability_zone=cls.share_zone,) availability_zone=cls.share_zone,
cls.replica = cls.shares_v2_client.list_share_replicas( client=cls.admin_client)
cls.replica = cls.admin_client.list_share_replicas(
share_id=cls.share['id'])[0] share_id=cls.share['id'])[0]
@test.attr(type=[base.TAG_POSITIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_API_WITH_BACKEND])
@ -70,21 +71,21 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
def test_extend_replicated_share(self): def test_extend_replicated_share(self):
# Test extend share # Test extend share
new_size = self.share["size"] + 1 new_size = self.share["size"] + 1
self.shares_v2_client.extend_share(self.share["id"], new_size) self.admin_client.extend_share(self.share["id"], new_size)
self.shares_v2_client.wait_for_share_status(self.share["id"], self.admin_client.wait_for_share_status(self.share["id"],
"available") "available")
share = self.shares_v2_client.get_share(self.share["id"]) share = self.admin_client.get_share(self.share["id"])
self.assertEqual(new_size, int(share["size"])) self.assertEqual(new_size, int(share["size"]))
@test.attr(type=[base.TAG_POSITIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_API_WITH_BACKEND])
@testtools.skipUnless(CONF.share.run_shrink_tests, @testtools.skipUnless(CONF.share.run_shrink_tests,
'Shrink share tests are disabled.') 'Shrink share tests are disabled.')
def test_shrink_replicated_share(self): def test_shrink_replicated_share(self):
share = self.shares_v2_client.get_share(self.share["id"]) share = self.admin_client.get_share(self.share["id"])
new_size = self.share["size"] - 1 new_size = self.share["size"] - 1
self.shares_v2_client.shrink_share(self.share["id"], new_size) self.admin_client.shrink_share(self.share["id"], new_size)
self.shares_v2_client.wait_for_share_status(share["id"], "available") self.admin_client.wait_for_share_status(share["id"], "available")
shrink_share = self.shares_v2_client.get_share(self.share["id"]) shrink_share = self.admin_client.get_share(self.share["id"])
self.assertEqual(new_size, int(shrink_share["size"])) self.assertEqual(new_size, int(shrink_share["size"]))
@test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND])
@ -96,30 +97,31 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
share = self.create_share(size=2, share = self.create_share(size=2,
share_type_id=self.share_type["id"], share_type_id=self.share_type["id"],
availability_zone=self.share_zone, availability_zone=self.share_zone,
cleanup_in_class=True) cleanup_in_class=True,
share = self.shares_v2_client.get_share(share["id"]) client=self.admin_client)
export_locations = self.shares_v2_client.list_share_export_locations( share = self.admin_client.get_share(share["id"])
export_locations = self.admin_client.list_share_export_locations(
share["id"]) share["id"])
export_path = export_locations[0]['path'] export_path = export_locations[0]['path']
self.shares_v2_client.unmanage_share(share['id']) self.admin_client.unmanage_share(share['id'])
self.shares_v2_client.wait_for_resource_deletion(share_id=share['id']) self.admin_client.wait_for_resource_deletion(share_id=share['id'])
# Manage the previously unmanaged share # Manage the previously unmanaged share
managed_share = self.shares_v2_client.manage_share( managed_share = self.admin_client.manage_share(
share['host'], share['share_proto'], share['host'], share['share_proto'],
export_path, self.share_type['id']) export_path, self.share_type['id'])
self.shares_v2_client.wait_for_share_status( self.admin_client.wait_for_share_status(
managed_share['id'], 'available') managed_share['id'], 'available')
# Add managed share to cleanup queue # Add managed share to cleanup queue
self.method_resources.insert( self.method_resources.insert(
0, {'type': 'share', 'id': managed_share['id'], 0, {'type': 'share', 'id': managed_share['id'],
'client': self.shares_v2_client}) 'client': self.admin_client})
# Make sure a replica can be added to newly managed share # Make sure a replica can be added to newly managed share
self.create_share_replica(managed_share['id'], self.replica_zone, self.create_share_replica(managed_share['id'], self.replica_zone,
cleanup=True) cleanup=True, client=self.admin_client)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@testtools.skipUnless(CONF.share.run_manage_unmanage_tests, @testtools.skipUnless(CONF.share.run_manage_unmanage_tests,
@ -128,10 +130,10 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Try to unmanage a share having replica.""" """Try to unmanage a share having replica."""
# Create a share replica before unmanaging the share # Create a share replica before unmanaging the share
self.create_share_replica(self.share["id"], self.replica_zone, self.create_share_replica(self.share["id"], self.replica_zone,
cleanup=True) cleanup=True, client=self.admin_client)
self.assertRaises( self.assertRaises(
lib_exc.Conflict, lib_exc.Conflict,
self.shares_v2_client.unmanage_share, self.admin_client.unmanage_share,
share_id=self.share['id']) share_id=self.share['id'])
@test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_BACKEND])
@ -141,9 +143,10 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Unmanage a replication type share that does not have replica.""" """Unmanage a replication type share that does not have replica."""
share = self.create_share(size=2, share = self.create_share(size=2,
share_type_id=self.share_type["id"], share_type_id=self.share_type["id"],
availability_zone=self.share_zone,) availability_zone=self.share_zone,
self.shares_v2_client.unmanage_share(share['id']) client=self.admin_client)
self.shares_v2_client.wait_for_resource_deletion(share_id=share['id']) self.admin_client.unmanage_share(share['id'])
self.admin_client.wait_for_resource_deletion(share_id=share['id'])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API_WITH_BACKEND])
@testtools.skipUnless(CONF.share.run_manage_unmanage_snapshot_tests, @testtools.skipUnless(CONF.share.run_manage_unmanage_snapshot_tests,
@ -152,10 +155,10 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Try to manage a snapshot of the replicated.""" """Try to manage a snapshot of the replicated."""
# Create a share replica before managing the snapshot # Create a share replica before managing the snapshot
self.create_share_replica(self.share["id"], self.replica_zone, self.create_share_replica(self.share["id"], self.replica_zone,
cleanup=True) cleanup=True, client=self.admin_client)
self.assertRaises( self.assertRaises(
lib_exc.Conflict, lib_exc.Conflict,
self.shares_v2_client.manage_snapshot, self.admin_client.manage_snapshot,
share_id=self.share['id'], share_id=self.share['id'],
provider_location="127.0.0.1:/fake_provider_location/" provider_location="127.0.0.1:/fake_provider_location/"
"manila_share_9dc61f49_fbc8_48d7_9337_2f9593d9") "manila_share_9dc61f49_fbc8_48d7_9337_2f9593d9")
@ -167,11 +170,12 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Try to unmanage a snapshot of the replicated share with replica.""" """Try to unmanage a snapshot of the replicated share with replica."""
# Create a share replica before unmanaging the snapshot # Create a share replica before unmanaging the snapshot
self.create_share_replica(self.share["id"], self.replica_zone, self.create_share_replica(self.share["id"], self.replica_zone,
cleanup=True) cleanup=True, client=self.admin_client)
snapshot = self.create_snapshot_wait_for_active(self.share["id"]) snapshot = self.create_snapshot_wait_for_active(
self.share["id"], client=self.admin_client)
self.assertRaises( self.assertRaises(
lib_exc.Conflict, lib_exc.Conflict,
self.shares_v2_client.unmanage_snapshot, self.admin_client.unmanage_snapshot,
snapshot_id=snapshot['id']) snapshot_id=snapshot['id'])
@test.attr(type=[base.TAG_POSITIVE, base.TAG_API_WITH_BACKEND]) @test.attr(type=[base.TAG_POSITIVE, base.TAG_API_WITH_BACKEND])
@ -181,9 +185,11 @@ class ReplicationAdminTest(base.BaseSharesAdminTest):
"""Unmanage a snapshot of the replicated share with no replica.""" """Unmanage a snapshot of the replicated share with no replica."""
share = self.create_share(size=2, share = self.create_share(size=2,
share_type_id=self.share_type["id"], share_type_id=self.share_type["id"],
availability_zone=self.share_zone,) availability_zone=self.share_zone,
client=self.admin_client)
snapshot = self.create_snapshot_wait_for_active(share["id"]) snapshot = self.create_snapshot_wait_for_active(
self.shares_v2_client.unmanage_snapshot(snapshot_id=snapshot['id']) share["id"], client=self.admin_client)
self.shares_v2_client.wait_for_resource_deletion( self.admin_client.unmanage_snapshot(snapshot_id=snapshot['id'])
self.admin_client.wait_for_resource_deletion(
snapshot_id=snapshot['id']) snapshot_id=snapshot['id'])

25
manila_tempest_tests/tests/api/admin/test_services_negative.py
View File

@ -17,30 +17,29 @@ import ddt
from tempest.lib import exceptions as lib_exc from tempest.lib import exceptions as lib_exc
from tempest import test from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
@ddt.ddt @ddt.ddt
class ServicesAdminNegativeTest(base.BaseSharesAdminTest): class ServicesAdminNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ServicesAdminNegativeTest, cls).resource_setup() super(ServicesAdminNegativeTest, cls).resource_setup()
user_clients = clients.Manager() cls.admin_client = cls.admin_shares_v2_client
cls.user_shares_client = user_clients.shares_client cls.member_client = cls.shares_v2_client
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_list_services_with_non_admin_user(self): def test_list_services_with_non_admin_user(self):
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.user_shares_client.list_services) self.member_client.list_services)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_service_by_invalid_params(self): def test_get_service_by_invalid_params(self):
# All services are expected if send the request with invalid parameter # All services are expected if send the request with invalid parameter
services = self.shares_client.list_services() services = self.admin_client.list_services()
params = {'fake_param': 'fake_param_value'} params = {'fake_param': 'fake_param_value'}
services_fake = self.shares_client.list_services(params) services_fake = self.admin_client.list_services(params)
self.assertEqual(len(services), len(services_fake)) self.assertEqual(len(services), len(services_fake))
# "update_at" field could be updated before second request, # "update_at" field could be updated before second request,
@ -58,31 +57,31 @@ class ServicesAdminNegativeTest(base.BaseSharesAdminTest):
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_service_by_invalid_host(self): def test_get_service_by_invalid_host(self):
params = {'host': 'fake_host'} params = {'host': 'fake_host'}
services_fake = self.shares_client.list_services(params) services_fake = self.admin_client.list_services(params)
self.assertEqual(0, len(services_fake)) self.assertEqual(0, len(services_fake))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_service_by_invalid_binary(self): def test_get_service_by_invalid_binary(self):
params = {'binary': 'fake_binary'} params = {'binary': 'fake_binary'}
services_fake = self.shares_client.list_services(params) services_fake = self.admin_client.list_services(params)
self.assertEqual(0, len(services_fake)) self.assertEqual(0, len(services_fake))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_service_by_invalid_zone(self): def test_get_service_by_invalid_zone(self):
params = {'zone': 'fake_zone'} params = {'zone': 'fake_zone'}
services_fake = self.shares_client.list_services(params) services_fake = self.admin_client.list_services(params)
self.assertEqual(0, len(services_fake)) self.assertEqual(0, len(services_fake))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_service_by_invalid_status(self): def test_get_service_by_invalid_status(self):
params = {'status': 'fake_status'} params = {'status': 'fake_status'}
services_fake = self.shares_client.list_services(params) services_fake = self.admin_client.list_services(params)
self.assertEqual(0, len(services_fake)) self.assertEqual(0, len(services_fake))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_service_by_invalid_state(self): def test_get_service_by_invalid_state(self):
params = {'state': 'fake_state'} params = {'state': 'fake_state'}
services_fake = self.shares_client.list_services(params) services_fake = self.admin_client.list_services(params)
self.assertEqual(0, len(services_fake)) self.assertEqual(0, len(services_fake))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -96,6 +95,6 @@ class ServicesAdminNegativeTest(base.BaseSharesAdminTest):
def test_list_services_with_wrong_versions(self, url, version): def test_list_services_with_wrong_versions(self, url, version):
self.assertRaises( self.assertRaises(
lib_exc.NotFound, lib_exc.NotFound,
self.shares_v2_client.list_services, self.admin_client.list_services,
version=version, url=url, version=version, url=url,
) )

38
manila_tempest_tests/tests/api/admin/test_share_servers_negative.py
View File

@ -13,78 +13,78 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest.lib.common.utils import data_utils # noqa from tempest.lib.common.utils import data_utils
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
class ShareServersNegativeAdminTest(base.BaseSharesAdminTest): class ShareServersNegativeAdminTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ShareServersNegativeAdminTest, cls).resource_setup() super(ShareServersNegativeAdminTest, cls).resource_setup()
cls.member_shares_client = clients.Manager().shares_client cls.admin_client = cls.admin_shares_v2_client
cls.member_client = cls.shares_v2_client
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_list_share_servers_with_member(self): def test_try_list_share_servers_with_member(self):
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.list_share_servers) self.member_client.list_share_servers)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_show_share_server_with_member(self): def test_try_show_share_server_with_member(self):
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.show_share_server, self.member_client.show_share_server,
'fake_id') 'fake_id')
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_show_share_server_details_with_member(self): def test_try_show_share_server_details_with_member(self):
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.show_share_server_details, self.member_client.show_share_server_details,
'fake_id') 'fake_id')
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_show_share_server_with_inexistent_id(self): def test_show_share_server_with_inexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.show_share_server, self.admin_client.show_share_server,
'fake_id') 'fake_id')
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_show_share_server_details_with_inexistent_id(self): def test_show_share_server_details_with_inexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.show_share_server_details, self.admin_client.show_share_server_details,
'fake_id') 'fake_id')
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_list_share_servers_with_wrong_filter_key(self): def test_list_share_servers_with_wrong_filter_key(self):
search_opts = {'fake_filter_key': 'ACTIVE'} search_opts = {'fake_filter_key': 'ACTIVE'}
servers = self.shares_client.list_share_servers(search_opts) servers = self.admin_client.list_share_servers(search_opts)
self.assertEqual(0, len(servers)) self.assertEqual(0, len(servers))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_list_share_servers_with_wrong_filter_value(self): def test_list_share_servers_with_wrong_filter_value(self):
search_opts = {'host': 123} search_opts = {'host': 123}
servers = self.shares_client.list_share_servers(search_opts) servers = self.admin_client.list_share_servers(search_opts)
self.assertEqual(0, len(servers)) self.assertEqual(0, len(servers))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_list_share_servers_with_fake_status(self): def test_list_share_servers_with_fake_status(self):
search_opts = {"status": data_utils.rand_name("fake_status")} search_opts = {"status": data_utils.rand_name("fake_status")}
servers = self.shares_client.list_share_servers(search_opts) servers = self.admin_client.list_share_servers(search_opts)
self.assertEqual(0, len(servers)) self.assertEqual(0, len(servers))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_list_share_servers_with_fake_host(self): def test_list_share_servers_with_fake_host(self):
search_opts = {"host": data_utils.rand_name("fake_host")} search_opts = {"host": data_utils.rand_name("fake_host")}
servers = self.shares_client.list_share_servers(search_opts) servers = self.admin_client.list_share_servers(search_opts)
self.assertEqual(0, len(servers)) self.assertEqual(0, len(servers))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_list_share_servers_with_fake_project(self): def test_list_share_servers_with_fake_project(self):
search_opts = {"project_id": data_utils.rand_name("fake_project_id")} search_opts = {"project_id": data_utils.rand_name("fake_project_id")}
servers = self.shares_client.list_share_servers(search_opts) servers = self.admin_client.list_share_servers(search_opts)
self.assertEqual(0, len(servers)) self.assertEqual(0, len(servers))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -92,17 +92,17 @@ class ShareServersNegativeAdminTest(base.BaseSharesAdminTest):
search_opts = { search_opts = {
"share_network": data_utils.rand_name("fake_share_network"), "share_network": data_utils.rand_name("fake_share_network"),
} }
servers = self.shares_client.list_share_servers(search_opts) servers = self.admin_client.list_share_servers(search_opts)
self.assertEqual(0, len(servers)) self.assertEqual(0, len(servers))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_delete_share_server_with_nonexistent_id(self): def test_delete_share_server_with_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.delete_share_server, self.admin_client.delete_share_server,
"fake_nonexistent_share_server_id") "fake_nonexistent_share_server_id")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_delete_share_server_with_member(self): def test_delete_share_server_with_member(self):
self.assertRaises(lib_exc.Forbidden, self.assertRaises(lib_exc.Forbidden,
self.member_shares_client.delete_share_server, self.member_client.delete_share_server,
"fake_nonexistent_share_server_id") "fake_nonexistent_share_server_id")

192
manila_tempest_tests/tests/api/admin/test_share_types_extra_specs_negative.py
View File

@ -13,32 +13,27 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest.lib.common.utils import data_utils # noqa from tempest.lib.common.utils import data_utils
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest): class ExtraSpecsAdminNegativeTest(base.BaseSharesMixedTest):
def _create_share_type(self): def _create_share_type(self):
name = data_utils.rand_name("unique_st_name") name = data_utils.rand_name("unique_st_name")
extra_specs = self.add_required_extra_specs_to_dict({"key": "value"}) extra_specs = self.add_required_extra_specs_to_dict({"key": "value"})
return self.create_share_type(name, extra_specs=extra_specs) return self.create_share_type(
name, extra_specs=extra_specs, client=self.admin_shares_v2_client)
@classmethod
def resource_setup(cls):
super(ExtraSpecsAdminNegativeTest, cls).resource_setup()
cls.member_shares_client = clients.Manager().shares_client
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_create_extra_specs_with_user(self): def test_try_create_extra_specs_with_user(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.create_share_type_extra_specs, self.shares_v2_client.create_share_type_extra_specs,
st["share_type"]["id"], st["share_type"]["id"],
self.add_required_extra_specs_to_dict({"key": "new_value"})) self.add_required_extra_specs_to_dict({"key": "new_value"}))
@ -47,7 +42,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.get_share_type_extra_specs, self.shares_v2_client.get_share_type_extra_specs,
st["share_type"]["id"]) st["share_type"]["id"])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -55,7 +50,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.get_share_type_extra_spec, self.shares_v2_client.get_share_type_extra_spec,
st["share_type"]["id"], "key") st["share_type"]["id"], "key")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -63,13 +58,13 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.get_share_type_extra_specs, self.shares_v2_client.get_share_type_extra_specs,
st["share_type"]["id"]) st["share_type"]["id"])
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_read_extra_specs_on_share_type_with_user(self): def test_try_read_extra_specs_on_share_type_with_user(self):
st = self._create_share_type() st = self._create_share_type()
share_type = self.member_shares_client.get_share_type( share_type = self.shares_v2_client.get_share_type(
st['share_type']['id']) st['share_type']['id'])
# Verify a non-admin can only read the required extra-specs # Verify a non-admin can only read the required extra-specs
expected_keys = ['driver_handles_share_servers', 'snapshot_support'] expected_keys = ['driver_handles_share_servers', 'snapshot_support']
@ -83,7 +78,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.update_share_type_extra_spec, self.shares_v2_client.update_share_type_extra_spec,
st["share_type"]["id"], "key", "new_value") st["share_type"]["id"], "key", "new_value")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -91,7 +86,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.update_share_type_extra_specs, self.shares_v2_client.update_share_type_extra_specs,
st["share_type"]["id"], {"key": "new_value"}) st["share_type"]["id"], {"key": "new_value"})
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -99,7 +94,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.Forbidden, lib_exc.Forbidden,
self.member_shares_client.delete_share_type_extra_spec, self.shares_v2_client.delete_share_type_extra_spec,
st["share_type"]["id"], "key") st["share_type"]["id"], "key")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -108,7 +103,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.BadRequest, lib_exc.BadRequest,
self.shares_client.create_share_type_extra_specs, self.admin_shares_v2_client.create_share_type_extra_specs,
st["share_type"]["id"], st["share_type"]["id"],
self.add_required_extra_specs_to_dict({too_big_key: "value"})) self.add_required_extra_specs_to_dict({too_big_key: "value"}))
@ -118,7 +113,7 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises( self.assertRaises(
lib_exc.BadRequest, lib_exc.BadRequest,
self.shares_client.create_share_type_extra_specs, self.admin_shares_v2_client.create_share_type_extra_specs,
st["share_type"]["id"], st["share_type"]["id"],
self.add_required_extra_specs_to_dict({"key": too_big_value})) self.add_required_extra_specs_to_dict({"key": too_big_value}))
@ -126,12 +121,12 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
def test_try_set_too_long_value_with_update(self): def test_try_set_too_long_value_with_update(self):
too_big_value = "v" * 256 too_big_value = "v" * 256
st = self._create_share_type() st = self._create_share_type()
self.shares_client.create_share_type_extra_specs( self.admin_shares_v2_client.create_share_type_extra_specs(
st["share_type"]["id"], st["share_type"]["id"],
self.add_required_extra_specs_to_dict({"key": "value"})) self.add_required_extra_specs_to_dict({"key": "value"}))
self.assertRaises( self.assertRaises(
lib_exc.BadRequest, lib_exc.BadRequest,
self.shares_client.update_share_type_extra_specs, self.admin_shares_v2_client.update_share_type_extra_specs,
st["share_type"]["id"], st["share_type"]["id"],
self.add_required_extra_specs_to_dict({"key": too_big_value})) self.add_required_extra_specs_to_dict({"key": too_big_value}))
@ -139,143 +134,164 @@ class ExtraSpecsAdminNegativeTest(base.BaseSharesAdminTest):
def test_try_set_too_long_value_with_update_of_one_key(self): def test_try_set_too_long_value_with_update_of_one_key(self):
too_big_value = "v" * 256 too_big_value = "v" * 256
st = self._create_share_type() st = self._create_share_type()
self.shares_client.create_share_type_extra_specs( self.admin_shares_v2_client.create_share_type_extra_specs(
st["share_type"]["id"], st["share_type"]["id"],
self.add_required_extra_specs_to_dict({"key": "value"})) self.add_required_extra_specs_to_dict({"key": "value"}))
self.assertRaises(lib_exc.BadRequest, self.assertRaises(
self.shares_client.update_share_type_extra_spec, lib_exc.BadRequest,
st["share_type"]["id"], "key", too_big_value) self.admin_shares_v2_client.update_share_type_extra_spec,
st["share_type"]["id"], "key", too_big_value)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_list_es_with_empty_shr_type_id(self): def test_try_list_es_with_empty_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.get_share_type_extra_specs, "") lib_exc.NotFound,
self.admin_shares_v2_client.get_share_type_extra_specs, "")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_list_es_with_invalid_shr_type_id(self): def test_try_list_es_with_invalid_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.get_share_type_extra_specs, lib_exc.NotFound,
data_utils.rand_name("fake")) self.admin_shares_v2_client.get_share_type_extra_specs,
data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_create_es_with_empty_shr_type_id(self): def test_try_create_es_with_empty_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.create_share_type_extra_specs, lib_exc.NotFound,
"", {"key1": "value1", }) self.admin_shares_v2_client.create_share_type_extra_specs,
"", {"key1": "value1", })
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_create_es_with_invalid_shr_type_id(self): def test_try_create_es_with_invalid_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.create_share_type_extra_specs, lib_exc.NotFound,
data_utils.rand_name("fake"), {"key1": "value1", }) self.admin_shares_v2_client.create_share_type_extra_specs,
data_utils.rand_name("fake"), {"key1": "value1", })
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_create_es_with_empty_specs(self): def test_try_create_es_with_empty_specs(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.BadRequest, self.assertRaises(
self.shares_client.create_share_type_extra_specs, lib_exc.BadRequest,
st["share_type"]["id"], "") self.admin_shares_v2_client.create_share_type_extra_specs,
st["share_type"]["id"], "")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_create_es_with_invalid_specs(self): def test_try_create_es_with_invalid_specs(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.BadRequest, self.assertRaises(
self.shares_client.create_share_type_extra_specs, lib_exc.BadRequest,
st["share_type"]["id"], {"": "value_with_empty_key"}) self.admin_shares_v2_client.create_share_type_extra_specs,
st["share_type"]["id"], {"": "value_with_empty_key"})
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_get_extra_spec_with_empty_key(self): def test_try_get_extra_spec_with_empty_key(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.get_share_type_extra_spec, lib_exc.NotFound,
st["share_type"]["id"], "") self.admin_shares_v2_client.get_share_type_extra_spec,
st["share_type"]["id"], "")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_get_extra_spec_with_invalid_key(self): def test_try_get_extra_spec_with_invalid_key(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.get_share_type_extra_spec, lib_exc.NotFound,
st["share_type"]["id"], data_utils.rand_name("fake")) self.admin_shares_v2_client.get_share_type_extra_spec,
st["share_type"]["id"], data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_get_extra_specs_with_empty_shr_type_id(self): def test_try_get_extra_specs_with_empty_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.get_share_type_extra_specs, lib_exc.NotFound,
"") self.admin_shares_v2_client.get_share_type_extra_specs,
"")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_get_extra_specs_with_invalid_shr_type_id(self): def test_try_get_extra_specs_with_invalid_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.get_share_type_extra_specs, lib_exc.NotFound,
data_utils.rand_name("fake")) self.admin_shares_v2_client.get_share_type_extra_specs,
data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_delete_es_key_with_empty_shr_type_id(self): def test_try_delete_es_key_with_empty_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.delete_share_type_extra_spec, lib_exc.NotFound,
"", "key", ) self.admin_shares_v2_client.delete_share_type_extra_spec,
"", "key", )
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_delete_es_key_with_invalid_shr_type_id(self): def test_try_delete_es_key_with_invalid_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.delete_share_type_extra_spec, lib_exc.NotFound,
data_utils.rand_name("fake"), "key", ) self.admin_shares_v2_client.delete_share_type_extra_spec,
data_utils.rand_name("fake"), "key", )
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_delete_with_invalid_key(self): def test_try_delete_with_invalid_key(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.delete_share_type_extra_spec, lib_exc.NotFound,
st["share_type"]["id"], data_utils.rand_name("fake")) self.admin_shares_v2_client.delete_share_type_extra_spec,
st["share_type"]["id"], data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_update_spec_with_empty_shr_type_id(self): def test_try_update_spec_with_empty_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.update_share_type_extra_spec, lib_exc.NotFound,
"", "key", "new_value") self.admin_shares_v2_client.update_share_type_extra_spec,
"", "key", "new_value")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_update_spec_with_invalid_shr_type_id(self): def test_try_update_spec_with_invalid_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.update_share_type_extra_spec, lib_exc.NotFound,
data_utils.rand_name("fake"), "key", "new_value") self.admin_shares_v2_client.update_share_type_extra_spec,
data_utils.rand_name("fake"), "key", "new_value")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_update_spec_with_empty_key(self): def test_try_update_spec_with_empty_key(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.update_share_type_extra_spec, lib_exc.NotFound,
st["share_type"]["id"], "", "new_value") self.admin_shares_v2_client.update_share_type_extra_spec,
st["share_type"]["id"], "", "new_value")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_update_with_invalid_shr_type_id(self): def test_try_update_with_invalid_shr_type_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.update_share_type_extra_specs, lib_exc.NotFound,
data_utils.rand_name("fake"), {"key": "new_value"}) self.admin_shares_v2_client.update_share_type_extra_specs,
data_utils.rand_name("fake"), {"key": "new_value"})
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_update_with_invalid_specs(self): def test_try_update_with_invalid_specs(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.BadRequest, self.assertRaises(
self.shares_client.update_share_type_extra_specs, lib_exc.BadRequest,
st["share_type"]["id"], {"": "new_value"}) self.admin_shares_v2_client.update_share_type_extra_specs,
st["share_type"]["id"], {"": "new_value"})
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_delete_spec_driver_handles_share_servers(self): def test_try_delete_spec_driver_handles_share_servers(self):
st = self._create_share_type() st = self._create_share_type()
# Try delete extra spec 'driver_handles_share_servers' # Try delete extra spec 'driver_handles_share_servers'
self.assertRaises(lib_exc.Forbidden, self.assertRaises(
self.shares_client.delete_share_type_extra_spec, lib_exc.Forbidden,
st["share_type"]["id"], self.admin_shares_v2_client.delete_share_type_extra_spec,
"driver_handles_share_servers") st["share_type"]["id"],
"driver_handles_share_servers")
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_delete_spec_snapshot_support(self): def test_try_delete_spec_snapshot_support(self):
st = self._create_share_type() st = self._create_share_type()
# Try delete extra spec 'snapshot_support' # Try delete extra spec 'snapshot_support'
self.assertRaises(lib_exc.Forbidden, self.assertRaises(
self.shares_client.delete_share_type_extra_spec, lib_exc.Forbidden,
st["share_type"]["id"], self.admin_shares_v2_client.delete_share_type_extra_spec,
"snapshot_support") st["share_type"]["id"],
"snapshot_support")

60
manila_tempest_tests/tests/api/admin/test_share_types_negative.py
View File

@ -13,52 +13,51 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest.lib.common.utils import data_utils # noqa from tempest.lib.common.utils import data_utils
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
class ShareTypesAdminNegativeTest(base.BaseSharesAdminTest): class ShareTypesAdminNegativeTest(base.BaseSharesMixedTest):
def _create_share_type(self): def _create_share_type(self):
name = data_utils.rand_name("unique_st_name") name = data_utils.rand_name("unique_st_name")
extra_specs = self.add_required_extra_specs_to_dict({"key": "value"}) extra_specs = self.add_required_extra_specs_to_dict({"key": "value"})
return self.create_share_type(name, extra_specs=extra_specs) return self.create_share_type(
name, extra_specs=extra_specs, client=self.admin_shares_v2_client)
@classmethod
def resource_setup(cls):
super(ShareTypesAdminNegativeTest, cls).resource_setup()
cls.member_shares_client = clients.Manager().shares_client
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_create_share_with_nonexistent_share_type(self): def test_create_share_with_nonexistent_share_type(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.create_share, self.admin_shares_v2_client.create_share,
share_type_id=data_utils.rand_name("fake")) share_type_id=data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_create_share_type_with_empty_name(self): def test_create_share_type_with_empty_name(self):
self.assertRaises(lib_exc.BadRequest, self.create_share_type, '') self.assertRaises(
lib_exc.BadRequest,
self.create_share_type, '',
client=self.admin_shares_v2_client)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_create_share_type_with_too_big_name(self): def test_create_share_type_with_too_big_name(self):
self.assertRaises(lib_exc.BadRequest, self.assertRaises(lib_exc.BadRequest,
self.create_share_type, self.create_share_type,
"x" * 256) "x" * 256,
client=self.admin_shares_v2_client)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_get_share_type_by_nonexistent_id(self): def test_get_share_type_by_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.get_share_type, self.admin_shares_v2_client.get_share_type,
data_utils.rand_name("fake")) data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_try_delete_share_type_by_nonexistent_id(self): def test_try_delete_share_type_by_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.delete_share_type, self.admin_shares_v2_client.delete_share_type,
data_utils.rand_name("fake")) data_utils.rand_name("fake"))
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
@ -67,34 +66,37 @@ class ShareTypesAdminNegativeTest(base.BaseSharesAdminTest):
self.assertRaises(lib_exc.Conflict, self.assertRaises(lib_exc.Conflict,
self.create_share_type, self.create_share_type,
st["share_type"]["name"], st["share_type"]["name"],
extra_specs=self.add_required_extra_specs_to_dict()) extra_specs=self.add_required_extra_specs_to_dict(),
client=self.admin_shares_v2_client)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_add_share_type_allowed_for_public(self): def test_add_share_type_allowed_for_public(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.Conflict, self.assertRaises(lib_exc.Conflict,
self.shares_client.add_access_to_share_type, self.admin_shares_v2_client.add_access_to_share_type,
st["share_type"]["id"], st["share_type"]["id"],
self.shares_client.tenant_id) self.admin_shares_v2_client.tenant_id)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_remove_share_type_allowed_for_public(self): def test_remove_share_type_allowed_for_public(self):
st = self._create_share_type() st = self._create_share_type()
self.assertRaises(lib_exc.Conflict, self.assertRaises(
self.shares_client.remove_access_from_share_type, lib_exc.Conflict,
st["share_type"]["id"], self.admin_shares_v2_client.remove_access_from_share_type,
self.shares_client.tenant_id) st["share_type"]["id"],
self.admin_shares_v2_client.tenant_id)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_add_share_type_by_nonexistent_id(self): def test_add_share_type_by_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(lib_exc.NotFound,
self.shares_client.add_access_to_share_type, self.admin_shares_v2_client.add_access_to_share_type,
data_utils.rand_name("fake"), data_utils.rand_name("fake"),
self.shares_client.tenant_id) self.admin_shares_v2_client.tenant_id)
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])
def test_remove_share_type_by_nonexistent_id(self): def test_remove_share_type_by_nonexistent_id(self):
self.assertRaises(lib_exc.NotFound, self.assertRaises(
self.shares_client.remove_access_from_share_type, lib_exc.NotFound,
data_utils.rand_name("fake"), self.admin_shares_v2_client.remove_access_from_share_type,
self.shares_client.tenant_id) data_utils.rand_name("fake"),
self.admin_shares_v2_client.tenant_id)

123
manila_tempest_tests/tests/api/base.py
View File

@ -21,6 +21,7 @@ import traceback
from oslo_concurrency import lockutils from oslo_concurrency import lockutils
from oslo_log import log from oslo_log import log
import six import six
from tempest import clients
from tempest.common import credentials_factory as common_creds from tempest.common import credentials_factory as common_creds
from tempest.common import dynamic_creds from tempest.common import dynamic_creds
from tempest import config from tempest import config
@ -28,8 +29,10 @@ from tempest.lib.common.utils import data_utils
from tempest.lib import exceptions from tempest.lib import exceptions
from tempest import test from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.common import constants from manila_tempest_tests.common import constants
from manila_tempest_tests.services.share.json import shares_client
from manila_tempest_tests.services.share.v2.json import (
shares_client as shares_v2_client)
from manila_tempest_tests import share_exceptions from manila_tempest_tests import share_exceptions
from manila_tempest_tests import utils from manila_tempest_tests import utils
@ -118,6 +121,7 @@ skip_if_microversion_lt = utils.skip_if_microversion_lt
class BaseSharesTest(test.BaseTestCase): class BaseSharesTest(test.BaseTestCase):
"""Base test case class for all Manila API tests.""" """Base test case class for all Manila API tests."""
credentials = ('primary', )
force_tenant_isolation = False force_tenant_isolation = False
protocols = ["nfs", "cifs", "glusterfs", "hdfs", "cephfs"] protocols = ["nfs", "cifs", "glusterfs", "hdfs", "cephfs"]
@ -178,15 +182,15 @@ class BaseSharesTest(test.BaseTestCase):
elif "alt" in type_of_creds: elif "alt" in type_of_creds:
creds = ic.get_alt_creds() creds = ic.get_alt_creds()
else: else:
creds = ic.self.get_credentials(type_of_creds) creds = ic.get_credentials(type_of_creds)
ic.type_of_creds = type_of_creds ic.type_of_creds = type_of_creds
# create client with isolated creds # create client with isolated creds
os = clients.Manager(credentials=creds) os = clients.Manager(credentials=creds)
if client_version == '1': if client_version == '1':
client = os.shares_client client = shares_client.SharesClient(os.auth_provider)
elif client_version == '2': elif client_version == '2':
client = os.shares_v2_client client = shares_v2_client.SharesV2Client(os.auth_provider)
# Set place where will be deleted isolated creds # Set place where will be deleted isolated creds
ic_res = { ic_res = {
@ -222,6 +226,23 @@ class BaseSharesTest(test.BaseTestCase):
msg = "Missing API credentials in configuration." msg = "Missing API credentials in configuration."
raise cls.skipException(msg) raise cls.skipException(msg)
@classmethod
def setup_clients(cls):
super(BaseSharesTest, cls).setup_clients()
os = getattr(cls, 'os_%s' % cls.credentials[0])
os.shares_client = shares_client.SharesClient(os.auth_provider)
cls.shares_client = os.shares_client
os.shares_v2_client = shares_v2_client.SharesV2Client(
os.auth_provider)
cls.shares_v2_client = os.shares_v2_client
if CONF.share.multitenancy_enabled:
if not CONF.service_available.neutron:
raise cls.skipException("Neutron support is required")
share_network_id = cls.provide_share_network(
cls.shares_v2_client, os.networks_client)
cls.shares_client.share_network_id = share_network_id
cls.shares_v2_client.share_network_id = share_network_id
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
if not (any(p in CONF.share.enable_protocols if not (any(p in CONF.share.enable_protocols
@ -230,22 +251,6 @@ class BaseSharesTest(test.BaseTestCase):
skip_msg = "Manila is disabled" skip_msg = "Manila is disabled"
raise cls.skipException(skip_msg) raise cls.skipException(skip_msg)
super(BaseSharesTest, cls).resource_setup() super(BaseSharesTest, cls).resource_setup()
if not hasattr(cls, "os"):
cls.username = CONF.identity.username
cls.password = CONF.identity.password
cls.project_name = CONF.identity.project_name
cls.verify_nonempty(cls.username, cls.password, cls.project_name)
cls.os = clients.Manager()
if CONF.share.multitenancy_enabled:
if not CONF.service_available.neutron:
raise cls.skipException("Neutron support is required")
sc = cls.os.shares_client
nc = cls.os.networks_client
share_network_id = cls.provide_share_network(sc, nc)
cls.os.shares_client.share_network_id = share_network_id
cls.os.shares_v2_client.share_network_id = share_network_id
cls.shares_client = cls.os.shares_client
cls.shares_v2_client = cls.os.shares_v2_client
def setUp(self): def setUp(self):
super(BaseSharesTest, self).setUp() super(BaseSharesTest, self).setUp()
@ -418,8 +423,7 @@ class BaseSharesTest(test.BaseTestCase):
:returns: list -- list of shares created using provided data. :returns: list -- list of shares created using provided data.
""" """
data = [copy.deepcopy(d) for d in share_data_list] for d in share_data_list:
for d in data:
if not isinstance(d, dict): if not isinstance(d, dict):
raise exceptions.TempestException( raise exceptions.TempestException(
"Expected 'dict', got '%s'" % type(d)) "Expected 'dict', got '%s'" % type(d))
@ -431,11 +435,20 @@ class BaseSharesTest(test.BaseTestCase):
raise exceptions.TempestException( raise exceptions.TempestException(
"Expected only 'args' and 'kwargs' keys. " "Expected only 'args' and 'kwargs' keys. "
"Provided %s" % list(d)) "Provided %s" % list(d))
d["kwargs"]["client"] = d["kwargs"].get(
"client", cls.shares_v2_client) data = []
d["share"] = cls._create_share(*d["args"], **d["kwargs"]) for d in share_data_list:
d["cnt"] = 0 client = d["kwargs"].pop("client", cls.shares_v2_client)
d["available"] = False local_d = {
"args": d["args"],
"kwargs": copy.deepcopy(d["kwargs"]),
}
local_d["kwargs"]["client"] = client
local_d["share"] = cls._create_share(
*local_d["args"], **local_d["kwargs"])
local_d["cnt"] = 0
local_d["available"] = False
data.append(local_d)
while not all(d["available"] for d in data): while not all(d["available"] for d in data):
for d in data: for d in data:
@ -836,36 +849,38 @@ class BaseSharesTest(test.BaseTestCase):
class BaseSharesAltTest(BaseSharesTest): class BaseSharesAltTest(BaseSharesTest):
"""Base test case class for all Shares Alt API tests.""" """Base test case class for all Shares Alt API tests."""
credentials = ('alt', )
@classmethod
def resource_setup(cls):
cls.username = CONF.identity.alt_username
cls.password = CONF.identity.alt_password
cls.project_name = CONF.identity.alt_project_name
cls.verify_nonempty(cls.username, cls.password, cls.project_name)
cls.os = clients.AltManager()
alt_share_network_id = CONF.share.alt_share_network_id
cls.os.shares_client.share_network_id = alt_share_network_id
cls.os.shares_v2_client.share_network_id = alt_share_network_id
super(BaseSharesAltTest, cls).resource_setup()
class BaseSharesAdminTest(BaseSharesTest): class BaseSharesAdminTest(BaseSharesTest):
"""Base test case class for all Shares Admin API tests.""" """Base test case class for all Shares Admin API tests."""
credentials = ('admin', )
class BaseSharesMixedTest(BaseSharesTest):
"""Base test case class for all Shares API tests with all user roles."""
credentials = ('primary', 'alt', 'admin')
@classmethod @classmethod
def resource_setup(cls): def setup_clients(cls):
if hasattr(CONF.identity, 'admin_username'): super(BaseSharesMixedTest, cls).setup_clients()
cls.username = CONF.identity.admin_username cls.admin_shares_client = shares_client.SharesClient(
cls.password = CONF.identity.admin_password cls.os_admin.auth_provider)
cls.project_name = CONF.identity.admin_project_name cls.admin_shares_v2_client = shares_v2_client.SharesV2Client(
else: cls.os_admin.auth_provider)
cls.username = CONF.auth.admin_username cls.alt_shares_client = shares_client.SharesClient(
cls.password = CONF.auth.admin_password cls.os_alt.auth_provider)
cls.project_name = CONF.auth.admin_project_name cls.alt_shares_v2_client = shares_v2_client.SharesV2Client(
cls.verify_nonempty(cls.username, cls.password, cls.project_name) cls.os_alt.auth_provider)
cls.os = clients.AdminManager()
admin_share_network_id = CONF.share.admin_share_network_id if CONF.share.multitenancy_enabled:
cls.os.shares_client.share_network_id = admin_share_network_id admin_share_network_id = cls.provide_share_network(
cls.os.shares_v2_client.share_network_id = admin_share_network_id cls.admin_shares_v2_client, cls.os_admin.networks_client)
super(BaseSharesAdminTest, cls).resource_setup() cls.admin_shares_client.share_network_id = admin_share_network_id
cls.admin_shares_v2_client.share_network_id = (
admin_share_network_id)
alt_share_network_id = cls.provide_share_network(
cls.alt_shares_v2_client, cls.os_alt.networks_client)
cls.alt_shares_client.share_network_id = alt_share_network_id
cls.alt_shares_v2_client.share_network_id = alt_share_network_id

9
manila_tempest_tests/tests/api/test_replication.py
View File

@ -18,7 +18,6 @@ from tempest.lib.common.utils import data_utils
from tempest import test from tempest import test
import testtools import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.common import constants from manila_tempest_tests.common import constants
from manila_tempest_tests import share_exceptions from manila_tempest_tests import share_exceptions
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
@ -34,14 +33,14 @@ DETAIL_KEYS = SUMMARY_KEYS + ['availability_zone', 'host', 'updated_at',
@testtools.skipUnless(CONF.share.run_replication_tests, @testtools.skipUnless(CONF.share.run_replication_tests,
'Replication tests are disabled.') 'Replication tests are disabled.')
@base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION) @base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION)
class ReplicationTest(base.BaseSharesTest): class ReplicationTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ReplicationTest, cls).resource_setup() super(ReplicationTest, cls).resource_setup()
# Create share_type # Create share_type
name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX) name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX)
cls.admin_client = clients.AdminManager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.replication_type = CONF.share.backend_replication_type cls.replication_type = CONF.share.backend_replication_type
if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES: if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES:
@ -288,14 +287,14 @@ class ReplicationTest(base.BaseSharesTest):
@testtools.skipUnless(CONF.share.run_replication_tests, @testtools.skipUnless(CONF.share.run_replication_tests,
'Replication tests are disabled.') 'Replication tests are disabled.')
@base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION) @base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION)
class ReplicationActionsTest(base.BaseSharesTest): class ReplicationActionsTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ReplicationActionsTest, cls).resource_setup() super(ReplicationActionsTest, cls).resource_setup()
# Create share_type # Create share_type
name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX) name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX)
cls.admin_client = clients.AdminManager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.replication_type = CONF.share.backend_replication_type cls.replication_type = CONF.share.backend_replication_type
if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES: if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES:

5
manila_tempest_tests/tests/api/test_replication_negative.py
View File

@ -19,7 +19,6 @@ from tempest.lib import exceptions as lib_exc
from tempest import test from tempest import test
import testtools import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.common import constants from manila_tempest_tests.common import constants
from manila_tempest_tests import share_exceptions from manila_tempest_tests import share_exceptions
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
@ -31,14 +30,14 @@ _MIN_SUPPORTED_MICROVERSION = '2.11'
@testtools.skipUnless(CONF.share.run_replication_tests, @testtools.skipUnless(CONF.share.run_replication_tests,
'Replication tests are disabled.') 'Replication tests are disabled.')
@base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION) @base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION)
class ReplicationNegativeTest(base.BaseSharesTest): class ReplicationNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ReplicationNegativeTest, cls).resource_setup() super(ReplicationNegativeTest, cls).resource_setup()
# Create share_type # Create share_type
name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX) name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX)
cls.admin_client = clients.AdminManager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.replication_type = CONF.share.backend_replication_type cls.replication_type = CONF.share.backend_replication_type
if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES: if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES:

5
manila_tempest_tests/tests/api/test_replication_snapshots.py
View File

@ -18,7 +18,6 @@ from tempest.lib.common.utils import data_utils
from tempest import test from tempest import test
import testtools import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.common import constants from manila_tempest_tests.common import constants
from manila_tempest_tests import share_exceptions from manila_tempest_tests import share_exceptions
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
@ -32,14 +31,14 @@ _MIN_SUPPORTED_MICROVERSION = '2.11'
@testtools.skipUnless(CONF.share.run_snapshot_tests, @testtools.skipUnless(CONF.share.run_snapshot_tests,
'Snapshot tests disabled.') 'Snapshot tests disabled.')
@base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION) @base.skip_if_microversion_lt(_MIN_SUPPORTED_MICROVERSION)
class ReplicationSnapshotTest(base.BaseSharesTest): class ReplicationSnapshotTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ReplicationSnapshotTest, cls).resource_setup() super(ReplicationSnapshotTest, cls).resource_setup()
# Create share_type # Create share_type
name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX) name = data_utils.rand_name(constants.TEMPEST_MANILA_PREFIX)
cls.admin_client = clients.AdminManager().shares_v2_client cls.admin_client = cls.admin_shares_v2_client
cls.replication_type = CONF.share.backend_replication_type cls.replication_type = CONF.share.backend_replication_type
if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES: if cls.replication_type not in constants.REPLICATION_TYPE_CHOICES:

4
manila_tempest_tests/tests/api/test_security_services.py
View File

@ -58,7 +58,7 @@ class SecurityServiceListMixin(object):
not CONF.share.multitenancy_enabled, "Only for multitenancy.") not CONF.share.multitenancy_enabled, "Only for multitenancy.")
def test_list_security_services_filter_by_share_network(self): def test_list_security_services_filter_by_share_network(self):
sn = self.shares_client.get_share_network( sn = self.shares_client.get_share_network(
self.os.shares_client.share_network_id) self.shares_client.share_network_id)
fresh_sn = [] fresh_sn = []
for i in range(2): for i in range(2):
sn = self.create_share_network( sn = self.create_share_network(
@ -163,7 +163,7 @@ class SecurityServicesTest(base.BaseSharesTest,
ss = self.create_security_service(**ss_data) ss = self.create_security_service(**ss_data)
sn = self.shares_client.get_share_network( sn = self.shares_client.get_share_network(
self.os.shares_client.share_network_id) self.shares_client.share_network_id)
fresh_sn = self.create_share_network( fresh_sn = self.create_share_network(
neutron_net_id=sn["neutron_net_id"], neutron_net_id=sn["neutron_net_id"],
neutron_subnet_id=sn["neutron_subnet_id"]) neutron_subnet_id=sn["neutron_subnet_id"])

12
manila_tempest_tests/tests/api/test_share_types_negative.py
View File

@ -13,15 +13,14 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest.lib.common.utils import data_utils # noqa from tempest.lib.common.utils import data_utils
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
class ShareTypesNegativeTest(base.BaseSharesTest): class ShareTypesNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def _create_share_type(cls): def _create_share_type(cls):
@ -29,11 +28,12 @@ class ShareTypesNegativeTest(base.BaseSharesTest):
extra_specs = cls.add_required_extra_specs_to_dict() extra_specs = cls.add_required_extra_specs_to_dict()
return cls.create_share_type( return cls.create_share_type(
name, extra_specs=extra_specs, name, extra_specs=extra_specs,
client=clients.AdminManager().shares_client) client=cls.admin_client)
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(ShareTypesNegativeTest, cls).resource_setup() super(ShareTypesNegativeTest, cls).resource_setup()
cls.admin_client = cls.admin_shares_v2_client
cls.st = cls._create_share_type() cls.st = cls._create_share_type()
@test.attr(type=[base.TAG_NEGATIVE, base.TAG_API]) @test.attr(type=[base.TAG_NEGATIVE, base.TAG_API])

18
manila_tempest_tests/tests/api/test_shares_actions_negative.py
View File

@ -13,21 +13,21 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from tempest import config # noqa from tempest import config
from tempest.lib import exceptions as lib_exc # noqa from tempest.lib import exceptions as lib_exc
from tempest import test # noqa from tempest import test
import testtools # noqa import testtools
from manila_tempest_tests import clients_share as clients
from manila_tempest_tests.tests.api import base from manila_tempest_tests.tests.api import base
CONF = config.CONF CONF = config.CONF
class SharesActionsNegativeTest(base.BaseSharesTest): class SharesActionsNegativeTest(base.BaseSharesMixedTest):
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
super(SharesActionsNegativeTest, cls).resource_setup() super(SharesActionsNegativeTest, cls).resource_setup()
cls.admin_client = cls.admin_shares_v2_client
cls.share = cls.create_share( cls.share = cls.create_share(
size=1, size=1,
) )
@ -85,8 +85,7 @@ class SharesActionsNegativeTest(base.BaseSharesTest):
new_size = int(share['size']) + 1 new_size = int(share['size']) + 1
# set "error" state # set "error" state
admin_client = clients.AdminManager().shares_client self.admin_client.reset_state(share['id'])
admin_client.reset_state(share['id'])
# run extend operation on same share and check result # run extend operation on same share and check result
self.assertRaises(lib_exc.BadRequest, self.assertRaises(lib_exc.BadRequest,
@ -129,8 +128,7 @@ class SharesActionsNegativeTest(base.BaseSharesTest):
new_size = int(share['size']) - 1 new_size = int(share['size']) - 1
# set "error" state # set "error" state
admin_client = clients.AdminManager().shares_client self.admin_client.reset_state(share['id'])
admin_client.reset_state(share['id'])
# run shrink operation on same share and check result # run shrink operation on same share and check result
self.assertRaises(lib_exc.BadRequest, self.assertRaises(lib_exc.BadRequest,

26
manila_tempest_tests/tests/scenario/manager_share.py
View File

@ -16,32 +16,38 @@
from oslo_log import log from oslo_log import log
import six import six
from tempest.common.utils.linux import remote_client # noqa from tempest.common.utils.linux import remote_client
from tempest import config # noqa from tempest import config
from tempest.lib.common.utils import data_utils from tempest.lib.common.utils import data_utils
from tempest.scenario import manager # noqa from tempest.scenario import manager
from manila_tempest_tests import clients_share from manila_tempest_tests.services.share.json import shares_client
from manila_tempest_tests.services.share.v2.json import (
shares_client as shares_v2_client)
CONF = config.CONF CONF = config.CONF
LOG = log.getLogger(__name__) LOG = log.getLogger(__name__)
class ShareScenarioTest(manager.NetworkScenarioTest): class ShareScenarioTest(manager.NetworkScenarioTest):
"""Provide harness to do Manila scenario tests.""" """Provide harness to do Manila scenario tests."""
credentials = ('admin', 'primary')
@classmethod @classmethod
def resource_setup(cls): def resource_setup(cls):
cls.set_network_resources() cls.set_network_resources()
super(ShareScenarioTest, cls).resource_setup() super(ShareScenarioTest, cls).resource_setup()
# Manila clients # Manila clients
cls.shares_client = clients_share.Manager().shares_client cls.shares_client = shares_client.SharesClient(
cls.shares_v2_client = clients_share.Manager().shares_v2_client cls.os_primary.auth_provider)
cls.shares_admin_client = clients_share.AdminManager().shares_client cls.shares_v2_client = shares_v2_client.SharesV2Client(
cls.shares_admin_v2_client = ( cls.os_primary.auth_provider)
clients_share.AdminManager().shares_v2_client) cls.shares_admin_client = shares_client.SharesClient(
cls.os_admin.auth_provider)
cls.shares_admin_v2_client = shares_v2_client.SharesV2Client(
cls.os_admin.auth_provider)
def _create_share(self, share_protocol=None, size=1, name=None, def _create_share(self, share_protocol=None, size=1, name=None,
snapshot_id=None, description=None, metadata=None, snapshot_id=None, description=None, metadata=None,