rally/tests/test_fuelclient.py
Sergey Skripnick a5cb98745e Add FuelClient
Client for access to Fuel API.

blueprint fuel-engine

Change-Id: If1572357b58e66cff84a5d2256f7b4d3bff2f0e4
2014-01-24 14:38:26 +02:00

338 lines
12 KiB
Python

# Copyright 2013: 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 rally import fuelclient
from tests import test
import copy
import mock
class FuelNodeTestCase(test.TestCase):
def test_check(self):
node = {
"cluster": None,
"mac": "00:01:02:0a:0b:0c",
"meta": {
"memory": {"total": 42},
"cpu": {"total": 2},
"disks": [{"size": 22}, {"size": 33}] # total 55
},
}
n = fuelclient.FuelNode(node)
self.assertFalse(n.check('ram==41'))
self.assertFalse(n.check('ram!=42'))
self.assertFalse(n.check('ram<=41'))
self.assertFalse(n.check('ram>=43'))
self.assertFalse(n.check('ram>43'))
self.assertFalse(n.check('ram<41'))
self.assertFalse(n.check('cpus>3'))
self.assertTrue(n.check('ram==42'))
self.assertTrue(n.check('ram!=41'))
self.assertTrue(n.check('ram<=43'))
self.assertTrue(n.check('ram<=42'))
self.assertTrue(n.check('ram>=41'))
self.assertTrue(n.check('ram>=42'))
self.assertTrue(n.check('ram<43'))
self.assertTrue(n.check('ram>41'))
self.assertTrue(n.check('cpus==2'))
self.assertTrue(n.check('mac==00:01:02:0a:0b:0c'))
self.assertTrue(n.check('mac!=00:01:02:0a:0b:0e'))
self.assertTrue(n.check('storage==55'))
self.assertTrue(n.check('storage<=1G'))
self.assertTrue(n.check('storage<1M'))
class FuelNodesCollectionTestCase(test.TestCase):
def test_pop(self):
node = {
"cluster": None,
"mac": "00:01:02:0a:0b:0c",
"meta": {
"memory": {"total": 42},
"cpu": {"total": 2},
"disks": [{"size": 22}, {"size": 33}] # total 55
},
}
nodes = [copy.deepcopy(node) for i in range(4)]
nodes[0]['meta']['cpu']['total'] = 1
nodes[1]['meta']['cpu']['total'] = 2
nodes[2]['meta']['memory']['total'] = 16
nodes[3]['cluster'] = 42 # node with cluster is occupied
nodes = fuelclient.FuelNodesCollection(nodes)
node_1cpu = nodes.pop(['cpus==1'])
self.assertEqual(node_1cpu._get_cpus(), 1)
self.assertEqual(len(nodes.nodes), 3)
node_2cpu = nodes.pop(['cpus==2'])
self.assertEqual(node_2cpu._get_cpus(), 2)
self.assertEqual(len(nodes.nodes), 2)
node_16ram_2cpu = nodes.pop(['ram>=16', 'cpus==2'])
self.assertEqual(node_16ram_2cpu._get_ram(), 16)
self.assertEqual(node_16ram_2cpu._get_cpus(), 2)
self.assertEqual(len(nodes.nodes), 1)
node_none = nodes.pop(['storage>4T'])
self.assertIsNone(node_none)
class FuelClusterTestCase(test.TestCase):
def setUp(self):
super(FuelClusterTestCase, self).setUp()
self.client = mock.Mock()
self.config = {'name': 'Cluster'}
self.cluster = fuelclient.FuelCluster(self.client, **self.config)
def test_init(self):
self.client.post.assert_called_once_with('clusters', self.config)
def test_get_nodes(self):
self.cluster.cluster = {'id': 42}
self.cluster.get_nodes()
self.client.get.assert_called_once_with('nodes?cluster_id=42')
def test_set_nodes_empty(self):
self.assertIsNone(self.cluster.set_nodes([], []))
def test_set_nodes(self):
nodes = [{'id': 42}, {'id': 43}]
self.cluster.cluster = {'id': 1}
self.cluster.set_nodes(nodes, ['role1', 'role2'])
node42_args = {'cluster_id': 1,
'pending_roles': ['role1', 'role2'],
'pending_addition': True,
'id': 42}
node43_args = {'cluster_id': 1,
'pending_roles': ['role1', 'role2'],
'pending_addition': True,
'id': 43}
expected = [
mock.call.post('clusters', {'name': 'Cluster'}),
mock.call.put('nodes', [node42_args, node43_args])
]
self.assertEqual(expected, self.client.mock_calls)
def test_configure_network(self):
current_network = {'networks': [{'name': 'public',
'key': 'old_val',
'key2': 'val2'}]}
netconfig = {'public': {'key': 'new_val'}}
self.cluster.get_network = mock.Mock(return_value=current_network)
self.cluster.set_network = mock.Mock()
self.cluster.configure_network(netconfig)
self.cluster.set_network.assert_called_once_with(
{'networks': [{'name': 'public',
'key': 'new_val',
'key2': 'val2'}]})
@mock.patch('rally.fuelclient.time.sleep')
def test_deploy(self, m_sleep):
call1 = {'progress': 50}
call2 = {'progress': 100}
self.client.get_task.side_effect = [call1, call2]
tasks = [{'name': 'deploy', 'id': 41}]
self.client.get_tasks.return_value = tasks
self.cluster.cluster = {'id': 42}
self.cluster.deploy()
expected = [
mock.call.post('clusters', {'name': 'Cluster'}),
mock.call.put('clusters/42/changes', {}),
mock.call.get_tasks(42),
mock.call.get_task(41),
mock.call.get_task(41)
]
self.assertEqual(expected, self.client.mock_calls)
def test_get_network(self):
self.cluster.cluster = {'id': 42, 'net_provider': 'nova_network'}
self.cluster.get_network()
self.client.get.assert_called_once_with(
'clusters/42/network_configuration/nova_network')
def test_set_network(self):
self.cluster.cluster = {'id': 42, 'net_provider': 'nova_network'}
self.cluster.verify_network = mock.Mock()
self.cluster.set_network({'key': 'val'})
self.client.put.assert_called_once_with(
'clusters/42/network_configuration/nova_network', {'key': 'val'})
self.cluster.verify_network.assert_called_once_with({'key': 'val'})
@mock.patch('rally.fuelclient.time.sleep')
def test_verify_network(self, m_sleep):
call1 = {'progress': 50}
call2 = {'progress': 100, 'message': ''}
self.client.put.return_value = {'id': 42}
self.client.get_task.side_effect = [call1, call2]
self.cluster.cluster = {'id': 43, 'net_provider': 'nova_network'}
self.cluster.verify_network({'key': 'val'})
self.client.put.assert_called_once_with(
'clusters/43/network_configuration/nova_network/verify',
{'key': 'val'})
self.assertEqual([mock.call(42), mock.call(42)],
self.client.get_task.mock_calls)
@mock.patch('rally.fuelclient.time.sleep')
def test_verify_network_fail(self, m_sleep):
self.client.put.return_value = {'id': 42}
self.client.get_task.return_value = {'progress': 100,
'message': 'error'}
self.cluster.cluster = {'id': 43, 'net_provider': 'nova_network'}
self.assertRaises(fuelclient.FuelNetworkVerificationFailed,
self.cluster.verify_network, {'key': 'val'})
def test_get_attributes(self):
self.cluster.cluster = {'id': 52}
self.cluster.get_attributes()
self.client.get.assert_called_once_with('clusters/52/attributes')
def test_get_endpoint_ip_multinode(self):
self.cluster.cluster = {'mode': 'multinode'}
node1 = {'roles': ['compute', 'cinder']}
node2 = {'roles': ['controller'],
'network_data': [{'name': 'private'},
{'name': 'public', 'ip': '42.42.42.42/24'}]}
fake_nodes = [node1, node2]
self.cluster.get_nodes = mock.Mock(return_value=fake_nodes)
ip = self.cluster.get_endpoint_ip()
self.assertEqual('42.42.42.42', ip)
def test_get_endpoint_ip_ha(self):
ip = '1.2.3.4'
self.cluster.cluster = {'id': 42, 'mode': 'ha_compact'}
self.cluster.get_network = mock.Mock(return_value={'public_vip': ip})
self.assertEqual(ip, self.cluster.get_endpoint_ip())
class FuelClientTestCase(test.TestCase):
def setUp(self):
super(FuelClientTestCase, self).setUp()
self.client = fuelclient.FuelClient('http://10.20.0.2:8000/api/v1/')
@mock.patch('rally.fuelclient.requests')
def test__request_non_json(self, fake_req):
reply = mock.Mock()
reply.status_code = 200
reply.headers = {'content-type': 'application/x-httpd-php'}
reply.text = '{"reply": "ok"}'
fake_req.method = mock.Mock(return_value=reply)
retval = self.client._request('method', 'url', data={'key': 'value'})
self.assertEqual(retval, reply)
@mock.patch('rally.fuelclient.requests')
def test__request_non_2xx(self, fake_req):
reply = mock.Mock()
reply.status_code = 300
reply.headers = {'content-type': 'application/json'}
reply.text = '{"reply": "ok"}'
fake_req.method = mock.Mock(return_value=reply)
self.assertRaises(fuelclient.FuelClientException,
self.client._request, 'method', 'url',
data={'key': 'value'})
@mock.patch('rally.fuelclient.requests')
def test__request(self, fake_req):
reply = mock.Mock()
reply.status_code = 202
reply.headers = {'content-type': 'application/json'}
reply.text = '{"reply": "ok"}'
fake_req.method = mock.Mock(return_value=reply)
retval = self.client._request('method', 'url', data={'key': 'value'})
fake_req.method.assert_called_once_with(
'http://10.20.0.2:8000/api/v1/url',
headers={'content-type': 'application/json'},
data='{"key": "value"}')
self.assertEqual(retval, {'reply': 'ok'})
@mock.patch.object(fuelclient.FuelClient, '_request')
def test_get(self, m_request):
self.client.get('url')
m_request.assert_called_once_with('get', 'url')
@mock.patch.object(fuelclient.FuelClient, '_request')
def test_delete(self, m_request):
self.client.delete('url')
m_request.assert_called_once_with('delete', 'url')
@mock.patch.object(fuelclient.FuelClient, '_request')
def test_post(self, m_request):
self.client.post('url', {'key': 'val'})
m_request.assert_called_once_with('post', 'url', {'key': 'val'})
@mock.patch.object(fuelclient.FuelClient, '_request')
def test_put(self, m_request):
self.client.put('url', {'key': 'val'})
m_request.assert_called_once_with('put', 'url', {'key': 'val'})
@mock.patch.object(fuelclient.FuelClient, 'get')
def test_get_releases(self, m_get):
self.client.get_releases()
m_get.assert_called_once_with('releases')
@mock.patch.object(fuelclient.FuelClient, 'get')
def test_get_task(self, m_get):
self.client.get_task(42)
m_get.assert_called_once_with('tasks/42')
@mock.patch.object(fuelclient.FuelClient, 'get')
def test_get_tasks(self, m_get):
self.client.get_tasks(42)
m_get.assert_called_once_with('tasks?cluster_id=42')
@mock.patch.object(fuelclient.FuelClient, 'get')
def test_get_node(self, m_get):
self.client.get_node(42)
m_get.assert_called_once_with('nodes/42')
@mock.patch.object(fuelclient, 'FuelNodesCollection')
@mock.patch.object(fuelclient.FuelClient, 'get')
def test_get_nodes(self, m_get, m_collection):
m_get.return_value = 'fake_nodes'
m_collection.return_value = 'fake_collection'
retval = self.client.get_nodes()
self.assertEqual('fake_collection', retval)
m_collection.assert_called_once_with('fake_nodes')
m_get.assert_called_once_with('nodes')
@mock.patch.object(fuelclient.FuelClient, 'delete')
def test_delete_cluster(self, m_delete):
self.client.delete_cluster(42)
m_delete.assert_called_once_with('clusters/42')