test: windows

Author: TristanSpeakEasy

internal/cache/example_test.go renamed to cache/example_test.go

@@ -3,7 +3,7 @@ package cache_test
 import (
 	"fmt"
 
-	"github.com/speakeasy-api/openapi/internal/cache"
+	"github.com/speakeasy-api/openapi/cache"
 	"github.com/speakeasy-api/openapi/internal/utils"
 	"github.com/speakeasy-api/openapi/references"
 )

internal/cache/manager.go renamed to cache/manager.go

@@ -87,8 +87,9 @@ func TestClearFieldCache_Success(t *testing.T) {
 	assert.Equal(t, int64(0), stats.FieldCacheSize, "Field cache should be empty")
 }
 
+// nolint:paralleltest
 func TestGetAllCacheStats_Success(t *testing.T) {
-	t.Parallel()
+	// Don't run in parallel since we're testing global cache state
 
 	// Clear all caches first
 	ClearAllCaches()

internal/cache/manager_test.go renamed to cache/manager_test.go

@@ -183,19 +183,98 @@ func (rc *ReferenceClassification) joinURL(relative string) (string, error) {
 	return resolvedURL.String(), nil
 }
 
-// joinFilePath joins this file path reference with a relative path using Go's filepath package
+// joinFilePath joins this file path reference with a relative path using cross-platform path handling
 func (rc *ReferenceClassification) joinFilePath(relative string) (string, error) {
 	// If relative path is absolute, return it as-is
 	// Check for both OS-specific absolute paths and Unix-style absolute paths (for cross-platform compatibility)
-	if filepath.IsAbs(relative) || strings.HasPrefix(relative, "/") {
+	if filepath.IsAbs(relative) || strings.HasPrefix(relative, "/") || rc.isWindowsAbsolutePath(relative) {
 		return relative, nil
 	}
 
-	// For all relative paths, join them with the base directory
-	// Use filepath.Join for proper path handling, then convert to forward slashes for OpenAPI/JSON Schema compatibility
-	joined := filepath.Join(filepath.Dir(rc.Original), relative)
-	// Convert backslashes to forward slashes for cross-platform compatibility in OpenAPI contexts
-	return strings.ReplaceAll(joined, "\\", "/"), nil
+	// Determine the path separator style from the original path
+	isWindowsStyle := strings.Contains(rc.Original, "\\") && !strings.Contains(rc.Original, "/")
+
+	// Get the directory part of the original path using cross-platform logic
+	var baseDir string
+	if isWindowsStyle {
+		// Handle Windows-style paths manually for cross-platform compatibility
+		baseDir = rc.getWindowsDir()
+	} else {
+		// Use standard filepath.Dir for Unix-style paths
+		baseDir = filepath.Dir(rc.Original)
+	}
+
+	// Join the paths
+	var joined string
+	if isWindowsStyle {
+		// Manual Windows-style path joining
+		joined = rc.joinWindowsPaths(baseDir, relative)
+	} else {
+		// Use standard filepath.Join for Unix-style paths
+		joined = filepath.Join(baseDir, relative)
+		// Convert to forward slashes for OpenAPI/JSON Schema compatibility
+		joined = strings.ReplaceAll(joined, "\\", "/")
+	}
+
+	return joined, nil
+}
+
+// getWindowsDir extracts the directory part from a Windows-style path
+func (rc *ReferenceClassification) getWindowsDir() string {
+	path := rc.Original
+	// Find the last backslash
+	lastSlash := strings.LastIndex(path, "\\")
+	if lastSlash == -1 {
+		return "." // No directory separator found
+	}
+	return path[:lastSlash]
+}
+
+// joinWindowsPaths joins Windows-style paths manually
+func (rc *ReferenceClassification) joinWindowsPaths(base, relative string) string {
+	// Handle relative path navigation
+	// Split by both forward and backward slashes to handle cross-platform relative paths
+	var parts []string
+	if strings.Contains(relative, "/") {
+		// Unix-style path with forward slashes
+		parts = strings.Split(relative, "/")
+	} else {
+		// Windows-style path with backslashes
+		parts = strings.Split(relative, "\\")
+	}
+
+	baseParts := strings.Split(base, "\\")
+
+	for _, part := range parts {
+		switch part {
+		case ".":
+			// Current directory, do nothing
+			continue
+		case "..":
+			// Parent directory, remove last part from base
+			if len(baseParts) > 1 {
+				baseParts = baseParts[:len(baseParts)-1]
+			}
+		default:
+			// Regular path component
+			baseParts = append(baseParts, part)
+		}
+	}
+
+	return strings.Join(baseParts, "\\")
+}
+
+// isWindowsAbsolutePath checks if a path is a Windows absolute path (e.g., C:\path or \\server\share)
+func (rc *ReferenceClassification) isWindowsAbsolutePath(path string) bool {
+	// Check for drive letter paths (C:\, D:\, etc.)
+	if len(path) >= 3 && path[1] == ':' && (path[2] == '\\' || path[2] == '/') {
+		return true
+	}
+	// Check for UNC paths (\\server\share)
+	if strings.HasPrefix(path, "\\\\") {
+		return true
+	}
+	return false
 }
 
 // JoinReference is a convenience function that classifies the base reference and joins it with a relative reference.

internal/utils/references.go

@@ -0,0 +1,172 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestWindowsStylePathJoining tests Windows-style path joining logic
+// This test simulates the Windows path behavior to verify our fixes
+func TestWindowsStylePathJoining_Success(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		base     string
+		relative string
+		expected string
+	}{
+		{
+			name:     "windows path with simple relative file",
+			base:     "C:\\path\\to\\schemas\\user.json",
+			relative: "common.json",
+			expected: "C:\\path\\to\\schemas\\common.json",
+		},
+		{
+			name:     "windows path with relative directory navigation",
+			base:     "C:\\path\\to\\schemas\\user.json",
+			relative: "..\\base\\common.json",
+			expected: "C:\\path\\to\\base\\common.json",
+		},
+		{
+			name:     "windows path with dot relative path",
+			base:     "C:\\path\\to\\schemas\\user.json",
+			relative: ".\\common.json",
+			expected: "C:\\path\\to\\schemas\\common.json",
+		},
+		{
+			name:     "windows path with absolute relative path",
+			base:     "C:\\path\\to\\schemas\\user.json",
+			relative: "D:\\other\\path\\schema.json",
+			expected: "D:\\other\\path\\schema.json",
+		},
+		{
+			name:     "windows path with fragment",
+			base:     "C:\\path\\to\\schema.json",
+			relative: "#/definitions/User",
+			expected: "C:\\path\\to\\schema.json#/definitions/User",
+		},
+		{
+			name:     "windows path with unix-style dot relative path",
+			base:     "C:\\path\\to\\schemas\\user.json",
+			relative: "./common.json",
+			expected: "C:\\path\\to\\schemas\\common.json",
+		},
+		{
+			name:     "windows path with unix-style relative directory navigation",
+			base:     "C:\\path\\to\\schemas\\user.json",
+			relative: "../base/common.json",
+			expected: "C:\\path\\to\\base\\common.json",
+		},
+		{
+			name:     "windows path with unix-style complex relative path",
+			base:     "D:\\a\\openapi\\openapi\\jsonschema\\oas3\\testdata\\resolve_test_main.yaml",
+			relative: "./resolve_test_external.yaml",
+			expected: "D:\\a\\openapi\\openapi\\jsonschema\\oas3\\testdata\\resolve_test_external.yaml",
+		},
+		{
+			name:     "windows UNC path joining",
+			base:     "\\\\server\\share\\path\\base.json",
+			relative: "schema.json",
+			expected: "\\\\server\\share\\path\\schema.json",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			classification, err := ClassifyReference(tt.base)
+			require.NoError(t, err)
+			require.NotNil(t, classification)
+			require.True(t, classification.IsFile, "Base should be classified as file path")
+
+			result, err := classification.JoinWith(tt.relative)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+// TestWindowsStylePathJoinReference_Success tests the convenience function
+func TestWindowsStylePathJoinReference_Success(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		base     string
+		relative string
+		expected string
+	}{
+		{
+			name:     "windows path joining via convenience function",
+			base:     "C:\\path\\to\\base.json",
+			relative: "schema.json",
+			expected: "C:\\path\\to\\schema.json",
+		},
+		{
+			name:     "windows UNC path joining",
+			base:     "\\\\server\\share\\path\\base.json",
+			relative: "schema.json",
+			expected: "\\\\server\\share\\path\\schema.json",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			result, err := JoinReference(tt.base, tt.relative)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+// TestUnixStylePathJoining_Success tests that Unix-style paths still work correctly
+func TestUnixStylePathJoining_Success(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		base     string
+		relative string
+		expected string
+	}{
+		{
+			name:     "unix path with simple relative file",
+			base:     "/path/to/schemas/user.json",
+			relative: "common.json",
+			expected: "/path/to/schemas/common.json",
+		},
+		{
+			name:     "unix path with relative directory navigation",
+			base:     "/path/to/schemas/user.json",
+			relative: "../base/common.json",
+			expected: "/path/to/base/common.json",
+		},
+		{
+			name:     "unix path with dot relative path",
+			base:     "/path/to/schemas/user.json",
+			relative: "./common.json",
+			expected: "/path/to/schemas/common.json",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			classification, err := ClassifyReference(tt.base)
+			require.NoError(t, err)
+			require.NotNil(t, classification)
+			require.True(t, classification.IsFile, "Base should be classified as file path")
+
+			result, err := classification.JoinWith(tt.relative)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}

internal/utils/references_path_test.go

@@ -129,8 +129,10 @@ func TestURLCache_Clear(t *testing.T) {
 	assert.Equal(t, int64(0), sizeAfter)
 }
 
+// nolint:paralleltest
 func TestParseURLCached_Global(t *testing.T) {
-	t.Parallel()
+	// Don't run in parallel since we're testing global cache state
+
 	// Clear global cache before test
 	ClearGlobalURLCache()
 

internal/utils/url_cache_test.go

@@ -176,8 +176,8 @@ func TestRefCache_Clear(t *testing.T) {
 	assert.Equal(t, int64(0), stats.Size)
 }
 
+//nolint:paralleltest // This test uses global cache and cannot be parallel
 func TestResolveAbsoluteReferenceCached_Global(t *testing.T) {
-	t.Parallel()
 	// Clear global cache before test
 	ClearGlobalRefCache()
 
@@ -203,8 +203,8 @@ func TestResolveAbsoluteReferenceCached_Global(t *testing.T) {
 	ClearGlobalRefCache()
 }
 
+//nolint:paralleltest // This test uses global cache and cannot be parallel
 func TestResolveAbsoluteReference_UsesCache(t *testing.T) {
-	t.Parallel()
 	// Clear global cache before test
 	ClearGlobalRefCache()