Mock transport

This commit is contained in:
Asim 2016-03-18 18:41:26 +00:00
parent dcb3fad476
commit da22d5b161
2 changed files with 225 additions and 0 deletions

165
transport/mock/mock.go Normal file
View File

@ -0,0 +1,165 @@
package mock
import (
"errors"
"sync"
"github.com/micro/go-micro/transport"
)
type mockSocket struct {
recv chan *transport.Message
send chan *transport.Message
// sock exit
exit chan bool
// listener exit
lexit chan bool
}
type mockClient struct {
*mockSocket
opts transport.DialOptions
}
type mockListener struct {
addr string
exit chan bool
conn chan *mockSocket
opts transport.ListenOptions
}
type mockTransport struct {
opts transport.Options
sync.Mutex
listeners map[string]*mockListener
}
func (ms *mockSocket) Recv(m *transport.Message) error {
select {
case <-ms.exit:
return errors.New("server side connection closed")
case <-ms.lexit:
return errors.New("server side connection closed")
case cm := <-ms.recv:
*m = *cm
}
return nil
}
func (ms *mockSocket) Send(m *transport.Message) error {
select {
case <-ms.exit:
return errors.New("client side connection closed")
case <-ms.lexit:
return errors.New("server side connection closed")
case ms.send <- m:
}
return nil
}
func (ms *mockSocket) Close() error {
close(ms.exit)
return nil
}
func (m *mockListener) Addr() string {
return m.addr
}
func (m *mockListener) Close() error {
close(m.exit)
return nil
}
func (m *mockListener) Accept(fn func(transport.Socket)) error {
for {
select {
case <-m.exit:
return nil
case c := <-m.conn:
go fn(&mockSocket{
lexit: make(chan bool),
exit: c.exit,
send: c.recv,
recv: c.send,
})
}
}
return nil
}
func (m *mockTransport) Dial(addr string, opts ...transport.DialOption) (transport.Client, error) {
m.Lock()
defer m.Unlock()
listener, ok := m.listeners[addr]
if !ok {
return nil, errors.New("could not dial " + addr)
}
var options transport.DialOptions
for _, o := range opts {
o(&options)
}
client := &mockClient{
&mockSocket{
send: make(chan *transport.Message),
recv: make(chan *transport.Message),
exit: make(chan bool),
lexit: listener.exit,
},
options,
}
// pseudo connect
select {
case <-listener.exit:
return nil, errors.New("connection error")
case listener.conn <- client.mockSocket:
}
return client, nil
}
func (m *mockTransport) Listen(addr string, opts ...transport.ListenOption) (transport.Listener, error) {
m.Lock()
defer m.Unlock()
if _, ok := m.listeners[addr]; ok {
return nil, errors.New("already listening on " + addr)
}
var options transport.ListenOptions
for _, o := range opts {
o(&options)
}
listener := &mockListener{
opts: options,
addr: addr,
conn: make(chan *mockSocket),
exit: make(chan bool),
}
m.listeners[addr] = listener
return listener, nil
}
func (m *mockTransport) String() string {
return "mock"
}
func NewTransport(opts ...transport.Option) transport.Transport {
var options transport.Options
for _, o := range opts {
o(&options)
}
return &mockTransport{
opts: options,
listeners: make(map[string]*mockListener),
}
}

View File

@ -0,0 +1,60 @@
package mock
import (
"testing"
"github.com/micro/go-micro/transport"
)
func TestTransport(t *testing.T) {
tr := NewTransport()
// bind / listen
l, err := tr.Listen("localhost:8080")
if err != nil {
t.Fatalf("Unexpected error listening %v", err)
}
defer l.Close()
// accept
go func() {
if err := l.Accept(func(sock transport.Socket) {
for {
var m transport.Message
if err := sock.Recv(&m); err != nil {
return
}
t.Logf("Server Received %s", string(m.Body))
if err := sock.Send(&transport.Message{
Body: []byte(`pong`),
}); err != nil {
return
}
}
}); err != nil {
t.Fatalf("Unexpected error accepting %v", err)
}
}()
// dial
c, err := tr.Dial("localhost:8080")
if err != nil {
t.Fatalf("Unexpected error dialing %v", err)
}
defer c.Close()
// send <=> receive
for i := 0; i < 3; i++ {
if err := c.Send(&transport.Message{
Body: []byte(`ping`),
}); err != nil {
return
}
var m transport.Message
if err := c.Recv(&m); err != nil {
return
}
t.Logf("Client Received %s", string(m.Body))
}
}