@pi-in-go/pigpen-jev 0.1.0

package/libs/typesafe/libraries/typesafe/logging_test.go

@@ -0,0 +1,259 @@
+package typesafe
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+)
+
+// captureStderr runs fn and returns what it wrote to os.Stderr.
+func captureStderr(t *testing.T, fn func()) string {
+	t.Helper()
+	r, w, err := os.Pipe()
+	noErr(t, err)
+	old := os.Stderr
+	os.Stderr = w
+	var out []byte
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() { defer wg.Done(); out, _ = io.ReadAll(r) }()
+	func() {
+		defer func() { os.Stderr = old; _ = w.Close() }()
+		fn()
+	}()
+	wg.Wait()
+	return string(out)
+}
+
+func modelsOK() *mockDoer {
+	return always(func() *http.Response { return jsonResp(200, map[string]any{"models": []any{}}) })
+}
+
+func TestDefaultConsoleLogger_IsSilentAtTheDefaultLevelForASuccessfulRequest(t *testing.T) {
+	twin(t, "logging.test.ts | default console logger is silent at the default level for a successful request")
+	out := captureStderr(t, func() {
+		c, err := NewClient(Config{APIKey: "k", HTTPClient: modelsOK(), Getenv: noEnv})
+		noErr(t, err)
+		_, err = c.Models().List(ctxBG(), nil)
+		noErr(t, err)
+	})
+	eq(t, out, "")
+}
+
+func TestDefaultConsoleLogger_WritesPrefixedLinesToConsoleAtDebugLevel(t *testing.T) {
+	twin(t, "logging.test.ts | default console logger writes prefixed lines to console at debug level")
+	out := captureStderr(t, func() {
+		c, err := NewClient(Config{APIKey: "k", HTTPClient: modelsOK(), LogLevel: LogDebug, Getenv: noEnv})
+		noErr(t, err)
+		_, err = c.Models().List(ctxBG(), nil)
+		noErr(t, err)
+	})
+	lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
+	if len(lines) < 2 {
+		t.Fatalf("want request and response lines, got %q", out)
+	}
+	re := regexp.MustCompile(`^\[typesafe-sdk\] #1 GET /v1/models`)
+	for _, l := range lines {
+		if !re.MatchString(l) {
+			t.Fatalf("unprefixed line %q", l)
+		}
+	}
+}
+
+func TestDefaultConsoleLogger_RoutesEachLevelToTheMatchingConsoleMethod(t *testing.T) {
+	// Adapted: Go has one stream (stderr); the message keeps the prefix and the values follow it.
+	twin(t, "logging.test.ts | default console logger routes each level to the matching console method")
+	out := captureStderr(t, func() { NewStderrLogger().Warn("careful", map[string]any{"a": 1}) })
+	eq(t, out, "[typesafe-sdk] careful {\"a\":1}\n")
+	out = captureStderr(t, func() { NewStderrLogger().Error("bad") })
+	eq(t, out, "[typesafe-sdk] bad\n")
+}
+
+func loggedClient(t *testing.T, logger Logger, level LogLevel) *Client {
+	return newClient(t, always(func() *http.Response {
+		return jsonResp(200, map[string]any{"models": []any{}}, "x-typesafe-request-id", "req_9")
+	}), func(c *Config) {
+		c.APIKey = "sk_live_0123456789abcdef"
+		c.BaseURL = "https://x.test"
+		c.Logger = logger
+		c.LogLevel = level
+	})
+}
+
+func TestCustomLogger_ExposesTheLevelFilteredLoggerOnTheClient(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering exposes the level-filtered logger on the client")
+	l := &recordingLogger{}
+	c := loggedClient(t, l, LogWarn)
+	c.Logger().Info("dropped")
+	c.Logger().Warn("kept")
+	eq(t, l.messages(""), []string{"kept"})
+}
+
+func TestCustomLogger_DropsEverythingAtLevelOff(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering drops everything at level off")
+	l := &recordingLogger{}
+	_, err := loggedClient(t, l, LogOff).Models().List(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, len(l.snapshot()), 0)
+}
+
+func TestCustomLogger_LogsAOneLineSummaryAtInfoAndNothingAtDebug(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering logs a one-line summary at info and nothing at debug")
+	l := &recordingLogger{}
+	_, err := loggedClient(t, l, LogInfo).Models().List(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, len(l.messages("debug")), 0)
+	got := l.messages("info")
+	eq(t, len(got), 1)
+	if !regexp.MustCompile(`^#1 GET /v1/models <- 200 in \d+ms \(request req_9\)$`).MatchString(got[0]) {
+		t.Fatalf("summary %q", got[0])
+	}
+}
+
+func TestCustomLogger_LogsRequestHeadersRequestBodyAndResponseBodyAtDebug(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering logs request headers, request body, and response body at debug")
+	l := &recordingLogger{}
+	_, err := loggedClient(t, l, LogDebug).Models().List(ctxBG(), nil)
+	noErr(t, err)
+	calls := l.snapshot()
+	first := calls[0]
+	eq(t, first.Level, "debug")
+	eq(t, first.Message, "#1 GET /v1/models -> https://x.test/v1/models")
+	detail := first.Args[0].(map[string]any)
+	headers := detail["headers"].(map[string]string)
+	runtimeHeader := headers["X-TypeSafe-Runtime"]
+	if !strings.HasPrefix(runtimeHeader, "go/") {
+		t.Fatalf("runtime %q", runtimeHeader)
+	}
+	eq(t, headers, map[string]string{
+		"Authorization": "Bearer ***cdef", "Accept": "application/json",
+		"User-Agent": "typesafe-sdk-go/" + Version, "X-TypeSafe-SDK": "typesafe-sdk-go/" + Version, "X-TypeSafe-Runtime": runtimeHeader,
+	})
+	if detail["body"] != nil {
+		t.Fatalf("a GET has no body, got %v", detail["body"])
+	}
+	last := calls[len(calls)-1]
+	eq(t, last.Level, "debug")
+	eq(t, last.Message, "#1 GET /v1/models <- body")
+	eq(t, last.Args[0], any(map[string]any{"models": []any{}}))
+}
+
+func TestCustomLogger_NeverLogsTheRawAPIKey(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering never logs the raw API key")
+	l := &recordingLogger{}
+	_, err := loggedClient(t, l, LogDebug).Models().List(ctxBG(), nil)
+	noErr(t, err)
+	for _, c := range l.snapshot() {
+		if strings.Contains(c.Message, "sk_live_0123456789abcdef") || strings.Contains(strings.ReplaceAll(strings.TrimSpace(fmtAny(c.Args)), "\n", " "), "sk_live_0123456789abcdef") {
+			t.Fatalf("raw key in log call %+v", c)
+		}
+	}
+}
+
+func TestCustomLogger_NumbersRequestsSoConcurrentCallsCanBeToldApart(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering numbers requests so concurrent calls can be told apart")
+	l := &recordingLogger{}
+	c := loggedClient(t, l, LogInfo)
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() { defer wg.Done(); _, _ = c.Models().List(ctxBG(), nil) }()
+	}
+	wg.Wait()
+	var tags []string
+	for _, m := range l.messages("info") {
+		tags = append(tags, m[:2])
+	}
+	if len(tags) != 2 || !((tags[0] == "#1" && tags[1] == "#2") || (tags[0] == "#2" && tags[1] == "#1")) {
+		t.Fatalf("tags %v", tags)
+	}
+}
+
+func TestCustomLogger_LogsErrorResponsesAsASummaryPlusTheBodyAtDebugWithoutAWarn(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering logs error responses as a summary plus the body at debug, without a warn")
+	l := &recordingLogger{}
+	c := newClient(t, always(func() *http.Response { return jsonResp(404, map[string]any{"message": "nope"}) }), func(c *Config) { c.Logger, c.LogLevel = l, LogDebug })
+	_, err := c.Models().List(ctxBG(), nil)
+	if err == nil || !strings.Contains(err.Error(), "404 nope") {
+		t.Fatalf("got %v", err)
+	}
+	info := l.messages("info")
+	eq(t, len(info), 1)
+	if !regexp.MustCompile(`^#1 GET /v1/models <- 404 in \d+ms$`).MatchString(info[0]) {
+		t.Fatalf("summary %q", info[0])
+	}
+	calls := l.snapshot()
+	last := calls[len(calls)-1]
+	eq(t, last, logCall{"debug", "#1 GET /v1/models <- error body", []any{map[string]any{"message": "nope"}}})
+	eq(t, len(l.messages("warn")), 0)
+	eq(t, len(l.messages("error")), 0)
+}
+
+func TestCustomLogger_LogsConnectionFailuresWithTheUnderlyingError(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering logs connection failures with the underlying error")
+	l := &recordingLogger{}
+	boom := errors.New("fetch failed")
+	c := newClient(t, newMock(func(*recordedRequest) (*http.Response, error) { return nil, boom }), func(c *Config) {
+		c.Logger, c.LogLevel = l, LogInfo
+		c.Retry = RetryOverrides{MaxRetries: Ptr(0)}
+	})
+	_, err := c.Models().List(ctxBG(), nil)
+	if err == nil || !strings.Contains(err.Error(), "fetch failed") {
+		t.Fatalf("got %v", err)
+	}
+	calls := l.snapshot()
+	eq(t, len(calls), 1)
+	eq(t, calls[0].Level, "info")
+	if !regexp.MustCompile(`^#1 GET /v1/models connection error after \d+ms$`).MatchString(calls[0].Message) {
+		t.Fatalf("message %q", calls[0].Message)
+	}
+	if len(calls[0].Args) != 1 || calls[0].Args[0] != error(boom) {
+		t.Fatalf("args %v", calls[0].Args)
+	}
+}
+
+func TestCustomLogger_LogsCallerAborts(t *testing.T) {
+	twin(t, "logging.test.ts | custom logger and level filtering logs caller aborts")
+	l := &recordingLogger{}
+	ctx, cancel := context.WithCancel(context.Background())
+	c := newClient(t, newMock(func(*recordedRequest) (*http.Response, error) { cancel(); return nil, context.Canceled }), func(c *Config) { c.Logger, c.LogLevel = l, LogInfo })
+	_, err := c.Models().List(ctx, nil)
+	mustAs[*APIUserAbortError](t, err)
+	info := l.messages("info")
+	eq(t, len(info), 1)
+	if !regexp.MustCompile(`^#1 GET /v1/models aborted by caller after \d+ms$`).MatchString(info[0]) {
+		t.Fatalf("message %q", info[0])
+	}
+}
+
+func TestRedactHeaders_MasksCredentialsKeepsTheSchemeAndTheLastFourCharacters(t *testing.T) {
+	twin(t, "logging.test.ts | redactHeaders masks credentials, keeps the scheme and the last four characters")
+	got := RedactHeaders(map[string]string{"Authorization": "Bearer sk_live_0123456789abcdef", "x-api-key": "0123456789abcdef", "Cookie": "session=abc", "Accept": "application/json"})
+	eq(t, got, map[string]string{"Authorization": "Bearer ***cdef", "x-api-key": "***cdef", "Cookie": "***", "Accept": "application/json"})
+}
+
+func TestRedactHeaders_DoesNotLeakATailFromShortSecrets(t *testing.T) {
+	twin(t, "logging.test.ts | redactHeaders does not leak a tail from short secrets")
+	eq(t, RedactHeaders(map[string]string{"authorization": "Bearer abc"}), map[string]string{"authorization": "Bearer ***"})
+}
+
+func TestRedactHeaders_DoesNotMutateItsInput(t *testing.T) {
+	twin(t, "logging.test.ts | redactHeaders does not mutate its input")
+	in := map[string]string{"Authorization": "Bearer x"}
+	RedactHeaders(in)
+	eq(t, in["Authorization"], "Bearer x")
+}
+
+func TestParseLogLevel_RejectsUnknownValuesNamingTheSource(t *testing.T) {
+	_, err := ParseLogLevel("loud", "somewhere")
+	contains(t, err.Error(), `Invalid log level "loud" from somewhere. Expected one of: debug, info, warn, error, off.`)
+	l, err := ParseLogLevel("info", "x")
+	noErr(t, err)
+	eq(t, l, LogInfo)
+}

