105 lines
4.5 KiB
Go
105 lines
4.5 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"proxy-pool/internal/loadgen"
|
|
)
|
|
|
|
func TestExecutePassesBoundedWorkloadAndWritesJSON(t *testing.T) {
|
|
var received loadgen.Options
|
|
var stdout, stderr bytes.Buffer
|
|
code := execute(context.Background(), []string{
|
|
"-target", "https://target.example/path", "-proxy", "http://gateway.example:8080", "-method", "post",
|
|
"-requests", "3", "-concurrency", "2", "-timeout", "2s", "-header", "X-Run: fixed", "-body", `{"count":1}`,
|
|
}, func(_ context.Context, options loadgen.Options) (loadgen.Report, error) {
|
|
received = options
|
|
return loadgen.Report{
|
|
Requests: 3, Completed: 3, Succeeded: 3, Duration: time.Second,
|
|
RateStartsGenerated: 3, RateStartsDropped: 1,
|
|
}, nil
|
|
}, &stdout, &stderr)
|
|
if code != 0 || received.TargetURL != "https://target.example/path" || received.ProxyURL != "http://gateway.example:8080" ||
|
|
received.Method != "post" || received.Requests != 3 || received.Duration != 0 || received.Concurrency != 2 ||
|
|
received.Headers.Get("X-Run") != "fixed" || string(received.RequestBody) != `{"count":1}` || stderr.Len() != 0 {
|
|
t.Fatalf("execute() = %d; options=%+v stderr=%q", code, received, stderr.String())
|
|
}
|
|
var report loadgen.Report
|
|
if err := json.Unmarshal(stdout.Bytes(), &report); err != nil || report.Succeeded != 3 ||
|
|
report.RateStartsGenerated != 3 || report.RateStartsDropped != 1 {
|
|
t.Fatalf("JSON report = (%+v, %v)", report, err)
|
|
}
|
|
}
|
|
|
|
func TestExecuteRejectsInvalidWorkload(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
code := execute(context.Background(), []string{"-target", "http://target.example"}, loadgen.Run, &stdout, &stderr)
|
|
if code != 2 || stdout.Len() != 0 || stderr.Len() == 0 {
|
|
t.Fatalf("execute() = %d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestExecutePassesCONNECTScenario(t *testing.T) {
|
|
var received loadgen.Options
|
|
var stdout, stderr bytes.Buffer
|
|
code := execute(context.Background(), []string{
|
|
"-scenario", "connect", "-target", "https://target.example/health", "-proxy", "http://gateway.example:8080",
|
|
"-requests", "2", "-concurrency", "1", "-timeout", "2s", "-hold", "30s",
|
|
}, func(_ context.Context, options loadgen.Options) (loadgen.Report, error) {
|
|
received = options
|
|
return loadgen.Report{Requests: 2, Completed: 2, Succeeded: 2, Duration: time.Second}, nil
|
|
}, &stdout, &stderr)
|
|
if code != 0 || received.Scenario != loadgen.ScenarioConnect || received.TunnelHold != 30*time.Second ||
|
|
received.ProxyURL != "http://gateway.example:8080" || stderr.Len() != 0 {
|
|
t.Fatalf("execute() = %d; options=%+v stderr=%q", code, received, stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestExecutePassesExtractScenario(t *testing.T) {
|
|
var received loadgen.Options
|
|
var stdout, stderr bytes.Buffer
|
|
code := execute(context.Background(), []string{
|
|
"-scenario", "extract", "-target", "http://controller.example:8081/api/v1/proxies/extract",
|
|
"-requests", "2", "-concurrency", "1", "-timeout", "2s", "-extract-count", "3", "-extract-fulfillment", "allOrNothing",
|
|
}, func(_ context.Context, options loadgen.Options) (loadgen.Report, error) {
|
|
received = options
|
|
return loadgen.Report{Requests: 2, Completed: 2, Succeeded: 2, Duration: time.Second}, nil
|
|
}, &stdout, &stderr)
|
|
if code != 0 || received.Scenario != loadgen.ScenarioExtract || received.Method != "" || received.ExtractCount != 3 ||
|
|
received.ExtractFulfillment != "allOrNothing" || stderr.Len() != 0 {
|
|
t.Fatalf("execute() = %d; options=%+v stderr=%q", code, received, stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestExecuteWritesReportFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
path := filepath.Join(t.TempDir(), "load-report.json")
|
|
if err := os.WriteFile(path, []byte("incomplete"), 0o600); err != nil {
|
|
t.Fatalf("WriteFile(): %v", err)
|
|
}
|
|
var stdout, stderr bytes.Buffer
|
|
code := execute(context.Background(), []string{
|
|
"-target", "https://target.example/health", "-requests", "1", "-concurrency", "1", "-output", path,
|
|
}, func(_ context.Context, _ loadgen.Options) (loadgen.Report, error) {
|
|
return loadgen.Report{Requests: 1, Completed: 1, Succeeded: 1, Duration: time.Second}, nil
|
|
}, &stdout, &stderr)
|
|
if code != 0 || stderr.Len() != 0 {
|
|
t.Fatalf("execute() = %d, stderr=%q", code, stderr.String())
|
|
}
|
|
content, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("ReadFile(): %v", err)
|
|
}
|
|
var report loadgen.Report
|
|
if err := json.Unmarshal(content, &report); err != nil || report.Succeeded != 1 || string(content) == "incomplete" {
|
|
t.Fatalf("report file = (%q, %+v, %v)", content, report, err)
|
|
}
|
|
}
|