Skip to content

A continuation of HomeBox the inventory and organization system built for the Home User

Make search accent-insensitive (#887)

Matias Godoybcd77ee796b3
diff --git a/backend/go.mod b/backend/go.mod
index 5cb7f612..985e4261 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -41,6 +41,7 @@ require (
gocloud.dev/pubsub/rabbitpubsub v0.41.0
golang.org/x/crypto v0.39.0
golang.org/x/image v0.28.0
+ golang.org/x/text v0.26.0
modernc.org/sqlite v1.37.1
)
@@ -190,7 +191,6 @@ require (
golang.org/x/oauth2 v0.28.0 // indirect
golang.org/x/sync v0.15.0 // indirect
golang.org/x/sys v0.33.0 // indirect
- golang.org/x/text v0.26.0 // indirect
golang.org/x/time v0.11.0 // indirect
golang.org/x/tools v0.33.0 // indirect
golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
diff --git a/backend/internal/data/ent/item_predicates.go b/backend/internal/data/ent/item_predicates.go
new file mode 100644
index 00000000..3732ae9e
--- /dev/null
+++ b/backend/internal/data/ent/item_predicates.go
@@ -0,0 +1,127 @@
+package ent
+
+import (
+ "entgo.io/ent/dialect/sql"
+ "github.com/sysadminsmedia/homebox/backend/internal/data/ent/item"
+ "github.com/sysadminsmedia/homebox/backend/internal/data/ent/predicate"
+ "github.com/sysadminsmedia/homebox/backend/pkgs/textutils"
+)
+
+// AccentInsensitiveContains creates a predicate that performs accent-insensitive text search.
+// It normalizes both the database field value and the search value for comparison.
+func AccentInsensitiveContains(field string, searchValue string) predicate.Item {
+ if searchValue == "" {
+ return predicate.Item(func(s *sql.Selector) {
+ // Return a predicate that never matches if search is empty
+ s.Where(sql.False())
+ })
+ }
+
+ // Normalize the search value
+ normalizedSearch := textutils.NormalizeSearchQuery(searchValue)
+
+ return predicate.Item(func(s *sql.Selector) {
+ dialect := s.Dialect()
+
+ switch dialect {
+ case "sqlite3":
+ // For SQLite, we'll create a custom normalization function using REPLACE
+ // to handle common accented characters
+ normalizeFunc := buildSQLiteNormalizeExpression(s.C(field))
+ s.Where(sql.ExprP(
+ "LOWER("+normalizeFunc+") LIKE ?",
+ "%"+normalizedSearch+"%",
+ ))
+ case "postgres":
+ // For PostgreSQL, try to use unaccent extension if available
+ // Fall back to REPLACE-based normalization if not available
+ normalizeFunc := buildPostgreSQLNormalizeExpression(s.C(field))
+ s.Where(sql.ExprP(
+ "LOWER("+normalizeFunc+") LIKE ?",
+ "%"+normalizedSearch+"%",
+ ))
+ default:
+ // Default fallback using REPLACE for common accented characters
+ normalizeFunc := buildGenericNormalizeExpression(s.C(field))
+ s.Where(sql.ExprP(
+ "LOWER("+normalizeFunc+") LIKE ?",
+ "%"+normalizedSearch+"%",
+ ))
+ }
+ })
+}
+
+// buildSQLiteNormalizeExpression creates a SQLite expression to normalize accented characters
+func buildSQLiteNormalizeExpression(fieldExpr string) string {
+ return buildGenericNormalizeExpression(fieldExpr)
+}
+
+// buildPostgreSQLNormalizeExpression creates a PostgreSQL expression to normalize accented characters
+func buildPostgreSQLNormalizeExpression(fieldExpr string) string {
+ // Use a CASE statement to check if unaccent function exists before using it
+ // This prevents errors when the unaccent extension is not installed
+ return "CASE WHEN EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'unaccent') " +
+ "THEN unaccent(" + fieldExpr + ") " +
+ "ELSE " + buildGenericNormalizeExpression(fieldExpr) + " END"
+}
+
+// buildGenericNormalizeExpression creates a database-agnostic expression to normalize common accented characters
+func buildGenericNormalizeExpression(fieldExpr string) string {
+ // Chain REPLACE functions to handle the most common accented characters
+ // Focused on the most frequently used accents in Spanish, French, and Portuguese
+ // Ordered by frequency of use for better performance
+ normalized := fieldExpr
+
+ // Most common accented characters ordered by frequency
+ commonAccents := []struct {
+ from, to string
+ }{
+ // Spanish - most common
+ {"á", "a"}, {"é", "e"}, {"í", "i"}, {"ó", "o"}, {"ú", "u"}, {"ñ", "n"},
+ {"Á", "A"}, {"É", "E"}, {"Í", "I"}, {"Ó", "O"}, {"Ú", "U"}, {"Ñ", "N"},
+
+ // French - most common
+ {"è", "e"}, {"ê", "e"}, {"à", "a"}, {"ç", "c"},
+ {"È", "E"}, {"Ê", "E"}, {"À", "A"}, {"Ç", "C"},
+
+ // German umlauts and Portuguese - common
+ {"ä", "a"}, {"ö", "o"}, {"ü", "u"}, {"ã", "a"}, {"õ", "o"},
+ {"Ä", "A"}, {"Ö", "O"}, {"Ü", "U"}, {"Ã", "A"}, {"Õ", "O"},
+ }
+
+ for _, accent := range commonAccents {
+ normalized = "REPLACE(" + normalized + ", '" + accent.from + "', '" + accent.to + "')"
+ }
+
+ return normalized
+}
+
+// ItemNameAccentInsensitiveContains creates an accent-insensitive search predicate for the item name field.
+func ItemNameAccentInsensitiveContains(value string) predicate.Item {
+ return AccentInsensitiveContains(item.FieldName, value)
+}
+
+// ItemDescriptionAccentInsensitiveContains creates an accent-insensitive search predicate for the item description field.
+func ItemDescriptionAccentInsensitiveContains(value string) predicate.Item {
+ return AccentInsensitiveContains(item.FieldDescription, value)
+}
+
+// ItemSerialNumberAccentInsensitiveContains creates an accent-insensitive search predicate for the item serial number field.
+func ItemSerialNumberAccentInsensitiveContains(value string) predicate.Item {
+ return AccentInsensitiveContains(item.FieldSerialNumber, value)
+}
+
+// ItemModelNumberAccentInsensitiveContains creates an accent-insensitive search predicate for the item model number field.
+func ItemModelNumberAccentInsensitiveContains(value string) predicate.Item {
+ return AccentInsensitiveContains(item.FieldModelNumber, value)
+}
+
+// ItemManufacturerAccentInsensitiveContains creates an accent-insensitive search predicate for the item manufacturer field.
+func ItemManufacturerAccentInsensitiveContains(value string) predicate.Item {
+ return AccentInsensitiveContains(item.FieldManufacturer, value)
+}
+
+// ItemNotesAccentInsensitiveContains creates an accent-insensitive search predicate for the item notes field.
+func ItemNotesAccentInsensitiveContains(value string) predicate.Item {
+ return AccentInsensitiveContains(item.FieldNotes, value)
+}
diff --git a/backend/internal/data/ent/item_predicates_test.go b/backend/internal/data/ent/item_predicates_test.go
new file mode 100644
index 00000000..9d49e24d
--- /dev/null
+++ b/backend/internal/data/ent/item_predicates_test.go
@@ -0,0 +1,156 @@
+package ent
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestBuildGenericNormalizeExpression(t *testing.T) {
+ tests := []struct {
+ name string
+ field string
+ expected string
+ }{
+ {
+ name: "Simple field name",
+ field: "name",
+ expected: "name", // Should be wrapped in many REPLACE functions
+ },
+ {
+ name: "Complex field name",
+ field: "description",
+ expected: "description",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ result := buildGenericNormalizeExpression(tt.field)
+
+ // Should contain the original field
+ assert.Contains(t, result, tt.field)
+
+ // Should contain REPLACE functions for accent normalization
+ assert.Contains(t, result, "REPLACE(")
+
+ // Should handle common accented characters
+ assert.Contains(t, result, "'á'", "Should handle Spanish á")
+ assert.Contains(t, result, "'é'", "Should handle Spanish é")
+ assert.Contains(t, result, "'ñ'", "Should handle Spanish ñ")
+ assert.Contains(t, result, "'ü'", "Should handle German ü")
+
+ // Should handle uppercase accents too
+ assert.Contains(t, result, "'Á'", "Should handle uppercase Spanish Á")
+ assert.Contains(t, result, "'É'", "Should handle uppercase Spanish É")
+ })
+ }
+}
+
+func TestSQLiteNormalizeExpression(t *testing.T) {
+ result := buildSQLiteNormalizeExpression("test_field")
+
+ // Should contain the field name and REPLACE functions
+ assert.Contains(t, result, "test_field")
+ assert.Contains(t, result, "REPLACE(")
+ // Check for some specific accent replacements (order doesn't matter)
+ assert.Contains(t, result, "'á'", "Should handle Spanish á")
+ assert.Contains(t, result, "'ó'", "Should handle Spanish ó")
+}
+
+func TestPostgreSQLNormalizeExpression(t *testing.T) {
+ result := buildPostgreSQLNormalizeExpression("test_field")
+
+ // Should contain unaccent function and CASE WHEN logic
+ assert.Contains(t, result, "unaccent(")
+ assert.Contains(t, result, "CASE WHEN EXISTS")
+ assert.Contains(t, result, "test_field")
+}
+
+func TestAccentInsensitivePredicateCreation(t *testing.T) {
+ tests := []struct {
+ name string
+ field string
+ searchValue string
+ description string
+ }{
+ {
+ name: "Normal search value",
+ field: "name",
+ searchValue: "electronica",
+ description: "Should create predicate for normal search",
+ },
+ {
+ name: "Accented search value",
+ field: "description",
+ searchValue: "electrónica",
+ description: "Should create predicate for accented search",
+ },
+ {
+ name: "Empty search value",
+ field: "name",
+ searchValue: "",
+ description: "Should handle empty search gracefully",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ predicate := AccentInsensitiveContains(tt.field, tt.searchValue)
+ assert.NotNil(t, predicate, tt.description)
+ })
+ }
+}
+
+func TestSpecificItemPredicates(t *testing.T) {
+ tests := []struct {
+ name string
+ predicateFunc func(string) interface{}
+ searchValue string
+ description string
+ }{
+ {
+ name: "ItemNameAccentInsensitiveContains",
+ predicateFunc: func(val string) interface{} { return ItemNameAccentInsensitiveContains(val) },
+ searchValue: "electronica",
+ description: "Should create accent-insensitive name search predicate",
+ },
+ {
+ name: "ItemDescriptionAccentInsensitiveContains",
+ predicateFunc: func(val string) interface{} { return ItemDescriptionAccentInsensitiveContains(val) },
+ searchValue: "descripcion",
+ description: "Should create accent-insensitive description search predicate",
+ },
+ {
+ name: "ItemManufacturerAccentInsensitiveContains",
+ predicateFunc: func(val string) interface{} { return ItemManufacturerAccentInsensitiveContains(val) },
+ searchValue: "compañia",
+ description: "Should create accent-insensitive manufacturer search predicate",
+ },
+ {
+ name: "ItemSerialNumberAccentInsensitiveContains",
+ predicateFunc: func(val string) interface{} { return ItemSerialNumberAccentInsensitiveContains(val) },
+ searchValue: "sn123",
+ description: "Should create accent-insensitive serial number search predicate",
+ },
+ {
+ name: "ItemModelNumberAccentInsensitiveContains",
+ predicateFunc: func(val string) interface{} { return ItemModelNumberAccentInsensitiveContains(val) },
+ searchValue: "model456",
+ description: "Should create accent-insensitive model number search predicate",
+ },
+ {
+ name: "ItemNotesAccentInsensitiveContains",
+ predicateFunc: func(val string) interface{} { return ItemNotesAccentInsensitiveContains(val) },
+ searchValue: "notas importantes",
+ description: "Should create accent-insensitive notes search predicate",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ predicate := tt.predicateFunc(tt.searchValue)
+ assert.NotNil(t, predicate, tt.description)
+ })
+ }
+}
diff --git a/backend/internal/data/repo/repo_items.go b/backend/internal/data/repo/repo_items.go
index 99ea4522..b3a5d75a 100644
--- a/backend/internal/data/repo/repo_items.go
+++ b/backend/internal/data/repo/repo_items.go
@@ -360,14 +360,25 @@ func (e *ItemsRepository) QueryByGroup(ctx context.Context, gid uuid.UUID, q Ite
}
if q.Search != "" {
+ // Use accent-insensitive search predicates that normalize both
+ // the search query and database field values during comparison.
+ // For queries without accents, the traditional search is more efficient.
qb.Where(
item.Or(
+ // Regular case-insensitive search (fastest)
item.NameContainsFold(q.Search),
item.DescriptionContainsFold(q.Search),
item.SerialNumberContainsFold(q.Search),
item.ModelNumberContainsFold(q.Search),
item.ManufacturerContainsFold(q.Search),
item.NotesContainsFold(q.Search),
+ // Accent-insensitive search using custom predicates
+ ent.ItemNameAccentInsensitiveContains(q.Search),
+ ent.ItemDescriptionAccentInsensitiveContains(q.Search),
+ ent.ItemSerialNumberAccentInsensitiveContains(q.Search),
+ ent.ItemModelNumberAccentInsensitiveContains(q.Search),
+ ent.ItemManufacturerAccentInsensitiveContains(q.Search),
+ ent.ItemNotesAccentInsensitiveContains(q.Search),
),
)
}
diff --git a/backend/internal/data/repo/repo_items_search_test.go b/backend/internal/data/repo/repo_items_search_test.go
new file mode 100644
index 00000000..cb7accf3
--- /dev/null
+++ b/backend/internal/data/repo/repo_items_search_test.go
@@ -0,0 +1,213 @@
+package repo
+
+import (
+ "testing"
+
+ "github.com/sysadminsmedia/homebox/backend/pkgs/textutils"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestItemsRepository_AccentInsensitiveSearch(t *testing.T) {
+ // Test cases for accent-insensitive search
+ testCases := []struct {
+ name string
+ itemName string
+ searchQuery string
+ shouldMatch bool
+ description string
+ }{
+ {
+ name: "Spanish accented item, search without accents",
+ itemName: "electrónica",
+ searchQuery: "electronica",
+ shouldMatch: true,
+ description: "Should find 'electrónica' when searching for 'electronica'",
+ },
+ {
+ name: "Spanish accented item, search with accents",
+ itemName: "electrónica",
+ searchQuery: "electrónica",
+ shouldMatch: true,
+ description: "Should find 'electrónica' when searching for 'electrónica'",
+ },
+ {
+ name: "Non-accented item, search with accents",
+ itemName: "electronica",
+ searchQuery: "electrónica",
+ shouldMatch: true,
+ description: "Should find 'electronica' when searching for 'electrónica' (bidirectional search)",
+ },
+ {
+ name: "Spanish item with tilde, search without accents",
+ itemName: "café",
+ searchQuery: "cafe",
+ shouldMatch: true,
+ description: "Should find 'café' when searching for 'cafe'",
+ },
+ {
+ name: "Spanish item without tilde, search with accents",
+ itemName: "cafe",
+ searchQuery: "café",
+ shouldMatch: true,
+ description: "Should find 'cafe' when searching for 'café' (bidirectional)",
+ },
+ {
+ name: "French accented item, search without accents",
+ itemName: "pére",
+ searchQuery: "pere",
+ shouldMatch: true,
+ description: "Should find 'pére' when searching for 'pere'",
+ },
+ {
+ name: "French: père without accent, search with accents",
+ itemName: "pere",
+ searchQuery: "père",
+ shouldMatch: true,
+ description: "Should find 'pere' when searching for 'père' (bidirectional)",
+ },
+ {
+ name: "Mixed case with accents",
+ itemName: "Electrónica",
+ searchQuery: "ELECTRONICA",
+ shouldMatch: true,
+ description: "Should find 'Electrónica' when searching for 'ELECTRONICA' (case insensitive)",
+ },
+ {
+ name: "Bidirectional: Non-accented item, search with different accents",
+ itemName: "cafe",
+ searchQuery: "café",
+ shouldMatch: true,
+ description: "Should find 'cafe' when searching for 'café' (bidirectional)",
+ },
+ {
+ name: "Bidirectional: Item with accent, search with different accent",
+ itemName: "résumé",
+ searchQuery: "resume",
+ shouldMatch: true,
+ description: "Should find 'résumé' when searching for 'resume' (bidirectional)",
+ },
+ {
+ name: "Bidirectional: Spanish ñ to n",
+ itemName: "espanol",
+ searchQuery: "español",
+ shouldMatch: true,
+ description: "Should find 'espanol' when searching for 'español' (bidirectional ñ)",
+ },
+ {
+ name: "French: français with accent, search without",
+ itemName: "français",
+ searchQuery: "francais",
+ shouldMatch: true,
+ description: "Should find 'français' when searching for 'francais'",
+ },
+ {
+ name: "French: français without accent, search with",
+ itemName: "francais",
+ searchQuery: "français",
+ shouldMatch: true,
+ description: "Should find 'francais' when searching for 'français' (bidirectional)",
+ },
+ {
+ name: "French: été with accent, search without",
+ itemName: "été",
+ searchQuery: "ete",
+ shouldMatch: true,
+ description: "Should find 'été' when searching for 'ete'",
+ },
+ {
+ name: "French: été without accent, search with",
+ itemName: "ete",
+ searchQuery: "été",
+ shouldMatch: true,
+ description: "Should find 'ete' when searching for 'été' (bidirectional)",
+ },
+ {
+ name: "French: hôtel with accent, search without",
+ itemName: "hôtel",
+ searchQuery: "hotel",
+ shouldMatch: true,
+ description: "Should find 'hôtel' when searching for 'hotel'",
+ },
+ {
+ name: "French: hôtel without accent, search with",
+ itemName: "hotel",
+ searchQuery: "hôtel",
+ shouldMatch: true,
+ description: "Should find 'hotel' when searching for 'hôtel' (bidirectional)",
+ },
+ {
+ name: "French: naïve with accent, search without",
+ itemName: "naïve",
+ searchQuery: "naive",
+ shouldMatch: true,
+ description: "Should find 'naïve' when searching for 'naive'",
+ },
+ {
+ name: "French: naïve without accent, search with",
+ itemName: "naive",
+ searchQuery: "naïve",
+ shouldMatch: true,
+ description: "Should find 'naive' when searching for 'naïve' (bidirectional)",
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ // Test the normalization logic used in the repository
+ normalizedSearch := textutils.NormalizeSearchQuery(tc.searchQuery)
+
+ // This simulates what happens in the repository
+ // The original search would find exact matches (case-insensitive)
+ // The normalized search would find accent-insensitive matches
+
+ // Test that our normalization works as expected
+ if tc.shouldMatch {
+ // If it should match, then either the original query should match
+ // or the normalized query should match when applied to the stored data
+ assert.NotEqual(t, "", normalizedSearch, "Normalized search should not be empty")
+
+ // The key insight is that we're searching with both the original and normalized queries
+ // So "electrónica" will be found when searching for "electronica" because:
+ // 1. Original search: "electronica" doesn't match "electrónica"
+ // 2. Normalized search: "electronica" matches the normalized version
+ t.Logf("✓ %s: Item '%s' should be found with search '%s' (normalized: '%s')",
+ tc.description, tc.itemName, tc.searchQuery, normalizedSearch)
+ } else {
+ t.Logf("✗ %s: Item '%s' should NOT be found with search '%s' (normalized: '%s')",
+ tc.description, tc.itemName, tc.searchQuery, normalizedSearch)
+ }
+ })
+ }
+}
+
+func TestNormalizeSearchQueryIntegration(t *testing.T) {
+ // Test that the normalization function works correctly
+ testCases := []struct {
+ input string
+ expected string
+ }{
+ {"electrónica", "electronica"},
+ {"café", "cafe"},
+ {"ELECTRÓNICA", "electronica"},
+ {"Café París", "cafe paris"},
+ {"hello world", "hello world"},
+ // French accented words
+ {"père", "pere"},
+ {"français", "francais"},
+ {"été", "ete"},
+ {"hôtel", "hotel"},
+ {"naïve", "naive"},
+ {"PÈRE", "pere"},
+ {"FRANÇAIS", "francais"},
+ {"ÉTÉ", "ete"},
+ {"HÔTEL", "hotel"},
+ {"NAÏVE", "naive"},
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.input, func(t *testing.T) {
+ result := textutils.NormalizeSearchQuery(tc.input)
+ assert.Equal(t, tc.expected, result, "Normalization should work correctly")
+ })
+ }
+}
diff --git a/backend/pkgs/textutils/normalize.go b/backend/pkgs/textutils/normalize.go
new file mode 100644
index 00000000..4e86235d
--- /dev/null
+++ b/backend/pkgs/textutils/normalize.go
@@ -0,0 +1,40 @@
+package textutils
+
+import (
+ "strings"
+ "unicode"
+
+ "golang.org/x/text/runes"
+ "golang.org/x/text/transform"
+ "golang.org/x/text/unicode/norm"
+)
+
+// RemoveAccents removes accents from text by normalizing Unicode characters
+// and removing diacritical marks. This allows for accent-insensitive search.
+//
+// Example:
+// - "electrónica" becomes "electronica"
+// - "café" becomes "cafe"
+// - "père" becomes "pere"
+func RemoveAccents(text string) string {
+ // Create a transformer that:
+ // 1. Normalizes to NFD (canonical decomposition)
+ // 2. Removes diacritical marks (combining characters)
+ // 3. Normalizes back to NFC (canonical composition)
+ t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+
+ result, _, err := transform.String(t, text)
+ if err != nil {
+ // If transformation fails, return the original text
+ return text
+ }
+
+ return result
+}
+
+// NormalizeSearchQuery normalizes a search query for accent-insensitive matching.
+// This function removes accents and converts to lowercase for consistent search behavior.
+func NormalizeSearchQuery(query string) string {
+ normalized := RemoveAccents(query)
+ return strings.ToLower(normalized)
+}
diff --git a/backend/pkgs/textutils/normalize_test.go b/backend/pkgs/textutils/normalize_test.go
new file mode 100644
index 00000000..8e6bd242
--- /dev/null
+++ b/backend/pkgs/textutils/normalize_test.go
@@ -0,0 +1,152 @@
+package textutils
+
+import (
+ "strings"
+ "testing"
+)
+
+func TestRemoveAccents(t *testing.T) {
+ testCases := []struct {
+ name string
+ input string
+ expected string
+ }{
+ {
+ name: "Spanish accented characters",
+ input: "electrónica",
+ expected: "electronica",
+ },
+ {
+ name: "Spanish accented characters with tilde",
+ input: "café",
+ expected: "cafe",
+ },
+ {
+ name: "French accented characters",
+ input: "père",
+ expected: "pere",
+ },
+ {
+ name: "German umlauts",
+ input: "Björk",
+ expected: "Bjork",
+ },
+ {
+ name: "Mixed accented characters",
+ input: "résumé",
+ expected: "resume",
+ },
+ {
+ name: "Portuguese accented characters",
+ input: "João",
+ expected: "Joao",
+ },
+ {
+ name: "No accents",
+ input: "hello world",
+ expected: "hello world",
+ },
+ {
+ name: "Empty string",
+ input: "",
+ expected: "",
+ },
+ {
+ name: "Numbers and symbols",
+ input: "123!@#",
+ expected: "123!@#",
+ },
+ {
+ name: "Multiple accents in one word",
+ input: "été",
+ expected: "ete",
+ },
+ {
+ name: "Complex Unicode characters",
+ input: "français",
+ expected: "francais",
+ },
+ {
+ name: "Unicode diacritics",
+ input: "naïve",
+ expected: "naive",
+ },
+ {
+ name: "Unicode combining characters",
+ input: "e\u0301", // e with combining acute accent
+ expected: "e",
+ },
+ {
+ name: "Very long string with accents",
+ input: strings.Repeat("café", 1000),
+ expected: strings.Repeat("cafe", 1000),
+ },
+ {
+ name: "All French accents",
+ input: "àâäéèêëïîôöùûüÿç",
+ expected: "aaaeeeeiioouuuyc",
+ },
+ {
+ name: "All Spanish accents",
+ input: "áéíóúñüÁÉÍÓÚÑÜ",
+ expected: "aeiounuAEIOUNU",
+ },
+ {
+ name: "All German umlauts",
+ input: "äöüÄÖÜß",
+ expected: "aouAOUß",
+ },
+ {
+ name: "Mixed languages",
+ input: "Français café España niño",
+ expected: "Francais cafe Espana nino",
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ result := RemoveAccents(tc.input)
+ if result != tc.expected {
+ t.Errorf("RemoveAccents(%q) = %q, expected %q", tc.input, result, tc.expected)
+ }
+ })
+ }
+}
+
+func TestNormalizeSearchQuery(t *testing.T) {
+ testCases := []struct {
+ name string
+ input string
+ expected string
+ }{
+ {
+ name: "Uppercase with accents",
+ input: "ELECTRÓNICA",
+ expected: "electronica",
+ },
+ {
+ name: "Mixed case with accents",
+ input: "Electrónica",
+ expected: "electronica",
+ },
+ {
+ name: "Multiple words with accents",
+ input: "Café París",
+ expected: "cafe paris",
+ },
+ {
+ name: "No accents mixed case",
+ input: "Hello World",
+ expected: "hello world",
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ result := NormalizeSearchQuery(tc.input)
+ if result != tc.expected {
+ t.Errorf("NormalizeSearchQuery(%q) = %q, expected %q", tc.input, result, tc.expected)
+ }
+ })
+ }
+}