openstack
/
adjutant
Code Issues Proposed changes

Added modify_dict_settings test decorator 

This decorator allows for modification of test settings that are
stored as dictionaries for that tests only without needing to
override the whole dictionary. It acts in a similar way to django's
in built override_settings, and modify_settings.

To be applied to a class the class must subclass StacktaskTestCase
or StacktaskAPITestCase. In those two classes settings can also
be modified using:

with self.modify_dict_settings(...):
	# code

Example Usage:
@modify_dict_settings(ROLES_MAPPING=[
		    {'key_list': ['project_mod'],
		    'operation': 'remove',
		    'value': 'heat_stack_owner'},
		    {'key_list': ['project_admin'],
		    'operation': 'append',
		    'value': 'heat_stack_owner'},
		    ])
or
@modify_dict_settings(PROJECT_QUOTA_SIZES={
		    'key_list': ['small', 'nova', 'instances'],
		    'operations': 'override',
		    'value': 11
		    })

Available operations:
Standard operations:
- 'override': Either overrides or adds the value to the dictionary.
- 'delete': Removes the value from the dictionary.

List operations:
List operations expect that the accessed value in the dictionary
is a list.
- 'append': Add the specified values to the end of the list
- 'prepend': Add the specifed values to the start of the list
- 'remove': Remove the specified values from the list

Change-Id: I575c17891d14418c335b2fb8426830e6e31be515
This commit is contained in:
Amelia Cordwell 2017-01-05 15:21:36 +13:00 committed by adrian-turjak
parent 0ff277f208
commit bbc0f31062
7 changed files with 330 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
stacktask/actions/v1/tests/test_project_actions.py
View File