package/libs/typesafe/libraries/typesafe/marshal_test.go

@@ -0,0 +1,112 @@
+package typesafe
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+)
+
+// encoding/json passes the output of a Marshaler (and a json.RawMessage) through compact, and Go 1.26
+// copies U+2028 and U+2029 through unescaped there when HTML escaping is off, while Go 1.27 always escapes
+// them (as it always has for a plain string). A body must not depend on the toolchain that built the client
+// (its Content-Length would not), so marshalPlain escapes them everywhere; a parser decodes both forms alike.
+func TestMarshalPlainEscapesLineSeparatorsOnEveryGoVersion(t *testing.T) {
+	raw := json.RawMessage("{\"k\":\"a\u2028b\u2029c\"}")
+	cases := map[string]any{
+		"string":      "a\u2028b\u2029c",
+		"raw message": raw,
+		"entry":       Value(raw),
+		"nested":      map[string]any{"state": Value(raw), "text": Text("a\u2028b")},
+	}
+	for name, v := range cases {
+		t.Run(name, func(t *testing.T) {
+			got, err := marshalPlain(v)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if bytes.Contains(got, []byte("\u2028")) || bytes.Contains(got, []byte("\u2029")) {
+				t.Fatalf("raw U+2028/U+2029 left in %q", got)
+			}
+			var back any
+			if err := json.Unmarshal(got, &back); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+// On Go 1.27 encoding/json never hands marshalPlain a raw separator, so the test above cannot see the escaping
+// step there; this one feeds it the raw bytes Go 1.26 produces, so the step is checked on every toolchain.
+func TestEscapeLineSeparatorsReplacesTheRawBytesGo126Leaves(t *testing.T) {
+	got := string(escapeLineSeparators([]byte("{\"k\":\"a\u2028b\u2029c\\\\u2028\"}")))
+	if want := `{"k":"a\u2028b\u2029c\\u2028"}`; got != want {
+		t.Fatalf("got %s, want %s", got, want)
+	}
+}
+
+func TestMarshalPlainKeepsHTMLAndAnEscapedBackslashIntact(t *testing.T) {
+	// A backslash followed by "u2028" is the text \u2028, not a separator, and must stay as written.
+	got, err := marshalPlain(map[string]any{"a": "<b>&\\u2028"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := `{"a":"<b>&\\u2028"}`; string(got) != want {
+		t.Fatalf("got %s, want %s", got, want)
+	}
+}
+
+// Most bodies hold neither separator. The replacement then must not copy the body (bytes.ReplaceAll returns a
+// fresh copy even when nothing matches, and every Entry in a request goes through it).
+func TestEscapeLineSeparatorsDoesNotCopyACleanBody(t *testing.T) {
+	clean := []byte(`{"state":"plain text","n":1}`)
+	if allocs := testing.AllocsPerRun(100, func() { _ = escapeLineSeparators(clean) }); allocs != 0 {
+		t.Fatalf("escapeLineSeparators allocated %.0f times for a body without U+2028 or U+2029", allocs)
+	}
+	got := escapeLineSeparators([]byte("{\"a\":\"x\u2028y\u2029z\"}"))
+	if want := `{"a":"x\u2028y\u2029z"}`; string(got) != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+}
+
+// A key is written the way marshalPlain writes it, but a plain one (the SDK's own field names, and a question
+// name such as "destructive") does not need an encoder: it is quoted directly.
+func TestObjectKeyMatchesMarshalPlainAndSkipsTheEncoderForPlainNames(t *testing.T) {
+	for _, name := range []string{"", "state", "beyond_scope", "with space", `quo"te`, `back\slash`, "tab\there", "ünï", "<tag>&", "a\u2028b", "\x7f", "emoji 🐖"} {
+		o := newObject()
+		o.key(name)
+		want, _ := marshalPlain(name)
+		if got := o.buf.String(); got != "{"+string(want)+":" {
+			t.Errorf("key(%q) wrote %q, want %q", name, got, "{"+string(want)+":")
+		}
+	}
+	if allocs := testing.AllocsPerRun(100, func() { o := newObject(); o.key("destructive") }); allocs > 3 {
+		t.Fatalf("a plain key allocated %.0f times; the object and its buffer are the only allocations it needs", allocs)
+	}
+}
+
+// Below debug level nothing reads the request headers or the response body that debug logging prints, so they
+// are not built: logBody parsed the whole response as JSON for a log line that the level filter then dropped.
+func TestDebugLogArgumentsAreNotBuiltBelowDebugLevel(t *testing.T) {
+	body := []byte(`{"model":"m","answers":{"a":{"type":"noul","noul":0.5}},"usage":{}}`)
+	for _, level := range []LogLevel{LogOff, LogError, LogWarn, LogInfo} {
+		c, err := NewClient(Config{APIKey: "k", BaseURL: "http://127.0.0.1:1", Getenv: noEnv, LogLevel: level})
+		noErr(t, err)
+		raw := &RawResponse{Status: 200, Body: body}
+		if allocs := testing.AllocsPerRun(50, func() { c.logBody(raw) }); allocs != 0 {
+			t.Errorf("level %s: logBody allocated %.0f times; the body must not be parsed for a debug line that is dropped", level, allocs)
+		}
+	}
+	c, err := NewClient(Config{APIKey: "k", BaseURL: "http://127.0.0.1:1", Getenv: noEnv, LogLevel: LogDebug, Logger: &captureLogger{}})
+	noErr(t, err)
+	c.logBody(&RawResponse{Status: 200, Body: body, tag: "#1 POST /x"})
+	if cl := c.logger.(levelLogger).sink.(*captureLogger); len(cl.debug) != 1 {
+		t.Fatalf("debug level must still log the parsed body, got %v", cl.debug)
+	}
+}
+
+type captureLogger struct{ debug []string }
+
+func (l *captureLogger) Debug(m string, _ ...any) { l.debug = append(l.debug, m) }
+func (l *captureLogger) Info(string, ...any)      {}
+func (l *captureLogger) Warn(string, ...any)      {}
+func (l *captureLogger) Error(string, ...any)     {}

package/libs/typesafe/libraries/typesafe/mutation_test.go

@@ -0,0 +1,39 @@
+package typesafe
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+)
+
+// Added by the mutation check (port/mutations.json: batch-default-concurrency-one): with no
+// Concurrency set, DefaultBatchConcurrency requests run at once.
+func TestEvaluateBatch_DefaultConcurrencyRunsSeveralRequestsAtOnce(t *testing.T) {
+	var mu sync.Mutex
+	inflight, peak := 0, 0
+	release := make(chan struct{})
+	var once sync.Once
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, _ *RequestOptions) (*SystemOneResult, error) {
+		mu.Lock()
+		inflight++
+		if inflight > peak {
+			peak = inflight
+		}
+		if inflight == DefaultBatchConcurrency {
+			once.Do(func() { close(release) })
+		}
+		mu.Unlock()
+		select {
+		case <-release:
+		case <-time.After(2 * time.Second):
+		}
+		mu.Lock()
+		inflight--
+		mu.Unlock()
+		return &SystemOneResult{}, nil
+	})
+	out := EvaluateBatch(context.Background(), ev, batchItems(2*DefaultBatchConcurrency), BatchOptions{})
+	eq(t, len(out), 2*DefaultBatchConcurrency)
+	eq(t, peak, DefaultBatchConcurrency)
+}