test: add unit tests and integration tests for coverage

Unit tests:
- db/import_test.go: TestEscapeCopyValue (COPY format escaping)
- fuse/index_ddl_test.go: TestExtractColumnCandidates (index name parsing)
- nfs/filesystem_test.go: TestHasFormatExtension (format detection)

Integration tests:
- TestFormats_YAML, TestFormats_YAML_NULL
- TestMetadata_InfoSchema, InfoColumns, InfoCount, InfoDDL, InfoIndexes

Author: mfreed

README.md

@@ -29,7 +29,7 @@ The filesystem interface is simple and predictable. The database handles durabil
 ┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
 │  Unix Tools  │────▶│  Filesystem  │────▶│   TigerFS    │────▶│  PostgreSQL  │
 │  ls, cat,    │     │   Backend    │     │   Daemon     │     │   Database   │
-│  echo, rm    │◀────│ (FUSE/NFS)  │◀────│              │◀────│              │
+│  echo, rm    │◀────│ (FUSE/NFS)   │◀────│              │◀────│              │
 └──────────────┘     └──────────────┘     └──────────────┘     └──────────────┘
 ```
 

internal/tigerfs/db/import_test.go

@@ -0,0 +1,143 @@
+package db
+
+import "testing"
+
+// TestEscapeCopyValue tests the escapeCopyValue helper function
+// which escapes values for PostgreSQL COPY text format.
+func TestEscapeCopyValue(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    interface{}
+		expected string
+	}{
+		// Basic strings - no escaping needed
+		{
+			name:     "simple_string",
+			input:    "hello",
+			expected: "hello",
+		},
+		{
+			name:     "empty_string",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "string_with_spaces",
+			input:    "hello world",
+			expected: "hello world",
+		},
+
+		// Backslash escaping
+		{
+			name:     "single_backslash",
+			input:    `a\b`,
+			expected: `a\\b`,
+		},
+		{
+			name:     "multiple_backslashes",
+			input:    `a\\b`,
+			expected: `a\\\\b`,
+		},
+		{
+			name:     "backslash_at_end",
+			input:    `path\`,
+			expected: `path\\`,
+		},
+
+		// Newline escaping
+		{
+			name:     "newline",
+			input:    "line1\nline2",
+			expected: `line1\nline2`,
+		},
+		{
+			name:     "multiple_newlines",
+			input:    "a\nb\nc",
+			expected: `a\nb\nc`,
+		},
+
+		// Carriage return escaping
+		{
+			name:     "carriage_return",
+			input:    "line1\rline2",
+			expected: `line1\rline2`,
+		},
+		{
+			name:     "crlf",
+			input:    "line1\r\nline2",
+			expected: `line1\r\nline2`,
+		},
+
+		// Tab escaping
+		{
+			name:     "tab",
+			input:    "col1\tcol2",
+			expected: `col1\tcol2`,
+		},
+		{
+			name:     "multiple_tabs",
+			input:    "a\tb\tc",
+			expected: `a\tb\tc`,
+		},
+
+		// Combined special characters
+		{
+			name:     "all_special_chars",
+			input:    "a\\b\nc\rd\te",
+			expected: `a\\b\nc\rd\te`,
+		},
+		{
+			name:     "backslash_before_newline",
+			input:    "a\\\nb",
+			expected: `a\\\nb`,
+		},
+
+		// Non-string types (converted via fmt.Sprintf)
+		{
+			name:     "integer",
+			input:    42,
+			expected: "42",
+		},
+		{
+			name:     "float",
+			input:    3.14,
+			expected: "3.14",
+		},
+		{
+			name:     "boolean_true",
+			input:    true,
+			expected: "true",
+		},
+		{
+			name:     "boolean_false",
+			input:    false,
+			expected: "false",
+		},
+		{
+			name:     "nil",
+			input:    nil,
+			expected: "<nil>",
+		},
+
+		// Unicode - should pass through unchanged
+		{
+			name:     "unicode",
+			input:    "日本語",
+			expected: "日本語",
+		},
+		{
+			name:     "emoji",
+			input:    "hello 👋 world",
+			expected: "hello 👋 world",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := escapeCopyValue(tt.input)
+			if result != tt.expected {
+				t.Errorf("escapeCopyValue(%#v) = %q, want %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}

internal/tigerfs/fuse/index_ddl_test.go

@@ -542,3 +542,153 @@ func TestIndexCreateDirNode_Lookup(t *testing.T) {
 }
 
 // Note: contains helper is defined in control_files_test.go
+
+// TestExtractColumnCandidates tests the extractColumnCandidates helper function
+func TestExtractColumnCandidates(t *testing.T) {
+	tests := []struct {
+		name               string
+		indexName          string
+		tableName          string
+		hasTableNameColumn bool
+		expected           []string
+	}{
+		// Prefix patterns: idx_<column>, ix_<column>, index_<column>
+		{
+			name:      "idx_prefix",
+			indexName: "idx_email",
+			tableName: "users",
+			expected:  []string{"email"},
+		},
+		{
+			name:      "ix_prefix",
+			indexName: "ix_name",
+			tableName: "users",
+			expected:  []string{"name"},
+		},
+		{
+			name:      "index_prefix",
+			indexName: "index_status",
+			tableName: "orders",
+			expected:  []string{"status"},
+		},
+
+		// Suffix patterns: <column>_idx, <column>_ix, <column>_index
+		{
+			name:      "idx_suffix",
+			indexName: "email_idx",
+			tableName: "users",
+			expected:  []string{"email"},
+		},
+		{
+			name:      "ix_suffix",
+			indexName: "name_ix",
+			tableName: "users",
+			expected:  []string{"name"},
+		},
+		{
+			name:      "index_suffix",
+			indexName: "status_index",
+			tableName: "orders",
+			expected:  []string{"status"},
+		},
+
+		// Table prefix patterns: <table>_<column>_idx
+		{
+			name:      "table_column_idx",
+			indexName: "users_email_idx",
+			tableName: "users",
+			expected:  []string{"email"},
+		},
+		{
+			name:      "table_column_no_suffix",
+			indexName: "users_email",
+			tableName: "users",
+			expected:  []string{"email"},
+		},
+
+		// Table prefix disabled when column has same name as table
+		{
+			name:               "table_column_idx_with_table_name_column",
+			indexName:          "users_email_idx",
+			tableName:          "users",
+			hasTableNameColumn: true,
+			expected:           []string{}, // No inference when ambiguous
+		},
+
+		// Just the column name
+		{
+			name:      "bare_column_name",
+			indexName: "email",
+			tableName: "users",
+			expected:  []string{"email"},
+		},
+
+		// Edge cases - no match
+		{
+			name:      "underscore_in_column_prefix",
+			indexName: "idx_created_at",
+			tableName: "users",
+			expected:  []string{}, // Has underscore after prefix
+		},
+		{
+			name:      "underscore_in_column_suffix",
+			indexName: "created_at_idx",
+			tableName: "users",
+			expected:  []string{}, // Has underscore before suffix
+		},
+		{
+			name:      "empty_after_prefix",
+			indexName: "idx_",
+			tableName: "users",
+			expected:  []string{},
+		},
+		{
+			name:      "random_underscored_name",
+			indexName: "some_random_name",
+			tableName: "users",
+			expected:  []string{},
+		},
+
+		// Case insensitivity
+		{
+			name:      "uppercase_prefix",
+			indexName: "IDX_EMAIL",
+			tableName: "users",
+			expected:  []string{"email"},
+		},
+		{
+			name:      "mixed_case_table",
+			indexName: "Users_Status_idx",
+			tableName: "Users",
+			expected:  []string{"status"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := extractColumnCandidates(tt.indexName, tt.tableName, tt.hasTableNameColumn)
+
+			// Compare results
+			if len(result) != len(tt.expected) {
+				t.Errorf("extractColumnCandidates(%q, %q, %v) = %v, want %v",
+					tt.indexName, tt.tableName, tt.hasTableNameColumn, result, tt.expected)
+				return
+			}
+
+			// Check each expected value is present
+			for _, exp := range tt.expected {
+				found := false
+				for _, got := range result {
+					if got == exp {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Errorf("extractColumnCandidates(%q, %q, %v) = %v, missing %q",
+						tt.indexName, tt.tableName, tt.hasTableNameColumn, result, exp)
+				}
+			}
+		})
+	}
+}

internal/tigerfs/nfs/filesystem_test.go

@@ -0,0 +1,50 @@
+package nfs
+
+import "testing"
+
+// TestHasFormatExtension tests the hasFormatExtension helper function
+func TestHasFormatExtension(t *testing.T) {
+	tests := []struct {
+		name     string
+		filename string
+		expected bool
+	}{
+		// Valid format extensions
+		{"csv_extension", "123.csv", true},
+		{"json_extension", "123.json", true},
+		{"tsv_extension", "123.tsv", true},
+		{"yaml_extension", "123.yaml", true},
+
+		// No extension
+		{"no_extension", "123", false},
+		{"directory_name", "users", false},
+
+		// Non-format extensions
+		{"txt_extension", "file.txt", false},
+		{"bin_extension", "data.bin", false},
+		{"sql_extension", "query.sql", false},
+		{"md_extension", "readme.md", false},
+
+		// Edge cases
+		{"empty_string", "", false},
+		{"dot_only", ".", false},
+		{"hidden_file", ".json", true}, // .json is the extension
+		{"double_extension", "file.tar.json", true},
+		{"uppercase_ignored", "123.JSON", false}, // case sensitive
+		{"uppercase_csv", "123.CSV", false},
+
+		// Primary key values that might look like extensions
+		{"pk_with_dot", "user.name", false},
+		{"uuid_style", "550e8400-e29b-41d4-a716-446655440000", false},
+		{"numeric", "12345", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := hasFormatExtension(tt.filename)
+			if result != tt.expected {
+				t.Errorf("hasFormatExtension(%q) = %v, want %v", tt.filename, result, tt.expected)
+			}
+		})
+	}
+}