package testutil

import (

"context"

"net"

"sync"

"golang.org/x/xerrors"

)

type Addr struct {

network string

addr string

}

func NewAddr(network, addr string) Addr {

return Addr{network, addr}

}

func (a Addr) Network() string {

return a.network

}

func (a Addr) Address() string {

return a.addr

}

func (a Addr) String() string {

return a.network + "|" + a.addr

}

type InProcNet struct {

sync.Mutex

listeners map[Addr]*inProcListener

}

type inProcListener struct {

c chan net.Conn

n *InProcNet

a Addr

o sync.Once

}

func NewInProcNet() *InProcNet {

return &InProcNet{listeners: make(map[Addr]*inProcListener)}

}

func (n *InProcNet) Listen(network, address string) (net.Listener, error) {

a := Addr{network, address}

n.Lock()

defer n.Unlock()

if _, ok := n.listeners[a]; ok {

return nil, xerrors.New("busy")

}

l := newInProcListener(n, a)

n.listeners[a] = l

return l, nil

}

func (n *InProcNet) Dial(ctx context.Context, a Addr) (net.Conn, error) {

n.Lock()

defer n.Unlock()

l, ok := n.listeners[a]

if !ok {

return nil, xerrors.Errorf("nothing listening on %s", a)

}

x, y := net.Pipe()

select {

case <-ctx.Done():

return nil, ctx.Err()

case l.c <- x:

return y, nil

}

}

func newInProcListener(n *InProcNet, a Addr) *inProcListener {

return &inProcListener{

c: make(chan net.Conn),

n: n,

a: a,

}

}

func (l *inProcListener) Accept() (net.Conn, error) {

c, ok := <-l.c

if !ok {

return nil, net.ErrClosed

}

return c, nil

}

func (l *inProcListener) Close() error {

l.o.Do(func() {

l.n.Lock()

defer l.n.Unlock()

delete(l.n.listeners, l.a)

close(l.c)

})

return nil

}

func (l *inProcListener) Addr() net.Addr {

return l.a

}