Bound external reference reads and fingerprints

internal/framework/pipeline/references_test.go

@@ -2,6 +2,9 @@ package pipeline
 
 import (
 	"encoding/json"
+	"errors"
+	"io"
+	"math"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -12,6 +15,61 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 )
 
+type countingReader struct {
+	content  []byte
+	consumed int
+}
+
+func (reader *countingReader) Read(buffer []byte) (int, error) {
+	if len(reader.content) == 0 {
+		return 0, io.EOF
+	}
+	read := copy(buffer, reader.content)
+	reader.content = reader.content[read:]
+	reader.consumed += read
+	return read, nil
+}
+
+func TestReadReferenceContentBoundsPositiveMaximum(t *testing.T) {
+	tests := []struct {
+		name          string
+		content       string
+		maxBytes      int64
+		wantContent   string
+		wantConsumed  int
+		wantLimitErr  bool
+		wantReadError bool
+	}{
+		{name: "exact maximum", content: "abc", maxBytes: 3, wantContent: "abc", wantConsumed: 3},
+		{name: "oversized", content: "abcdef", maxBytes: 3, wantConsumed: 4, wantLimitErr: true},
+		{name: "unbounded", content: "abcdef", maxBytes: 0, wantContent: "abcdef", wantConsumed: 6},
+		{name: "negative maximum remains unbounded", content: "abcdef", maxBytes: -1, wantContent: "abcdef", wantConsumed: 6},
+		{name: "overflowing maximum", content: "abcdef", maxBytes: math.MaxInt64, wantConsumed: 0, wantReadError: true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reader := &countingReader{content: []byte(tt.content)}
+			content, err := readReferenceContent(reader, tt.maxBytes)
+			if reader.consumed != tt.wantConsumed {
+				t.Fatalf("reader consumed %d bytes, want %d", reader.consumed, tt.wantConsumed)
+			}
+			if got := string(content); got != tt.wantContent {
+				t.Fatalf("content = %q, want %q", got, tt.wantContent)
+			}
+			var sizeErr *referenceSizeLimitError
+			if errors.As(err, &sizeErr) != tt.wantLimitErr {
+				t.Fatalf("error = %v, want limit error=%t", err, tt.wantLimitErr)
+			}
+			if (err != nil) != (tt.wantLimitErr || tt.wantReadError) {
+				t.Fatalf("error = %v, want error=%t", err, tt.wantLimitErr || tt.wantReadError)
+			}
+			if sizeErr != nil && (sizeErr.SizeBytes != 4 || sizeErr.MaxBytes != 3) {
+				t.Fatalf("size error = %#v, want observed size 4 and limit 3", sizeErr)
+			}
+		})
+	}
+}
+
 func TestMaterializeReferencesResolvesPathsAndDigestsContent(t *testing.T) {
 	configDir := t.TempDir()
 	workingDir := t.TempDir()