Add inline/bundling tests for additional operations

Author: BlakeTheAwesome

openapi/bundle_test.go

@@ -172,3 +172,77 @@ func TestBundle_SiblingDirectories_Success(t *testing.T) {
 	// Compare the actual output with expected output
 	assert.Equal(t, string(expectedBytes), string(actualYAML), "Bundled document should match expected output")
 }
+
+func TestBundle_AdditionalOperations_Success(t *testing.T) {
+	t.Parallel()
+
+	ctx := t.Context()
+
+	// Load the input document with additionalOperations
+	inputFile, err := os.Open("testdata/inline/additionaloperations_input.yaml")
+	require.NoError(t, err)
+	defer inputFile.Close()
+
+	inputDoc, validationErrs, err := openapi.Unmarshal(ctx, inputFile)
+	require.NoError(t, err)
+	require.Empty(t, validationErrs, "Input document should be valid")
+
+	// Configure bundling options
+	opts := openapi.BundleOptions{
+		ResolveOptions: openapi.ResolveOptions{
+			RootDocument:   inputDoc,
+			TargetLocation: "testdata/inline/additionaloperations_input.yaml",
+		},
+		NamingStrategy: openapi.BundleNamingFilePath,
+	}
+
+	// Bundle all external references
+	err = openapi.Bundle(ctx, inputDoc, opts)
+	require.NoError(t, err)
+
+	// Marshal the bundled document to YAML
+	var buf bytes.Buffer
+	err = openapi.Marshal(ctx, inputDoc, &buf)
+	require.NoError(t, err)
+	actualYAML := buf.String()
+
+	// Verify that external references in additionalOperations were bundled
+	assert.Contains(t, actualYAML, "components:", "Components section should be created")
+	assert.Contains(t, actualYAML, "additionalOperations:", "additionalOperations should be preserved")
+
+	// Verify external schemas were bundled into components
+	assert.Contains(t, actualYAML, "ResourceMetadata:", "External ResourceMetadata schema should be bundled")
+	assert.Contains(t, actualYAML, "SyncConfig:", "External SyncConfig schema should be bundled")
+	assert.Contains(t, actualYAML, "BatchConfig:", "External BatchConfig schema should be bundled")
+
+	// Verify external parameters were bundled
+	assert.Contains(t, actualYAML, "DestinationParam:", "External DestinationParam should be bundled")
+	assert.Contains(t, actualYAML, "ConfirmationParam:", "External ConfirmationParam should be bundled")
+
+	// Verify external responses were bundled
+	assert.Contains(t, actualYAML, "CopyResponse:", "External CopyResponse should be bundled")
+	assert.Contains(t, actualYAML, "ValidationErrorResponse:", "External ValidationErrorResponse should be bundled")
+
+	// Verify external request bodies were bundled
+	assert.Contains(t, actualYAML, "CopyRequest:", "External CopyRequest should be bundled")
+
+	// Verify references in additionalOperations now point to components
+	assert.Contains(t, actualYAML, "$ref: \"#/components/parameters/DestinationParam\"", "COPY operation should reference bundled parameter")
+	assert.Contains(t, actualYAML, "$ref: \"#/components/requestBodies/CopyRequest\"", "COPY operation should reference bundled request body")
+	assert.Contains(t, actualYAML, "$ref: \"#/components/responses/CopyResponse\"", "COPY operation should reference bundled response")
+
+	// Verify references in PURGE operation
+	assert.Contains(t, actualYAML, "$ref: \"#/components/parameters/ConfirmationParam\"", "PURGE operation should reference bundled parameter")
+	assert.Contains(t, actualYAML, "$ref: \"#/components/responses/ValidationErrorResponse\"", "PURGE operation should reference bundled response")
+
+	// Verify references in SYNC operation
+	assert.Contains(t, actualYAML, "$ref: \"#/components/schemas/SyncConfig\"", "SYNC operation should reference bundled schema")
+	assert.Contains(t, actualYAML, "$ref: \"#/components/schemas/SyncResult\"", "SYNC operation should reference bundled schema")
+
+	// Verify references in BATCH operation
+	assert.Contains(t, actualYAML, "$ref: \"#/components/schemas/BatchConfig\"", "BATCH operation should reference bundled schema")
+	assert.Contains(t, actualYAML, "$ref: \"#/components/schemas/BatchResult\"", "BATCH operation should reference bundled schema")
+
+	// Verify no external file references remain in additionalOperations
+	assert.NotContains(t, actualYAML, "external_custom_operations.yaml#/", "No external file references should remain")
+}

openapi/inline_test.go

