notarius/internal/framework/pipeline/extractor_registry_test.go

package pipeline

import (
	"context"
	"errors"
	"reflect"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)

func TestExtractorRegistryRegisterAndBuild(t *testing.T) {
	registry := NewExtractorRegistry()

	if err := registry.Register("generic-extractor", fakeExtractorConstructor("generic-extractor")); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	extractor, err := registry.Build("generic-extractor")
	if err != nil {
		t.Fatalf("Build() error = %v, want nil", err)
	}
	if extractor.Key() != "generic-extractor" {
		t.Fatalf("extractor.Key() = %q, want generic-extractor", extractor.Key())
	}
}

func TestExtractorRegistryRegisterAndBuildTrimKeys(t *testing.T) {
	registry := NewExtractorRegistry()

	if err := registry.Register(" generic-extractor ", fakeExtractorConstructor("generic-extractor")); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	extractor, err := registry.Build("\tgeneric-extractor\n")
	if err != nil {
		t.Fatalf("Build() error = %v, want nil", err)
	}
	if extractor.Key() != "generic-extractor" {
		t.Fatalf("extractor.Key() = %q, want generic-extractor", extractor.Key())
	}
}

func TestExtractorRegistryRegisterWithSpecStoresMetadata(t *testing.T) {
	registry := NewExtractorRegistry()
	spec := ModuleSpec{
		Key:      " generic-extractor ",
		Stage:    StageExtract,
		Provides: []string{" generic-artifact ", "source-citations", "generic-artifact", ""},
		Requires: []string{" source-document ", "source-document", ""},
		ReferenceSlots: []contracts.ReferenceSlot{
			{
				Name:               " glossary ",
				Description:        " Supporting terms ",
				AcceptedMediaTypes: []string{" text/plain ", "text/markdown", "text/plain", ""},
				MaxBytes:           1024,
			},
			{
				Name:        " roster ",
				Description: " Characters ",
				Required:    true,
				Multiple:    true,
			},
		},
	}

	if err := registry.RegisterWithSpec(spec, fakeExtractorConstructor("generic-extractor")); err != nil {
		t.Fatalf("RegisterWithSpec() error = %v, want nil", err)
	}

	got, ok := registry.Spec("\tgeneric-extractor\n")
	if !ok {
		t.Fatal("Spec() ok = false, want true")
	}
	want := ModuleSpec{
		Key:      "generic-extractor",
		Stage:    StageExtract,
		Provides: []string{"generic-artifact", "source-citations"},
		Requires: []string{"source-document"},
		ReferenceSlots: []contracts.ReferenceSlot{
			{
				Name:               "glossary",
				Description:        "Supporting terms",
				AcceptedMediaTypes: []string{"text/markdown", "text/plain"},
				MaxBytes:           1024,
			},
			{
				Name:        "roster",
				Description: "Characters",
				Required:    true,
				Multiple:    true,
			},
		},
	}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("Spec() = %#v, want %#v", got, want)
	}

	got.Provides[0] = "changed"
	got.ReferenceSlots[0].Name = "changed"
	got.ReferenceSlots[0].AcceptedMediaTypes[0] = "changed"
	again, ok := registry.Spec("generic-extractor")
	if !ok {
		t.Fatal("Spec() after caller mutation ok = false, want true")
	}
	if !reflect.DeepEqual(again, want) {
		t.Fatalf("Spec() after caller mutation = %#v, want %#v", again, want)
	}
}

func TestExtractorRegistryRegisterStoresDefaultSpec(t *testing.T) {
	registry := NewExtractorRegistry()

	if err := registry.Register(" generic-extractor ", fakeExtractorConstructor("generic-extractor")); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	got, ok := registry.Spec("generic-extractor")
	if !ok {
		t.Fatal("Spec() ok = false, want true")
	}
	want := ModuleSpec{Key: "generic-extractor", Stage: StageExtract}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("Spec() = %#v, want %#v", got, want)
	}
}

