def test_location_autosuggest_json(self):
transport = Transport(self.api_key, response_format='json')
self.result = transport.location_autosuggest(query='KUL',
market='UK',
currency='GBP',
locale='en-GB').parsed
self.assertTrue('Places' in self.result)
self.assertTrue(len(self.result['Places']) > 0)
def test_location_autosuggest_xml(self):
transport = Transport(self.api_key, response_format='xml')
self.result = transport.location_autosuggest(query='BER',
market='DE',
currency='EUR',
locale='de-DE').parsed
self.assertIsNotNone(self.result.find('./Places'))
self.assertTrue(len(self.result.findall('./Places/PlaceDto')) > 0)
def test_location_autosuggest_json(self):
transport = Transport(self.api_key, response_format='json')
self.result = transport.location_autosuggest(query='KUL',
market='UK',
currency='GBP',
locale='en-GB').parsed
self.assertTrue('Places' in self.result)
self.assertTrue(len(self.result['Places']) > 0)
def test_location_autosuggest_xml(self):
transport = Transport(self.api_key, response_format='xml')
self.result = transport.location_autosuggest(query='BER',
market='DE',
currency='EUR',
locale='de-DE').parsed
self.assertTrue(None != self.result.find('./Places'))
self.assertTrue(len(self.result.findall('./Places/PlaceDto')) > 0)
def cityDecoder(city):
flights_locale = Transport('ha306082955374085267757354385037')
result = flights_locale.location_autosuggest(
market='ES',
currency='eur',
locale='en-GB',
query = city).parsed
return result
def test_construct_params(self):
params = dict(a=1, b=2, c=3)
self.assertEqual("1/2/3", Transport._construct_params(params, ("a", "b", "c")))
params = dict(a=1, b=2)
self.assertEqual("1/2", Transport._construct_params(params, ("a", "b"), ("c",)))
params = dict(a=1, b=2, c=3)
self.assertEqual("1/2/3", Transport._construct_params(params, ("a", "b"), ("c",)))
params = dict(a=1, c=3)
self.assertRaises(MissingParameter, Transport._construct_params, params, ("a", "b"), ("c",))
def test_construct_params(self):
params = dict(a=1, b=2, c=3)
self.assertEqual('1/2/3', Transport._construct_params(params, ('a', 'b', 'c')))
params = dict(a=1, b=2)
self.assertEqual('1/2', Transport._construct_params(params, ('a', 'b'), ('c',)))
params = dict(a=1, b=2, c=3)
self.assertEqual('1/2/3', Transport._construct_params(params, ('a', 'b'), ('c',)))
with self.assertRaises(MissingParameter):
params = dict(a=1, c=3)
Transport._construct_params(params, ('a', 'b'), ('c',))
def test_default_resp_callback_json(self):
t = Transport(self.api_key, response_format="json")
self.assertRaises(EmptyResponse, t._default_resp_callback, None)
self.assertRaises(EmptyResponse, t._default_resp_callback, FakeResponse(content=""))
self.assertRaises(ValueError, t._default_resp_callback, FakeResponse(content="invalid json"))
resp_json = t._default_resp_callback(FakeResponse(content='{"valid": 1}')).parsed
self.assertTrue(None != resp_json)
self.assertTrue("valid" in resp_json)
self.assertEqual(resp_json["valid"], 1)
def test_with_error_handling_ignore(self):
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), IGNORE)
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(), IGNORE)
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(), IGNORE)
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(content='{"valid": 1}'), HTTPError(), IGNORE)
self.assertIsNotNone(result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
def test_construct_params(self):
params = dict(a=1, b=2, c=3)
self.assertEqual('1/2/3',
Transport._construct_params(params, ('a', 'b', 'c')))
params = dict(a=1, b=2)
self.assertEqual(
'1/2', Transport._construct_params(params, ('a', 'b'), ('c', )))
params = dict(a=1, b=2, c=3)
self.assertEqual(
'1/2/3', Transport._construct_params(params, ('a', 'b'), ('c', )))
with self.assertRaises(MissingParameter):
params = dict(a=1, c=3)
Transport._construct_params(params, ('a', 'b'), ('c', ))
def city_string_to_id(city_as_str):
transport_service = Transport(API_KEY)
city_suggestion_results = transport_service.location_autosuggest(
**{
'market': 'ES',
'currency': 'EUR',
'locale': 'en-GB',
'query': city_as_str
}).json()['Places']
if not city_suggestion_results:
return None
else:
return city_suggestion_results[0]['PlaceId']
def test_with_error_handling_ignore(self):
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), IGNORE, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(), IGNORE, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(), IGNORE, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), IGNORE, 'xml').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(), IGNORE, 'xml').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(), IGNORE, 'xml').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}'), HTTPError(), IGNORE, 'json').parsed
self.assertIsNotNone(result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(
FakeResponse(content='<valid>1</valid>'), HTTPError(), IGNORE, 'xml').parsed
self.assertIsNotNone(result)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
def test_with_error_handling_ignore(self):
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), IGNORE, "json").parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(), IGNORE, "json").parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(), IGNORE, "json").parsed
self.assertEqual(None, result)
try:
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), IGNORE, "xml").parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(), IGNORE, "xml").parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(), IGNORE, "xml").parsed
self.assertEqual(None, result)
except Exception as e:
# Exception for Python 2.6
print(e)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}'), HTTPError(), IGNORE, "json"
).parsed
self.assertTrue(None != result)
self.assertTrue("valid" in result)
self.assertEqual(result["valid"], 1)
result = Transport._with_error_handling(
FakeResponse(content="<valid>1</valid>"), HTTPError(), IGNORE, "xml"
).parsed
self.assertTrue(None != result)
self.assertEqual(result.tag, "valid")
self.assertEqual(result.text, "1")
def test_with_error_handling_ignore(self):
result = Transport._with_error_handling(
FakeResponse(), EmptyResponse(), IGNORE, 'json').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(
FakeResponse(), RuntimeError(), IGNORE, 'json').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(
FakeResponse(), HTTPError(), IGNORE, 'json').parsed
self.assertEqual(None, result)
try:
result = Transport._with_error_handling(
FakeResponse(), EmptyResponse(), IGNORE, 'xml').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(
FakeResponse(), RuntimeError(), IGNORE, 'xml').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(
FakeResponse(), HTTPError(), IGNORE, 'xml').parsed
self.assertEqual(None, result)
except Exception as e:
# Exception for Python 2.6
print(e)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}'), HTTPError(), IGNORE, 'json').parsed
self.assertTrue(None != result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(
FakeResponse(content='<valid>1</valid>'), HTTPError(), IGNORE, 'xml').parsed
self.assertTrue(None != result)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
def test_with_error_handling_ignore(self):
result = Transport._with_error_handling(FakeResponse(),
EmptyResponse(), IGNORE,
'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(),
IGNORE, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(),
IGNORE, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(),
EmptyResponse(), IGNORE,
'xml').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(),
IGNORE, 'xml').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(),
IGNORE, 'xml').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}'), HTTPError(), IGNORE,
'json').parsed
self.assertIsNotNone(result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(
FakeResponse(content='<valid>1</valid>'), HTTPError(), IGNORE,
'xml').parsed
self.assertIsNotNone(result)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
def test_default_resp_callback_json(self):
t = Transport(self.api_key, response_format='json')
self.assertRaises(EmptyResponse, t._default_resp_callback, None)
self.assertRaises(EmptyResponse, t._default_resp_callback,
FakeResponse(content=''))
self.assertRaises(ValueError, t._default_resp_callback,
FakeResponse(content='invalid json'))
resp_json = t._default_resp_callback(
FakeResponse(content='{"valid": 1}')).parsed
self.assertTrue(None != resp_json)
self.assertTrue('valid' in resp_json)
self.assertEqual(resp_json['valid'], 1)
def test_default_resp_callback_xml(self):
t = Transport(self.api_key, response_format="xml")
self.assertRaises(EmptyResponse, t._default_resp_callback, None)
self.assertRaises(EmptyResponse, t._default_resp_callback, FakeResponse(content=""))
try:
self.assertRaises(ValueError, t._default_resp_callback, FakeResponse(content="invalid XML"))
except:
self.assertRaises(Exception, t._default_resp_callback, FakeResponse(content="invalid XML"))
resp_xml = t._default_resp_callback(FakeResponse(content='<valid a="test">1</valid>')).parsed
self.assertTrue(None != resp_xml)
self.assertEqual(resp_xml.tag, "valid")
self.assertEqual(resp_xml.text, "1")
self.assertEqual(resp_xml.get("a"), "test")
def test_default_resp_callback_xml(self):
t = Transport(self.api_key, response_format='xml')
self.assertRaises(EmptyResponse, t._default_resp_callback, None)
self.assertRaises(EmptyResponse, t._default_resp_callback,
FakeResponse(content=''))
try:
self.assertRaises(ValueError, t._default_resp_callback,
FakeResponse(content='invalid XML'))
except:
self.assertRaises(Exception, t._default_resp_callback,
FakeResponse(content='invalid XML'))
resp_xml = t._default_resp_callback(
FakeResponse(content='<valid a="test">1</valid>')).parsed
self.assertTrue(None != resp_xml)
self.assertEqual(resp_xml.tag, 'valid')
self.assertEqual(resp_xml.text, '1')
self.assertEqual(resp_xml.get('a'), 'test')
def test_default_resp_callback_xml(self):
t = Transport(self.api_key, response_format='xml')
with self.assertRaises(EmptyResponse):
t._default_resp_callback(None)
with self.assertRaises(EmptyResponse):
t._default_resp_callback(FakeResponse(content=''))
with self.assertRaises(ValueError):
t._default_resp_callback(FakeResponse(content='invalid XML'))
resp_xml = t._default_resp_callback(
FakeResponse(content='<valid a="test">1</valid>')).parsed
self.assertIsNotNone(resp_xml)
self.assertEqual(resp_xml.tag, 'valid')
self.assertEqual(resp_xml.text, '1')
self.assertEqual(resp_xml.get('a'), 'test')
def test_default_resp_callback_xml(self):
t = Transport(self.api_key, response_format='xml')
self.assertRaises(EmptyResponse,
t._default_resp_callback, None)
self.assertRaises(EmptyResponse,
t._default_resp_callback, FakeResponse(content=''))
try:
self.assertRaises(ValueError,
t._default_resp_callback, FakeResponse(content='invalid XML'))
except:
self.assertRaises(Exception,
t._default_resp_callback, FakeResponse(content='invalid XML'))
resp_xml = t._default_resp_callback(
FakeResponse(content='<valid a="test">1</valid>')).parsed
self.assertTrue(None != resp_xml)
self.assertEqual(resp_xml.tag, 'valid')
self.assertEqual(resp_xml.text, '1')
self.assertEqual(resp_xml.get('a'), 'test')
def test_default_resp_callback(self):
with self.assertRaises(EmptyResponse):
Transport._default_resp_callback(None)
with self.assertRaises(EmptyResponse):
Transport._default_resp_callback(FakeResponse(content=''))
with self.assertRaises(ValueError):
Transport._default_resp_callback(FakeResponse(content='invalid json'))
with self.assertRaises(ResponseError) as e:
Transport._default_resp_callback(FakeResponse(content='{"errors": ["Wrong API key", "Another error"]}'))
self.assertEqual(e.message, '\n\t%s' % '\n\t'.join(['Wrong API key', 'Another error']))
resp_json = Transport._default_resp_callback(FakeResponse(content='{"valid": 1}'))
self.assertIsNotNone(resp_json)
self.assertTrue('valid' in resp_json)
self.assertEqual(resp_json['valid'], 1)
def test_with_error_handling_strict(self):
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError, STRICT)
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(status_code=404), HTTPError(), STRICT)
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=429), HTTPError('429: '), STRICT)
self.assertEqual(e.message, '429: Too many requests in the last minute.')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=400), HTTPError('400'), STRICT)
self.assertEqual(e.message, '400')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=400,
content='{"ValidationErrors": '
'[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError('400'), STRICT)
self.assertEqual(e.message, '400: %s' % '\n\t'.join(['1', '2']))
def test_default_resp_callback_json(self):
t = Transport(self.api_key, response_format='json')
with self.assertRaises(EmptyResponse):
t._default_resp_callback(None)
with self.assertRaises(EmptyResponse):
t._default_resp_callback(FakeResponse(content=''))
with self.assertRaises(ValueError):
t._default_resp_callback(FakeResponse(content='invalid json'))
resp_json = t._default_resp_callback(FakeResponse(content='{"valid": 1}')).parsed
self.assertIsNotNone(resp_json)
self.assertTrue('valid' in resp_json)
self.assertEqual(resp_json['valid'], 1)
def test_default_resp_callback_xml(self):
t = Transport(self.api_key, response_format='xml')
with self.assertRaises(EmptyResponse):
t._default_resp_callback(None)
with self.assertRaises(EmptyResponse):
t._default_resp_callback(FakeResponse(content=''))
with self.assertRaises(ValueError):
t._default_resp_callback(FakeResponse(content='invalid XML'))
resp_xml = t._default_resp_callback(FakeResponse(content='<valid a="test">1</valid>')).parsed
self.assertIsNotNone(resp_xml)
self.assertEqual(resp_xml.tag, 'valid')
self.assertEqual(resp_xml.text, '1')
self.assertEqual(resp_xml.get('a'), 'test')
def test_with_error_handling_ignore(self):
result = Transport._with_error_handling(FakeResponse(),
EmptyResponse(), IGNORE,
'json').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(), RuntimeError(),
IGNORE, 'json').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(), HTTPError(),
IGNORE, 'json').parsed
self.assertEqual(None, result)
try:
result = Transport._with_error_handling(FakeResponse(),
EmptyResponse(), IGNORE,
'xml').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(),
RuntimeError(), IGNORE,
'xml').parsed
self.assertEqual(None, result)
result = Transport._with_error_handling(FakeResponse(),
HTTPError(), IGNORE,
'xml').parsed
self.assertEqual(None, result)
except Exception as e:
# Exception for Python 2.6
print(e)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}'), HTTPError(), IGNORE,
'json').parsed
self.assertTrue(result is not None)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(
FakeResponse(content='<valid>1</valid>'), HTTPError(), IGNORE,
'xml').parsed
self.assertTrue(result is not None)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
def test_with_error_handling_graceful(self):
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), GRACEFUL)
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(content='{"valid": 1}', status_code=429),
HTTPError(), GRACEFUL)
self.assertIsNotNone(result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL)
self.assertIsNone(result)
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(), HTTPError(), GRACEFUL)
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError(), GRACEFUL)
def test_with_error_handling_graceful(self):
result = Transport._with_error_handling(
FakeResponse(), EmptyResponse(), GRACEFUL, 'json')
self.assertTrue(result is not None)
self.assertEqual(None, result.parsed)
result = Transport._with_error_handling(
FakeResponse(), EmptyResponse(), GRACEFUL, 'xml')
self.assertTrue(result is not None)
self.assertEqual(None, result.parsed)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}', status_code=429),
HTTPError(), GRACEFUL, 'json'
).parsed
self.assertTrue(result is not None)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(
FakeResponse(content='<valid>1</valid>', status_code=429),
HTTPError(), GRACEFUL, 'xml'
).parsed
self.assertTrue(result is not None)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
result = Transport._with_error_handling(
FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL, 'json'
).parsed
self.assertEqual(None, result)
try:
result = Transport._with_error_handling(
FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL, 'xml'
).parsed
except Exception as e:
print(e)
self.assertEqual(None, result)
for format in ['json', 'xml']:
self.assertRaises(HTTPError,
Transport._with_error_handling,
FakeResponse(), HTTPError(), GRACEFUL, format)
self.assertRaises(RuntimeError,
Transport._with_error_handling,
FakeResponse(), RuntimeError(), GRACEFUL, format)
def test_with_error_handling_graceful(self):
result = Transport._with_error_handling(
FakeResponse(), EmptyResponse(), GRACEFUL, 'json')
self.assertTrue(None != result)
self.assertEqual(None, result.parsed)
result = Transport._with_error_handling(
FakeResponse(), EmptyResponse(), GRACEFUL, 'xml')
self.assertTrue(None != result)
self.assertEqual(None, result.parsed)
result = Transport._with_error_handling(FakeResponse(content='{"valid": 1}', status_code=429),
HTTPError(), GRACEFUL, 'json').parsed
self.assertTrue(None != result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(FakeResponse(content='<valid>1</valid>', status_code=429),
HTTPError(), GRACEFUL, 'xml').parsed
self.assertTrue(None != result)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
result = Transport._with_error_handling(FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL, 'json').parsed
self.assertEqual(None, result)
try:
result = Transport._with_error_handling(FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL, 'xml').parsed
except Exception as e:
print(e)
self.assertEqual(None, result)
for format in ['json', 'xml']:
self.assertRaises(HTTPError,
Transport._with_error_handling,
FakeResponse(), HTTPError(), GRACEFUL, format)
self.assertRaises(RuntimeError,
Transport._with_error_handling,
FakeResponse(), RuntimeError(), GRACEFUL, format)
def test_with_error_handling_graceful(self):
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), GRACEFUL, "json")
self.assertTrue(None != result)
self.assertEqual(None, result.parsed)
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), GRACEFUL, "xml")
self.assertTrue(None != result)
self.assertEqual(None, result.parsed)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}', status_code=429), HTTPError(), GRACEFUL, "json"
).parsed
self.assertTrue(None != result)
self.assertTrue("valid" in result)
self.assertEqual(result["valid"], 1)
result = Transport._with_error_handling(
FakeResponse(content="<valid>1</valid>", status_code=429), HTTPError(), GRACEFUL, "xml"
).parsed
self.assertTrue(None != result)
self.assertEqual(result.tag, "valid")
self.assertEqual(result.text, "1")
result = Transport._with_error_handling(
FakeResponse(content="invalid", status_code=429), HTTPError(), GRACEFUL, "json"
).parsed
self.assertEqual(None, result)
try:
result = Transport._with_error_handling(
FakeResponse(content="invalid", status_code=429), HTTPError(), GRACEFUL, "xml"
).parsed
except Exception as e:
print(e)
self.assertEqual(None, result)
for format in ["json", "xml"]:
self.assertRaises(HTTPError, Transport._with_error_handling, FakeResponse(), HTTPError(), GRACEFUL, format)
self.assertRaises(
RuntimeError, Transport._with_error_handling, FakeResponse(), RuntimeError(), GRACEFUL, format
)
def test_get_markets_json(self):
transport = Transport(self.api_key, response_format="json")
self.result = transport.get_markets("en-GB").parsed
self.assertTrue("Countries" in self.result)
self.assertTrue(len(self.result["Countries"]) > 0)
def test_with_error_handling_strict(self):
for format in ['json', 'xml']:
try:
self.assertRaises(RuntimeError, Transport._with_error_handling,
FakeResponse(), RuntimeError, STRICT, format)
self.assertRaises(HTTPError, Transport._with_error_handling,
FakeResponse(status_code=404), HTTPError(),
STRICT, format)
self.assertRaises(HTTPError, Transport._with_error_handling,
FakeResponse(status_code=429),
HTTPError('429: '), STRICT, format)
try:
Transport._with_error_handling(
FakeResponse(status_code=429), HTTPError('429: '),
STRICT, format)
except HTTPError as e:
self.assertEqual(
e.message,
'429: Too many requests in the last minute.')
self.assertRaises(HTTPError, Transport._with_error_handling,
FakeResponse(status_code=400),
HTTPError('400'), STRICT, format)
try:
Transport._with_error_handling(
FakeResponse(status_code=400), HTTPError('400'),
STRICT, format)
except HTTPError as e:
self.assertEqual(e.message, '400')
except Exception as e:
# Exception for Python 2.6
print(e)
self.assertRaises(
HTTPError, Transport._with_error_handling,
FakeResponse(status_code=400,
content='{"ValidationErrors": '
'[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError('400'), STRICT, 'json')
try:
Transport._with_error_handling(
FakeResponse(status_code=400,
content='{"ValidationErrors": '
'[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError('400'), STRICT, 'json')
except HTTPError as e:
try:
self.assertEqual(e.message,
('400: %s' % '\n\t'.join(['1', '2'])))
except AttributeError as e:
# Exception for Python 3
print(e)
try:
self.assertRaises(
HTTPError, Transport._with_error_handling,
FakeResponse(status_code=400,
content='<Root><ValidationErrors>'
'<ValidationErrorDto>'
'<Message>1</Message'
'</ValidationErrorDto>'
'<ValidationErrorDto>'
'<Message>2</Message'
'</ValidationErrorDto>'
'</ValidationErrors></Root>'), HTTPError('400'),
STRICT, 'xml')
except Exception as e:
# Exception for Python 2.6
print(e)
try:
try:
Transport._with_error_handling(
FakeResponse(status_code=400,
content='<Root><ValidationErrors>'
'<ValidationErrorDto>'
'<Message>1</Message'
'</ValidationErrorDto>'
'<ValidationErrorDto>'
'<Message>2</Message'
'</ValidationErrorDto>'
'</ValidationErrors></Root>'),
HTTPError('400'), STRICT, 'xml')
except Exception as e:
# Exception for Python 2.6
print(e)
except HTTPError as e:
try:
self.assertEqual(e.message, '400')
except AttributeError as e:
# Exception for Python 3
print(e)
def test_create_session(self):
self.assertRaises(NotImplementedError,
Transport(self.api_key).create_session)
def test_with_error_handling_strict(self):
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError,
STRICT, 'json')
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError,
STRICT, 'xml')
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(status_code=404),
HTTPError(), STRICT, 'json')
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(status_code=404),
HTTPError(), STRICT, 'xml')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=429),
HTTPError('429: '), STRICT, 'json')
self.assertEqual(e.message,
'429: Too many requests in the last minute.')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=429),
HTTPError('429: '), STRICT, 'xml')
self.assertEqual(e.message,
'429: Too many requests in the last minute.')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=400),
HTTPError('400'), STRICT, 'json')
self.assertEqual(e.message, '400')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(FakeResponse(status_code=400),
HTTPError('400'), STRICT, 'xml')
self.assertEqual(e.message, '400')
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(
FakeResponse(status_code=400,
content='{"ValidationErrors": '
'[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError('400'), STRICT, 'json')
self.assertEqual(e.message, '400: %s' % '\n\t'.join(['1', '2']))
with self.assertRaises(HTTPError) as e:
Transport._with_error_handling(
FakeResponse(status_code=400,
content='<Root><ValidationErrors>'
'<ValidationErrorDto>'
'<Message>1</Message'
'</ValidationErrorDto>'
'<ValidationErrorDto>'
'<Message>2</Message'
'</ValidationErrorDto>'
'</ValidationErrors></Root>'), HTTPError('400'),
STRICT, 'xml')
self.assertEqual(e.message, '400: %s' % '\n\t'.join(['1', '2']))
def test_get_markets_xml(self):
transport = Transport(self.api_key, response_format='xml')
self.result = transport.get_markets('de-DE').parsed
self.assertTrue(None != self.result.find('./Countries'))
self.assertTrue(len(self.result.findall('./Countries/CountryDto')) > 0)
def test_with_error_handling_graceful(self):
result = Transport._with_error_handling(FakeResponse(),
EmptyResponse(), GRACEFUL,
'json')
self.assertIsNotNone(result)
self.assertIsNone(result.parsed)
result = Transport._with_error_handling(FakeResponse(),
EmptyResponse(), GRACEFUL,
'xml')
self.assertIsNotNone(result)
self.assertIsNone(result.parsed)
result = Transport._with_error_handling(
FakeResponse(content='{"valid": 1}', status_code=429), HTTPError(),
GRACEFUL, 'json').parsed
self.assertIsNotNone(result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(
FakeResponse(content='<valid>1</valid>', status_code=429),
HTTPError(), GRACEFUL, 'xml').parsed
self.assertIsNotNone(result)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
result = Transport._with_error_handling(
FakeResponse(content='invalid', status_code=429), HTTPError(),
GRACEFUL, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(
FakeResponse(content='invalid', status_code=429), HTTPError(),
GRACEFUL, 'xml').parsed
self.assertIsNone(result)
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(), HTTPError(),
GRACEFUL, 'json')
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError(),
GRACEFUL, 'json')
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(), HTTPError(),
GRACEFUL, 'xml')
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError(),
GRACEFUL, 'xml')
def test_with_error_handling_strict(self):
for format in ["json", "xml"]:
try:
self.assertRaises(
RuntimeError, Transport._with_error_handling, FakeResponse(), RuntimeError, STRICT, format
)
self.assertRaises(
HTTPError,
Transport._with_error_handling,
FakeResponse(status_code=404),
HTTPError(),
STRICT,
format,
)
self.assertRaises(
HTTPError,
Transport._with_error_handling,
FakeResponse(status_code=429),
HTTPError("429: "),
STRICT,
format,
)
try:
Transport._with_error_handling(FakeResponse(status_code=429), HTTPError("429: "), STRICT, format)
except HTTPError as e:
self.assertEqual(e.message, "429: Too many requests in the last minute.")
self.assertRaises(
HTTPError,
Transport._with_error_handling,
FakeResponse(status_code=400),
HTTPError("400"),
STRICT,
format,
)
try:
Transport._with_error_handling(FakeResponse(status_code=400), HTTPError("400"), STRICT, format)
except HTTPError as e:
self.assertEqual(e.message, "400")
except Exception as e:
# Exception for Python 2.6
print(e)
self.assertRaises(
HTTPError,
Transport._with_error_handling,
FakeResponse(status_code=400, content='{"ValidationErrors": ' '[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError("400"),
STRICT,
"json",
)
try:
Transport._with_error_handling(
FakeResponse(status_code=400, content='{"ValidationErrors": ' '[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError("400"),
STRICT,
"json",
)
except HTTPError as e:
try:
self.assertEqual(e.message, ("400: %s" % "\n\t".join(["1", "2"])))
except AttributeError as e:
# Exception for Python 3
print(e)
try:
self.assertRaises(
HTTPError,
Transport._with_error_handling,
FakeResponse(
status_code=400,
content="<Root><ValidationErrors>"
"<ValidationErrorDto>"
"<Message>1</Message"
"</ValidationErrorDto>"
"<ValidationErrorDto>"
"<Message>2</Message"
"</ValidationErrorDto>"
"</ValidationErrors></Root>",
),
HTTPError("400"),
STRICT,
"xml",
)
except Exception as e:
# Exception for Python 2.6
print(e)
try:
try:
Transport._with_error_handling(
FakeResponse(
status_code=400,
content="<Root><ValidationErrors>"
"<ValidationErrorDto>"
"<Message>1</Message"
"</ValidationErrorDto>"
"<ValidationErrorDto>"
"<Message>2</Message"
"</ValidationErrorDto>"
"</ValidationErrors></Root>",
),
HTTPError("400"),
STRICT,
"xml",
)
except Exception as e:
# Exception for Python 2.6
print(e)
except HTTPError as e:
try:
self.assertEqual(e.message, "400")
except AttributeError as e:
# Exception for Python 3
print(e)
def test_get_markets(self):
transport = Transport(self.api_key)
self.result = transport.get_markets('en-GB')
self.assertTrue('Countries' in self.result)
self.assertTrue(len(self.result['Countries']) > 0)
def test_get_markets_xml(self):
transport = Transport(self.api_key, response_format='xml')
self.result = transport.get_markets('de-DE').parsed
self.assertIsNotNone(self.result.find('./Countries'))
self.assertTrue(len(self.result.findall('./Countries/CountryDto')) > 0)
def test_get_markets_json(self):
transport = Transport(self.api_key, response_format='json')
self.result = transport.get_markets('en-GB').parsed
self.assertTrue('Countries' in self.result)
self.assertTrue(len(self.result['Countries']) > 0)
def test_location_autosuggest(self):
transport = Transport(self.api_key)
self.result = transport.location_autosuggest('KUL', 'UK', 'GBP', 'en-GB')
self.assertTrue('Places' in self.result)
self.assertTrue(len(self.result['Places']) > 0)
def test_get_markets_json(self):
transport = Transport(self.api_key, response_format='json')
self.result = transport.get_markets('en-GB').parsed
self.assertTrue('Countries' in self.result)
self.assertTrue(len(self.result['Countries']) > 0)
def test_location_autosuggest_xml(self):
transport = Transport(self.api_key, response_format="xml")
self.result = transport.location_autosuggest(query="BER", market="DE", currency="EUR", locale="de-DE").parsed
self.assertTrue(None != self.result.find("./Places"))
self.assertTrue(len(self.result.findall("./Places/PlaceDto")) > 0)
def test_location_autosuggest_json(self):
transport = Transport(self.api_key, response_format="json")
self.result = transport.location_autosuggest(query="KUL", market="UK", currency="GBP", locale="en-GB").parsed
self.assertTrue("Places" in self.result)
self.assertTrue(len(self.result["Places"]) > 0)
def test_get_markets_xml(self):
transport = Transport(self.api_key, response_format="xml")
self.result = transport.get_markets("de-DE").parsed
self.assertTrue(None != self.result.find("./Countries"))
self.assertTrue(len(self.result.findall("./Countries/CountryDto")) > 0)
def test_with_error_handling_graceful(self):
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), GRACEFUL, 'json')
self.assertIsNotNone(result)
self.assertIsNone(result.parsed)
result = Transport._with_error_handling(FakeResponse(), EmptyResponse(), GRACEFUL, 'xml')
self.assertIsNotNone(result)
self.assertIsNone(result.parsed)
result = Transport._with_error_handling(FakeResponse(content='{"valid": 1}', status_code=429),
HTTPError(), GRACEFUL, 'json').parsed
self.assertIsNotNone(result)
self.assertTrue('valid' in result)
self.assertEqual(result['valid'], 1)
result = Transport._with_error_handling(FakeResponse(content='<valid>1</valid>', status_code=429),
HTTPError(), GRACEFUL, 'xml').parsed
self.assertIsNotNone(result)
self.assertEqual(result.tag, 'valid')
self.assertEqual(result.text, '1')
result = Transport._with_error_handling(FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL, 'json').parsed
self.assertIsNone(result)
result = Transport._with_error_handling(FakeResponse(content='invalid', status_code=429),
HTTPError(), GRACEFUL, 'xml').parsed
self.assertIsNone(result)
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(), HTTPError(), GRACEFUL, 'json')
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError(), GRACEFUL, 'json')
with self.assertRaises(HTTPError):
Transport._with_error_handling(FakeResponse(), HTTPError(), GRACEFUL, 'xml')
with self.assertRaises(RuntimeError):
Transport._with_error_handling(FakeResponse(), RuntimeError(), GRACEFUL, 'xml')
def test_with_error_handling_strict(self):
for format in ['json', 'xml']:
try:
self.assertRaises(RuntimeError,
Transport._with_error_handling, FakeResponse(), RuntimeError, STRICT, format)
self.assertRaises(HTTPError,
Transport._with_error_handling, FakeResponse(status_code=404), HTTPError(), STRICT, format)
self.assertRaises(HTTPError,
Transport._with_error_handling, FakeResponse(status_code=429), HTTPError('429: '), STRICT, format)
try:
Transport._with_error_handling(
FakeResponse(status_code=429), HTTPError('429: '), STRICT, format)
except HTTPError as e:
self.assertEqual(
e.message, '429: Too many requests in the last minute.')
self.assertRaises(HTTPError,
Transport._with_error_handling, FakeResponse(status_code=400), HTTPError('400'), STRICT, format)
try:
Transport._with_error_handling(
FakeResponse(status_code=400), HTTPError('400'), STRICT, format)
except HTTPError as e:
self.assertEqual(e.message, '400')
except Exception as e:
# Exception for Python 2.6
print(e)
self.assertRaises(HTTPError,
Transport._with_error_handling, FakeResponse(status_code=400,
content='{"ValidationErrors": '
'[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError('400'), STRICT, 'json')
try:
Transport._with_error_handling(FakeResponse(status_code=400,
content='{"ValidationErrors": '
'[{"Message": "1"}, {"Message": "2"}]}'),
HTTPError('400'), STRICT, 'json')
except HTTPError as e:
try:
self.assertEqual(
e.message, ('400: %s' % '\n\t'.join(['1', '2'])))
except AttributeError as e:
# Exception for Python 3
print(e)
try:
self.assertRaises(HTTPError,
Transport._with_error_handling, FakeResponse(status_code=400,
content='<Root><ValidationErrors>'
'<ValidationErrorDto>'
'<Message>1</Message'
'</ValidationErrorDto>'
'<ValidationErrorDto>'
'<Message>2</Message'
'</ValidationErrorDto>'
'</ValidationErrors></Root>'),
HTTPError('400'), STRICT, 'xml')
except Exception as e:
# Exception for Python 2.6
print(e)
try:
try:
Transport._with_error_handling(FakeResponse(status_code=400,
content='<Root><ValidationErrors>'
'<ValidationErrorDto>'
'<Message>1</Message'
'</ValidationErrorDto>'
'<ValidationErrorDto>'
'<Message>2</Message'
'</ValidationErrorDto>'
'</ValidationErrors></Root>'),
HTTPError('400'), STRICT, 'xml')
except Exception as e:
# Exception for Python 2.6
print(e)
except HTTPError as e:
try:
self.assertEqual(e.message, '400')
except AttributeError as e:
# Exception for Python 3
print(e)
