extern/netbird
1
0
Fork 0
mirror of https://github.com/netbirdio/netbird.git synced 2025-06-21 10:18:50 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix lint

Browse Source
This commit is contained in:
Zoltan Papp 2024-07-09 09:44:23 +02:00
parent 63f2f51614
commit 5625d83c3f
2 changed files with 119 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
relay/client/client_test.go
View File

@ -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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
time.Sleep(300 * time.Millisecond)
// wait for servers to start
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
}

67
relay/client/manager_test.go
View File

@ -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
time.Sleep(300 * time.Millisecond)
if err := waitForServerToStart(errChan2); err != nil {
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)