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 create_cmd(*args, **kwargs):
cmd = MagicMock()
def execute(*args, **kwargs):
return test_outputs.pop()
cmd.execute = MagicMock(side_effect=execute)
return cmd
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)
