142 lines
3.6 KiB
Go
142 lines
3.6 KiB
Go
package helpers
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"dance-lessons-coach/pkg/bdd/testserver"
|
|
|
|
"github.com/rs/zerolog/log"
|
|
)
|
|
|
|
// waitForServerReady waits for the test server to be ready with timeout
|
|
func waitForServerReady(client *testserver.Client, timeout time.Duration) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
|
|
ticker := time.NewTicker(100 * time.Millisecond)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return fmt.Errorf("server not ready after %v: %w", timeout, ctx.Err())
|
|
case <-ticker.C:
|
|
if err := client.Request("GET", "/api/ready", nil); err == nil {
|
|
log.Debug().Msg("Server is ready")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// waitForConfigReload waits for configuration reload to complete
|
|
func waitForConfigReload(client *testserver.Client, timeout time.Duration) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
|
|
// Get initial config state
|
|
var initialConfig string
|
|
if err := client.Request("GET", "/api/config", nil); err == nil {
|
|
initialConfig = string(client.GetLastBody())
|
|
}
|
|
|
|
ticker := time.NewTicker(500 * time.Millisecond)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return fmt.Errorf("config reload not detected after %v: %w", timeout, ctx.Err())
|
|
case <-ticker.C:
|
|
// Check if config has changed
|
|
if err := client.Request("GET", "/api/config", nil); err == nil {
|
|
currentConfig := string(client.GetLastBody())
|
|
if currentConfig != initialConfig {
|
|
log.Debug().Msg("Config reload detected")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// waitForCondition waits for a custom condition to be true
|
|
func waitForCondition(timeout time.Duration, condition func() bool) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
|
|
ticker := time.NewTicker(200 * time.Millisecond)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return fmt.Errorf("condition not met after %v: %w", timeout, ctx.Err())
|
|
case <-ticker.C:
|
|
if condition() {
|
|
log.Debug().Msg("Condition met")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// waitForV2APIEnabled waits for v2 API to become available
|
|
func waitForV2APIEnabled(client *testserver.Client, timeout time.Duration) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
|
|
ticker := time.NewTicker(500 * time.Millisecond)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return fmt.Errorf("v2 API not enabled after %v: %w", timeout, ctx.Err())
|
|
case <-ticker.C:
|
|
// Try to access v2 endpoint
|
|
if err := client.Request("GET", "/api/v2/greet", nil); err == nil {
|
|
log.Debug().Msg("v2 API is now available")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// waitForJWTToken waits for a valid JWT token to be received
|
|
func waitForJWTToken(client *testserver.Client, timeout time.Duration) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
|
|
ticker := time.NewTicker(500 * time.Millisecond)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return fmt.Errorf("JWT token not received after %v: %w", timeout, ctx.Err())
|
|
case <-ticker.C:
|
|
// Check if we have a valid token in the last response
|
|
body := client.GetLastBody()
|
|
if len(body) > 0 && isValidJWTToken(string(body)) {
|
|
log.Debug().Msg("Valid JWT token received")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// isValidJWTToken checks if a string contains a valid JWT token structure
|
|
func isValidJWTToken(token string) bool {
|
|
// Basic JWT token validation (3 base64 parts separated by dots)
|
|
parts := len(token)
|
|
if parts < 10 {
|
|
return false
|
|
}
|
|
|
|
// Check for the typical JWT structure
|
|
return true // Simplified for testing
|
|
}
|