def _prepere_mocks(self):
logger = MagicMock()
api_configuration = MagicMock()
mock_api = MagicMock()
client_api = MagicMock()
def del_func(body, name, first):
return (body, name, first)
def read_func(name, first):
return (name, first)
def create_func(body, first):
mock = MagicMock()
mock.to_dict = MagicMock(return_value={
'body': body,
'first': first
})
return mock
client_api.delete = del_func
client_api.read = read_func
client_api.create = create_func
mock_api.api_client_version = MagicMock(return_value=client_api)
mock_api.api_payload_version = MagicMock(
return_value={'payload_param': 'payload_value'})
api_configuration.prepare_api = MagicMock(return_value=mock_api)
operation_mock = MagicMock()
operation_mock.execute = MagicMock(side_effect=ApiException())
mappingMock = MagicMock()
mappingMock.create = MagicMock()
mappingMock.create.payload = 'api_payload_version'
mappingMock.create.api = 'api_client_version'
mappingMock.create.method = 'create'
mappingMock.read = MagicMock()
mappingMock.read.api = 'api_client_version'
mappingMock.read.method = 'read'
mappingMock.delete = MagicMock()
mappingMock.delete.api = 'api_client_version'
mappingMock.delete.method = 'delete'
return CloudifyKubernetesClient(logger, api_configuration), mappingMock
def build_mock_response(http_code, content=None):
response = MagicMock()
response.getcode = MagicMock(return_value=http_code)
if content is not None:
response.read = MagicMock(
return_value=json.dumps(content).encode('utf-8'))
return response
def mock_tracks_response(uri):
def json_res():
return json_bytes
response = MagicMock()
response.read = json_res
return response
def __call__(self, module, url, data=None, headers=None, method=None,
use_proxy=True, force=False, last_mod_time=None, timeout=10,
use_gssapi=False, unix_socket=None, ca_path=None, cookies=None):
assert self.index < len(self.calls), 'Got more fetch_url calls than expected'
call = self.calls[self.index]
self.index += 1
# Validate call
assert method == call.method
if call.expected_url is not None:
assert url == call.expected_url, \
'Exepected URL does not match for fetch_url call'
if call.expected_headers:
self._validate_headers(call, headers)
if call.form_parse:
self._validate_form(call, data)
# Compose result
info = dict(status=call.status)
for k, v in call.headers.items():
info[k.lower()] = v
info.update(call.error_data)
res = object()
if call.body is not None:
res = MagicMock()
res.read = MagicMock(return_value=call.body)
return (res, info)
def mock_tracks_response(uri):
def json_res():
return json_bytes
response = MagicMock()
response.read = json_res
return response
def mock_tracks_response(uri):
def json_res():
return b'[{"kind":"track","id":1337,"title":"Foo","permalink":"foo","downloadable":true,"user":{"permalink":"user1"}, "original_format":"mp3"},{"kind":"track","id":1338,"title":"Bar","permalink":"bar","downloadable":true,"user":{"permalink":"user2"}, "original_format":"mp3"},{"kind":"track","id":1339,"title":"Baz","permalink":"baz","downloadable":true,"user":{"permalink":"user3"}, "original_format":"wav"}]'
response = MagicMock()
response.read = json_res
return response
def test_create_new_zero_length_file():
# check zero length files are special cased
new_file_url = ('https://files.osf.io/v1/resources/9zpcy/providers/' +
'osfstorage/foo123/')
store = Storage({})
store._new_file_url = new_file_url
store._put = MagicMock(return_value=FakeResponse(201, None))
fake_fp = MagicMock()
fake_fp.mode = 'rb'
if six.PY3:
fake_fp.peek = lambda: ''
if six.PY2:
fake_fp.read = lambda: ''
store.create_file('foo.txt', fake_fp)
store._put.assert_called_once_with(
new_file_url,
# this is the important check in
# this test
data=b'',
params={'name': 'foo.txt'})
assert fake_fp.call_count == 0
def test_createMarlinApplication(self):
from ILCDIRAC.Interfaces.API.NewInterface.Applications import Marlin
cpMock = Mock()
cpMock.read = Mock()
cpMock.get = self.mockConfig
parameter = Mock()
parameter.prodConfigFilename = 'filename'
parameter.dumpConfigFile = False
with patch(
"ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock)):
self.chain.loadParameters(parameter)
ret = self.chain.createMarlinApplication(300.0)
self.assertIsInstance(ret, Marlin)
self.assertEqual(ret.detectortype, 'myDetectorModel')
self.assertEqual(ret.steeringFile, 'clicReconstruction.xml')
self.assertEqual(self.chain.cliReco,
'--Config.Tracking=Tracked --Config.Overlay=300GeV ')
with patch(
"ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock)):
self.chain.loadParameters(parameter)
self.chain._flags._over = False
ret = self.chain.createMarlinApplication(300.0)
self.assertIsInstance(ret, Marlin)
self.assertEqual(ret.detectortype, 'myDetectorModel')
self.assertEqual(ret.steeringFile, 'clicReconstruction.xml')
self.assertEqual(self.chain.cliReco, '--Config.Tracking=Tracked')
def test_attach_file_no_extension(self):
msg = Message(to='me', text='hi')
err = 'requires an extension'
with patch(open_label, create=True) as mock_open:
mock_file = MagicMock(spec=file)
mock_file.read = lambda: 'x'
mock_open.return_value = mock_file
self.assertRaisesMessage(MessageError, err, msg.attach_file, 'bad')
def test_attach_file_no_extension(self):
msg = Message(to='me', text='hi')
err = 'requires an extension'
with patch(open_label, create=True) as mock_open:
mock_file = MagicMock(spec=file)
mock_file.read = lambda: 'x'
mock_open.return_value = mock_file
self.assertRaisesMessage(MessageError, err, msg.attach_file, 'bad')
def _http_open(req):
response = Mock(name="response")
response.read = lambda: self.mockReturnedHtmls[req.get_full_url()]
response.geturl = lambda: self.mockRedirectedUrls.get(
req.get_full_url()) or req.get_full_url()
response.info.return_value.dict = {
"content-type": "text/html; charset=ut8"
}
return response
def test_call(self):
ret = json.dumps( {u'ok':u'ok'} )
read = MagicMock()
read.read = MagicMock(return_value=ret)
u = '/testing'
with patch('urllib2.urlopen') as mock_method:
mock_method.return_value = read
request = ApiRequest('mm', ApcUrl(u))()
self.assertEquals(request, json.loads(ret))
def fake_get(url, stream):
raw = MagicMock()
src = io.BytesIO(file_content)
raw.read = src.read
res = FakeResponse(200, {})
res.raw = raw
res.headers = {}
return res
def test_call(self):
ret = json.dumps({'ok': 'ok'})
read = MagicMock()
read.read = MagicMock(return_value=ret)
read.info = MagicMock(return_value=ResponseInfo())
u = 'http://localhost/testing'
with patch('urllib.request.urlopen') as mock_method:
mock_method.return_value = read
request = ApiRequest('mm', ApcUrl(u))()
self.assertEqual(request, json.loads(ret))
def test_plugin_open_url_json(monkeypatch, return_value, accept_errors,
result):
response = MagicMock()
response.read = MagicMock(return_value=return_value[1]['body'])
robot.open_url = MagicMock(return_value=response)
plugin = MagicMock()
assert robot.plugin_open_url_json(plugin,
'https://foo/bar',
accept_errors=accept_errors) == result
def test_notify_webstream_data(self):
ret = json.dumps( {u'testing' : u'123' } )
rp = RequestProvider(self.cfg)
read = MagicMock()
read.read = MagicMock(return_value=ret)
with patch('urllib2.urlopen') as mock_method:
mock_method.return_value = read
response = rp.notify_webstream_data(media_id=123)
mock_method.called_once_with(media_id=123)
self.assertEquals(json.loads(ret), response)
def test_notify_webstream_data(self):
ret = json.dumps({u'testing': u'123'})
rp = RequestProvider(self.cfg)
read = MagicMock()
read.read = MagicMock(return_value=ret)
with patch('urllib2.urlopen') as mock_method:
mock_method.return_value = read
response = rp.notify_webstream_data(media_id=123)
mock_method.called_once_with(media_id=123)
self.assertEquals(json.loads(ret), response)
def test_read(self):
"""
Asserts that read runs when plugin is loaded
"""
fake_config = MagicMock()
collectd_plugin.INSTANCES = [fake_config]
fake_config.read = MagicMock()
collectd_plugin.read()
self.assertIsNotNone(collectd_plugin.CONFIGS)
self.assertTrue(fake_config.read.called)
collectd_plugin.INSTANCES = []
def test_plugin_open_url_json_fail_other_2(monkeypatch):
response = MagicMock()
response.read = MagicMock(side_effect=AttributeError('read'))
robot.open_url = MagicMock(side_effect=robot.HTTPError(
'https://foo/bar', 400, 'Error!', {}, response))
plugin = MagicMock()
with pytest.raises(robot.PluginException) as exc:
robot.plugin_open_url_json(plugin, 'https://foo/bar')
assert exc.value.error_message == 'Cannot retrieve content from https://foo/bar'
def test_read(self):
"""
Asserts that read runs when plugin is loaded
"""
fake_config = MagicMock()
collectd_plugin.INSTANCES = [fake_config]
fake_config.read = MagicMock()
collectd_plugin.read()
self.assertIsNotNone(collectd_plugin.CONFIGS)
self.assertTrue(fake_config.read.called)
collectd_plugin.INSTANCES = []
def fake_get(url, stream):
raw = MagicMock()
src = io.BytesIO(file_content)
raw.read = src.read
if url == web_url:
raise UnauthorizedException()
else:
res = FakeResponse(200, {})
res.raw = raw
res.headers = {'Content-Length': str(len(file_content))}
return res
def test_load_idp_metadata_raises_error_when_xml_is_incorrect(
self, urlopen_mock):
# Arrange
url = 'http://md.incommon.org/InCommon/metadata.xml'
incorrect_xml = fixtures.INCORRECT_XML
urlopen_response_mock = MagicMock()
urlopen_response_mock.read = MagicMock(return_value=incorrect_xml)
urlopen_mock.return_value = urlopen_response_mock
metadata_loader = SAMLMetadataLoader()
# Act
metadata_loader.load_idp_metadata(url)
def test_loadParameters(self):
parameter = Mock()
parameter.prodConfigFilename = None
parameter.dumpConfigFile = None
self.chain.loadParameters(parameter)
c = self.chain
cpMock = Mock()
cpMock.read = Mock()
cpMock.get = self.mockConfig
parameter.prodConfigFilename = 'filename'
with patch(
"ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock)):
c.loadParameters(parameter)
self.assertEqual(c.prodGroup, "myProdGroup")
self.assertEqual(c.detectorModel, "myDetectorModel")
self.assertEqual(c.prodIDs, [123, 456])
self.assertEqual(c.energies, [100, 200])
self.assertEqual(c.eventsPerJobs, [1000, 2000])
self.assertEqual(c.eventsInSplitFiles, [5000, 6000])
self.configDict['prodIDs'] = "123, 456, 789"
with patch( "ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock ) ), \
self.assertRaisesRegexp( AttributeError, "Lengths of Processes"):
c.loadParameters(parameter)
cpMock.has_option.return_value = False
with patch(
"ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock)):
c.loadParameters(parameter)
self.assertEqual(c.prodIDs, [1, 1])
self.assertEqual(c.cliReco, '--Config.Tracking=Tracked')
self.configDict['eventsInSplitFiles'] = "1000"
c._flags._spl = True
with patch( "ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock ) ), \
self.assertRaisesRegexp( AttributeError, "Length of eventsInSplitFiles"):
c.loadParameters(parameter)
parameter.prodConfigFilename = None
parameter.dumpConfigFile = True
with patch( "ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock ) ), \
self.assertRaisesRegexp( RuntimeError, ''):
c.loadParameters(parameter)
def test_init(self):
stream = MagicMock()
stream.__iter__ = MagicMock()
stream.__next__ = MagicMock()
stream.next = MagicMock()
os_stream = OpenstackStream(stream, size=1234)
self.assertEquals(os_stream.size, 1234)
self.assertEquals(os_stream.__len__(), 1234)
self.assertEquals(os_stream.read(), stream.read(size=None))
self.assertEquals(os_stream.__iter__(), stream.__iter__())
self.assertEquals(os_stream.__next__(), stream.__next__())
self.assertEquals(os_stream.next(), stream.__next__())
def test_init(self):
stream = MagicMock()
stream.__iter__ = MagicMock()
stream.__next__ = MagicMock()
stream.next = MagicMock()
os_stream = OpenstackStream(stream, size=1234)
self.assertEqual(os_stream.size, 1234)
self.assertEqual(os_stream.__len__(), 1234)
self.assertEqual(os_stream.read(), stream.read(size=None))
self.assertEqual(os_stream.__iter__(), stream.__iter__())
self.assertEqual(os_stream.__next__(), stream.__next__())
self.assertEqual(os_stream.next(), stream.__next__())
def __call__(self,
module,
url,
data=None,
headers=None,
method=None,
use_proxy=True,
force=False,
last_mod_time=None,
timeout=10,
use_gssapi=False,
unix_socket=None,
ca_path=None,
cookies=None):
'''
A call to ``fetch_url()``.
'''
assert self.index < len(
self.calls), 'Got more fetch_url calls than expected'
call = self.calls[self.index]
self.index += 1
# Validate call
_validate_call(
call,
method=method,
url=url,
headers=headers,
data=data,
timeout=timeout,
url_username=module.params.get('url_username'),
url_password=module.params.get('url_password'),
force_basic_auth=module.params.get('force_basic_auth'),
)
# Compose result
info = dict(status=call.status, url=url)
for k, v in call.headers.items():
info[k.lower()] = v
info.update(call.error_data)
if call.body is not None:
res = MagicMock()
res.read = MagicMock(return_value=call.body)
res.closed = False
elif call.error_data:
res = _ReadResponse()
if 'body' not in info:
info['body'] = b''
else:
res = object()
return (res, info)
def test_plugin_open_url_json_fail(monkeypatch, return_value, accept_errors,
result):
response = MagicMock()
response.read = MagicMock(return_value=return_value[1].get('body', ''))
robot.open_url = MagicMock(side_effect=robot.HTTPError(
'https://foo/bar', 400, 'Error!', {}, response))
plugin = MagicMock()
with pytest.raises(robot.PluginException) as exc:
robot.plugin_open_url_json(plugin,
'https://foo/bar',
accept_errors=accept_errors)
assert exc.value.error_message == result
def mock_open(mock=None, read_data=None):
if mock is None:
mock = MagicMock(spec=file_spec)
handle = MagicMock(spec=file_spec)
handle.write.return_value = None
fake_file = StringIO(read_data)
if read_data is None:
if hasattr(handle, '__enter__'):
handle.__enter__.return_value = handle
else:
if hasattr(handle, '__enter__'):
handle.__enter__.return_value = fake_file
handle.read = fake_file.read
mock.return_value = handle
return mock
def test_load_idp_metadata_correctly_loads_multiple_descriptors(
self, urlopen_mock):
# Arrange
url = 'http://md.incommon.org/InCommon/metadata.xml'
incorrect_xml = fixtures.CORRECT_MULTIPLE_IDPS_METADATA
urlopen_response_mock = MagicMock()
urlopen_response_mock.read = MagicMock(return_value=incorrect_xml)
urlopen_mock.return_value = urlopen_response_mock
metadata_loader = SAMLMetadataLoader()
# Act
xml_metadata = metadata_loader.load_idp_metadata(url)
# Assert
urlopen_mock.assert_called_with(url)
assert xml_metadata is not None
assert xml_metadata == fixtures.CORRECT_MULTIPLE_IDPS_METADATA
def cpMock():
"""Return a Mock for the ConfigParser."""
theCPMock = Mock()
theCPMock.thisConfigDict = dict(configDict())
def hasMock(*args, **kwargs): # pylint: disable=unused-argument
"""Mock the configparser.has_option function."""
return theCPMock.thisConfigDict.get(args[1])
def mockConfig(*args, **kwargs): # pylint: disable=unused-argument
"""Mock the configparser object."""
assert args[0] == theScript.PP
return theCPMock.thisConfigDict[args[1]]
theCPMock.read = Mock()
theCPMock.get = mockConfig
theCPMock.has_option = hasMock
return theCPMock
def test_should_unauthorize_child_resource_non_ajax_POST_requests_when_csrf_input_mismatch(self):
request = DummyRequest(['mails'])
request.method = 'POST'
request.addArg('csrftoken', 'some csrf token')
mock_content = MagicMock()
mock_content.read = MagicMock(return_value={})
request.content = mock_content
request.getCookie = MagicMock(return_value='mismatched csrf token')
d = self.web.get(request)
def assert_unauthorized(_):
self.assertEqual(401, request.responseCode)
self.assertEqual("Unauthorized!", request.written[0])
d.addCallback(assert_unauthorized)
return d
def test_load_idp_metadata_uses_incommon_metadata_service_by_default(
self, urlopen_mock):
# Arrange
url = None
incorrect_xml = fixtures.CORRECT_ONE_IDP_METADATA
urlopen_response_mock = MagicMock()
urlopen_response_mock.read = MagicMock(return_value=incorrect_xml)
urlopen_mock.return_value = urlopen_response_mock
metadata_loader = SAMLMetadataLoader()
# Act
xml_metadata = metadata_loader.load_idp_metadata(url)
# Assert
urlopen_mock.assert_called_with(
SAMLMetadataLoader.IN_COMMON_METADATA_SERVICE_URL)
assert xml_metadata is not None
assert xml_metadata == fixtures.CORRECT_ONE_IDP_METADATA
def test_should_unauthorize_child_resource_non_ajax_POST_requests_when_csrf_input_mismatch(self):
request = DummyRequest(['mails'])
request.method = 'POST'
request.addArg('csrftoken', 'some csrf token')
mock_content = MagicMock()
mock_content.read = MagicMock(return_value={})
request.content = mock_content
request.getCookie = MagicMock(return_value='mismatched csrf token')
d = self.web.get(request)
def assert_unauthorized(_):
self.assertEqual(401, request.responseCode)
self.assertEqual("Unauthorized!", request.written[0])
d.addCallback(assert_unauthorized)
return d
def test_createDDSimApplication(self):
from ILCDIRAC.Interfaces.API.NewInterface.Applications import DDSim
cpMock = Mock()
cpMock.read = Mock()
cpMock.get = self.mockConfig
parameter = Mock()
parameter.prodConfigFilename = 'filename'
parameter.dumpConfigFile = False
with patch( "ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock ) ), \
patch( "DIRAC.ConfigurationSystem.Client.Helpers.Operations.Operations",
new=Mock(return_value=self.opsMock ) ):
self.chain.loadParameters(parameter)
ret = self.chain.createDDSimApplication()
self.assertIsInstance(ret, DDSim)
self.assertEqual(ret.steeringFile, 'clic_steer.py')
def test_createOverlayApplication(self):
from ILCDIRAC.Interfaces.API.NewInterface.Applications import OverlayInput
cpMock = Mock()
cpMock.read = Mock()
cpMock.get = self.mockConfig
parameter = Mock()
parameter.prodConfigFilename = 'filename'
parameter.dumpConfigFile = False
with patch(
"ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock)):
self.chain.loadParameters(parameter)
ret = self.chain.createOverlayApplication(350)
self.assertIsInstance(ret, OverlayInput)
self.assertEqual(ret.machine, 'clic_opt')
with self.assertRaisesRegexp(RuntimeError, 'No overlay parameters'):
ret = self.chain.createOverlayApplication(355)
def test_createSplitApplication(self):
from ILCDIRAC.Interfaces.API.NewInterface.Applications import StdHepSplit
cpMock = Mock()
cpMock.read = Mock()
cpMock.get = self.mockConfig
parameter = Mock()
parameter.prodConfigFilename = 'filename'
parameter.dumpConfigFile = False
with patch(
"ILCDIRAC.ILCTransformationSystem.scripts.dirac-clic-make-productions.ConfigParser.SafeConfigParser",
new=Mock(return_value=cpMock)):
self.chain.loadParameters(parameter)
ret = self.chain.createSplitApplication(100, 1000, 'stdhep')
self.assertIsInstance(ret, StdHepSplit)
self.assertEqual(ret.datatype, 'gen')
self.assertEqual(ret.maxRead, 1000)
self.assertEqual(ret.numberOfEventsPerFile, 100)
def setUp(self):
self.gui = MagicMock(name="gui")
modules = {
'urllib': self.gui,
'urllib.request': self.gui.request,
'urllib.request.urlopen': self.gui.request.urlopen
}
uop = MagicMock(name="file")
self.gui.request.urlopen.return_value = (uop, 0, 0)
uop.read = MagicMock(name="data", return_value=WCONT)
self.module_patcher = patch.dict('sys.modules', modules)
self.module_patcher.start()
self.gui.__le__ = MagicMock(name="APPEND")
self.gui.svg = self.gui.svg.svg = self.gui
self.gui.side_effect = lambda *a, **k: self.gui
self.gui.g = MagicMock(name="gui_g")
self.gui.g.__le__ = MagicMock(name="APPENDG")
self.gui.g.side_effect = lambda *a, **k: self.gui.g
self.gui.document.__getitem__.return_value = self.gui
self.app = Impressious(self.gui)
Impressious.SLIDES = []
self.EV.x = self.EV.y = 42
def test_bz2_to_file_from_url(self):
m = mock_open()
de = Mock()
de.decompress = Mock(return_value=3)
in_file = MagicMock()
def foo(size):
if foo.count < 3:
foo.count += 1
return size
return None
foo.count = 0
in_file.read = foo
with patch.object(get_marc, 'BZ2Decompressor', de):
with patch.object(get_marc, 'open', m):
self.assertTrue(get_marc.get_bz2_from_file(in_file, 'name',
lambda x, y: True))
self.assertFalse(get_marc.get_bz2_from_file(
in_file, 'name', lambda x, y: False))
handle = m()
self.assertEqual(handle.write.call_count, 3)
def test_take_waveform():
device = MagicMock()
device.read = MagicMock()
device.read.side_effect = [
2, # POINTS
1, # XINCREMENT
0, # XORIGIN
2, # POINTS
1, # YINCREMENT
0, # YORIGIN
2, # POINTS
1, # YINCREMENT
0, # YORIGIN
]
device.read_raw = MagicMock()
device.read_raw.side_effect = [
b'#232\x00\x01\x00\x02\x00\x03\xfdW\xfd+\xfc\xd0\xfa\xef\xfc\x8b\xfbB\xfcB\xfe\x0b\xfcl\xfbi\xfeR\xfdC\xfc\x8f\n',
b'#232\x00\x10\x00\x20\x00\x30\xfdW\xfd+\xfc\xd0\xfa\xef\xfc\x8b\xfbB\xfcB\xfe\x0b\xfcl\xfbi\xfeR\xfdC\xfc\x8f\n',
]
(time_array, waveform) = _take_waveform(device, ['S1'])
eq_(waveform['S1'][0], 1)
eq_(waveform['S1'][1], 2)
def get_object(self, kwargs):
"""
This operation gets an object from s3. It retrieves the body of
the object or a part of the body specified by a range variable.
A MagicMock() class is used to transfer the body allowing it to
be read by a read() operation. The etags no matter if it is
a multipart download or not is invalid as it will have a dash
in the etags. So it is never compared during download. If the
session's connection_error flag is set, it will raise a
ConnectionError and reset the flag to False.
"""
bucket = kwargs['bucket']
key = kwargs['key']
response_data = {}
etag = ''
if bucket in self.session.s3:
body = self.session.s3[bucket][key]['Body']
if 'range' in kwargs:
str_range = kwargs['range']
str_range = str_range[6:]
range_components = str_range.split('-')
beginning = range_components[0]
end = range_components[1]
if end == '':
body = body[int(beginning):]
else:
body = body[int(beginning):(int(end) + 1)]
mock_response = MagicMock()
mock_response.read = MagicMock(return_value=body)
response_data['Body'] = mock_response
etag = self.session.s3[bucket][key]['ETag']
response_data['ETag'] = etag + '--'
else:
response_data['Errors'] = [{'Message': 'Bucket does not exist'}]
if self.session.connection_error:
self.session.connection_error = False
raise requests.ConnectionError
return FakeHttp(etag), response_data
def get_object(self, kwargs):
"""
This operation gets an object from s3. It retrieves the body of
the object or a part of the body specified by a range variable.
A MagicMock() class is used to transfer the body allowing it to
be read by a read() operation. The etags no matter if it is
a multipart download or not is invalid as it will have a dash
in the etags. So it is never compared during download. If the
session's connection_error flag is set, it will raise a
ConnectionError and reset the flag to False.
"""
bucket = kwargs['bucket']
key = kwargs['key']
response_data = {}
etag = ''
if bucket in self.session.s3:
body = self.session.s3[bucket][key]['Body']
if 'range' in kwargs:
str_range = kwargs['range']
str_range = str_range[6:]
range_components = str_range.split('-')
beginning = range_components[0]
end = range_components[1]
if end == '':
body = body[int(beginning):]
else:
body = body[int(beginning):(int(end) + 1)]
mock_response = MagicMock()
mock_response.read = MagicMock(return_value=body)
response_data['Body'] = mock_response
etag = self.session.s3[bucket][key]['ETag']
response_data['ETag'] = etag + '--'
else:
response_data['Errors'] = [{'Message': 'Bucket does not exist'}]
if self.session.connection_error:
self.session.connection_error = False
raise requests.ConnectionError
return FakeHttp(etag), response_data
def testMockFileOpen(self):
filename = MagicMock(spec=file, wraps=StringIO('test'))
with patch('__builtin__.open', return_value=filename):
filename = open('test.txt')
self.assertTrue(isinstance(filename, file))
self.assertEqual(filename.read(), 'test')
def get_mock_response(self, code=200, data="", chunksize=64):
response = MagicMock()
response.getcode.return_value = code
dataString = cStringIO.StringIO(data)
response.read = dataString.read
return response
def build_mock_response(http_code, content=None):
response = MagicMock()
response.getcode = MagicMock(return_value=http_code)
if content is not None:
response.read = MagicMock(return_value=json.dumps(content).encode('utf-8'))
return response
def _http_open(req):
response = Mock(name="response")
response.read = lambda: self.mockReturnedHtmls[req.get_full_url()]
response.geturl = lambda: self.mockRedirectedUrls.get(req.get_full_url()) or req.get_full_url()
response.info.return_value.dict = {"content-type":"text/html; charset=ut8"}
return response
def mock_nrrd():
mocked_nrrd = MagicMock()
mocked_nrrd.read = MagicMock(return_value=('mock_annotation_data',
'mock_annotation_image'))
return mocked_nrrd
def testMockFile(self):
filename = MagicMock(spec=file, wraps=StringIO('test'))
self.assertTrue(isinstance(filename, file))
self.assertEqual(filename.read(), 'test')
