Fix lint

relay/client/client_test.go

@@ -33,11 +33,12 @@ func TestClient(t *testing.T) {
 	ctx := context.Background()
 
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		listenCfg := server.ListenerConfig{Address: serverListenAddr}
 		err := srv.Listen(listenCfg)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -49,8 +50,9 @@ func TestClient(t *testing.T) {
 	}()
 
 	// wait for server to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
-
+		t.Fatalf("failed to start server: %s", err)
+	}
 	t.Log("alice connecting to server")
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, "alice")
 	err := clientAlice.Connect()
@@ -110,15 +112,18 @@ func TestRegistration(t *testing.T) {
 	ctx := context.Background()
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
 	// wait for server to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, "alice")
 	err := clientAlice.Connect()
@@ -178,10 +183,11 @@ func TestEcho(t *testing.T) {
 	idBob := "bob"
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -192,8 +198,10 @@ func TestEcho(t *testing.T) {
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, idAlice)
 	err := clientAlice.Connect()
@@ -261,10 +269,11 @@ func TestBindToUnavailabePeer(t *testing.T) {
 
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -276,8 +285,10 @@ func TestBindToUnavailabePeer(t *testing.T) {
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, "alice")
 	err := clientAlice.Connect()
@@ -301,10 +312,11 @@ func TestBindReconnect(t *testing.T) {
 
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Errorf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -316,8 +328,10 @@ func TestBindReconnect(t *testing.T) {
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, "alice")
 	err := clientAlice.Connect()
@@ -386,10 +400,11 @@ func TestCloseConn(t *testing.T) {
 
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Errorf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -401,8 +416,10 @@ func TestCloseConn(t *testing.T) {
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, "alice")
 	err := clientAlice.Connect()
@@ -437,10 +454,11 @@ func TestCloseRelayConn(t *testing.T) {
 
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Errorf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -451,8 +469,10 @@ func TestCloseRelayConn(t *testing.T) {
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	clientAlice := NewClient(ctx, serverURL, hmacTokenStore, "alice")
 	err := clientAlice.Connect()
@@ -483,15 +503,19 @@ func TestCloseByServer(t *testing.T) {
 
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv1 := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
+
 	go func() {
 		err := srv1.Listen(srvCfg)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	idAlice := "alice"
 	log.Debugf("connect by alice")
@@ -529,15 +553,18 @@ func TestCloseByClient(t *testing.T) {
 
 	srvCfg := server.ListenerConfig{Address: serverListenAddr}
 	srv := server.NewServer(serverURL, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
-	// wait for server to start
+	// wait for servers to start
-	time.Sleep(300 * time.Millisecond)
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
 
 	idAlice := "alice"
 	log.Debugf("connect by alice")
@@ -562,3 +589,15 @@ func TestCloseByClient(t *testing.T) {
 		t.Fatalf("failed to close server: %s", err)
 	}
 }
+
+func waitForServerToStart(errChan chan error) error {
+	select {
+	case err := <-errChan:
+		if err != nil {
+			return err
+		}
+	case <-time.After(300 * time.Second):
+		return nil
+	}
+	return nil
+}

relay/client/manager_test.go

@@ -17,10 +17,11 @@ func TestForeignConn(t *testing.T) {
 		Address: "localhost:1234",
 	}
 	srv1 := server.NewServer(srvCfg1.Address, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv1.Listen(srvCfg1)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -31,14 +32,19 @@ func TestForeignConn(t *testing.T) {
 		}
 	}()
 
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	srvCfg2 := server.ListenerConfig{
 		Address: "localhost:2234",
 	}
 	srv2 := server.NewServer(srvCfg2.Address, false, av)
+	errChan2 := make(chan error, 1)
 	go func() {
 		err := srv2.Listen(srvCfg2)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan2 <- err
 		}
 	}()
 
@@ -49,18 +55,27 @@ func TestForeignConn(t *testing.T) {
 		}
 	}()
 
+	if err := waitForServerToStart(errChan2); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	idAlice := "alice"
 	log.Debugf("connect by alice")
 	mCtx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	clientAlice := NewManager(mCtx, toURL(srvCfg1), idAlice)
-	clientAlice.Serve()
+	err := clientAlice.Serve()
+	if err != nil {
+		t.Fatalf("failed to serve manager: %s", err)
+	}
 
 	idBob := "bob"
 	log.Debugf("connect by bob")
 	clientBob := NewManager(mCtx, toURL(srvCfg2), idBob)
-	clientBob.Serve()
+	err = clientBob.Serve()
-
+	if err != nil {
+		t.Fatalf("failed to serve manager: %s", err)
+	}
 	bobsSrvAddr, err := clientBob.RelayInstanceAddress()
 	if err != nil {
 		t.Fatalf("failed to get relay address: %s", err)
@@ -108,10 +123,11 @@ func TestForeginConnClose(t *testing.T) {
 		Address: "localhost:1234",
 	}
 	srv1 := server.NewServer(srvCfg1.Address, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv1.Listen(srvCfg1)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -122,14 +138,19 @@ func TestForeginConnClose(t *testing.T) {
 		}
 	}()
 
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	srvCfg2 := server.ListenerConfig{
 		Address: "localhost:2234",
 	}
 	srv2 := server.NewServer(srvCfg2.Address, false, av)
+	errChan2 := make(chan error, 1)
 	go func() {
 		err := srv2.Listen(srvCfg2)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan2 <- err
 		}
 	}()
 
@@ -140,6 +161,10 @@ func TestForeginConnClose(t *testing.T) {
 		}
 	}()
 
+	if err := waitForServerToStart(errChan2); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	idAlice := "alice"
 	log.Debugf("connect by alice")
 	mCtx, cancel := context.WithCancel(ctx)
@@ -167,11 +192,12 @@ func TestForeginAutoClose(t *testing.T) {
 		Address: "localhost:1234",
 	}
 	srv1 := server.NewServer(srvCfg1.Address, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		t.Log("binding server 1.")
 		err := srv1.Listen(srvCfg1)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -184,15 +210,20 @@ func TestForeginAutoClose(t *testing.T) {
 		t.Logf("server 1. closed")
 	}()
 
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	srvCfg2 := server.ListenerConfig{
 		Address: "localhost:2234",
 	}
 	srv2 := server.NewServer(srvCfg2.Address, false, av)
+	errChan2 := make(chan error, 1)
 	go func() {
 		t.Log("binding server 2.")
 		err := srv2.Listen(srvCfg2)
 		if err != nil {
-			t.Fatalf("failed to bind server: %s", err)
+			errChan2 <- err
 		}
 	}()
 	defer func() {
@@ -204,8 +235,10 @@ func TestForeginAutoClose(t *testing.T) {
 		t.Logf("server 2 closed.")
 	}()
 
-	// wait for servers to start
+	if err := waitForServerToStart(errChan2); err != nil {
-	time.Sleep(300 * time.Millisecond)
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	idAlice := "alice"
 	t.Log("connect to server 1.")
 	mCtx, cancel := context.WithCancel(ctx)
@@ -245,10 +278,11 @@ func TestAutoReconnect(t *testing.T) {
 		Address: "localhost:1234",
 	}
 	srv := server.NewServer(srvCfg.Address, false, av)
+	errChan := make(chan error, 1)
 	go func() {
 		err := srv.Listen(srvCfg)
 		if err != nil {
-			t.Errorf("failed to bind server: %s", err)
+			errChan <- err
 		}
 	}()
 
@@ -259,10 +293,17 @@ func TestAutoReconnect(t *testing.T) {
 		}
 	}()
 
+	if err := waitForServerToStart(errChan); err != nil {
+		t.Fatalf("failed to start server: %s", err)
+	}
+
 	mCtx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	clientAlice := NewManager(mCtx, toURL(srvCfg), "alice")
-	clientAlice.Serve()
+	err := clientAlice.Serve()
+	if err != nil {
+		t.Fatalf("failed to serve manager: %s", err)
+	}
 	ra, err := clientAlice.RelayInstanceAddress()
 	if err != nil {
 		t.Errorf("failed to get relay address: %s", err)