dps-sdk/test/v1/sdk.go

package v1

import (
	"fmt"
	"git.sxidc.com/service-supports/dps-sdk"
	"git.sxidc.com/service-supports/dps-sdk/client"
	"github.com/stretchr/testify/assert"
	"testing"
)

var clientInstance client.Client

func initClient(t *testing.T, address string) {
	c, err := dps.NewClient(address, "v1")
	if err != nil {
		t.Fatal(err)
	}

	clientInstance = c
}

func destroyClient(t *testing.T) {
	err := dps.DestroyClient("v1")
	if err != nil {
		t.Fatal(err)
	}

	clientInstance = nil
}

type ToolKit struct {
	t *testing.T
}

func newToolKit(t *testing.T) *ToolKit {
	return &ToolKit{t: t}
}

func (toolKit *ToolKit) autoMigrate(databaseID string, req *client.AutoMigrateRequest) *ToolKit {
	err := clientInstance.AutoMigrate(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	return toolKit
}

func (toolKit *ToolKit) autoMigrateBatch(databaseID string, req *client.AutoMigrateBatchRequest) *ToolKit {
	err := clientInstance.AutoMigrateBatch(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	return toolKit
}

func (toolKit *ToolKit) transaction(databaseID string, txFunc client.TransactionFunc) *ToolKit {
	err := clientInstance.Transaction(databaseID, txFunc)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	return toolKit
}

func (toolKit *ToolKit) insert(databaseID string, req *client.InsertRequest) *ToolKit {
	statement, err := clientInstance.Insert(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	return toolKit
}

func (toolKit *ToolKit) insertBatch(databaseID string, req *client.InsertBatchRequest) *ToolKit {
	statement, err := clientInstance.InsertBatch(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	return toolKit
}

func (toolKit *ToolKit) delete(databaseID string, req *client.DeleteRequest) *ToolKit {
	statement, err := clientInstance.Delete(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	return toolKit
}

func (toolKit *ToolKit) deleteBatch(databaseID string, req *client.DeleteBatchRequest) *ToolKit {
	statement, err := clientInstance.DeleteBatch(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	return toolKit
}

func (toolKit *ToolKit) update(databaseID string, req *client.UpdateRequest) *ToolKit {
	statement, err := clientInstance.Update(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	return toolKit
}

func (toolKit *ToolKit) reply(databaseID string, req *client.ReplayRequest) *ToolKit {
	statement, err := clientInstance.Replay(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	return toolKit
}

func (toolKit *ToolKit) queryByWhereAndOrderBy(databaseID string, req *client.QueryByWhereAndOrderByRequest, retInfosMap *[]map[string]any, retTotalCount *int64) *ToolKit {
	statement, infosMap, totalCount, err := clientInstance.QueryByWhereAndOrderBy(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfosMap != nil {
		*retInfosMap = make([]map[string]any, 0)
		*retInfosMap = infosMap
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) commonQuery(databaseID string, req *client.CommonQueryRequest, retInfosMap *[]map[string]any, retTotalCount *int64) *ToolKit {
	statement, infosMap, totalCount, err := clientInstance.CommonQuery(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfosMap != nil {
		*retInfosMap = make([]map[string]any, 0)
		*retInfosMap = infosMap
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) queryByKeys(databaseID string, req *client.QueryByKeysRequest, retInfoMap *map[string]any) *ToolKit {
	statement, infoMap, err := clientInstance.QueryByKeys(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfoMap != nil {
		*retInfoMap = make(map[string]any)
		*retInfoMap = infoMap
	}

	return toolKit
}

func (toolKit *ToolKit) countWhere(databaseID string, req *client.CountWhereRequest, retCount *int64) *ToolKit {
	statement, count, err := clientInstance.CountWhere(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) commonCount(databaseID string, req *client.CommonCountRequest, retCount *int64) *ToolKit {
	statement, count, err := clientInstance.CommonCount(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) eventQueryByKeys(databaseID string, req *client.EventQueryByKeysRequest, retInfos *[]client.EventInfo, retTotalCount *int64) *ToolKit {
	statement, infos, totalCount, err := clientInstance.EventQueryByKeys(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfos != nil {
		*retInfos = make([]client.EventInfo, 0)
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) commonEventQuery(databaseID string, req *client.CommonEventQueryRequest, retInfos *[]client.EventInfo, retTotalCount *int64) *ToolKit {
	statement, infos, totalCount, err := clientInstance.CommonEventQuery(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfos != nil {
		*retInfos = make([]client.EventInfo, 0)
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) countEventByKeys(databaseID string, req *client.CountEventByKeysRequest, retCount *int64) *ToolKit {
	statement, count, err := clientInstance.CountEventByKeys(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) commonCountEvent(databaseID string, req *client.CommonCountEventRequest, retCount *int64) *ToolKit {
	statement, count, err := clientInstance.CommonCountEvent(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) eventHistoryQueryByKeys(databaseID string, req *client.EventQueryByKeysRequest, retInfos *[]client.EventInfo, retTotalCount *int64) *ToolKit {
	statement, infos, totalCount, err := clientInstance.EventHistoryQueryByKeys(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfos != nil {
		*retInfos = make([]client.EventInfo, 0)
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) commonEventHistoryQuery(databaseID string, req *client.CommonEventQueryRequest, retInfos *[]client.EventInfo, retTotalCount *int64) *ToolKit {
	statement, infos, totalCount, err := clientInstance.CommonEventHistoryQuery(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retInfos != nil {
		*retInfos = make([]client.EventInfo, 0)
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) countEventHistoryByKeys(databaseID string, req *client.CountEventByKeysRequest, retCount *int64) *ToolKit {
	statement, count, err := clientInstance.CountEventHistoryByKeys(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) commonCountEventHistory(databaseID string, req *client.CommonCountEventRequest, retCount *int64) *ToolKit {
	statement, count, err := clientInstance.CommonCountEventHistory(databaseID, req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	fmt.Println(statement)

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) assertEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) *ToolKit {
	assert.Equal(toolKit.t, expected, actual, msgAndArgs)
	return toolKit
}

func (toolKit *ToolKit) assertNotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) *ToolKit {
	assert.NotEqual(toolKit.t, expected, actual, msgAndArgs)
	return toolKit
}

func (toolKit *ToolKit) assertNotEmpty(object interface{}, msgAndArgs ...interface{}) *ToolKit {
	assert.NotEmpty(toolKit.t, object, msgAndArgs)
	return toolKit
}