def test_bad_ca_cert(self):
with open(os.path.join(self.temp_ent_dir, "foo.pem"), 'w+') as cert:
cert.write('xxxxxx\n')
with open(os.path.join(self.temp_ent_dir, "foo-key.pem"), 'w+') as key:
key.write('xxxxxx\n')
with self.assertRaises(NoValidEntitlement):
cont_conn = ContentConnection(host="foobar", username="******", password="******", insecure=True, cert_dir=self.temp_ent_dir)
cont_conn.get_versions('/')
restlib = Restlib("somehost", "123", "somehandler")
restlib.ca_dir = self.temp_ent_dir
with self.assertRaises(BadCertificateException):
restlib._load_ca_certificates(ssl.SSLContext(ssl.PROTOCOL_SSLv23))
def test_bad_ca_cert(self):
f = open(os.path.join(self.temp_ent_dir, "foo.pem"), 'w+')
f.write('xxxxxx\n')
f.close()
cont_conn = ContentConnection(host="foobar", username="******", password="******", insecure=True)
cont_conn.ent_dir = self.temp_ent_dir
with self.assertRaises(BadCertificateException):
cont_conn._load_ca_certificates(ssl.SSLContext(ssl.PROTOCOL_SSLv23))
restlib = Restlib("somehost", "123", "somehandler")
restlib.ca_dir = self.temp_ent_dir
with self.assertRaises(BadCertificateException):
restlib._load_ca_certificates(ssl.SSLContext(ssl.PROTOCOL_SSLv23))
def test_bad_ca_cert(self):
f = open(os.path.join(self.temp_ent_dir, "foo.pem"), 'w+')
f.write('xxxxxx\n')
f.close()
cont_conn = ContentConnection(host="foobar", username="******", password="******", insecure=True)
cont_conn.ent_dir = self.temp_ent_dir
with self.assertRaises(BadCertificateException) as e:
cont_conn._load_ca_certificates(ssl.SSLContext(ssl.PROTOCOL_SSLv23))
restlib = Restlib("somehost", "123", "somehandler")
restlib.ca_dir = self.temp_ent_dir
with self.assertRaises(BadCertificateException) as e:
restlib._load_ca_certificates(ssl.SSLContext(ssl.PROTOCOL_SSLv23))
class RestlibValidateResponseTests(unittest.TestCase):
def setUp(self):
self.restlib = Restlib("somehost", "123", "somehandler")
self.request_type = "GET"
self.handler = "https://server/path"
def vr(self, status, content):
response = {'status': status,
'content': content}
#print "response", response
self.restlib.validateResponse(response, self.request_type, self.handler)
# All empty responses that aren't 200/204 raise a NetworkException
def test_200_empty(self):
# this should just not raise any exceptions
self.vr("200", "")
def test_200_json(self):
# no exceptions
content = u'{"something": "whatever"}'
self.vr("200", content)
# 202 ACCEPTED
def test_202_empty(self):
self.assertRaises(NetworkException, self.vr, "202", "")
def test_202_none(self):
self.assertRaises(NetworkException, self.vr, "202", None)
def test_202_json(self):
content = u'{"something": "whatever"}'
try:
self.vr("202", content)
except RestlibException, e:
self.assertEquals("202", e.code)
# self.assertEquals(self.request_type, e.request_type)
# self.assertEquals(self.handler, e.handler)
self.assertTrue(e.msg is "")
else:
def test_json_uft8_encoding(self):
# A unicode string containing JSON
test_json = u"""
{
"firstName": "John",
"message": "こんにちは世界",
"address": { "street": "21 2nd Street" },
"phoneNumbers": [
[
{ "type": "home", "number": "212 555-1234" },
{ "type": "fax", "number": "646 555-4567" }
]
]
}
"""
restlib = Restlib("somehost", "123", "somehandler")
data = json.loads(test_json, object_hook=restlib._decode_dict)
self.assertTrue(isinstance(data["message"], str))
# Access a value deep in the structure to make sure we recursed down.
self.assertTrue(isinstance(data["phoneNumbers"][0][0]["type"], str))
def setUp(self):
self.restlib = Restlib("somehost", "123", "somehandler")
self.request_type = "GET"
self.handler = "https://server/path"
class RestlibValidateResponseTests(unittest.TestCase):
def setUp(self):
self.restlib = Restlib("somehost", "123", "somehandler")
self.request_type = "GET"
self.handler = "https://server/path"
def vr(self, status, content, headers=None):
response = {'status': status, 'content': content}
if headers:
response['headers'] = headers
self.restlib.validateResponse(response, self.request_type,
self.handler)
# All empty responses that aren't 200/204 raise a NetworkException
def test_200_empty(self):
# this should just not raise any exceptions
self.vr("200", "")
def test_200_json(self):
# no exceptions
content = u'{"something": "whatever"}'
self.vr("200", content)
# 202 ACCEPTED
def test_202_empty(self):
self.vr("202", "")
def test_202_none(self):
self.vr("202", None)
def test_202_json(self):
content = u'{"something": "whatever"}'
self.vr("202", content)
# 204 NO CONTENT
# no exceptions is okay
def test_204_empty(self):
self.vr("204", "")
# no exceptions is okay
def test_204_none(self):
self.vr("204", None)
# MOVED PERMANENTLY
# FIXME: implement 301 support?
# def test_301_empty(self):
# self.vr("301", "")
def test_400_empty(self):
# FIXME: not sure 400 makes sense as "NetworkException"
# we check for NetworkException in several places in
# addition to RestlibException and RemoteServerException
# I think maybe a 400 ("Bad Request") should be a
# RemoteServerException
self.assertRaises(NetworkException, self.vr, "400", "")
def test_401_empty(self):
try:
self.vr("401", "")
except UnauthorizedException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEquals(expected_str, str(e))
else:
self.fail("Should have raised UnauthorizedException")
def test_401_invalid_json(self):
content = u'{this is not json</> dfsdf"" '
try:
self.vr("401", content)
except UnauthorizedException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEquals(expected_str, str(e))
else:
self.fail("Should have raised UnauthorizedException")
@patch("rhsm.connection.json.loads")
def test_401_json_exception(self, mock_json_loads):
mock_json_loads.side_effect = Exception
content = u'{"errors": ["Forbidden message"]}'
try:
self.vr("401", content)
except UnauthorizedException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEquals(expected_str, str(e))
else:
self.fail("Should have raised UnauthorizedException")
def test_403_valid(self):
content = u'{"errors": ["Forbidden message"]}'
try:
self.vr("403", content)
except RestlibException as e:
self.assertEquals("403", e.code)
self.assertEquals("Forbidden message", e.msg)
else:
self.fails("Should have raised a RestlibException")
def test_403_empty(self):
try:
self.vr("403", "")
except ForbiddenException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals("403", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 403\n" \
"Forbidden: Invalid credentials for request."
self.assertEquals(expected_str, str(e))
else:
self.fail("Should have raised ForbiddenException")
def test_401_valid(self):
content = u'{"errors": ["Unauthorized message"]}'
try:
self.vr("401", content)
except RestlibException as e:
self.assertEquals("401", e.code)
self.assertEquals("Unauthorized message", e.msg)
else:
self.fails("Should have raised a RestlibException")
def test_404_empty(self):
try:
self.vr("404", "")
except RemoteServerException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals(self.handler, e.handler)
self.assertEquals("404", e.code)
self.assertEquals(
"Server error attempting a GET to https://server/path returned status 404",
str(e))
else:
self.fails("Should have raise RemoteServerException")
def test_404_valid_but_irrelevant_json(self):
content = u'{"something": "whatever"}'
try:
self.vr("404", content)
except RestlibException as e:
self.assertEquals("404", e.code)
self.assertEquals("", e.msg)
else:
self.fails("Should have raised a RemoteServerException")
def test_404_valid_body_old_style(self):
content = u'{"displayMessage": "not found"}'
try:
self.vr("404", content)
except RestlibException as e:
self.assertEquals("not found", e.msg)
self.assertEquals("404", e.code)
except Exception as e:
self.fail("RestlibException expected, got %s" % e)
else:
self.fail("RestlibException expected")
def test_404_valid_body(self):
content = u'{"errors": ["not found", "still not found"]}'
try:
self.vr("404", content)
except RestlibException as e:
self.assertEquals("not found still not found", e.msg)
self.assertEquals("404", e.code)
except Exception as e:
self.fail("RestlibException expected, got %s" % e)
else:
self.fail("RestlibException expected")
def test_410_emtpy(self):
try:
self.vr("410", "")
except RemoteServerException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals(self.handler, e.handler)
else:
self.fail("RemoteServerException expected")
def test_410_body(self):
content = u'{"displayMessage": "foo", "deletedId": "12345"}'
# self.assertRaises(GoneException, self.vr, "410", content)
try:
self.vr("410", content)
except GoneException as e:
self.assertEquals("12345", e.deleted_id)
self.assertEquals("foo", e.msg)
self.assertEquals("410", e.code)
else:
self.fail("Should have raised a GoneException")
def test_429_empty(self):
try:
self.vr("429", "")
except RateLimitExceededException as e:
self.assertEquals("429", e.code)
else:
self.fail("Should have raised a RateLimitExceededException")
def test_429_body(self):
content = u'{"errors": ["TooFast"]}'
headers = {'retry-after': 20}
try:
self.vr("429", content, headers)
except RateLimitExceededException as e:
self.assertEquals(20, e.retry_after)
self.assertEquals("TooFast", e.msg)
self.assertEquals("429", e.code)
else:
self.fail("Should have raised a RateLimitExceededException")
def test_500_empty(self):
try:
self.vr("500", "")
except RemoteServerException as e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals(self.handler, e.handler)
else:
self.fail("RemoteServerException expected")
def test_599_emtpty(self):
self.assertRaises(NetworkException, self.vr, "599", "")
def setUp(self):
self.restlib = Restlib("somehost", "123", "somehandler")
self.request_type = "GET"
self.handler = "https://server/path"
class RestlibValidateResponseTests(unittest.TestCase):
def setUp(self):
self.restlib = Restlib("somehost", "123", "somehandler")
self.request_type = "GET"
self.handler = "https://server/path"
def vr(self, status, content, headers=None):
response = {'status': status,
'content': content}
if headers:
response['headers'] = headers
#print "response", response
self.restlib.validateResponse(response, self.request_type, self.handler)
# All empty responses that aren't 200/204 raise a NetworkException
def test_200_empty(self):
# this should just not raise any exceptions
self.vr("200", "")
def test_200_json(self):
# no exceptions
content = u'{"something": "whatever"}'
self.vr("200", content)
# 202 ACCEPTED
def test_202_empty(self):
self.vr("202", "")
def test_202_none(self):
self.vr("202", None)
def test_202_json(self):
content = u'{"something": "whatever"}'
self.vr("202", content)
# 204 NO CONTENT
# no exceptions is okay
def test_204_empty(self):
self.vr("204", "")
# no exceptions is okay
def test_204_none(self):
self.vr("204", None)
# MOVED PERMANENTLY
# FIXME: implement 301 support?
#def test_301_empty(self):
# self.vr("301", "")
def test_400_empty(self):
# FIXME: not sure 400 makes sense as "NetworkException"
# we check for NetworkException in several places in
# addition to RestlibException and RemoteServerException
# I think maybe a 400 ("Bad Request") should be a
# RemoteServerException
self.assertRaises(NetworkException,
self.vr,
"400",
"")
def test_401_empty(self):
try:
self.vr("401", "")
except UnauthorizedException, e:
self.assertEquals(self.request_type, e.request_type)
self.assertEquals("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEquals(expected_str, str(e))
else:
class RestlibValidateResponseTests(unittest.TestCase):
def setUp(self):
self.restlib = Restlib("somehost", "123", "somehandler")
self.request_type = "GET"
self.handler = "https://server/path"
def vr(self, status, content, headers=None):
response = {'status': status,
'content': content}
if headers:
response['headers'] = headers
self.restlib.validateResponse(response, self.request_type, self.handler)
# All empty responses that aren't 200/204 raise a NetworkException
def test_200_empty(self):
# this should just not raise any exceptions
self.vr("200", "")
def test_200_json(self):
# no exceptions
content = u'{"something": "whatever"}'
self.vr("200", content)
# 202 ACCEPTED
def test_202_empty(self):
self.vr("202", "")
def test_202_none(self):
self.vr("202", None)
def test_202_json(self):
content = u'{"something": "whatever"}'
self.vr("202", content)
# 204 NO CONTENT
# no exceptions is okay
def test_204_empty(self):
self.vr("204", "")
# no exceptions is okay
def test_204_none(self):
self.vr("204", None)
# MOVED PERMANENTLY
# FIXME: implement 301 support?
# def test_301_empty(self):
# self.vr("301", "")
def test_400_empty(self):
# FIXME: not sure 400 makes sense as "NetworkException"
# we check for NetworkException in several places in
# addition to RestlibException and RemoteServerException
# I think maybe a 400 ("Bad Request") should be a
# RemoteServerException
self.assertRaises(NetworkException,
self.vr,
"400",
"")
def test_401_empty(self):
try:
self.vr("401", "")
except UnauthorizedException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEqual(expected_str, str(e))
else:
self.fail("Should have raised UnauthorizedException")
def test_401_invalid_json(self):
content = u'{this is not json</> dfsdf"" '
try:
self.vr("401", content)
except UnauthorizedException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEqual(expected_str, str(e))
else:
self.fail("Should have raised UnauthorizedException")
@patch("rhsm.connection.json.loads")
def test_401_json_exception(self, mock_json_loads):
mock_json_loads.side_effect = Exception
content = u'{"errors": ["Forbidden message"]}'
try:
self.vr("401", content)
except UnauthorizedException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual("401", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 401\n" \
"Unauthorized: Invalid credentials for request."
self.assertEqual(expected_str, str(e))
else:
self.fail("Should have raised UnauthorizedException")
def test_403_valid(self):
content = u'{"errors": ["Forbidden message"]}'
try:
self.vr("403", content)
except RestlibException as e:
self.assertEqual("403", e.code)
self.assertEqual("Forbidden message", e.msg)
else:
self.fails("Should have raised a RestlibException")
def test_403_empty(self):
try:
self.vr("403", "")
except ForbiddenException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual("403", e.code)
expected_str = "Server error attempting a GET to https://server/path returned status 403\n" \
"Forbidden: Invalid credentials for request."
self.assertEqual(expected_str, str(e))
else:
self.fail("Should have raised ForbiddenException")
def test_401_valid(self):
content = u'{"errors": ["Unauthorized message"]}'
try:
self.vr("401", content)
except RestlibException as e:
self.assertEqual("401", e.code)
self.assertEqual("Unauthorized message", e.msg)
else:
self.fails("Should have raised a RestlibException")
def test_404_empty(self):
try:
self.vr("404", "")
except RemoteServerException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual(self.handler, e.handler)
self.assertEqual("404", e.code)
self.assertEqual("Server error attempting a GET to https://server/path returned status 404", str(e))
else:
self.fails("Should have raise RemoteServerException")
def test_404_valid_but_irrelevant_json(self):
content = u'{"something": "whatever"}'
try:
self.vr("404", content)
except RestlibException as e:
self.assertEqual("404", e.code)
self.assertEqual("", e.msg)
else:
self.fails("Should have raised a RemoteServerException")
def test_404_valid_body_old_style(self):
content = u'{"displayMessage": "not found"}'
try:
self.vr("404", content)
except RestlibException as e:
self.assertEqual("not found", e.msg)
self.assertEqual("404", e.code)
except Exception as e:
self.fail("RestlibException expected, got %s" % e)
else:
self.fail("RestlibException expected")
def test_404_valid_body(self):
content = u'{"errors": ["not found", "still not found"]}'
try:
self.vr("404", content)
except RestlibException as e:
self.assertEqual("not found still not found", e.msg)
self.assertEqual("404", e.code)
except Exception as e:
self.fail("RestlibException expected, got %s" % e)
else:
self.fail("RestlibException expected")
def test_410_emtpy(self):
try:
self.vr("410", "")
except RemoteServerException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual(self.handler, e.handler)
else:
self.fail("RemoteServerException expected")
def test_410_body(self):
content = u'{"displayMessage": "foo", "deletedId": "12345"}'
# self.assertRaises(GoneException, self.vr, "410", content)
try:
self.vr("410", content)
except GoneException as e:
self.assertEqual("12345", e.deleted_id)
self.assertEqual("foo", e.msg)
self.assertEqual("410", e.code)
else:
self.fail("Should have raised a GoneException")
def test_429_empty(self):
try:
self.vr("429", "")
except RateLimitExceededException as e:
self.assertEqual("429", e.code)
else:
self.fail("Should have raised a RateLimitExceededException")
def test_429_body(self):
content = u'{"errors": ["TooFast"]}'
headers = {'retry-after': 20}
try:
self.vr("429", content, headers)
except RateLimitExceededException as e:
self.assertEqual(20, e.retry_after)
self.assertEqual("TooFast, retry access after: 20 seconds.", e.msg)
self.assertEqual("429", e.code)
else:
self.fail("Should have raised a RateLimitExceededException")
def test_500_empty(self):
try:
self.vr("500", "")
except RemoteServerException as e:
self.assertEqual(self.request_type, e.request_type)
self.assertEqual(self.handler, e.handler)
else:
self.fail("RemoteServerException expected")
def test_599_emtpty(self):
self.assertRaises(NetworkException, self.vr, "599", "")