dps-sdk/test/instance/sdk.go

package instance

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

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

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

type ToolKit struct {
	t *testing.T
}

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

func (toolKit *ToolKit) autoMigrate(items []client.AutoMigrateItem) *ToolKit {
	err := dps.AutoMigrate(items...)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	return toolKit
}

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

	return toolKit
}

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

	return toolKit
}

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

	return toolKit
}

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

	return toolKit
}

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

	return toolKit
}

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

	return toolKit
}

func (toolKit *ToolKit) reply(req *client.ReplayRequest) *ToolKit {
	err := dps.Replay(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	return toolKit
}

func (toolKit *ToolKit) queryByWhereAndOrderBy(req *client.QueryByWhereAndOrderByRequest, retTableRows *[]client.TableRow, retTotalCount *int64) *ToolKit {
	tableRows, totalCount, err := dps.QueryByWhereAndOrderBy(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retTableRows != nil {
		*retTableRows = tableRows
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) commonQuery(req *client.CommonQueryRequest, retTableRows *[]client.TableRow, retTotalCount *int64) *ToolKit {
	tableRows, totalCount, err := dps.CommonQuery(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retTableRows != nil {
		*retTableRows = tableRows
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) queryOnlyByWhereAndOrderBy(req *client.QueryByWhereAndOrderByRequest, retTableRows *[]client.TableRow) *ToolKit {
	tableRows, err := dps.QueryOnlyByWhereAndOrderBy(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retTableRows != nil {
		*retTableRows = tableRows
	}

	return toolKit
}

func (toolKit *ToolKit) commonQueryOnly(req *client.CommonQueryRequest, retTableRows *[]client.TableRow) *ToolKit {
	tableRows, err := dps.CommonQueryOnly(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retTableRows != nil {
		*retTableRows = tableRows
	}

	return toolKit
}

func (toolKit *ToolKit) queryByKeys(req *client.QueryByKeysRequest, retTableRow *client.TableRow) *ToolKit {
	tableRow, err := dps.QueryByKeys(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retTableRow != nil {
		*retTableRow = *tableRow
	}

	return toolKit
}

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

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

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

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) checkExistWhere(req *client.CountWhereRequest, retExist *bool) *ToolKit {
	exist, err := dps.CheckExistWhere(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retExist != nil {
		*retExist = exist
	}

	return toolKit
}

func (toolKit *ToolKit) commonCheckExist(req *client.CommonCountRequest, retExist *bool) *ToolKit {
	exist, err := dps.CommonCheckExist(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retExist != nil {
		*retExist = exist
	}

	return toolKit
}

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

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

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

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

	if retInfos != nil {
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) eventQueryOnlyByKeys(req *client.EventQueryByKeysRequest, retInfos *[]client.EventInfo) *ToolKit {
	infos, err := dps.EventQueryOnlyByKeys(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retInfos != nil {
		*retInfos = infos
	}

	return toolKit
}

func (toolKit *ToolKit) commonEventQueryOnly(req *client.CommonEventQueryRequest, retInfos *[]client.EventInfo) *ToolKit {
	infos, err := dps.CommonEventQueryOnly(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retInfos != nil {
		*retInfos = infos
	}

	return toolKit
}

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

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

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

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) checkEventExistByKeys(req *client.CountEventByKeysRequest, retExist *bool) *ToolKit {
	exist, err := dps.CheckEventExistByKeys(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retExist != nil {
		*retExist = exist
	}

	return toolKit
}

func (toolKit *ToolKit) commonCheckEventExist(req *client.CommonCountEventRequest, retExist *bool) *ToolKit {
	exist, err := dps.CommonCheckEventExist(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retExist != nil {
		*retExist = exist
	}

	return toolKit
}

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

	if retInfos != nil {
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

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

	if retInfos != nil {
		*retInfos = infos
	}

	if retTotalCount != nil {
		*retTotalCount = totalCount
	}

	return toolKit
}

func (toolKit *ToolKit) eventHistoryQueryOnlyByKeys(req *client.EventQueryByKeysRequest, retInfos *[]client.EventInfo) *ToolKit {
	infos, err := dps.EventHistoryQueryOnlyByKeys(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retInfos != nil {
		*retInfos = infos
	}

	return toolKit
}

func (toolKit *ToolKit) commonEventHistoryQueryOnly(req *client.CommonEventQueryRequest, retInfos *[]client.EventInfo) *ToolKit {
	infos, err := dps.CommonEventHistoryQueryOnly(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retInfos != nil {
		*retInfos = infos
	}

	return toolKit
}

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

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

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

	if retCount != nil {
		*retCount = count
	}

	return toolKit
}

func (toolKit *ToolKit) checkEventHistoryExistByKeys(req *client.CountEventByKeysRequest, retExist *bool) *ToolKit {
	exist, err := dps.CheckEventHistoryExistByKeys(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retExist != nil {
		*retExist = exist
	}

	return toolKit
}

func (toolKit *ToolKit) commonCheckEventHistoryExist(req *client.CommonCountEventRequest, retExist *bool) *ToolKit {
	exist, err := dps.CommonCheckEventHistoryExist(req)
	if err != nil {
		toolKit.t.Fatal(err)
	}

	if retExist != nil {
		*retExist = exist
	}

	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
}