test(bundler): cover absolute inline ref rewrite

Author: daveshanley

bundler/bundler.go

@@ -577,26 +577,7 @@ func composeWithOrigins(model *v3.Document, compositionConfig *BundleComposition
 		rewriteAllRefs(idx, processedNodes, rolodex)
 	}
 
-	// Fix any remaining absolute path references that match inlined content
-	// Also check the root index
-	allIndexes := append(allLoadedIndexes, rolodex.GetRootIndex())
-	for _, idx := range allIndexes {
-		for _, seqRef := range idx.GetRawReferencesSequenced() {
-			if isRef, _, refVal := utils.IsNodeRefValue(seqRef.Node); isRef {
-				// Check if this is an absolute path that should have been inlined
-				if filepath.IsAbs(refVal) {
-					// Try to find matching inlined content
-					for inlinedPath, inlinedNode := range inlinedPaths {
-						// Match if paths are the same or if they refer to the same file
-						if refVal == inlinedPath {
-							seqRef.Node.Content = inlinedNode.Content
-							break
-						}
-					}
-				}
-			}
-		}
-	}
+	rewriteInlinedAbsoluteRefs(rolodex, allLoadedIndexes, inlinedPaths)
 
 	b, err := renderBundledModel(model, rootIndex)
 	errs = append(errs, err)
@@ -707,33 +688,48 @@ func compose(model *v3.Document, compositionConfig *BundleCompositionConfig) ([]
 		rewriteAllRefs(idx, processedNodes, rolodex)
 	}
 
-	// Fix any remaining absolute path references that match inlined content
-	// Also check the root index
-	allIndexes := append(allLoadedIndexes, rolodex.GetRootIndex())
-	for _, idx := range allIndexes {
-		for _, seqRef := range idx.GetRawReferencesSequenced() {
-			if isRef, _, refVal := utils.IsNodeRefValue(seqRef.Node); isRef {
-				// Check if this is an absolute path that should have been inlined
-				if filepath.IsAbs(refVal) {
-					// Try to find matching inlined content
-					for inlinedPath, inlinedNode := range inlinedPaths {
-						// Match if paths are the same or if they refer to the same file
-						if refVal == inlinedPath {
-							seqRef.Node.Content = inlinedNode.Content
-							break
-						}
-					}
-				}
-			}
-		}
-	}
+	rewriteInlinedAbsoluteRefs(rolodex, allLoadedIndexes, inlinedPaths)
 
 	b, err := renderBundledModel(model, rootIndex)
 	errs = append(errs, err)
 
 	return b, errors.Join(errs...)
 }
 
