def setUp(self):
self.cassette = cassette.Cassette(
TestCassette.cassette_name,
'json',
'w+'
)
r = Response()
r.status_code = 200
r.encoding = 'utf-8'
r.headers = CaseInsensitiveDict({'Content-Type': decode('foo')})
r.url = 'http://example.com'
cassette.add_urllib3_response({
'body': {
'string': decode('foo'),
'encoding': 'utf-8'
}
}, r)
self.response = r
r = Request()
r.method = 'GET'
r.url = 'http://example.com'
r.headers = {}
r.data = {'key': 'value'}
self.response.request = r.prepare()
self.response.request.headers.update(
{'User-Agent': 'betamax/test header'}
)
self.json = {
'request': {
'body': 'key=value',
'headers': {
'User-Agent': 'betamax/test header',
'Content-Length': '9',
'Content-Type': 'application/x-www-form-urlencoded',
},
'method': 'GET',
'uri': 'http://example.com/',
},
'response': {
'body': {
'string': decode('foo'),
'encoding': 'utf-8',
},
'headers': {'Content-Type': decode('foo')},
'status_code': 200,
'url': 'http://example.com',
},
'recorded_at': '2013-08-31T00:00:00',
}
self.date = datetime(2013, 8, 31)
self.cassette.save_interaction(self.response, self.response.request)
self.interaction = self.cassette.interactions[0]
self.interaction.recorded_at = self.date
def load(obj, dto=None, decode=None):
"""
Loads a serialised object back into native datatypes, and optionally
imports it back into the native NiFi DTO
Warning: Using this on objects not produced by this Package may have
unintended results! While efforts have been made to ensure that unsafe
loading is not possible, no stringent security testing has been completed.
Args:
obj (dict, list): The serialised object to import
dto (Optional [tuple{str, str}]): A Tuple describing the service and
object that should be constructed.
e.g. dto = ('registry', 'VersionedFlowSnapshot')
Returns: Either the loaded object in native Python datatypes, or the
constructed native datatype object
"""
assert isinstance(obj, (six.string_types, bytes))
assert dto is None or isinstance(dto, tuple)
assert decode is None or isinstance(decode, six.string_types)
# ensure object is standard json before reusing the api_client deserializer
# safe_load from ruamel.yaml as it doesn't accidentally convert str
# to unicode in py2. It also manages both json and yaml equally well
# Good explanation: https://stackoverflow.com/a/16373377/4717963
# Safe Load also helps prevent code injection
if decode:
if decode == 'base64':
prep_obj = base64.b64decode(obj)
else:
raise ValueError("Load's decode option only supports base64")
else:
prep_obj = obj
loaded_obj = ruamel.yaml.safe_load(prep_obj)
if dto:
assert dto[0] in ['cloudbreak']
assert isinstance(dto[1], six.string_types)
obj_as_json = dump(loaded_obj)
response = Response()
response.data = obj_as_json
api_clients = {
'cloudbreak': config.cb_config.api_client,
}
api_client = api_clients[dto[0]]
return api_client.deserialize(
response=response,
response_type=dto[1]
)
return loaded_obj
def setUp(self):
# Make a new serializer to test with
self.test_serializer = Serializer()
serializers.serializer_registry["test"] = self.test_serializer
# Instantiate the cassette to test with
self.cassette = cassette.Cassette(TestCassette.cassette_name, "test", record_mode="once")
# Create a new object to serialize
r = Response()
r.status_code = 200
r.reason = "OK"
r.encoding = "utf-8"
r.headers = CaseInsensitiveDict({"Content-Type": decode("foo")})
r.url = "http://example.com"
util.add_urllib3_response({"body": {"string": decode("foo"), "encoding": "utf-8"}}, r)
self.response = r
# Create an associated request
r = Request()
r.method = "GET"
r.url = "http://example.com"
r.headers = {}
r.data = {"key": "value"}
self.response.request = r.prepare()
self.response.request.headers.update({"User-Agent": "betamax/test header"})
# Expected serialized cassette data.
self.json = {
"request": {
"body": {"encoding": "utf-8", "string": "key=value"},
"headers": {
"User-Agent": ["betamax/test header"],
"Content-Length": ["9"],
"Content-Type": ["application/x-www-form-urlencoded"],
},
"method": "GET",
"uri": "http://example.com/",
},
"response": {
"body": {"string": decode("foo"), "encoding": "utf-8"},
"headers": {"Content-Type": [decode("foo")]},
"status": {"code": 200, "message": "OK"},
"url": "http://example.com",
},
"recorded_at": "2013-08-31T00:00:00",
}
self.date = datetime(2013, 8, 31)
self.cassette.save_interaction(self.response, self.response.request)
self.interaction = self.cassette.interactions[0]
self.interaction.recorded_at = self.date
def setUp(self):
# Make a new serializer to test with
self.test_serializer = Serializer()
serializers.serializer_registry['test'] = self.test_serializer
# Instantiate the cassette to test with
self.cassette = cassette.Cassette(TestCassette.cassette_name,
'test',
record_mode='once')
# Create a new object to serialize
r = Response()
r.status_code = 200
r.reason = 'OK'
r.encoding = 'utf-8'
r.headers = CaseInsensitiveDict({'Content-Type': decode('foo')})
r.url = 'http://example.com'
util.add_urllib3_response(
{'body': {
'string': decode('foo'),
'encoding': 'utf-8'
}}, r, HTTPHeaderDict({'Content-Type': decode('foo')}))
self.response = r
# Create an associated request
r = Request()
r.method = 'GET'
r.url = 'http://example.com'
r.headers = {}
r.data = {'key': 'value'}
self.response.request = r.prepare()
self.response.request.headers.update(
{'User-Agent': 'betamax/test header'})
# Expected serialized cassette data.
self.json = {
'request': {
'body': {
'encoding': 'utf-8',
'string': 'key=value',
},
'headers': {
'User-Agent': ['betamax/test header'],
'Content-Length': ['9'],
'Content-Type': ['application/x-www-form-urlencoded'],
},
'method': 'GET',
'uri': 'http://example.com/',
},
'response': {
'body': {
'string': decode('foo'),
'encoding': 'utf-8',
},
'headers': {
'Content-Type': [decode('foo')]
},
'status': {
'code': 200,
'message': 'OK'
},
'url': 'http://example.com',
},
'recorded_at': '2013-08-31T00:00:00',
}
self.date = datetime(2013, 8, 31)
self.cassette.save_interaction(self.response, self.response.request)
self.interaction = self.cassette.interactions[0]
def setUp(self):
# Make a new serializer to test with
self.test_serializer = Serializer()
serializers.serializer_registry['test'] = self.test_serializer
# Instantiate the cassette to test with
self.cassette = cassette.Cassette(
TestCassette.cassette_name,
'test',
record_mode='once'
)
# Create a new object to serialize
r = Response()
r.status_code = 200
r.reason = 'OK'
r.encoding = 'utf-8'
r.headers = CaseInsensitiveDict({'Content-Type': decode('foo')})
r.url = 'http://example.com'
util.add_urllib3_response({
'body': {
'string': decode('foo'),
'encoding': 'utf-8'
}
}, r, HTTPHeaderDict({'Content-Type': decode('foo')}))
self.response = r
# Create an associated request
r = Request()
r.method = 'GET'
r.url = 'http://example.com'
r.headers = {}
r.data = {'key': 'value'}
self.response.request = r.prepare()
self.response.request.headers.update(
{'User-Agent': 'betamax/test header'}
)
# Expected serialized cassette data.
self.json = {
'request': {
'body': {
'encoding': 'utf-8',
'string': 'key=value',
},
'headers': {
'User-Agent': ['betamax/test header'],
'Content-Length': ['9'],
'Content-Type': ['application/x-www-form-urlencoded'],
},
'method': 'GET',
'uri': 'http://example.com/',
},
'response': {
'body': {
'string': decode('foo'),
'encoding': 'utf-8',
},
'headers': {'Content-Type': [decode('foo')]},
'status': {'code': 200, 'message': 'OK'},
'url': 'http://example.com',
},
'recorded_at': '2013-08-31T00:00:00',
}
self.date = datetime(2013, 8, 31)
self.cassette.save_interaction(self.response, self.response.request)
self.interaction = self.cassette.interactions[0]
