REP-5274 Compare full index specs rather than just a subset. (#50)

Previously migration-verifier only checked the parts of index specs that go in a mongo.IndexSpecification. That struct is incomplete, though; it doesn’t, for example, include partial index filters. Thus, migration-verifier didn’t compare those parts of an index specification.

This changeset alters the index-checking logic to check full index specifications. Note that this comparison is rather “coarse” and may flag some specifications as mismatching when they actually produce the same index. For example, `{foo: 1}` and `{foo: 2}` actually produce the same index, but migration-verifier will flag them as mismatches. Eventually we hope to fix that, but for now false positives are safer than incomplete checks.

This does teach index verification to ignore type differences, which is a common source of false-positives in verifications. For example, `{_id: Double(1)}` vs. `{_id: Long(1)}` will no longer be flagged as a mismatch. (NB: Due to this change, the metadata DB must now be on a v6+ cluster.)

This also replaces use of mongo.CollectionSpecification with a struct that allows detection of unrecognized fields. Thus we’ll avoid a similar problem for collection specifications. 

This also copies over mongosync’s Option implementation.

Author: FGasper

internal/util/collections.go

@@ -0,0 +1,84 @@
+package util
+
+import (
+	"context"
+
+	"github.com/10gen/migration-verifier/option"
+	"github.com/pkg/errors"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+// CollectionSpec is like mongo.CollectionSpecification except:
+// - IDIndex is a bson.Raw rather than mongo.IndexSpecification.
+// - It can detect unexpected fields.
+type CollectionSpec struct {
+	Name    string
+	Type    string
+	Options bson.Raw
+	Info    struct {
+		ReadOnly bool `bson:"readOnly"`
+		UUID     primitive.Binary
+
+		Extra map[string]any
+	}
+	IDIndex bson.Raw `bson:"idIndex"`
+
+	Extra map[string]any
+}
+
+// FullName returns the collection's full namespace.
+func FullName(collection *mongo.Collection) string {
+	return collection.Database().Name() + "." + collection.Name()
+}
+
+// GetCollectionSpecIfExists returns the given collection’s specification,
+// or empty if the collection doesn’t exist. If any unexpected properties
+// exist in the collection specification then an error is returned.
+func GetCollectionSpecIfExists(
+	ctx context.Context,
+	coll *mongo.Collection,
+) (option.Option[CollectionSpec], error) {
+	cursor, err := coll.Database().ListCollections(ctx, bson.M{"name": coll.Name()})
+	if err != nil {
+		return option.None[CollectionSpec](), errors.Wrapf(
+			err,
+			"failed to fetch %#q's specification",
+			FullName(coll),
+		)
+	}
+
+	var specs []CollectionSpec
+	err = cursor.All(ctx, &specs)
+	if err != nil {
+		return option.None[CollectionSpec](), errors.Wrapf(
+			err,
+			"failed to parse %#q's specification",
+			FullName(coll),
+		)
+	}
+
+	switch len(specs) {
+	case 0:
+		return option.None[CollectionSpec](), nil
+	case 1:
+		if len(specs[0].Extra) > 0 || len(specs[0].Info.Extra) > 0 {
+			return option.None[CollectionSpec](), errors.Wrapf(
+				err,
+				"%#q's specification (%v) contains unrecognized fields",
+				FullName(coll),
+				specs[0],
+			)
+		}
+
+		return option.Some(specs[0]), nil
+	}
+
+	return option.None[CollectionSpec](), errors.Wrapf(
+		err,
+		"received multiple results (%v) when fetching %#q's specification",
+		specs,
+		FullName(coll),
+	)
+}