From 57d06d5d273e7be46720a0d22444eb7eaf9cdcb9 Mon Sep 17 00:00:00 2001 From: Vasiliy Tolstov Date: Sun, 24 Apr 2022 11:08:38 +0300 Subject: [PATCH] add tests Signed-off-by: Vasiliy Tolstov --- service.go | 2 +- service_test.go | 747 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 748 insertions(+), 1 deletion(-) diff --git a/service.go b/service.go index 4ca11354..533cacf7 100644 --- a/service.go +++ b/service.go @@ -241,7 +241,7 @@ func (s *service) Meter(names ...string) meter.Meter { } func (s *service) String() string { - return "micro" + return s.opts.Name } //nolint:gocyclo diff --git a/service_test.go b/service_test.go index 1ee6a77f..38a4f2d9 100644 --- a/service_test.go +++ b/service_test.go @@ -1,7 +1,21 @@ package micro import ( + "reflect" + "context" "testing" + + "go.unistack.org/micro/v3/auth" + "go.unistack.org/micro/v3/broker" + "go.unistack.org/micro/v3/client" + "go.unistack.org/micro/v3/config" + "go.unistack.org/micro/v3/logger" + "go.unistack.org/micro/v3/meter" + "go.unistack.org/micro/v3/register" + "go.unistack.org/micro/v3/router" + "go.unistack.org/micro/v3/server" + "go.unistack.org/micro/v3/store" + "go.unistack.org/micro/v3/tracer" ) type testItem struct { @@ -20,3 +34,736 @@ func TestGetNameIndex(t *testing.T) { t.Fatalf("getNameIndex func error, item not found") } } + +func TestRegisterHandler(t *testing.T) { + type args struct { + s server.Server + h interface{} + opts []server.HandlerOption + } + h := struct{}{} + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "RegisterHandler", + args: args{ + s: server.DefaultServer, + h: h, + opts: nil, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := RegisterHandler(tt.args.s, tt.args.h, tt.args.opts...); (err != nil) != tt.wantErr { + t.Errorf("RegisterHandler() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestRegisterSubscriber(t *testing.T) { + type args struct { + topic string + s server.Server + h interface{} + opts []server.SubscriberOption + } + h := func(_ context.Context, _ interface{}) error { + return nil + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "RegisterSubscriber", + args: args{ + topic: "test", + s: server.DefaultServer, + h: h, + opts: nil, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := RegisterSubscriber(tt.args.topic, tt.args.s, tt.args.h, tt.args.opts...); (err != nil) != tt.wantErr { + t.Errorf("RegisterSubscriber() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + + +func TestNewService(t *testing.T) { + type args struct { + opts []Option + } + tests := []struct { + name string + args args + want Service + }{ + { + name: "NewService", + args: args { + opts: []Option{Name("test")}, + }, + want: NewService(Name("test")), + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewService(tt.args.opts...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewService() = %v, want %v", got.Options().Name, tt.want.Options().Name) + } + }) + } +} + + +func Test_service_Name(t *testing.T) { + type fields struct { + opts Options + } + tests := []struct { + name string + fields fields + want string + }{ + { + name: "Test_service_Name", + fields: fields { + opts: Options{Name: "test"}, + }, + want: "test", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Name(); got != tt.want { + t.Errorf("service.Name() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Init(t *testing.T) { + type fields struct { + opts Options + } + type args struct { + opts []Option + } + tests := []struct { + name string + fields fields + args args + wantErr bool + }{ + { + name: "service.Init()", + fields: fields{ + opts: Options{}, + }, + args: args{ +opts: []Option{}, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if err := s.Init(tt.args.opts...); (err != nil) != tt.wantErr { + t.Errorf("service.Init() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + + +func Test_service_Options(t *testing.T) { + opts := Options{Name:"test"} + type fields struct { + opts Options + } + tests := []struct { + name string + fields fields + want Options + }{ + { + name: "service.Options", + fields:fields{ +opts: opts, + }, + want: opts, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Options(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Options() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Broker(t *testing.T) { + b := broker.NewBroker() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want broker.Broker + }{ + { + name:"service.Broker", + fields: fields{ + opts: Options{Brokers: []broker.Broker{b}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: b, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Broker(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Broker() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Tracer(t *testing.T) { + tr := tracer.NewTracer() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want tracer.Tracer + }{ + { + name:"service.Tracer", + fields: fields{ + opts: Options{Tracers: []tracer.Tracer{tr}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: tr, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Tracer(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Tracer() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_service_Config(t *testing.T) { + c := config.NewConfig() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want config.Config + }{ + { + name:"service.Config", + fields: fields{ + opts: Options{Configs: []config.Config{c}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: c, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Config(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Config() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Client(t *testing.T) { + c := client.NewClient() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want client.Client + }{ + { + name:"service.Client", + fields: fields{ + opts: Options{Clients: []client.Client{c}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: c, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Client(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Client() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Server(t *testing.T) { + s := server.NewServer() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want server.Server + }{ + { + name:"service.Server", + fields: fields{ + opts: Options{Servers: []server.Server{s}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: s, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Server(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Server() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Store(t *testing.T) { + s := store.NewStore() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want store.Store + }{ + { + name:"service.Store", + fields: fields{ + opts: Options{Stores: []store.Store{s}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: s, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Store(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Store() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Register(t *testing.T) { + r := register.NewRegister() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want register.Register + }{ + { + name:"service.Register", + fields: fields{ + opts: Options{Registers: []register.Register{r}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: r, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Register(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Register() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_service_Logger(t *testing.T) { + l := logger.NewLogger() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want logger.Logger + }{ + { + name:"service.Logger", + fields: fields{ + opts: Options{Loggers: []logger.Logger{l}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: l, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Logger(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Logger() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_Auth(t *testing.T) { + a := auth.NewAuth() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want auth.Auth + }{ + { + name:"service.Auth", + fields: fields{ + opts: Options{Auths: []auth.Auth{a}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: a, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Auth(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Auth() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_service_Router(t *testing.T) { + r := router.NewRouter() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want router.Router + }{ + { + name:"service.Router", + fields: fields{ + opts: Options{Routers: []router.Router{r}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: r, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Router(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Router() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_service_Meter(t *testing.T) { + m := meter.NewMeter() + type fields struct { + opts Options + } + type args struct { + names []string + } + tests := []struct { + name string + fields fields + args args + want meter.Meter + }{ + { + name:"service.Meter", + fields: fields{ + opts: Options{Meters: []meter.Meter{m}}, + }, + args: args{ + names: []string{"noop"}, + }, + want: m, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.Meter(tt.args.names...); !reflect.DeepEqual(got, tt.want) { + t.Errorf("service.Meter() = %v, want %v", got, tt.want) + } + }) + } +} + + +func Test_service_String(t *testing.T) { + type fields struct { + opts Options + } + tests := []struct { + name string + fields fields + want string + }{ + { + name:"service.String", + fields: fields{ + opts: Options{Name: "noop"}, + }, + want: "noop", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + opts: tt.fields.opts, + } + if got := s.String(); got != tt.want { + t.Errorf("service.String() = %v, want %v", got, tt.want) + } + }) + } +} + +/* +func Test_service_Start(t *testing.T) { + type fields struct { + RWMutex sync.RWMutex + opts Options + } + tests := []struct { + name string + fields fields + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + RWMutex: tt.fields.RWMutex, + opts: tt.fields.opts, + } + if err := s.Start(); (err != nil) != tt.wantErr { + t.Errorf("service.Start() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_service_Stop(t *testing.T) { + type fields struct { + RWMutex sync.RWMutex + opts Options + } + tests := []struct { + name string + fields fields + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + RWMutex: tt.fields.RWMutex, + opts: tt.fields.opts, + } + if err := s.Stop(); (err != nil) != tt.wantErr { + t.Errorf("service.Stop() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_service_Run(t *testing.T) { + type fields struct { + RWMutex sync.RWMutex + opts Options + } + tests := []struct { + name string + fields fields + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &service{ + RWMutex: tt.fields.RWMutex, + opts: tt.fields.opts, + } + if err := s.Run(); (err != nil) != tt.wantErr { + t.Errorf("service.Run() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func Test_getNameIndex(t *testing.T) { + type args struct { + n string + ifaces interface{} + } + tests := []struct { + name string + args args + want int + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := getNameIndex(tt.args.n, tt.args.ifaces); got != tt.want { + t.Errorf("getNameIndex() = %v, want %v", got, tt.want) + } + }) + } +} +*/