Add Normalization to options.Collation

GODRIVER-758

Change-Id: I9db9f5956a97646c9d45ced7cf8abdeb88f8393c

Author: Divjot Arora

mongo/crud_spec_test.go

@@ -198,7 +198,7 @@ func aggregateTest(t *testing.T, db *Database, coll *Collection, test *testCase)
 		}
 
 		if collation, found := test.Operation.Arguments["collation"]; found {
-			opts = opts.SetCollation(newCollationFromMap(collation.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(collation.(map[string]interface{})))
 		}
 
 		out := false

mongo/crud_util_test.go

@@ -72,7 +72,7 @@ func executeCount(sess *sessionImpl, coll *Collection, args map[string]interface
 		case "limit":
 			opts = opts.SetLimit(int64(opt.(float64)))
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -98,7 +98,7 @@ func executeDistinct(sess *sessionImpl, coll *Collection, args map[string]interf
 		case "fieldName":
 			fieldName = opt.(string)
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -317,7 +317,7 @@ func executeDeleteOne(sess *sessionImpl, coll *Collection, args map[string]inter
 		case "filter":
 			filter = opt.(map[string]interface{})
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -346,7 +346,7 @@ func executeDeleteMany(sess *sessionImpl, coll *Collection, args map[string]inte
 		case "filter":
 			filter = opt.(map[string]interface{})
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -380,7 +380,7 @@ func executeReplaceOne(sess *sessionImpl, coll *Collection, args map[string]inte
 		case "upsert":
 			opts = opts.SetUpsert(opt.(bool))
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -423,7 +423,7 @@ func executeUpdateOne(sess *sessionImpl, coll *Collection, args map[string]inter
 		case "upsert":
 			opts = opts.SetUpsert(opt.(bool))
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -463,7 +463,7 @@ func executeUpdateMany(sess *sessionImpl, coll *Collection, args map[string]inte
 		case "upsert":
 			opts = opts.SetUpsert(opt.(bool))
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -498,7 +498,7 @@ func executeAggregate(sess *sessionImpl, coll *Collection, args map[string]inter
 		case "batchSize":
 			opts = opts.SetBatchSize(int32(opt.(float64)))
 		case "collation":
-			opts = opts.SetCollation(newCollationFromMap(opt.(map[string]interface{})))
+			opts = opts.SetCollation(collationFromMap(opt.(map[string]interface{})))
 		}
 	}
 
@@ -824,46 +824,8 @@ func collationFromMap(m map[string]interface{}) *options.Collation {
 		collation.MaxVariable = maxVariable.(string)
 	}
 
-	if backwards, found := m["backwards"]; found {
-		collation.Backwards = backwards.(bool)
-	}
-
-	return &collation
-}
-
-// Matt: bad name, I know; also, type-aliasing, I know.
-// The issue is, options.Collation has a ToDocument function and mongoopt.Collation has a convert function
-// type aliasing doesn't allow defining new functions on non-local types.
-// When all options are updated to the improved api, this function will be the only one and will simply be named "collationFromMap"
-func newCollationFromMap(m map[string]interface{}) *options.Collation {
-	var collation options.Collation
-
-	if locale, found := m["locale"]; found {
-		collation.Locale = locale.(string)
-	}
-
-	if caseLevel, found := m["caseLevel"]; found {
-		collation.CaseLevel = caseLevel.(bool)
-	}
-
-	if caseFirst, found := m["caseFirst"]; found {
-		collation.CaseFirst = caseFirst.(string)
-	}
-
-	if strength, found := m["strength"]; found {
-		collation.Strength = int(strength.(float64))
-	}
-
-	if numericOrdering, found := m["numericOrdering"]; found {
-		collation.NumericOrdering = numericOrdering.(bool)
-	}
-
-	if alternate, found := m["alternate"]; found {
-		collation.Alternate = alternate.(string)
-	}
-
-	if maxVariable, found := m["maxVariable"]; found {
-		collation.MaxVariable = maxVariable.(string)
+	if normalization, found := m["normalization"]; found {
+		collation.Normalization = normalization.(bool)
 	}
 
 	if backwards, found := m["backwards"]; found {

mongo/options/collation_test.go

@@ -0,0 +1,40 @@
+package options
+
+import (
+	"github.com/mongodb/mongo-go-driver/x/bsonx"
+	"reflect"
+	"testing"
+)
+
+func TestCollation(t *testing.T) {
+	t.Run("TestCollationToDocument", func(t *testing.T) {
+		c := &Collation{
+			Locale:          "locale",
+			CaseLevel:       true,
+			CaseFirst:       "first",
+			Strength:        1,
+			NumericOrdering: true,
+			Alternate:       "alternate",
+			MaxVariable:     "maxVariable",
+			Normalization:   true,
+			Backwards:       true,
+		}
+
+		doc := c.ToDocument()
+		expected := bsonx.Doc{
+			{"locale", bsonx.String("locale")},
+			{"caseLevel", bsonx.Boolean(true)},
+			{"caseFirst", bsonx.String("first")},
+			{"strength", bsonx.Int32(1)},
+			{"numericOrdering", bsonx.Boolean(true)},
+			{"alternate", bsonx.String("alternate")},
+			{"maxVariable", bsonx.String("maxVariable")},
+			{"normalization", bsonx.Boolean(true)},
+			{"backwards", bsonx.Boolean(true)},
+		}
+
+		if !reflect.DeepEqual(doc, expected) {
+			t.Fatalf("collation did not match expected. got %v; wanted %v", doc, expected)
+		}
+	})
+}

mongo/options/mongooptions.go

@@ -25,6 +25,7 @@ type Collation struct {
 	NumericOrdering bool   `bson:",omitempty"` // Whether to order numbers based on numerical order and not collation order
 	Alternate       string `bson:",omitempty"` // Whether spaces and punctuation are considered base characters
 	MaxVariable     string `bson:",omitempty"` // Which characters are affected by alternate: "shifted"
+	Normalization   bool   `bson:",omitempty"` // Causes text to be normalized into Unicode NFD
 	Backwards       bool   `bson:",omitempty"` // Causes secondary differences to be considered in reverse order, as it is done in the French language
 }
 
@@ -52,6 +53,9 @@ func (co *Collation) ToDocument() bsonx.Doc {
 	if co.MaxVariable != "" {
 		doc = append(doc, bsonx.Elem{"maxVariable", bsonx.String(co.MaxVariable)})
 	}
+	if co.Normalization {
+		doc = append(doc, bsonx.Elem{"normalization", bsonx.Boolean(co.Normalization)})
+	}
 	if co.Backwards {
 		doc = append(doc, bsonx.Elem{"backwards", bsonx.Boolean(true)})
 	}