This is an automated email from the ASF dual-hosted git repository.
jimin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-seata-go.git
The following commit(s) were added to refs/heads/master by this push:
new cc5edf7a test: improve test coverage for pkg/datasource/sql/mock (#976)
cc5edf7a is described below
commit cc5edf7a1982e2da55f9e71e74ee38722325c340
Author: 深几许 <[email protected]>
AuthorDate: Tue Nov 4 23:26:07 2025 +0800
test: improve test coverage for pkg/datasource/sql/mock (#976)
---
.../sql/mock/mock_datasource_manager_test.go | 209 ++++++++++++++++
.../sql/mock/mock_driver_components_test.go | 203 ++++++++++++++++
pkg/datasource/sql/mock/mock_driver_test.go | 262 +++++++++++++++++++++
.../sql/mock/mock_table_meta_cache_test.go | 91 +++++++
4 files changed, 765 insertions(+)
diff --git a/pkg/datasource/sql/mock/mock_datasource_manager_test.go
b/pkg/datasource/sql/mock/mock_datasource_manager_test.go
new file mode 100644
index 00000000..cfe00f98
--- /dev/null
+++ b/pkg/datasource/sql/mock/mock_datasource_manager_test.go
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mock
+
+import (
+ "context"
+ "database/sql"
+ "sync"
+ "testing"
+
+ "github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
+
+ "seata.apache.org/seata-go/pkg/datasource/sql/datasource"
+ "seata.apache.org/seata-go/pkg/datasource/sql/types"
+ "seata.apache.org/seata-go/pkg/protocol/branch"
+ "seata.apache.org/seata-go/pkg/rm"
+)
+
+func TestNewMockDataSourceManager(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ assert.NotNil(t, mockDSM)
+ assert.NotNil(t, mockDSM.EXPECT())
+}
+
+func TestMockDataSourceManager_BranchCommit(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ ctx := context.Background()
+ resource := rm.BranchResource{
+ ResourceId: "test-resource",
+ BranchId: 123,
+ Xid: "test-xid",
+ }
+
+ expectedStatus :=
branch.BranchStatus(branch.BranchStatusPhasetwoCommitted)
+ mockDSM.EXPECT().BranchCommit(ctx, resource).Return(expectedStatus, nil)
+
+ status, err := mockDSM.BranchCommit(ctx, resource)
+ assert.NoError(t, err)
+ assert.Equal(t, expectedStatus, status)
+}
+
+func TestMockDataSourceManager_BranchRollback(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ ctx := context.Background()
+ resource := rm.BranchResource{
+ ResourceId: "test-resource",
+ BranchId: 456,
+ Xid: "test-xid",
+ }
+
+ expectedStatus :=
branch.BranchStatus(branch.BranchStatusPhasetwoRollbacked)
+ mockDSM.EXPECT().BranchRollback(ctx, resource).Return(expectedStatus,
nil)
+
+ status, err := mockDSM.BranchRollback(ctx, resource)
+ assert.NoError(t, err)
+ assert.Equal(t, expectedStatus, status)
+}
+
+func TestMockDataSourceManager_BranchRegister(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ ctx := context.Background()
+ param := rm.BranchRegisterParam{
+ Xid: "test-xid",
+ ResourceId: "test-resource",
+ LockKeys: "key1,key2",
+ }
+
+ expectedBranchID := int64(789)
+ mockDSM.EXPECT().BranchRegister(ctx, param).Return(expectedBranchID,
nil)
+
+ branchID, err := mockDSM.BranchRegister(ctx, param)
+ assert.NoError(t, err)
+ assert.Equal(t, expectedBranchID, branchID)
+}
+
+func TestMockDataSourceManager_BranchReport(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ ctx := context.Background()
+ param := rm.BranchReportParam{
+ Xid: "test-xid",
+ BranchId: 123,
+ Status:
branch.BranchStatus(branch.BranchStatusPhasetwoCommitted),
+ }
+
+ mockDSM.EXPECT().BranchReport(ctx, param).Return(nil)
+
+ err := mockDSM.BranchReport(ctx, param)
+ assert.NoError(t, err)
+}
+
+func TestMockDataSourceManager_CreateTableMetaCache(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ ctx := context.Background()
+ resID := "test-resource"
+ dbType := types.DBTypeMySQL
+ db := &sql.DB{}
+
+ expectedCache := datasource.TableMetaCache(nil)
+ mockDSM.EXPECT().CreateTableMetaCache(ctx, resID, dbType,
db).Return(expectedCache, nil)
+
+ cache, err := mockDSM.CreateTableMetaCache(ctx, resID, dbType, db)
+ assert.NoError(t, err)
+ assert.Equal(t, expectedCache, cache)
+}
+
+func TestMockDataSourceManager_GetSetBranchType(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ expectedBranchType := branch.BranchTypeAT
+
+ mockDSM.SetBranchType(expectedBranchType)
+ branchType := mockDSM.GetBranchType()
+ assert.Equal(t, expectedBranchType, branchType)
+}
+
+func TestMockDataSourceManager_GetCachedResources(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ expectedMap := &sync.Map{}
+
+ mockDSM.EXPECT().GetCachedResources().Return(expectedMap)
+
+ resources := mockDSM.GetCachedResources()
+ assert.Equal(t, expectedMap, resources)
+}
+
+func TestMockDataSourceManager_LockQuery(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ ctx := context.Background()
+ param := rm.LockQueryParam{
+ Xid: "test-xid",
+ ResourceId: "test-resource",
+ LockKeys: "key1,key2",
+ }
+
+ expectedResult := true
+ mockDSM.EXPECT().LockQuery(ctx, param).Return(expectedResult, nil)
+
+ result, err := mockDSM.LockQuery(ctx, param)
+ assert.NoError(t, err)
+ assert.Equal(t, expectedResult, result)
+}
+
+func TestMockDataSourceManager_RegisterResource(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ resource := rm.Resource(nil)
+
+ mockDSM.EXPECT().RegisterResource(resource).Return(nil)
+
+ err := mockDSM.RegisterResource(resource)
+ assert.NoError(t, err)
+}
+
+func TestMockDataSourceManager_UnregisterResource(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDSM := NewMockDataSourceManager(ctrl)
+ resource := rm.Resource(nil)
+
+ mockDSM.EXPECT().UnregisterResource(resource).Return(nil)
+
+ err := mockDSM.UnregisterResource(resource)
+ assert.NoError(t, err)
+}
diff --git a/pkg/datasource/sql/mock/mock_driver_components_test.go
b/pkg/datasource/sql/mock/mock_driver_components_test.go
new file mode 100644
index 00000000..c01192c6
--- /dev/null
+++ b/pkg/datasource/sql/mock/mock_driver_components_test.go
@@ -0,0 +1,203 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mock
+
+import (
+ "context"
+ "database/sql/driver"
+ "testing"
+
+ "github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestNewMockTestDriverStmt(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ assert.NotNil(t, mockStmt)
+ assert.NotNil(t, mockStmt.EXPECT())
+}
+
+func TestMockTestDriverStmt_Close(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+
+ mockStmt.EXPECT().Close().Return(nil)
+
+ err := mockStmt.Close()
+ assert.NoError(t, err)
+}
+
+func TestMockTestDriverStmt_NumInput(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ expectedNum := 2
+
+ mockStmt.EXPECT().NumInput().Return(expectedNum)
+
+ num := mockStmt.NumInput()
+ assert.Equal(t, expectedNum, num)
+}
+
+func TestMockTestDriverStmt_Exec(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ args := []driver.Value{"test", 123}
+ result := driver.Result(nil)
+
+ mockStmt.EXPECT().Exec(args).Return(result, nil)
+
+ res, err := mockStmt.Exec(args)
+ assert.NoError(t, err)
+ assert.Equal(t, result, res)
+}
+
+func TestMockTestDriverStmt_ExecContext(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ ctx := context.Background()
+ args := []driver.NamedValue{{Value: "test"}, {Value: 123}}
+ result := driver.Result(nil)
+
+ mockStmt.EXPECT().ExecContext(ctx, args).Return(result, nil)
+
+ res, err := mockStmt.ExecContext(ctx, args)
+ assert.NoError(t, err)
+ assert.Equal(t, result, res)
+}
+
+func TestMockTestDriverStmt_Query(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ mockRows := NewMockTestDriverRows(ctrl)
+ args := []driver.Value{"test"}
+
+ mockStmt.EXPECT().Query(args).Return(mockRows, nil)
+
+ rows, err := mockStmt.Query(args)
+ assert.NoError(t, err)
+ assert.Equal(t, mockRows, rows)
+}
+
+func TestMockTestDriverStmt_QueryContext(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ mockRows := NewMockTestDriverRows(ctrl)
+ ctx := context.Background()
+ args := []driver.NamedValue{{Value: "test"}}
+
+ mockStmt.EXPECT().QueryContext(ctx, args).Return(mockRows, nil)
+
+ rows, err := mockStmt.QueryContext(ctx, args)
+ assert.NoError(t, err)
+ assert.Equal(t, mockRows, rows)
+}
+
+func TestNewMockTestDriverTx(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockTx := NewMockTestDriverTx(ctrl)
+ assert.NotNil(t, mockTx)
+ assert.NotNil(t, mockTx.EXPECT())
+}
+
+func TestMockTestDriverTx_Commit(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockTx := NewMockTestDriverTx(ctrl)
+
+ mockTx.EXPECT().Commit().Return(nil)
+
+ err := mockTx.Commit()
+ assert.NoError(t, err)
+}
+
+func TestMockTestDriverTx_Rollback(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockTx := NewMockTestDriverTx(ctrl)
+
+ mockTx.EXPECT().Rollback().Return(nil)
+
+ err := mockTx.Rollback()
+ assert.NoError(t, err)
+}
+
+func TestNewMockTestDriverRows(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockRows := NewMockTestDriverRows(ctrl)
+ assert.NotNil(t, mockRows)
+ assert.NotNil(t, mockRows.EXPECT())
+}
+
+func TestMockTestDriverRows_Columns(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockRows := NewMockTestDriverRows(ctrl)
+ expectedColumns := []string{"id", "name", "age"}
+
+ mockRows.EXPECT().Columns().Return(expectedColumns)
+
+ columns := mockRows.Columns()
+ assert.Equal(t, expectedColumns, columns)
+}
+
+func TestMockTestDriverRows_Close(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockRows := NewMockTestDriverRows(ctrl)
+
+ mockRows.EXPECT().Close().Return(nil)
+
+ err := mockRows.Close()
+ assert.NoError(t, err)
+}
+
+func TestMockTestDriverRows_Next(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockRows := NewMockTestDriverRows(ctrl)
+ dest := make([]driver.Value, 3)
+
+ mockRows.EXPECT().Next(dest).Return(nil)
+
+ err := mockRows.Next(dest)
+ assert.NoError(t, err)
+}
diff --git a/pkg/datasource/sql/mock/mock_driver_test.go
b/pkg/datasource/sql/mock/mock_driver_test.go
new file mode 100644
index 00000000..fb538d9b
--- /dev/null
+++ b/pkg/datasource/sql/mock/mock_driver_test.go
@@ -0,0 +1,262 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mock
+
+import (
+ "context"
+ "database/sql/driver"
+ "testing"
+
+ "github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestNewMockTestDriver(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDriver := NewMockTestDriver(ctrl)
+ assert.NotNil(t, mockDriver)
+ assert.NotNil(t, mockDriver.EXPECT())
+}
+
+func TestMockTestDriver_Open(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockDriver := NewMockTestDriver(ctrl)
+ mockConn := NewMockTestDriverConn(ctrl)
+ dsn := "test:test@tcp(localhost:3306)/test"
+
+ mockDriver.EXPECT().Open(dsn).Return(mockConn, nil)
+
+ conn, err := mockDriver.Open(dsn)
+ assert.NoError(t, err)
+ assert.Equal(t, mockConn, conn)
+}
+
+func TestNewMockTestDriverConnector(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConnector := NewMockTestDriverConnector(ctrl)
+ assert.NotNil(t, mockConnector)
+ assert.NotNil(t, mockConnector.EXPECT())
+}
+
+func TestMockTestDriverConnector_Connect(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConnector := NewMockTestDriverConnector(ctrl)
+ mockConn := NewMockTestDriverConn(ctrl)
+ ctx := context.Background()
+
+ mockConnector.EXPECT().Connect(ctx).Return(mockConn, nil)
+
+ conn, err := mockConnector.Connect(ctx)
+ assert.NoError(t, err)
+ assert.Equal(t, mockConn, conn)
+}
+
+func TestMockTestDriverConnector_Driver(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConnector := NewMockTestDriverConnector(ctrl)
+ mockDriver := NewMockTestDriver(ctrl)
+
+ mockConnector.EXPECT().Driver().Return(mockDriver)
+
+ drv := mockConnector.Driver()
+ assert.Equal(t, mockDriver, drv)
+}
+
+func TestNewMockTestDriverConn(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ assert.NotNil(t, mockConn)
+ assert.NotNil(t, mockConn.EXPECT())
+}
+
+func TestMockTestDriverConn_Close(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+
+ mockConn.EXPECT().Close().Return(nil)
+
+ err := mockConn.Close()
+ assert.NoError(t, err)
+}
+
+func TestMockTestDriverConn_Begin(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ mockTx := NewMockTestDriverTx(ctrl)
+
+ mockConn.EXPECT().Begin().Return(mockTx, nil)
+
+ tx, err := mockConn.Begin()
+ assert.NoError(t, err)
+ assert.Equal(t, mockTx, tx)
+}
+
+func TestMockTestDriverConn_BeginTx(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ mockTx := NewMockTestDriverTx(ctrl)
+ ctx := context.Background()
+ opts := driver.TxOptions{}
+
+ mockConn.EXPECT().BeginTx(ctx, opts).Return(mockTx, nil)
+
+ tx, err := mockConn.BeginTx(ctx, opts)
+ assert.NoError(t, err)
+ assert.Equal(t, mockTx, tx)
+}
+
+func TestMockTestDriverConn_Prepare(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ query := "SELECT * FROM test WHERE id = ?"
+
+ mockConn.EXPECT().Prepare(query).Return(mockStmt, nil)
+
+ stmt, err := mockConn.Prepare(query)
+ assert.NoError(t, err)
+ assert.Equal(t, mockStmt, stmt)
+}
+
+func TestMockTestDriverConn_PrepareContext(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ mockStmt := NewMockTestDriverStmt(ctrl)
+ ctx := context.Background()
+ query := "SELECT * FROM test WHERE id = ?"
+
+ mockConn.EXPECT().PrepareContext(ctx, query).Return(mockStmt, nil)
+
+ stmt, err := mockConn.PrepareContext(ctx, query)
+ assert.NoError(t, err)
+ assert.Equal(t, mockStmt, stmt)
+}
+
+func TestMockTestDriverConn_Exec(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ query := "INSERT INTO test (name) VALUES (?)"
+ args := []driver.Value{"test"}
+ result := driver.Result(nil)
+
+ mockConn.EXPECT().Exec(query, args).Return(result, nil)
+
+ res, err := mockConn.Exec(query, args)
+ assert.NoError(t, err)
+ assert.Equal(t, result, res)
+}
+
+func TestMockTestDriverConn_ExecContext(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ ctx := context.Background()
+ query := "INSERT INTO test (name) VALUES (?)"
+ args := []driver.NamedValue{{Value: "test"}}
+ result := driver.Result(nil)
+
+ mockConn.EXPECT().ExecContext(ctx, query, args).Return(result, nil)
+
+ res, err := mockConn.ExecContext(ctx, query, args)
+ assert.NoError(t, err)
+ assert.Equal(t, result, res)
+}
+
+func TestMockTestDriverConn_Query(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ mockRows := NewMockTestDriverRows(ctrl)
+ query := "SELECT * FROM test"
+ args := []driver.Value{}
+
+ mockConn.EXPECT().Query(query, args).Return(mockRows, nil)
+
+ rows, err := mockConn.Query(query, args)
+ assert.NoError(t, err)
+ assert.Equal(t, mockRows, rows)
+}
+
+func TestMockTestDriverConn_QueryContext(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ mockRows := NewMockTestDriverRows(ctrl)
+ ctx := context.Background()
+ query := "SELECT * FROM test"
+ args := []driver.NamedValue{}
+
+ mockConn.EXPECT().QueryContext(ctx, query, args).Return(mockRows, nil)
+
+ rows, err := mockConn.QueryContext(ctx, query, args)
+ assert.NoError(t, err)
+ assert.Equal(t, mockRows, rows)
+}
+
+func TestMockTestDriverConn_Ping(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ ctx := context.Background()
+
+ mockConn.EXPECT().Ping(ctx).Return(nil)
+
+ err := mockConn.Ping(ctx)
+ assert.NoError(t, err)
+}
+
+func TestMockTestDriverConn_ResetSession(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockConn := NewMockTestDriverConn(ctrl)
+ ctx := context.Background()
+
+ mockConn.EXPECT().ResetSession(ctx).Return(nil)
+
+ err := mockConn.ResetSession(ctx)
+ assert.NoError(t, err)
+}
diff --git a/pkg/datasource/sql/mock/mock_table_meta_cache_test.go
b/pkg/datasource/sql/mock/mock_table_meta_cache_test.go
new file mode 100644
index 00000000..391e9909
--- /dev/null
+++ b/pkg/datasource/sql/mock/mock_table_meta_cache_test.go
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mock
+
+import (
+ "context"
+ "database/sql"
+ "testing"
+
+ "github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
+
+ "seata.apache.org/seata-go/pkg/datasource/sql/types"
+)
+
+func TestNewMockTableMetaCache(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockCache := NewMockTableMetaCache(ctrl)
+ assert.NotNil(t, mockCache)
+ assert.NotNil(t, mockCache.EXPECT())
+}
+
+func TestMockTableMetaCache_GetTableMeta(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockCache := NewMockTableMetaCache(ctrl)
+ ctx := context.Background()
+ dbName := "test_db"
+ tableName := "test_table"
+
+ expectedTableMeta := &types.TableMeta{
+ TableName: tableName,
+ Columns: map[string]types.ColumnMeta{
+ "id": {
+ ColumnName: "id",
+ ColumnType: "BIGINT",
+ },
+ },
+ }
+
+ mockCache.EXPECT().GetTableMeta(ctx, dbName,
tableName).Return(expectedTableMeta, nil)
+
+ tableMeta, err := mockCache.GetTableMeta(ctx, dbName, tableName)
+ assert.NoError(t, err)
+ assert.Equal(t, expectedTableMeta, tableMeta)
+ assert.Equal(t, tableName, tableMeta.TableName)
+}
+
+func TestMockTableMetaCache_Init(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockCache := NewMockTableMetaCache(ctrl)
+ ctx := context.Background()
+ db := &sql.DB{}
+
+ mockCache.EXPECT().Init(ctx, db).Return(nil)
+
+ err := mockCache.Init(ctx, db)
+ assert.NoError(t, err)
+}
+
+func TestMockTableMetaCache_Destroy(t *testing.T) {
+ ctrl := gomock.NewController(t)
+ defer ctrl.Finish()
+
+ mockCache := NewMockTableMetaCache(ctrl)
+
+ mockCache.EXPECT().Destroy().Return(nil)
+
+ err := mockCache.Destroy()
+ assert.NoError(t, err)
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
