def setUp(self, mocked_settings=None):
# this is run once per test-method
kwargs = {'event': None, 'id': None, 'group': None}
# THIS OR GET SETTING, or even better, get timezone...
#from scheduler.base import SchedulerEventFactory
#SchedulerEventFactory.Setting = MockSettings
#from scheduler.base.SchedulerEventFactory import TimeCondition
#TimeCondition.Settings = MagicMock
TimeCondition.getSettings = lambda dummy: MockSettings(self.
usertimezone)
self.timeCondition = TimeCondition(**kwargs)
TimeTrigger.getSettings = lambda dummy: MockSettings(self.usertimezone)
mockEvent = Mock()
mockEvent.execute = Mock()
kwargs = {
'params': {
'minute': '0',
'hour': '11'
},
'event': mockEvent,
'id': 833
}
self.timeTrigger = TimeTrigger(TimeTriggerManager(False), **kwargs)
mockEvent = Mock()
mockEvent.execute = Mock()
# 'params': {'sunStatus': '1', 'offset': '0'},
kwargs = {'event': mockEvent, 'id': 833}
self.sunTimeTrigger = ModifiedSuntimeTrigger(55.70584, 13.19321,
TimeTriggerManager(False),
**kwargs)
kwargs['group'] = None
self.sunTimeCondition = ModifiedSuntimeCondition(
55.70584, 13.19321, **kwargs)
def test_get_tables_info_when_no_table_list_is_provided(self):
mocked_table_list_query_cursor = Mock()
mocked_table_list_query_cursor.execute = Mock(return_value=True)
mocked_table_list_query_cursor.fetchall = Mock(return_value=[['unit'], ['test']])
mocked_table_count_query_cursor = Mock()
mocked_table_count_query_cursor.execute = Mock(return_value=True)
mocked_table_count_query_cursor.fetchone = Mock(return_value=[10])
columns = {
'table_name': '',
'column_name': 'column',
'data_type': 'string',
'character_maximum_length': '1',
'is_nullable': 'NO',
'column_default': ''
}
tables_columns = []
columns.update(table_name='unit')
tables_columns.append(columns.copy())
columns.update(table_name='test')
tables_columns.append(columns.copy())
mocked_table_columns_query_cursor = Mock()
mocked_table_columns_query_cursor.execute = Mock(return_value=True)
mocked_table_columns_query_cursor.fetchall = Mock(return_value=tables_columns)
mocked_table_collation_query_cursor = Mock()
mocked_table_collation_query_cursor.execute = Mock(return_value=True)
mocked_table_collation_query_cursor.fetchone = Mock(return_value=['en_US.UTF-8'])
mocked_table_top_query_cursor = Mock()
mocked_table_top_query_cursor.execute = Mock(return_value=True)
mocked_table_top_query_cursor.fetchall = Mock(return_value=[])
mocked_psycopg2 = Mock()
mocked_psycopg2.cursor = Mock(side_effect=[mocked_table_list_query_cursor, mocked_table_count_query_cursor,
mocked_table_columns_query_cursor, mocked_table_collation_query_cursor,
mocked_table_top_query_cursor])
mocked_builder = Mock()
mocked_builder.build = Mock(return_value=mocked_psycopg2)
expected = {'tables': {'test': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'column_name': 'column',
'data_type': 'string',
'is_nullable': 'NO'}],
'count': 10,
'rows': []},
'unit': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'column_name': 'column',
'data_type': 'string',
'is_nullable': 'NO'}],
'count': 10,
'rows': []}},
'db_connection_string': 'jdbc:postgresql://test'
}
assert expected == Postgresql(mocked_builder, self.logger, db_host = 'test').get_all_tables_info(None, None, None)
def test_get_tables_info_when_no_table_list_is_provided(self,__makedict):
__makedict.return_value = None
mocked_table_list_query_cursor = Mock()
mocked_table_list_query_cursor.execute = Mock(return_value=True)
mocked_table_list_query_cursor.fetchall = Mock(return_value=[{'TABLE_NAME': 'unit'}, {'TABLE_NAME': 'test'}])
mocked_table_count_query_cursor = Mock()
mocked_table_count_query_cursor.execute = Mock(return_value=True)
mocked_table_count_query_cursor.fetchone = Mock(return_value=[10])
columns = {
'TABLE_NAME': '',
'COLUMN_NAME': 'column',
'DATA_TYPE': 'string',
'DATA_LENGTH': '1',
'NULLABLE': 'N',
'DATA_DEFAULT': ''
}
tables_columns = []
columns.update(TABLE_NAME='unit')
tables_columns.append(columns.copy())
columns.update(TABLE_NAME='test')
tables_columns.append(columns.copy())
mocked_table_columns_query_cursor = Mock()
mocked_table_columns_query_cursor.execute = Mock(return_value=True)
mocked_table_columns_query_cursor.fetchall = Mock(return_value=tables_columns)
mocked_table_top_query_cursor = Mock()
mocked_table_top_query_cursor.execute = Mock(return_value=True)
mocked_table_top_query_cursor.fetchall = Mock(return_value=[])
mocked_oracle = Mock()
mocked_oracle.cursor = Mock(side_effect=[mocked_table_list_query_cursor, mocked_table_count_query_cursor,
mocked_table_columns_query_cursor, mocked_table_top_query_cursor])
mocked_builder = Mock()
mocked_builder.build = Mock(return_value=mocked_oracle)
expected = {'tables': {'test': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'source_column_name': 'column',
'column_name': 'column',
'source_data_type': 'string',
'data_type': 'string',
'is_nullable': 'N'}],
'count': 10,
'rows': []},
'unit': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'source_column_name': 'column',
'column_name': 'column',
'source_data_type': 'string',
'data_type': 'string',
'is_nullable': 'N'}],
'count': 10,
'rows': []}}}
assert expected == Oracle(mocked_builder, self.logger).get_all_tables_info(None, None, None)
def test_assertions(self):
# assert_exception_test
mock_session = Mock(
**
{'execute.side_effect': AlreadyExists("Dummy exception message.")})
assert_exception(mock_session, "DUMMY QUERY", expected=AlreadyExists)
# assert_unavailable_test
mock_session = Mock(**{
'execute.side_effect':
Unavailable("Dummy Unavailabile message.")
})
assert_unavailable(mock_session.execute)
# assert_invalid_test
mock_session = Mock(**{
'execute.side_effect':
InvalidRequest("Dummy InvalidRequest message.")
})
assert_invalid(mock_session, "DUMMY QUERY")
# assert_unauthorized_test
mock_session = Mock(**{
'execute.side_effect':
Unauthorized("Dummy Unauthorized message.")
})
assert_unauthorized(mock_session, "DUMMY QUERY", None)
# assert_one_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[1, 1]])
assert_one(mock_session, "SELECT * FROM test", [1, 1])
# assert_none_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[])
assert_none(mock_session, "SELECT * FROM test")
# assert_all_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[i, i]
for i in range(0, 10)])
assert_all(mock_session,
"SELECT k, v FROM test", [[i, i] for i in range(0, 10)],
ignore_order=True)
# assert_almost_equal_test
assert_almost_equal(1, 1.1, 1.2, 1.9, error=1.0)
# assert_row_count_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[1]])
assert_row_count(mock_session, 'test', 1)
# assert_length_equal_test
check = [1, 2, 3, 4]
assert_length_equal(check, 4)
def test_get_tables_info_when_no_table_list_is_provided(self):
mocked_table_list_query_cursor = Mock()
mocked_table_list_query_cursor.execute = Mock(return_value=True)
mocked_table_list_query_cursor.fetchall = Mock(return_value=[{'table_name': 'unit'}, {'table_name': 'test'}])
mocked_table_count_query_cursor = Mock()
mocked_table_count_query_cursor.execute = Mock(return_value=True)
mocked_table_count_query_cursor.fetchone = Mock(return_value=[10])
columns = {
'table_name': '',
'column_name': 'column',
'data_type': 'string',
'character_maximum_length': '1',
'is_nullable': 'NO',
'column_default': ''
}
tables_columns = []
columns.update(table_name='unit')
tables_columns.append(columns.copy())
columns.update(table_name='test')
tables_columns.append(columns.copy())
mocked_table_columns_query_cursor = Mock()
mocked_table_columns_query_cursor.execute = Mock(return_value=True)
mocked_table_columns_query_cursor.fetchall = Mock(return_value=tables_columns)
mocked_table_top_query_cursor = Mock()
mocked_table_top_query_cursor.execute = Mock(return_value=True)
mocked_table_top_query_cursor.fetchall = Mock(return_value=[])
mocked_mssql = Mock()
mocked_mssql.cursor = Mock(side_effect=[mocked_table_list_query_cursor, mocked_table_count_query_cursor,
mocked_table_columns_query_cursor, mocked_table_top_query_cursor])
mocked_builder = Mock()
mocked_builder.build = Mock(return_value=mocked_mssql)
expected = {'tables': {'test': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'source_column_name': 'column',
'column_name': 'column',
'source_data_type': 'string',
'data_type': 'string',
'is_nullable': 'NO'}],
'count': 10,
'rows': []},
'unit': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'source_column_name': 'column',
'column_name': 'column',
'source_data_type': 'string',
'data_type': 'string',
'is_nullable': 'NO'}],
'count': 10,
'rows': []}}}
assert expected == Sqlserver(mocked_builder, self.logger).get_all_tables_info(None, None, None)
def make_mock_service(self, project_quota, region_quota):
mock_project_method = Mock()
mock_project_method.execute = Mock(return_value={'quotas': project_quota})
mock_projects = Mock()
mock_projects.get = Mock(return_value=mock_project_method)
mock_region_method = Mock()
mock_region_method.execute = Mock(return_value={'quotas': region_quota})
mock_regions = Mock()
mock_regions.get = Mock(return_value=mock_region_method)
mock_service = Mock()
mock_service.projects = Mock(return_value=mock_projects)
mock_service.regions = Mock(return_value=mock_regions)
return mock_service
def make_mock_service(self, project_quota, region_quota):
mock_project_method = Mock()
mock_project_method.execute = Mock(return_value={'quotas': project_quota})
mock_projects = Mock()
mock_projects.get = Mock(return_value=mock_project_method)
mock_region_method = Mock()
mock_region_method.execute = Mock(return_value={'quotas': region_quota})
mock_regions = Mock()
mock_regions.get = Mock(return_value=mock_region_method)
mock_service = Mock()
mock_service.projects = Mock(return_value=mock_projects)
mock_service.regions = Mock(return_value=mock_regions)
return mock_service
def test_execute_with_tracker(self):
topic1 = Mock()
topic1.id = 1
topic2 = Mock()
topic2.id = 2
trackers_manager = Mock()
trackers_manager.get_tracker_topics = Mock(
return_value=[topic1, topic2])
engine_runner = Mock()
engine_runner.trackers_manager = trackers_manager
engine_runner.execute = MagicMock()
# noinspection PyTypeChecker
execute_call = ExecuteCall(engine_runner)
self.api.add_route(self.test_route, execute_call)
self.simulate_request(self.test_route,
query_string="tracker=tracker.tv",
method="POST")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
engine_runner.execute.assert_called_once_with([1, 2])
trackers_manager.get_tracker_topics.assert_called_once_with(
'tracker.tv')
def test_no_logged_user(self, cookie_facade):
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = None
cookie_facade.retrive_cookie_data = Mock(return_value=cmd_mock)
result = facade.logged_user(None).execute().result
self.assertIsNone(result)
def test_grab_new_jobs_with_jobs(self, job_patch):
mock_row = [Mock(ID=1), Mock(ID=2), None]
cursor = Mock()
cursor.fetchone.side_effect = mock_row
cursor.execute = Mock()
connection = Mock()
connection.cursor.return_value = cursor
job_1 = Mock(id=1, status=1)
job_1.set_status_in_db.return_value = None
job_2 = Mock(id=2, status=1)
job_2.set_status_in_db.return_value = None
job_patch.side_effect = [job_1, job_2]
maker = CDMaker("/audio/", "/ptburn/", "/label/", "conn_string")
return_value = maker.grab_new_jobs(connection)
self.assertEquals(len(return_value), 2)
self.assertEquals(return_value[0].id, 1)
self.assertEquals(job_1.status, 2)
job_1.set_status_in_db.called_once_with(connection)
self.assertEquals(return_value[1].id, 2)
self.assertEquals(job_2.status, 2)
job_2.set_status_in_db.called_once_with(connection)
cursor.execute.called_once_with(CDMaker.GRAB_NEW_JOBS_SQL)
def _gen_ctx(self):
_ctx = Mock()
_graph_mock = Mock()
_graph_mock.execute = Mock()
_sequence = Mock()
_sequence.add = Mock()
_graph_mock._sequence = _sequence
_graph_mock.sequence = Mock(return_value=_sequence)
_node = Mock()
_node.operations = {
'operation1': {},
'operation2': {},
}
_instance = Mock()
_instance.id = "instance_id"
_instance.send_event = Mock(return_value='event')
_instance.execute_operation = Mock(return_value='execute_operation')
_node.properties = {}
_node.id = 'node_id'
_node.instances = [_instance]
_workflow_ctx = Mock()
_workflow_ctx.nodes = [_node]
_workflow_ctx.graph_mode = Mock(return_value=_graph_mock)
_workflow_ctx.get_ctx = Mock(return_value=_ctx)
return _workflow_ctx, _graph_mock, _instance
async def test_check_connection(app, client, mocker):
s = spark.fget(app)
await s.check_connection()
m_wait_sync = mocker.patch(TESTED + '.service_status.wait_synchronized', AsyncMock())
m_wait_sync.return_value = False
m_cmder = Mock()
m_cmder.execute = AsyncMock()
m_cmder.start_reconnect = AsyncMock()
mocker.patch(TESTED + '.commander.fget').return_value = m_cmder
await s.check_connection()
assert m_cmder.execute.await_count == 0
assert m_cmder.start_reconnect.await_count == 0
m_wait_sync.return_value = True
await s.check_connection()
assert m_cmder.execute.await_count == 1
assert m_cmder.start_reconnect.await_count == 0
m_cmder.execute.side_effect = exceptions.CommandException()
await s.check_connection()
assert m_cmder.execute.await_count == 2
assert m_cmder.start_reconnect.await_count == 1
def test_generate_thematic_schema(self, connect, exists, copy):
sqlite = self.path + '/utils/tests/files/test.sqlite'
shapefile = self.path + '/utils/tests/files/thematic_shp'
thematic_sqlite = self.path + '/utils/tests/files/test_thematic_shp_thematic.sqlite'
exists.return_value = True
conn = Mock()
conn.enable_load_extention = Mock()
connect.return_value = conn
cur = Mock()
conn.cursor = cur
cur.execute = Mock()
cmd = "SELECT load_extension('libspatialite')"
tags = self.job.categorised_tags
t2s = ThematicSQliteToShp(sqlite=sqlite,
shapefile=shapefile,
tags=tags,
job_name='test_thematic_shp',
zipped=False,
debug=False)
exists.assert_called_twice()
copy.assert_called_once()
t2s.generate_thematic_schema()
connect.assert_called_once()
conn.load_extention.assert_called_once()
conn.cursor.assert_called_once()
def create_trackers_manager(self):
execute_mock = Mock()
self.trackers_manager = TrackersManager(TrackerSettings(10, None), {})
mock_tracker = Mock()
mock_tracker.get_topics = Mock(return_value=[Topic()])
mock_tracker.execute = execute_mock
self.trackers_manager.trackers = {'mock.tracker': mock_tracker}
def test_convert(self, connect, popen, pipe, exists, copy):
sqlite = self.path + '/utils/tests/files/test_thematic_shp_thematic.sqlite'
shapefile = self.path + '/utils/tests/files/shp'
cmd = "ogr2ogr -f 'ESRI Shapefile' {0} {1} -lco ENCODING=UTF-8".format(
shapefile, sqlite)
proc = Mock()
exists.return_value = True
conn = Mock()
conn.enable_load_extention = Mock()
connect.return_value = conn
cur = Mock()
conn.cursor = cur
cur.execute = Mock()
popen.return_value = proc
proc.communicate.return_value = (Mock(), Mock())
proc.wait.return_value = 0
# set zipped to False for testing
tags = self.job.categorised_tags
t2s = ThematicSQliteToShp(sqlite=sqlite,
shapefile=shapefile,
tags=tags,
job_name='test_thematic_shp',
zipped=False,
debug=False)
exists.assert_called_twice()
copy.assert_called_once()
out = t2s.convert()
popen.assert_called_once_with(cmd,
shell=True,
executable='/bin/bash',
stdout=pipe,
stderr=pipe)
self.assertEquals(out, shapefile)
def test_update_interval_during_execute(self, test_interval):
waiter = Event()
scope = self.Bunch()
scope.first_execute = True
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
self.engine_runner.interval = test_interval
if scope.first_execute:
scope.start = time()
scope.first_execute = False
else:
scope.end = time()
waiter.set()
execute_mock = Mock(side_effect=execute)
mock_tracker = Mock()
mock_tracker.get_topics = Mock(return_value=[Topic()])
mock_tracker.execute = execute_mock
self.trackers_manager.trackers = {'mock.tracker': mock_tracker}
self.create_runner()
waiter.wait(2)
self.assertTrue(waiter.is_set)
self.stop_runner()
self.assertEqual(2, execute_mock.call_count)
# noinspection PyUnresolvedReferences
delta = scope.end - scope.start
self.assertLessEqual(abs(delta - test_interval), 0.027)
def test_stop_after_multiple_execute(self, value):
waiter = Event()
scope = self.Bunch()
scope.execute_count = 0
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
scope.execute_count += 1
if scope.execute_count < value:
return
waiter.set()
execute_mock = Mock(side_effect=execute)
mock_tracker = Mock()
mock_tracker.get_topics = Mock(return_value=[Topic()])
mock_tracker.execute = execute_mock
self.trackers_manager.trackers = {'mock.tracker': mock_tracker}
self.create_runner()
waiter.wait(2)
self.assertTrue(waiter.is_set)
self.stop_runner()
self.assertEqual(value, execute_mock.call_count)
def test_manual_execute_shouldnt_reset_timeout_for_whole_execute(self):
executed = Event()
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
executed.set()
execute_mock = Mock(side_effect=execute)
mock_tracker = Mock()
mock_tracker.get_topics = Mock(return_value=[Topic()])
mock_tracker.execute = execute_mock
self.trackers_manager.trackers = {'mock.tracker': mock_tracker}
with DBSession() as db:
db.add(ExecuteSettings(interval=1, last_execute=None))
self.create_runner()
sleep(0.5)
# start manual
self.engine_runner.execute([1, 2, 3])
executed.wait(0.3)
executed.clear()
sleep(0.5)
executed.wait(0.3)
self.assertTrue(executed.is_set)
self.stop_runner()
self.assertEqual(2, execute_mock.call_count)
def test_manual_execute_with_ids_ignored_while_in_execute(self):
waiter = Event()
long_execute_waiter = Event()
# noinspection PyUnusedLocal
def execute(*args, **kwargs):
waiter.set()
long_execute_waiter.wait(1)
self.assertTrue(long_execute_waiter.is_set)
execute_mock = Mock(side_effect=execute)
topics = [Topic()]
mock_tracker = Mock()
mock_tracker.get_topics = Mock(return_value=topics)
mock_tracker.execute = execute_mock
self.trackers_manager.trackers = {'mock.tracker': mock_tracker}
self.create_runner(interval=1)
self.engine_runner.execute(None)
waiter.wait(0.3)
waiter.clear()
ids = [1, 2, 3]
self.engine_runner.execute(ids)
long_execute_waiter.set()
waiter.wait(0.3)
self.assertTrue(waiter.is_set)
self.stop_runner()
execute_mock.assert_called_once_with(topics, ANY)
def test_prepare_conn_execute_the_subnet_actions(self):
# Arrage
actions = []
actions.append(
NetworkAction(id="Net", connection_params=PrepareNetworkParams()))
actions.append(
NetworkAction(id="SubA", connection_params=PrepareSubnetParams()))
actions.append(
NetworkAction(id="SubB", connection_params=PrepareSubnetParams()))
# Act
with patch(
'cloudshell.cp.aws.domain.conncetivity.operations.prepare.PrepareSubnetExecutor'
) as ctor:
obj = Mock()
obj.execute = Mock(return_value=["ResA", "ResB"])
ctor.return_value = obj
results = self.prepare_conn.prepare_connectivity(
ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=actions,
cancellation_context=self.cancellation_context,
logger=Mock())
# Assert
self.assertEqual(len(results), 3)
self.assertEqual(results[1], "ResA")
self.assertEqual(results[2], "ResB")
def test_prepare_conn_execute_the_subnet_actions(self):
# Arrage
actions = []
prepare_subnet_sub_a = PrepareSubnet();
prepare_subnet_sub_a.actionId = "SubA"
prepare_subnet_sub_a.actionParams = PrepareSubnetParams()
actions.append(prepare_subnet_sub_a)
prepare_cloud_infra = PrepareCloudInfra()
prepare_cloud_infra.actionId = "Net"
prepare_cloud_infra.actionParams = PrepareCloudInfraParams()
actions.append(prepare_cloud_infra)
prepare_subnet_sub_b = PrepareSubnet();
prepare_subnet_sub_b.actionId = "SubB"
prepare_subnet_sub_b.actionParams = PrepareSubnetParams()
actions.append(prepare_subnet_sub_b)
prepare_create_key = CreateKeys();
prepare_create_key.actionId = "CreateKeys"
actions.append(prepare_create_key)
# Act
with patch('cloudshell.cp.aws.domain.conncetivity.operations.prepare.PrepareSubnetExecutor') as ctor:
obj = Mock()
obj.execute = Mock(return_value=["ResA", "ResB"])
ctor.return_value = obj
results = self.prepare_conn.prepare_connectivity(ec2_client=self.ec2_client,
ec2_session=self.ec2_session,
s3_session=self.s3_session,
reservation=self.reservation,
aws_ec2_datamodel=self.aws_dm,
actions=actions,
cancellation_context=self.cancellation_context,
logger=Mock())
# Assert
self.assertEqual(len(results), 4)
self.assertEqual(results[2], "ResA")
self.assertEqual(results[3], "ResB")
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 = Mock()
m_cursor.execute = m_execute
m_cursor.fetchone = m_fetchone
conn = Mock()
conn.cursor.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 test_new_public_version_notify_only_once(self):
notifier_manager_execute = MagicMock()
notifier_manager_execute.notify = Mock()
notifier_manager_execute.__enter__ = Mock(
return_value=notifier_manager_execute)
notifier_manager = Mock()
notifier_manager.execute = Mock(name="notifier_manager.execute123",
return_value=notifier_manager_execute)
# noinspection PyTypeChecker
checker = NewVersionChecker(notifier_manager, False)
with patch('monitorrent.new_version_checker.monitorrent',
create=True) as version_mock:
version_mock.__version__ = "1.0.0"
checker.execute()
self.assertEqual(
'https://github.com/werwolfby/monitorrent/releases/tag/1.1.1',
checker.new_version_url)
notifier_manager_execute.notify.assert_called_once()
checker.execute()
notifier_manager_execute.notify.assert_called_once()
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (["{}"], "", 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.result = Mock(return_value=conn)
return conn
def _build_mock():
fetch_mock = Mock()
fetch_mock.execute = Mock(return_value=fetch_mock)
fetch_mock.result.content = _SUCCESS_PAGSEGURO_XML.encode('ISO-8859-1')
fetch_mock.result.status_code = 200
fetch_mock.errors = {}
fetch_mock.commit = Mock(return_value=[])
return fetch_mock
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (['{}'], '', 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.result = Mock(return_value=conn)
return conn
def _build_mock():
fetch_mock = Mock()
fetch_mock.execute = Mock(return_value=fetch_mock)
fetch_mock.result.content = _SUCCESS_PAGSEGURO_XML.encode('ISO-8859-1')
fetch_mock.result.status_code = 200
fetch_mock.errors = {}
fetch_mock.commit = Mock(return_value=[])
return fetch_mock
def test_logged_user(self, cookie_facade):
user = mommy.save_one(MainUser)
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = {'id': user.key.id()}
cookie_facade.retrive_cookie_data = Mock(return_value=cmd_mock)
result = facade.logged_user(None).execute().result
self.assertEqual(user, result)
def setup_base_mock(self, fetch_command_cls):
app = _setup_app_data()
fetch_cmd_obj = Mock()
fetch_cmd_obj.errors = {}
fetch_cmd_obj.execute = Mock(return_value=fetch_cmd_obj)
fetch_cmd_obj.result.content = json.dumps({'id': "654321", 'email': "*****@*****.**"})
fetch_command_cls.return_value = fetch_cmd_obj
return app, fetch_cmd_obj, Mock()
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or ([b'{}'], [], 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
return conn
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (['{}'], '', 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
return conn
def test_google_user_logged(self, facade_mock):
self.set_current_user()
cmd_mock = Mock()
cmd_mock.pending_link = False
execute_mock = Mock()
execute_mock.execute = Mock(return_value=cmd_mock)
facade_mock.login_google = Mock(return_value=execute_mock)
response = google.index(Mock())
self.assertIsInstance(response, RedirectResponse)
def test_google_user_logged(self, facade_mock):
self.set_current_user()
cmd_mock = Mock()
cmd_mock.pending_link = False
execute_mock = Mock()
execute_mock.execute = Mock(return_value=cmd_mock)
facade_mock.login_google = Mock(return_value=execute_mock)
response = google.index(Mock())
self.assertIsInstance(response, RedirectResponse)
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or ([b'{}'], [], 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
conn.cmd = lambda x: x
return conn
def assertions_test(self):
# assert_exception_test
mock_session = Mock(**{'execute.side_effect': AlreadyExists("Dummy exception message.")})
assert_exception(mock_session, "DUMMY QUERY", expected=AlreadyExists)
# assert_unavailable_test
mock_session = Mock(**{'execute.side_effect': Unavailable("Dummy Unavailabile message.")})
assert_unavailable(mock_session.execute)
# assert_invalid_test
mock_session = Mock(**{'execute.side_effect': InvalidRequest("Dummy InvalidRequest message.")})
assert_invalid(mock_session, "DUMMY QUERY")
# assert_unauthorized_test
mock_session = Mock(**{'execute.side_effect': Unauthorized("Dummy Unauthorized message.")})
assert_unauthorized(mock_session, "DUMMY QUERY", None)
# assert_one_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[1, 1]])
assert_one(mock_session, "SELECT * FROM test", [1, 1])
# assert_none_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[])
assert_none(mock_session, "SELECT * FROM test")
# assert_all_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[i, i] for i in range(0, 10)])
assert_all(mock_session, "SELECT k, v FROM test", [[i, i] for i in range(0, 10)], ignore_order=True)
# assert_almost_equal_test
assert_almost_equal(1, 1.1, 1.2, 1.9, error=1.0)
# assert_row_count_test
mock_session = Mock()
mock_session.execute = Mock(return_value=[[1]])
assert_row_count(mock_session, 'test', 1)
# assert_length_equal_test
check = [1, 2, 3, 4]
assert_length_equal(check, 4)
def create_command(self, name, execute_method=None):
command = Mock()
command.aliases = name
command.matches = Mock()
command.matches.return_value = True
if execute_method:
command.execute = execute_method
return command
def test_no_logged_user(self, facade):
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = None
facade.logged_user = Mock(return_value=cmd_mock)
dependency = {}
middleware.LoggedUserMiddleware(Mock(), dependency, Mock()).set_up()
self.assertEqual({'_login_path': '/login',
'_logout_path': '/logout',
'_logged_user': None}, dependency)
def test_get_where_clause_empty(self):
cursor = Mock()
cursor.execute = Mock(return_value=None)
arcpy = Mock()
arcpy.ArcSDESQLExecute = Mock(return_value=cursor)
actual = self.patient._get_where_clause(arcpy, {})
self.assertIsNone(actual)
def test_get_where_clause_array(self):
cursor = Mock()
cursor.execute = Mock(return_value=[['\'2\''], ['\'1\'']])
arcpy = Mock()
arcpy.ArcSDESQLExecute = Mock(return_value=cursor)
actual = self.patient._get_where_clause(arcpy, {})
expected = 'Project_FK in (\'2\',\'1\')'
self.assertEqual(actual, expected)
def test_execute_fail_with_multiple_params(self, query_string):
engine_runner = Mock()
engine_runner.execute = MagicMock()
# noinspection PyTypeChecker
execute_call = ExecuteCall(engine_runner)
self.api.add_route(self.test_route, execute_call)
self.simulate_request(self.test_route, query_string=query_string, method="POST")
self.assertEqual(self.srmock.status, falcon.HTTP_BAD_REQUEST)
engine_runner.execute.assert_not_called()
def test_execute_fail_with_multiple_params(self, query_string):
engine_runner = Mock()
engine_runner.execute = MagicMock()
# noinspection PyTypeChecker
execute_call = ExecuteCall(engine_runner)
self.api.add_route(self.test_route, execute_call)
self.simulate_request(self.test_route, query_string=query_string, method="POST")
self.assertEqual(self.srmock.status, falcon.HTTP_BAD_REQUEST)
engine_runner.execute.assert_not_called()
def test_insert(loglines):
for line in loglines:
database = Mock('cursor')
database.fetchone = lambda: [random.randint(1, 10000)]
def execute(sql, params=()):
return sql % params
database.execute = execute
message = logengine.create_message(line)
assert message, "unparseable: %s" % line
logengine.insert_message(message, database, {}, {}, {}, {}, {}, {})
def test_count(stubbed_cursor):
fake_connection = Mock()
fake_connection.execute = Mock(return_value=[[36]])
fake_collection = Mock()
fake_collection.get_connection = Mock(return_value=fake_connection)
stubbed_cursor._collection_ref = fake_collection
fake_request = Mock()
stubbed_cursor._serialize_count = Mock(return_value=fake_request)
count = stubbed_cursor.count(True)
assert count == 36
stubbed_cursor._serialize_count.assert_called_with(True)
fake_connection.execute.assert_called_with(fake_request)
def test_no_logged_user(self, facade):
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = None
facade.logged_user = Mock(return_value=cmd_mock)
dependency = {}
handler = Mock()
handler.request.path_qs='/foo?param1=1¶m2=2'
middleware.LoggedUserMiddleware(handler, dependency, Mock()).set_up()
self.assertEqual({'_login_path': '/login?ret_path=%2Ffoo%3Fparam1%3D1%26param2%3D2',
'_logout_path': None,
'_logged_user': None}, dependency)
def test_logged_user(self, facade):
user = mommy.save_one(MainUser)
user.put()
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = user
facade.logged_user = Mock(return_value=cmd_mock)
dependency = {}
middleware.LoggedUserMiddleware(Mock(), dependency, Mock()).set_up()
self.assertEqual({'_login_path': None,
'_logout_path': '/logout',
'_logged_user': user}, dependency)
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (['{}'], [], 0)
conn = Mock()
conn.cmd = lambda x: x
conn.sudo = ''
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
conn.cmd = lambda x: x
return conn
def test_stop_bofore_execute(self):
execute_mock = MagicMock()
mock_tracker = Mock()
mock_tracker.get_topics = Mock(return_value=[Topic()])
mock_tracker.execute = execute_mock
self.trackers_manager.trackers = {'mock.tracker': mock_tracker}
self.create_runner()
self.stop_runner()
execute_mock.assert_not_called()
def test_execute_with_ids(self):
engine_runner = Mock()
engine_runner.execute = MagicMock()
# noinspection PyTypeChecker
execute_call = ExecuteCall(engine_runner)
self.api.add_route(self.test_route, execute_call)
self.simulate_request(self.test_route, query_string="ids=1,2,3", method="POST")
self.assertEqual(self.srmock.status, falcon.HTTP_OK)
engine_runner.execute.assert_called_once_with([1, 2, 3])
def test_single_value_sql5(self):
m_execute = Mock()
m_fetchall = Mock(return_value=((17, 22),))
m_cursor = Mock()
m_cursor.execute = m_execute
m_cursor.fetchall = m_fetchall
conn = Mock()
conn.cursor.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 create_command(self, name, priority='normal', execute_method=None):
command = Mock()
command.aliases = name
command.matches = Mock()
command.matches.return_value = True
if execute_method:
command.execute = execute_method
command.priority = priority
return command
def test_single_value_sql5(self):
m_execute = Mock()
m_fetchall = Mock(return_value=((17, 22), ))
m_cursor = Mock()
m_cursor.execute = m_execute
m_cursor.fetchall = m_fetchall
conn = Mock()
conn.cursor.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_grab_new_jobs_no_jobs(self):
cursor = Mock()
cursor.fetchone.return_value = None
cursor.execute = Mock()
connection = Mock()
connection.cursor.return_value = cursor
maker = CDMaker("/audio/", "/ptburn/", "/label/", "conn_string")
return_value = maker.grab_new_jobs(connection)
self.assertEquals(return_value, [])
cursor.execute.called_once_with(CDMaker.GRAB_NEW_JOBS_SQL)
def test_execute_no_results(self):
m_execute = Mock()
m_cursor = Mock()
m_cursor.execute = m_execute
conn = Mock()
conn.cursor.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_check_for_new_jobs_no_jobs(self):
mock_row = [0]
cursor = Mock()
cursor.fetchone.return_value = mock_row
cursor.execute = Mock()
connection = Mock()
connection.cursor.return_value = cursor
maker = CDMaker("/audio/", "/ptburn/", "/label/", "conn_string")
return_value = maker.check_for_new_jobs(connection)
self.assertFalse(return_value)
cursor.execute.called_once_with(CDMaker.COUNT_NEW_JOBS_SQL)
def test_check_for_running_jobs_found_jobs(self):
mock_row = [1]
cursor = Mock()
cursor.fetchone.return_value = mock_row
cursor.execute = Mock()
connection = Mock()
connection.cursor.return_value = cursor
maker = CDMaker("/audio/", "/ptburn/", "/label/", "conn_string")
return_value = maker.check_for_running_jobs(connection)
self.assertTrue(return_value)
cursor.execute.called_once_with(CDMaker.COUNT_RUNNING_JOBS_SQL)
def test_single_value_sql1(self):
m_execute = Mock()
m_fetchall = Mock(return_value=((17,),))
m_cursor = Mock()
m_cursor.execute = m_execute
m_cursor.fetchall = m_fetchall
conn = Mock()
conn.cursor.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_should_execute_declarator():
channel = Mock()
channel_declarator = Mock()
channel_declarator.execute = Mock()
config = Mock()
queue_name = 'queue'
no_ack = False
pub.start_consume(channel=channel,
channel_declarator=channel_declarator,
loc_config=config,
queue_name=queue_name,
no_ack=no_ack)
channel_declarator.execute.assert_called_with(channel,
queue_name,
config)
def test_single_value_sql4(self):
m_execute = Mock()
m_fetchall = Mock(return_value=None)
m_cursor = Mock()
m_cursor.execute = m_execute
m_cursor.fetchall = m_fetchall
conn = Mock()
conn.cursor.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_get_tables_info_when_no_table_list_is_provided(self):
mocked_table_list_query_cursor = Mock()
mocked_table_list_query_cursor.execute = Mock(return_value=True)
mocked_table_list_query_cursor.fetchall = Mock(return_value=[{'table_name': 'unit'}, {'table_name': 'test'}])
mocked_table_count_query_cursor = Mock()
mocked_table_count_query_cursor.execute = Mock(return_value=True)
mocked_table_count_query_cursor.fetchone = Mock(return_value=[10])
columns = {
'table_name': '',
'column_name': 'column',
'data_type': 'string',
'character_maximum_length': '1',
'is_nullable': 'NO',
'column_default': ''
}
tables_columns = []
columns.update(table_name='unit')
tables_columns.append(columns.copy())
columns.update(table_name='test')
tables_columns.append(columns.copy())
mocked_table_columns_query_cursor = Mock()
mocked_table_columns_query_cursor.execute = Mock(return_value=True)
mocked_table_columns_query_cursor.fetchall = Mock(return_value=tables_columns)
mocked_table_top_query_cursor = Mock()
mocked_table_top_query_cursor.execute = Mock(return_value=True)
mocked_table_top_query_cursor.fetchall = Mock(return_value=[])
mocked_mssql = Mock()
mocked_mssql.cursor = Mock(side_effect=[mocked_table_list_query_cursor, mocked_table_count_query_cursor,
mocked_table_columns_query_cursor, mocked_table_top_query_cursor])
mocked_builder = Mock()
mocked_builder.build = Mock(return_value=mocked_mssql)
expected = {'tables': {'test': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'column_name': 'column',
'data_type': 'string',
'is_nullable': 'NO'}],
'count': 10,
'rows': []},
'unit': {'columns': [{'character_maximum_length': '1',
'column_default': '',
'column_name': 'column',
'data_type': 'string',
'is_nullable': 'NO'}],
'count': 10,
'rows': []}},
'db_connection_string': 'jdbc:sqlserver://test'
}
assert expected == Sqlserver(mocked_builder, self.logger, db_host = 'test').get_all_tables_info(None, None, None)
def test_convert(self, connect, popen, pipe, exists, copy):
sqlite = self.path + "/files/test_thematic_shp_thematic.sqlite"
shapefile = self.path + "/files/shp"
cmd = "ogr2ogr -f 'ESRI Shapefile' {0} {1} -lco ENCODING=UTF-8".format(shapefile, sqlite)
proc = Mock()
exists.return_value = True
conn = Mock()
conn.enable_load_extention = Mock()
connect.return_value = conn
cur = Mock()
conn.cursor = cur
cur.execute = Mock()
popen.return_value = proc
proc.communicate.return_value = (Mock(), Mock())
proc.wait.return_value = 0
# set zipped to False for testing
tags = self.job.categorised_tags
t2s = ThematicSQliteToShp(
sqlite=sqlite, shapefile=shapefile, tags=tags, job_name="test_thematic_shp", zipped=False, debug=True
)
exists.assert_called_twice()
copy.assert_called_once()
out = t2s.convert()
popen.assert_called_once_with(cmd, shell=True, executable="/bin/bash", stdout=pipe, stderr=pipe)
self.assertEquals(out, shapefile)
