frostfs-node/lib/muxer/muxer_test.go
alexvanin dadfd90dcd Initial commit
Initial public review release v0.10.0
2020-07-10 17:45:00 +03:00

415 lines
8.4 KiB
Go

package muxer
import (
"context"
"net"
"net/http"
"os"
"reflect"
"strings"
"sync"
"testing"
"time"
"bou.ke/monkey"
"github.com/multiformats/go-multiaddr"
"github.com/nspcc-dev/neofs-node/lib/peers"
"github.com/nspcc-dev/neofs-node/lib/test"
"github.com/nspcc-dev/neofs-node/lib/transport"
"github.com/pkg/errors"
"github.com/soheilhy/cmux"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
"github.com/valyala/fasthttp"
"go.uber.org/atomic"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
"google.golang.org/grpc"
)
type (
errListener struct {
net.TCPListener
}
syncListener struct {
sync.Mutex
net.Listener
}
errMuxer struct {
handleError func(error) bool
}
testWriter struct{}
// service is used to implement GreaterServer.
service struct{}
)
const MIMEApplicationJSON = "application/json"
// Hello is simple handler
func (*service) Hello(ctx context.Context, req *HelloRequest) (*HelloResponse, error) {
return &HelloResponse{
Message: "Hello " + req.Name,
}, nil
}
func (testWriter) Sync() error { return nil }
func (testWriter) Write(p []byte) (n int, err error) { return len(p), nil }
func (errMuxer) Match(...cmux.Matcher) net.Listener {
return &errListener{}
}
func (errMuxer) MatchWithWriters(...cmux.MatchWriter) net.Listener {
return &errListener{}
}
func (errMuxer) Serve() error {
return errors.New("cmux.Serve error")
}
func (e *errMuxer) HandleError(h cmux.ErrorHandler) {
e.handleError = h
}
func (errMuxer) SetReadTimeout(time.Duration) {
panic("implement me")
}
func (l *syncListener) Close() error {
l.Lock()
err := l.Listener.Close()
l.Unlock()
return err
}
func (errListener) Close() error { return errors.New("close error") }
func testMultiAddr(is *require.Assertions) multiaddr.Multiaddr {
mAddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/tcp/0")
is.NoError(err)
return mAddr
}
func testPeers(is *require.Assertions, a multiaddr.Multiaddr) peers.Interface {
s, err := peers.New(peers.Params{
Address: a,
Transport: transport.New(5, time.Second),
Logger: test.NewTestLogger(false),
})
is.NoError(err)
return s
}
func testLogger() *zap.Logger {
encoderCfg := zapcore.EncoderConfig{
MessageKey: "msg",
LevelKey: "level",
NameKey: "logger",
EncodeLevel: zapcore.LowercaseLevelEncoder,
EncodeTime: zapcore.ISO8601TimeEncoder,
EncodeDuration: zapcore.StringDurationEncoder,
}
core := zapcore.NewCore(zapcore.NewJSONEncoder(encoderCfg), testWriter{}, zap.DPanicLevel)
return zap.New(core).WithOptions()
}
func testHTTPServer() *fasthttp.Server {
return &fasthttp.Server{Handler: func(ctx *fasthttp.RequestCtx) {}}
}
func TestSuite(t *testing.T) {
t.Run("it should run, stop and not panic", func(t *testing.T) {
var (
is = require.New(t)
v = viper.New()
g = grpc.NewServer()
l = testLogger()
a = testMultiAddr(is)
s = time.Second
err error
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
v.SetDefault("api.address", "/ip4/0.0.0.0/tcp/0")
v.SetDefault("api.shutdown_timeout", time.Second)
m := New(Params{
Logger: l,
Address: a,
ShutdownTTL: s,
API: testHTTPServer(),
P2P: g,
Peers: testPeers(is, a),
})
is.NotPanics(func() {
m.Start(ctx)
})
res, err := http.Post("http://"+m.(*muxer).lis.Addr().String(), MIMEApplicationJSON, strings.NewReader(`{
"jsonrpc": "2.0",
"id": 1
"method": "get_version",
"params": [],
}`))
is.NoError(err)
defer res.Body.Close()
time.Sleep(100 * time.Millisecond)
is.NotPanics(m.Stop)
})
t.Run("it should work with gRPC", func(t *testing.T) {
var (
is = require.New(t)
g = grpc.NewServer()
l = testLogger()
s = time.Second
err error
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
addr, err := multiaddr.NewMultiaddr("/ip4/127.0.0.1/tcp/63090")
is.NoError(err)
ps := testPeers(is, addr)
RegisterGreeterServer(g, &service{})
m := New(Params{
Logger: l,
Address: addr,
ShutdownTTL: s,
P2P: g,
Peers: ps,
})
is.NotPanics(func() {
m.Start(ctx)
})
con, err := ps.GRPCConnection(ctx, addr, false)
is.NoError(err)
res, err := NewGreeterClient(con).Hello(ctx, &HelloRequest{Name: "test"})
is.NoError(err)
is.Contains(res.Message, "test")
time.Sleep(100 * time.Millisecond)
is.NotPanics(m.Stop)
})
t.Run("it should not start if already started", func(t *testing.T) {
var (
is = require.New(t)
g = grpc.NewServer()
l = testLogger()
a = testMultiAddr(is)
s = time.Second
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m := New(Params{
Logger: l,
Address: a,
ShutdownTTL: s,
API: testHTTPServer(),
P2P: g,
Peers: testPeers(is, a),
})
is.NotNil(m)
mux, ok := m.(*muxer)
is.True(ok)
is.NotNil(mux)
*mux.run = 1
is.NotPanics(func() {
mux.Start(ctx)
})
*mux.run = 0
is.NotPanics(mux.Stop)
})
t.Run("it should fail on close listener", func(t *testing.T) {
var (
is = require.New(t)
g = grpc.NewServer()
l = testLogger()
a = testMultiAddr(is)
s = time.Second
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m := New(Params{
Logger: l,
Address: a,
ShutdownTTL: s,
API: testHTTPServer(),
P2P: g,
Peers: testPeers(is, a),
})
is.NotNil(m)
mux, ok := m.(*muxer)
is.True(ok)
is.NotNil(mux)
mux.lis = &errListener{}
exit := atomic.NewInt32(0)
monkey.Patch(os.Exit, func(v int) { exit.Store(int32(v)) })
is.NotPanics(func() {
mux.Start(ctx)
})
is.Equal(int32(1), exit.Load())
})
t.Run("it should fail on create/close Listener without handlers", func(t *testing.T) {
var (
is = require.New(t)
l = testLogger()
a = testMultiAddr(is)
err error
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
mux := new(muxer)
mux.log = l
mux.peers = testPeers(is, a)
mux.run = new(int32)
mux.done = make(chan struct{})
mux.maddr, err = multiaddr.NewMultiaddr("/ip4/1.1.1.1/tcp/2")
is.NoError(err)
mux.lis, err = net.ListenTCP("tcp", nil)
is.NoError(err)
exit := atomic.NewInt32(0)
monkey.Patch(os.Exit, func(v int) {
exit.Store(int32(v))
})
m := &errMuxer{handleError: func(e error) bool { return true }}
monkey.Patch(cmux.New, func(net.Listener) cmux.CMux {
// prevent panic:
mux.lis, err = net.ListenTCP("tcp", nil)
return m
})
mux.Start(ctx)
// c.So(mux.Start, ShouldNotPanic)
m.handleError(errors.New("test"))
is.Equal(int32(1), exit.Load())
mux.lis = &errListener{}
*mux.run = 1
is.NotPanics(mux.Stop)
})
t.Run("it should fail on create/close Listener with handlers", func(t *testing.T) {
var (
is = require.New(t)
g = grpc.NewServer()
l = testLogger()
a = testMultiAddr(is)
err error
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
mux := new(muxer)
mux.api = testHTTPServer()
mux.p2p = g
mux.log = l
mux.peers = testPeers(is, a)
mux.run = new(int32)
mux.done = make(chan struct{})
mux.maddr, err = multiaddr.NewMultiaddr("/ip4/1.1.1.1/tcp/2")
is.NoError(err)
mu := new(sync.Mutex)
exit := atomic.NewInt32(0)
monkey.Patch(os.Exit, func(v int) {
exit.Store(int32(v))
mu.Lock()
if l, ok := mux.lis.(*syncListener); ok {
l.Lock()
l.Listener, _ = net.ListenTCP("tcp", nil)
l.Unlock()
}
mu.Unlock()
})
m := &errMuxer{handleError: func(e error) bool { return true }}
monkey.Patch(cmux.New, func(net.Listener) cmux.CMux {
// prevent panic:
return m
})
is.NotPanics(func() {
mux.Start(ctx)
})
m.handleError(errors.New("test"))
is.Equal(int32(1), exit.Load())
mu.Lock()
mux.lis = &syncListener{Listener: &errListener{}}
mu.Unlock()
*mux.run = 1
monkey.PatchInstanceMethod(reflect.TypeOf(&http.Server{}), "Shutdown", func(*http.Server, context.Context) error {
return errors.New("http.Shutdown error")
})
is.NotPanics(mux.Stop)
})
t.Run("should not panic when work with nil listener", func(t *testing.T) {
var (
is = require.New(t)
err error
)
lis := NetListener(nil)
is.NotPanics(func() {
is.NoError(lis.Close())
})
is.NotPanics(func() {
lis.Addr()
})
is.NotPanics(func() {
_, err = lis.Accept()
is.EqualError(err, errNothingAccept.Error())
})
})
}