func TestExtractorRegistryRegisterWithSpecRejectsWrongStage(t *testing.T) {
	registry := NewExtractorRegistry()

	err := registry.RegisterWithSpec(ModuleSpec{Key: "generic-extractor", Stage: StageInput}, fakeExtractorConstructor("generic-extractor"))

	if err == nil {
		t.Fatal("RegisterWithSpec() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "stage") {
		t.Fatalf("RegisterWithSpec() error = %q, want stage error", err.Error())
	}
}

func TestExtractorRegistryRejectsInvalidReferenceSlots(t *testing.T) {
	tests := []struct {
		name  string
		slots []contracts.ReferenceSlot
		want  string
	}{
		{
			name:  "empty name",
			slots: []contracts.ReferenceSlot{{Name: " "}},
			want:  "name",
		},
		{
			name: "duplicate name after trim",
			slots: []contracts.ReferenceSlot{
				{Name: "roster"},
				{Name: " roster "},
			},
			want: "duplicated",
		},
		{
			name:  "negative max bytes",
			slots: []contracts.ReferenceSlot{{Name: "roster", MaxBytes: -1}},
			want:  "max_bytes",
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			registry := NewExtractorRegistry()
			err := registry.RegisterWithSpec(ModuleSpec{
				Key:            "generic-extractor",
				Stage:          StageExtract,
				ReferenceSlots: test.slots,
			}, fakeExtractorConstructor("generic-extractor"))
			if err == nil {
				t.Fatal("RegisterWithSpec() error = nil, want error")
			}
			if !strings.Contains(err.Error(), test.want) {
				t.Fatalf("RegisterWithSpec() error = %q, want %q", err.Error(), test.want)
			}
		})
	}
}

func TestExtractorRegistrySpecRejectsUnknownKey(t *testing.T) {
	registry := NewExtractorRegistry()

	if _, ok := registry.Spec("missing-extractor"); ok {
		t.Fatal("Spec() ok = true, want false")
	}
}

