@shortlink-org/portolan 0.1.0

package/plugins/extract-csr/extract.go

@@ -0,0 +1,338 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/shortlink-org/portolan/catalog"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+// LockName is what fetch-csr writes beside each vendored schema. Finding one
+// is what makes a directory a subject rather than a directory that happens to
+// hold a .avsc.
+const LockName = "csr.lock.json"
+
+func extract(in plugin.Input, opts Options) (plugin.Response, error) {
+	b := &plugin.Builder{}
+	root := in.Root
+
+	if opts.Context == "" {
+		opts.Context = filepath.Base(root)
+	}
+	if opts.Service == "" {
+		opts.Service = filepath.Base(root)
+	}
+	service := opts.Context + "." + opts.Service
+	strategy := strategyOf(opts.Strategy)
+
+	locks, err := find(root, opts.Paths)
+	if err != nil {
+		return plugin.Response{}, err
+	}
+	if len(locks) == 0 {
+		b.Warn(service, "no "+LockName+" under "+root+"; nothing was fetched from a schema registry, or it was fetched somewhere this step is not looking")
+	}
+
+	defs := map[string]catalog.TypeDef{}
+	channels := newChannels()
+
+	for _, at := range locks {
+		if err := readSubject(b, at, root, service, strategy, opts, defs, channels); err != nil {
+			return plugin.Response{}, err
+		}
+	}
+
+	// A field pointing at a shape nobody vendored would fail the catalog's own
+	// validation, and the reference is a real fact worth keeping as a label
+	// even when the shape behind it is not in this estate. So the label stays
+	// and the ref goes.
+	drop(defs, b, service)
+
+	fragment := catalog.Catalog{
+		GeneratedAt: in.GeneratedAt,
+		Commit:      in.Commit,
+		Contexts: []catalog.BoundedContext{{
+			ID:   opts.Context,
+			Slug: opts.Context,
+			// Named by whichever source knows the name, the way the AsyncAPI
+			// and OpenAPI fragments leave it: a registry describes what a
+			// service puts on a topic, not what the service is called.
+			Services: []catalog.Service{{
+				ID:         service,
+				Slug:       opts.Service,
+				Provides:   []catalog.RpcService{},
+				Consumes:   []catalog.RpcCall{},
+				Aggregates: []catalog.Aggregate{},
+				Channels:   channels.all(),
+			}},
+		}},
+		Defs:  defs,
+		Flows: []catalog.Flow{},
+		Adrs:  []catalog.Adr{},
+	}
+
+	encoded, err := json.MarshalIndent(fragment, "", "  ")
+	if err != nil {
+		return plugin.Response{}, err
+	}
+
+	b.File(firstNonEmpty(opts.Out, "schemas.json"), string(encoded)+"\n")
+
+	return b.Response(), nil
+}
+
+// readSubject reads one vendored subject: its lock, its schema, and the two
+// facts they add up to.
+func readSubject(
+	b *plugin.Builder,
+	at, root, service, strategy string,
+	opts Options,
+	defs map[string]catalog.TypeDef,
+	channels *channelSet,
+) error {
+	dir := filepath.Dir(at)
+	where := filepath.ToSlash(at)
+
+	raw, err := os.ReadFile(at)
+	if err != nil {
+		return err
+	}
+
+	var lock Lock
+	if err := json.Unmarshal(raw, &lock); err != nil {
+		return fmt.Errorf("%s: %w", where, err)
+	}
+	if len(lock.Subjects) != 1 {
+		return fmt.Errorf("%s names %d subjects; expected exactly one", where, len(lock.Subjects))
+	}
+
+	entry := lock.Subjects[0]
+	if len(entry.Files) == 0 {
+		b.Warn(entry.Subject, where+" names no schema file")
+
+		return nil
+	}
+
+	schemaAt := filepath.Join(dir, filepath.FromSlash(entry.Files[0].Path))
+	schema, err := os.ReadFile(schemaAt)
+	if err != nil {
+		return fmt.Errorf("%s: %w", where, err)
+	}
+	source := filepath.ToSlash(schemaAt)
+
+	declared, shapes, err := shapesOf(entry, schema, b, source)
+	if err != nil {
+		return fmt.Errorf("%s: %w", source, err)
+	}
+	for name, def := range shapes {
+		// Two subjects vendoring one shared record is the ordinary case - it
+		// is what a registry reference is for - and the two copies are the
+		// same bytes, so the first one wins and the second is not a conflict.
+		if _, held := defs[name]; !held {
+			defs[name] = def
+		}
+	}
+
+	registered := resolve(entry.Subject, declared, strategy)
+	if registered.Topic == "" {
+		// RecordNameStrategy says nothing about topics on purpose, so this is
+		// not a gap to report. The shape is still the fact worth having.
+		return nil
+	}
+
+	if registered.Key {
+		// A key is part of every message on the topic rather than a message on
+		// it, so its shape is kept and its name is not put on the channel.
+		return nil
+	}
+
+	channels.add(registered.Topic, catalog.ChannelMessage{
+		Name:      registered.Record,
+		Doc:       fmt.Sprintf("Registered as %s version %d.", entry.Subject, entry.Version),
+		Direction: directionFor(entry.Subject, opts),
+	}, source)
+
+	return nil
+}
+
+// shapesOf reads the schema according to its declared type.
+func shapesOf(entry LockSubject, schema []byte, b *plugin.Builder, source string) (string, map[string]catalog.TypeDef, error) {
+	switch strings.ToUpper(entry.SchemaType) {
+	case "", "AVRO":
+		return avro(schema)
+
+	case "JSON":
+		return jsonSchema(schema, entry.Subject)
+
+	case "PROTOBUF":
+		// Reading protobuf properly is extract-proto's whole job, and a
+		// second, worse parser here would be a second answer to one question.
+		b.Warn(entry.Subject, source+" is protobuf; its topic is read but its shape is not. Point extract-proto at the vendored directory for the fields.")
+
+		return "", nil, nil
+	}
+
+	return "", nil, fmt.Errorf("unknown schema type %q", entry.SchemaType)
+}
+
+// directionFor is which way a subject's channel travels. A registry records no
+// producer and no consumer, so this is told rather than read.
+func directionFor(subject string, opts Options) catalog.ChannelDirection {
+	declared, named := opts.Subjects[subject]
+	if !named {
+		declared = opts.Direction
+	}
+
+	if declared == string(catalog.ChannelReceive) {
+		return catalog.ChannelReceive
+	}
+
+	return catalog.ChannelSend
+}
+
+// channelSet collects topics as the subjects are read. Several subjects on one
+// topic - a key and a value, or two record types multiplexed onto it - are one
+// channel carrying several messages.
+type channelSet struct {
+	byTopic map[string]*catalog.Channel
+	seen    map[string]bool
+	order   []string
+}
+
+func newChannels() *channelSet {
+	return &channelSet{byTopic: map[string]*catalog.Channel{}, seen: map[string]bool{}}
+}
+
+func (c *channelSet) add(topic string, message catalog.ChannelMessage, source string) {
+	held, known := c.byTopic[topic]
+	if !known {
+		held = &catalog.Channel{
+			Address:  topic,
+			Messages: []catalog.ChannelMessage{},
+			Source:   source,
+		}
+		c.byTopic[topic] = held
+		c.order = append(c.order, topic)
+	}
+
+	key := topic + " " + string(message.Direction) + " " + message.Name
+	if c.seen[key] {
+		return
+	}
+	c.seen[key] = true
+
+	held.Messages = append(held.Messages, message)
+}
+
+// all is the channels in topic order, and their messages in name order. Sorted
+// rather than kept in the order the tree happened to be walked in, because the
+// fragment is committed and an unstable order would rewrite it every run.
+func (c *channelSet) all() []catalog.Channel {
+	sort.Strings(c.order)
+
+	out := make([]catalog.Channel, 0, len(c.order))
+	for _, topic := range c.order {
+		held := c.byTopic[topic]
+		sort.Slice(held.Messages, func(i, j int) bool {
+			if held.Messages[i].Name != held.Messages[j].Name {
+				return held.Messages[i].Name < held.Messages[j].Name
+			}
+
+			return held.Messages[i].Direction < held.Messages[j].Direction
+		})
+		out = append(out, *held)
+	}
+
+	return out
+}
+
+// drop clears a field's ref when nothing in this estate declares the shape it
+// names, which is the ordinary case for a record referenced across an estate
+// boundary. The catalog validates that every ref resolves, so leaving one
+// dangling would fail the whole run over a fact that is true.
+func drop(defs map[string]catalog.TypeDef, b *plugin.Builder, service string) {
+	var dangling []string
+
+	for name, def := range defs {
+		for i, field := range def.Fields {
+			if field.Ref == "" {
+				continue
+			}
+			if _, known := defs[field.Ref]; known {
+				continue
+			}
+			dangling = append(dangling, field.Ref)
+			def.Fields[i].Ref = ""
+		}
+		defs[name] = def
+	}
+
+	if len(dangling) == 0 {
+		return
+	}
+
+	sort.Strings(dangling)
+	b.Warn(service, "these shapes are referenced but not vendored, so they are named without a shape: "+
+		strings.Join(unique(dangling), ", "))
+}
+
+// find locates every lock under the root, or under the declared paths.
+//
+// Sorted, so the fragment comes out the same way on every filesystem: WalkDir
+// is ordered, but a manifest that names two paths is not.
+func find(root string, paths []string) ([]string, error) {
+	roots := []string{root}
+	if len(paths) > 0 {
+		roots = roots[:0]
+		for _, at := range paths {
+			roots = append(roots, filepath.Join(root, filepath.FromSlash(at)))
+		}
+	}
+
+	var found []string
+	for _, at := range roots {
+		err := filepath.WalkDir(at, func(p string, entry os.DirEntry, err error) error {
+			if err != nil {
+				// A named path that is not there is worth reporting; one
+				// inside a walk is not this plugin's to explain.
+				if p == at && os.IsNotExist(err) {
+					return fmt.Errorf("%s does not exist", filepath.ToSlash(at))
+				}
+
+				return err
+			}
+			if !entry.IsDir() && entry.Name() == LockName {
+				found = append(found, p)
+			}
+
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	sort.Strings(found)
+
+	return found, nil
+}
+
+func unique(values []string) []string {
+	out := values[:0]
+	seen := map[string]bool{}
+
+	for _, value := range values {
+		if seen[value] {
+			continue
+		}
+		seen[value] = true
+		out = append(out, value)
+	}
+
+	return out
+}

package/plugins/extract-csr/extract_test.go

@@ -0,0 +1,374 @@
+package main
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/shortlink-org/portolan/catalog"
+	"github.com/shortlink-org/portolan/plugin"
+)
+
+const estate = "testdata/estate"
+
+func fragmentFrom(t *testing.T, opts Options) (catalog.Catalog, plugin.Response) {
+	t.Helper()
+
+	resp, err := extract(plugin.Input{Root: estate, Commit: "abc123", GeneratedAt: "2026-09-05T00:00:00Z"}, opts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(resp.Files) != 1 {
+		t.Fatalf("the extractor named %d files, want 1", len(resp.Files))
+	}
+
+	var fragment catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &fragment); err != nil {
+		t.Fatal(err)
+	}
+
+	return fragment, resp
+}
+
+func defaults() Options {
+	return Options{Context: "shop", Service: "oms", Paths: []string{"vendor/schemas"}}
+}
+
+func channelsOf(t *testing.T, fragment catalog.Catalog) []catalog.Channel {
+	t.Helper()
+
+	if len(fragment.Contexts) != 1 || len(fragment.Contexts[0].Services) != 1 {
+		t.Fatalf("the fragment does not describe one service: %+v", fragment.Contexts)
+	}
+
+	return fragment.Contexts[0].Services[0].Channels
+}
+
+func fieldsOf(t *testing.T, fragment catalog.Catalog, name string) []catalog.Field {
+	t.Helper()
+
+	def, known := fragment.Defs[name]
+	if !known {
+		var held []string
+		for key := range fragment.Defs {
+			held = append(held, key)
+		}
+		t.Fatalf("no def named %s; the fragment holds %v", name, held)
+	}
+
+	return def.Fields
+}
+
+func fieldNamed(t *testing.T, fields []catalog.Field, name string) catalog.Field {
+	t.Helper()
+
+	for _, field := range fields {
+		if field.Name == name {
+			return field
+		}
+	}
+	t.Fatalf("no field named %s in %+v", name, fields)
+
+	return catalog.Field{}
+}
+
+func TestTopicsComeFromSubjects(t *testing.T) {
+	fragment, _ := fragmentFrom(t, defaults())
+
+	channels := channelsOf(t, fragment)
+	if len(channels) != 3 {
+		t.Fatalf("channels: %+v", channels)
+	}
+
+	// Sorted by address, so the fragment is the same on every run.
+	var addresses []string
+	for _, channel := range channels {
+		addresses = append(addresses, channel.Address)
+	}
+	if got := strings.Join(addresses, ","); got != "shop.oms.order,shop.oms.route,shop.oms.shipment" {
+		t.Errorf("addresses %q", got)
+	}
+
+	orders := channels[0]
+	// The key subject shares the topic with the value one and adds no message:
+	// a key is part of every message on the channel, not a message on it.
+	if len(orders.Messages) != 1 {
+		t.Fatalf("shop.oms.order carries %+v", orders.Messages)
+	}
+	if orders.Messages[0].Name != "shop.oms.OrderPlaced" {
+		t.Errorf("message name %q", orders.Messages[0].Name)
+	}
+	if orders.Messages[0].Direction != catalog.ChannelSend {
+		t.Errorf("direction %q, want send by default", orders.Messages[0].Direction)
+	}
+	if !strings.Contains(orders.Messages[0].Doc, "version 3") {
+		t.Errorf("the message does not say which registration it is: %q", orders.Messages[0].Doc)
+	}
+	if orders.Source != "testdata/estate/vendor/schemas/shop.oms.order-value/v3.avsc" {
+		t.Errorf("source %q", orders.Source)
+	}
+}
+
+func TestDirectionIsToldPerSubject(t *testing.T) {
+	opts := defaults()
+	opts.Direction = "send"
+	opts.Subjects = map[string]string{"shop.oms.shipment-value": "receive"}
+
+	fragment, _ := fragmentFrom(t, opts)
+
+	for _, channel := range channelsOf(t, fragment) {
+		want := catalog.ChannelSend
+		if channel.Address == "shop.oms.shipment" {
+			want = catalog.ChannelReceive
+		}
+		for _, message := range channel.Messages {
+			if message.Direction != want {
+				t.Errorf("%s carries %s %s, want %s", channel.Address, message.Name, message.Direction, want)
+			}
+		}
+	}
+}
+
+func TestAvroShapesLandInDefs(t *testing.T) {
+	fragment, _ := fragmentFrom(t, defaults())
+
+	fields := fieldsOf(t, fragment, "shop.oms.OrderPlaced")
+
+	for _, want := range []catalog.Field{
+		{Name: "order_id", Type: "string", Doc: "The order's own id."},
+		{Name: "note", Type: "string?", Doc: "What the customer wrote in the box."},
+		{Name: "labels", Type: "map<string, string>"},
+		{Name: "placed_at", Type: "timestamp-millis"},
+		{Name: "total", Type: "decimal(12,2)"},
+	} {
+		got := fieldNamed(t, fields, want.Name)
+		if got.Type != want.Type || got.Doc != want.Doc {
+			t.Errorf("%s is %+v, want type %q doc %q", want.Name, got, want.Type, want.Doc)
+		}
+	}
+
+	// A record vendored as its own subject is a shape this one points at, and
+	// the ref is what makes the two one shape rather than two.
+	buyer := fieldNamed(t, fields, "buyer")
+	if buyer.Type != "shop.oms.Party" || buyer.Ref != "shop.oms.Party" {
+		t.Errorf("buyer is %+v", buyer)
+	}
+	if got := fieldsOf(t, fragment, "shop.oms.Party"); len(got) != 2 {
+		t.Errorf("shop.oms.Party: %+v", got)
+	}
+
+	// A record inlined in a field gets its own def, under the namespace it
+	// inherits rather than none.
+	lines := fieldNamed(t, fields, "lines")
+	if lines.Type != "shop.oms.Line[]" || lines.Ref != "" {
+		t.Errorf("lines is %+v", lines)
+	}
+	if got := fieldsOf(t, fragment, "shop.oms.Line"); len(got) != 2 {
+		t.Errorf("shop.oms.Line: %+v", got)
+	}
+
+	// Field order is the order the schema lists them in - it is the producer's
+	// statement about the record, and re-sorting it would lose that.
+	var order []string
+	for _, field := range fields {
+		order = append(order, field.Name)
+	}
+	if got := strings.Join(order, ","); got != "order_id,buyer,note,lines,labels,placed_at,total" {
+		t.Errorf("field order %q", got)
+	}
+}
+
+func TestJSONSchemaShapesLandInDefs(t *testing.T) {
+	fragment, _ := fragmentFrom(t, defaults())
+
+	fields := fieldsOf(t, fragment, "shop.oms.ShipmentBooked")
+
+	// The order the document writes its properties in, which decoding into a
+	// map would have lost.
+	var order []string
+	for _, field := range fields {
+		order = append(order, field.Name)
+	}
+	if got := strings.Join(order, ","); got != "shipment_id,carrier,booked_at,weight_kg,stops,address" {
+		t.Errorf("property order %q", got)
+	}
+
+	for _, want := range []catalog.Field{
+		{Name: "shipment_id", Type: "string", Doc: "The booking's own id."},
+		{Name: "booked_at", Type: "date-time?"},
+		{Name: "weight_kg", Type: "number?"},
+		{Name: "stops", Type: "string[]?"},
+	} {
+		got := fieldNamed(t, fields, want.Name)
+		if got.Type != want.Type || got.Doc != want.Doc {
+			t.Errorf("%s is %+v, want type %q doc %q", want.Name, got, want.Type, want.Doc)
+		}
+	}
+
+	// A $ref resolves to the definition the document keeps to one side.
+	// The label stays the name the document uses; the ref carries the key the
+	// catalog files it under, which is qualified because `definitions` is
+	// local to a document and `defs` is not.
+	carrier := fieldNamed(t, fields, "carrier")
+	if carrier.Type != "Carrier" || carrier.Ref != "shop.oms.ShipmentBooked.Carrier" {
+		t.Errorf("carrier is %+v", carrier)
+	}
+	if got := fieldsOf(t, fragment, "shop.oms.ShipmentBooked.Carrier"); len(got) != 2 {
+		t.Errorf("Carrier: %+v", got)
+	}
+
+	// An object inlined with no title is still a shape; it is named for where
+	// it sits.
+	address := fieldNamed(t, fields, "address")
+	if address.Ref != "shop.oms.ShipmentBooked.address" {
+		t.Errorf("address is %+v", address)
+	}
+	inner := fieldsOf(t, fragment, "shop.oms.ShipmentBooked.address")
+	if fieldNamed(t, inner, "line1").Type != "string" {
+		t.Errorf("line1 is %+v", fieldNamed(t, inner, "line1"))
+	}
+	if fieldNamed(t, inner, "postcode").Type != "string?" {
+		t.Errorf("postcode is not optional: %+v", fieldNamed(t, inner, "postcode"))
+	}
+}
+
+func TestProtobufIsNamedButNotShaped(t *testing.T) {
+	fragment, resp := fragmentFrom(t, defaults())
+
+	// The topic is still a fact, and it is the one thing extract-proto cannot
+	// say: a .proto file does not know which topic it was registered against.
+	var found bool
+	for _, channel := range channelsOf(t, fragment) {
+		if channel.Address == "shop.oms.route" {
+			found = true
+			if len(channel.Messages) != 1 || channel.Messages[0].Name != "shop.oms.route-value" {
+				t.Errorf("shop.oms.route carries %+v", channel.Messages)
+			}
+		}
+	}
+	if !found {
+		t.Error("the protobuf subject named no topic")
+	}
+
+	var said bool
+	for _, warning := range resp.Warnings() {
+		if strings.Contains(warning.Message, "extract-proto") {
+			said = true
+		}
+	}
+	if !said {
+		t.Errorf("nothing pointed at extract-proto for the shape: %+v", resp.Warnings())
+	}
+}
+
+func TestRecordStrategyNamesNoTopic(t *testing.T) {
+	opts := defaults()
+	opts.Strategy = StrategyRecord
+
+	fragment, _ := fragmentFrom(t, opts)
+
+	// RecordNameStrategy says nothing about topics on purpose - a record under
+	// it is reusable across many - so a fragment with no channels is the right
+	// answer rather than a gap.
+	if channels := channelsOf(t, fragment); len(channels) != 0 {
+		t.Errorf("channels: %+v", channels)
+	}
+	// The shapes are still there, which is the half the strategy does state.
+	if got := fieldsOf(t, fragment, "shop.oms.OrderPlaced"); len(got) != 7 {
+		t.Errorf("shop.oms.OrderPlaced: %+v", got)
+	}
+}
+
+func TestTopicRecordStrategySplitsOnTheSchemasOwnName(t *testing.T) {
+	// "shop.oms.order-value" under this strategy is topic "shop.oms.order"
+	// and record "value" if you split at the hyphen, and neither half is
+	// reliable - so the schema's own full name is what the suffix is matched
+	// against.
+	for _, c := range []struct {
+		subject, declared, topic, record string
+	}{
+		{"orders-com.acme.Order", "com.acme.Order", "orders", "com.acme.Order"},
+		{"shop.oms.order-shop.oms.OrderPlaced", "shop.oms.OrderPlaced", "shop.oms.order", "shop.oms.OrderPlaced"},
+		{"orders-Order", "", "orders", "Order"},
+	} {
+		got := resolve(c.subject, c.declared, StrategyTopicRecord)
+		if got.Topic != c.topic || got.Record != c.record {
+			t.Errorf("%q -> %+v, want topic %q record %q", c.subject, got, c.topic, c.record)
+		}
+	}
+}
+
+func TestTopicStrategyReadsTheSuffix(t *testing.T) {
+	for _, c := range []struct {
+		subject, declared, topic, record string
+		key                              bool
+	}{
+		{"shop.oms.order-value", "shop.oms.OrderPlaced", "shop.oms.order", "shop.oms.OrderPlaced", false},
+		{"shop.oms.order-key", "shop.oms.OrderKey", "shop.oms.order", "shop.oms.OrderKey", true},
+		// Registered some other way: it names a shape but cannot name a topic.
+		{"loose", "shop.oms.Loose", "", "shop.oms.Loose", false},
+	} {
+		got := resolve(c.subject, c.declared, StrategyTopic)
+		if got.Topic != c.topic || got.Record != c.record || got.Key != c.key {
+			t.Errorf("%q -> %+v", c.subject, got)
+		}
+	}
+}
+
+func TestAMissingPathIsReported(t *testing.T) {
+	opts := defaults()
+	opts.Paths = []string{"vendor/nothing"}
+
+	_, err := extract(plugin.Input{Root: estate}, opts)
+	if err == nil || !strings.Contains(err.Error(), "does not exist") {
+		t.Errorf("a path that is not there was walked silently: %v", err)
+	}
+}
+
+func TestAReferenceNobodyVendoredKeepsItsNameAndLosesItsRef(t *testing.T) {
+	// The catalog validates that every field ref resolves, so a ref pointing
+	// at a shape this estate does not hold would fail the whole run over a
+	// fact that is true: the schema really does reference it, and the shape
+	// really does live somewhere else.
+	resp, err := extract(
+		plugin.Input{Root: "testdata/dangling"},
+		Options{Context: "shop", Service: "oms", Paths: []string{"vendor/schemas"}},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var fragment catalog.Catalog
+	if err := json.Unmarshal([]byte(resp.Files[0].Contents), &fragment); err != nil {
+		t.Fatal(err)
+	}
+
+	actor := fieldNamed(t, fieldsOf(t, fragment, "shop.oms.AuditWritten"), "actor")
+	if actor.Type != "shop.identity.Actor" {
+		t.Errorf("the reference lost its name: %+v", actor)
+	}
+	if actor.Ref != "" {
+		t.Errorf("a ref was left pointing at a shape nothing declares: %+v", actor)
+	}
+
+	for _, def := range fragment.Defs {
+		for _, field := range def.Fields {
+			if field.Ref == "" {
+				continue
+			}
+			if _, known := fragment.Defs[field.Ref]; !known {
+				t.Errorf("%s refs %s, which the fragment does not declare", field.Name, field.Ref)
+			}
+		}
+	}
+
+	var said bool
+	for _, warning := range resp.Warnings() {
+		if strings.Contains(warning.Message, "shop.identity.Actor") {
+			said = true
+		}
+	}
+	if !said {
+		t.Errorf("the unvendored reference was dropped silently: %+v", resp.Warnings())
+	}
+}