60c25a50be
Partially Implements: bp node-aggregate Change-Id: I733f5158997cd0764048471b5cae5c97fe40c4dc
294 lines
10 KiB
Python
294 lines
10 KiB
Python
# Copyright 2017 Huawei, Inc. All rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
|
|
import mock
|
|
|
|
from osc_lib import utils
|
|
|
|
from moganclient.common import base
|
|
from moganclient.osc.v1 import aggregate
|
|
from moganclient.tests.unit import base as test_base
|
|
from moganclient.tests.unit import fakes
|
|
from moganclient.v1 import aggregate as aggregate_mgr
|
|
|
|
|
|
class TestAggregateBase(test_base.TestBaremetalComputeV1):
|
|
def setUp(self):
|
|
super(TestAggregateBase, self).setUp()
|
|
self.fake_agg = fakes.FakeAggregate.create_one_aggregate()
|
|
|
|
self.columns = (
|
|
'created_at',
|
|
'links',
|
|
'name',
|
|
'properties',
|
|
'updated_at',
|
|
'uuid',
|
|
)
|
|
|
|
self.data = (
|
|
self.fake_agg.created_at,
|
|
self.fake_agg.links,
|
|
self.fake_agg.name,
|
|
utils.format_dict(self.fake_agg.metadata),
|
|
self.fake_agg.updated_at,
|
|
self.fake_agg.uuid,
|
|
)
|
|
|
|
|
|
@mock.patch.object(aggregate_mgr.AggregateManager, '_create')
|
|
class TestAggregateCreate(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateCreate, self).setUp()
|
|
self.cmd = aggregate.CreateAggregate(self.app, None)
|
|
|
|
def test_aggregate_create(self, mock_create):
|
|
arglist = [
|
|
'test_agg',
|
|
'--property', 'k1=v1'
|
|
]
|
|
verifylist = [
|
|
('name', 'test_agg'),
|
|
('property', {'k1': 'v1'}),
|
|
]
|
|
mock_create.return_value = self.fake_agg
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
mock_create.assert_called_once_with('/aggregates',
|
|
data={
|
|
'name': 'test_agg',
|
|
'metadata': {'k1': 'v1'},
|
|
})
|
|
self.assertEqual(self.columns, columns)
|
|
self.assertEqual(self.data, data)
|
|
|
|
|
|
@mock.patch.object(utils, 'find_resource')
|
|
@mock.patch.object(aggregate_mgr.AggregateManager, '_delete')
|
|
class TestAggregateDelete(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateDelete, self).setUp()
|
|
self.cmd = aggregate.DeleteAggregate(self.app, None)
|
|
|
|
def test_aggregate_delete(self, mock_delete, mock_find):
|
|
arglist = [
|
|
'test_agg1',
|
|
]
|
|
verifylist = [
|
|
('aggregate', ['test_agg1']),
|
|
]
|
|
mock_find.return_value = self.fake_agg
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
result = self.cmd.take_action(parsed_args)
|
|
expected_url = '/aggregates/%s' % base.getid(self.fake_agg)
|
|
mock_delete.assert_called_once_with(expected_url)
|
|
self.assertIsNone(result)
|
|
|
|
def test_aggregate_multiple_delete(self, mock_delete, mock_find):
|
|
arglist = [
|
|
'agg1',
|
|
'agg2',
|
|
'agg3'
|
|
]
|
|
verifylist = [
|
|
('aggregate', ['agg1', 'agg2', 'agg3']),
|
|
]
|
|
mock_find.return_value = self.fake_agg
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
result = self.cmd.take_action(parsed_args)
|
|
expected_url = '/aggregates/%s' % base.getid(self.fake_agg)
|
|
expected_call = [mock.call(expected_url), mock.call(expected_url),
|
|
mock.call(expected_url)]
|
|
mock_delete.assert_has_calls(expected_call)
|
|
self.assertIsNone(result)
|
|
|
|
|
|
@mock.patch.object(aggregate_mgr.AggregateManager, '_list')
|
|
class TestAggregateList(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateList, self).setUp()
|
|
self.list_columns = (
|
|
"UUID",
|
|
"Name",
|
|
"Properties"
|
|
)
|
|
|
|
self.list_data = (
|
|
(self.fake_agg.uuid,
|
|
self.fake_agg.name,
|
|
utils.format_dict(self.fake_agg.metadata),
|
|
),)
|
|
|
|
self.cmd = aggregate.ListAggregate(self.app, None)
|
|
|
|
def test_aggregate_list(self, mock_list):
|
|
arglist = []
|
|
verifylist = []
|
|
mock_list.return_value = [self.fake_agg]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
mock_list.assert_called_once_with('/aggregates',
|
|
response_key='aggregates')
|
|
self.assertEqual(self.list_columns, columns)
|
|
self.assertEqual(self.list_data, tuple(data))
|
|
|
|
|
|
@mock.patch.object(aggregate_mgr.AggregateManager, '_get')
|
|
class TestAggregateShow(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateShow, self).setUp()
|
|
self.cmd = aggregate.ShowAggregate(self.app, None)
|
|
|
|
def test_agregate_show(self, mock_get):
|
|
arglist = [
|
|
'agg1',
|
|
]
|
|
verifylist = [
|
|
('aggregate', 'agg1'),
|
|
]
|
|
mock_get.return_value = self.fake_agg
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
expected_url = '/aggregates/%s' % parsed_args.aggregate
|
|
mock_get.assert_called_once_with(expected_url)
|
|
self.assertEqual(self.columns, columns)
|
|
self.assertEqual(self.data, data)
|
|
|
|
|
|
@mock.patch.object(utils, 'find_resource')
|
|
@mock.patch.object(aggregate_mgr.AggregateManager, '_update')
|
|
class TestAggregateSet(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateSet, self).setUp()
|
|
self.cmd = aggregate.SetAggregate(self.app, None)
|
|
|
|
def test_aggregate_update(self, mock_update, mock_find):
|
|
mock_find.return_value = self.fake_agg
|
|
arglist = [
|
|
'--name', 'test_agg',
|
|
'--property', 'k1=v1',
|
|
self.fake_agg.uuid,
|
|
]
|
|
verifylist = [
|
|
('aggregate', self.fake_agg.uuid),
|
|
('name', 'test_agg'),
|
|
('property', {'k1': 'v1'}),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
self.cmd.take_action(parsed_args)
|
|
expected_url = '/aggregates/%s' % base.getid(self.fake_agg)
|
|
expected_args = [
|
|
{'path': '/name', 'value': 'test_agg', 'op': 'replace'},
|
|
{'path': '/metadata/k1', 'value': 'v1', 'op': 'add'},
|
|
]
|
|
mock_update.assert_called_once_with(expected_url,
|
|
data=expected_args)
|
|
|
|
|
|
@mock.patch.object(utils, 'find_resource')
|
|
@mock.patch.object(aggregate_mgr.AggregateManager, '_update')
|
|
class TestAggregateUnset(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateUnset, self).setUp()
|
|
self.cmd = aggregate.UnsetAggregate(self.app, None)
|
|
|
|
def test_aggregate_update(self, mock_update, mock_find):
|
|
mock_find.return_value = self.fake_agg
|
|
arglist = [
|
|
'--property', 'key1',
|
|
self.fake_agg.uuid,
|
|
]
|
|
verifylist = [
|
|
('aggregate', self.fake_agg.uuid),
|
|
('property', ['key1']),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
self.cmd.take_action(parsed_args)
|
|
expected_url = '/aggregates/%s' % base.getid(self.fake_agg)
|
|
expected_args = [
|
|
{'path': '/metadata/key1', 'op': 'remove'}
|
|
]
|
|
mock_update.assert_called_once_with(expected_url,
|
|
data=expected_args)
|
|
|
|
|
|
@mock.patch.object(utils, 'find_resource')
|
|
@mock.patch.object(aggregate_mgr.AggregateNodeManager, '_list')
|
|
class TestAggregateListNode(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateListNode, self).setUp()
|
|
self.cmd = aggregate.AggregateListNode(self.app, None)
|
|
self.fake_nodes = ("node-1", "node-1", "node-1")
|
|
|
|
def test_agg_node_list(self, mock_list, mock_find):
|
|
mock_find.return_value = self.fake_agg
|
|
arglist = [
|
|
self.fake_agg.uuid,
|
|
]
|
|
verifylist = [
|
|
('aggregate', self.fake_agg.uuid),
|
|
]
|
|
mock_list.return_value = [self.fake_nodes]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
url = '/aggregates/%s/nodes' % self.fake_agg.uuid
|
|
mock_list.assert_called_once_with(url, response_key='nodes')
|
|
self.assertEqual(('Node',), columns)
|
|
self.assertEqual(((("node-1", "node-1", "node-1"),),), data)
|
|
|
|
|
|
@mock.patch.object(utils, 'find_resource')
|
|
@mock.patch.object(aggregate_mgr.AggregateNodeManager, '_create')
|
|
class TestAggregateAddNode(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateAddNode, self).setUp()
|
|
self.cmd = aggregate.AggregateAddNode(self.app, None)
|
|
|
|
def test_agg_node_add(self, mock_create, mock_find):
|
|
mock_find.return_value = self.fake_agg
|
|
arglist = [
|
|
self.fake_agg.uuid, 'node-1',
|
|
]
|
|
verifylist = [
|
|
('aggregate', self.fake_agg.uuid),
|
|
('node', 'node-1'),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
self.cmd.take_action(parsed_args)
|
|
url = '/aggregates/%s/nodes' % self.fake_agg.uuid
|
|
mock_create.assert_called_once_with(url, data={'node': 'node-1'})
|
|
|
|
|
|
@mock.patch.object(utils, 'find_resource')
|
|
@mock.patch.object(aggregate_mgr.AggregateNodeManager, '_delete')
|
|
class TestAggregateRemoveNode(TestAggregateBase):
|
|
def setUp(self):
|
|
super(TestAggregateRemoveNode, self).setUp()
|
|
self.cmd = aggregate.AggregateRemoveNode(self.app, None)
|
|
|
|
def test_agg_node_remove(self, mock_delete, mock_find):
|
|
mock_find.return_value = self.fake_agg
|
|
arglist = [
|
|
self.fake_agg.uuid, 'node-1',
|
|
]
|
|
verifylist = [
|
|
('aggregate', self.fake_agg.uuid),
|
|
('node', 'node-1'),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
self.cmd.take_action(parsed_args)
|
|
url = '/aggregates/%s/nodes/node-1' % self.fake_agg.uuid
|
|
mock_delete.assert_called_once_with(url)
|