def _fake_popen(self, stdout, stderr, sleeptime): def wait_stdout(self): import time for line in stdout.splitlines(): time.sleep(sleeptime) yield line def wait_stderr(self): import time for line in stderr.splitlines(): time.sleep(sleeptime) yield line m = Mock(spec=subprocess.Popen) sout = Mock() sout.read = stdout sout.__iter__ = wait_stdout serr = Mock() serr.read = stderr serr.__iter__ = wait_stderr m.return_value.stdout = sout m.return_value.stderr = serr return m
def _fake_popen( self, stdout, stderr, sleeptime ): def wait_stdout( self ): import time for line in stdout.splitlines(): time.sleep(sleeptime) yield line def wait_stderr( self ): import time for line in stderr.splitlines(): time.sleep(sleeptime) yield line m = Mock(spec=subprocess.Popen) sout = Mock() sout.read = stdout sout.__iter__ = wait_stdout serr = Mock() serr.read = stderr serr.__iter__ = wait_stderr m.return_value.stdout = sout m.return_value.stderr = serr return m
def sideEffect(filePath, _mode): mockFile = Mock() if filePath == masterChangeSetFilePath: mockFile.read = Mock(return_value=mockMasterYaml) else: self.assertEqual('migrations/include1.yml', filePath) mockFile.read = Mock(return_value=mockIncludedYaml) return mockFile
def side_effect(filePath, mode): mockFile = Mock() if filePath == masterChangeSetFilePath: mockFile.read = Mock(return_value=mockMasterYaml) else: self.assertEqual('migrations/include1.yml', filePath) mockFile.read = Mock(return_value=mockIncludedYaml) return mockFile
def test_run(self, mock_execute): # Ensure execute returns a sensible result result = Mock() result.read = Mock(return_value=json.dumps({'result': 'ok'})) mock_execute.return_value = result # Invoke run self.session.run('foo/bar') self.assertTrue(mock_execute.called) # Sanity check self.assertTrue(self.session.access_token is not None) # Verify call args args = mock_execute.call_args[0] self.assertEqual(args[0], 'foo/bar') self.assertEqual(args[1], None) self.assertTrue(args[2].has_key('User-Agent')) self.assertTrue(args[2].has_key('Authorization')) # Invoke run data = {'one': 1} headers = {'two': 2} self.session.run('foo/bar', data, headers) self.assertTrue(mock_execute.called) args = mock_execute.call_args[0] self.assertEqual(args[0], 'foo/bar') self.assertEqual(args[1], data) self.assertTrue(args[2].has_key('two')) # Unset asset_token and verify that the 'Authorization' # header is not added to the request. self.session.access_token = None self.session.auth = None self.session.run('foo/bar') self.assertTrue(mock_execute.called) args = mock_execute.call_args[0] self.assertFalse(args[2].has_key('Authorization')) # Verify that the run method will retry if execute returns # an expired_token response. result.read = Mock(return_value=json.dumps({'error': 'expired_token'})) mock_execute.return_value = result with patch.object(Session, 'renew_access_token') as mock_renew_access_token: self.session.run('foo/bar') self.assertTrue(mock_renew_access_token.called)
def test_load_data(self): cached = {"prod1": "Product 1", "prod2": "Product 2"} mock_file = Mock() mock_file.read = Mock(return_value=json.dumps(cached)) data = self.mgr._load_data(mock_file) self.assertEquals(data, cached)
def test_create_html_email(self, mock_urlopen): html = '''<html><body> <p>First paragraph</p> <p><img src='http://localhost/firstimage.jpg'></p> <p>Third paragraph</p> <p><img src='http://localhost/secondimage.jpg'></p> <p>Final paragraph</p> </body></html> ''' mini_jpeg = ( b'\xff\xd8\xff\xdb\x00C\x00\x03\x02\x02\x02\x02\x02\x03\x02\x02' b'\x02\x03\x03\x03\x03\x04\x06\x04\x04\x04\x04\x04\x08\x06\x06\x05' b'\x06\t\x08\n\n\t\x08\t\t\n\x0c\x0f\x0c\n\x0b\x0e' b'\x0b\t\t\r\x11\r\x0e\x0f\x10\x10\x11\x10\n\x0c\x12\x13' b'\x12\x10\x13\x0f\x10\x10\x10\xff\xc9\x00\x0b\x08\x00\x01\x00\x01' b'\x01\x01\x11\x00\xff\xcc\x00\x06\x00\x10\x10\x05\xff\xda\x00\x08' b'\x01\x01\x00\x00?\x00\xd2\xcf \xff\xd9') mock_httpresponse = Mock() mock_httpresponse.getheader = Mock() mock_httpresponse.read = Mock() mock_httpresponse.getheader.side_effect = ['image/jpeg', 'image/jpeg'] mock_httpresponse.read.side_effect = [mini_jpeg, mini_jpeg] mock_urlopen.return_value.__enter__.return_value = mock_httpresponse msg = create_html_mail('A test mail', html) msg.recipientlist = ('*****@*****.**',) msg.send() self.assertEquals(len(mail.outbox), 1, 'should have one message') msg = mail.outbox[0] self.assertEquals(msg.alternatives[0][1], 'text/html') self.assertEquals(len(msg.attachments), 2, 'has two attachments') soup = BeautifulSoup(msg.alternatives[0][0], 'lxml') for img in soup.findAll('img'): cid = img['src'].split(':')[1] att = self.find_attachment_by_content_id(msg, cid) self.assertIsNotNone(att, 'image tag has a matching attachment')
def test_crawl(): html =\ """<html> <head> <title>Python is fun!</title> </head> <body> <div>Python is similar to Ruby, but different.</div> </body> </html>""" response_mock = Mock(url="http://expanded_url.com") response_mock.read = Mock(return_value=html) urllib2.urlopen = Mock(return_value=response_mock) url = "http://a.com" input_queue = Mock() input_queue.get = Mock(return_value=url) output_queue = Queue() crawler = Crawler() crawler.crawl(input_queue, output_queue) expected_result = {'CONTENT': html, 'EXPANDED_URL': 'http://expanded_url.com', 'STATUS': 'OK', 'URL': 'http://a.com'} eq_(expected_result, output_queue.get())
def test_load_task(self, mock_messagebox): mock_messagebox.return_value = mock_messagebox customizer = MainWindowCustomizer(self.gui.get_main_window(), MagicMock()) customizer._load_new_task_from_definition = Mock() task_path = os.path.join(self.path, "file.gt") f = Mock() f.read.return_value = '[{"key": "value"}]' with patch('__builtin__.open') as mock_open: mock_open.return_value = f customizer._load_task(task_path) assert mock_open.called assert f.close.called assert not mock_messagebox.exec_.called assert customizer._load_new_task_from_definition.called def _raise(*_): raise Exception f.read = _raise customizer._load_new_task_from_definition.called = False with patch('__builtin__.open') as mock_open: mock_open.return_value = f customizer._load_task(task_path) assert mock_open.called assert f.close.called assert mock_messagebox.exec_.called assert not customizer._load_new_task_from_definition.called
def _mock_pkg_profile(packages, repo_file, enabled_modules): """ Turn a list of package objects into an RPMProfile object. """ dict_list = [] for pkg in packages: dict_list.append(pkg.to_dict()) mock_file = Mock() mock_file.read = Mock(return_value=json.dumps(dict_list)) mock_rpm_profile = RPMProfile(from_file=mock_file) mock_enabled_repos_profile = EnabledReposProfile(repo_file=repo_file) mock_module_profile = ModulesProfile() mock_module_profile.collect = Mock(return_value=enabled_modules) mock_profile = { "rpm": mock_rpm_profile, "enabled_repos": mock_enabled_repos_profile, "modulemd": mock_module_profile } return mock_profile
def test_not_validated_returned(self, mock_open): document = {} message = 'hello' key_path = '/etc/pki/pulp/consumer/server/rsa_pub.pem' key = RSA.load_key_bio(BIO.MemoryBuffer(RSA_KEY)) test_conf = {'server': {'rsa_pub': key_path}} self.plugin.pulp_conf.update(test_conf) mock_fp = Mock() mock_fp.read = Mock(return_value=RSA_PUB) mock_open.return_value = mock_fp # test try: patcher = patch('pulp.agent.gofer.pulpplugin.RSA') rsa = patcher.start() rsa.load_pub_key_bio.return_value.verify.return_value = False authenticator = self.plugin.Authenticator() self.assertRaises(ValidationFailed, authenticator.validate, document, message, key.sign(message)) finally: if patcher: patcher.stop() # validation mock_open.assert_called_with(key_path) mock_fp.close.assert_called_with()
def empty_sagemaker_session(): ims = Mock(name="sagemaker_session") ims.default_bucket = Mock(name="default_bucket", return_value=BUCKET_NAME) ims.sagemaker_runtime_client = Mock(name="sagemaker_runtime") ims.sagemaker_client.describe_endpoint = Mock(return_value=ENDPOINT_DESC) ims.sagemaker_client.describe_endpoint_config = Mock( return_value=ENDPOINT_CONFIG_DESC) ims.sagemaker_runtime_client.invoke_endpoint_async = Mock( name="invoke_endpoint_async", return_value={ "OutputLocation": ASYNC_OUTPUT_LOCATION, }, ) response_body = Mock("body") response_body.read = Mock("read", return_value=RETURN_VALUE) response_body.close = Mock("close", return_value=None) ims.s3_client = Mock(name="s3_client") ims.s3_client.get_object = Mock( name="get_object", return_value={"Body": response_body}, ) ims.s3_client.put_object = Mock(name="put_object") return ims
def context_sagemaker_session(summaries=True): ims = Mock(name="sagemaker_session") ims.sagemaker_client.describe_endpoint = Mock(return_value=ENDPOINT_DESC) ims.sagemaker_client.describe_endpoint_config = Mock( return_value=ENDPOINT_CONFIG_DESC) if summaries: ims.sagemaker_client.list_contexts = Mock( return_value={"ContextSummaries": [{ "ContextName": "bar" }]}) else: ims.sagemaker_client.list_contexts = Mock( return_value={"ContextSummaries": []}) ims.sagemaker_client.describe_context = Mock(return_value={ "ContextArn": "foo", "ContextName": "bar", }) response_body = Mock("body") response_body.read = Mock("read", return_value=json.dumps([RETURN_VALUE])) response_body.close = Mock("close", return_value=None) ims.sagemaker_runtime_client.invoke_endpoint = Mock( name="invoke_endpoint", return_value={ "Body": response_body, "ContentType": "application/json" }, ) return ims
def testFlickrWrapperGetUrls(self, mock_urlopen): response = {'photos': {'photo': [ {'id': 'id1', 'secret': 'secret1', 'server': 'server1', 'farm': 1}, {'id': 'id2', 'secret': 'secret2', 'server': 'server2', 'farm': 2} ]}} response = json.dumps(response) m = Mock() m.read = Mock(return_value=response) mock_urlopen.return_value = m api_key = 'key' tag = 'tag' wrapper = FlickrWrapper(api_key) result = wrapper.get_urls(tag) self.assertEqual(2, len(result)) self.assertTrue('farm1' in result[0]) self.assertTrue('id1' in result[0]) self.assertTrue('secret1' in result[0]) self.assertTrue('server1' in result[0]) self.assertTrue('farm2' in result[1]) self.assertTrue('id2' in result[1]) self.assertTrue('secret2' in result[1]) self.assertTrue('server2' in result[1])
def test_should_not_update_state_if_unaavailable(self): # Set app = NewrelicApp('1111','777') headers = {"X-Api-Key":'1111'} url ='/v2/applications/777.json' # Mocks connection_obj = Mock() response_obj = Mock() httplib.HTTPConnection = Mock(return_value=connection_obj) response_obj.status = 500 # Error response_obj.read = Mock(return_value='') connection_obj.connect = Mock() connection_obj.request = Mock() connection_obj.getresponse = Mock(return_value=response_obj) # Assertion app.update_state() connection_obj.connect.assert_called_once() connection_obj.request.assert_called_once_with('GET', url, '', headers) connection_obj.getresponse.assert_called_once() self.assertFalse(app.reachable)
def test_create_html_email(self, mock_urlopen): html = """<html><body> <p>First paragraph</p> <p><img src='http://localhost/firstimage.jpg'></p> <p>Third paragraph</p> <p><img src='http://localhost/secondimage.jpg'></p> <p>Final paragraph</p> </body></html> """ mini_jpeg = ( b"\xff\xd8\xff\xdb\x00C\x00\x03\x02\x02\x02\x02\x02\x03\x02\x02" b"\x02\x03\x03\x03\x03\x04\x06\x04\x04\x04\x04\x04\x08\x06\x06\x05" b"\x06\t\x08\n\n\t\x08\t\t\n\x0c\x0f\x0c\n\x0b\x0e" b"\x0b\t\t\r\x11\r\x0e\x0f\x10\x10\x11\x10\n\x0c\x12\x13" b"\x12\x10\x13\x0f\x10\x10\x10\xff\xc9\x00\x0b\x08\x00\x01\x00\x01" b"\x01\x01\x11\x00\xff\xcc\x00\x06\x00\x10\x10\x05\xff\xda\x00\x08" b"\x01\x01\x00\x00?\x00\xd2\xcf \xff\xd9") mock_httpresponse = Mock() mock_httpresponse.getheader = Mock() mock_httpresponse.read = Mock() mock_httpresponse.getheader.side_effect = ["image/jpeg", "image/jpeg"] mock_httpresponse.read.side_effect = [mini_jpeg, mini_jpeg] mock_urlopen.return_value.__enter__.return_value = mock_httpresponse msg = create_html_mail("A test mail", html) msg.recipientlist = ("*****@*****.**", ) msg.send() self.assertEqual(len(mail.outbox), 1, "should have one message") msg = mail.outbox[0] self.assertEqual(msg.alternatives[0][1], "text/html") self.assertEqual(len(msg.attachments), 2, "has two attachments") soup = BeautifulSoup(msg.alternatives[0][0], "lxml") for img in soup.findAll("img"): cid = img["src"].split(":")[1] att = self.find_attachment_by_content_id(msg, cid) self.assertIsNotNone(att, "image tag has a matching attachment")
def test_retrieve_of_json_data_from_api(self): json_response = json.dumps({"steps": ["step 1", "step 2"]}) response_mock = Mock() response_mock.read = Mock(return_value=json_response) self.cache.get_authorized_response = Mock(return_value=response_mock) self.assertListEqual(self.cache.get_steps_information(), ["step 1", "step 2"])
def test_load_data(self): cached = {'prod1': 'Product 1', 'prod2': 'Product 2'} mock_file = Mock() mock_file.read = Mock(return_value=json.dumps(cached)) data = self.mgr._load_data(mock_file) self.assertEquals(data, cached)
def setUp(self): self.memory_map = {0: bytearray([0, 1])} def _read(addresses): data_ = {} for address in addresses: data_[address] = self.memory_map[ address.page][address.offset:address.offset + address.length] return data_ def _write(data_map): for address, data_ in data_map.items(): for index, data_byte in enumerate(data_): self.memory_map[address.page][address.offset + index] = data_byte memory_file_mock = Mock(MemoryFile) memory_file_mock.read = _read memory_file_mock.write = _write SetUpTestInjections( memory_files={MemoryTypes.EEPROM: memory_file_mock}) # Remove read-only flags from device_type for testing purposes below if hasattr(OutputModuleConfiguration, '_device_type'): OutputModuleConfiguration._device_type._read_only = False else: OutputModuleConfiguration.device_type._read_only = False
def empty_s3_client(): s3_client = Mock(name="s3-client") client_other_error = ClientError( error_response={ "Error": { "Code": "SomeOtherError", "Message": "some-error-message" } }, operation_name="client-other-error", ) client_error = ClientError( error_response={"Error": { "Code": "NoSuchKey" }}, operation_name="async-inference-response-test", ) response_body = Mock("body") response_body.read = Mock("read", return_value=RETURN_VALUE) response_body.close = Mock("close", return_value=None) s3_client.get_object = Mock( name="get_object", side_effect=[ client_other_error, client_error, { "Body": response_body } ], ) return s3_client
def test_not_validated_returned(self, mock_open): document = {} message = 'hello' key_path = '/etc/pki/pulp/consumer/server/rsa_pub.pem' key = RSA.load_key_bio(BIO.MemoryBuffer(RSA_KEY)) test_conf = {'server': {'rsa_pub': key_path}} self.plugin.pulp_conf.update(test_conf) mock_fp = Mock() mock_fp.read = Mock(return_value=RSA_PUB) mock_open.return_value = mock_fp # test try: patcher = patch('pulp.agent.gofer.pulpplugin.RSA') rsa = patcher.start() rsa.load_pub_key_bio.return_value.verify.return_value = False authenticator = self.plugin.Authenticator() self.assertRaises( ValidationFailed, authenticator.validate, document, message, key.sign(message)) finally: if patcher: patcher.stop() # validation mock_open.assert_called_with(key_path) mock_fp.close.assert_called_with()
def create_file_context_manager(*args, **kwargs): path = args[0] file_mock = Mock() file_mock.read = Mock(return_value=file_map[path]) cm = Mock() cm.__enter__ = Mock(return_value=file_mock) cm.__exit__ = Mock() return cm
def test_getNode(self): """ @return: """ uri = "vos://foo.com!vospace/bar" nodes = (' <vos:nodes>\n' '<vos:node uri="vos://cadc.nrc.ca!vospace/mydir/file123" ' 'xs:type="vos:DataNode">\n' ' <vos:properties>\n' ' <vos:property ' 'uri="ivo://ivoa.net/vospace/core#date">2016-05-10T09:52:13' '</vos:property>\n' ' </vos:properties>\n' '</vos:node>\n' '<vos:node uri="vos://cadc.nrc.ca!vospace/mydir/file456" ' 'xs:type="vos:DataNode">\n' ' <vos:properties>\n' ' <vos:property uri="ivo://ivoa.net/vospace/core#date">' '2016-05-19T09:52:14</vos:property>\n' ' </vos:properties>\n' '</vos:node>\n' '</vos:nodes>\n') mock_vofile = Mock() client = Client() client.open = Mock(return_value=mock_vofile) mock_vofile.read = Mock( return_value=NODE_XML.format(uri, '').encode('UTF-8')) my_node = client.get_node(uri, limit=0, force=False) self.assertEqual(uri, my_node.uri) self.assertEqual(len(my_node.node_list), 0) mock_vofile.read = Mock( return_value=NODE_XML.format(uri, nodes).encode('UTF-8')) my_node = client.get_node(uri, limit=2, force=True) self.assertEqual(uri, my_node.uri) self.assertEqual(len(my_node.node_list), 2) my_node = client.get_node(uri, limit=2, force=False) self.assertEqual(uri, my_node.uri) self.assertEqual(len(my_node.node_list), 2)
def test_raise_error_with_no_data(self): response = Mock() response.status = 400 response.reason = 'Bad Request' response.getheader = Mock(return_value='') response.read = Mock(return_value='') con = Urllib3HttpConnection() self.assertRaises(BadRequestError, con._raise_error, response)
def test_command_fails_and_the_execution_does_not_stop(self): error_mocked = Mock() error_mocked.read = Mock(return_value='test') ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked)) ssh_lib_mocked.close = Mock(return_value=True) assert 'test ' == SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def empty_sagemaker_session(): ims = Mock(name='sagemaker_session') ims.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME) ims.sagemaker_runtime_client = Mock(name='sagemaker_runtime') response_body = Mock('body') response_body.read = Mock('read', return_value=RETURN_VALUE) response_body.close = Mock('close', return_value=None) ims.sagemaker_runtime_client.invoke_endpoint = Mock(name='invoke_endpoint', return_value={'Body': response_body}) return ims
def test_get_export(self): m = Mock() m.read = Mock(return_value='{"foo": "bar"}') self.client._api.get_export = Mock(return_value={'body': m}) eq_(self.client.get_export(None, 'baz'), {}) eq_(self.client.get_export('baz', 'qux'), {'foo': 'bar'}) self.client._api.get_export = Mock( side_effect=botocore.exceptions.ClientError({'Error': {}}, 'bar')) eq_(self.client.get_export('baz', 'qux'), {})
def test_call_helper(self, transport): getresponse_mock = Mock() transport.return_value = getresponse_mock read_mock = Mock() read_mock.read = Mock(return_value='data!') getresponse_mock.getresponse = Mock(return_value=read_mock) s = HttpLibHttpService('host', 42, 'path') r = s._call('body', {}) self.assertIsInstance(r, tuple) self.assertEqual(len(r), 3)
def _dummy_send(*args, **kwargs): dummy_response = Mock() dummy_response.headers = {} dummy_response.getheaders = Mock(return_value={}) dummy_response.status = status_code dummy_response.read = Mock(return_value=response_body) dummy_response.request = args[0] dummy_response.cookies = {} _dummy_send.call_args = (args, kwargs) return dummy_response
def test_load_data(self): cached = { 'prod1': 'Product 1', 'prod2': 'Product 2' } mock_file = Mock() mock_file.read = Mock(return_value=json.dumps(cached)) data = self.mgr._load_data(mock_file) self.assertEquals(data, cached)
def test_print_debug_info(self, m_isfile, m_isdir, m_popen, m_open): m_isfile.return_value = True m_isdir.return_value = True m_popen.return_value = Mock() cmdline = Mock() cmdline.find = Mock(return_value=0) m1 = Mock() m2 = Mock() m2.read = Mock(return_value=cmdline) m_open.side_effect = [m1, m2] ls.print_debug_info("the_job", "job/dir", "some/archive/dir")
def test_load_s3_schema(self): mocked_json = '{"survey": "some_survey"}' mocked_connection = Mock() with patch('boto3.resource', Mock(return_value=mocked_connection)): mocked_file = Mock() mocked_file.read = Mock(return_value=mocked_json.encode()) mocked_object = Mock() mocked_connection.Object = Mock(return_value=mocked_object) mocked_object.get.return_value = {"Body": mocked_file} self.assertEqual(json.loads(mocked_json), load_s3_schema_file("ignored_filename.json"))
def test_receive_state(self): mi = Mock() mi.read = self.response interface = StateInterface(mi) device = InterfaceDevice(address=None, devices=interface, initial_state=State.UNKNOWN) self.assertEqual(device.state, State.UNKNOWN) self._response = State.ON time.sleep(2) self.assertEqual(device.state, State.ON)
def test_request_metrics(self, mock_rest_request): data = {"key1": "value1", "key2": "value2"} mock_rest_request_response = Mock() mock_read = Mock() mock_read.return_value = json.dumps(data) mock_rest_request_response.read = mock_read mock_rest_request.return_value = mock_rest_request_response expected_response = data actual_response = self.agent.request_metrics("http://host", "/path") self.assertDictEqual(actual_response, expected_response)
def test_exec_command_and_wait_input_lines_scoket_timeout(self): yum_cmd = "yum clean all" configurator = ssh_utilities.RemoteConnection(self.hostname, self.user, self.passwd, ssh_client=self.ssh_client) stdout = Mock() stdout.channel.recv_exit_status = Mock(return_value=1) stdout.read = Mock(side_effect=socket.timeout) self.ssh_client.exec_command.return_value = (Mock(), stdout, Mock()) self.assertRaises(socket.timeout, configurator.exec_command_and_wait, yum_cmd, input_lines="tee my.log")
def ret_csv_sagemaker_session(): ims = Mock(name='sagemaker_session') ims.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME) ims.sagemaker_runtime_client = Mock(name='sagemaker_runtime') response_body = Mock('body') response_body.read = Mock('read', return_value=CSV_RETURN_VALUE) response_body.close = Mock('close', return_value=None) ims.sagemaker_runtime_client.invoke_endpoint = Mock(name='invoke_endpoint', return_value={'Body': response_body, 'ContentType': CSV_CONTENT_TYPE}) return ims
class TestAPI(unittest.TestCase): def setUp(self): mapper = Mock() self.db = Mock() self.input = Mock() self.input.read.return_value = b'{"name":"test","period":1800}' self.req = { "CONTENT_TYPE": "application/json", "CONTENT_LENGTH": len(self.input.read()), "wsgi.input": self.input, } self.res = Mock() fuse.api.log = Mock() self.api = fuse.api.APIWrapper(config, self.db, mapper)
def test_exec_command_and_wait_input_lines(self): yum_cmd = "yum clean all" configurator = ssh_utilities.RemoteConnection(self.hostname, self.user, self.passwd, ssh_client=self.ssh_client) stdout = Mock() stdout.channel.recv_exit_status = Mock(return_value=1) stdout.read = Mock(return_value="validoutput") self.ssh_client.exec_command.return_value = (Mock(), stdout, Mock()) exit_code, stdout_data, stderr_data = configurator.\ exec_command_and_wait(yum_cmd, input_lines="tee my.log") self.assertEquals(stdout_data, "validoutput")
def test_exec_command_and_wait_raise_on_exit(self): yum_cmd = "yum clean all" configurator = ssh_utilities.RemoteConnection(self.hostname, self.user, self.passwd, ssh_client=self.ssh_client) stdout = Mock() stdout.channel.recv_exit_status = Mock(return_value=1) stdout.read = Mock(return_value="error") self.ssh_client.exec_command.return_value = (Mock(), stdout, Mock()) self.assertRaises(Exception, configurator.exec_command_and_wait, yum_cmd, input_lines="tee my.log", raise_on_exit_not_0=True)
def _set_up_mock_httplib(self, desired_response): mock_file = Mock() mock_file.read = Mock(return_value=desired_response) mock_r = Mock() mock_getresponse = Mock(return_value=mock_file) mock_r.getresponse = mock_getresponse mock_httplib = Mock(spec=httplib) mock_httplib.HTTPSConnection = Mock(return_value=mock_r) return mock_httplib
def test_delete_shell_shell_not_found_raises_error(self, mock_delete, mock_build_opener): # Arrange mock_url = Mock() mock_url.read = Mock(return_value='TOKEN') mock_opener = Mock() mock_opener.open = Mock(return_value=mock_url) mock_build_opener.return_value = mock_opener mock_delete.return_value = Response() mock_delete.return_value.status_code = 400 # Bad Request # Act Assert client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global') self.assertRaises(ShellNotFoundException, client.delete_shell, 'shell')
def test_login(self, mock_build_opener): # Arrange mock_url = Mock() mock_url.read = Mock(return_value='TOKEN') mock_opener = Mock() mock_opener.open = Mock(return_value=mock_url) mock_build_opener.return_value = mock_opener # Act PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global') # Assert self.assertTrue(mock_opener.open.called, 'open should be called')
def test_command_fails_and_execution_is_stopped(self): error_mocked = Mock() error_mocked.read = Mock(return_value='test') ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked)) ssh_lib_mocked.close = Mock(return_value=True) with pytest.raises(RuntimeError) as runtime_error: SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test', True) assert 'test' == str(runtime_error.value)
def test_load_data(self): cached = { 'pools': { 'pool1': 'Pool 1', 'pool2': 'Pool 2' }, 'tags': ['p1', 'p2'] } mock_file = Mock() mock_file.read = Mock(return_value=json.dumps(cached)) data = self.pool_status_cache._load_data(mock_file) self.assertEqual(data, cached)
def test_command_fails_and_the_execution_does_not_stop(self): error_mocked = Mock() error_mocked.read = Mock(return_value='test') ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked)) ssh_lib_mocked.close = Mock(return_value=True) assert 'test ' == SSHClient( ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def _mock_pkg_profile(packages): """ Turn a list of package objects into an RPMProfile object. """ dict_list = [] for pkg in packages: dict_list.append(pkg.to_dict()) mock_file = Mock() mock_file.read = Mock(return_value=json.dumps(dict_list)) mock_profile = RPMProfile(from_file=mock_file) return mock_profile
def test_return_value(monkeypatch): """ Check the return value of doWebRequest. """ # Setup the mocks. response = Mock() response.read.return_value = 'test content' mock_urlopen = Mock(return_value=response) # Patch urlopen so that we do not make an http request. monkeypatch.setattr('urllib2.urlopen', mock_urlopen) return_value = util.doWebRequest('http://exmple.com/foo/bar') assert return_value == (response, response.read())
def test_loadFile(self, file_mock): rp_name = 'reportName' full_rp_path = '/path/to/test_zp/Reports/SomeReports/reportName.rpt' report_txt = "some report data" #mock build in file method and its instance read method file_read = Mock() file_read.read = Mock(return_value=report_txt) file_mock.return_value = file_read root = Mock() root._setObject = Mock() rp = self.rp_load.loadFile(root, rp_name, full_rp_path) self.assertIsInstance(rp, Report) self.assertEqual(rp.id, rp_name) root._setObject.assert_called_once_with(rp_name, rp)
def test_call_paypal(self, urllib2_mock): mixin = PayPalFormMixin() response_mock = Mock() response_mock.read = Mock(return_value=self.paypal_response) urllib2_mock.urlopen.return_value = response_mock response = mixin.call_paypal(API_URL, {}) self.assertEqual(response['ACK'], ['Success'], msg=( 'Should parse the response from paypal and return it as a dict')) with patch.object(mixin, 'log_error') as log_error_mock: urllib2_mock.urlopen = PropertyMock(side_effect=HTTPException) mixin.call_paypal(API_URL, {}) self.assertEqual(log_error_mock.call_count, 1, msg=( 'Should log an error if calling the PayPal API fails.'))
def _irregular_reader(self, items): def item_read(read_length): try: item = items.pop(0) except IndexError: # If no more items, the buffer is empty and would return empty string return '' return item.read(read_length) mock_fh = Mock() mock_fh.read = Mock() mock_fh.read.side_effect = item_read return mock_fh
def test_load(self, mock_open): mock_fp = Mock() mock_fp.read = Mock(return_value=RSA_KEY) mock_fp.__enter__ = Mock(return_value=mock_fp) mock_fp.__exit__ = Mock() mock_open.return_value = mock_fp # test authenticator = Authenticator() authenticator.load() # validation self.assertTrue(mock_fp.__exit__.called) self.assertTrue(isinstance(authenticator.rsa_key, RSA.RSA))
def setUpResponse(self, headers, body, status_code=200): if not headers: headers = {'Content-Type': 'application/json'} def decode_content(): pass response = Response() response.status_code = status_code response.headers = headers stream = Mock() stream.read = Mock() stream.read.side_effect = [body, None] response.raw = stream return response