Update structure, add tests for RPC

21 files changed, 281 insertions, 68 deletions

diff --git a/plugins/app/app.go b/plugins/app/plugin.go
index 312e5bc6..2ef851e8 100644
--- a/plugins/app/app.go
+++ b/plugins/app/plugin.go
@@ -26,15 +26,15 @@ type WorkerFactory interface {
 	NewWorkerPool(ctx context.Context, opt roadrunner.Config, env Env) (roadrunner.Pool, error)
 }
 
-// App manages worker
-type App struct {
+// Plugin manages worker
+type Plugin struct {
 	cfg     Config
 	log     *zap.Logger
 	factory roadrunner.Factory
 }
 
 // Init application provider.
-func (app *App) Init(cfg config.Provider, log *zap.Logger) error {
+func (app *Plugin) Init(cfg config.Configurer, log *zap.Logger) error {
 	err := cfg.UnmarshalKey(ServiceName, &app.cfg)
 	if err != nil {
 		return err
@@ -46,11 +46,11 @@ func (app *App) Init(cfg config.Provider, log *zap.Logger) error {
 }
 
 // Name contains service name.
-func (app *App) Name() string {
+func (app *Plugin) Name() string {
 	return ServiceName
 }
 
-func (app *App) Serve() chan error {
+func (app *Plugin) Serve() chan error {
 	errCh := make(chan error, 1)
 	var err error
 
@@ -62,7 +62,7 @@ func (app *App) Serve() chan error {
 	return errCh
 }
 
-func (app *App) Stop() error {
+func (app *Plugin) Stop() error {
 	if app.factory == nil {
 		return nil
 	}
@@ -71,7 +71,7 @@ func (app *App) Stop() error {
 }
 
 // CmdFactory provides worker command factory assocated with given context.
-func (app *App) CmdFactory(env Env) (func() *exec.Cmd, error) {
+func (app *Plugin) CmdFactory(env Env) (func() *exec.Cmd, error) {
 	var cmdArgs []string
 
 	// create command according to the config
@@ -97,7 +97,7 @@ func (app *App) CmdFactory(env Env) (func() *exec.Cmd, error) {
 }
 
 // NewWorker issues new standalone worker.
-func (app *App) NewWorker(ctx context.Context, env Env) (roadrunner.WorkerBase, error) {
+func (app *Plugin) NewWorker(ctx context.Context, env Env) (roadrunner.WorkerBase, error) {
 	spawnCmd, err := app.CmdFactory(env)
 	if err != nil {
 		return nil, err
@@ -114,7 +114,7 @@ func (app *App) NewWorker(ctx context.Context, env Env) (roadrunner.WorkerBase,
 }
 
 // NewWorkerPool issues new worker pool.
-func (app *App) NewWorkerPool(ctx context.Context, opt roadrunner.Config, env Env) (roadrunner.Pool, error) {
+func (app *Plugin) NewWorkerPool(ctx context.Context, opt roadrunner.Config, env Env) (roadrunner.Pool, error) {
 	spawnCmd, err := app.CmdFactory(env)
 	if err != nil {
 		return nil, err
@@ -131,7 +131,7 @@ func (app *App) NewWorkerPool(ctx context.Context, opt roadrunner.Config, env En
 }
 
 // creates relay and worker factory.
-func (app *App) initFactory() (roadrunner.Factory, error) {
+func (app *Plugin) initFactory() (roadrunner.Factory, error) {
 	if app.cfg.Relay == "" || app.cfg.Relay == "pipes" {
 		return roadrunner.NewPipeFactory(), nil
 	}
@@ -157,7 +157,7 @@ func (app *App) initFactory() (roadrunner.Factory, error) {
 	}
 }
 
-func (app *App) setEnv(e Env) []string {
+func (app *Plugin) setEnv(e Env) []string {
 	env := append(os.Environ(), fmt.Sprintf("RR_RELAY=%s", app.cfg.Relay))
 	for k, v := range e {
 		env = append(env, fmt.Sprintf("%s=%s", strings.ToUpper(k), v))
@@ -166,7 +166,7 @@ func (app *App) setEnv(e Env) []string {
 	return env
 }
 
-func (app *App) collectLogs(event interface{}) {
+func (app *Plugin) collectLogs(event interface{}) {
 	if we, ok := event.(roadrunner.WorkerEvent); ok {
 		switch we.Event {
 		case roadrunner.EventWorkerError:
diff --git a/plugins/app/tests/.rr.yaml b/plugins/app/tests/.rr.yaml
index 171f51dc..c9d1bd40 100644
--- a/plugins/app/tests/.rr.yaml
+++ b/plugins/app/tests/.rr.yaml
@@ -1,5 +1,5 @@
 app:
-  command: "php hello.php"
+  command: "php plugins/app/tests/hello.php hello_echo"
   user: ""
   group: ""
   env:
diff --git a/plugins/app/tests/factory_test.go b/plugins/app/tests/factory_test.go
index 7c885797..969c361c 100644
--- a/plugins/app/tests/factory_test.go
+++ b/plugins/app/tests/factory_test.go
@@ -9,24 +9,25 @@ import (
 	"github.com/spiral/endure"
 	"github.com/spiral/roadrunner/v2/plugins/app"
 	"github.com/spiral/roadrunner/v2/plugins/config"
+	"github.com/spiral/roadrunner/v2/plugins/logger"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestFactory(t *testing.T) {
-	container, err := endure.NewContainer(endure.DebugLevel, endure.RetryOnFail(true))
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.DebugLevel))
 	if err != nil {
 		t.Fatal(err)
 	}
 	// config plugin
-	vp := &config.ViperProvider{}
-	vp.Path = ".rr.yaml"
+	vp := &config.Viper{}
+	vp.Path = "plugins/app/tests/.rr.yaml"
 	vp.Prefix = "rr"
 	err = container.Register(vp)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = container.Register(&app.App{})
+	err = container.Register(&app.Plugin{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -41,6 +42,11 @@ func TestFactory(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	err = container.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	err = container.Init()
 	if err != nil {
 		t.Fatal(err)
@@ -55,7 +61,7 @@ func TestFactory(t *testing.T) {
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt)
 
-	tt := time.NewTicker(time.Second * 2)
+	tt := time.NewTicker(time.Second * 200)
 
 	for {
 		select {
diff --git a/plugins/app/tests/hello.php b/plugins/app/tests/hello.php
index bf9e82cc..4219dcf4 100644
--- a/plugins/app/tests/hello.php
+++ b/plugins/app/tests/hello.php
@@ -1 +1,19 @@
-<?php echo "hello1 - " . time();
\ No newline at end of file
+<?php
+/**
+ * @var Goridge\RelayInterface $relay
+ */
+
+use Spiral\Goridge;
+use Spiral\RoadRunner;
+
+require "/vendor_php/autoload.php";
+
+$rr = new RoadRunner\Worker($relay);
+
+while ($in = $rr->receive($ctx)) {
+    try {
+        $rr->send((string)$in);
+    } catch (\Throwable $e) {
+        $rr->error((string)$e);
+    }
+}
\ No newline at end of file
diff --git a/plugins/app/tests/plugin_1.go b/plugins/app/tests/plugin_1.go
index 7259ea9d..c6287f5c 100644
--- a/plugins/app/tests/plugin_1.go
+++ b/plugins/app/tests/plugin_1.go
@@ -9,11 +9,11 @@ import (
 )
 
 type Foo struct {
-	configProvider config.Provider
+	configProvider config.Configurer
 	spawner        app.WorkerFactory
 }
 
-func (f *Foo) Init(p config.Provider, spw app.WorkerFactory) error {
+func (f *Foo) Init(p config.Configurer, spw app.WorkerFactory) error {
 	f.configProvider = p
 	f.spawner = spw
 	return nil
diff --git a/plugins/app/tests/plugin_2.go b/plugins/app/tests/plugin_2.go
index fbb9ca11..51fb83a4 100644
--- a/plugins/app/tests/plugin_2.go
+++ b/plugins/app/tests/plugin_2.go
@@ -12,11 +12,11 @@ import (
 )
 
 type Foo2 struct {
-	configProvider config.Provider
+	configProvider config.Configurer
 	wf             app.WorkerFactory
 }
 
-func (f *Foo2) Init(p config.Provider, workerFactory app.WorkerFactory) error {
+func (f *Foo2) Init(p config.Configurer, workerFactory app.WorkerFactory) error {
 	f.configProvider = p
 	f.wf = workerFactory
 	return nil
diff --git a/plugins/config/provider.go b/plugins/config/configurer.go
index ac33b3de..00010eae 100755
--- a/plugins/config/provider.go
+++ b/plugins/config/configurer.go
@@ -1,9 +1,9 @@
 package config
 
-type Provider interface {
+type Configurer interface {
 	// UnmarshalKey reads configuration section into configuration object.
 	//
-	// func (h *HttpService) Init(cp config.Provider) error {
+	// func (h *HttpService) Init(cp config.Configurer) error {
 	//     h.config := &HttpConfig{}
 	//     if err := configProvider.UnmarshalKey("http", h.config); err != nil {
 	//         return err
diff --git a/plugins/config/viper.go b/plugins/config/plugin.go
index 4e85af6b..2555d28a 100755
--- a/plugins/config/viper.go
+++ b/plugins/config/plugin.go
@@ -8,14 +8,14 @@ import (
 	"github.com/spf13/viper"
 )
 
-type ViperProvider struct {
+type Viper struct {
 	viper  *viper.Viper
 	Path   string
 	Prefix string
 }
 
 // Inits config provider.
-func (v *ViperProvider) Init() error {
+func (v *Viper) Init() error {
 	v.viper = viper.New()
 
 	// read in environment variables that match
@@ -36,7 +36,7 @@ func (v *ViperProvider) Init() error {
 }
 
 // Overwrite overwrites existing config with provided values
-func (v *ViperProvider) Overwrite(values map[string]string) error {
+func (v *Viper) Overwrite(values map[string]string) error {
 	if len(values) != 0 {
 		for _, flag := range values {
 			key, value, err := parseFlag(flag)
@@ -51,7 +51,7 @@ func (v *ViperProvider) Overwrite(values map[string]string) error {
 }
 
 // UnmarshalKey reads configuration section into configuration object.
-func (v *ViperProvider) UnmarshalKey(name string, out interface{}) error {
+func (v *Viper) UnmarshalKey(name string, out interface{}) error {
 	err := v.viper.UnmarshalKey(name, &out)
 	if err != nil {
 		return err
@@ -60,12 +60,12 @@ func (v *ViperProvider) UnmarshalKey(name string, out interface{}) error {
 }
 
 // Get raw config in a form of config section.
-func (v *ViperProvider) Get(name string) interface{} {
+func (v *Viper) Get(name string) interface{} {
 	return v.viper.Get(name)
 }
 
 // Has checks if config section exists.
-func (v *ViperProvider) Has(name string) bool {
+func (v *Viper) Has(name string) bool {
 	return v.viper.IsSet(name)
 }
 
diff --git a/plugins/config/tests/.rr.yaml b/plugins/config/tests/.rr.yaml
index df9077d0..732a1366 100755
--- a/plugins/config/tests/.rr.yaml
+++ b/plugins/config/tests/.rr.yaml
@@ -1,21 +1,12 @@
 reload:
-  # enable or disable file watcher
   enabled: true
-  # sync interval
   interval: 1s
-  # global patterns to sync
   patterns: [".php"]
-  # list of included for sync services
   services:
     http:
-      # recursive search for file patterns to add
       recursive: true
-      # ignored folders
       ignore: ["vendor"]
-      # service specific file pattens to sync
       patterns: [".php", ".go",".md",]
-      # directories to sync. If recursive is set to true,
-      # recursive sync will be applied only to the directories in `dirs` section
       dirs:     ["."]
     jobs:
       recursive: false
@@ -24,5 +15,4 @@ reload:
     rpc:
       recursive: true
       patterns: [".json"]
-      # to include all project directories from workdir, leave `dirs` empty or add a dot "."
       dirs:     [""]
diff --git a/plugins/config/tests/config_test.go b/plugins/config/tests/config_test.go
index 14e60ac2..422e7eee 100755
--- a/plugins/config/tests/config_test.go
+++ b/plugins/config/tests/config_test.go
@@ -12,11 +12,11 @@ import (
 )
 
 func TestViperProvider_Init(t *testing.T) {
-	container, err := endure.NewContainer(endure.DebugLevel, endure.RetryOnFail(true))
+	container, err := endure.NewContainer(nil, endure.RetryOnFail(true), endure.SetLogLevel(endure.DebugLevel))
 	if err != nil {
 		t.Fatal(err)
 	}
-	vp := &config.ViperProvider{}
+	vp := &config.Viper{}
 	vp.Path = ".rr.yaml"
 	vp.Prefix = "rr"
 	err = container.Register(vp)
diff --git a/plugins/config/tests/plugin1.go b/plugins/config/tests/plugin1.go
index 7c5f2afd..a276c15f 100755
--- a/plugins/config/tests/plugin1.go
+++ b/plugins/config/tests/plugin1.go
@@ -23,11 +23,11 @@ type ServiceConfig struct {
 }
 
 type Foo struct {
-	configProvider config.Provider
+	configProvider config.Configurer
 }
 
 // Depends on S2 and DB (S3 in the current case)
-func (f *Foo) Init(p config.Provider) error {
+func (f *Foo) Init(p config.Configurer) error {
 	f.configProvider = p
 	return nil
 }
diff --git a/plugins/logger/tests/.rr.yaml b/plugins/logger/tests/.rr.yaml
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/plugins/logger/tests/.rr.yaml
diff --git a/plugins/logger/tests/logger_test.go b/plugins/logger/tests/logger_test.go
new file mode 100644
index 00000000..ca8701d2
--- /dev/null
+++ b/plugins/logger/tests/logger_test.go
@@ -0,0 +1 @@
+package tests
diff --git a/plugins/logger/tests/plugin1.go b/plugins/logger/tests/plugin1.go
new file mode 100644
index 00000000..ca8701d2
--- /dev/null
+++ b/plugins/logger/tests/plugin1.go
@@ -0,0 +1 @@
+package tests
diff --git a/plugins/logger/tests/plugin2.go b/plugins/logger/tests/plugin2.go
new file mode 100644
index 00000000..ca8701d2
--- /dev/null
+++ b/plugins/logger/tests/plugin2.go
@@ -0,0 +1 @@
+package tests
diff --git a/plugins/logger/zap_logger.go b/plugins/logger/zap_logger.go
index 8c1739f2..a22cdb22 100644
--- a/plugins/logger/zap_logger.go
+++ b/plugins/logger/zap_logger.go
@@ -25,7 +25,7 @@ type ZapLogger struct {
 }
 
 // Init logger service.
-func (z *ZapLogger) Init(cfg config.Provider) (err error) {
+func (z *ZapLogger) Init(cfg config.Configurer) (err error) {
 	err = cfg.UnmarshalKey(ServiceName, &z.cfg)
 	if err != nil {
 		return err
diff --git a/plugins/rpc/rpc.go b/plugins/rpc/rpc.go
index f299bd55..cda42aa0 100755
--- a/plugins/rpc/rpc.go
+++ b/plugins/rpc/rpc.go
@@ -11,8 +11,8 @@ import (
 	"github.com/spiral/roadrunner/v2/plugins/config"
 )
 
-// RPCPluggable declares the ability to create set of public RPC methods.
-type RPCPluggable interface {
+// Pluggable declares the ability to create set of public RPC methods.
+type Pluggable interface {
 	endure.Named
 
 	// Provides RPC methods for the given service.
@@ -22,19 +22,20 @@ type RPCPluggable interface {
 // ServiceName contains default service name.
 const ServiceName = "rpc"
 
-// Service is RPC service.
-type Service struct {
+// Plugin is RPC service.
+type Plugin struct {
 	cfg      Config
 	log      *zap.Logger
 	rpc      *rpc.Server
-	services []RPCPluggable
+	services []Pluggable
 	close    chan struct{}
 }
 
 // Init rpc service. Must return true if service is enabled.
-func (s *Service) Init(cfg config.Provider, log *zap.Logger) error {
+func (s *Plugin) Init(cfg config.Configurer, log *zap.Logger) error {
+	const op = errors.Op("RPC Init")
 	if !cfg.Has(ServiceName) {
-		return errors.E(errors.Disabled)
+		return errors.E(op, errors.Disabled)
 	}
 
 	err := cfg.UnmarshalKey(ServiceName, &s.cfg)
@@ -44,38 +45,39 @@ func (s *Service) Init(cfg config.Provider, log *zap.Logger) error {
 	s.cfg.InitDefaults()
 
 	if s.cfg.Disabled {
-		return errors.E(errors.Disabled)
+		return errors.E(op, errors.Disabled)
 	}
 
 	s.log = log
+	s.close = make(chan struct{}, 1)
 
 	return s.cfg.Valid()
 }
 
 // Serve serves the service.
-func (s *Service) Serve() chan error {
+func (s *Plugin) Serve() chan error {
+	const op = errors.Op("register service")
 	errCh := make(chan error, 1)
 
-	s.close = make(chan struct{}, 1)
 	s.rpc = rpc.NewServer()
 
-	names := make([]string, 0, len(s.services))
+	services := make([]string, 0, len(s.services))
 
 	// Attach all services
 	for i := 0; i < len(s.services); i++ {
 		svc, err := s.services[i].RPCService()
 		if err != nil {
-			errCh <- errors.E(errors.Op("register service"), err)
+			errCh <- errors.E(op, err)
 			return errCh
 		}
 
 		err = s.Register(s.services[i].Name(), svc)
 		if err != nil {
-			errCh <- errors.E(errors.Op("register service"), err)
+			errCh <- errors.E(op, err)
 			return errCh
 		}
 
-		names = append(names, s.services[i].Name())
+		services = append(services, s.services[i].Name())
 	}
 
 	ln, err := s.cfg.Listener()
@@ -84,14 +86,14 @@ func (s *Service) Serve() chan error {
 		return errCh
 	}
 
-	s.log.Debug("Started RPC service", zap.String("address", s.cfg.Listen), zap.Any("services", names))
+	s.log.Debug("Started RPC service", zap.String("address", s.cfg.Listen), zap.Any("services", services))
 
 	go func() {
 		for {
 			select {
 			case <-s.close:
 				// log error
-				err := ln.Close()
+				err = ln.Close()
 				if err != nil {
 					errCh <- errors.E(errors.Op("close RPC socket"), err)
 				}
@@ -111,25 +113,25 @@ func (s *Service) Serve() chan error {
 }
 
 // Stop stops the service.
-func (s *Service) Stop() error {
+func (s *Plugin) Stop() error {
 	s.close <- struct{}{}
 	return nil
 }
 
 // Name contains service name.
-func (s *Service) Name() string {
+func (s *Plugin) Name() string {
 	return ServiceName
 }
 
 // Depends declares services to collect for RPC.
-func (s *Service) Depends() []interface{} {
+func (s *Plugin) Collects() []interface{} {
 	return []interface{}{
 		s.RegisterPlugin,
 	}
 }
 
 // RegisterPlugin registers RPC service plugin.
-func (s *Service) RegisterPlugin(p RPCPluggable) error {
+func (s *Plugin) RegisterPlugin(p Pluggable) error {
 	s.services = append(s.services, p)
 	return nil
 }
@@ -142,7 +144,7 @@ func (s *Service) RegisterPlugin(p RPCPluggable) error {
 //	- one return value, of type error
 // It returns an error if the receiver is not an exported type or has
 // no suitable methods. It also logs the error using package log.
-func (s *Service) Register(name string, svc interface{}) error {
+func (s *Plugin) Register(name string, svc interface{}) error {
 	if s.rpc == nil {
 		return errors.E("RPC service is not configured")
 	}
@@ -151,7 +153,7 @@ func (s *Service) Register(name string, svc interface{}) error {
 }
 
 // Client creates new RPC client.
-func (s *Service) Client() (*rpc.Client, error) {
+func (s *Plugin) Client() (*rpc.Client, error) {
 	conn, err := s.cfg.Dialer()
 	if err != nil {
 		return nil, err
diff --git a/plugins/rpc/tests/.rr.yaml b/plugins/rpc/tests/.rr.yaml
new file mode 100644
index 00000000..76e8b440
--- /dev/null
+++ b/plugins/rpc/tests/.rr.yaml
@@ -0,0 +1,3 @@
+rpc:
+  listen: tcp://127.0.0.1:6001
+  disabled: false
\ No newline at end of file
diff --git a/plugins/rpc/tests/plugin1.go b/plugins/rpc/tests/plugin1.go
new file mode 100644
index 00000000..788e6a2c
--- /dev/null
+++ b/plugins/rpc/tests/plugin1.go
@@ -0,0 +1,42 @@
+package tests
+
+import (
+	"fmt"
+
+	"github.com/spiral/roadrunner/v2/plugins/config"
+)
+
+type Plugin1 struct {
+	config config.Configurer
+}
+
+func (p1 *Plugin1) Init(cfg config.Configurer) error {
+	p1.config = cfg
+	return nil
+}
+
+func (p1 *Plugin1) Serve() chan error {
+	errCh := make(chan error, 1)
+	return errCh
+}
+
+func (p1 *Plugin1) Stop() error {
+	return nil
+}
+
+func (p1 *Plugin1) Name() string {
+	return "rpc_test.plugin1"
+}
+
+func (p1 *Plugin1) RPCService() (interface{}, error) {
+	return &PluginRpc{srv: p1}, nil
+}
+
+type PluginRpc struct {
+	srv *Plugin1
+}
+
+func (r *PluginRpc) Hello(in string, out *string) error {
+	*out = fmt.Sprintf("Hello, username: %s", in)
+	return nil
+}
diff --git a/plugins/rpc/tests/plugin2.go b/plugins/rpc/tests/plugin2.go
new file mode 100644
index 00000000..feeae4af
--- /dev/null
+++ b/plugins/rpc/tests/plugin2.go
@@ -0,0 +1,54 @@
+package tests
+
+import (
+	"net"
+	"net/rpc"
+	"time"
+
+	"github.com/spiral/errors"
+	"github.com/spiral/goridge/v2"
+)
+
+// plugin2 makes a call to the plugin1 via RPC
+// this is just a simulation of external call FOR TEST
+// you don't need to do such things :)
+type Plugin2 struct {
+}
+
+func (p2 *Plugin2) Init() error {
+	return nil
+}
+
+func (p2 *Plugin2) Serve() chan error {
+	errCh := make(chan error, 1)
+
+	go func() {
+		time.Sleep(time.Second * 3)
+
+		conn, err := net.Dial("tcp", "127.0.0.1:6001")
+		if err != nil {
+			errCh <- err
+			return
+		}
+		client := rpc.NewClientWithCodec(goridge.NewClientCodec(conn))
+		var ret string
+		err = client.Call("rpc_test.plugin1.Hello", "Valery", &ret)
+		if err != nil {
+			errCh <- err
+			return
+		}
+		if ret != "Hello, username: Valery" {
+			errCh <- errors.E("wrong response")
+			return
+		}
+		// to stop exec
+		errCh <- errors.E(errors.Disabled)
+		return
+	}()
+
+	return errCh
+}
+
+func (p2 *Plugin2) Stop() error {
+	return nil
+}
diff --git a/plugins/rpc/tests/rpc_test.go b/plugins/rpc/tests/rpc_test.go
new file mode 100644
index 00000000..85a11eec
--- /dev/null
+++ b/plugins/rpc/tests/rpc_test.go
@@ -0,0 +1,95 @@
+package tests
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/spiral/endure"
+	"github.com/spiral/errors"
+	"github.com/spiral/roadrunner/v2/plugins/config"
+	"github.com/spiral/roadrunner/v2/plugins/logger"
+	"github.com/spiral/roadrunner/v2/plugins/rpc"
+	"github.com/stretchr/testify/assert"
+)
+
+// graph https://bit.ly/3ensdNb
+func TestRpcInit(t *testing.T) {
+	cont, err := endure.NewContainer(nil, endure.SetLogLevel(endure.DebugLevel), endure.Visualize(endure.StdOut, ""))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = cont.Register(&Plugin1{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = cont.Register(&Plugin2{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	v := &config.Viper{}
+	v.Path = ".rr.yaml"
+	v.Prefix = "rr"
+	err = cont.Register(v)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = cont.Register(&rpc.Plugin{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = cont.Register(&logger.ZapLogger{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = cont.Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ch, err := cont.Serve()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sig := make(chan os.Signal, 1)
+
+	signal.Notify(sig, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+	tt := time.NewTimer(time.Second * 10)
+
+	for {
+		select {
+		case e := <-ch:
+			// just stop, this is ok
+			if errors.Is(errors.Disabled, e.Error) {
+				return
+			}
+			assert.Fail(t, "error", e.Error.Error())
+			err = cont.Stop()
+			if err != nil {
+				assert.FailNow(t, "error", err.Error())
+			}
+		case <-sig:
+			err = cont.Stop()
+			if err != nil {
+				assert.FailNow(t, "error", err.Error())
+			}
+			return
+		case <-tt.C:
+			// timeout
+			err = cont.Stop()
+			if err != nil {
+				assert.FailNow(t, "error", err.Error())
+			}
+			assert.Fail(t, "timeout")
+		}
+	}
+}