stackforge/python-libraclient
Code Issues Proposed changes

Upgrade novaclient version required

Browse Source 
Also removed test, getting almost impossible to keep it working.  Needs to be
re-thought.

Change-Id: I44344c4180f4f27c050abc667e85cd6345e56671
This commit is contained in:
Andrew Hutchings
2013-09-09 12:18:03 +01:00
parent c5c5198462
commit cf7e39953c
2 changed files with 1 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files

365
tests/test_lbaas_client.py
View File

@@ -1,365 +0,0 @@
import json
import mock
import requests
import sys
import novaclient
import testtools
from StringIO import StringIO
from libraclient.libraapi import LibraAPI
class DummyArgs(object):
""" Fake argparse response """
def __init__(self):
self.id = 2000
self.deleted = False
class DummyCreateArgs(object):
""" Fake argparse response for Create function """
def __init__(self):
self.name = 'a-new-loadbalancer'
self.node = ['10.1.1.1:80', '10.1.1.2:81']
self.port = None
self.protocol = None
self.algorithm = None
self.vip = None
class DummyModifyArgs(object):
""" Fake argparse response for Modify function """
def __init__(self):
self.id = 2012
self.name = 'a-modified-loadbalancer'
self.algorithm = 'LEAST_CONNECTIONS'
class TestResponse(requests.Response):
"""
Class used to wrap requests.Response and provide some
convenience to initialize with a dict
"""
def __init__(self, data):
self._text = None
super(TestResponse, self)
if isinstance(data, dict):
self.status_code = data.get('status', None)
self.headers = data.get('headers', None)
# Fake the text attribute to streamline Response creation
self._text = data.get('text', None)
else:
self.status_code = data
def __eq__(self, other):
return self.__dict__ == other.__dict__
@property
def text(self):
return self._text
class MockLibraArgs(object):
def __init__(self, username, password, tenant, auth_url, region):
self.os_username=username
self.os_password=password
self.os_tenant_name=tenant
self.os_auth_url=auth_url
self.os_region_name=region
self.service_type='compute'
self.debug=False
self.insecure=False
self.bypass_url=None
class MockLibraAPI(LibraAPI):
""" Used to capture data that would be sent to the API server """
def __init__(self, username, password, tenant, auth_url, region):
self.postdata = None
self.putdata = None
args=MockLibraArgs(username, password, tenant, auth_url, region)
return super(MockLibraAPI, self).__init__(args)
def _post(self, url, **kwargs):
""" Store the post data and execute as normal """
self.postdata = kwargs['body']
return super(MockLibraAPI, self)._post(url, **kwargs)
def _put(self, url, **kwargs):
""" Store the put data, no need to execute the httplib """
self.putdata = kwargs['body']
class TestLBaaSClientLibraAPI(testtools.TestCase):
def setUp(self):
""" Fake a login with token """
super(TestLBaaSClientLibraAPI, self).setUp()
self.api = MockLibraAPI('username', 'password', 'tenant', 'auth_test', 'region')
self.api.nova.management_url = "auth_url/v1.0"
self.api.nova.auth_token = "token"
def testListLb(self):
""" Test the table generated from the LIST function """
fake_response = TestResponse({"status": 200,
"text": json.dumps({
"loadBalancers":[
{
"name":"lb-site1",
"id":"71",
"protocol":"HTTP",
"port":"80",
"algorithm":"LEAST_CONNECTIONS",
"status":"ACTIVE",
"created":"2010-11-30T03:23:42Z",
"updated":"2010-11-30T03:23:44Z"
},
{
"name":"lb-site2",
"id":"166",
"protocol":"TCP",
"port":"9123",
"algorithm":"ROUND_ROBIN",
"status":"ACTIVE",
"created":"2010-11-30T03:23:42Z",
"updated":"2010-11-30T03:23:44Z"
}
]})
})
mock_request = mock.Mock(return_value=(fake_response))
with mock.patch.object(requests, "request", mock_request):
with mock.patch('time.time', mock.Mock(return_value=1234)):
orig = sys.stdout
try:
out = StringIO()
sys.stdout = out
args = DummyArgs()
self.api.list_lb(args)
output = out.getvalue().strip()
self.assertRegexpMatches(output, 'lb-site1')
self.assertRegexpMatches(output, '71')
self.assertRegexpMatches(output, 'HTTP')
self.assertRegexpMatches(output, '80')
self.assertRegexpMatches(output, 'LEAST_CONNECTIONS')
self.assertRegexpMatches(output, 'ACTIVE')
self.assertRegexpMatches(output, '2010-11-30T03:23:42Z')
self.assertRegexpMatches(output, '2010-11-30T03:23:44Z')
finally:
sys.stdout = orig
def testGetLb(self):
""" Test the table generated from the STATUS function """
fake_response = TestResponse({"status": 200,
"text": json.dumps({
"id": "2000",
"name":"sample-loadbalancer",
"protocol":"HTTP",
"port": "80",
"algorithm":"ROUND_ROBIN",
"status":"ACTIVE",
"created":"2010-11-30T03:23:42Z",
"updated":"2010-11-30T03:23:44Z",
"virtualIps":[
{
"id": "1000",
"address":"2001:cdba:0000:0000:0000:0000:3257:9652",
"type":"PUBLIC",
"ipVersion":"IPV6"
}],
"nodes": [
{
"id": "1041",
"address":"10.1.1.1",
"port": "80",
"condition":"ENABLED",
"status":"ONLINE"
},
{
"id": "1411",
"address":"10.1.1.2",
"port": "80",
"condition":"ENABLED",
"status":"ONLINE"
}],
"sessionPersistence":{
"persistenceType":"HTTP_COOKIE"
},
"connectionThrottle":{
"maxRequestRate": "50",
"rateInterval": "60"
}})
})
mock_request = mock.Mock(return_value=(fake_response))
with mock.patch.object(requests, "request", mock_request):
with mock.patch('time.time', mock.Mock(return_value=1234)):
orig = sys.stdout
try:
out = StringIO()
sys.stdout = out
args = DummyArgs()
self.api.status_lb(args)
output = out.getvalue().strip()
self.assertRegexpMatches(output, 'HTTP_COOKIE')
finally:
sys.stdout = orig
def testDeleteFailLb(self):
"""
Test a failure of a DELETE function. We don't test a succeed yet
since that has no response so nothing to assert on
"""
fake_response = TestResponse({"status": 500, "text": ""})
mock_request = mock.Mock(return_value=(fake_response))
with mock.patch.object(requests, "request", mock_request):
with mock.patch('time.time', mock.Mock(return_value=1234)):
args = DummyArgs()
self.assertRaises(novaclient.exceptions.ClientException,
self.api.delete_lb, args)
def testCreateLb(self):
"""
Tests the CREATE function, tests that:
1. We send the correct POST data
2. We create a table from the response correctly
"""
fake_response = TestResponse({"status": 202,
"text": json.dumps({
'name': 'a-new-loadbalancer',
'id': '144',
'protocol': 'HTTP',
'port': '83',
'algorithm': 'ROUND_ROBIN',
'status': 'BUILD',
'created': '2011-04-13T14:18:07Z',
'updated': '2011-04-13T14:18:07Z',
'virtualIps': [
{
'address': '15.0.0.1',
'id': '39',
'type': 'PUBLIC',
'ipVersion': 'IPV4',
}
],
'nodes': [
{
'address': '10.1.1.1',
'id': '653',
'port': '80',
'status': 'ONLINE',
'condition': 'ENABLED'
}
]
})
})
# This is what the POST data should look like based on the args passed
post_compare = {
"name": "a-new-loadbalancer",
"nodes": [
{
"address": "10.1.1.1",
"port": "80"
},
{
"address": "10.1.1.2",
"port": "81"
}
]
}
mock_request = mock.Mock(return_value=(fake_response))
with mock.patch.object(requests, "request", mock_request):
with mock.patch('time.time', mock.Mock(return_value=1234)):
orig = sys.stdout
try:
out = StringIO()
sys.stdout = out
args = DummyCreateArgs()
self.api.create_lb(args)
self.assertEquals(post_compare, self.api.postdata)
output = out.getvalue().strip()
# At some point we should possibly compare the complete
# table rendering somehow instead of basic field data
self.assertRegexpMatches(output, 'ROUND_ROBIN')
self.assertRegexpMatches(output, 'BUILD')
self.assertRegexpMatches(output, '144')
finally:
sys.stdout = orig
def testCreateAddLb(self):
"""
Tests the CREATE function as above but adding a load balancer to a
virtual IP
"""
fake_response = TestResponse({"status": 202,
"text": json.dumps({
'name': 'a-new-loadbalancer',
'id': '144',
'protocol': 'HTTP',
'port': '83',
'algorithm': 'ROUND_ROBIN',
'status': 'BUILD',
'created': '2011-04-13T14:18:07Z',
'updated': '2011-04-13T14:18:07Z',
'virtualIps': [
{
'address': '15.0.0.1',
'id': '39',
'type': 'PUBLIC',
'ipVersion': 'IPV4',
}
],
'nodes': [
{
'address': '10.1.1.1',
'id': '653',
'port': '80',
'status': 'ONLINE',
}
]
})
})
# This is what the POST data should look like based on the args passed
post_compare = {
"name": "a-new-loadbalancer",
"port": "83",
"protocol": "HTTP",
"virtualIps": [
{
"id": "39"
}
],
"nodes": [
{
"address": "10.1.1.1",
"port": "80"
}
]
}
mock_request = mock.Mock(return_value=(fake_response))
with mock.patch.object(requests, "request", mock_request):
with mock.patch('time.time', mock.Mock(return_value=1234)):
orig = sys.stdout
try:
out = StringIO()
sys.stdout = out
# Add args to add a LB to a VIP
args = DummyCreateArgs()
args.port = '83'
args.protocol = 'HTTP'
args.vip = '39'
args.node = ['10.1.1.1:80']
self.api.create_lb(args)
self.assertEquals(post_compare, self.api.postdata)
output = out.getvalue().strip()
# At some point we should possibly compare the complete
# table rendering somehow instead of basic field data
self.assertRegexpMatches(output, 'ROUND_ROBIN')
self.assertRegexpMatches(output, 'BUILD')
self.assertRegexpMatches(output, '144')
finally:
sys.stdout = orig
def testModifyLb(self):
"""
Tests the MODIFY function, no repsonse so we only test the PUT data
"""
# This is what the PUT data should look like based on the args passed
put_compare = {
"name": "a-modified-loadbalancer",
"algorithm": "LEAST_CONNECTIONS"
}
args = DummyModifyArgs()
self.api.modify_lb(args)
self.assertEquals(put_compare, self.api.putdata)

2
tools/pip-requires
View File

@@ -1 +1 @@
python_novaclient<2.14.0 python_novaclient>=2.14.1,<2.14.2