131 lines
4.0 KiB
Go
131 lines
4.0 KiB
Go
package mongoext
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"git.blackforestbytes.com/BlackForestBytes/goext/tst"
|
|
"go.mongodb.org/mongo-driver/v2/bson"
|
|
"go.mongodb.org/mongo-driver/v2/mongo"
|
|
)
|
|
|
|
func TestFixTextSearchPipelineEmpty(t *testing.T) {
|
|
pipeline := mongo.Pipeline{}
|
|
result := FixTextSearchPipeline(pipeline)
|
|
tst.AssertEqual(t, len(result), 0)
|
|
}
|
|
|
|
func TestFixTextSearchPipelineNoTextSearch(t *testing.T) {
|
|
pipeline := mongo.Pipeline{
|
|
bson.D{{Key: "$match", Value: bson.M{"foo": "bar"}}},
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
}
|
|
|
|
result := FixTextSearchPipeline(pipeline)
|
|
|
|
tst.AssertEqual(t, len(result), 2)
|
|
tst.AssertEqual(t, result[0][0].Key, "$match")
|
|
tst.AssertEqual(t, result[1][0].Key, "$sort")
|
|
}
|
|
|
|
func TestFixTextSearchPipelineMovesTextSearchToFront(t *testing.T) {
|
|
pipeline := mongo.Pipeline{
|
|
bson.D{{Key: "$match", Value: bson.M{"foo": "bar"}}},
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"$text": bson.M{"$search": "hello world"}}}},
|
|
}
|
|
|
|
result := FixTextSearchPipeline(pipeline)
|
|
|
|
tst.AssertEqual(t, len(result), 3)
|
|
|
|
// $text/$search should be at front
|
|
first := result[0]
|
|
matchVal, ok := first[0].Value.(bson.M)
|
|
tst.AssertTrue(t, ok)
|
|
textVal, ok := matchVal["$text"].(bson.M)
|
|
tst.AssertTrue(t, ok)
|
|
tst.AssertEqual(t, textVal["$search"].(string), "hello world")
|
|
|
|
// other entries should preserve order
|
|
tst.AssertEqual(t, result[1][0].Key, "$match")
|
|
tst.AssertEqual(t, result[2][0].Key, "$sort")
|
|
}
|
|
|
|
func TestFixTextSearchPipelineMultipleTextSearches(t *testing.T) {
|
|
pipeline := mongo.Pipeline{
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"$text": bson.M{"$search": "first"}}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"foo": "bar"}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"$text": bson.M{"$search": "second"}}}},
|
|
}
|
|
|
|
result := FixTextSearchPipeline(pipeline)
|
|
|
|
tst.AssertEqual(t, len(result), 4)
|
|
|
|
// Last seen text-search should be prepended last, ending up at front.
|
|
first := result[0][0].Value.(bson.M)
|
|
tst.AssertEqual(t, first["$text"].(bson.M)["$search"].(string), "second")
|
|
|
|
second := result[1][0].Value.(bson.M)
|
|
tst.AssertEqual(t, second["$text"].(bson.M)["$search"].(string), "first")
|
|
|
|
tst.AssertEqual(t, result[2][0].Key, "$sort")
|
|
tst.AssertEqual(t, result[3][0].Key, "$match")
|
|
}
|
|
|
|
func TestFixTextSearchPipelineMatchWithoutText(t *testing.T) {
|
|
pipeline := mongo.Pipeline{
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"name": "alice"}}},
|
|
}
|
|
|
|
result := FixTextSearchPipeline(pipeline)
|
|
|
|
tst.AssertEqual(t, len(result), 2)
|
|
tst.AssertEqual(t, result[0][0].Key, "$sort")
|
|
tst.AssertEqual(t, result[1][0].Key, "$match")
|
|
}
|
|
|
|
func TestFixTextSearchPipelineTextWithoutSearch(t *testing.T) {
|
|
// $text present but without $search key — should NOT be moved
|
|
pipeline := mongo.Pipeline{
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"$text": bson.M{"$language": "en"}}}},
|
|
}
|
|
|
|
result := FixTextSearchPipeline(pipeline)
|
|
|
|
tst.AssertEqual(t, len(result), 2)
|
|
tst.AssertEqual(t, result[0][0].Key, "$sort")
|
|
tst.AssertEqual(t, result[1][0].Key, "$match")
|
|
}
|
|
|
|
func TestFixTextSearchPipelineMatchValueWrongType(t *testing.T) {
|
|
// $match with non-bson.M value — function should keep entry in place
|
|
pipeline := mongo.Pipeline{
|
|
bson.D{{Key: "$match", Value: "not a map"}},
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
}
|
|
|
|
result := FixTextSearchPipeline(pipeline)
|
|
|
|
tst.AssertEqual(t, len(result), 2)
|
|
tst.AssertEqual(t, result[0][0].Key, "$match")
|
|
tst.AssertEqual(t, result[1][0].Key, "$sort")
|
|
}
|
|
|
|
func TestFixTextSearchPipelinePreservesOriginal(t *testing.T) {
|
|
original := mongo.Pipeline{
|
|
bson.D{{Key: "$sort", Value: bson.M{"baz": 1}}},
|
|
bson.D{{Key: "$match", Value: bson.M{"$text": bson.M{"$search": "x"}}}},
|
|
}
|
|
originalLen := len(original)
|
|
originalFirstKey := original[0][0].Key
|
|
|
|
_ = FixTextSearchPipeline(original)
|
|
|
|
tst.AssertEqual(t, len(original), originalLen)
|
|
tst.AssertEqual(t, original[0][0].Key, originalFirstKey)
|
|
}
|