Tests: Add unit tests

internal/search/photos_filter_archived_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryArchived(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "archived:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 1)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in archived starts with f/F, the txt package will assume it means false,
+		f.Query = "archived:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "archived:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_geo_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryGeo(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "geo:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 13)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in geo starts with f/F, the txt package will assume it means false,
+		f.Query = "geo:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "geo:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_hidden_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryHidden(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "hidden:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 1)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in hidden starts with f/F, the txt package will assume it means false,
+		f.Query = "hidden:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "hidden:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_merged_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryMerged(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "merged:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 22)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in merged starts with f/F, the txt package will assume it means false,
+		f.Query = "merged:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "merged:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_mono_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryMono(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "mono:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 8)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in mono starts with f/F, the txt package will assume it means false,
+		f.Query = "mono:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "mono:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_portrait_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryPortrait(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "portrait:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 5)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in portrait starts with f/F, the txt package will assume it means false,
+		f.Query = "portrait:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "portrait:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_private_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryPrivate(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "private:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.Equal(t, len(photos0), 1)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in private starts with f/F, the txt package will assume it means false,
+		f.Query = "private:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "private:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_public_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryPublic(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "public:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 21)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in public starts with f/F, the txt package will assume it means false,
+		f.Query = "public:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "public:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_review_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryReview(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "review:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 15)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in review starts with f/F, the txt package will assume it means false,
+		f.Query = "review:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "review:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}

internal/search/photos_filter_unsorted_test.go

@@ -0,0 +1,299 @@
+package search
+
+import (
+	"testing"
+
+	"github.com/photoprism/photoprism/internal/form"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPhotosQueryUnsorted(t *testing.T) {
+	var f0 form.SearchPhotos
+
+	f0.Query = "unsorted:true"
+	f0.Merged = true
+
+	photos0, _, err := Photos(f0)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.GreaterOrEqual(t, len(photos0), 16)
+
+	t.Run("StartsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"%gold\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"I love % dog\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPercent", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"sale%\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"&IlikeFood\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Pets & Dogs\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAmpersand", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Light&\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"'Family\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		// Note: If the string in unsorted starts with f/F, the txt package will assume it means false,
+		f.Query = "unsorted:\"Mother's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithSingleQuote", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Ice Cream'\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"*Forrest\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"My*Kids\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithAsterisk", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Yoga***\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"|Banana\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Red|Green\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithPipe", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Blue|\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("StartsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"345 Shirt\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("CenterNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Color555 Blue\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("EndsWithNumber", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Route 66\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("AndSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Route 66 & Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+	t.Run("OrSearch", func(t *testing.T) {
+		var f form.SearchPhotos
+
+		f.Query = "unsorted:\"Route %66 | *Father's Day\""
+		f.Merged = true
+
+		photos, _, err := Photos(f)
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		assert.Equal(t, len(photos), len(photos0))
+	})
+}