func TestExtractorRegistryRegisterRejectsEmptyKey(t *testing.T) {
	registry := NewExtractorRegistry()

	err := registry.Register(" \t", fakeExtractorConstructor("generic-extractor"))

	if err == nil {
		t.Fatal("Register() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "key must not be empty") {
		t.Fatalf("Register() error = %q, want empty key error", err.Error())
	}
}

func TestExtractorRegistryRegisterRejectsDuplicateKey(t *testing.T) {
	registry := NewExtractorRegistry()
	if err := registry.Register("generic-extractor", fakeExtractorConstructor("generic-extractor")); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	err := registry.Register(" generic-extractor ", fakeExtractorConstructor("generic-extractor"))

	if err == nil {
		t.Fatal("Register() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "already registered") {
		t.Fatalf("Register() error = %q, want duplicate key error", err.Error())
	}
}

func TestExtractorRegistryRegisterRejectsNilConstructor(t *testing.T) {
	registry := NewExtractorRegistry()

	err := registry.Register("generic-extractor", nil)

	if err == nil {
		t.Fatal("Register() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "constructor") {
		t.Fatalf("Register() error = %q, want constructor error", err.Error())
	}
}

func TestExtractorRegistryBuildRejectsUnknownKey(t *testing.T) {
	registry := NewExtractorRegistry()

	_, err := registry.Build("missing-extractor")

	if err == nil {
		t.Fatal("Build() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "not registered") {
		t.Fatalf("Build() error = %q, want unknown key error", err.Error())
	}
}

func TestExtractorRegistryBuildWrapsConstructorError(t *testing.T) {
	registry := NewExtractorRegistry()
	constructorErr := errors.New("constructor failed")
	if err := registry.Register("generic-extractor", func() (contracts.Extractor, error) {
		return nil, constructorErr
	}); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	_, err := registry.Build("generic-extractor")

	if err == nil {
		t.Fatal("Build() error = nil, want error")
	}
	if !errors.Is(err, constructorErr) {
		t.Fatalf("Build() error = %v, want wrapped constructor error", err)
	}
	if !strings.Contains(err.Error(), "generic-extractor") {
		t.Fatalf("Build() error = %q, want key context", err.Error())
	}
}

func TestExtractorRegistryBuildRejectsNilExtractor(t *testing.T) {
	registry := NewExtractorRegistry()
	if err := registry.Register("generic-extractor", func() (contracts.Extractor, error) {
		return nil, nil
	}); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	_, err := registry.Build("generic-extractor")

	if err == nil {
		t.Fatal("Build() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "returned nil") {
		t.Fatalf("Build() error = %q, want nil extractor error", err.Error())
	}
}

func TestExtractorRegistryBuildRejectsExtractorKeyMismatch(t *testing.T) {
	registry := NewExtractorRegistry()
	if err := registry.Register("generic-extractor", fakeExtractorConstructor("other-extractor")); err != nil {
		t.Fatalf("Register() error = %v, want nil", err)
	}

	_, err := registry.Build("generic-extractor")

	if err == nil {
		t.Fatal("Build() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "returned key") {
		t.Fatalf("Build() error = %q, want key mismatch error", err.Error())
	}
}

func TestExtractorRegistryRegisteredKeysReturnsSortedCopy(t *testing.T) {
	registry := NewExtractorRegistry()
	for _, key := range []string{"zeta", "alpha", "middle"} {
		if err := registry.Register(key, fakeExtractorConstructor(key)); err != nil {
			t.Fatalf("Register(%q) error = %v, want nil", key, err)
		}
	}

	keys := registry.RegisteredKeys()

	want := []string{"alpha", "middle", "zeta"}
	if !reflect.DeepEqual(keys, want) {
		t.Fatalf("RegisteredKeys() = %#v, want %#v", keys, want)
	}

	keys[0] = "changed"
	if got := registry.RegisteredKeys(); !reflect.DeepEqual(got, want) {
		t.Fatalf("RegisteredKeys() after caller mutation = %#v, want %#v", got, want)
	}
}

func TestExtractorRegistryNilRegistryBehavior(t *testing.T) {
	var registry *ExtractorRegistry

	if err := registry.Register("generic-extractor", fakeExtractorConstructor("generic-extractor")); err == nil {
		t.Fatal("Register() error = nil, want error")
	}
	if _, err := registry.Build("generic-extractor"); err == nil {
		t.Fatal("Build() error = nil, want error")
	}
	if _, ok := registry.Spec("generic-extractor"); ok {
		t.Fatal("Spec() ok = true, want false")
	}
	if keys := registry.RegisteredKeys(); keys != nil {
		t.Fatalf("RegisteredKeys() = %#v, want nil", keys)
	}
}

func TestExtractorRegistryBuildRejectsEmptyKey(t *testing.T) {
	registry := NewExtractorRegistry()

	_, err := registry.Build(" \n")

	if err == nil {
		t.Fatal("Build() error = nil, want error")
	}
	if !strings.Contains(err.Error(), "key must not be empty") {
		t.Fatalf("Build() error = %q, want empty key error", err.Error())
	}
}

type registryFakeExtractor struct {
	key string
}

func fakeExtractorConstructor(key string) ExtractorConstructor {
	return func() (contracts.Extractor, error) {
		return registryFakeExtractor{key: key}, nil
	}
}

func (extractor registryFakeExtractor) Key() string {
	return extractor.key
}

func (extractor registryFakeExtractor) ReferenceSlots() []contracts.ReferenceSlot {
	return nil
}

func (extractor registryFakeExtractor) Extract(ctx context.Context, req contracts.ExtractionRequest) (contracts.ExtractionResult, error) {
	return contracts.ExtractionResult{}, nil
}