@ -20,7 +20,8 @@ from stacktask.actions.v1.projects import (
NewProjectWithUserAction, AddDefaultUsersToProjectAction)
from stacktask.api.models import Task
from stacktask.api.v1 import tests
from stacktask.api.v1.tests import FakeManager, setup_temp_cache
from stacktask.api.v1.tests import (FakeManager, setup_temp_cache,
modify_dict_settings)
@mock.patch('stacktask.actions.user_store.IdentityManager',
@ -449,6 +450,11 @@ class ProjectActionTests(TestCase):
action.post_approve()
self.assertEquals(action.valid, False)
@modify_dict_settings(DEFAULT_ACTION_SETTINGS={
'key_list': ['AddDefaultUsersToProjectAction'],
'operation': 'override',
'value': {'default_users': ['admin', ],
'default_roles': ['admin', ]}})
def test_add_default_users(self):
"""
Base case, adds admin user with admin role to project.
@ -512,6 +518,11 @@ class ProjectActionTests(TestCase):
# Now the missing project should make the action invalid
self.assertEquals(action.valid, False)
@modify_dict_settings(DEFAULT_ACTION_SETTINGS={
'key_list': ['AddDefaultUsersToProjectAction'],
'operation': 'override',
'value': {'default_users': ['admin', ],
'default_roles': ['admin', ]}})
def test_add_default_users_reapprove(self):
"""
Ensure nothing happens or changes during rerun of approve.

14
stacktask/actions/v1/tests/test_resource_actions.py
View File

@ -20,7 +20,8 @@ from stacktask.actions.v1.resources import (
NewDefaultNetworkAction, NewProjectDefaultNetworkAction,
SetProjectQuotaAction)
from stacktask.api.models import Task
from stacktask.api.v1.tests import FakeManager, setup_temp_cache
from stacktask.api.v1.tests import (FakeManager, setup_temp_cache,
modify_dict_settings)
from stacktask.actions.v1.tests import (
get_fake_neutron, get_fake_novaclient, get_fake_cinderclient,
setup_neutron_cache, neutron_cache, cinder_cache, nova_cache,
@ -207,6 +208,17 @@ class ProjectSetupActionTests(TestCase):
self.assertEquals(len(
neutron_cache['RegionOne']['test_project_id']['subnets']), 1)
@modify_dict_settings(DEFAULT_ACTION_SETTINGS={
'operation': 'override',
'key_list': ['NewDefaultNetworkAction'],
'value': {'RegionOne': {
'DNS_NAMESERVERS': ['193.168.1.2', '193.168.1.3'],
'SUBNET_CIDR': '192.168.1.0/24',
'network_name': 'somenetwork',
'public_network': '3cb50f61-5bce-4c03-96e6-8e262e12bb35',
'router_name': 'somerouter',
'subnet_name': 'somesubnet'
}}})
def test_new_project_network_setup(self):
"""
Base case, setup network after a new project, no issues.

129
stacktask/actions/v1/tests/test_user_actions.py
View File

@ -12,20 +12,19 @@
# License for the specific language governing permissions and limitations
# under the License.
from django.test import TestCase
import mock
from stacktask.actions.v1.users import (
EditUserRolesAction, NewUserAction, ResetUserPasswordAction)
from stacktask.api.models import Task
from stacktask.api.v1 import tests
from stacktask.api.v1.tests import FakeManager, setup_temp_cache
from stacktask.api.v1.tests import (FakeManager, setup_temp_cache,
modify_dict_settings, StacktaskTestCase)
@mock.patch('stacktask.actions.user_store.IdentityManager',
FakeManager)
class UserActionTests(TestCase):
class UserActionTests(StacktaskTestCase):
def test_new_user(self):
"""
@ -711,3 +710,125 @@ class UserActionTests(TestCase):
self.assertEquals(
project.roles[user.id], ['_member_', 'project_admin'])
def test_edit_user_roles_modified_settings(self):
"""
Tests that the role mappings do come from settings and that they
are enforced.
"""
project = mock.Mock()
project.id = 'test_project_id'
project.name = 'test_project'
project.domain = 'default'
project.roles = {'user_id': ['project_mod']}
user = mock.Mock()
user.id = 'user_id'
user.name = "test@example.com"
user.email = "test@example.com"
user.domain = 'default'
setup_temp_cache({'test_project': project}, {user.id: user})
task = Task.objects.create(
ip_address="0.0.0.0",
keystone_user={
'roles': ['project_mod'],
'project_id': 'test_project_id',
'project_domain_id': 'default',
})
data = {
'domain_id': 'default',
'user_id': 'user_id',
'project_id': 'test_project_id',
'roles': ['heat_stack_owner'],
'remove': False
}
action = EditUserRolesAction(data, task=task, order=1)
action.pre_approve()
self.assertEquals(action.valid, True)
# Remove role from ROLES_MAPPING
with self.modify_dict_settings(ROLES_MAPPING={
'key_list': ['project_mod'],
'operation': "remove",
'value': 'heat_stack_owner'}):
action.post_approve()
self.assertEquals(action.valid, False)
token_data = {}
action.submit(token_data)
self.assertEquals(action.valid, False)
# After Settings Reset
action.post_approve()
self.assertEquals(action.valid, True)
token_data = {}
action.submit(token_data)
self.assertEquals(action.valid, True)
self.assertEquals(len(project.roles[user.id]), 2)
self.assertEquals(set(project.roles[user.id]),
set(['project_mod', 'heat_stack_owner']))
@modify_dict_settings(ROLES_MAPPING={'key_list': ['project_mod'],
'operation': "append", 'value': 'new_role'})
def test_edit_user_roles_modified_settings_add(self):
"""
Tests that the role mappings do come from settings and a new role
added there will be allowed.
"""
project = mock.Mock()
project.id = 'test_project_id'
project.name = 'test_project'
project.domain = 'default'
project.roles = {'user_id': ['project_mod']}
user = mock.Mock()
user.id = 'user_id'
user.name = "test@example.com"
user.email = "test@example.com"
user.domain = 'default'
setup_temp_cache({'test_project': project}, {user.id: user})
# Add a new role to the temp cache
tests.temp_cache['roles']['new_role'] = 'new_role'
task = Task.objects.create(
ip_address="0.0.0.0",
keystone_user={
'roles': ['project_mod'],
'project_id': 'test_project_id',
'project_domain_id': 'default',
})
data = {
'domain_id': 'default',
'user_id': 'user_id',
'project_id': 'test_project_id',
'roles': ['new_role'],
'remove': False
}
action = EditUserRolesAction(data, task=task, order=1)
action.pre_approve()
self.assertEquals(action.valid, True)
action.post_approve()
self.assertEquals(action.valid, True)
token_data = {}
action.submit(token_data)
self.assertEquals(action.valid, True)
self.assertEquals(len(project.roles[user.id]), 2)
self.assertEquals(set(project.roles[user.id]),
set(['project_mod', 'new_role']))

169
stacktask/api/v1/tests/__init__.py
View File

@ -12,9 +12,15 @@
# License for the specific language governing permissions and limitations
# under the License.
import mock
import six
import copy
from django.conf import settings
from django.test.utils import override_settings
from django.test import TestCase
from rest_framework.test import APITestCase
temp_cache = {}
@ -112,6 +118,7 @@ class FakeManager(object):
r = mock.Mock()
r.name = role
user.roles.append(r)
users.append(user)
return users
@ -251,3 +258,165 @@ class FakeManager(object):
def get_region(self, region_id):
global temp_cache
return temp_cache['regions'].get(region_id, None)
class modify_dict_settings(override_settings):
"""
A decorator like djangos modify_settings and override_settings, but makes
it possible to do those same operations on dict based settings.
The decorator will act after both override_settings and modify_settings.
Can be applied to test functions or StacktaskTestCase,
StacktaskAPITestCase classes. In those two classes settings can also
be modified using:
with self.modify_dict_settings(...):
# code
Example Usage:
@modify_dict_settings(ROLES_MAPPING=[
{'key_list': ['project_mod'],
'operation': 'remove',
'value': 'heat_stack_owner'},
{'key_list': ['project_admin'],
'operation': 'append',
'value': 'heat_stack_owner'},
])
or
@modify_dict_settings(PROJECT_QUOTA_SIZES={
'key_list': ['small', 'nova', 'instances'],
'operations': 'override',
'value': 11
})
Available operations:
Standard operations:
- 'override': Either overrides or adds the value to the dictionary.
- 'delete': Removes the value from the dictionary.
List operations:
List operations expect that the accessed value in the dictionary is a list.
- 'append': Add the specified values to the end of the list
- 'prepend': Add the specifed values to the start of the list
- 'remove': Remove the specified values from the list
"""
def __init__(self, *args, **kwargs):
if args:
# Hack used when instantiating from SimpleTestCase.setUpClass.
assert not kwargs
self.operations = args[0]
else:
assert not args
self.operations = list(kwargs.items())
super(override_settings, self).__init__()
def save_options(self, test_func):
if test_func._modified_dict_settings is None:
test_func._modified_dict_settings = self.operations
else:
# Duplicate list to prevent subclasses from altering their parent.
test_func._modified_dict_settings = list(
test_func._modified_dict_settings) + self.operations
def disable(self):
self.wrapped = self._wrapped
super(modify_dict_settings, self).disable()
def enable(self):
self.options = {}
self._wrapped = copy.deepcopy(settings._wrapped)
for name, operation_list in self.operations:
try:
value = self.options[name]
except KeyError:
value = getattr(settings, name, [])
if not isinstance(value, dict):
raise ValueError("Initial setting not dictionary.")
if not isinstance(operation_list, list):
operation_list = [operation_list]
for operation in operation_list:
op_type = operation['operation']
holding_dict = value
# Recursively find the dict we want
key_len = len(operation['key_list'])
final_key = operation['key_list'][0]
for i in range(key_len):
current_key = operation['key_list'][i]
if i == (key_len - 1):
final_key = current_key
else:
try:
holding_dict = holding_dict[current_key]
except KeyError:
holding_dict[current_key] = {}
holding_dict = holding_dict[current_key]
if op_type == "override":
holding_dict[final_key] = operation['value']
elif op_type == "delete":
del holding_dict[final_key]
else:
val = holding_dict.get(final_key, [])
items = operation['value']
if not isinstance(items, list):
items = [items]
if op_type == 'append':
holding_dict[final_key] = val + [
item for item in items if item not in val]
elif op_type == 'prepend':
holding_dict[final_key] = ([item for item in items if
item not in val] + val)
elif op_type == 'remove':
holding_dict[final_key] = [
item for item in val if item not in items]
else:
raise ValueError("Unsupported action: %s" % op_type)
self.options[name] = value
super(modify_dict_settings, self).enable()
class TestCaseMixin(object):
""" Mixin to add modify_dict_settings functions to test classes """
@classmethod
def setUpClass(cls):
super(StacktaskAPITestCase, cls).setUpClass()
if cls._modified_dict_settings:
cls._cls_modifyied_dict_context = override_settings(
**cls._overridden_settings)
cls._cls_modifyied_dict_context.enable()
@classmethod
def tearDownClass(cls):
if hasattr(cls, '_cls_modified_dict_context'):
cls._cls_modified_dict_context.disable()
delattr(cls, '_cls_modified_dict_context')
super(StacktaskAPITestCase, cls).tearDownClass()
def modify_dict_settings(self, **kwargs):
return modify_dict_settings(**kwargs)
class StacktaskTestCase(TestCase, TestCaseMixin):
"""
TestCase override that has support for @modify_dict_settings as a
class decorator and internal function
"""
class StacktaskAPITestCase(APITestCase, TestCaseMixin):
"""
APITestCase override that has support for @modify_dict_settings as a
class decorator, and internal function
"""

9
stacktask/api/v1/tests/test_api_admin.py
View File

@ -26,7 +26,8 @@ from rest_framework import status
from rest_framework.test import APITestCase
from stacktask.api.models import Task, Token
from stacktask.api.v1.tests import FakeManager, setup_temp_cache
from stacktask.api.v1.tests import (FakeManager, setup_temp_cache,
modify_dict_settings)
@mock.patch('stacktask.actions.user_store.IdentityManager',
@ -1022,6 +1023,12 @@ class AdminAPITests(APITestCase):
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
@modify_dict_settings(TASK_SETTINGS={
'key_list': ['reset_password', 'action_settings',
'ResetUserPasswordAction', 'blacklisted_roles'],
'operation': 'append',
'value': ['admin']
})
def test_reset_admin(self):
"""
Ensure that you cannot issue a password reset for an

6
stacktask/api/v1/tests/test_api_taskview.py
View File

@ -15,15 +15,15 @@
import mock
from rest_framework import status
from rest_framework.test import APITestCase
from stacktask.api.models import Task, Token
from stacktask.api.v1.tests import FakeManager, setup_temp_cache
from stacktask.api.v1.tests import (FakeManager, setup_temp_cache,
StacktaskAPITestCase)
@mock.patch('stacktask.actions.user_store.IdentityManager',
FakeManager)
class TaskViewTests(APITestCase):
class TaskViewTests(StacktaskAPITestCase):
"""
Tests to ensure the approval/token workflow does what is
expected with the given TaskViews. These test don't check

11
stacktask/test_settings.py
View File

@ -122,9 +122,6 @@ DEFAULT_ACTION_SETTINGS = {
'NewUserAction': {
'allowed_roles': ['project_mod', 'project_admin', "_member_"]
},
'ResetUserPasswordAction': {
'blacklisted_roles': ['admin']
},
'NewDefaultNetworkAction': {
'RegionOne': {
'DNS_NAMESERVERS': ['193.168.1.2', '193.168.1.3'],
@ -145,14 +142,6 @@ DEFAULT_ACTION_SETTINGS = {
'subnet_name': 'somesubnet'
},
},
'AddDefaultUsersToProjectAction': {
'default_users': [
'admin',
],
'default_roles': [
'admin',
],
},
'SetProjectQuotaAction': {
'regions': {
'RegionOne': {