+// rewriteInlinedAbsoluteRefs updates absolute $ref values that were resolved by
+// the inline fallback after the index's normal rewrite pass has already run.
+func rewriteInlinedAbsoluteRefs(rolodex *index.Rolodex, indexes []*index.SpecIndex, inlinedPaths map[string]*yaml.Node) {
+	if rolodex == nil || len(inlinedPaths) == 0 {
+		return
+	}
+
+	allIndexes := append([]*index.SpecIndex{}, indexes...)
+	allIndexes = append(allIndexes, rolodex.GetRootIndex())
+	seen := make(map[*index.SpecIndex]struct{}, len(allIndexes))
+
+	for _, idx := range allIndexes {
+		if idx == nil {
+			continue
+		}
+		if _, ok := seen[idx]; ok {
+			continue
+		}
+		seen[idx] = struct{}{}
+
+		for _, seqRef := range idx.GetRawReferencesSequenced() {
+			isRef, _, refVal := utils.IsNodeRefValue(seqRef.Node)
+			if !isRef || !filepath.IsAbs(refVal) {
+				continue
+			}
+			inlinedNode := inlinedPaths[refVal]
+			if inlinedNode == nil {
+				continue
+			}
+			seqRef.Node.Content = inlinedNode.Content
+		}
+	}
+}
+
 // inlineRequiredRefs inlines refs that cannot be represented as root components.
 func inlineRequiredRefs(required []*processRef, rolodex *index.Rolodex) map[string]*yaml.Node {
 	inlinedPaths := make(map[string]*yaml.Node)

bundler/composer_functions_test.go

@@ -13,6 +13,7 @@ import (
 	v3low "github.com/pb33f/libopenapi/datamodel/low/v3"
 	"github.com/pb33f/libopenapi/index"
 	"github.com/pb33f/libopenapi/orderedmap"
+	"github.com/pb33f/libopenapi/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.yaml.in/yaml/v4"
@@ -416,6 +417,65 @@ x-extension:
 	assert.NotEqual(t, replacement.Content, schemaRef.Node.Content)
 }
 
+func TestRewriteInlinedAbsoluteRefs(t *testing.T) {
+	tmpDir := t.TempDir()
+	rootPath := filepath.Join(tmpDir, "root.yaml")
+	matchedPath := filepath.Join(tmpDir, "matched.yaml")
+
+	rootSource := strings.ReplaceAll(`openapi: 3.1.0
+info:
+  title: Test
+  version: 1.0.0
+paths:
+  /matched:
+    get:
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: 'MATCHED_PATH'
+  /relative:
+    get:
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: './relative.yaml'
+`, "MATCHED_PATH", matchedPath)
+	require.NoError(t, os.WriteFile(rootPath, []byte(rootSource), 0644))
+
+	var root yaml.Node
+	require.NoError(t, yaml.Unmarshal([]byte(rootSource), &root))
+
+	cfg := index.CreateOpenAPIIndexConfig()
+	cfg.BasePath = tmpDir
+	cfg.SpecAbsolutePath = rootPath
+	idx := index.NewSpecIndexWithConfig(&root, cfg)
+
+	matchedRef := findRawRefByValue(t, idx, matchedPath)
+	relativeRef := findRawRefByValue(t, idx, "./relative.yaml")
+	replacement := testYAMLContentNode(t, "type: object\nproperties:\n  id:\n    type: string\n")
+
+	rolodex := index.NewRolodex(cfg)
+	rolodex.SetRootIndex(idx)
+	rolodex.AddIndex(idx)
+
+	rewriteInlinedAbsoluteRefs(nil, []*index.SpecIndex{idx}, map[string]*yaml.Node{matchedPath: replacement})
+	assert.NotEqual(t, replacement.Content, matchedRef.Node.Content)
+
+	rewriteInlinedAbsoluteRefs(rolodex, []*index.SpecIndex{nil, idx}, nil)
+	rewriteInlinedAbsoluteRefs(rolodex, []*index.SpecIndex{nil, idx}, map[string]*yaml.Node{matchedPath: nil})
+	assert.NotEqual(t, replacement.Content, matchedRef.Node.Content)
+
+	rewriteInlinedAbsoluteRefs(rolodex, []*index.SpecIndex{nil, idx}, map[string]*yaml.Node{matchedPath: replacement})
+	assert.Equal(t, replacement.Content, matchedRef.Node.Content)
+	assert.NotEqual(t, replacement.Content, relativeRef.Node.Content)
+}
+
 func newVersionedIndex(version float32) *index.SpecIndex {
 	var root yaml.Node
 	_ = yaml.Unmarshal([]byte(`openapi: 3.1.0
@@ -454,6 +514,21 @@ func findRawRefByComponentType(t *testing.T, idx *index.SpecIndex, componentType
 	return nil
 }
 
+func findRawRefByValue(t *testing.T, idx *index.SpecIndex, refValue string) *index.Reference {
+	t.Helper()
+
+	for _, ref := range idx.GetRawReferencesSequenced() {
+		if ref == nil || ref.Node == nil {
+			continue
+		}
+		if isRef, _, value := utils.IsNodeRefValue(ref.Node); isRef && value == refValue {
+			return ref
+		}
+	}
+	t.Fatalf("expected raw ref value %q", refValue)
+	return nil
+}
+
 func newProcessRefForTest(t *testing.T, name, source string) *processRef {
 	t.Helper()