Skip to content

Commit e119614

Browse files
bishopbm2bishopbm2
committed
Finished add all tests for all python files.
1 parent 86013fa commit e119614

File tree

5 files changed

+306
-5
lines changed

5 files changed

+306
-5
lines changed

‎actions/generic_query.py‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,8 @@ def run(self, **kwargs):
3030
return_result = {'affected_rows': query_result.rowcount}
3131
if query_result.returns_rows:
3232
return_result = []
33-
for row in query_result:
33+
all_results = query_result.fetchall()
34+
for row in all_results:
3435
# Rows are returned as tuples with keys. Convert that to a dictionary for return
3536
return_result.append(self.row_to_dict(row))
3637

‎tests/test_action_delete.py‎

Lines changed: 79 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
from st2common.runners.base_action import Action
55
from delete import SQLDeleteAction
66

7-
# import mock
7+
import mock
88

99
__all__ = [
1010
'TestActionSQLDeleteAction'
@@ -20,3 +20,81 @@ def test_init(self):
2020
self.assertIsInstance(action, SQLDeleteAction)
2121
self.assertIsInstance(action, BaseAction)
2222
self.assertIsInstance(action, Action)
23+
24+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
25+
@mock.patch('delete.sqlalchemy')
26+
def test_run_object(self, mock_sqlalchemy, mock_connect_to_db):
27+
action = self.get_action_instance(self.config_good)
28+
connection_name = 'full'
29+
connection_config = self.config_good['sql'][connection_name]
30+
test_dict = {
31+
'table': 'Test_Table',
32+
'where_data': {
33+
'column_1': 'value_1'
34+
}
35+
}
36+
test_dict.update(connection_config)
37+
execute_dict = {'_column_1': 'value_1'}
38+
expected_result = {'affected_rows': 1}
39+
action_meta = 'MetaData'
40+
action_engine = "Engine Data"
41+
mock_connect_to_db.return_value = "Successfully connected"
42+
mock_where_return = "Where statment"
43+
mock_where = mock.Mock()
44+
mock_where.where.return_value = mock_where_return
45+
mock_sql_table = mock.Mock()
46+
mock_sql_table.delete.return_value = mock_where
47+
mock_query_results = mock.Mock(rowcount=1)
48+
mock_connection = mock.Mock()
49+
mock_connection.execute.return_value = mock_query_results
50+
mock_connection.close.return_value = "Successfully disconnected"
51+
52+
action.conn = mock_connection
53+
action.meta = action_meta
54+
action.engine = action_engine
55+
mock_sqlalchemy.Table.return_value = mock_sql_table
56+
57+
result = action.run(**test_dict)
58+
self.assertEqual(result, expected_result)
59+
mock_connect_to_db.assert_called_once_with(connection_config)
60+
mock_sqlalchemy.Table.assert_called_once_with(test_dict['table'],
61+
action_meta,
62+
autoload=True,
63+
autoload_with=action_engine)
64+
mock_connection.execute.assert_called_once_with(mock_where_return, execute_dict)
65+
66+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
67+
@mock.patch('delete.sqlalchemy')
68+
def test_run_array(self, mock_sqlalchemy, mock_connect_to_db):
69+
action = self.get_action_instance(self.config_good)
70+
connection_name = 'full'
71+
connection_config = self.config_good['sql'][connection_name]
72+
test_dict = {
73+
'connection': connection_name,
74+
'table': 'Test_Table'
75+
}
76+
expected_result = {'affected_rows': 20}
77+
action_meta = 'MetaData'
78+
action_engine = "Engine Data"
79+
mock_connect_to_db.return_value = "Successfully connected"
80+
mock_delete_return = "Delete Statement"
81+
mock_sql_table = mock.Mock()
82+
mock_sql_table.delete.return_value = mock_delete_return
83+
mock_query_results = mock.Mock(rowcount=20)
84+
mock_connection = mock.Mock()
85+
mock_connection.execute.return_value = mock_query_results
86+
mock_connection.close.return_value = "Successfully disconnected"
87+
88+
action.conn = mock_connection
89+
action.meta = action_meta
90+
action.engine = action_engine
91+
mock_sqlalchemy.Table.return_value = mock_sql_table
92+
93+
result = action.run(**test_dict)
94+
self.assertEqual(result, expected_result)
95+
mock_connect_to_db.assert_called_once_with(connection_config)
96+
mock_sqlalchemy.Table.assert_called_once_with(test_dict['table'],
97+
action_meta,
98+
autoload=True,
99+
autoload_with=action_engine)
100+
mock_connection.execute.assert_called_once_with(mock_delete_return, None)

‎tests/test_action_insert.py‎

Lines changed: 80 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
from st2common.runners.base_action import Action
55
from insert import SQLInsertAction
66

7-
# import mock
7+
import mock
88

99
__all__ = [
1010
'TestActionSQLInsertAction'
@@ -20,3 +20,82 @@ def test_init(self):
2020
self.assertIsInstance(action, SQLInsertAction)
2121
self.assertIsInstance(action, BaseAction)
2222
self.assertIsInstance(action, Action)
23+
24+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
25+
@mock.patch('insert.sqlalchemy')
26+
def test_run_object(self, mock_sqlalchemy, mock_connect_to_db):
27+
action = self.get_action_instance(self.config_good)
28+
connection_name = 'full'
29+
connection_config = self.config_good['sql'][connection_name]
30+
test_dict = {
31+
'table': 'Test_Table',
32+
'data': {
33+
'column_1': 'value_1',
34+
'column_2': 'value_2'
35+
}
36+
}
37+
test_dict.update(connection_config)
38+
action_meta = "MetaData"
39+
action_engine = "Engine Data"
40+
mock_connect_to_db.return_value = "Successfully connected"
41+
mock_sql_table = mock.Mock()
42+
insert_return = "Insert Statment"
43+
mock_sql_table.insert.return_value = insert_return
44+
mock_connection = mock.Mock()
45+
mock_connection.execute.return_value = "Successfully Executed Statement"
46+
mock_connection.close.return_value = "Successfully disconnected"
47+
48+
action.conn = mock_connection
49+
action.meta = action_meta
50+
action.engine = action_engine
51+
mock_sqlalchemy.Table.return_value = mock_sql_table
52+
53+
result = action.run(**test_dict)
54+
self.assertEqual(result, True)
55+
mock_connect_to_db.assert_called_once_with(connection_config)
56+
mock_sqlalchemy.Table.assert_called_once_with(test_dict['table'],
57+
action_meta,
58+
autoload=True,
59+
autoload_with=action_engine)
60+
mock_connection.execute.assert_called_once_with(insert_return, [test_dict['data']])
61+
62+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
63+
@mock.patch('insert.sqlalchemy')
64+
def test_run_array(self, mock_sqlalchemy, mock_connect_to_db):
65+
action = self.get_action_instance(self.config_good)
66+
connection_name = 'full'
67+
connection_config = self.config_good['sql'][connection_name]
68+
test_dict = {
69+
'connection': connection_name,
70+
'table': 'Test_Table',
71+
'data': [{
72+
'column_1': 'value_1',
73+
'column_2': 'value_2'
74+
}, {
75+
'column_1': 'value_3',
76+
'column_2': 'value_4'
77+
}]
78+
}
79+
action_meta = "MetaData"
80+
action_engine = "Engine Data"
81+
mock_connect_to_db.return_value = "Successfully connected"
82+
mock_sql_table = mock.Mock()
83+
insert_return = "Insert Statment"
84+
mock_sql_table.insert.return_value = insert_return
85+
mock_connection = mock.Mock()
86+
mock_connection.execute.return_value = "Successfully Executed Statement"
87+
mock_connection.close.return_value = "Successfully disconnected"
88+
89+
action.conn = mock_connection
90+
action.meta = action_meta
91+
action.engine = action_engine
92+
mock_sqlalchemy.Table.return_value = mock_sql_table
93+
94+
result = action.run(**test_dict)
95+
self.assertEqual(result, True)
96+
mock_connect_to_db.assert_called_once_with(connection_config)
97+
mock_sqlalchemy.Table.assert_called_once_with(test_dict['table'],
98+
action_meta,
99+
autoload=True,
100+
autoload_with=action_engine)
101+
mock_connection.execute.assert_called_once_with(insert_return, test_dict['data'])

‎tests/test_action_query.py‎

Lines changed: 53 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
from st2common.runners.base_action import Action
55
from generic_query import SQLQueryAction
66

7-
# import mock
7+
import mock
88

99
__all__ = [
1010
'TestActionSQLQueryAction'
@@ -20,3 +20,55 @@ def test_init(self):
2020
self.assertIsInstance(action, SQLQueryAction)
2121
self.assertIsInstance(action, BaseAction)
2222
self.assertIsInstance(action, Action)
23+
24+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
25+
def test_run(self, mock_connect_to_db):
26+
action = self.get_action_instance(self.config_good)
27+
connection_name = 'full'
28+
connection_config = self.config_good['sql'][connection_name]
29+
test_dict = {
30+
'query': 'generic query'
31+
}
32+
test_dict.update(connection_config)
33+
mock_connect_to_db.return_value = "Successfully connected"
34+
test_row = mock.Mock(test1='value', test2='value2')
35+
test_row.keys.return_value = ['test1', 'test2']
36+
expected_result = [{
37+
'test1': 'value',
38+
'test2': 'value2'
39+
}]
40+
mock_query_results = mock.Mock(returns_rows=True, rowcount=1)
41+
mock_query_results.fetchall.return_value = [test_row]
42+
mock_connection = mock.Mock()
43+
mock_connection.execute.return_value = mock_query_results
44+
mock_connection.close.return_value = "Successfully disconnected"
45+
46+
action.conn = mock_connection
47+
48+
result = action.run(**test_dict)
49+
self.assertEqual(result, expected_result)
50+
mock_connect_to_db.assert_called_once_with(connection_config)
51+
mock_connection.execute.assert_called_once_with(test_dict['query'])
52+
53+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
54+
def test_run_connction(self, mock_connect_to_db):
55+
action = self.get_action_instance(self.config_good)
56+
connection_name = 'full'
57+
connection_config = self.config_good['sql'][connection_name]
58+
test_dict = {
59+
'connection': connection_name,
60+
'query': 'generic query'
61+
}
62+
mock_connect_to_db.return_value = "Successfully connected"
63+
expected_result = {'affected_rows': 5}
64+
mock_query_results = mock.Mock(returns_rows=False, rowcount=5)
65+
mock_connection = mock.Mock()
66+
mock_connection.execute.return_value = mock_query_results
67+
mock_connection.close.return_value = "Successfully disconnected"
68+
69+
action.conn = mock_connection
70+
71+
result = action.run(**test_dict)
72+
self.assertEqual(result, expected_result)
73+
mock_connect_to_db.assert_called_once_with(connection_config)
74+
mock_connection.execute.assert_called_once_with(test_dict['query'])

‎tests/test_action_update.py‎

Lines changed: 92 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
from st2common.runners.base_action import Action
55
from update import SQLUpdateAction
66

7-
# import mock
7+
import mock
88

99
__all__ = [
1010
'TestActionSQLUpdateAction'
@@ -20,3 +20,94 @@ def test_init(self):
2020
self.assertIsInstance(action, SQLUpdateAction)
2121
self.assertIsInstance(action, BaseAction)
2222
self.assertIsInstance(action, Action)
23+
24+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
25+
@mock.patch('update.sqlalchemy')
26+
def test_run_object(self, mock_sqlalchemy, mock_connect_to_db):
27+
action = self.get_action_instance(self.config_good)
28+
connection_name = 'full'
29+
connection_config = self.config_good['sql'][connection_name]
30+
test_dict = {
31+
'table': 'Test_Table',
32+
'where_data': {
33+
'column_1': 'value_1'
34+
},
35+
'update_data': {
36+
'column_2': 'value_2'
37+
}
38+
}
39+
test_dict.update(connection_config)
40+
execute_dict = {'_column_1': 'value_1', 'column_2': 'value_2'}
41+
expected_result = {'affected_rows': 1}
42+
action_meta = 'MetaData'
43+
action_engine = "Engine Data"
44+
mock_connect_to_db.return_value = "Successfully connected"
45+
mock_values = mock.Mock()
46+
mock_values_return = "Where and Values object"
47+
mock_values.values.return_value = mock_values_return
48+
mock_where = mock.Mock()
49+
mock_where.where.return_value = mock_values
50+
mock_sql_table = mock.Mock()
51+
mock_sql_table.update.return_value = mock_where
52+
mock_sql_table.c.get.return_value = "column return"
53+
mock_query_results = mock.Mock(rowcount=1)
54+
mock_connection = mock.Mock()
55+
mock_connection.execute.return_value = mock_query_results
56+
mock_connection.close.return_value = "Successfully disconnected"
57+
58+
action.conn = mock_connection
59+
action.meta = action_meta
60+
action.engine = action_engine
61+
mock_sqlalchemy.Table.return_value = mock_sql_table
62+
63+
result = action.run(**test_dict)
64+
self.assertEqual(result, expected_result)
65+
mock_connect_to_db.assert_called_once_with(connection_config)
66+
mock_sqlalchemy.Table.assert_called_once_with(test_dict['table'],
67+
action_meta,
68+
autoload=True,
69+
autoload_with=action_engine)
70+
mock_connection.execute.assert_called_once_with(mock_values_return, execute_dict)
71+
72+
@mock.patch('lib.base_action.BaseAction.connect_to_db')
73+
@mock.patch('update.sqlalchemy')
74+
def test_run_array(self, mock_sqlalchemy, mock_connect_to_db):
75+
action = self.get_action_instance(self.config_good)
76+
connection_name = 'full'
77+
connection_config = self.config_good['sql'][connection_name]
78+
test_dict = {
79+
'connection': connection_name,
80+
'table': 'Test_Table',
81+
'update_data': {
82+
'column_2': 'value_2'
83+
}
84+
}
85+
expected_result = {'affected_rows': 20}
86+
action_meta = 'MetaData'
87+
action_engine = "Engine Data"
88+
mock_connect_to_db.return_value = "Successfully connected"
89+
mock_values = mock.Mock()
90+
mock_values_return = "Where and Values object"
91+
mock_values.values.return_value = mock_values_return
92+
mock_sql_table = mock.Mock()
93+
mock_sql_table.update.return_value = mock_values
94+
mock_sql_table.c.get.return_value = "column return"
95+
mock_query_results = mock.Mock(rowcount=20)
96+
mock_connection = mock.Mock()
97+
mock_connection.execute.return_value = mock_query_results
98+
mock_connection.close.return_value = "Successfully disconnected"
99+
100+
action.conn = mock_connection
101+
action.meta = action_meta
102+
action.engine = action_engine
103+
mock_sqlalchemy.Table.return_value = mock_sql_table
104+
105+
result = action.run(**test_dict)
106+
self.assertEqual(result, expected_result)
107+
mock_connect_to_db.assert_called_once_with(connection_config)
108+
mock_sqlalchemy.Table.assert_called_once_with(test_dict['table'],
109+
action_meta,
110+
autoload=True,
111+
autoload_with=action_engine)
112+
mock_connection.execute.assert_called_once_with(mock_values_return,
113+
test_dict['update_data'])

0 commit comments

Comments
 (0)