def test_after_map(self): mock = Mock() self.rasa_plugin.after_map(mock) calls = [ call.connect("databot_user_message", "/databot/user/message", controller="ckanext.rasa.controller:RasaPluginController", action="send_user_message"), call.connect("data_bot", "/databot",controller="ckanext.rasa.controller:RasaPluginController", action="databot_index") ] self.assertEqual(mock.mock_calls, calls)
def test_close(self, mysql_mock, db_, cursor_mock): db_.close() calls = [ call.connect(host='localhost', user='******', password='******', database='default'), call.connect().cursor(), call.connect().cursor().close(), call.connect().close() ] assert mysql_mock.mock_calls == calls
def test_init(self, mysql_mock): MySQLHelper(host='127.0.0.1', user='******', password='******', database='test_db', pooled=False) assert mysql_mock.mock_calls == [ call.connect(host='127.0.0.1', user='******', password='******', database='test_db'), call.connect().cursor() ]
def test_init_none_pghelper(self, postgresql_mock): PostgreSQLHelper(host=None, user='******', password='******', database='test_db', pooled=False) assert postgresql_mock.mock_calls == [ call.connect(host='localhost', user='******', password='******', database='test_db'), call.connect().cursor() ]
def install_test(self, remote_cls, installation_cls, transaction_cls): """Test flatpak installation is working.""" flatpak = FlatpakPayload("remote/path") self._setup_flatpak_objects(remote_cls, installation_cls, transaction_cls) flatpak.initialize_with_system_path() mock_ref_list = [ RefMock(name="org.space.coolapp", kind=RefKind.APP, arch="x86_64", branch="stable"), RefMock(name="com.prop.notcoolapp", kind=RefKind.APP, arch="i386", branch="f36"), RefMock(name="org.space.coolruntime", kind=RefKind.RUNTIME, arch="x86_64", branch="stable"), RefMock(name="com.prop.notcoolruntime", kind=RefKind.RUNTIME, arch="i386", branch="f36") ] self._installation.list_remote_refs_sync.return_value = mock_ref_list flatpak.install_all() expected_calls = [ call.connect("new_operation", flatpak._operation_started_callback), call.connect("operation_done", flatpak._operation_stopped_callback), call.connect("operation_error", flatpak._operation_error_callback), call.add_install(FlatpakPayload.LOCAL_REMOTE_NAME, mock_ref_list[0].format_ref(), None), call.add_install(FlatpakPayload.LOCAL_REMOTE_NAME, mock_ref_list[1].format_ref(), None), call.add_install(FlatpakPayload.LOCAL_REMOTE_NAME, mock_ref_list[2].format_ref(), None), call.add_install(FlatpakPayload.LOCAL_REMOTE_NAME, mock_ref_list[3].format_ref(), None), call.run() ] self.assertEqual(self._transaction.mock_calls, expected_calls)
def test_init_extra_args_no_pool(self, mysql_mock): MySQLHelper(host='127.0.0.1', user='******', password='******', database='test_db', pooled=False, database_args={"ssl_ca": "file"}) assert mysql_mock.mock_calls == [ call.connect(host='127.0.0.1', user='******', password='******', database='test_db', ssl_ca="file"), call.connect().cursor() ]
def test_make_socket(self, sender): with patch('socket.socket'): sock = sender._make_socket() assert sock.mock_calls == [ call.settimeout(sender.timeout), call.connect((sender.host, sender.port)) ]
def test_conn_cached_closed(instance, sshclient): instance.config['host'] = 'localhost' instance.config['fingerprint'] = 'foo' first_client = MagicMock() first_client.get_transport.return_value = None second_client = MagicMock() sshclient.side_effect = [first_client, second_client] conn = instance.conn assert len(first_client.method_calls) == 3 assert [x[0] for x in first_client.method_calls] == [ 'set_missing_host_key_policy', 'connect', 'save_host_keys'] conn1 = instance.conn assert conn1 is not conn assert conn1 is not first_client assert conn1 is second_client assert len(first_client.method_calls) == 4 assert [x[0] for x in first_client.method_calls] == [ 'set_missing_host_key_policy', 'connect', 'save_host_keys', 'get_transport'] assert len(second_client.method_calls) == 3 assert second_client.method_calls[0][0] == 'set_missing_host_key_policy' assert second_client.method_calls[1] == call.connect('localhost', username='******', key_filename=None, password=None, sock=None, port=22) assert second_client.method_calls[2] == call.save_host_keys(instance.master.known_hosts)
def test_after_map(self): mock = Mock() self.rasa_plugin.after_map(mock) calls = [ call.connect( "databot_user_message", "/databot/user/message", controller="ckanext.rasa.controller:RasaPluginController", action="send_user_message"), call.connect( "data_bot", "/databot", controller="ckanext.rasa.controller:RasaPluginController", action="databot_index") ] self.assertEqual(mock.mock_calls, calls)
def test_conn(instance, sshclient): instance.config['host'] = 'localhost' instance.config['fingerprint'] = 'foo' conn = instance.conn assert len(conn.method_calls) == 3 assert conn.method_calls[0][0] == 'set_missing_host_key_policy' assert conn.method_calls[1] == call.connect('localhost', username='******', key_filename=None, password=None, sock=None, port=22) assert conn.method_calls[2] == call.save_host_keys(instance.master.known_hosts)
def test_insert_item(self): self.q.insertItem(user_id=1, prj_id=2, priority=10, data="mydata") # Check the db call of the item insert insert_call = call.connect().execute( 'insert into `test` (user_id, prj_id, priority, data) ' 'values(%s, %s, %s, %s)', [1, 2, 10, '"mydata"']) self.assertIn(insert_call, self.db_engine_mock.mock_calls) # Check the item existence and values in the in-memory queue priority, timestamp, item = heapq.heappop(self.q.pqueue._heap) self.assertEqual(-10, priority) self.assertEqual(item.getCreationTime(), timestamp) self.assertEqual(1, item.user_id) self.assertEqual(2, item.prj_id) self.assertEqual(10, item.priority) self.assertEqual(0, item.retry_count) self.assertIsNone(item.data) # TODO(vincent): should it be "mydata"?
def test_connect_signal_function(self): self.disconnect_signals() f = FileFieldAutoDelete('file_field') f(self.get_model()) self.assertEqual(len(models.signals.post_delete.receivers), 1) self.assertIs(models.signals.post_delete.receivers[0][1], f.get_signal_function()) self.restore_signals() self.disconnect_signals() mock = MagicMock() f = FileFieldAutoDelete('file_field', signal=mock) m = self.get_model() f(m) self.assertEqual(len(mock.mock_calls), 1) self.assertEqual(mock.mock_calls[0], call.connect( f.get_signal_function(), weak=False, dispatch_uid='post_delete_Model_delete_file_field', sender=m )) self.restore_signals()
def test__send__FullMessages(sock_mock): # The test assume that the socket is always correctly connected when # fileno is queried sock_mock().fileno.return_value = 11 message = 'ACommandWithParameters:#P1#P2;' msg_reply = 'ACommandWithParameters:done;' sock_mock().send.return_value = len(message) sock_mock().recv.return_value = msg_reply.encode() sock_conn = SocketConnector(host='127.0.0.3', port=10006) reply = sock_conn.__send__(message) assert reply == msg_reply sock_calls = [ call.connect(('127.0.0.3', 10006)), call.send(message.encode()), # call.shutdown(socket.SHUT_WR), call.recv(1024), call.fileno(), # This from is_connected() call.close() ] sock_mock().assert_has_calls(sock_calls)
def test_connect(self): self._subject.connect() assert_that(self._subject._connector.mock_calls, equal_to([call.connect()]))
def test_connect(self): self._subject.connect() assert_that(self._subject._sock.mock_calls, equal_to([call.connect((self._subject._ip, 4998))]))
class TestMySQLHelper: @fixture def mysql_mock(self, mocker): return mocker.patch('nova_api.persistence' '.mysql_helper.mysql.connector') @fixture def raise_exception(self): def side_effect_func(*args, **kwargs): raise mysql.connector.Error(errno=1146, sqlstate='42S02', msg="Table 'test.spam' doesn't exist") return side_effect_func @fixture def db_(self, mysql_mock): return MySQLHelper(pooled=False) @fixture def cursor_mock(self, mysql_mock): cursor_mock = mysql_mock.connect.return_value.cursor.return_value cursor_mock.rowcount = 1 cursor_mock.lastrowid = 1 return cursor_mock def test_init(self, mysql_mock): MySQLHelper(host='127.0.0.1', user='******', password='******', database='test_db', pooled=False) assert mysql_mock.mock_calls == [ call.connect(host='127.0.0.1', user='******', password='******', database='test_db'), call.connect().cursor() ] def test_init_extra_args_no_pool(self, mysql_mock): MySQLHelper(host='127.0.0.1', user='******', password='******', database='test_db', pooled=False, database_args={"ssl_ca": "file"}) assert mysql_mock.mock_calls == [ call.connect(host='127.0.0.1', user='******', password='******', database='test_db', ssl_ca="file"), call.connect().cursor() ] def test_init_pooled(self, mocker): pool_mock = mocker.patch("nova_api.persistence.mysql_helper.MySQLPool") MySQLHelper(host='127.0.0.1', user='******', password='******', database='test_db', pooled=True) assert pool_mock.mock_calls == [ call.get_instance(host='127.0.0.1', user='******', password='******', database='test_db', database_args={}), call.get_instance().get_connection(), call.get_instance().get_connection().cursor() ] def test_init_pooled_extra_args(self, mocker): pool_mock = mocker.patch("nova_api.persistence.mysql_helper.MySQLPool") MySQLHelper(host='127.0.0.1', user='******', password='******', database='test_db', pooled=True, database_args={"ssl_ca": "file"}) assert pool_mock.mock_calls == [ call.get_instance(host='127.0.0.1', user='******', password='******', database='test_db', database_args={"ssl_ca": "file"}), call.get_instance().get_connection(), call.get_instance().get_connection().cursor() ] def test_init_none(self, mysql_mock): MySQLHelper(host=None, user='******', password='******', database='test_db', pooled=False) assert mysql_mock.mock_calls == [ call.connect(host='localhost', user='******', password='******', database='test_db'), call.connect().cursor() ] @mark.parametrize( "query, params, calls", [("SELECT * FROM teste;", None, [call.connect().cursor().execute("SELECT * FROM teste;")]), ("SELECT * FROM teste WHERE id=%s;", [1], [ call.connect().cursor().execute( "SELECT * FROM teste WHERE id=%s;", [1]) ]), ("INSERT INTO t (a) VALUES (%s);", [1], [ call.connect().cursor().execute("INSERT INTO t (a) VALUES (%s);", [1]), call.connect().commit() ]), ("DELETE FROM t;", [1], [ call.connect().cursor().execute("DELETE FROM t;", [1]), call.connect().commit() ]), ("UPDATE t SET a=%s;", [1], [ call.connect().cursor().execute("UPDATE t SET a=%s;", [1]), call.connect().commit() ])]) def test_query(self, mysql_mock, cursor_mock, query, params, calls, db_): row_count, last_id = db_.query(query, params) assert ([call_ for call_ in calls if call_ in mysql_mock.mock_calls] == calls and row_count == 1 and last_id == 1) @mark.parametrize("results, returned", [([], None), ([[1, 2, 3]], [[1, 2, 3]])]) def test_get_results(self, mysql_mock, cursor_mock, results, returned, db_): cursor_mock.fetchall.return_value = results assert db_.get_results() == returned def test_close(self, mysql_mock, db_, cursor_mock): db_.close() calls = [ call.connect(host='localhost', user='******', password='******', database='default'), call.connect().cursor(), call.connect().cursor().close(), call.connect().close() ] assert mysql_mock.mock_calls == calls @mark.parametrize("exception_type", [ValueError, InterfaceError]) def test_fail_init(self, mysql_mock, exception_type): def raise_exception(*args, **kwargs): raise exception_type() mysql_mock.connect.side_effect = raise_exception with raises(ConnectionError): db_ = MySQLHelper(pooled=False) @mark.parametrize("exception_type", [InterfaceError, DatabaseError, Error]) def test_fail_query(self, mysql_mock, db_, exception_type): def raise_exception(*args, **kwargs): raise exception_type() cursor_mock = mysql_mock.connect.return_value.cursor.return_value cursor_mock.execute.side_effect = raise_exception with raises(RuntimeError): db_.query("SELECT * FROM table") @mark.parametrize("exception_type", [InterfaceError, DatabaseError, Error]) def test_fail_get_results(self, mysql_mock, db_, exception_type): def raise_exception(*args, **kwargs): raise exception_type() cursor_mock = mysql_mock.connect.return_value.cursor.return_value cursor_mock.fetchall.side_effect = raise_exception with raises(RuntimeError): db_.get_results() @mark.parametrize("cls, type_", [(bool, "TINYINT(1)"), (datetime, "DATETIME"), (str, "VARCHAR(100)"), (int, "INT"), (float, "DECIMAL"), (date, "DATE"), (TestEntity, "CHAR(32)")]) def test_predict_db_type(self, cls, type_, mysql_mock): helper = MySQLHelper(pooled=False) assert helper.predict_db_type(cls) == type_