test(sink): cover http and sinktest error branches

Add the http build-request and PostJSON marshal-error paths, and exercise the
sinktest conformance harness's Flusher and Shutdowner error and panic branches
plus its nil-Outlet guard.

Signed-off-by: Joshua Temple <joshua.temple@stablekernel.com>

Author: joshua-temple

sink/http/error_paths_test.go

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package http_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	httpsink "github.com/stablekernel/crucible/sink/http"
+)
+
+// TestPost_BuildRequestError exercises the NewRequestWithContext failure branch:
+// a URL containing a control character cannot be parsed into a request, so Post
+// returns a build-request error before any Do call.
+func TestPost_BuildRequestError(t *testing.T) {
+	t.Parallel()
+
+	doer := &fakeDoer{}
+	// A control character in the URL makes http.NewRequestWithContext fail.
+	err := httpsink.Post("http://example.test/\x7f", "application/json", []byte("{}")).
+		Apply(context.Background(), doer)
+	if err == nil {
+		t.Fatal("Apply() = nil, want a build-request error")
+	}
+	if !strings.Contains(err.Error(), "build request") {
+		t.Errorf("error = %v, want it to mention building the request", err)
+	}
+	if len(doer.requests) != 0 {
+		t.Errorf("Do() called %d times, want 0 (request never built)", len(doer.requests))
+	}
+}
+
+// unmarshalable is a type json.Marshal rejects: a channel field cannot be
+// encoded, driving the PostJSON marshal-error branch.
+type unmarshalable struct {
+	Ch chan int
+}
+
+// TestPostJSON_MarshalError exercises the json.Marshal failure branch: an
+// unmarshalable payload returns a marshal error before any request is built.
+func TestPostJSON_MarshalError(t *testing.T) {
+	t.Parallel()
+
+	doer := &fakeDoer{}
+	err := httpsink.PostJSON("http://example.test/items", unmarshalable{Ch: make(chan int)}).
+		Apply(context.Background(), doer)
+	if err == nil {
+		t.Fatal("Apply() = nil, want a marshal error")
+	}
+	if !strings.Contains(err.Error(), "marshal json") {
+		t.Errorf("error = %v, want it to mention marshaling json", err)
+	}
+	if len(doer.requests) != 0 {
+		t.Errorf("Do() called %d times, want 0 (marshal failed first)", len(doer.requests))
+	}
+}

sink/sinktest/error_branches_test.go

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package sinktest
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/stablekernel/crucible/sink"
+)
+
+// flushOutlet is a conforming Outlet whose Flush behavior is configurable, so
+// the harness's Flusher branch can be driven into both its error and panic
+// arms.
+type flushOutlet struct {
+	flushErr   error
+	flushPanic bool
+}
+
+func (o *flushOutlet) Sink(_ context.Context, _ any) error { return sink.ErrUnregistered }
+
+func (o *flushOutlet) Flush(context.Context) error {
+	if o.flushPanic {
+		panic("flush boom")
+	}
+	return o.flushErr
+}
+
+// shutdownOutlet is a conforming Outlet whose Shutdown behavior is configurable.
+type shutdownOutlet struct {
+	shutdownErr   error
+	shutdownPanic bool
+}
+
+func (o *shutdownOutlet) Sink(_ context.Context, _ any) error { return sink.ErrUnregistered }
+
+func (o *shutdownOutlet) Shutdown(context.Context) error {
+	if o.shutdownPanic {
+		panic("shutdown boom")
+	}
+	return o.shutdownErr
+}
+
+func TestCheckFlusherReportsError(t *testing.T) {
+	t.Parallel()
+
+	boom := errors.New("dirty flush")
+	errs := checkOutlet(func() sink.Outlet { return &flushOutlet{flushErr: boom} })
+	if !containsErr(errs, "Flush on a clean outlet") {
+		t.Fatalf("checkOutlet did not flag a flush error; got %v", errs)
+	}
+}
+
+func TestCheckFlusherRecoversPanic(t *testing.T) {
+	t.Parallel()
+
+	errs := checkOutlet(func() sink.Outlet { return &flushOutlet{flushPanic: true} })
+	if !containsErr(errs, "Flush panicked") {
+		t.Fatalf("checkOutlet did not report a flush panic; got %v", errs)
+	}
+}
+
+func TestCheckShutdownerReportsError(t *testing.T) {
+	t.Parallel()
+
+	boom := errors.New("dirty shutdown")
+	errs := checkOutlet(func() sink.Outlet { return &shutdownOutlet{shutdownErr: boom} })
+	if !containsErr(errs, "Shutdown returned") {
+		t.Fatalf("checkOutlet did not flag a shutdown error; got %v", errs)
+	}
+}
+
+func TestCheckShutdownerRecoversPanic(t *testing.T) {
+	t.Parallel()
+
+	errs := checkOutlet(func() sink.Outlet { return &shutdownOutlet{shutdownPanic: true} })
+	if !containsErr(errs, "Shutdown panicked") {
+		t.Fatalf("checkOutlet did not report a shutdown panic; got %v", errs)
+	}
+}
+
+func TestCheckOutletRejectsNilOutlet(t *testing.T) {
+	t.Parallel()
+
+	errs := checkOutlet(func() sink.Outlet { return nil })
+	if !containsErr(errs, "nil Outlet") {
+		t.Fatalf("checkOutlet did not flag a nil Outlet; got %v", errs)
+	}
+}
+
+func containsErr(errs []error, substr string) bool {
+	for _, e := range errs {
+		if e != nil && contains(e.Error(), substr) {
+			return true
+		}
+	}
+	return false
+}
+
+func contains(haystack, needle string) bool {
+	for i := 0; i+len(needle) <= len(haystack); i++ {
+		if haystack[i:i+len(needle)] == needle {
+			return true
+		}
+	}
+	return false
+}