Skip to content

Commit

Permalink
remove unneeded tests
Browse files Browse the repository at this point in the history 
Signed-off-by: Gyuho Lee <[email protected]>
  • Loading branch information
@gyuho
gyuho committed Feb 8, 2025
1 parent 664a940 commit 187868b
Show file tree
Hide file tree
Showing 2 changed files with 2 additions and 257 deletions.
4 changes: 2 additions & 2 deletions client/v1/healthz.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,8 @@ import (
"github.com/leptonai/gpud/internal/server"
)

var ErrServerNotReady = errors.New("server not ready, timeout waiting")

func CheckHealthz(ctx context.Context, addr string, opts ...OpOption) error {
op := &Op{}
if err := op.applyOpts(opts); err != nil {
Expand Down Expand Up @@ -84,5 +86,3 @@ func BlockUntilServerReady(ctx context.Context, addr string, opts ...OpOption) e
}
return ErrServerNotReady
}

var ErrServerNotReady = errors.New("server not ready, timeout waiting")
255 changes: 0 additions & 255 deletions client/v1/healthz_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,6 @@ import (
"context"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"

Expand Down Expand Up @@ -208,257 +207,3 @@ func TestCheckHealthzTimeout(t *testing.T) {
t.Error("CheckHealthz() with timeout should return error")
}
}

func TestBlockUntilServerReady(t *testing.T) {
tests := []struct {
name string
serverBehavior func(w http.ResponseWriter, r *http.Request)
expectedError bool
}{
{
name: "Server ready immediately",
serverBehavior: func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
if _, err := w.Write(json); err != nil {
t.Errorf("Error writing response: %v", err)
}
},
expectedError: false,
},
{
name: "Server ready after delay",
serverBehavior: func(w http.ResponseWriter, r *http.Request) {
time.Sleep(100 * time.Millisecond)
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
if _, err := w.Write(json); err != nil {
t.Errorf("Error writing response: %v", err)
}
},
expectedError: false,
},
{
name: "Server never ready",
serverBehavior: func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
},
expectedError: true,
},
}

for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(tt.serverBehavior))
defer server.Close()

ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()

err := BlockUntilServerReady(ctx, server.URL, WithCheckInterval(50*time.Millisecond))
if (err != nil) != tt.expectedError {
t.Errorf("BlockUntilServerReady() error = %v, expectedError %v", err, tt.expectedError)
}
})
}
}

func TestBlockUntilServerReadyInvalidURL(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()

err := BlockUntilServerReady(ctx, "invalid-url")
if err == nil {
t.Error("BlockUntilServerReady() with invalid URL should return error")
}
}

func TestBlockUntilServerReadyWithCustomInterval(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
_, err := w.Write(json)
if err != nil {
t.Errorf("Error writing response: %v", err)
}
}))
defer srv.Close()

ctx := context.Background()
err := BlockUntilServerReady(ctx, srv.URL, WithCheckInterval(10*time.Millisecond))
if err != nil {
t.Errorf("BlockUntilServerReady() with custom interval error = %v, want nil", err)
}
}

func TestBlockUntilServerReadyWithInvalidResponse(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
_, err := w.Write([]byte(`{"invalid":"json"}`))
if err != nil {
t.Errorf("Error writing response: %v", err)
}
}))
defer srv.Close()

ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
defer cancel()

err := BlockUntilServerReady(ctx, srv.URL, WithCheckInterval(50*time.Millisecond))
if err == nil {
t.Error("BlockUntilServerReady() with invalid response should return error")
}
}

func TestCheckHealthzConcurrent(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/healthz" {
http.NotFound(w, r)
return
}
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
_, err := w.Write(json)
require.NoError(t, err)
}))
defer srv.Close()

var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
err := CheckHealthz(context.Background(), srv.URL)
assert.NoError(t, err)
}()
}
wg.Wait()
}

func TestBlockUntilServerReadyExactRetries(t *testing.T) {
retryCount := 0
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
retryCount++
// Only succeed after 29 retries (30th attempt)
if retryCount < 30 {
w.WriteHeader(http.StatusServiceUnavailable)
return
}
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
_, err := w.Write(json)
require.NoError(t, err)
}))
defer srv.Close()

ctx := context.Background()
err := BlockUntilServerReady(ctx, srv.URL, WithCheckInterval(1*time.Millisecond))
assert.NoError(t, err)
assert.Equal(t, 30, retryCount, "Expected exactly 30 retries")
}

func TestBlockUntilServerReadyWithSlowResponse(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
time.Sleep(50 * time.Millisecond)
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
_, err := w.Write(json)
require.NoError(t, err)
}))
defer srv.Close()

// Test with a client timeout shorter than server response time
client := &http.Client{Timeout: 20 * time.Millisecond}
err := BlockUntilServerReady(context.Background(), srv.URL,
WithHTTPClient(client),
WithCheckInterval(10*time.Millisecond))
assert.Error(t, err)
assert.Equal(t, err, ErrServerNotReady)

// Test with a client timeout longer than server response time
client = &http.Client{Timeout: 100 * time.Millisecond}
err = BlockUntilServerReady(context.Background(), srv.URL,
WithHTTPClient(client),
WithCheckInterval(10*time.Millisecond))
assert.NoError(t, err)
}

func TestBlockUntilServerReadyWithContextDeadline(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusServiceUnavailable)
}))
defer srv.Close()

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()

start := time.Now()
err := BlockUntilServerReady(ctx, srv.URL, WithCheckInterval(10*time.Millisecond))
duration := time.Since(start)

assert.Error(t, err)
assert.Contains(t, err.Error(), "context done")
assert.True(t, duration >= 100*time.Millisecond, "Should have waited for context deadline")
assert.True(t, duration < 150*time.Millisecond, "Should not have waited much longer than deadline")
}

func TestBlockUntilServerReadyWithNetworkErrors(t *testing.T) {
// Start and immediately close a server to get an unused address
srv := httptest.NewServer(http.HandlerFunc(nil))
addr := srv.URL
srv.Close()

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()

err := BlockUntilServerReady(ctx, addr, WithCheckInterval(10*time.Millisecond))
assert.Error(t, err)
assert.Contains(t, err.Error(), "context done")
}

func TestBlockUntilServerReadyWithIntermittentFailures(t *testing.T) {
attempts := 0
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
attempts++
// Fail the first 2 attempts with different status codes
switch attempts {
case 1:
w.WriteHeader(http.StatusServiceUnavailable)
case 2:
w.WriteHeader(http.StatusInternalServerError)
default:
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
_, err := w.Write(json)
require.NoError(t, err)
}
}))
defer srv.Close()

err := BlockUntilServerReady(context.Background(), srv.URL, WithCheckInterval(10*time.Millisecond))
assert.NoError(t, err)
assert.Equal(t, 3, attempts, "Expected exactly 3 attempts before success")
}

func TestBlockUntilServerReadyWithConnectionErrors(t *testing.T) {
attempts := 0
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
attempts++
if attempts <= 2 {
// Simulate connection errors for first two attempts
conn, _, err := w.(http.Hijacker).Hijack()
require.NoError(t, err)
conn.Close()
return
}
w.WriteHeader(http.StatusOK)
json, _ := server.DefaultHealthz.JSON()
_, err := w.Write(json)
require.NoError(t, err)
}))
defer srv.Close()

err := BlockUntilServerReady(context.Background(), srv.URL, WithCheckInterval(10*time.Millisecond))
assert.NoError(t, err)
assert.Equal(t, 3, attempts, "Expected exactly 3 attempts before success")
}

0 comments on commit 187868b

Please sign in to comment.