217 lines
7.1 KiB
Python
217 lines
7.1 KiB
Python
# Copyright 2013 OpenStack Foundation
|
|
#
|
|
# 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 logging
|
|
|
|
import httpretty
|
|
import six
|
|
from testtools import matchers
|
|
|
|
from keystoneclient import exceptions
|
|
from keystoneclient import httpclient
|
|
from keystoneclient import session
|
|
from keystoneclient.tests import utils
|
|
|
|
|
|
RESPONSE_BODY = '{"hi": "there"}'
|
|
|
|
|
|
def get_client():
|
|
cl = httpclient.HTTPClient(username="username", password="password",
|
|
tenant_id="tenant", auth_url="auth_test")
|
|
return cl
|
|
|
|
|
|
def get_authed_client():
|
|
cl = get_client()
|
|
cl.management_url = "http://127.0.0.1:5000"
|
|
cl.auth_token = "token"
|
|
return cl
|
|
|
|
|
|
class FakeLog(object):
|
|
def __init__(self):
|
|
self.warn_log = str()
|
|
self.debug_log = str()
|
|
|
|
def warn(self, msg=None, *args, **kwargs):
|
|
self.warn_log = "%s\n%s" % (self.warn_log, (msg % args))
|
|
|
|
def debug(self, msg=None, *args, **kwargs):
|
|
self.debug_log = "%s\n%s" % (self.debug_log, (msg % args))
|
|
|
|
|
|
class ClientTest(utils.TestCase):
|
|
|
|
TEST_URL = 'http://127.0.0.1:5000/hi'
|
|
|
|
def test_unauthorized_client_requests(self):
|
|
cl = get_client()
|
|
self.assertRaises(exceptions.AuthorizationFailure, cl.get, '/hi')
|
|
self.assertRaises(exceptions.AuthorizationFailure, cl.post, '/hi')
|
|
self.assertRaises(exceptions.AuthorizationFailure, cl.put, '/hi')
|
|
self.assertRaises(exceptions.AuthorizationFailure, cl.delete, '/hi')
|
|
|
|
@httpretty.activate
|
|
def test_get(self):
|
|
cl = get_authed_client()
|
|
|
|
self.stub_url(httpretty.GET, body=RESPONSE_BODY)
|
|
|
|
resp, body = cl.get("/hi")
|
|
self.assertEqual(httpretty.last_request().method, 'GET')
|
|
self.assertEqual(httpretty.last_request().path, '/hi')
|
|
|
|
self.assertRequestHeaderEqual('X-Auth-Token', 'token')
|
|
self.assertRequestHeaderEqual('User-Agent', httpclient.USER_AGENT)
|
|
|
|
# Automatic JSON parsing
|
|
self.assertEqual(body, {"hi": "there"})
|
|
|
|
@httpretty.activate
|
|
def test_get_error_with_plaintext_resp(self):
|
|
cl = get_authed_client()
|
|
self.stub_url(httpretty.GET, status=400,
|
|
body='Some evil plaintext string')
|
|
|
|
self.assertRaises(exceptions.BadRequest, cl.get, '/hi')
|
|
|
|
@httpretty.activate
|
|
def test_get_error_with_json_resp(self):
|
|
cl = get_authed_client()
|
|
err_response = {
|
|
"error": {
|
|
"code": 400,
|
|
"title": "Error title",
|
|
"message": "Error message string"
|
|
}
|
|
}
|
|
self.stub_url(httpretty.GET, status=400, json=err_response)
|
|
exc_raised = False
|
|
try:
|
|
cl.get('/hi')
|
|
except exceptions.BadRequest as exc:
|
|
exc_raised = True
|
|
self.assertEqual(exc.message, "Error message string")
|
|
self.assertTrue(exc_raised, 'Exception not raised.')
|
|
|
|
@httpretty.activate
|
|
def test_post(self):
|
|
cl = get_authed_client()
|
|
|
|
self.stub_url(httpretty.POST)
|
|
cl.post("/hi", body=[1, 2, 3])
|
|
|
|
self.assertEqual(httpretty.last_request().method, 'POST')
|
|
self.assertEqual(httpretty.last_request().body, '[1, 2, 3]')
|
|
|
|
self.assertRequestHeaderEqual('X-Auth-Token', 'token')
|
|
self.assertRequestHeaderEqual('Content-Type', 'application/json')
|
|
self.assertRequestHeaderEqual('User-Agent', httpclient.USER_AGENT)
|
|
|
|
@httpretty.activate
|
|
def test_forwarded_for(self):
|
|
ORIGINAL_IP = "10.100.100.1"
|
|
cl = httpclient.HTTPClient(username="username", password="password",
|
|
tenant_id="tenant", auth_url="auth_test",
|
|
original_ip=ORIGINAL_IP)
|
|
|
|
self.stub_url(httpretty.GET)
|
|
|
|
cl.request(self.TEST_URL, 'GET')
|
|
forwarded = "for=%s;by=%s" % (ORIGINAL_IP, httpclient.USER_AGENT)
|
|
self.assertRequestHeaderEqual('Forwarded', forwarded)
|
|
|
|
def test_client_deprecated(self):
|
|
# Can resolve symbols from the keystoneclient.client module.
|
|
# keystoneclient.client was deprecated and renamed to
|
|
# keystoneclient.httpclient. This tests that keystoneclient.client
|
|
# can still be used.
|
|
|
|
from keystoneclient import client
|
|
|
|
# These statements will raise an AttributeError if the symbol isn't
|
|
# defined in the module.
|
|
|
|
client.HTTPClient
|
|
|
|
|
|
class BasicRequestTests(utils.TestCase):
|
|
|
|
url = 'http://keystone.test.com/'
|
|
|
|
def setUp(self):
|
|
super(BasicRequestTests, self).setUp()
|
|
self.logger_message = six.moves.cStringIO()
|
|
handler = logging.StreamHandler(self.logger_message)
|
|
handler.setLevel(logging.DEBUG)
|
|
|
|
self.logger = logging.getLogger(session.__name__)
|
|
level = self.logger.getEffectiveLevel()
|
|
self.logger.setLevel(logging.DEBUG)
|
|
self.logger.addHandler(handler)
|
|
|
|
self.addCleanup(self.logger.removeHandler, handler)
|
|
self.addCleanup(self.logger.setLevel, level)
|
|
|
|
def request(self, method='GET', response='Test Response', status=200,
|
|
url=None, **kwargs):
|
|
if not url:
|
|
url = self.url
|
|
|
|
httpretty.register_uri(method, url, body=response, status=status)
|
|
|
|
return httpclient.request(url, method, **kwargs)
|
|
|
|
@httpretty.activate
|
|
def test_basic_params(self):
|
|
method = 'GET'
|
|
response = 'Test Response'
|
|
status = 200
|
|
|
|
self.request(method=method, status=status, response=response)
|
|
|
|
self.assertEqual(httpretty.last_request().method, method)
|
|
|
|
logger_message = self.logger_message.getvalue()
|
|
|
|
self.assertThat(logger_message, matchers.Contains('curl'))
|
|
self.assertThat(logger_message, matchers.Contains('-X %s' %
|
|
method))
|
|
self.assertThat(logger_message, matchers.Contains(self.url))
|
|
|
|
self.assertThat(logger_message, matchers.Contains(str(status)))
|
|
self.assertThat(logger_message, matchers.Contains(response))
|
|
|
|
@httpretty.activate
|
|
def test_headers(self):
|
|
headers = {'key': 'val', 'test': 'other'}
|
|
|
|
self.request(headers=headers)
|
|
|
|
for k, v in six.iteritems(headers):
|
|
self.assertRequestHeaderEqual(k, v)
|
|
|
|
for header in six.iteritems(headers):
|
|
self.assertThat(self.logger_message.getvalue(),
|
|
matchers.Contains('-H "%s: %s"' % header))
|
|
|
|
@httpretty.activate
|
|
def test_body(self):
|
|
data = "BODY DATA"
|
|
self.request(response=data)
|
|
logger_message = self.logger_message.getvalue()
|
|
self.assertThat(logger_message, matchers.Contains('BODY:'))
|
|
self.assertThat(logger_message, matchers.Contains(data))
|