Fix lint issues after Go driver update.

.github/workflows/all.yml

@@ -22,7 +22,7 @@ jobs:
 
           # This is hard-coded by design in order to catch inadvertent changes
           # to the minimum-required Go version to build migration-verifier.
-          - 1.19
+          - '1.20'
           - stable
 
     runs-on: ${{matrix.os.runsOn}}

go.mod

@@ -1,6 +1,6 @@
 module github.com/10gen/migration-verifier
 
-go 1.19
+go 1.20
 
 require (
 	github.com/deckarep/golang-set/v2 v2.3.0

internal/partitions/partition_test.go

@@ -73,50 +73,60 @@ func (suite *UnitTestSuite) TestVersioning() {
 	expectedFilterWithTypeBracketing := makeExpectedFilterWithTypeBracketing(partition.Key.Lower, partition.Upper)
 	// No version given, default to no bracketing
 	findOptions := partition.GetFindOptions(nil, nil)
-	filter := findOptions.Map()["filter"]
+	filter := getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 6.0 (int64)
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int64(6), int64(0), int64(0), int64(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 6.0
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(6), int32(0), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 5.3.0.9
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(5), int32(3), int32(0), int32(9)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 7.1.3.5
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(7), int32(1), int32(3), int32(5)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 4.4 (int64)
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int64(4), int64(4), int64(0), int64(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// 4.4
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(4), int32(4), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// 4.2
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(4), int32(2), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// No version array -- assume old, require type bracketing.
 	findOptions = partition.GetFindOptions(&bson.M{"notVersionArray": bson.A{6, int32(0), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 }
 
+func getFilterFromFindOptions(opts bson.D) any {
+	for _, el := range opts {
+		if el.Key == "filter" {
+			return el.Value
+		}
+	}
+
+	return nil
+}
+
 func makeTestPartition() (Partition, bson.D) {
 	partition := Partition{
 		Key: PartitionKey{

internal/util/uuid.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/google/uuid"
+	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -21,10 +22,10 @@ const (
 type UUID uuid.UUID
 
 var (
-	_ bsoncodec.ValueMarshaler   = UUID{}
-	_ bsoncodec.ValueUnmarshaler = (*UUID)(nil)
-	_ bsoncodec.KeyMarshaler     = UUID{}
-	_ bsoncodec.KeyUnmarshaler   = (*UUID)(nil)
+	_ bson.ValueMarshaler      = UUID{}
+	_ bson.ValueUnmarshaler    = (*UUID)(nil)
+	_ bsoncodec.KeyMarshaler   = UUID{}
+	_ bsoncodec.KeyUnmarshaler = (*UUID)(nil)
 )
 
 // NewUUID constructs a new, randomly-generated UUID.
@@ -36,13 +37,13 @@ func NewUUID() UUID {
 // ValueMarshaler interface.
 func (u UUID) MarshalBSONValue() (bsontype.Type, []byte, error) {
 	val := bsoncore.AppendBinary(nil, uuidBinarySubtype, u[:])
-	return bsontype.Binary, val, nil
+	return bson.TypeBinary, val, nil
 }
 
 // UnmarshalBSONValue is used to unmarshal BSON into UUID objects. This implements the
 // ValueUnmarshaler interface.
 func (u *UUID) UnmarshalBSONValue(bsonType bsontype.Type, data []byte) error {
-	if bsonType != bsontype.Binary {
+	if bsonType != bson.TypeBinary {
 		return fmt.Errorf("cannot decoded BSON value of type %s as a UUID", bsonType)
 	}
 

internal/verifier/bson_compare.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 type MismatchDetails struct {
@@ -109,9 +108,9 @@ func bsonUnorderedCompareRawValue(srcValue, dstValue bson.RawValue) (bool, error
 	}
 
 	switch srcValue.Type {
-	case bsontype.Array:
+	case bson.TypeArray:
 		return bsonUnorderedCompareRawArray(srcValue.Array(), dstValue.Array())
-	case bsontype.EmbeddedDocument:
+	case bson.TypeEmbeddedDocument:
 		return BsonUnorderedCompareRawDocument(srcValue.Document(), dstValue.Document())
 	default:
 		return srcValue.Equal(dstValue), nil

internal/verifier/change_stream.go

@@ -37,7 +37,7 @@ type DocKey struct {
 func (verifier *Verifier) HandleChangeStreamEvent(ctx context.Context, changeEvent *ParsedEvent) error {
 	if changeEvent.ClusterTime != nil &&
 		(verifier.lastChangeEventTime == nil ||
-			primitive.CompareTimestamp(*verifier.lastChangeEventTime, *changeEvent.ClusterTime) < 0) {
+			verifier.lastChangeEventTime.Compare(*changeEvent.ClusterTime) < 0) {
 		verifier.lastChangeEventTime = changeEvent.ClusterTime
 	}
 	switch changeEvent.OpType {
@@ -175,7 +175,7 @@ func (verifier *Verifier) StartChangeStream(ctx context.Context, startTime *prim
 		}
 
 		verifier.logger.Debug().Msgf("Initial cluster time is %+v", clusterTimeTs)
-		if primitive.CompareTimestamp(clusterTimeTs, resumeTokenTime) < 0 {
+		if clusterTimeTs.Compare(resumeTokenTime) < 0 {
 			verifier.srcStartAtTs = &clusterTimeTs
 		}
 	}

internal/verifier/change_stream_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
 )
 
@@ -77,7 +76,7 @@ func (suite *MultiSourceVersionTestSuite) TestStartAtTimeWithChanges() {
 	suite.Require().NoError(err)
 	newStartTs := sess.OperationTime()
 	suite.Require().NotNil(newStartTs)
-	suite.Require().Less(primitive.CompareTimestamp(*origStartTs, *newStartTs), 0)
+	suite.Require().Negative(origStartTs.Compare(*newStartTs))
 	verifier.changeStreamEnderChan <- struct{}{}
 	<-verifier.changeStreamDoneChan
 	suite.Require().Equal(verifier.srcStartAtTs, newStartTs)
@@ -98,6 +97,5 @@ func (suite *MultiSourceVersionTestSuite) TestNoStartAtTime() {
 	err = verifier.StartChangeStream(ctx, nil)
 	suite.Require().NoError(err)
 	suite.Require().NotNil(verifier.srcStartAtTs)
-	suite.Require().LessOrEqual(primitive.CompareTimestamp(
-		*origStartTs, *verifier.srcStartAtTs), 0)
+	suite.Require().LessOrEqual(origStartTs.Compare(*verifier.srcStartAtTs), 0)
 }

internal/verifier/migration_verifier.go

@@ -211,7 +211,7 @@ func (verifier *Verifier) getClientOpts(uri string) *options.ClientOptions {
 		AppName: &appName,
 	}
 	opts.ApplyURI(uri)
-	opts.SetWriteConcern(writeconcern.New(writeconcern.WMajority()))
+	opts.SetWriteConcern(writeconcern.Majority())
 
 	verifier.doIfForceReadConcernMajority(func() {
 		opts.SetReadConcern(readconcern.Majority())
@@ -714,12 +714,11 @@ func (verifier *Verifier) logChunkInfo(ctx context.Context, namespaceAndUUID *uu
 	}
 	defer cursor.Close(ctx)
 	for cursor.Next(ctx) {
-		var result bson.D
-		if err = cursor.Decode(&result); err != nil {
+		var resultMap bson.M
+		if err = cursor.Decode(&resultMap); err != nil {
 			verifier.logger.Error().Msgf("Error decoding chunk info for %s: %v", namespace, err)
 			return
 		}
-		resultMap := result.Map()
 		verifier.logger.Debug().Msgf(" Chunk of %s on %v, range %v to %v", namespace, resultMap["shard"],
 			resultMap["min"], resultMap["max"])
 	}
@@ -986,7 +985,7 @@ func (verifier *Verifier) markCollectionFailed(workerNum int, task *Verification
 		Details:   Failed + fmt.Sprintf(" %v", err)})
 }
 
-func verifyIndexes(ctx context.Context, workerNum int, task *VerificationTask, srcColl, dstColl *mongo.Collection,
+func verifyIndexes(ctx context.Context, _ int, _ *VerificationTask, srcColl, dstColl *mongo.Collection,
 	srcIdIndexSpec, dstIdIndexSpec *mongo.IndexSpecification) ([]VerificationResult, error) {
 	srcSpecs, err := srcColl.Indexes().ListSpecifications(ctx)
 	if err != nil {
@@ -1209,12 +1208,12 @@ func (verifier *Verifier) doIfForceReadConcernMajority(f func()) {
 
 func (verifier *Verifier) verificationDatabase() *mongo.Database {
 	db := verifier.metaClient.Database(verifier.metaDBName)
-	if db.WriteConcern().GetW() != "majority" {
+	if db.WriteConcern().W != "majority" {
 		verifier.logger.Fatal().Msgf("Verification metadata is not using write concern majority: %+v", db.WriteConcern())
 	}
 
 	verifier.doIfForceReadConcernMajority(func() {
-		if db.ReadConcern().GetLevel() != "majority" {
+		if db.ReadConcern().Level != "majority" {
 			verifier.logger.Fatal().Msgf("Verification metadata is not using read concern majority: %+v", db.ReadConcern())
 		}
 	})
@@ -1234,7 +1233,7 @@ func (verifier *Verifier) srcClientDatabase(dbName string) *mongo.Database {
 	db := verifier.srcClient.Database(dbName)
 	// No need to check the write concern because we do not write to the source database.
 	verifier.doIfForceReadConcernMajority(func() {
-		if db.ReadConcern().GetLevel() != "majority" {
+		if db.ReadConcern().Level != "majority" {
 			verifier.logger.Fatal().Msgf("Source client is not using read concern majority: %+v", db.ReadConcern())
 		}
 	})
@@ -1245,7 +1244,7 @@ func (verifier *Verifier) dstClientDatabase(dbName string) *mongo.Database {
 	db := verifier.dstClient.Database(dbName)
 	// No need to check the write concern because we do not write to the target database.
 	verifier.doIfForceReadConcernMajority(func() {
-		if db.ReadConcern().GetLevel() != "majority" {
+		if db.ReadConcern().Level != "majority" {
 			verifier.logger.Fatal().Msgf("Source client is not using read concern majority: %+v", db.ReadConcern())
 		}
 	})
@@ -1460,11 +1459,10 @@ func getBuildInfo(ctx context.Context, client *mongo.Client) (*bson.M, error) {
 	if commandResult.Err() != nil {
 		return nil, commandResult.Err()
 	}
-	var buildInfo bson.D
-	err := commandResult.Decode(&buildInfo)
+	var buildInfoMap bson.M
+	err := commandResult.Decode(&buildInfoMap)
 	if err != nil {
 		return nil, err
 	}
-	buildInfoMap := buildInfo.Map()
 	return &buildInfoMap, nil
 }

internal/verifier/migration_verifier_test.go

@@ -161,7 +161,7 @@ func (suite *MultiDataVersionTestSuite) TestVerifierFetchDocuments() {
 			func() {
 				doc := srcMap.Fetch(both[0])
 				val := doc.Lookup("num")
-				suite.Assert().Less(val.AsInt32(), int32(100))
+				suite.Assert().Less(val.AsInt64(), int64(100))
 			},
 			"doc is fetched",
 		)

internal/verifier/unit_test_util.go

@@ -83,10 +83,10 @@ func (suite *WithMongodsTestSuite) SetupSuite() {
 	err := startTestMongods(suite.T(), &suite.srcMongoInstance, &suite.dstMongoInstance, &suite.metaMongoInstance)
 	suite.Require().NoError(err)
 	ctx := context.Background()
-	clientOpts := options.Client().ApplyURI("mongodb://localhost:" + suite.srcMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.New(writeconcern.WMajority()))
+	clientOpts := options.Client().ApplyURI("mongodb://localhost:" + suite.srcMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.Majority())
 	suite.srcMongoClient, err = mongo.Connect(ctx, clientOpts)
 	suite.Require().NoError(err)
-	clientOpts = options.Client().ApplyURI("mongodb://localhost:" + suite.dstMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.New(writeconcern.WMajority()))
+	clientOpts = options.Client().ApplyURI("mongodb://localhost:" + suite.dstMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.Majority())
 	suite.dstMongoClient, err = mongo.Connect(ctx, clientOpts)
 	suite.Require().NoError(err)
 	clientOpts = options.Client().ApplyURI("mongodb://localhost:" + suite.metaMongoInstance.port).SetAppName("Verifier Test Suite")

internal/verifier/util.go

@@ -129,7 +129,7 @@ func GetLastOpTimeAndSyncShardClusterTime(
 			fmt.Sprintf("Running appendOplogNote command. %v", appendOplogNoteCmd))
 		ret := client.Database("admin").RunCommand(ctx, appendOplogNoteCmd)
 		var err error
-		if response, err = ret.DecodeBytes(); err != nil {
+		if response, err = ret.Raw(); err != nil {
 			return err
 		}