9 "github.com/mitchellh/go-testing-interface"
10 "google.golang.org/grpc"
13 // The testing file contains test helpers that you can use outside of
14 // this package for making it easier to test plugins themselves.
16 // TestConn is a helper function for returning a client and server
17 // net.Conn connected to each other.
18 func TestConn(t testing.T) (net.Conn, net.Conn) {
19 // Listen to any local port. This listener will be closed
20 // after a single connection is established.
21 l, err := net.Listen("tcp", "127.0.0.1:0")
23 t.Fatalf("err: %s", err)
26 // Start a goroutine to accept our client connection
27 var serverConn net.Conn
28 doneCh := make(chan struct{})
33 serverConn, err = l.Accept()
35 t.Fatalf("err: %s", err)
39 // Connect to the server
40 clientConn, err := net.Dial("tcp", l.Addr().String())
42 t.Fatalf("err: %s", err)
45 // Wait for the server side to acknowledge it has connected
48 return clientConn, serverConn
51 // TestRPCConn returns a rpc client and server connected to each other.
52 func TestRPCConn(t testing.T) (*rpc.Client, *rpc.Server) {
53 clientConn, serverConn := TestConn(t)
55 server := rpc.NewServer()
56 go server.ServeConn(serverConn)
58 client := rpc.NewClient(clientConn)
62 // TestPluginRPCConn returns a plugin RPC client and server that are connected
63 // together and configured.
64 func TestPluginRPCConn(t testing.T, ps map[string]Plugin) (*RPCClient, *RPCServer) {
65 // Create two net.Conns we can use to shuttle our control connection
66 clientConn, serverConn := TestConn(t)
68 // Start up the server
69 server := &RPCServer{Plugins: ps, Stdout: new(bytes.Buffer), Stderr: new(bytes.Buffer)}
70 go server.ServeConn(serverConn)
72 // Connect the client to the server
73 client, err := NewRPCClient(clientConn, ps)
75 t.Fatalf("err: %s", err)
81 // TestGRPCConn returns a gRPC client conn and grpc server that are connected
82 // together and configured. The register function is used to register services
83 // prior to the Serve call. This is used to test gRPC connections.
84 func TestGRPCConn(t testing.T, register func(*grpc.Server)) (*grpc.ClientConn, *grpc.Server) {
86 l, err := net.Listen("tcp", "127.0.0.1:0")
88 t.Fatalf("err: %s", err)
91 server := grpc.NewServer()
95 // Connect to the server
96 conn, err := grpc.Dial(
101 t.Fatalf("err: %s", err)
104 // Connection successful, close the listener
110 // TestPluginGRPCConn returns a plugin gRPC client and server that are connected
111 // together and configured. This is used to test gRPC connections.
112 func TestPluginGRPCConn(t testing.T, ps map[string]Plugin) (*GRPCClient, *GRPCServer) {
114 l, err := net.Listen("tcp", "127.0.0.1:0")
116 t.Fatalf("err: %s", err)
119 // Start up the server
120 server := &GRPCServer{
122 Server: DefaultGRPCServer,
123 Stdout: new(bytes.Buffer),
124 Stderr: new(bytes.Buffer),
126 if err := server.Init(); err != nil {
127 t.Fatalf("err: %s", err)
131 // Connect to the server
132 conn, err := grpc.Dial(
137 t.Fatalf("err: %s", err)
140 brokerGRPCClient := newGRPCBrokerClient(conn)
141 broker := newGRPCBroker(brokerGRPCClient, nil)
143 go brokerGRPCClient.StartStream()
146 client := &GRPCClient{
150 doneCtx: context.Background(),
153 return client, server