gotest

package
v0.0.0-...-8d2f45b Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 13, 2026 License: MIT Imports: 18 Imported by: 0

README

gotest

gotest is a library that simulates the testing of cache, dao and handler.


Example of use

mock test cache

Example of a cache interface.

// UserExampleCache cache interface
type UserExampleCache interface {
	Set(ctx context.Context, id uint64, data *model.UserExample, duration time.Duration) error
	Get(ctx context.Context, id uint64) (ret *model.UserExample, err error)
}

// userExampleCache define a cache struct
type userExampleCache struct {
	cache cache.Cache
}

// NewUserExampleCache new a cache
func NewUserExampleCache(rdb *redis.Client) UserExampleCache {
	return &userExampleCache{
		// ...
	}
}

Test cache example

func newUserExampleCache() *gotest.RedisCache {
	testData := map[string]interface{}{
		"1": &model.UserExample{ID:1},
	}

	rc := gotest.NewRedisCache(testData)
	rc.ICache = NewUserExampleCache(rc.RedisClient)
	return rc
}

func Test_userExampleCache_Set(t *testing.T) {
	c := newUserExampleCache()
	defer c.Close()

	record := c.TestDataSlice[0].(*model.UserExample)
	err := c.ICache.(UserExampleCache).Set(c.Ctx, record.ID, record, time.Hour)
	if err != nil {
		t.Fatal(err)
	}
}

func Test_userExampleCache_Get(t *testing.T) {
	c := newUserExampleCache()
	defer c.Close()

	record := c.TestDataSlice[0].(*model.UserExample)
	err := c.ICache.(UserExampleCache).Set(c.Ctx, record.ID, record, time.Hour)
	if err != nil {
		t.Fatal(err)
	}

	got, err := c.ICache.(UserExampleCache).Get(c.Ctx, record.ID)
	if err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, record, got)
}

Simulation test dao

Click to see the specific example.


Mock Test Handler

func newHandler() *Handler {
	now := time.Now()
	testData := &User{
		ID:        1,
		Name:      "foo",
		CreatedAt: now,
		UpdatedAt: now,
	}

	// init mock cache
	c := gotest.NewCache(map[string]interface{}{"no cache": testData})
	c.ICache = struct{}{} // instantiated cache interface

	// init mock dao
	d := gotest.NewDao(c, testData)
	d.IDao = struct{}{} // instantiated dao interface

	// init mock handler
	h := gotest.NewHandler(d, testData)
	h.IHandler = struct{}{} // instantiated handler interface

	h := newHandler()
	defer h.Close()

	h.GoRunHttpServer([]gotest.RouterInfo{
		{
			FuncName: "GetByID",
			Method:   http.MethodGet,
			Path:     "/user/:id",
			HandlerFunc: func(c *gin.Context) {
				c.String(http.StatusOK, testData.Name)
			},
		},
	})

	return h
}

func TestGetHello(t *testing.T) {
	h := newHandler()
	defer h.Close()
	testData := h.TestData.(*User)

	rows := sqlmock.NewRows([]string{"id", "created_at", "updated_at"}).
		AddRow(testData.ID, testData.CreatedAt, testData.UpdatedAt)

	h.MockDao.SqlMock.ExpectQuery("SELECT .*").
		WithArgs(testData.ID).
		WillReturnRows(rows)

	result := &httpcli.StdResult{}
	err := httpcli.Get(result, h.GetRequestURL("GetByID", testData.ID))
	if err != nil {
		t.Fatal(err)
	}
	if result.Code != 0 {
		t.Fatalf("%+v", result)
	}
}

Documentation

Overview

Package gotest is a library that simulates the testing of cache, dao and handler.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Cache

type Cache struct {
	Ctx           context.Context
	TestDataSlice []any
	TestDataMap   map[string]any
	RedisClient   *redis.Client

	ICache any
	// contains filtered or unexported fields
}

Cache redis cache

func NewCache

func NewCache(testDataMap map[string]any) *Cache

NewCache instantiated redis cache

func (*Cache) Close

func (c *Cache) Close()

Close redis server

func (*Cache) GetFields

func (c *Cache) GetFields() []string

GetFields get test data fields

func (*Cache) GetIDs

func (c *Cache) GetIDs() []uint64

GetIDs get test data ids

func (*Cache) GetTestData

func (c *Cache) GetTestData() map[string]any

GetTestData get test data

type Dao

type Dao struct {
	Ctx      context.Context
	TestData any
	SQLMock  sqlmock.Sqlmock
	Cache    *Cache
	DB       *gorm.DB
	IDao     any
	AnyTime  *anyTime
	// contains filtered or unexported fields
}

Dao dao info

func NewDao

func NewDao(c *Cache, testData any) *Dao

NewDao instantiated dao

func (*Dao) Close

func (d *Dao) Close()

Close dao

func (*Dao) GetAnyArgs

func (d *Dao) GetAnyArgs(obj any) []driver.Value

GetAnyArgs Dynamic generation of parameter types based on structures

type Handler

type Handler struct {
	TestData any
	MockDao  *Dao
	IHandler any

	Engine     *gin.Engine
	HTTPServer *http.Server
	// contains filtered or unexported fields
}

Handler info

func NewHandler

func NewHandler(dao *Dao, testData any) *Handler

NewHandler instantiated handler

func (*Handler) Close

func (h *Handler) Close()

Close handler

func (*Handler) GetRequestURL

func (h *Handler) GetRequestURL(funcName string, pathVal ...any) string

GetRequestURL get request url from name

func (*Handler) GoRunHTTPServer

func (h *Handler) GoRunHTTPServer(fns []RouterInfo)

GoRunHTTPServer run http server

type RCCache

type RCCache struct {
	Ctx           context.Context
	TestDataSlice []any
	TestDataMap   map[string]any
	RedisClient   *redis.ClusterClient

	ICache any
	// contains filtered or unexported fields
}

RCCache redis cluster cache

func NewRCCache

func NewRCCache(testDataMap map[string]any) *RCCache

NewRCCache instantiated redis cluster cache

func (*RCCache) Close

func (c *RCCache) Close()

Close redis server

func (*RCCache) GetIDs

func (c *RCCache) GetIDs() []uint64

GetIDs get test data ids

func (*RCCache) GetTestData

func (c *RCCache) GetTestData() map[string]any

GetTestData get test data

type RouterInfo

type RouterInfo struct {
	FuncName    string
	Method      string
	Path        string
	HandlerFunc gin.HandlerFunc
}

RouterInfo router info

type Service

type Service struct {
	Ctx      context.Context
	TestData any
	MockDao  *Dao

	Server *grpc.Server

	IServiceClient any
	// contains filtered or unexported fields
}

Service info

func NewService

func NewService(dao *Dao, testData any) *Service

NewService instantiated service

func (*Service) Close

func (s *Service) Close()

Close service

func (*Service) GetClientConn

func (s *Service) GetClientConn() *grpc.ClientConn

GetClientConn dial rpc server

func (*Service) GoGrpcServer

func (s *Service) GoGrpcServer()

GoGrpcServer run grpc server

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
⌂ 换网址