164 lines
2.8 KiB
Go
164 lines
2.8 KiB
Go
package portcheck_test
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
"testing"
|
|
"time"
|
|
|
|
"sneak.berlin/go/dnswatcher/internal/portcheck"
|
|
)
|
|
|
|
func listenTCP(
|
|
t *testing.T,
|
|
) (net.Listener, int) {
|
|
t.Helper()
|
|
|
|
lc := &net.ListenConfig{}
|
|
|
|
ln, err := lc.Listen(
|
|
context.Background(), "tcp", "127.0.0.1:0",
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("failed to start listener: %v", err)
|
|
}
|
|
|
|
addr, ok := ln.Addr().(*net.TCPAddr)
|
|
if !ok {
|
|
t.Fatal("unexpected address type")
|
|
}
|
|
|
|
return ln, addr.Port
|
|
}
|
|
|
|
func TestCheckPortOpen(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ln, port := listenTCP(t)
|
|
|
|
defer func() { _ = ln.Close() }()
|
|
|
|
checker := portcheck.NewStandalone()
|
|
|
|
result, err := checker.CheckPort(
|
|
context.Background(), "127.0.0.1", port,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if !result.Open {
|
|
t.Error("expected port to be open")
|
|
}
|
|
|
|
if result.Error != "" {
|
|
t.Errorf("expected no error, got: %s", result.Error)
|
|
}
|
|
|
|
if result.Latency <= 0 {
|
|
t.Error("expected positive latency")
|
|
}
|
|
}
|
|
|
|
func TestCheckPortClosed(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ln, port := listenTCP(t)
|
|
_ = ln.Close()
|
|
|
|
checker := portcheck.NewStandalone()
|
|
|
|
result, err := checker.CheckPort(
|
|
context.Background(), "127.0.0.1", port,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Open {
|
|
t.Error("expected port to be closed")
|
|
}
|
|
|
|
if result.Error == "" {
|
|
t.Error("expected error message for closed port")
|
|
}
|
|
}
|
|
|
|
func TestCheckPortContextCanceled(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
|
|
checker := portcheck.NewStandalone()
|
|
|
|
result, err := checker.CheckPort(ctx, "127.0.0.1", 1)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Open {
|
|
t.Error("expected port to not be open")
|
|
}
|
|
}
|
|
|
|
func TestCheckPortsMultiple(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ln, openPort := listenTCP(t)
|
|
|
|
defer func() { _ = ln.Close() }()
|
|
|
|
ln2, closedPort := listenTCP(t)
|
|
_ = ln2.Close()
|
|
|
|
checker := portcheck.NewStandalone()
|
|
|
|
results, err := checker.CheckPorts(
|
|
context.Background(),
|
|
"127.0.0.1",
|
|
[]int{openPort, closedPort},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(results) != 2 {
|
|
t.Fatalf(
|
|
"expected 2 results, got %d", len(results),
|
|
)
|
|
}
|
|
|
|
if !results[openPort].Open {
|
|
t.Error("expected open port to be open")
|
|
}
|
|
|
|
if results[closedPort].Open {
|
|
t.Error("expected closed port to be closed")
|
|
}
|
|
}
|
|
|
|
func TestCheckPortLatencyReasonable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ln, port := listenTCP(t)
|
|
|
|
defer func() { _ = ln.Close() }()
|
|
|
|
checker := portcheck.NewStandalone()
|
|
|
|
result, err := checker.CheckPort(
|
|
context.Background(), "127.0.0.1", port,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Latency > time.Second {
|
|
t.Errorf(
|
|
"latency too high for localhost: %v",
|
|
result.Latency,
|
|
)
|
|
}
|
|
}
|