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 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 _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 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_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 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')