def test_reboot(self, sleep_patch): device = MagicMock(spec=Cisco) device.log = MagicMock() sleep_patch = MagicMock() device.save_config = MagicMock() ################################################################### logging.info("Test case 1: Cannot save config. Reboot unsuccessfully") device.cli = MagicMock(return_value=Response(response='yes/no')) device.execute = MagicMock() result = IOS.reboot(device) self.assertFalse(result, "Result should be False") logging.info("\tPassed") ################################################################### logging.info("Test case 2: Reboot successfully") device.cli = MagicMock(return_value=Response(response='confirm')) device.execute = MagicMock() device.reconnect = MagicMock(return_value=True) result = IOS.reboot(device) self.assertTrue(result, "Result should be True") logging.info("\tPassed") ################################################################### logging.info("Test case 2: Reboot unsuccessfully") device.cli = MagicMock(return_value=Response(response='confirm')) device.execute = MagicMock() device.reconnect = MagicMock(return_value=False) result = IOS.reboot(device) self.assertFalse(result, "Result should be False") logging.info("\tPassed")
def test_unix_su_exception4(self): uobject = MagicMock(spec=UnixHost) uobject.execute = MagicMock(side_effect=(1, 1)) uobject.prompt = '$ ' uobject.set_prompt = MagicMock() uobject.name = 'foo' uobject.channels = [] # needed to raise TobyException # Exception uobject.shell.return_value.response.return_value.find.return_value = -1 try: UnixHost.su(uobject, password='******') except Exception as exp: self.assertEqual(exp.args[0], "Not able to switch to root user") # return True uobject.execute = MagicMock(side_effect=(1, 1)) uobject.shell.return_value.response.return_value.find.return_value = 1 uobject.get_su_credentials.return_value = ('root', 'Embe1mpls') uobject.shell.return_value.response.return_value = "root" self.assertTrue(UnixHost.su(uobject)) # Exception uobject.execute = MagicMock(side_effect=(-1, 1)) try: UnixHost.su(uobject) except Exception as exp: self.assertEqual(exp.args[0], "Not able to switch to root user") # Exception uobject.execute = MagicMock(side_effect=(-1, -1)) try: UnixHost.su(uobject) except Exception as exp: self.assertEqual(exp.args[0], "Not able to switch to root user")
def test_save_config(self): device = MagicMock(spec=Cisco) device.log = MagicMock() ################################################################### logging.info("Test case 1: save config successfully") device.cli = MagicMock(return_value=Response(response='')) device.execute = MagicMock( side_effect=['want to overwrite?', '[confirm]', '[OK]']) result = IOS.save_config(device, file='start') self.assertTrue(result, "Result should be True") logging.info("\tPassed") ################################################################### logging.info("Test case 2: Invalid file. save config unsuccessfully") device.cli = MagicMock(return_value=Response(response='')) device.execute = MagicMock( side_effect=['want to overwrite?', '[confirm]', '[OK]']) with self.assertRaises(Exception) as context: self.assertRaises(Exception, IOS.save_config(device)) logging.info("\tPassed") ################################################################### logging.info("Test case 3: save config successfully") device.cli = MagicMock(return_value=Response(response='')) device.execute = MagicMock(side_effect=['', '', '']) result = IOS.save_config(device, file='start') self.assertFalse(result, "Result should be False") logging.info("\tPassed")
def test_connect(self): from jnpr.toby.hldcl.brocade.brocade import Brocade device = MagicMock(spec=Brocade) device.host = 'test' device._connect = MagicMock(return_value=True) device.enable = MagicMock(return_value=True) device.log = MagicMock() device.execute = MagicMock(return_value='') Brocade.connect(device) device.execute = MagicMock(return_value='error') Brocade.connect(device)
def test_unix_su_user_password(self): uobject = MagicMock(spec=UnixHost) uobject.execute = MagicMock(return_value=1) uobject.prompt = '$ ' uobject.set_prompt = MagicMock uobject.shell.return_value.response.return_value = "root" self.assertTrue(UnixHost.su(uobject, password='******'))
def test_unix_set_prompt_expection2(self): uobject = MagicMock(spec=UnixHost) uobject.execute = MagicMock(return_value=1) uobject.prompt = MagicMock(return_value="TOBY") type(uobject).response = PropertyMock(side_effect=['vsh $']) self.assertRaises(Exception, lambda: UnixHost.set_prompt(uobject, prompt='TOBY'))
def _gen_ctx(self): _ctx = MagicMock() _graph_mock = MagicMock() _graph_mock.execute = MagicMock() _sequence = MagicMock() _sequence.add = MagicMock() _graph_mock._sequence = _sequence _graph_mock.sequence = MagicMock(return_value=_sequence) _node = MagicMock() _node.operations = { # deprecated calls 'cloudify.interfaces.lifecycle.suspend': {}, 'cloudify.interfaces.lifecycle.resume': {}, # upstream calls 'cloudify.interfaces.freeze.suspend': {}, 'cloudify.interfaces.freeze.resume': {}, } _instance = MagicMock() _instance.id = "correct_id" _instance.send_event = MagicMock(return_value='event') _instance.execute_operation = MagicMock( return_value='execute_operation') _node.properties = {} _node.instances = [_instance] _workflow_ctx = MagicMock() _workflow_ctx.nodes = [_node] _workflow_ctx.graph_mode = MagicMock(return_value=_graph_mock) _workflow_ctx.get_ctx = MagicMock(return_value=_ctx) return _workflow_ctx, _graph_mock, _instance
def test_unix_set_prompt_exception3(self): uobject = MagicMock(spec=UnixHost) uobject.execute = MagicMock() uobject.execute.side_effect = (1, -1) type(uobject).response = PropertyMock(side_effect=['csh $']) self.assertRaises(Exception, lambda: UnixHost.set_prompt(uobject, prompt='TOBY'))
def _setup(): global reconnect_handler, session_manager, session_list, path, kernel_id, kernel_manager,\ individual_kernel_manager, response_id, good_msg, client, spark_events # Mock kernel manager client = MagicMock() client.execute = MagicMock(return_value=response_id) client.get_shell_msg = MagicMock(return_value=good_msg) individual_kernel_manager = MagicMock() individual_kernel_manager.client = MagicMock(return_value=client) kernel_manager = MagicMock() kernel_manager.get_kernel = MagicMock( return_value=individual_kernel_manager) # Mock session manager session_list = [create_session_dict(path, kernel_id)] session_manager = MagicMock() session_manager.list_sessions = MagicMock(return_value=session_list) #Mock spark events spark_events = MagicMock() # Create mocked reconnect_handler ReconnectHandler.__bases__ = (SimpleObject, ) reconnect_handler = ReconnectHandler() reconnect_handler.spark_events = spark_events reconnect_handler.session_manager = session_manager reconnect_handler.kernel_manager = kernel_manager reconnect_handler.set_status = MagicMock() reconnect_handler.finish = MagicMock() reconnect_handler.get_body_argument = get_argument reconnect_handler.current_user = '******'
def test_set_wrongtag(discovery_mock: Any) -> NoReturn: service_mock = MagicMock() service_mock.projects = MagicMock(return_value=service_mock) service_mock.locations = MagicMock(return_value=service_mock) service_mock.services = MagicMock(return_value=service_mock) service_mock.get = MagicMock(return_value=service_mock) service_mock.execute = MagicMock( return_value=service_data(MOCK_SERVICE_NAME, [MOCK_PR_NUMBER])) discovery_mock.build = MagicMock(return_value=service_mock) invalid_pr = MOCK_PR_NUMBER + 1 # intentionally wrong response = runner.invoke( cli, [ "set", "--project-id", MOCK_PROJECT_ID, "--region", "us-central1", "--service", MOCK_SERVICE_NAME, "--repo-name", MOCK_REPO_NAME, "--commit-sha", MOCK_COMMIT_SHA, "--pull-request", invalid_pr, "--dry-run", ], ) print(response.output) assert response.exit_code == 1 assert "Error finding revision" in response.output assert f"pr-{invalid_pr}" in response.output
def test_unix_shell(self): uobject = MagicMock(spec=UnixHost) uobject.handle = MagicMock() uobject.execute = MagicMock(return_value=1) uobject.response = 'regress' uobject.shell_timeout = 60 self.assertIsInstance(UnixHost.shell(uobject, command='ls'), Response)
def test_extraction_with_single_result(self): # type: () -> None with patch.object(SQLAlchemyExtractor, '_get_connection') as mock_connection: connection = MagicMock() mock_connection.return_value = connection sql_execute = MagicMock() connection.execute = sql_execute table = {'schema': 'test_schema', 'name': 'test_table', 'description': 'a table for testing', 'cluster': self.conf['extractor.postgres_metadata.{}'.format(PostgresMetadataExtractor.CLUSTER_KEY)] } sql_execute.return_value = [ self._union( {'col_name': 'col_id1', 'col_type': 'bigint', 'col_description': 'description of id1', 'col_sort_order': 0}, table), self._union( {'col_name': 'col_id2', 'col_type': 'bigint', 'col_description': 'description of id2', 'col_sort_order': 1}, table), self._union( {'col_name': 'is_active', 'col_type': 'boolean', 'col_description': None, 'col_sort_order': 2}, table), self._union( {'col_name': 'source', 'col_type': 'varchar', 'col_description': 'description of source', 'col_sort_order': 3}, table), self._union( {'col_name': 'etl_created_at', 'col_type': 'timestamp', 'col_description': 'description of etl_created_at', 'col_sort_order': 4}, table), self._union( {'col_name': 'ds', 'col_type': 'varchar', 'col_description': None, 'col_sort_order': 5}, table) ] extractor = PostgresMetadataExtractor() extractor.init(self.conf) actual = extractor.extract() expected = TableMetadata('postgres', 'MY_CLUSTER', 'test_schema', 'test_table', 'a table for testing', [ColumnMetadata('col_id1', 'description of id1', 'bigint', 0), ColumnMetadata('col_id2', 'description of id2', 'bigint', 1), ColumnMetadata('is_active', None, 'boolean', 2), ColumnMetadata('source', 'description of source', 'varchar', 3), ColumnMetadata('etl_created_at', 'description of etl_created_at', 'timestamp', 4), ColumnMetadata('ds', None, 'varchar', 5)]) self.assertEqual(expected.__repr__(), actual.__repr__()) self.assertIsNone(extractor.extract())
def test_task_system_failure(): with TemporaryConfiguration(os.path.join( os.path.dirname(os.path.realpath(__file__)), '../../../common/configs/local.config'), internal_overrides={ 'image': 'myflyteimage:{}'.format( os.environ.get('IMAGE_VERSION', 'sha')), 'project': 'myflyteproject', 'domain': 'development' }): m = MagicMock() m.execute = _raise_system_exception with utils.AutoDeletingTempDir("test") as tmp: engine.FlyteTask(m).execute(None, {'output_prefix': tmp.name}) doc = errors.ErrorDocument.from_flyte_idl( utils.load_proto_from_file( errors_pb2.ErrorDocument, os.path.join(tmp.name, constants.ERROR_FILE_NAME))) assert doc.error.code == "SYSTEM:Unknown" assert doc.error.kind == errors.ContainerError.Kind.RECOVERABLE assert "errorERRORerror" in doc.error.message
def test_execute_query1(self): m_execute = Mock() expected = [(17, 22), (19, 24)] returns = [(17, 22), (19, 24), None] def foo(*args): r = returns.pop(0) return r m_fetchone = Mock(side_effect=foo) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchone = m_fetchone conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor zipped = zip( dbapi2_util.execute_query_iter( conn, "select * from somewhere" ), expected ) for x, y in zipped: eq_(x, y) eq_(conn.cursor.call_count, 1) eq_(m_cursor.execute.call_count, 1) m_cursor.execute.assert_called_once_with("select * from somewhere", None)
def _setup(): global reconnect_handler, session_manager, session_list, path, kernel_id, kernel_manager,\ individual_kernel_manager, response_id, good_msg, client, spark_events, request # Mock kernel manager client = MagicMock() client.execute = MagicMock(return_value=response_id) client.get_shell_msg = MagicMock(return_value=good_msg) individual_kernel_manager = MagicMock() individual_kernel_manager.client = MagicMock(return_value=client) kernel_manager = MagicMock() kernel_manager.get_kernel = MagicMock(return_value=individual_kernel_manager) # Mock session manager session_list = [create_session_dict(path, kernel_id)] session_manager = MagicMock() session_manager.list_sessions = MagicMock(return_value=session_list) # Mock spark events spark_events = MagicMock() # Mock request request = MagicMock() request.body = json.dumps({"path": path, "username": username, "password": password, "endpoint": endpoint}) # Create mocked reconnect_handler ReconnectHandler.__bases__ = (SimpleObject,) reconnect_handler = ReconnectHandler() reconnect_handler.spark_events = spark_events reconnect_handler.session_manager = session_manager reconnect_handler.kernel_manager = kernel_manager reconnect_handler.set_status = MagicMock() reconnect_handler.finish = MagicMock() reconnect_handler.current_user = '******' reconnect_handler.request = request
def test_get_all_user_valid_bookings_valid(self): db_helper = MagicMock() db_helper.connection = None db_helper.execute = MagicMock( return_value=[{ 'booking_id': 1, 'facility_id': '1', 'booking_name': 'booking_2', 'start_time': date(2021, 3, 12), 'end_time': date(2021, 4, 12), 'booked_by': 'test_user', }]) response = do_get_all_user_valid_bookings(db_helper) print(response) assert response == [{ 'bookingId': 1, 'facilityId': '1', 'text': 'booking_2', 'start': '2021/03/12 00:00', 'end': '2021/04/12 00:00', 'bookedBy': 'test_user', 'facilityName': None, 'facilityPax': None, 'facilityLevel': None, 'isMe': False }]
def _gen_ctx(self): _ctx = MagicMock() _graph_mock = MagicMock() _graph_mock.execute = MagicMock() _sequence = MagicMock() _sequence.add = MagicMock() _graph_mock._sequence = _sequence _graph_mock.sequence = MagicMock(return_value=_sequence) _node = MagicMock() _node.operations = { 'cloudify.interfaces.statistics.perfomance': {} } _instance = MagicMock() _instance.send_event = MagicMock( return_value='event') _instance.execute_operation = MagicMock( return_value='execute_operation') _node.properties = {} _node.instances = [_instance] _workflow_ctx = MagicMock() _workflow_ctx.nodes = [_node] _workflow_ctx.graph_mode = MagicMock(return_value=_graph_mock) _workflow_ctx.get_ctx = MagicMock(return_value=_ctx) return _workflow_ctx, _graph_mock, _instance
def _gen_ctx(self): _ctx = MagicMock() _graph_mock = MagicMock() _graph_mock.execute = MagicMock() _sequence = MagicMock() _sequence.add = MagicMock() _graph_mock._sequence = _sequence _graph_mock.sequence = MagicMock(return_value=_sequence) _node = MagicMock() _node.operations = { 'cloudify.interfaces.lifecycle.suspend': {}, 'cloudify.interfaces.lifecycle.resume': {} } _instance = MagicMock() _instance.send_event = MagicMock(return_value='event') _instance.execute_operation = MagicMock( return_value='execute_operation') _node.instances = [_instance] _workflow_ctx = MagicMock() _workflow_ctx.nodes = [_node] _workflow_ctx.graph_mode = MagicMock(return_value=_graph_mock) _workflow_ctx.get_ctx = MagicMock(return_value=_ctx) return _workflow_ctx, _graph_mock, _instance
def test_cli(self): from jnpr.toby.hldcl.cisco.cisco import Cisco, IOS device = MagicMock(spec=Cisco) device.log = MagicMock() device._switch_mode = MagicMock(return_value=True) device.execute = MagicMock(return_value=True) device.prompt = '#' ###################################################################### logging.info("Test case 1: execute cli successfully") result = IOS.cli(device, command='show version', pattern='#') self.assertIsInstance(result, Response, 'Should be string') logging.info("\tPassed") ###################################################################### logging.info( "Test case 2: Exception when executing cli without command") with self.assertRaises(Exception) as context: result = IOS.cli(device, command=None, pattern='#') self.assertRaises(Exception, result) logging.info("\tPassed") ###################################################################### logging.info("Test case 3: execute cli unsuccessfully") with self.assertRaises(Exception) as context: result = IOS.cli(device, command=111) self.assertRaises(Exception, result) logging.info("\tPassed")
def test_execute_query2(self): m_execute = Mock() expected = [] returns = [None] def foo(*args): r = returns.pop(0) return r m_fetchone = Mock(side_effect=foo) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchone = m_fetchone conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor zipped = zip( dbapi2_util.execute_query_iter(conn, "select * from somewhere"), expected) for x, y in zipped: assert x == y assert conn.cursor.call_count == 1 assert m_cursor.execute.call_count == 1 m_cursor.execute.assert_called_once_with("select * from somewhere", None)
def test_config(self): from jnpr.toby.hldcl.cisco.cisco import Cisco, IOS device = MagicMock(spec=Cisco) device.log = MagicMock() device._switch_mode = MagicMock(return_value=True) device.execute = MagicMock(return_value=True) device.detect_mode = MagicMock(return_value=True) device.prompt = '#' ###################################################################### logging.info("Test case 1: execute config with command_list is None") with self.assertRaises(Exception) as context: self.assertRaises(Exception, IOS.config( device, command_list=None, pattern='#')) logging.info("\tPassed") ###################################################################### logging.info( "Test case 2: execute config with command_list is not a list") with self.assertRaises(Exception) as context: self.assertRaises(Exception, IOS.config( device, command_list=111, pattern='#')) logging.info("\tPassed") ###################################################################### logging.info("Test case 3: execute config successfully") result = IOS.config(device, command_list=[ 'interface f0/1', 'no shut'], pattern='#') self.assertIsInstance(result, Response, 'Should be string') logging.info("\tPassed") ###################################################################### logging.info( "Test case 2: execute config with element in command_list is not a string") with self.assertRaises(Exception) as context: self.assertRaises(Exception, IOS.config( device, command_list=[111, 'abc'])) logging.info("\tPassed")
def test_disable_billing(discovery_mock, PROJECT_ID): PROJECT_ID = 'my-project' PROJECT_NAME = f'projects/{PROJECT_ID}' data = {"budgetAmount": 400, "costAmount": 500} pubsub_message = { "data": base64.b64encode(bytes(json.dumps(data), 'utf-8')), "attributes": {} } projects_mock = MagicMock() projects_mock.projects = MagicMock(return_value=projects_mock) projects_mock.getBillingInfo = MagicMock(return_value=projects_mock) projects_mock.updateBillingInfo = MagicMock(return_value=projects_mock) projects_mock.execute = MagicMock(return_value={'billingEnabled': True}) discovery_mock.build = MagicMock(return_value=projects_mock) main.stop_billing(pubsub_message, None) assert projects_mock.getBillingInfo.called_with(name=PROJECT_NAME) assert projects_mock.updateBillingInfo.called_with( name=PROJECT_NAME, body={'billingAccountName': ''}) assert projects_mock.execute.call_count == 2
def test_extraction(self) -> None: with patch.object(SQLAlchemyExtractor, '_get_connection') as mock_connection: connection = MagicMock() mock_connection.return_value = connection sql_execute = MagicMock() connection.execute = sql_execute sql_execute.return_value = [{ 'database': 'gold', 'schema': 'scm', 'name': 'foo', 'user_email': '*****@*****.**', 'read_count': 1 }] expected = TableColumnUsage(col_readers=[ ColumnReader(database='snowflake', cluster='gold', schema='scm', table='foo', column='*', user_email='*****@*****.**', read_count=1) ]) extractor = GenericUsageExtractor() extractor.init(self.conf) actual = extractor.extract() self.assertEqual(expected.__repr__(), actual.__repr__()) self.assertIsNone(extractor.extract())
def test_procedure(self): manager = MagicMock() manager.execute = MagicMock(return_value='expected') with self.assertRaises(TypeError): Procedure('wrong', manager) p = Procedure(F('sum'), manager) ast = p.to_ast() self.assertEqual( ast, { 'name': 'run', 'val': { 'name': 'func_sum', 'val': [] } } ) result = p() self.assertEqual(result, 'expected') manager.execute.assert_called_with( p.to_ast(), scope=[] )
def test_extraction_with_database_specified(self): # type: () -> None with patch.object(SQLAlchemyExtractor, '_get_connection') as mock_connection: connection = MagicMock() mock_connection.return_value = connection sql_execute = MagicMock() connection.execute = sql_execute sql_execute.return_value = [{ 'schema': 'test_schema', 'name': 'test_table', 'description': 'a table for testing', 'cluster': 'MY_CLUSTER', 'is_view': 'false', 'col_name': 'ds', 'col_type': 'varchar', 'col_description': None, 'col_sort_order': 0 }] extractor = SnowflakeMetadataExtractor() extractor.init(self.conf) actual = extractor.extract() expected = TableMetadata( self.database_key, 'MY_CLUSTER', 'test_schema', 'test_table', 'a table for testing', [ColumnMetadata('ds', None, 'varchar', 0)]) self.assertEqual(expected.__repr__(), actual.__repr__()) self.assertIsNone(extractor.extract())
def test_extraction_with_single_result(self) -> None: """ Test Extraction with default cluster and database and with one table as result """ with patch.object(SQLAlchemyExtractor, '_get_connection') as mock_connection: connection = MagicMock() mock_connection.return_value = connection sql_execute = MagicMock() connection.execute = sql_execute sql_execute.return_value = [{ 'schema': 'test_schema', 'table_name': 'test_table', 'last_updated_time': 1000, 'cluster': self.conf['extractor.snowflake_table_last_updated.{}'.format( SnowflakeTableLastUpdatedExtractor.CLUSTER_KEY)], }] extractor = SnowflakeTableLastUpdatedExtractor() extractor.init(self.conf) actual = extractor.extract() expected = TableLastUpdated(schema='test_schema', table_name='test_table', last_updated_time_epoch=1000, db='snowflake', cluster='MY_CLUSTER') self.assertEqual(expected.__repr__(), actual.__repr__()) self.assertIsNone(extractor.extract())
def test_extraction_with_database_specified(self) -> None: """ Test DATABASE_KEY in extractor result """ with patch.object(SQLAlchemyExtractor, '_get_connection') as mock_connection: connection = MagicMock() mock_connection.return_value = connection sql_execute = MagicMock() connection.execute = sql_execute sql_execute.return_value = [{ 'schema': 'test_schema', 'table_name': 'test_table', 'last_updated_time': 1000, 'cluster': 'MY_CLUSTER', }] extractor = SnowflakeTableLastUpdatedExtractor() extractor.init(self.conf) actual = extractor.extract() expected = TableLastUpdated(schema='test_schema', table_name='test_table', last_updated_time_epoch=1000, db=self.database_key, cluster='MY_CLUSTER') self.assertEqual(expected.__repr__(), actual.__repr__()) self.assertIsNone(extractor.extract())
def test_limit_use(discovery_mock, ZONE, PROJECT_ID): PROJECT_ID = 'my-project' PROJECT_NAME = f'projects/{PROJECT_ID}' ZONE = 'my-zone' data = {"budgetAmount": 400, "costAmount": 500} pubsub_message = { "data": base64.b64encode(bytes(json.dumps(data), 'utf-8')), "attributes": {} } instances_list = { "items": [{ "name": "instance-1", "status": "RUNNING" }, { "name": "instance-2", "status": "TERMINATED" }] } instances_mock = MagicMock() instances_mock.instances = MagicMock(return_value=instances_mock) instances_mock.list = MagicMock(return_value=instances_mock) instances_mock.stop = MagicMock(return_value=instances_mock) instances_mock.execute = MagicMock(return_value=instances_list) projects_mock = MagicMock() projects_mock.projects = MagicMock(return_value=projects_mock) projects_mock.getBillingInfo = MagicMock(return_value=projects_mock) projects_mock.execute = MagicMock(return_value={'billingEnabled': True}) def discovery_mocker(x, *args, **kwargs): if x == 'compute': return instances_mock else: return projects_mock discovery_mock.build = MagicMock(side_effect=discovery_mocker) main.limit_use(pubsub_message, None) assert projects_mock.getBillingInfo.called_with(name=PROJECT_NAME) assert instances_mock.list.calledWith(project=PROJECT_ID, zone=ZONE) assert instances_mock.stop.call_count == 1 assert instances_mock.execute.call_count == 2
def create_cmd(*args, **kwargs): cmd = MagicMock() def execute(*args, **kwargs): return test_outputs.pop() cmd.execute = MagicMock(side_effect=execute) return cmd
def test_unix_su_exception2(self): uobject = MagicMock(spec=UnixHost) uobject.execute = MagicMock() uobject.execute.side_effect = (1, -1) uobject.prompt = '$ ' uobject.get_su_credentials = MagicMock(return_value=('root', 'Embe1mpls')) self.assertRaises(Exception, lambda: UnixHost.su(uobject))
def test_insert_booking_valid(self): db_helper = MagicMock() db_helper.connection = None db_helper.execute = MagicMock(return_value=1) response = do_insert_booking(db_helper) assert response == 1
def test_insert_booking_invalid(self): db_helper = MagicMock() db_helper.connection = None db_helper.execute = MagicMock(side_effect=Exception('sample error')) response = do_insert_booking(db_helper) assert response is False
def test_get_all_user_valid_bookings_invalid(self): db_helper = MagicMock() db_helper.connection = None db_helper.execute = MagicMock(side_effect=Exception('sample_error')) response = do_get_all_user_valid_bookings(db_helper) assert response is False
def setUp(self): # instantiate broker for testing self.sommelier_broker = SommelierBroker() # create mock DB db = MagicMock() db.execute = MagicMock() db.fetch_all = MagicMock() db.fetch_one = MagicMock() # inject mock db into broker self.sommelier_broker.db = db
def SideEffect(customer, maxResults, pageToken, projection, orderBy): """Mock list function to return different mock execute calls.""" # pylint: disable=unused-argument # pylint: disable=invalid-name if pageToken == '': mock_execute.return_value = fake_dictionary_1 else: mock_execute.return_value = fake_dictionary_2 some_object = MagicMock() some_object.execute = mock_execute return some_object
def testNextTurn(self): from game import Game g = Game() #Create mock objects helpCommand = MagicMock() helpCommand.execute = MagicMock() g._parser.getNextCommand = MagicMock(return_value=helpCommand) g._nextTurn() self.assertTrue(helpCommand.execute.called, "Game._nextTurn() failed to execute command")
def SideEffect1(groupKey, pageToken=''): """Mock list function to return different mock execute calls.""" # pylint: disable=unused-argument # pylint: disable=invalid-name if pageToken == '': mock_execute.return_value = fake_dictionary_1 else: mock_execute.return_value = fake_dictionary_2 some_object = MagicMock() some_object.execute = mock_execute return some_object
def test_single_value_sql5(self): m_execute = Mock() m_fetchall = Mock(return_value=((17, 22),)) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchall = m_fetchall conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor dbapi2_util.single_row_sql(conn, "select 17, 22", (1, 2, 3)) eq_(conn.cursor.call_count, 1) eq_(m_cursor.execute.call_count, 1) m_cursor.execute.assert_called_once_with("select 17, 22", (1, 2, 3))
def test_single_value_sql2(self): m_execute = Mock() m_fetchall = Mock(return_value=((17,),)) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchall = m_fetchall conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor dbapi2_util.single_value_sql(conn, "select 17", (1, 2, 3)) assert conn.cursor.call_count == 1 assert m_cursor.execute.call_count == 1 m_cursor.execute.assert_called_once_with('select 17', (1, 2, 3))
def test_single_row_sql1(self): m_execute = Mock() m_fetchall = Mock(return_value=((17, 22),)) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchall = m_fetchall conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor r = dbapi2_util.single_row_sql(conn, "select 17, 22") assert r == (17, 22) assert conn.cursor.call_count == 1 assert m_cursor.execute.call_count == 1 m_cursor.execute.assert_called_once_with('select 17, 22', None)
def test_single_value_sql4(self): m_execute = Mock() m_fetchall = Mock(return_value=None) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchall = m_fetchall conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor with pytest.raises(dbapi2_util.SQLDidNotReturnSingleRow): dbapi2_util.single_row_sql(conn, 'select 17, 22', (1, 2, 3)) assert conn.cursor.call_count == 1 assert m_cursor.execute.call_count == 1 m_cursor.execute.assert_called_once_with("select 17, 22", (1, 2, 3))
def test_single_value_sql1(self): m_execute = Mock() m_fetchall = Mock(return_value=((17,),)) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchall = m_fetchall conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor r = dbapi2_util.single_value_sql(conn, "select 17") eq_(r, 17) eq_(conn.cursor.call_count, 1) eq_(m_cursor.execute.call_count, 1) m_cursor.execute.assert_called_once_with('select 17', None)
def test_single_value_sql4(self): m_execute = Mock() m_fetchall = Mock(return_value=None) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchall = m_fetchall conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor assert_raises(dbapi2_util.SQLDidNotReturnSingleRow, dbapi2_util.single_row_sql, conn, "select 17, 22", (1, 2, 3)) eq_(conn.cursor.call_count, 1) eq_(m_cursor.execute.call_count, 1) m_cursor.execute.assert_called_once_with("select 17, 22", (1, 2, 3))
def test_execute_no_results(self): m_execute = Mock() m_cursor = MagicMock() m_cursor.execute = m_execute conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor dbapi2_util.execute_no_results( conn, "insert into table (a, b, c) values (%s, %s, %s)", (1, 2, 3) ) eq_(conn.cursor.call_count, 1) eq_(m_cursor.execute.call_count, 1) m_cursor.execute.assert_called_once_with( "insert into table (a, b, c) values (%s, %s, %s)", (1, 2, 3) )
def test_execute_query2(self): m_execute = Mock() expected = [] returns = [None] def foo(*args): r = returns.pop(0) return r m_fetchone = Mock(side_effect=foo) m_cursor = MagicMock() m_cursor.execute = m_execute m_cursor.fetchone = m_fetchone conn = MagicMock() conn.cursor.return_value.__enter__.return_value = m_cursor zipped = zip(dbutil.execute_query_iter(conn, "select * from somewhere"), expected) for x, y in zipped: assert x == y assert conn.cursor.call_count == 1 assert m_cursor.execute.call_count == 1 m_cursor.execute.assert_called_once_with("select * from somewhere", None)
def test_pop(self): self.assertTrue(hasattr(self.queue, 'pop')) m = MagicMock() m.execute = MagicMock(return_value=[{}, 60]) self.queue.server.pipeline = MagicMock(return_value=m) self.assertEquals(self.queue.pop(), None)
def _setup(): global mock_spark_session, client mock_spark_session = MagicMock() mock_spark_session.execute = MagicMock(return_value=(True, "")) client = PandasLivyClientBase(mock_spark_session, 10)