@@ -3,6 +3,7 @@ package openapi_test
 import (
 	"bytes"
 	"os"
+	"strings"
 	"testing"
 
 	"github.com/speakeasy-api/openapi/openapi"
@@ -120,3 +121,123 @@ func TestInline_SiblingDirectories_Success(t *testing.T) {
 	// Compare the actual output with expected output
 	assert.Equal(t, string(expectedBytes), string(actualYAML), "Inlined document should match expected output")
 }
+
+func TestInline_AdditionalOperations_Success(t *testing.T) {
+	t.Parallel()
+
+	ctx := t.Context()
+
+	// Load the input document with additionalOperations
+	inputFile, err := os.Open("testdata/inline/additionaloperations_input.yaml")
+	require.NoError(t, err)
+	defer inputFile.Close()
+
+	inputDoc, validationErrs, err := openapi.Unmarshal(ctx, inputFile)
+	require.NoError(t, err)
+	require.Empty(t, validationErrs, "Input document should be valid")
+
+	// Configure inlining options
+	opts := openapi.InlineOptions{
+		ResolveOptions: openapi.ResolveOptions{
+			RootDocument:   inputDoc,
+			TargetLocation: "testdata/inline/additionaloperations_input.yaml",
+		},
+		RemoveUnusedComponents: true,
+	}
+
+	// Inline all references
+	err = openapi.Inline(ctx, inputDoc, opts)
+	require.NoError(t, err)
+
+	// Marshal the inlined document to YAML
+	var buf bytes.Buffer
+	err = openapi.Marshal(ctx, inputDoc, &buf)
+	require.NoError(t, err)
+	actualYAML := buf.String()
+
+	// Verify that additionalOperations are preserved
+	assert.Contains(t, actualYAML, "additionalOperations:", "additionalOperations should be preserved")
+
+	// Verify that external references in additionalOperations were inlined
+	assert.NotContains(t, actualYAML, "$ref:", "No references should remain after inlining")
+	assert.NotContains(t, actualYAML, "external_custom_operations.yaml", "No external file references should remain")
+
+	// Verify that the COPY operation has inlined content
+	assert.Contains(t, actualYAML, "COPY:", "COPY operation should be present")
+	assert.Contains(t, actualYAML, "operationId: copyResource", "COPY operation content should be inlined")
+
+	// Verify that external parameter was inlined in COPY operation
+	copyOperationSection := extractAdditionalOperationSection(actualYAML, "COPY")
+	assert.Contains(t, copyOperationSection, "name: destination", "DestinationParam should be inlined")
+	assert.Contains(t, copyOperationSection, "in: header", "DestinationParam should be inlined")
+
+	// Verify that external request body was inlined in COPY operation
+	assert.Contains(t, copyOperationSection, "source_path:", "CopyRequest schema should be inlined")
+	assert.Contains(t, copyOperationSection, "destination_path:", "CopyRequest schema should be inlined")
+
+	// Verify that the PURGE operation has inlined content
+	assert.Contains(t, actualYAML, "PURGE:", "PURGE operation should be present")
+	assert.Contains(t, actualYAML, "operationId: purgeResource", "PURGE operation content should be inlined")
+
+	// Verify that external parameter was inlined in PURGE operation
+	purgeOperationSection := extractAdditionalOperationSection(actualYAML, "PURGE")
+	assert.Contains(t, purgeOperationSection, "name: X-Confirm-Purge", "ConfirmationParam should be inlined")
+	assert.Contains(t, purgeOperationSection, "pattern: ^CONFIRM-[A-Z0-9]{8}$", "ConfirmationParam schema should be inlined")
+
+	// Verify that the SYNC operation has inlined content
+	assert.Contains(t, actualYAML, "SYNC:", "SYNC operation should be present")
+	assert.Contains(t, actualYAML, "operationId: syncResource", "SYNC operation content should be inlined")
+
+	// Verify that external schemas were inlined in SYNC operation
+	syncOperationSection := extractAdditionalOperationSection(actualYAML, "SYNC")
+	assert.Contains(t, syncOperationSection, "source:", "SyncConfig schema should be inlined")
+	assert.Contains(t, syncOperationSection, "destination:", "SyncConfig schema should be inlined")
+	assert.Contains(t, syncOperationSection, "sync_id:", "SyncResult schema should be inlined")
+	assert.Contains(t, syncOperationSection, "files_synced:", "SyncResult schema should be inlined")
+
+	// Verify that the BATCH operation has inlined content
+	assert.Contains(t, actualYAML, "BATCH:", "BATCH operation should be present")
+	assert.Contains(t, actualYAML, "operationId: batchProcess", "BATCH operation content should be inlined")
+
+	// Verify that nested external schemas were properly inlined
+	batchOperationSection := extractAdditionalOperationSection(actualYAML, "BATCH")
+	assert.Contains(t, batchOperationSection, "parallel_execution:", "BatchConfig schema should be inlined")
+	assert.Contains(t, batchOperationSection, "batch_id:", "BatchResult schema should be inlined")
+	assert.Contains(t, batchOperationSection, "max_attempts:", "RetryPolicy schema should be inlined")
+
+	// Verify components section was removed (since RemoveUnusedComponents is true)
+	// Note: Some components might remain if they're still referenced from the main document
+	if !assert.NotContains(t, actualYAML, "components:", "Components section should be removed after inlining") {
+		// If components section exists, ensure it doesn't contain the external schemas
+		assert.NotContains(t, actualYAML, "ResourceMetadata:", "External ResourceMetadata should not be in components after inlining")
+		assert.NotContains(t, actualYAML, "SyncConfig:", "External SyncConfig should not be in components after inlining")
+	}
+}
+
+// Helper function to extract a specific additionalOperation section from YAML
+func extractAdditionalOperationSection(yamlContent, operationName string) string {
+	lines := strings.Split(yamlContent, "\n")
+	var sectionLines []string
+	inTargetOperation := false
+	indentLevel := -1
+
+	for _, line := range lines {
+		if strings.Contains(line, operationName+":") && strings.Contains(line, "additionalOperations") == false {
+			inTargetOperation = true
+			indentLevel = len(line) - len(strings.TrimLeft(line, " "))
+			sectionLines = append(sectionLines, line)
+			continue
+		}
+
+		if inTargetOperation {
+			currentIndent := len(line) - len(strings.TrimLeft(line, " "))
+			// If we hit a line at the same or lower indent level, we've left the operation
+			if strings.TrimSpace(line) != "" && currentIndent <= indentLevel {
+				break
+			}
+			sectionLines = append(sectionLines, line)
+		}
+	}
+
+	return strings.Join(sectionLines, "\n")
+}