snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

test/s3/cors/Makefile

@@ -0,0 +1,343 @@
+# CORS Integration Tests Makefile
+# This Makefile provides comprehensive targets for running CORS integration tests
+
+.PHONY: help build-weed setup-server start-server stop-server test-cors test-cors-quick test-cors-comprehensive test-all clean logs check-deps
+
+# Configuration
+WEED_BINARY := ../../../weed/weed_binary
+S3_PORT := 8333
+MASTER_PORT := 9333
+VOLUME_PORT := 8080
+FILER_PORT := 8888
+TEST_TIMEOUT := 10m
+TEST_PATTERN := TestCORS
+SERVER_DIR := test-mini-data
+S3_CONFIG := s3_test_config.json
+
+# Default target
+help:
+	@echo "CORS Integration Tests Makefile"
+	@echo ""
+	@echo "Available targets:"
+	@echo "  help                       - Show this help message"
+	@echo "  build-weed                - Build the SeaweedFS binary"
+	@echo "  check-deps                - Check dependencies and build binary if needed"
+	@echo "  start-server              - Start SeaweedFS server for testing"
+	@echo "  start-server-simple       - Start server without process cleanup (for CI)"
+	@echo "  stop-server               - Stop SeaweedFS server"
+	@echo "  test-cors                 - Run all CORS tests"
+	@echo "  test-cors-quick           - Run core CORS tests only"
+	@echo "  test-cors-simple          - Run tests without server management"
+	@echo "  test-cors-comprehensive   - Run comprehensive CORS tests"
+	@echo "  test-with-server          - Start server, run tests, stop server"
+	@echo "  logs                      - Show server logs"
+	@echo "  clean                     - Clean up test artifacts and stop server"
+	@echo "  health-check              - Check if server is accessible"
+	@echo ""
+	@echo "Configuration:"
+	@echo "  S3_PORT=${S3_PORT}"
+	@echo "  TEST_TIMEOUT=${TEST_TIMEOUT}"
+
+# Build the SeaweedFS binary
+build-weed:
+	@echo "Building SeaweedFS binary..."
+	@cd ../../../weed && go build -o weed_binary .
+	@chmod +x $(WEED_BINARY)
+	@echo "OK SeaweedFS binary built at $(WEED_BINARY)"
+
+check-deps: build-weed
+	@echo "Checking dependencies..."
+	@echo "DEBUG: Checking Go installation..."
+	@command -v go >/dev/null 2>&1 || (echo "Go is required but not installed" && exit 1)
+	@echo "DEBUG: Go version: $$(go version)"
+	@echo "DEBUG: Checking binary at $(WEED_BINARY)..."
+	@test -f $(WEED_BINARY) || (echo "SeaweedFS binary not found at $(WEED_BINARY)" && exit 1)
+	@echo "🔍 DEBUG: Binary size: $$(ls -lh $(WEED_BINARY) | awk '{print $$5}')"
+	@echo "🔍 DEBUG: Binary permissions: $$(ls -la $(WEED_BINARY) | awk '{print $$1}')"
+	@echo "🔍 DEBUG: Checking Go module dependencies..."
+	@go list -m github.com/aws/aws-sdk-go-v2 >/dev/null 2>&1 || (echo "AWS SDK Go v2 not found. Run 'go mod tidy'." && exit 1)
+	@go list -m github.com/stretchr/testify >/dev/null 2>&1 || (echo "Testify not found. Run 'go mod tidy'." && exit 1)
+	@echo "OK All dependencies are available"
+
+# Start SeaweedFS server for testing
+start-server: check-deps
+	@echo "Starting SeaweedFS server..."
+	@echo "🔍 DEBUG: Current working directory: $$(pwd)"
+	@echo "🔍 DEBUG: Checking for existing weed processes..."
+	@ps aux | grep weed | grep -v grep || echo "No existing weed processes found"
+	@echo "🔍 DEBUG: Cleaning up any existing PID file..."
+	@rm -f weed-server.pid
+	@echo "🔍 DEBUG: Checking for port conflicts..."
+	@if netstat -tlnp 2>/dev/null | grep $(S3_PORT) >/dev/null; then \
+		echo "⚠️  Port $(S3_PORT) is already in use, trying to find the process..."; \
+		netstat -tlnp 2>/dev/null | grep $(S3_PORT) || true; \
+	else \
+		echo "✅ Port $(S3_PORT) is available"; \
+	fi
+	@echo "🔍 DEBUG: Checking binary at $(WEED_BINARY)"
+	@ls -la $(WEED_BINARY) || (echo "❌ Binary not found!" && exit 1)
+	@echo "🔍 DEBUG: Checking config file at ../../../docker/compose/s3.json"
+	@ls -la ../../../docker/compose/s3.json || echo "⚠️  Config file not found, continuing without it"
+	@echo "🔍 DEBUG: Creating volume directory..."
+	@mkdir -p $(SERVER_DIR)
+	@echo "🔍 DEBUG: Launching SeaweedFS S3 server in background..."
+	@echo "🔍 DEBUG: Command: AWS_ACCESS_KEY_ID=some_access_key1 AWS_SECRET_ACCESS_KEY=some_secret_key1 $(WEED_BINARY) mini -dir=$(SERVER_DIR) -s3.port=$(S3_PORT) -s3.config=$(S3_CONFIG)"
+	@env AWS_ACCESS_KEY_ID=some_access_key1 \
+	 AWS_SECRET_ACCESS_KEY=some_secret_key1 \
+	 $(WEED_BINARY) mini \
+		-dir=$(SERVER_DIR) \
+		-s3.port=$(S3_PORT) \
+		-s3.config=$(S3_CONFIG) \
+		> weed-test.log 2>&1 & \
+		echo $$! > weed-server.pid
+	
+	@echo "Waiting for S3 server to be ready..."
+	@for i in $$(seq 1 30); do \
+		if echo | nc -z localhost $(S3_PORT); then \
+			echo "S3 server is ready!"; \
+			exit 0; \
+		fi; \
+		sleep 1; \
+	done; \
+	echo "S3 server failed to start"; \
+	exit 1
+	@echo "🔍 DEBUG: Server PID: $$(cat weed-server.pid 2>/dev/null || echo 'PID file not found')"
+	@echo "🔍 DEBUG: Checking if PID is still running..."
+	@sleep 2
+	@if [ -f weed-server.pid ]; then \
+		SERVER_PID=$$(cat weed-server.pid); \
+		ps -p $$SERVER_PID || echo "⚠️  Server PID $$SERVER_PID not found after 2 seconds"; \
+	else \
+		echo "⚠️  PID file not found"; \
+	fi
+	@echo "🔍 DEBUG: Waiting for server to start (up to 90 seconds)..."
+	@for i in $$(seq 1 90); do \
+		echo "🔍 DEBUG: Attempt $$i/90 - checking port $(S3_PORT)"; \
+		if curl -s http://localhost:$(S3_PORT) >/dev/null 2>&1; then \
+			echo "✅ SeaweedFS server started successfully on port $(S3_PORT) after $$i seconds"; \
+			exit 0; \
+		fi; \
+		if [ $$i -eq 5 ]; then \
+			echo "🔍 DEBUG: After 5 seconds, checking process and logs..."; \
+			ps aux | grep weed | grep -v grep || echo "No weed processes found"; \
+			if [ -f weed-test.log ]; then \
+				echo "=== First server logs ==="; \
+				head -20 weed-test.log; \
+			fi; \
+		fi; \
+		if [ $$i -eq 15 ]; then \
+			echo "🔍 DEBUG: After 15 seconds, checking port bindings..."; \
+			netstat -tlnp 2>/dev/null | grep $(S3_PORT) || echo "Port $(S3_PORT) not bound"; \
+			netstat -tlnp 2>/dev/null | grep 9333 || echo "Port 9333 not bound"; \
+			netstat -tlnp 2>/dev/null | grep 8080 || echo "Port 8080 not bound"; \
+		fi; \
+		if [ $$i -eq 30 ]; then \
+			echo "⚠️  Server taking longer than expected (30s), checking logs..."; \
+			if [ -f weed-test.log ]; then \
+				echo "=== Recent server logs ==="; \
+				tail -20 weed-test.log; \
+			fi; \
+		fi; \
+		sleep 1; \
+	done; \
+	echo "❌ Server failed to start within 90 seconds"; \
+	echo "🔍 DEBUG: Final process check:"; \
+	ps aux | grep weed | grep -v grep || echo "No weed processes found"; \
+	echo "🔍 DEBUG: Final port check:"; \
+	netstat -tlnp 2>/dev/null | grep -E "(8333|9333|8080)" || echo "No ports bound"; \
+	echo "=== Full server logs ==="; \
+	if [ -f weed-test.log ]; then \
+		cat weed-test.log; \
+	else \
+		echo "No log file found"; \
+	fi; \
+	exit 1
+
+# Stop SeaweedFS server
+stop-server:
+	@echo "Stopping SeaweedFS server..."
+	@if [ -f weed-server.pid ]; then \
+		SERVER_PID=$$(cat weed-server.pid); \
+		echo "Killing server PID $$SERVER_PID"; \
+		if ps -p $$SERVER_PID >/dev/null 2>&1; then \
+			kill -TERM $$SERVER_PID 2>/dev/null || true; \
+			sleep 2; \
+			if ps -p $$SERVER_PID >/dev/null 2>&1; then \
+				echo "Process still running, sending KILL signal..."; \
+				kill -KILL $$SERVER_PID 2>/dev/null || true; \
+				sleep 1; \
+			fi; \
+		else \
+			echo "Process $$SERVER_PID not found (already stopped)"; \
+		fi; \
+		rm -f weed-server.pid; \
+	else \
+		echo "No PID file found, checking for running processes..."; \
+		echo "⚠️  Skipping automatic process cleanup to avoid CI issues"; \
+		echo "Note: Any remaining weed processes should be cleaned up by the CI environment"; \
+	fi
+	@echo "✅ SeaweedFS server stopped"
+
+# Show server logs
+logs:
+	@if test -f weed-test.log; then \
+		echo "=== SeaweedFS Server Logs ==="; \
+		tail -f weed-test.log; \
+	else \
+		echo "No log file found. Server may not be running."; \
+	fi
+
+# Core CORS tests (basic functionality)
+test-cors-quick: check-deps
+	@echo "Running core CORS tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSConfigurationManagement|TestCORSPreflightRequest|TestCORSActualRequest" .
+	@echo "✅ Core CORS tests completed"
+
+# All CORS tests (comprehensive)
+test-cors: check-deps
+	@echo "Running all CORS tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "$(TEST_PATTERN)" .
+	@echo "✅ All CORS tests completed"
+
+# Comprehensive CORS tests (all features)
+test-cors-comprehensive: check-deps
+	@echo "Running comprehensive CORS tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORS" .
+	@echo "✅ Comprehensive CORS tests completed"
+
+# All tests without server management
+test-cors-simple: check-deps
+	@echo "Running CORS tests (assuming server is already running)..."
+	@go test -v -timeout=$(TEST_TIMEOUT) .
+	@echo "✅ All CORS tests completed"
+
+# Start server, run tests, stop server
+test-with-server: start-server
+	@echo "Running CORS tests with managed server..."
+	@sleep 5  # Give server time to fully start
+	@make test-cors-comprehensive || (echo "Tests failed, stopping server..." && make stop-server && exit 1)
+	@make stop-server
+	@echo "✅ All tests completed with managed server"
+
+# Health check
+health-check:
+	@echo "Checking server health..."
+	@if curl -s http://localhost:$(S3_PORT) >/dev/null 2>&1; then \
+		echo "✅ Server is accessible on port $(S3_PORT)"; \
+	else \
+		echo "❌ Server is not accessible on port $(S3_PORT)"; \
+		exit 1; \
+	fi
+
+# Clean up
+clean:
+	@echo "Cleaning up test artifacts..."
+	@make stop-server
+	@rm -f weed-test.log
+	@rm -f weed-server.pid
+	@rm -rf ./test-volume-data
+	@rm -f cors.test
+	@go clean -testcache
+	@echo "✅ Cleanup completed"
+
+# Individual test targets for specific functionality
+test-basic-cors:
+	@echo "Running basic CORS tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSConfigurationManagement" .
+
+test-preflight-cors:
+	@echo "Running preflight CORS tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSPreflightRequest" .
+
+test-actual-cors:
+	@echo "Running actual CORS request tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSActualRequest" .
+
+test-origin-matching:
+	@echo "Running origin matching tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSOriginMatching" .
+
+test-header-matching:
+	@echo "Running header matching tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSHeaderMatching" .
+
+test-method-matching:
+	@echo "Running method matching tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSMethodMatching" .
+
+test-multiple-rules:
+	@echo "Running multiple rules tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSMultipleRulesMatching" .
+
+test-validation:
+	@echo "Running validation tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSValidation" .
+
+test-caching:
+	@echo "Running caching tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSCaching" .
+
+test-error-handling:
+	@echo "Running error handling tests..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSErrorHandling" .
+
+# Development targets
+dev-start: start-server
+	@echo "Development server started. Access S3 API at http://localhost:$(S3_PORT)"
+	@echo "To stop: make stop-server"
+
+dev-test: check-deps
+	@echo "Running tests in development mode..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -run "TestCORSConfigurationManagement" .
+
+# CI targets
+ci-test: check-deps
+	@echo "Running tests in CI mode..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -race .
+
+# All targets
+test-all: test-cors test-cors-comprehensive
+	@echo "✅ All CORS tests completed"
+
+# Benchmark targets
+benchmark-cors:
+	@echo "Running CORS performance benchmarks..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -bench=. -benchmem .
+
+# Coverage targets
+coverage:
+	@echo "Running tests with coverage..."
+	@go test -v -timeout=$(TEST_TIMEOUT) -coverprofile=coverage.out .
+	@go tool cover -html=coverage.out -o coverage.html
+	@echo "Coverage report generated: coverage.html"
+
+# Format and lint
+fmt:
+	@echo "Formatting Go code..."
+	@go fmt .
+
+lint:
+	@echo "Running linter..."
+	@golint . || echo "golint not available, skipping..."
+
+# Install dependencies for development
+install-deps:
+	@echo "Installing Go dependencies..."
+	@go mod tidy
+	@go mod download
+
+# Show current configuration
+show-config:
+	@echo "Current configuration:"
+	@echo "  WEED_BINARY: $(WEED_BINARY)"
+	@echo "  S3_PORT: $(S3_PORT)"
+	@echo "  TEST_TIMEOUT: $(TEST_TIMEOUT)"
+	@echo "  TEST_PATTERN: $(TEST_PATTERN)"
+
+# Legacy targets for backward compatibility
+test: test-with-server
+test-verbose: test-cors-comprehensive
+test-single: test-basic-cors
+test-clean: clean
+build: check-deps
+setup: check-deps 

