connection_string_test.go

package minisql

import (
	"encoding/hex"
	"testing"
	"time"

	"github.com/RichardKnop/minisql/internal/minisql"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestParseConnectionString(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name        string
		connStr     string
		wantConfig  *ConnectionConfig
		wantErr     bool
		errContains string
	}{
		{
			name:    "simple path",
			connStr: "./test.db",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "set log level",
			connStr: "./test.db?log_level=debug",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "debug",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "set max cached pages",
			connStr: "./test.db?max_cached_pages=500",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         500,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "custom checkpoint threshold",
			connStr: "./test.db?wal_checkpoint_threshold=500",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: 500,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "custom write buffer size",
			connStr: "./test.db?wal_write_buffer_size=131072",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     131072,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "zero write buffer size disables batching",
			connStr: "./test.db?wal_write_buffer_size=0",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     0,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "all parameters",
			connStr: "./test.db?wal_checkpoint_threshold=200&log_level=info&max_cached_pages=4000&slow_query_threshold=75ms",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: 200,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "info",
				MaxCachedPages:         4000,
				SlowQueryThreshold:     75 * time.Millisecond,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "zero checkpoint threshold disables auto-checkpoint",
			connStr: "./test.db?wal_checkpoint_threshold=0",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: 0,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "synchronous=full",
			connStr: "./test.db?synchronous=full",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousFull,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "synchronous=normal explicit",
			connStr: "./test.db?synchronous=normal",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "synchronous=off",
			connStr: "./test.db?synchronous=off",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousOff,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:        "invalid wal_checkpoint_threshold - negative",
			connStr:     "./test.db?wal_checkpoint_threshold=-1",
			wantErr:     true,
			errContains: "invalid wal_checkpoint_threshold",
		},
		{
			name:        "invalid wal_checkpoint_threshold - not a number",
			connStr:     "./test.db?wal_checkpoint_threshold=abc",
			wantErr:     true,
			errContains: "invalid wal_checkpoint_threshold",
		},
		{
			name:        "invalid wal_write_buffer_size - negative",
			connStr:     "./test.db?wal_write_buffer_size=-1",
			wantErr:     true,
			errContains: "invalid wal_write_buffer_size",
		},
		{
			name:        "invalid wal_write_buffer_size - not a number",
			connStr:     "./test.db?wal_write_buffer_size=abc",
			wantErr:     true,
			errContains: "invalid wal_write_buffer_size",
		},
		{
			name:        "invalid max_cached_pages - negative",
			connStr:     "./test.db?max_cached_pages=-100",
			wantErr:     true,
			errContains: "must be a non-negative integer",
		},
		{
			name:        "invalid max_cached_pages - not a number",
			connStr:     "./test.db?max_cached_pages=abc",
			wantErr:     true,
			errContains: "must be a non-negative integer",
		},
		{
			name:        "invalid log level",
			connStr:     "./test.db?log_level=verbose",
			wantErr:     true,
			errContains: "invalid log_level parameter",
		},
		{
			name:        "invalid slow query threshold",
			connStr:     "./test.db?slow_query_threshold=soon",
			wantErr:     true,
			errContains: "invalid slow_query_threshold parameter",
		},
		{
			name:        "negative slow query threshold",
			connStr:     "./test.db?slow_query_threshold=-1ms",
			wantErr:     true,
			errContains: "invalid slow_query_threshold parameter",
		},
		{
			name:        "invalid synchronous value",
			connStr:     "./test.db?synchronous=extra",
			wantErr:     true,
			errContains: "invalid synchronous parameter",
		},
		{
			name:    "parallel_scan=on",
			connStr: "./test.db?parallel_scan=on",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				ParallelScan:           true,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "parallel_scan=off explicit",
			connStr: "./test.db?parallel_scan=off",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				ParallelScan:           false,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:        "invalid parallel_scan value",
			connStr:     "./test.db?parallel_scan=maybe",
			wantErr:     true,
			errContains: "invalid parallel_scan parameter",
		},
		{
			name:    "encryption_key set",
			connStr: "./test.db?encryption_key=" + hex.EncodeToString([]byte("my-secret-key-32bytes-long-paddd")),
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				EncryptionKey:          []byte("my-secret-key-32bytes-long-paddd"),
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:        "invalid encryption_key (not hex)",
			connStr:     "./test.db?encryption_key=not-hex!!",
			wantErr:     true,
			errContains: "invalid encryption_key parameter",
		},
		{
			name:    "sort_mem_limit=1048576",
			connStr: "./test.db?sort_mem_limit=1048576",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           1048576,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:    "sort_mem_limit=0 disables external sort",
			connStr: "./test.db?sort_mem_limit=0",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           0,
				HNSWVecCacheSize:       DefaultHNSWVecCacheSize,
			},
			wantErr: false,
		},
		{
			name:        "invalid sort_mem_limit - negative",
			connStr:     "./test.db?sort_mem_limit=-1",
			wantErr:     true,
			errContains: "invalid sort_mem_limit parameter",
		},
		{
			name:        "invalid sort_mem_limit - not a number",
			connStr:     "./test.db?sort_mem_limit=big",
			wantErr:     true,
			errContains: "invalid sort_mem_limit parameter",
		},
		{
			name:        "sort_mem_limit exceeds maximum",
			connStr:     "./test.db?sort_mem_limit=3221225472",
			wantErr:     true,
			errContains: "exceeds maximum of 2 GiB",
		},
		{
			name:    "hnsw_vec_cache_size=512",
			connStr: "./test.db?hnsw_vec_cache_size=512",
			wantConfig: &ConnectionConfig{
				FilePath:               "./test.db",
				WALCheckpointThreshold: DefaultWALCheckpointThreshold,
				WALWriteBufferSize:     DefaultWALWriteBufferSize,
				LogLevel:               "warn",
				MaxCachedPages:         minisql.PageCacheSize,
				Synchronous:            SynchronousNormal,
				SortMemLimit:           DefaultSortMemLimit,
				HNSWVecCacheSize:       512,
			},
			wantErr: false,
		},
		{
			name:        "invalid hnsw_vec_cache_size - zero",
			connStr:     "./test.db?hnsw_vec_cache_size=0",
			wantErr:     true,
			errContains: "invalid hnsw_vec_cache_size parameter",
		},
		{
			name:        "invalid hnsw_vec_cache_size - negative",
			connStr:     "./test.db?hnsw_vec_cache_size=-1",
			wantErr:     true,
			errContains: "invalid hnsw_vec_cache_size parameter",
		},
		{
			name:        "invalid hnsw_vec_cache_size - not a number",
			connStr:     "./test.db?hnsw_vec_cache_size=big",
			wantErr:     true,
			errContains: "invalid hnsw_vec_cache_size parameter",
		},
		{
			name:        "wal_write_buffer_size exceeds maximum",
			connStr:     "./test.db?wal_write_buffer_size=268435457",
			wantErr:     true,
			errContains: "exceeds maximum of 256 MiB",
		},
		{
			name:        "encryption_key too short",
			connStr:     "./test.db?encryption_key=" + hex.EncodeToString([]byte("tooshort")),
			wantErr:     true,
			errContains: "key too short",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			config, err := ParseConnectionString(tt.connStr)

			if tt.wantErr {
				require.Error(t, err)
				if tt.errContains != "" {
					assert.Contains(t, err.Error(), tt.errContains)
				}
				return
			}

			require.NoError(t, err)
			assert.Equal(t, tt.wantConfig, config)
		})
	}
}

func TestGetZapLevel(t *testing.T) {
	t.Parallel()

	tests := []struct {
		level    string
		wantName string
	}{
		{"debug", "debug"},
		{"info", "info"},
		{"warn", "warn"},
		{"error", "error"},
		{"unknown", "warn"}, // default falls back to warn
		{"", "warn"},        // empty string → default warn
	}

	for _, tt := range tests {
		t.Run(tt.level, func(t *testing.T) {
			t.Parallel()
			cfg := &ConnectionConfig{LogLevel: tt.level}
			got := cfg.GetZapLevel()
			assert.Equal(t, tt.wantName, got.String())
		})
	}
}