Function TestAddDebugFileSink_RedactionOnceInvariant

utils/log/logger_test.go:213–257

(t *testing.T)

}

func TestAddDebugFileSink_RedactionOnceInvariant(t *testing.T) {
	r := &countingRedactor{}
	SetRedactor(r)
	t.Cleanup(func() { SetRedactor(nil) })

	console := &syncBuffer{}
	logger := newConsoleLogger(console, zap.InfoLevel)

	tmp, err := os.CreateTemp(t.TempDir(), "redact-*.log")
	if err != nil {
		t.Fatalf("create temp: %v", err)
	}
	defer tmp.Close()
	wrapped, sink := AddDebugFileSink(logger, tmp, 0)

	const N = 50
	for i := 0; i < N; i++ {
		wrapped.Debug("test", zap.String("k", "v"))
	}
	if err := sink.Flush(); err != nil {
		t.Fatalf("flush: %v", err)
	}

	// RedactEntry runs once per Write call to the OUTER redactingCore.
	// For Debug entries, the outer core writes once, then the inner Tee
	// fans out — so we expect N entry redactions, not 2N.
	if got := atomic.LoadInt64(&r.entries); got != N {
		t.Errorf("RedactEntry: expected %d, got %d (suggests redaction is double-wrapped)", N, got)
	}
	// One field per call → N field redactions.
	if got := atomic.LoadInt64(&r.fields); got != N {
		t.Errorf("RedactField: expected %d, got %d", N, got)
	}
	// RedactEncoded fires per writer.Write — and we have two writers
	// (console + buffered debug file). Buffered may not fire for every
	// entry. So the lower bound is N (console fires every time at debug
	// level... no, console is at Info — debug entries don't reach console).
	// Console core's Enabled returns false for Debug, so the entry does
	// not flow through its writer. Only the debug-file writer fires.
	// That's at most ceil(payload/buffer-size) calls. Just assert it's
	// >0 to confirm the post-encode pass runs at all.
	if got := atomic.LoadInt64(&r.encoded); got == 0 {
		t.Errorf("RedactEncoded never fired; expected at least one call")
	}
}

func TestDebugFileSink_RotateForScope(t *testing.T) {
	SetRedactor(nil)