test/s3/cors/README.md

@@ -0,0 +1,362 @@
+# CORS Integration Tests for SeaweedFS S3 API
+
+This directory contains comprehensive integration tests for the CORS (Cross-Origin Resource Sharing) functionality in SeaweedFS S3 API.
+
+## Overview
+
+The CORS integration tests validate the complete CORS implementation including:
+- CORS configuration management (PUT/GET/DELETE)
+- CORS rule validation
+- CORS middleware behavior
+- Caching functionality
+- Error handling
+- Real-world CORS scenarios
+
+## Prerequisites
+
+1. **Go 1.19+**: For building SeaweedFS and running tests
+2. **Network Access**: Tests use `localhost:8333` by default
+3. **System Dependencies**: `curl` and `netstat` for health checks
+
+## Quick Start
+
+The tests now automatically start their own SeaweedFS server, so you don't need to manually start one.
+
+### 1. Run All Tests with Managed Server
+
+```bash
+# Run all tests with automatic server management
+make test-with-server
+
+# Run core CORS tests only
+make test-cors-quick
+
+# Run comprehensive CORS tests
+make test-cors-comprehensive
+```
+
+### 2. Manual Server Management
+
+If you prefer to manage the server manually:
+
+```bash
+# Start server
+make start-server
+
+# Run tests (assuming server is running)
+make test-cors-simple
+
+# Stop server
+make stop-server
+```
+
+### 3. Individual Test Categories
+
+```bash
+# Run specific test types
+make test-basic-cors           # Basic CORS configuration
+make test-preflight-cors       # Preflight OPTIONS requests
+make test-actual-cors          # Actual CORS request handling
+make test-origin-matching      # Origin matching logic
+make test-header-matching      # Header matching logic
+make test-method-matching      # Method matching logic
+make test-multiple-rules       # Multiple CORS rules
+make test-validation           # CORS validation
+make test-caching              # CORS caching behavior
+make test-error-handling       # Error handling
+```
+
+## Test Server Management
+
+The tests use a comprehensive server management system similar to other SeaweedFS integration tests:
+
+### Server Configuration
+
+- **S3 Port**: 8333 (configurable via `S3_PORT`)
+- **Master Port**: 9333
+- **Volume Port**: 8080
+- **Filer Port**: 8888
+- **Metrics Port**: 9324
+- **Data Directory**: `./test-volume-data` (auto-created)
+- **Log File**: `weed-test.log`
+
+### Server Lifecycle
+
+1. **Build**: Automatically builds `../../../weed/weed_binary`
+2. **Start**: Launches SeaweedFS with S3 API enabled
+3. **Health Check**: Waits up to 90 seconds for server to be ready
+4. **Test**: Runs the requested tests
+5. **Stop**: Gracefully shuts down the server
+6. **Cleanup**: Removes temporary files and data
+
+### Available Commands
+
+```bash
+# Server management
+make start-server              # Start SeaweedFS server
+make stop-server               # Stop SeaweedFS server
+make health-check              # Check server health
+make logs                      # View server logs
+
+# Test execution
+make test-with-server          # Full test cycle with server management
+make test-cors-simple          # Run tests without server management
+make test-cors-quick           # Run core tests only
+make test-cors-comprehensive   # Run all tests
+
+# Development
+make dev-start                 # Start server for development
+make dev-test                  # Run development tests
+make build-weed                # Build SeaweedFS binary
+make check-deps                # Check dependencies
+
+# Maintenance
+make clean                     # Clean up all artifacts
+make coverage                  # Generate coverage report
+make fmt                       # Format code
+make lint                      # Run linter
+```
+
+## Test Configuration
+
+### Default Configuration
+
+The tests use these default settings (configurable via environment variables):
+
+```bash
+WEED_BINARY=../../../weed/weed_binary
+S3_PORT=8333
+TEST_TIMEOUT=10m
+TEST_PATTERN=TestCORS
+```
+
+### Configuration File
+
+The `test_config.json` file contains S3 client configuration:
+
+```json
+{
+  "endpoint": "http://localhost:8333",
+  "access_key": "some_access_key1",
+  "secret_key": "some_secret_key1",
+  "region": "us-east-1",
+  "bucket_prefix": "test-cors-",
+  "use_ssl": false,
+  "skip_verify_ssl": true
+}
+```
+
+## Troubleshooting
+
+### Compilation Issues
+
+If you encounter compilation errors, the most common issues are:
+
+1. **AWS SDK v2 Type Mismatches**: The `MaxAgeSeconds` field in `types.CORSRule` expects `int32`, not `*int32`. Use direct values like `3600` instead of `aws.Int32(3600)`.
+
+2. **Field Name Issues**: The `GetBucketCorsOutput` type has a `CORSRules` field directly, not a `CORSConfiguration` field.
+
+Example fix:
+```go
+// ❌ Incorrect
+MaxAgeSeconds: aws.Int32(3600),
+assert.Len(t, getResp.CORSConfiguration.CORSRules, 1)
+
+// ✅ Correct
+MaxAgeSeconds: 3600,
+assert.Len(t, getResp.CORSRules, 1)
+```
+
+### Server Issues
+
+1. **Server Won't Start**
+   ```bash
+   # Check for port conflicts
+   netstat -tlnp | grep 8333
+   
+   # View server logs
+   make logs
+   
+   # Force cleanup
+   make clean
+   ```
+
+2. **Test Failures**
+   ```bash
+   # Run with server management
+   make test-with-server
+   
+   # Run specific test
+   make test-basic-cors
+   
+   # Check server health
+   make health-check
+   ```
+
+3. **Connection Issues**
+   ```bash
+   # Verify server is running
+   curl -s http://localhost:8333
+   
+   # Check server logs
+   tail -f weed-test.log
+   ```
+
+### Performance Issues
+
+If tests are slow or timing out:
+
+```bash
+# Increase timeout
+export TEST_TIMEOUT=30m
+make test-with-server
+
+# Run quick tests only
+make test-cors-quick
+
+# Check server resources
+make debug-status
+```
+
+## Test Coverage
+
+### Core Functionality Tests
+
+#### 1. CORS Configuration Management (`TestCORSConfigurationManagement`)
+- PUT CORS configuration
+- GET CORS configuration
+- DELETE CORS configuration
+- Configuration updates
+- Error handling for non-existent configurations
+
+#### 2. Multiple CORS Rules (`TestCORSMultipleRules`)
+- Multiple rules in single configuration
+- Rule precedence and ordering
+- Complex rule combinations
+
+#### 3. CORS Validation (`TestCORSValidation`)
+- Invalid HTTP methods
+- Empty origins validation
+- Negative MaxAge validation
+- Rule limit validation
+
+#### 4. Wildcard Support (`TestCORSWithWildcards`)
+- Wildcard origins (`*`, `https://*.example.com`)
+- Wildcard headers (`*`)
+- Wildcard expose headers
+
+#### 5. Rule Limits (`TestCORSRuleLimit`)
+- Maximum 100 rules per configuration
+- Rule limit enforcement
+- Large configuration handling
+
+#### 6. Error Handling (`TestCORSErrorHandling`)
+- Non-existent bucket operations
+- Invalid configurations
+- Malformed requests
+
+### HTTP-Level Tests
+
+#### 1. Preflight Requests (`TestCORSPreflightRequest`)
+- OPTIONS request handling
+- CORS headers in preflight responses
+- Access-Control-Request-Method validation
+- Access-Control-Request-Headers validation
+
+#### 2. Actual Requests (`TestCORSActualRequest`)
+- CORS headers in actual responses
+- Origin validation for real requests
+- Proper expose headers handling
+
+#### 3. Origin Matching (`TestCORSOriginMatching`)
+- Exact origin matching
+- Wildcard origin matching (`*`)
+- Subdomain wildcard matching (`https://*.example.com`)
+- Non-matching origins (should be rejected)
+
+#### 4. Header Matching (`TestCORSHeaderMatching`)
+- Wildcard header matching (`*`)
+- Specific header matching
+- Case-insensitive matching
+- Disallowed headers
+
+#### 5. Method Matching (`TestCORSMethodMatching`)
+- Allowed methods verification
+- Disallowed methods rejection
+- Method-specific CORS behavior
+
+#### 6. Multiple Rules (`TestCORSMultipleRulesMatching`)
+- Rule precedence and selection
+- Multiple rules with different configurations
+- Complex rule interactions
+
+### Integration Tests
+
+#### 1. Caching (`TestCORSCaching`)
+- CORS configuration caching
+- Cache invalidation
+- Cache performance
+
+#### 2. Object Operations (`TestCORSObjectOperations`)
+- CORS with actual S3 operations
+- PUT/GET/DELETE objects with CORS
+- CORS headers in object responses
+
+#### 3. Without Configuration (`TestCORSWithoutConfiguration`)
+- Behavior when no CORS configuration exists
+- Default CORS behavior
+- Graceful degradation
+
+## Development
+
+### Running Tests During Development
+
+```bash
+# Start server for development
+make dev-start
+
+# Run quick test
+make dev-test
+
+# View logs in real-time
+make logs
+```
+
+### Adding New Tests
+
+1. Follow the existing naming convention (`TestCORSXxxYyy`)
+2. Use the helper functions (`getS3Client`, `createTestBucket`, etc.)
+3. Add cleanup with `defer cleanupTestBucket(t, client, bucketName)`
+4. Include proper error checking with `require.NoError(t, err)`
+5. Use assertions with `assert.Equal(t, expected, actual)`
+6. Add the test to the appropriate Makefile target
+
+### Code Quality
+
+```bash
+# Format code
+make fmt
+
+# Run linter
+make lint
+
+# Generate coverage report
+make coverage
+```
+
+## Performance Notes
+
+- Tests create and destroy buckets for each test case
+- Large configuration tests may take several minutes
+- Server startup typically takes 15-30 seconds
+- Tests run in parallel where possible for efficiency
+
+## Integration with SeaweedFS
+
+These tests validate the CORS implementation in:
+- `weed/s3api/cors/` - Core CORS package
+- `weed/s3api/s3api_bucket_cors_handlers.go` - HTTP handlers
+- `weed/s3api/s3api_server.go` - Router integration
+- `weed/s3api/s3api_bucket_config.go` - Configuration management
+
+The tests ensure AWS S3 API compatibility and proper CORS behavior across all supported scenarios. 

