micro-client-mock/mock.go
Vasiliy Tolstov 3f5fc8ec06 initial import
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
2023-03-30 02:24:54 +03:00

252 lines
5.5 KiB
Go

package mock
import (
"context"
"fmt"
"reflect"
"strings"
"sync"
"time"
"go.unistack.org/micro/v3/client"
"go.unistack.org/micro/v3/codec"
"go.unistack.org/micro/v3/errors"
rutil "go.unistack.org/micro/v3/util/reflect"
)
var _ client.Client = (*MockClient)(nil)
type MockClient struct {
opts client.Options
mu sync.Mutex
expected []expectation
}
func (c *MockClient) newCodec(ct string) (codec.Codec, error) {
if idx := strings.IndexRune(ct, ';'); idx >= 0 {
ct = ct[:idx]
}
if cc, ok := c.opts.Codecs[ct]; ok {
return cc, nil
}
return nil, codec.ErrUnknownContentType
}
// an expectation interface
type expectation interface {
fulfilled() bool
Lock()
Unlock()
String() string
}
// common expectation struct
// satisfies the expectation interface
type commonExpectation struct {
sync.Mutex
triggered bool
err error
}
func (e *commonExpectation) fulfilled() bool {
return e.triggered
}
// ExpectedRequest is used to manage client.Call expectations.
// Returned by *MockClient.ExpectRequest.
type ExpectedRequest struct {
commonExpectation
delay time.Duration
rsp interface{}
req client.Request
}
// WillDelayFor allows to specify duration for which it will delay result. May
// be used together with Context.
func (e *ExpectedRequest) WillDelayFor(duration time.Duration) *ExpectedRequest {
e.delay = duration
return e
}
// WillReturnError allows to set an error for expected client.Call
func (e *ExpectedRequest) WillReturnError(err error) *ExpectedRequest {
e.err = err
return e
}
// WillReturnResponse allows to set a response for expected client.Call
func (e *ExpectedRequest) WillReturnResponse(rsp interface{}) *ExpectedRequest {
e.rsp = rsp
return e
}
// String returns string representation
func (e *ExpectedRequest) String() string {
msg := "ExpectedRequest => expecting client.Call request"
if e.err != nil {
msg += fmt.Sprintf(", which should return error: %s", e.err)
}
if e.rsp != nil {
msg += fmt.Sprintf(", which should return rsp: %v", e.rsp)
}
return msg
}
func (c *MockClient) ExpectationsWereMet() error {
for _, e := range c.expected {
e.Lock()
fulfilled := e.fulfilled()
e.Unlock()
if !fulfilled {
return fmt.Errorf("there is a remaining expectation which was not matched: %s", e)
}
}
return nil
}
func (c *MockClient) ExpectRequest(req client.Request) *ExpectedRequest {
e := &ExpectedRequest{req: req}
c.expected = append(c.expected, e)
return e
}
func (c *MockClient) BatchPublish(ctx context.Context, msgs []client.Message, opts ...client.PublishOption) error {
return nil
}
func (c *MockClient) Publish(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
return nil // c.opts.Broker.Publish()
}
func (c *MockClient) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
c.mu.Lock()
defer c.mu.Unlock()
options := client.NewCallOptions(opts...)
ct := req.ContentType()
if len(options.ContentType) > 0 {
ct = options.ContentType
}
cf, err := c.newCodec(ct)
if err != nil {
return errors.BadRequest("go.micro.client", err.Error())
}
for _, e := range c.expected {
er, ok := e.(*ExpectedRequest)
if !ok {
continue
}
if er.delay > 0 {
time.Sleep(er.delay)
}
if er.req.Service() != req.Service() ||
er.req.Method() != req.Method() {
continue
}
er.triggered = true
if er.err != nil {
return er.err
}
if er.req == nil {
return errors.BadRequest("go.micro.client", "empty request passed")
}
src := er.req.Body()
switch reqbody := er.req.Body().(type) {
case []byte:
src, err = rutil.Zero(req.Body())
if err == nil {
err = cf.Unmarshal(reqbody, src)
}
if err != nil {
return errors.BadRequest("go.micro.client", err.Error())
}
case client.Request:
break
default:
return errors.BadRequest("go.micro.client", "unknown request passed: %v", reqbody)
}
if !reflect.DeepEqual(req.Body(), src) {
return errors.BadRequest("go.micro.client", "unexpected request %v != %v", req.Body(), src)
}
if er.rsp == nil {
return nil
}
switch rspbody := er.rsp.(type) {
case []byte:
if err = cf.Unmarshal(rspbody, rsp); err != nil {
return errors.BadRequest("go.micro.client", err.Error())
}
return nil
}
v := reflect.ValueOf(rsp)
if t := reflect.TypeOf(rsp); t.Kind() == reflect.Ptr {
v = reflect.Indirect(v)
}
response := er.rsp
if t := reflect.TypeOf(er.rsp); t.Kind() == reflect.Func {
response = reflect.ValueOf(er.rsp).Call([]reflect.Value{})[0].Interface()
}
v.Set(reflect.ValueOf(response))
return nil
}
return fmt.Errorf("can't find service %s", req.Method())
}
func (c *MockClient) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
return nil, nil
}
func (c *MockClient) Init(opts ...client.Option) error {
for _, o := range opts {
o(&c.opts)
}
return nil
}
func (c *MockClient) String() string {
return "mock"
}
func (c *MockClient) Name() string {
return c.opts.Name
}
func (c *MockClient) Options() client.Options {
return c.opts
}
func (c *MockClient) NewMessage(topic string, msg interface{}, opts ...client.MessageOption) client.Message {
return nil
}
func (c *MockClient) NewRequest(service, method string, req interface{}, opts ...client.RequestOption) client.Request {
return newRequest(service, method, req, c.opts.ContentType, opts...)
}
func NewClient(opts ...client.Option) *MockClient {
options := client.NewOptions(opts...)
return &MockClient{opts: options}
}