d804628933
Vim settings can be done in your vimrc file, there is no need to add them in each source files. Also if set incorrectly, gate (pep8 check) will catch your mistakes. NOTE: openstack.common files are left untouched because they should be fixed in oslo. Change-Id: I96fe6479e64a13766e7a974727405423a66cd496 Closes-Bug: #1229324
300 lines
9.1 KiB
Python
300 lines
9.1 KiB
Python
# 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 heatclient.v1.stacks import Stack
|
|
from heatclient.v1.stacks import StackManager
|
|
|
|
from mock import MagicMock
|
|
import testscenarios
|
|
from testscenarios.scenarios import multiply_scenarios
|
|
import testtools
|
|
|
|
load_tests = testscenarios.load_tests_apply_scenarios
|
|
|
|
|
|
def mock_stack(manager, stack_name, stack_id):
|
|
return Stack(manager, {
|
|
"id": stack_id,
|
|
"stack_name": stack_name,
|
|
"links": [{
|
|
"href": "http://192.0.2.1:8004/v1/1234/stacks/%s/%s" % (
|
|
stack_name, stack_id),
|
|
"rel": "self"}],
|
|
"description": "No description",
|
|
"stack_status_reason": "Stack create completed successfully",
|
|
"creation_time": "2013-08-04T20:57:55Z",
|
|
"updated_time": "2013-08-04T20:57:55Z",
|
|
"stack_status": "CREATE_COMPLETE"
|
|
})
|
|
|
|
|
|
class StackStatusActionTest(testtools.TestCase):
|
|
|
|
scenarios = multiply_scenarios([
|
|
('CREATE', dict(action='CREATE')),
|
|
('DELETE', dict(action='DELETE')),
|
|
('UPDATE', dict(action='UPDATE')),
|
|
('ROLLBACK', dict(action='ROLLBACK')),
|
|
('SUSPEND', dict(action='SUSPEND')),
|
|
('RESUME', dict(action='RESUME'))
|
|
], [
|
|
('IN_PROGRESS', dict(status='IN_PROGRESS')),
|
|
('FAILED', dict(status='FAILED')),
|
|
('COMPLETE', dict(status='COMPLETE'))
|
|
])
|
|
|
|
def test_status_action(self):
|
|
stack_status = '%s_%s' % (self.action, self.status)
|
|
stack = mock_stack(None, 'stack_1', 'abcd1234')
|
|
stack.stack_status = stack_status
|
|
self.assertEqual(self.action, stack.action)
|
|
self.assertEqual(self.status, stack.status)
|
|
|
|
|
|
class StackIdentifierTest(testtools.TestCase):
|
|
|
|
def test_stack_identifier(self):
|
|
stack = mock_stack(None, 'the_stack', 'abcd1234')
|
|
self.assertEqual('the_stack/abcd1234', stack.identifier)
|
|
|
|
|
|
class StackOperationsTest(testtools.TestCase):
|
|
|
|
def test_delete_stack(self):
|
|
manager = MagicMock()
|
|
stack = mock_stack(manager, 'the_stack', 'abcd1234')
|
|
stack.delete()
|
|
manager.delete.assert_called_once_with('the_stack/abcd1234')
|
|
|
|
def test_get_stack(self):
|
|
manager = MagicMock()
|
|
stack = mock_stack(manager, 'the_stack', 'abcd1234')
|
|
stack.get()
|
|
manager.get.assert_called_once_with('the_stack/abcd1234')
|
|
|
|
def test_update_stack(self):
|
|
manager = MagicMock()
|
|
stack = mock_stack(manager, 'the_stack', 'abcd1234')
|
|
stack.update()
|
|
manager.update.assert_called_once_with('the_stack/abcd1234')
|
|
|
|
def test_create_stack(self):
|
|
manager = MagicMock()
|
|
stack = mock_stack(manager, 'the_stack', 'abcd1234')
|
|
stack = stack.create()
|
|
manager.create.assert_called_once_with('the_stack/abcd1234')
|
|
|
|
|
|
class StackManagerNoPaginationTest(testtools.TestCase):
|
|
|
|
scenarios = [
|
|
('total_0', dict(total=0)),
|
|
('total_1', dict(total=1)),
|
|
('total_9', dict(total=9)),
|
|
('total_10', dict(total=10)),
|
|
('total_11', dict(total=11)),
|
|
('total_19', dict(total=19)),
|
|
('total_20', dict(total=20)),
|
|
('total_21', dict(total=21)),
|
|
('total_49', dict(total=49)),
|
|
('total_50', dict(total=50)),
|
|
('total_51', dict(total=51)),
|
|
('total_95', dict(total=95)),
|
|
]
|
|
|
|
# absolute limit for results returned
|
|
limit = 50
|
|
|
|
def mock_manager(self):
|
|
manager = StackManager(None)
|
|
manager._list = MagicMock()
|
|
|
|
def mock_list(*args, **kwargs):
|
|
def results():
|
|
for i in range(0, self.total):
|
|
stack_name = 'stack_%s' % (i + 1)
|
|
stack_id = 'abcd1234-%s' % (i + 1)
|
|
yield mock_stack(manager, stack_name, stack_id)
|
|
|
|
return list(results())
|
|
|
|
manager._list.side_effect = mock_list
|
|
return manager
|
|
|
|
def test_stack_list_no_pagination(self):
|
|
manager = self.mock_manager()
|
|
results = list(manager.list(limit=self.limit))
|
|
manager._list.assert_called_once_with(
|
|
'/stacks?', 'stacks')
|
|
|
|
last_result = min(self.limit, self.total)
|
|
# paginate is not specified, so the total
|
|
# results (up to the limit) is always returned
|
|
self.assertEqual(last_result, len(results))
|
|
|
|
if last_result > 0:
|
|
self.assertEqual('stack_1', results[0].stack_name)
|
|
self.assertEqual('stack_%s' % last_result, results[-1].stack_name)
|
|
|
|
def test_stack_list_no_pagination_no_limit(self):
|
|
manager = self.mock_manager()
|
|
|
|
results = list(manager.list())
|
|
manager._list.assert_called_once_with(
|
|
'/stacks?', 'stacks')
|
|
|
|
# paginate is not specified, so the total
|
|
# results is always returned
|
|
self.assertEqual(self.total, len(results))
|
|
|
|
if self.total > 0:
|
|
self.assertEqual('stack_1', results[0].stack_name)
|
|
self.assertEqual('stack_%s' % self.total, results[-1].stack_name)
|
|
|
|
|
|
class StackManagerPaginationTest(testtools.TestCase):
|
|
|
|
scenarios = [
|
|
('0_offset_0', dict(
|
|
page_size=10,
|
|
offset=0,
|
|
total=0,
|
|
results=((0, 0),)
|
|
)),
|
|
('1_offset_0', dict(
|
|
page_size=10,
|
|
offset=0,
|
|
total=1,
|
|
results=((0, 1),)
|
|
)),
|
|
('9_offset_0', dict(
|
|
page_size=10,
|
|
offset=0,
|
|
total=9,
|
|
results=((0, 9),)
|
|
)),
|
|
('10_offset_0', dict(
|
|
page_size=10,
|
|
offset=0,
|
|
total=10,
|
|
results=((0, 10), (10, 10))
|
|
)),
|
|
('11_offset_0', dict(
|
|
page_size=10,
|
|
offset=0,
|
|
total=11,
|
|
results=((0, 10), (10, 11))
|
|
)),
|
|
('11_offset_10', dict(
|
|
page_size=10,
|
|
offset=10,
|
|
total=11,
|
|
results=((10, 11),)
|
|
)),
|
|
('19_offset_10', dict(
|
|
page_size=10,
|
|
offset=10,
|
|
total=19,
|
|
results=((10, 19),)
|
|
)),
|
|
('20_offset_10', dict(
|
|
page_size=10,
|
|
offset=10,
|
|
total=20,
|
|
results=((10, 20), (20, 20))
|
|
)),
|
|
('21_offset_10', dict(
|
|
page_size=10,
|
|
offset=10,
|
|
total=21,
|
|
results=((10, 20), (20, 21))
|
|
)),
|
|
('21_offset_0', dict(
|
|
page_size=10,
|
|
offset=0,
|
|
total=21,
|
|
results=((0, 10), (10, 20), (20, 21))
|
|
)),
|
|
('21_offset_20', dict(
|
|
page_size=10,
|
|
offset=20,
|
|
total=21,
|
|
results=((20, 21),)
|
|
)),
|
|
('95_offset_90', dict(
|
|
page_size=10,
|
|
offset=90,
|
|
total=95,
|
|
results=((90, 95),)
|
|
)),
|
|
]
|
|
|
|
# absolute limit for results returned
|
|
limit = 50
|
|
|
|
def mock_manager(self):
|
|
manager = StackManager(None)
|
|
manager._list = MagicMock()
|
|
|
|
def mock_list(arg_url, arg_response_key):
|
|
try:
|
|
result = self.results[self.result_index]
|
|
except IndexError:
|
|
return
|
|
self.result_index = self.result_index + 1
|
|
|
|
offset = result[0]
|
|
url = '/stacks?'
|
|
url += 'limit=%s' % self.page_size
|
|
if offset > 0:
|
|
url += '&marker=abcd1234-%s' % offset
|
|
self.assertEqual(url, arg_url)
|
|
|
|
def results():
|
|
|
|
for i in range(*result):
|
|
stack_name = 'stack_%s' % (i + 1)
|
|
stack_id = 'abcd1234-%s' % (i + 1)
|
|
yield mock_stack(manager, stack_name, stack_id)
|
|
|
|
return list(results())
|
|
|
|
manager._list.side_effect = mock_list
|
|
return manager
|
|
|
|
def test_stack_list_pagination(self):
|
|
manager = self.mock_manager()
|
|
|
|
list_params = {
|
|
'page_size': self.page_size,
|
|
'limit': self.limit
|
|
}
|
|
|
|
if self.offset > 0:
|
|
marker = 'abcd1234-%s' % self.offset
|
|
list_params['marker'] = marker
|
|
|
|
self.result_index = 0
|
|
results = list(manager.list(**list_params))
|
|
|
|
# assert that the list method has been called enough times
|
|
self.assertEqual(len(self.results), self.result_index)
|
|
|
|
last_result = min(self.limit, self.total - self.offset)
|
|
# one or more list calls have been recomposed into a single list
|
|
self.assertEqual(last_result, len(results))
|
|
|
|
if last_result > 0:
|
|
self.assertEqual('stack_%s' % (self.offset + 1),
|
|
results[0].stack_name)
|
|
self.assertEqual('stack_%s' % (self.offset + last_result),
|
|
results[-1].stack_name)
|