test/s3/cors/s3_cors_http_test.go

@@ -0,0 +1,633 @@
+package cors
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestCORSPreflightRequest tests CORS preflight OPTIONS requests
+func TestCORSPreflightRequest(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Set up CORS configuration
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"Content-Type", "Authorization"},
+				AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag", "Content-Length"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration")
+
+	// Wait for metadata subscription to update cache
+	time.Sleep(50 * time.Millisecond)
+
+	// Test preflight request with raw HTTP
+	httpClient := &http.Client{Timeout: 10 * time.Second}
+
+	// Create OPTIONS request
+	req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+	require.NoError(t, err, "Should be able to create OPTIONS request")
+
+	// Add CORS preflight headers
+	req.Header.Set("Origin", "https://example.com")
+	req.Header.Set("Access-Control-Request-Method", "PUT")
+	req.Header.Set("Access-Control-Request-Headers", "Content-Type, Authorization")
+
+	// Send the request
+	resp, err := httpClient.Do(req)
+	require.NoError(t, err, "Should be able to send OPTIONS request")
+	defer resp.Body.Close()
+
+	// Verify CORS headers in response
+	assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Methods"), "PUT", "Should allow PUT method")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Headers"), "Content-Type", "Should allow Content-Type header")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Headers"), "Authorization", "Should allow Authorization header")
+	assert.Equal(t, "3600", resp.Header.Get("Access-Control-Max-Age"), "Should have correct Max-Age header")
+	assert.Contains(t, resp.Header.Get("Access-Control-Expose-Headers"), "ETag", "Should expose ETag header")
+	assert.Equal(t, http.StatusOK, resp.StatusCode, "OPTIONS request should return 200")
+}
+
+// TestCORSActualRequest tests CORS behavior with actual requests
+func TestCORSActualRequest(t *testing.T) {
+	// Temporarily clear AWS environment variables to ensure truly anonymous requests
+	// This prevents AWS SDK from auto-signing requests in GitHub Actions
+	originalAccessKey := os.Getenv("AWS_ACCESS_KEY_ID")
+	originalSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
+	originalSessionToken := os.Getenv("AWS_SESSION_TOKEN")
+	originalProfile := os.Getenv("AWS_PROFILE")
+	originalRegion := os.Getenv("AWS_REGION")
+
+	os.Setenv("AWS_ACCESS_KEY_ID", "")
+	os.Setenv("AWS_SECRET_ACCESS_KEY", "")
+	os.Setenv("AWS_SESSION_TOKEN", "")
+	os.Setenv("AWS_PROFILE", "")
+	os.Setenv("AWS_REGION", "")
+
+	defer func() {
+		// Restore original environment variables
+		os.Setenv("AWS_ACCESS_KEY_ID", originalAccessKey)
+		os.Setenv("AWS_SECRET_ACCESS_KEY", originalSecretKey)
+		os.Setenv("AWS_SESSION_TOKEN", originalSessionToken)
+		os.Setenv("AWS_PROFILE", originalProfile)
+		os.Setenv("AWS_REGION", originalRegion)
+	}()
+
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Set up CORS configuration
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET", "PUT"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag", "Content-Length"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration")
+
+	// Wait for CORS configuration to be fully processed
+	time.Sleep(100 * time.Millisecond)
+
+	// First, put an object using S3 client
+	objectKey := "test-cors-object"
+	_, err = client.PutObject(context.TODO(), &s3.PutObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+		Body:   strings.NewReader("Test CORS content"),
+	})
+	require.NoError(t, err, "Should be able to put object")
+
+	// Test GET request with CORS headers using raw HTTP
+	// Create a completely isolated HTTP client to avoid AWS SDK auto-signing
+	transport := &http.Transport{
+		// Completely disable any proxy or middleware
+		Proxy: nil,
+	}
+
+	httpClient := &http.Client{
+		Timeout: 10 * time.Second,
+		// Use a completely clean transport to avoid any AWS SDK middleware
+		Transport: transport,
+	}
+
+	// Create URL manually to avoid any AWS SDK endpoint processing
+	// Use the same endpoint as the S3 client to ensure compatibility with GitHub Actions
+	config := getDefaultConfig()
+	endpoint := config.Endpoint
+	// Remove any protocol prefix and ensure it's http for anonymous requests
+	if strings.HasPrefix(endpoint, "https://") {
+		endpoint = strings.Replace(endpoint, "https://", "http://", 1)
+	}
+	if !strings.HasPrefix(endpoint, "http://") {
+		endpoint = "http://" + endpoint
+	}
+
+	requestURL := fmt.Sprintf("%s/%s/%s", endpoint, bucketName, objectKey)
+	req, err := http.NewRequest("GET", requestURL, nil)
+	require.NoError(t, err, "Should be able to create GET request")
+
+	// Add Origin header to simulate CORS request
+	req.Header.Set("Origin", "https://example.com")
+
+	// Explicitly ensure no AWS headers are present (defensive programming)
+	// Clear ALL potential AWS-related headers that might be auto-added
+	req.Header.Del("Authorization")
+	req.Header.Del("X-Amz-Content-Sha256")
+	req.Header.Del("X-Amz-Date")
+	req.Header.Del("Amz-Sdk-Invocation-Id")
+	req.Header.Del("Amz-Sdk-Request")
+	req.Header.Del("X-Amz-Security-Token")
+	req.Header.Del("X-Amz-Session-Token")
+	req.Header.Del("AWS-Session-Token")
+	req.Header.Del("X-Amz-Target")
+	req.Header.Del("X-Amz-User-Agent")
+
+	// Ensure User-Agent doesn't indicate AWS SDK
+	req.Header.Set("User-Agent", "anonymous-cors-test/1.0")
+
+	// Verify no AWS-related headers are present
+	for name := range req.Header {
+		headerLower := strings.ToLower(name)
+		if strings.Contains(headerLower, "aws") ||
+			strings.Contains(headerLower, "amz") ||
+			strings.Contains(headerLower, "authorization") {
+			t.Fatalf("Found AWS-related header in anonymous request: %s", name)
+		}
+	}
+
+	// Send the request
+	resp, err := httpClient.Do(req)
+	require.NoError(t, err, "Should be able to send GET request")
+	defer resp.Body.Close()
+
+	// Verify CORS headers are present
+	assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+	assert.Contains(t, resp.Header.Get("Access-Control-Expose-Headers"), "ETag", "Should expose ETag header")
+
+	// Anonymous requests should succeed when anonymous read permission is configured in IAM
+	// The server configuration allows anonymous users to have Read permissions
+	assert.Equal(t, http.StatusOK, resp.StatusCode, "Anonymous GET request should succeed when anonymous read is configured")
+}
+
+// TestCORSOriginMatching tests origin matching with different patterns
+func TestCORSOriginMatching(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	testCases := []struct {
+		name           string
+		allowedOrigins []string
+		requestOrigin  string
+		shouldAllow    bool
+	}{
+		{
+			name:           "exact match",
+			allowedOrigins: []string{"https://example.com"},
+			requestOrigin:  "https://example.com",
+			shouldAllow:    true,
+		},
+		{
+			name:           "wildcard match",
+			allowedOrigins: []string{"*"},
+			requestOrigin:  "https://example.com",
+			shouldAllow:    true,
+		},
+		{
+			name:           "subdomain wildcard match",
+			allowedOrigins: []string{"https://*.example.com"},
+			requestOrigin:  "https://api.example.com",
+			shouldAllow:    true,
+		},
+		{
+			name:           "no match",
+			allowedOrigins: []string{"https://example.com"},
+			requestOrigin:  "https://malicious.com",
+			shouldAllow:    false,
+		},
+		{
+			name:           "subdomain wildcard no match",
+			allowedOrigins: []string{"https://*.example.com"},
+			requestOrigin:  "https://example.com",
+			shouldAllow:    false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Set up CORS configuration for this test case
+			corsConfig := &types.CORSConfiguration{
+				CORSRules: []types.CORSRule{
+					{
+						AllowedHeaders: []string{"*"},
+						AllowedMethods: []string{"GET"},
+						AllowedOrigins: tc.allowedOrigins,
+						ExposeHeaders:  []string{"ETag"},
+						MaxAgeSeconds:  aws.Int32(3600),
+					},
+				},
+			}
+
+			_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+				Bucket:            aws.String(bucketName),
+				CORSConfiguration: corsConfig,
+			})
+			require.NoError(t, err, "Should be able to put CORS configuration")
+
+			// Wait for metadata subscription to update cache
+			time.Sleep(50 * time.Millisecond)
+
+			// Test preflight request
+			httpClient := &http.Client{Timeout: 10 * time.Second}
+
+			req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+			require.NoError(t, err, "Should be able to create OPTIONS request")
+
+			req.Header.Set("Origin", tc.requestOrigin)
+			req.Header.Set("Access-Control-Request-Method", "GET")
+
+			resp, err := httpClient.Do(req)
+			require.NoError(t, err, "Should be able to send OPTIONS request")
+			defer resp.Body.Close()
+
+			if tc.shouldAllow {
+				assert.Equal(t, tc.requestOrigin, resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+				assert.Contains(t, resp.Header.Get("Access-Control-Allow-Methods"), "GET", "Should allow GET method")
+			} else {
+				assert.Empty(t, resp.Header.Get("Access-Control-Allow-Origin"), "Should not have Allow-Origin header for disallowed origin")
+			}
+		})
+	}
+}
+
+// TestCORSHeaderMatching tests header matching with different patterns
+func TestCORSHeaderMatching(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	testCases := []struct {
+		name            string
+		allowedHeaders  []string
+		requestHeaders  string
+		shouldAllow     bool
+		expectedHeaders string
+	}{
+		{
+			name:            "wildcard headers",
+			allowedHeaders:  []string{"*"},
+			requestHeaders:  "Content-Type, Authorization",
+			shouldAllow:     true,
+			expectedHeaders: "Content-Type, Authorization",
+		},
+		{
+			name:            "specific headers match",
+			allowedHeaders:  []string{"Content-Type", "Authorization"},
+			requestHeaders:  "Content-Type, Authorization",
+			shouldAllow:     true,
+			expectedHeaders: "Content-Type, Authorization",
+		},
+		{
+			name:            "partial header match",
+			allowedHeaders:  []string{"Content-Type"},
+			requestHeaders:  "Content-Type",
+			shouldAllow:     true,
+			expectedHeaders: "Content-Type",
+		},
+		{
+			name:            "case insensitive match",
+			allowedHeaders:  []string{"content-type"},
+			requestHeaders:  "Content-Type",
+			shouldAllow:     true,
+			expectedHeaders: "Content-Type",
+		},
+		{
+			name:           "disallowed header",
+			allowedHeaders: []string{"Content-Type"},
+			requestHeaders: "Authorization",
+			shouldAllow:    false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Set up CORS configuration for this test case
+			corsConfig := &types.CORSConfiguration{
+				CORSRules: []types.CORSRule{
+					{
+						AllowedHeaders: tc.allowedHeaders,
+						AllowedMethods: []string{"GET", "POST"},
+						AllowedOrigins: []string{"https://example.com"},
+						ExposeHeaders:  []string{"ETag"},
+						MaxAgeSeconds:  aws.Int32(3600),
+					},
+				},
+			}
+
+			_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+				Bucket:            aws.String(bucketName),
+				CORSConfiguration: corsConfig,
+			})
+			require.NoError(t, err, "Should be able to put CORS configuration")
+
+			// Wait for metadata subscription to update cache
+			time.Sleep(50 * time.Millisecond)
+
+			// Test preflight request
+			httpClient := &http.Client{Timeout: 10 * time.Second}
+
+			req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+			require.NoError(t, err, "Should be able to create OPTIONS request")
+
+			req.Header.Set("Origin", "https://example.com")
+			req.Header.Set("Access-Control-Request-Method", "POST")
+			req.Header.Set("Access-Control-Request-Headers", tc.requestHeaders)
+
+			resp, err := httpClient.Do(req)
+			require.NoError(t, err, "Should be able to send OPTIONS request")
+			defer resp.Body.Close()
+
+			if tc.shouldAllow {
+				assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+				allowedHeaders := resp.Header.Get("Access-Control-Allow-Headers")
+				for _, header := range strings.Split(tc.expectedHeaders, ", ") {
+					assert.Contains(t, allowedHeaders, header, "Should allow header: %s", header)
+				}
+			} else {
+				// Even if headers are not allowed, the origin should still be in the response
+				// but the headers should not be echoed back
+				assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+				allowedHeaders := resp.Header.Get("Access-Control-Allow-Headers")
+				assert.NotContains(t, allowedHeaders, "Authorization", "Should not allow Authorization header")
+			}
+		})
+	}
+}
+
+// TestCORSWithoutConfiguration tests CORS behavior when no bucket-level configuration is set
+// With the fallback feature, buckets without explicit CORS config will use the global CORS settings
+func TestCORSWithoutConfiguration(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Test preflight request without bucket-level CORS configuration
+	// The global CORS fallback (default: "*") should be used
+	httpClient := &http.Client{Timeout: 10 * time.Second}
+
+	req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+	require.NoError(t, err, "Should be able to create OPTIONS request")
+
+	req.Header.Set("Origin", "https://example.com")
+	req.Header.Set("Access-Control-Request-Method", "GET")
+	req.Header.Set("Access-Control-Request-Headers", "Content-Type")
+
+	resp, err := httpClient.Do(req)
+	require.NoError(t, err, "Should be able to send OPTIONS request")
+	defer resp.Body.Close()
+
+	// With fallback CORS (global default: "*"), CORS headers should be present
+	assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have Allow-Origin header from global fallback")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Methods"), "GET", "Should have GET in Allow-Methods from global fallback")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Headers"), "Content-Type", "Should have requested headers in Allow-Headers from global fallback")
+}
+
+// TestCORSMethodMatching tests method matching
+func TestCORSMethodMatching(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Set up CORS configuration with limited methods
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET", "POST"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration")
+
+	// Wait for metadata subscription to update cache
+	time.Sleep(50 * time.Millisecond)
+
+	testCases := []struct {
+		method      string
+		shouldAllow bool
+	}{
+		{"GET", true},
+		{"POST", true},
+		{"PUT", false},
+		{"DELETE", false},
+		{"HEAD", false},
+	}
+
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("method_%s", tc.method), func(t *testing.T) {
+			httpClient := &http.Client{Timeout: 10 * time.Second}
+
+			req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+			require.NoError(t, err, "Should be able to create OPTIONS request")
+
+			req.Header.Set("Origin", "https://example.com")
+			req.Header.Set("Access-Control-Request-Method", tc.method)
+
+			resp, err := httpClient.Do(req)
+			require.NoError(t, err, "Should be able to send OPTIONS request")
+			defer resp.Body.Close()
+
+			if tc.shouldAllow {
+				assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+				assert.Contains(t, resp.Header.Get("Access-Control-Allow-Methods"), tc.method, "Should allow method: %s", tc.method)
+			} else {
+				// Even if method is not allowed, the origin should still be in the response
+				// but the method should not be in the allowed methods
+				assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should have correct Allow-Origin header")
+				allowedMethods := resp.Header.Get("Access-Control-Allow-Methods")
+				assert.NotContains(t, allowedMethods, tc.method, "Should not allow method: %s", tc.method)
+			}
+		})
+	}
+}
+
+// TestCORSMultipleRulesMatching tests CORS with multiple rules
+func TestCORSMultipleRulesMatching(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Set up CORS configuration with multiple rules
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"Content-Type"},
+				AllowedMethods: []string{"GET"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+			{
+				AllowedHeaders: []string{"Authorization"},
+				AllowedMethods: []string{"POST", "PUT"},
+				AllowedOrigins: []string{"https://api.example.com"},
+				ExposeHeaders:  []string{"Content-Length"},
+				MaxAgeSeconds:  aws.Int32(7200),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration")
+
+	// Wait for metadata subscription to update cache
+	time.Sleep(50 * time.Millisecond)
+
+	// Test first rule
+	httpClient := &http.Client{Timeout: 10 * time.Second}
+
+	req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+	require.NoError(t, err, "Should be able to create OPTIONS request")
+
+	req.Header.Set("Origin", "https://example.com")
+	req.Header.Set("Access-Control-Request-Method", "GET")
+	req.Header.Set("Access-Control-Request-Headers", "Content-Type")
+
+	resp, err := httpClient.Do(req)
+	require.NoError(t, err, "Should be able to send OPTIONS request")
+	defer resp.Body.Close()
+
+	assert.Equal(t, "https://example.com", resp.Header.Get("Access-Control-Allow-Origin"), "Should match first rule")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Methods"), "GET", "Should allow GET method")
+	assert.Contains(t, resp.Header.Get("Access-Control-Allow-Headers"), "Content-Type", "Should allow Content-Type header")
+	assert.Equal(t, "3600", resp.Header.Get("Access-Control-Max-Age"), "Should have first rule's max age")
+
+	// Test second rule
+	req2, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/%s/test-object", getDefaultConfig().Endpoint, bucketName), nil)
+	require.NoError(t, err, "Should be able to create OPTIONS request")
+
+	req2.Header.Set("Origin", "https://api.example.com")
+	req2.Header.Set("Access-Control-Request-Method", "POST")
+	req2.Header.Set("Access-Control-Request-Headers", "Authorization")
+
+	resp2, err := httpClient.Do(req2)
+	require.NoError(t, err, "Should be able to send OPTIONS request")
+	defer resp2.Body.Close()
+
+	assert.Equal(t, "https://api.example.com", resp2.Header.Get("Access-Control-Allow-Origin"), "Should match second rule")
+	assert.Contains(t, resp2.Header.Get("Access-Control-Allow-Methods"), "POST", "Should allow POST method")
+	assert.Contains(t, resp2.Header.Get("Access-Control-Allow-Headers"), "Authorization", "Should allow Authorization header")
+	assert.Equal(t, "7200", resp2.Header.Get("Access-Control-Max-Age"), "Should have second rule's max age")
+}
+
+// TestServiceLevelCORS tests that service-level endpoints (like /status) get proper CORS headers
+func TestServiceLevelCORS(t *testing.T) {
+	assert := assert.New(t)
+
+	endpoints := []string{
+		"/",
+		"/status",
+		"/healthz",
+	}
+
+	for _, endpoint := range endpoints {
+		t.Run(fmt.Sprintf("endpoint_%s", strings.ReplaceAll(endpoint, "/", "_")), func(t *testing.T) {
+			req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s%s", getDefaultConfig().Endpoint, endpoint), nil)
+			assert.NoError(err)
+
+			// Add Origin header to trigger CORS
+			req.Header.Set("Origin", "http://example.com")
+
+			client := &http.Client{}
+			resp, err := client.Do(req)
+			assert.NoError(err)
+			defer resp.Body.Close()
+
+			// Should return 200 OK
+			assert.Equal(http.StatusOK, resp.StatusCode)
+
+			// Should have CORS headers set
+			assert.Equal("*", resp.Header.Get("Access-Control-Allow-Origin"))
+			assert.Equal("*", resp.Header.Get("Access-Control-Expose-Headers"))
+			assert.Equal("*", resp.Header.Get("Access-Control-Allow-Methods"))
+			assert.Equal("*", resp.Header.Get("Access-Control-Allow-Headers"))
+		})
+	}
+}
+
+// TestServiceLevelCORSWithoutOrigin tests that service-level endpoints without Origin header don't get CORS headers
+func TestServiceLevelCORSWithoutOrigin(t *testing.T) {
+	assert := assert.New(t)
+
+	req, err := http.NewRequest("OPTIONS", fmt.Sprintf("%s/status", getDefaultConfig().Endpoint), nil)
+	assert.NoError(err)
+
+	// No Origin header
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	assert.NoError(err)
+	defer resp.Body.Close()
+
+	// Should return 200 OK
+	assert.Equal(http.StatusOK, resp.StatusCode)
+
+	// Should not have CORS headers set (or have empty values)
+	corsHeaders := []string{
+		"Access-Control-Allow-Origin",
+		"Access-Control-Expose-Headers",
+		"Access-Control-Allow-Methods",
+		"Access-Control-Allow-Headers",
+	}
+
+	for _, header := range corsHeaders {
+		value := resp.Header.Get(header)
+		// Headers should either be empty or not present
+		assert.True(value == "" || value == "*", "Header %s should be empty or wildcard, got: %s", header, value)
+	}
+}

test/s3/cors/s3_cors_test.go

@@ -0,0 +1,785 @@
+package cors
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
+	"github.com/k0kubun/pp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// S3TestConfig holds configuration for S3 tests
+type S3TestConfig struct {
+	Endpoint       string
+	MasterEndpoint string
+	AccessKey      string
+	SecretKey      string
+	Region         string
+	BucketPrefix   string
+	UseSSL         bool
+	SkipVerifySSL  bool
+}
+
+// allTestBucketPrefixes lists every prefix used to name buckets in this test suite.
+// cleanupAllTestBuckets uses it to find stale buckets from prior tests/runs.
+// Add the new prefix here whenever a test introduces one.
+var allTestBucketPrefixes = []string{
+	"test-cors-",
+}
+
+// testRunID uniquely identifies this `go test` invocation. It's embedded into
+// every bucket created by createTestBucket (after defaultConfig.BucketPrefix), so
+// the cleanup sweep can scope deletions to buckets that belong to this run only —
+// letting concurrent runs against the same endpoints coexist without tearing each
+// other's buckets down. Stale buckets left behind by a crashed prior run share the
+// family prefix but a different runID, so they are not swept here; `make clean`
+// (or wiping the data dir) is the right cleanup for that case.
+var testRunID = strconv.FormatInt(time.Now().UnixNano(), 36)
+
+// getDefaultConfig returns a fresh instance of the default test configuration
+// to avoid parallel test issues with global mutable state
+func getDefaultConfig() *S3TestConfig {
+	endpoint := os.Getenv("S3_ENDPOINT")
+	if endpoint == "" {
+		endpoint = "http://localhost:8333" // Default SeaweedFS S3 port
+	}
+	masterEndpoint := os.Getenv("MASTER_ENDPOINT")
+	if masterEndpoint == "" {
+		masterEndpoint = "http://127.0.0.1:9333" // Default SeaweedFS master HTTP port
+	}
+	return &S3TestConfig{
+		Endpoint:       endpoint,
+		MasterEndpoint: masterEndpoint,
+		AccessKey:      "some_access_key1",
+		SecretKey:      "some_secret_key1",
+		Region:         "us-east-1",
+		BucketPrefix:   "test-cors-",
+		UseSSL:         false,
+		SkipVerifySSL:  true,
+	}
+}
+
+// getS3Client creates an AWS S3 client for testing
+func getS3Client(t *testing.T) *s3.Client {
+	defaultConfig := getDefaultConfig()
+	cfg, err := config.LoadDefaultConfig(context.TODO(),
+		config.WithRegion(defaultConfig.Region),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
+			defaultConfig.AccessKey,
+			defaultConfig.SecretKey,
+			"",
+		)),
+		config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(
+			func(service, region string, options ...interface{}) (aws.Endpoint, error) {
+				return aws.Endpoint{
+					URL:           defaultConfig.Endpoint,
+					SigningRegion: defaultConfig.Region,
+				}, nil
+			})),
+	)
+	require.NoError(t, err)
+
+	client := s3.NewFromConfig(cfg, func(o *s3.Options) {
+		o.UsePathStyle = true
+	})
+	return client
+}
+
+// createTestBucket creates a test bucket with a unique name
+func createTestBucket(t *testing.T, client *s3.Client) string {
+	defaultConfig := getDefaultConfig()
+	// Sweep stale buckets from prior tests in this run so each new bucket starts
+	// on a fresh slate. Without this, leaked collection volumes accumulate on a
+	// single `weed mini` data node and the suite eventually exhausts its volume
+	// slots.
+	cleanupAllTestBuckets(t, client)
+	bucketName := fmt.Sprintf("%sr%s-%d", defaultConfig.BucketPrefix, testRunID, time.Now().UnixNano())
+
+	_, err := client.CreateBucket(context.TODO(), &s3.CreateBucketInput{
+		Bucket: aws.String(bucketName),
+	})
+	require.NoError(t, err)
+
+	// Wait for bucket metadata to be fully processed
+	time.Sleep(50 * time.Millisecond)
+
+	return bucketName
+}
+
+// cleanupTestBucket removes the test bucket and all its contents.
+// Always force-drops the underlying collection at the master afterwards: the S3
+// DeleteBucket can race with concurrent `volume_grow` requests (the warm-create
+// batch keeps registering volumes after the master's collection-delete sweep has
+// already snapshotted the layout), so 1-3 volumes per bucket can leak. Without
+// this, running enough tests on a single `weed mini` server exhausts the data
+// node's volume slots and every subsequent PutObject 500s with "Not enough data
+// nodes found".
+func cleanupTestBucket(t *testing.T, client *s3.Client, bucketName string) {
+	defer forceDeleteCollection(t, bucketName)
+	// First, delete all objects in the bucket
+	listResp, err := client.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
+		Bucket: aws.String(bucketName),
+	})
+	if err == nil {
+		for _, obj := range listResp.Contents {
+			_, err := client.DeleteObject(context.TODO(), &s3.DeleteObjectInput{
+				Bucket: aws.String(bucketName),
+				Key:    obj.Key,
+			})
+			if err != nil {
+				t.Logf("Warning: failed to delete object %s: %v", *obj.Key, err)
+			}
+		}
+	}
+
+	// Then delete the bucket
+	_, err = client.DeleteBucket(context.TODO(), &s3.DeleteBucketInput{
+		Bucket: aws.String(bucketName),
+	})
+	if err != nil {
+		t.Logf("Warning: failed to delete bucket %s: %v", bucketName, err)
+	}
+}
+
+// forceDeleteCollection drops the SeaweedFS collection backing a test bucket via the master's
+// /col/delete admin endpoint. The S3 layer normally drops the collection on DeleteBucket, but
+// in-flight `volume_grow` requests can register volumes after the master's first sweep, leaking
+// them. Best-effort: a 400 from the master means the collection was already gone, which is the
+// success path and not an error.
+func forceDeleteCollection(t *testing.T, bucketName string) {
+	masterEndpoint := getDefaultConfig().MasterEndpoint
+	if masterEndpoint == "" {
+		return
+	}
+	endpoint := strings.TrimRight(masterEndpoint, "/") + "/col/delete?collection=" + url.QueryEscape(bucketName)
+	req, err := http.NewRequest(http.MethodGet, endpoint, nil)
+	if err != nil {
+		t.Logf("Note: building collection delete request for %s failed: %v", bucketName, err)
+		return
+	}
+	httpClient := &http.Client{Timeout: 5 * time.Second}
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		t.Logf("Note: force-delete collection %s failed: %v", bucketName, err)
+		return
+	}
+	defer resp.Body.Close()
+	io.Copy(io.Discard, resp.Body)
+	switch resp.StatusCode {
+	case http.StatusNoContent:
+		t.Logf("Force-deleted collection %s", bucketName)
+	case http.StatusBadRequest:
+		// Collection already gone - normal path when DeleteBucket succeeded.
+	default:
+		t.Logf("Note: force-delete collection %s returned HTTP %d", bucketName, resp.StatusCode)
+	}
+}
+
+// cleanupAllTestBuckets cleans up any leftover test buckets owned by this run
+// (prefix + runID marker). Called from createTestBucket before each new bucket
+// creation so a single `weed mini` data node does not exhaust its volume slots
+// after many tests.
+func cleanupAllTestBuckets(t *testing.T, client *s3.Client) {
+	listResp, err := client.ListBuckets(context.TODO(), &s3.ListBucketsInput{})
+	if err != nil {
+		t.Logf("Warning: failed to list buckets for cleanup: %v", err)
+		return
+	}
+
+	for _, bucket := range listResp.Buckets {
+		if bucket.Name == nil {
+			continue
+		}
+		for _, prefix := range allTestBucketPrefixes {
+			// Only sweep buckets owned by this run (prefix + runID marker).
+			// Buckets from concurrent runs carry a different runID and are skipped.
+			if strings.HasPrefix(*bucket.Name, prefix+"r"+testRunID+"-") {
+				t.Logf("Cleaning up leftover test bucket: %s", *bucket.Name)
+				cleanupTestBucket(t, client, *bucket.Name)
+				break
+			}
+		}
+	}
+}
+
+// TestCORSConfigurationManagement tests basic CORS configuration CRUD operations
+func TestCORSConfigurationManagement(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Test 1: Get CORS configuration when none exists (should return error)
+	_, err := client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+		Bucket: aws.String(bucketName),
+	})
+	assert.Error(t, err, "Should get error when no CORS configuration exists")
+
+	// Test 2: Put CORS configuration
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET", "POST", "PUT"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration")
+
+	// Wait for metadata subscription to update cache
+	time.Sleep(50 * time.Millisecond)
+
+	// Test 3: Get CORS configuration
+	getResp, err := client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+		Bucket: aws.String(bucketName),
+	})
+	require.NoError(t, err, "Should be able to get CORS configuration")
+	require.NotNil(t, getResp.CORSRules, "CORS configuration should not be nil")
+	require.Len(t, getResp.CORSRules, 1, "Should have one CORS rule")
+
+	rule := getResp.CORSRules[0]
+	assert.Equal(t, []string{"*"}, rule.AllowedHeaders, "Allowed headers should match")
+	assert.Equal(t, []string{"GET", "POST", "PUT"}, rule.AllowedMethods, "Allowed methods should match")
+	assert.Equal(t, []string{"https://example.com"}, rule.AllowedOrigins, "Allowed origins should match")
+	assert.Equal(t, []string{"ETag"}, rule.ExposeHeaders, "Expose headers should match")
+	assert.Equal(t, aws.Int32(3600), rule.MaxAgeSeconds, "Max age should match")
+
+	// Test 4: Update CORS configuration
+	updatedCorsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"Content-Type"},
+				AllowedMethods: []string{"GET", "POST"},
+				AllowedOrigins: []string{"https://example.com", "https://another.com"},
+				ExposeHeaders:  []string{"ETag", "Content-Length"},
+				MaxAgeSeconds:  aws.Int32(7200),
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: updatedCorsConfig,
+	})
+	require.NoError(t, err, "Should be able to update CORS configuration")
+
+	// Wait for CORS configuration update to be fully processed
+	time.Sleep(100 * time.Millisecond)
+
+	// Verify the update with retries for robustness
+	var updateSuccess bool
+	for i := 0; i < 3; i++ {
+		getResp, err = client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+			Bucket: aws.String(bucketName),
+		})
+		if err != nil {
+			t.Logf("Attempt %d: Failed to get updated CORS config: %v", i+1, err)
+			time.Sleep(50 * time.Millisecond)
+			continue
+		}
+
+		if len(getResp.CORSRules) > 0 {
+			rule = getResp.CORSRules[0]
+			// Check if the update actually took effect
+			if len(rule.AllowedHeaders) > 0 && rule.AllowedHeaders[0] == "Content-Type" &&
+				len(rule.AllowedOrigins) > 1 {
+				updateSuccess = true
+				break
+			}
+		}
+		t.Logf("Attempt %d: CORS config not updated yet, retrying...", i+1)
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	require.NoError(t, err, "Should be able to get updated CORS configuration")
+	require.True(t, updateSuccess, "CORS configuration should be updated after retries")
+	assert.Equal(t, []string{"Content-Type"}, rule.AllowedHeaders, "Updated allowed headers should match")
+	assert.Equal(t, []string{"https://example.com", "https://another.com"}, rule.AllowedOrigins, "Updated allowed origins should match")
+
+	// Test 5: Delete CORS configuration
+	_, err = client.DeleteBucketCors(context.TODO(), &s3.DeleteBucketCorsInput{
+		Bucket: aws.String(bucketName),
+	})
+	require.NoError(t, err, "Should be able to delete CORS configuration")
+
+	// Wait for deletion to be fully processed
+	time.Sleep(100 * time.Millisecond)
+
+	// Verify deletion - should get NoSuchCORSConfiguration error
+	_, err = client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+		Bucket: aws.String(bucketName),
+	})
+
+	// Check that we get the expected error type
+	if err != nil {
+		// Log the error for debugging
+		t.Logf("Got expected error after CORS deletion: %v", err)
+		// Check if it's the correct error type (NoSuchCORSConfiguration)
+		errMsg := err.Error()
+		if !strings.Contains(errMsg, "NoSuchCORSConfiguration") && !strings.Contains(errMsg, "404") {
+			t.Errorf("Expected NoSuchCORSConfiguration error, got: %v", err)
+		}
+	} else {
+		// If no error, this might be a SeaweedFS implementation difference
+		// Some implementations might return empty config instead of error
+		t.Logf("CORS deletion test: No error returned - this may be implementation-specific behavior")
+	}
+}
+
+// TestCORSMultipleRules tests CORS configuration with multiple rules
+func TestCORSMultipleRules(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Create CORS configuration with multiple rules
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET", "HEAD"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+			{
+				AllowedHeaders: []string{"Content-Type", "Authorization"},
+				AllowedMethods: []string{"POST", "PUT", "DELETE"},
+				AllowedOrigins: []string{"https://app.example.com"},
+				ExposeHeaders:  []string{"ETag", "Content-Length"},
+				MaxAgeSeconds:  aws.Int32(7200),
+			},
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET"},
+				AllowedOrigins: []string{"*"},
+				ExposeHeaders:  []string{"ETag"},
+				MaxAgeSeconds:  aws.Int32(1800),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration with multiple rules")
+
+	// Wait for CORS configuration to be fully processed
+	time.Sleep(100 * time.Millisecond)
+
+	// Get and verify the configuration with retries for robustness
+	var getResp *s3.GetBucketCorsOutput
+	var getErr error
+
+	// Retry getting CORS config up to 3 times to handle timing issues
+	for i := 0; i < 3; i++ {
+		getResp, getErr = client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+			Bucket: aws.String(bucketName),
+		})
+		if getErr == nil {
+			break
+		}
+		t.Logf("Attempt %d: Failed to get multiple rules CORS config: %v", i+1, getErr)
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	require.NoError(t, getErr, "Should be able to get CORS configuration after retries")
+	require.NotNil(t, getResp, "GetBucketCors response should not be nil")
+	require.Len(t, getResp.CORSRules, 3, "Should have three CORS rules")
+
+	// Verify first rule
+	rule1 := getResp.CORSRules[0]
+	assert.Equal(t, []string{"*"}, rule1.AllowedHeaders)
+	assert.Equal(t, []string{"GET", "HEAD"}, rule1.AllowedMethods)
+	assert.Equal(t, []string{"https://example.com"}, rule1.AllowedOrigins)
+
+	// Verify second rule
+	rule2 := getResp.CORSRules[1]
+	assert.Equal(t, []string{"Content-Type", "Authorization"}, rule2.AllowedHeaders)
+	assert.Equal(t, []string{"POST", "PUT", "DELETE"}, rule2.AllowedMethods)
+	assert.Equal(t, []string{"https://app.example.com"}, rule2.AllowedOrigins)
+
+	// Verify third rule
+	rule3 := getResp.CORSRules[2]
+	assert.Equal(t, []string{"*"}, rule3.AllowedHeaders)
+	assert.Equal(t, []string{"GET"}, rule3.AllowedMethods)
+	assert.Equal(t, []string{"*"}, rule3.AllowedOrigins)
+}
+
+// TestCORSValidation tests CORS configuration validation
+func TestCORSValidation(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Test invalid HTTP method
+	invalidMethodConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"INVALID_METHOD"},
+				AllowedOrigins: []string{"https://example.com"},
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: invalidMethodConfig,
+	})
+	assert.Error(t, err, "Should get error for invalid HTTP method")
+
+	// Test empty origins
+	emptyOriginsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET"},
+				AllowedOrigins: []string{},
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: emptyOriginsConfig,
+	})
+	assert.Error(t, err, "Should get error for empty origins")
+
+	// Test negative MaxAge
+	negativeMaxAgeConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET"},
+				AllowedOrigins: []string{"https://example.com"},
+				MaxAgeSeconds:  aws.Int32(-1),
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: negativeMaxAgeConfig,
+	})
+	assert.Error(t, err, "Should get error for negative MaxAge")
+}
+
+// TestCORSWithWildcards tests CORS configuration with wildcard patterns
+func TestCORSWithWildcards(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Create CORS configuration with wildcard patterns
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET", "POST"},
+				AllowedOrigins: []string{"https://*.example.com"},
+				ExposeHeaders:  []string{"*"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	require.NoError(t, err, "Should be able to put CORS configuration with wildcards")
+
+	// Wait for CORS configuration to be fully processed and available
+	time.Sleep(100 * time.Millisecond)
+
+	// Get and verify the configuration with retries for robustness
+	var getResp *s3.GetBucketCorsOutput
+	var getErr error
+
+	// Retry getting CORS config up to 3 times to handle timing issues
+	for i := 0; i < 3; i++ {
+		getResp, getErr = client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+			Bucket: aws.String(bucketName),
+		})
+		if getErr == nil {
+			break
+		}
+		t.Logf("Attempt %d: Failed to get CORS config: %v", i+1, getErr)
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	require.NoError(t, getErr, "Should be able to get CORS configuration after retries")
+	require.NotNil(t, getResp, "GetBucketCors response should not be nil")
+	require.Len(t, getResp.CORSRules, 1, "Should have one CORS rule")
+
+	rule := getResp.CORSRules[0]
+	require.NotNil(t, rule, "CORS rule should not be nil")
+	assert.Equal(t, []string{"*"}, rule.AllowedHeaders, "Wildcard headers should be preserved")
+	assert.Equal(t, []string{"https://*.example.com"}, rule.AllowedOrigins, "Wildcard origins should be preserved")
+	assert.Equal(t, []string{"*"}, rule.ExposeHeaders, "Wildcard expose headers should be preserved")
+}
+
+// TestCORSRuleLimit tests the maximum number of CORS rules
+func TestCORSRuleLimit(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Create CORS configuration with maximum allowed rules (100)
+	rules := make([]types.CORSRule, 100)
+	for i := 0; i < 100; i++ {
+		rules[i] = types.CORSRule{
+			AllowedHeaders: []string{"*"},
+			AllowedMethods: []string{"GET"},
+			AllowedOrigins: []string{fmt.Sprintf("https://example%d.com", i)},
+			MaxAgeSeconds:  aws.Int32(3600),
+		}
+	}
+
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: rules,
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	assert.NoError(t, err, "Should be able to put CORS configuration with 100 rules")
+
+	// Try to add one more rule (should fail)
+	rules = append(rules, types.CORSRule{
+		AllowedHeaders: []string{"*"},
+		AllowedMethods: []string{"GET"},
+		AllowedOrigins: []string{"https://example101.com"},
+		MaxAgeSeconds:  aws.Int32(3600),
+	})
+
+	corsConfig.CORSRules = rules
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	assert.Error(t, err, "Should get error when exceeding maximum number of rules")
+}
+
+// TestCORSNonExistentBucket tests CORS operations on non-existent bucket
+func TestCORSNonExistentBucket(t *testing.T) {
+	client := getS3Client(t)
+	nonExistentBucket := "non-existent-bucket-cors-test"
+
+	// Test Get CORS on non-existent bucket
+	_, err := client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+		Bucket: aws.String(nonExistentBucket),
+	})
+	assert.Error(t, err, "Should get error for non-existent bucket")
+
+	// Test Put CORS on non-existent bucket
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET"},
+				AllowedOrigins: []string{"https://example.com"},
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(nonExistentBucket),
+		CORSConfiguration: corsConfig,
+	})
+	assert.Error(t, err, "Should get error for non-existent bucket")
+
+	// Test Delete CORS on non-existent bucket
+	_, err = client.DeleteBucketCors(context.TODO(), &s3.DeleteBucketCorsInput{
+		Bucket: aws.String(nonExistentBucket),
+	})
+	assert.Error(t, err, "Should get error for non-existent bucket")
+}
+
+// TestCORSObjectOperations tests CORS behavior with object operations
+func TestCORSObjectOperations(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Set up CORS configuration
+	corsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"},
+				AllowedOrigins: []string{"https://example.com"},
+				ExposeHeaders:  []string{"ETag", "Content-Length"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig,
+	})
+	assert.NoError(t, err, "Should be able to put CORS configuration")
+
+	// Test putting an object (this should work normally)
+	objectKey := "test-object.txt"
+	objectContent := "Hello, CORS World!"
+
+	_, err = client.PutObject(context.TODO(), &s3.PutObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+		Body:   strings.NewReader(objectContent),
+	})
+	assert.NoError(t, err, "Should be able to put object in CORS-enabled bucket")
+
+	// Test getting the object
+	getResp, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	assert.NoError(t, err, "Should be able to get object from CORS-enabled bucket")
+	assert.NotNil(t, getResp.Body, "Object body should not be nil")
+
+	// Test deleting the object
+	_, err = client.DeleteObject(context.TODO(), &s3.DeleteObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	assert.NoError(t, err, "Should be able to delete object from CORS-enabled bucket")
+}
+
+// TestCORSCaching tests CORS configuration caching behavior
+func TestCORSCaching(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Set up initial CORS configuration
+	corsConfig1 := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{"GET"},
+				AllowedOrigins: []string{"https://example.com"},
+				MaxAgeSeconds:  aws.Int32(3600),
+			},
+		},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig1,
+	})
+	require.NoError(t, err, "Should be able to put initial CORS configuration")
+
+	// Get the configuration
+	getResp1, err := client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+		Bucket: aws.String(bucketName),
+	})
+	require.NoError(t, err, "Should be able to get initial CORS configuration")
+	require.Len(t, getResp1.CORSRules, 1, "Should have one CORS rule")
+
+	// Update the configuration
+	corsConfig2 := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"Content-Type"},
+				AllowedMethods: []string{"GET", "POST"},
+				AllowedOrigins: []string{"https://example.com", "https://another.com"},
+				MaxAgeSeconds:  aws.Int32(7200),
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: corsConfig2,
+	})
+	require.NoError(t, err, "Should be able to update CORS configuration")
+
+	// Get the updated configuration (should reflect the changes)
+	getResp2, err := client.GetBucketCors(context.TODO(), &s3.GetBucketCorsInput{
+		Bucket: aws.String(bucketName),
+	})
+	require.NoError(t, err, "Should be able to get updated CORS configuration")
+	require.Len(t, getResp2.CORSRules, 1, "Should have one CORS rule")
+
+	rule := getResp2.CORSRules[0]
+	assert.Equal(t, []string{"Content-Type"}, rule.AllowedHeaders, "Should have updated headers")
+	assert.Equal(t, []string{"GET", "POST"}, rule.AllowedMethods, "Should have updated methods")
+	assert.Equal(t, []string{"https://example.com", "https://another.com"}, rule.AllowedOrigins, "Should have updated origins")
+	assert.Equal(t, aws.Int32(7200), rule.MaxAgeSeconds, "Should have updated max age")
+}
+
+// TestCORSErrorHandling tests various error conditions
+func TestCORSErrorHandling(t *testing.T) {
+	client := getS3Client(t)
+	bucketName := createTestBucket(t, client)
+	defer cleanupTestBucket(t, client, bucketName)
+
+	// Test empty CORS configuration
+	emptyCorsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{},
+	}
+
+	_, err := client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: emptyCorsConfig,
+	})
+	assert.Error(t, err, "Should get error for empty CORS configuration")
+
+	// Test nil CORS configuration
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: nil,
+	})
+	assert.Error(t, err, "Should get error for nil CORS configuration")
+
+	// Test CORS rule with empty methods
+	emptyMethodsConfig := &types.CORSConfiguration{
+		CORSRules: []types.CORSRule{
+			{
+				AllowedHeaders: []string{"*"},
+				AllowedMethods: []string{},
+				AllowedOrigins: []string{"https://example.com"},
+			},
+		},
+	}
+
+	_, err = client.PutBucketCors(context.TODO(), &s3.PutBucketCorsInput{
+		Bucket:            aws.String(bucketName),
+		CORSConfiguration: emptyMethodsConfig,
+	})
+	assert.Error(t, err, "Should get error for empty methods")
+}
+
+// Debugging helper to pretty print responses
+func debugResponse(t *testing.T, title string, response interface{}) {
+	t.Logf("=== %s ===", title)
+	pp.Println(response)
+}

test/s3/cors/s3_test_config.json

@@ -0,0 +1,27 @@
+{
+    "identities": [
+        {
+            "name": "anonymous",
+            "actions": [
+                "Read",
+                "List"
+            ]
+        },
+        {
+            "name": "admin",
+            "credentials": [
+                {
+                    "accessKey": "some_access_key1",
+                    "secretKey": "some_secret_key1"
+                }
+            ],
+            "actions": [
+                "Admin",
+                "Read",
+                "List",
+                "Tagging",
+                "Write"
+            ]
+        }
+    ]
+}