def test_json_build_query(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {
"foo": 1,
"bar": u"\N{COMET}",
"baz": ["fe", "fi", "fo", "fum"], # Repeated parameters
"qux": [],
}
body = {}
headers, unused_params, query, body = model.request(headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertEqual(headers["content-type"], "application/json")
query_dict = parse_qs(query[1:])
self.assertEqual(query_dict["foo"], ["1"])
if six.PY3:
# Python 3, no need to encode
self.assertEqual(query_dict["bar"], [u"\N{COMET}"])
else:
# Python 2, encode string
self.assertEqual(query_dict["bar"], [u"\N{COMET}".encode("utf-8")])
self.assertEqual(query_dict["baz"], ["fe", "fi", "fo", "fum"])
self.assertTrue("qux" not in query_dict)
self.assertEqual(body, "{}")
def test_json_build_query(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {'foo': 1, 'bar': u'\N{COMET}',
'baz': ['fe', 'fi', 'fo', 'fum'], # Repeated parameters
'qux': []}
body = {}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers['accept'], 'application/json')
self.assertEqual(headers['content-type'], 'application/json')
query_dict = parse_qs(query[1:])
self.assertEqual(query_dict['foo'], ['1'])
if six.PY3:
# Python 3, no need to encode
self.assertEqual(query_dict['bar'], [u'\N{COMET}'])
else:
# Python 2, encode string
self.assertEqual(query_dict['bar'], [u'\N{COMET}'.encode('utf-8')])
self.assertEqual(query_dict['baz'], ['fe', 'fi', 'fo', 'fum'])
self.assertTrue('qux' not in query_dict)
self.assertEqual(body, '{}')
def test_json_build_query(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {
'foo': 1,
'bar': u'\N{COMET}',
'baz': ['fe', 'fi', 'fo', 'fum'], # Repeated parameters
'qux': []
}
body = {}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers['accept'], 'application/json')
self.assertEqual(headers['content-type'], 'application/json')
query_dict = parse_qs(query[1:])
self.assertEqual(query_dict['foo'], ['1'])
if six.PY3:
# Python 3, no need to encode
self.assertEqual(query_dict['bar'], [u'\N{COMET}'])
else:
# Python 2, encode string
self.assertEqual(query_dict['bar'], [u'\N{COMET}'.encode('utf-8')])
self.assertEqual(query_dict['baz'], ['fe', 'fi', 'fo', 'fum'])
self.assertTrue('qux' not in query_dict)
self.assertEqual(body, '{}')
def test_json_build_query(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {
"foo": 1,
"bar": u"\N{COMET}",
"baz": ["fe", "fi", "fo", "fum"], # Repeated parameters
"qux": [],
}
body = {}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertEqual(headers["content-type"], "application/json")
query_dict = parse_qs(query[1:])
self.assertEqual(query_dict["foo"], ["1"])
if six.PY3:
# Python 3, no need to encode
self.assertEqual(query_dict["bar"], [u"\N{COMET}"])
else:
# Python 2, encode string
self.assertEqual(query_dict["bar"], [u"\N{COMET}".encode("utf-8")])
self.assertEqual(query_dict["baz"], ["fe", "fi", "fo", "fum"])
self.assertTrue("qux" not in query_dict)
self.assertEqual(body, "{}")
def test_user_agent(self):
model = JsonModel(data_wrapper=False)
headers = {"user-agent": "my-test-app/1.23.4"}
path_params = {}
query_params = {}
body = {}
headers, unused_params, unused_query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers["user-agent"], "my-test-app/1.23.4 (gzip)")
def test_user_agent(self):
model = JsonModel(data_wrapper=False)
headers = {"user-agent": "my-test-app/1.23.4"}
path_params = {}
query_params = {}
body = {}
headers, unused_params, unused_query, body = model.request(headers, path_params, query_params, body)
self.assertEqual(
headers["user-agent"], "my-test-app/1.23.4 google-api-python-client/" + __version__ + " (gzip)"
)
def test_json_body_data_wrapper(self):
model = JsonModel(data_wrapper=True)
headers = {}
path_params = {}
query_params = {}
body = {}
headers, unused_params, query, body = model.request(headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertEqual(headers["content-type"], "application/json")
self.assertNotEqual(query, "")
self.assertEqual(body, '{"data": {}}')
def test_json_no_body(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {}
body = None
headers, unused_params, query, body = model.request(headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertTrue("content-type" not in headers)
self.assertNotEqual(query, "")
self.assertEqual(body, None)
def test_user_agent(self):
model = JsonModel(data_wrapper=False)
headers = {'user-agent': 'my-test-app/1.23.4'}
path_params = {}
query_params = {}
body = {}
headers, unused_params, unused_query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers['user-agent'],
'my-test-app/1.23.4 google-api-python-client/' + __version__ +
' (gzip)')
def test_logging(self):
class MockLogging(object):
def __init__(self):
self.info_record = []
self.debug_record = []
def info(self, message, *args):
self.info_record.append(message % args)
def debug(self, message, *args):
self.debug_record.append(message % args)
class MockResponse(dict):
def __init__(self, items):
super(MockResponse, self).__init__()
self.status = items["status"]
for key, value in six.iteritems(items):
self[key] = value
old_logging = googleapiclient.model.LOGGER
googleapiclient.model.LOGGER = MockLogging()
googleapiclient.model.dump_request_response = True
model = JsonModel()
request_body = {"field1": "value1", "field2": "value2"}
body_string = model.request({}, {}, {}, request_body)[-1]
json_body = json.loads(body_string)
self.assertEqual(request_body, json_body)
response = {
"status": 200,
"response_field_1": "response_value_1",
"response_field_2": "response_value_2",
}
response_body = model.response(MockResponse(response), body_string)
self.assertEqual(request_body, response_body)
self.assertEqual(
googleapiclient.model.LOGGER.info_record[:2],
["--request-start--", "-headers-start-"],
)
self.assertTrue("response_field_1: response_value_1" in
googleapiclient.model.LOGGER.info_record)
self.assertTrue("response_field_2: response_value_2" in
googleapiclient.model.LOGGER.info_record)
self.assertEqual(
json.loads(googleapiclient.model.LOGGER.info_record[-2]),
request_body)
self.assertEqual(googleapiclient.model.LOGGER.info_record[-1],
"--response-end--")
googleapiclient.model.LOGGER = old_logging
def test_json_body(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {}
body = {}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers['accept'], 'application/json')
self.assertEqual(headers['content-type'], 'application/json')
self.assertNotEqual(query, '')
self.assertEqual(body, '{}')
def test_user_agent(self):
model = JsonModel(data_wrapper=False)
headers = {'user-agent': 'my-test-app/1.23.4'}
path_params = {}
query_params = {}
body = {}
headers, unused_params, unused_query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(
headers['user-agent'],
'my-test-app/1.23.4 google-api-python-client/' + __version__ +
' (gzip)')
def test_json_body_default_data(self):
"""Test that a 'data' wrapper doesn't get added if one is already present."""
model = JsonModel(data_wrapper=True)
headers = {}
path_params = {}
query_params = {}
body = {"data": "foo"}
headers, unused_params, query, body = model.request(headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertEqual(headers["content-type"], "application/json")
self.assertNotEqual(query, "")
self.assertEqual(body, '{"data": "foo"}')
def test_json_body(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {}
body = {}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers['accept'], 'application/json')
self.assertEqual(headers['content-type'], 'application/json')
self.assertNotEqual(query, '')
self.assertEqual(body, '{}')
def test_x_goog_api_client(self):
model = JsonModel(data_wrapper=False)
# test header composition for cloud clients that wrap discovery
headers = {'x-goog-api-client': 'gccl/1.23.4'}
path_params = {}
query_params = {}
body = {}
headers, unused_params, unused_query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(
headers['x-goog-api-client'], 'gccl/1.23.4' + ' gdcl/' +
__version__ + ' gl-python/' + platform.python_version())
def test_json_body_data_wrapper(self):
model = JsonModel(data_wrapper=True)
headers = {}
path_params = {}
query_params = {}
body = {}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertEqual(headers["content-type"], "application/json")
self.assertNotEqual(query, "")
self.assertEqual(body, '{"data": {}}')
def test_json_no_body(self):
model = JsonModel(data_wrapper=False)
headers = {}
path_params = {}
query_params = {}
body = None
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertTrue("content-type" not in headers)
self.assertNotEqual(query, "")
self.assertEqual(body, None)
def test_json_body_default_data(self):
"""Test that a 'data' wrapper doesn't get added if one is already present."""
model = JsonModel(data_wrapper=True)
headers = {}
path_params = {}
query_params = {}
body = {"data": "foo"}
headers, unused_params, query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(headers["accept"], "application/json")
self.assertEqual(headers["content-type"], "application/json")
self.assertNotEqual(query, "")
self.assertEqual(body, '{"data": "foo"}')
def test_logging(self):
class MockLogging(object):
def __init__(self):
self.info_record = []
self.debug_record = []
def info(self, message, *args):
self.info_record.append(message % args)
def debug(self, message, *args):
self.debug_record.append(message % args)
class MockResponse(dict):
def __init__(self, items):
super(MockResponse, self).__init__()
self.status = items['status']
for key, value in six.iteritems(items):
self[key] = value
old_logging = googleapiclient.model.LOGGER
googleapiclient.model.LOGGER = MockLogging()
googleapiclient.model.dump_request_response = True
model = JsonModel()
request_body = {'field1': 'value1', 'field2': 'value2'}
body_string = model.request({}, {}, {}, request_body)[-1]
json_body = json.loads(body_string)
self.assertEqual(request_body, json_body)
response = {
'status': 200,
'response_field_1': 'response_value_1',
'response_field_2': 'response_value_2'
}
response_body = model.response(MockResponse(response), body_string)
self.assertEqual(request_body, response_body)
self.assertEqual(googleapiclient.model.LOGGER.info_record[:2],
['--request-start--', '-headers-start-'])
self.assertTrue('response_field_1: response_value_1' in
googleapiclient.model.LOGGER.info_record)
self.assertTrue('response_field_2: response_value_2' in
googleapiclient.model.LOGGER.info_record)
self.assertEqual(
json.loads(googleapiclient.model.LOGGER.info_record[-2]),
request_body)
self.assertEqual(googleapiclient.model.LOGGER.info_record[-1],
'--response-end--')
googleapiclient.model.LOGGER = old_logging
def test_logging(self):
class MockLogging(object):
def __init__(self):
self.info_record = []
self.debug_record = []
def info(self, message, *args):
self.info_record.append(message % args)
def debug(self, message, *args):
self.debug_record.append(message % args)
class MockResponse(dict):
def __init__(self, items):
super(MockResponse, self).__init__()
self.status = items['status']
for key, value in six.iteritems(items):
self[key] = value
old_logging = googleapiclient.model.LOGGER
googleapiclient.model.LOGGER = MockLogging()
googleapiclient.model.dump_request_response = True
model = JsonModel()
request_body = {
'field1': 'value1',
'field2': 'value2'
}
body_string = model.request({}, {}, {}, request_body)[-1]
json_body = json.loads(body_string)
self.assertEqual(request_body, json_body)
response = {'status': 200,
'response_field_1': 'response_value_1',
'response_field_2': 'response_value_2'}
response_body = model.response(MockResponse(response), body_string)
self.assertEqual(request_body, response_body)
self.assertEqual(googleapiclient.model.LOGGER.info_record[:2],
['--request-start--',
'-headers-start-'])
self.assertTrue('response_field_1: response_value_1' in
googleapiclient.model.LOGGER.info_record)
self.assertTrue('response_field_2: response_value_2' in
googleapiclient.model.LOGGER.info_record)
self.assertEqual(json.loads(googleapiclient.model.LOGGER.info_record[-2]),
request_body)
self.assertEqual(googleapiclient.model.LOGGER.info_record[-1],
'--response-end--')
googleapiclient.model.LOGGER = old_logging
def test_x_goog_api_client(self):
model = JsonModel(data_wrapper=False)
# test header composition for cloud clients that wrap discovery
headers = {"x-goog-api-client": "gccl/1.23.4"}
path_params = {}
query_params = {}
body = {}
headers, unused_params, unused_query, body = model.request(
headers, path_params, query_params, body)
self.assertEqual(
headers["x-goog-api-client"],
"gccl/1.23.4" + " gdcl/" + _LIBRARY_VERSION + " gl-python/" +
platform.python_version(),
)
def test_logging(self):
class MockLogging(object):
def __init__(self):
self.info_record = []
self.debug_record = []
def info(self, message, *args):
self.info_record.append(message % args)
def debug(self, message, *args):
self.debug_record.append(message % args)
class MockResponse(dict):
def __init__(self, items):
super(MockResponse, self).__init__()
self.status = items["status"]
for key, value in six.iteritems(items):
self[key] = value
old_logging = googleapiclient.model.logging
googleapiclient.model.logging = MockLogging()
googleapiclient.model.dump_request_response = True
model = JsonModel()
request_body = {"field1": "value1", "field2": "value2"}
body_string = model.request({}, {}, {}, request_body)[-1]
json_body = json.loads(body_string)
self.assertEqual(request_body, json_body)
response = {"status": 200, "response_field_1": "response_value_1", "response_field_2": "response_value_2"}
response_body = model.response(MockResponse(response), body_string)
self.assertEqual(request_body, response_body)
self.assertEqual(googleapiclient.model.logging.info_record[:2], ["--request-start--", "-headers-start-"])
self.assertTrue("response_field_1: response_value_1" in googleapiclient.model.logging.info_record)
self.assertTrue("response_field_2: response_value_2" in googleapiclient.model.logging.info_record)
self.assertEqual(json.loads(googleapiclient.model.logging.info_record[-2]), request_body)
self.assertEqual(googleapiclient.model.logging.info_record[-1], "--response-end--")
googleapiclient.model.logging = old_logging
