GODRIVER-1569 Add support for authorizedDatabases option (#371)

Author: Divjot Arora

mongo/client.go

@@ -718,9 +718,14 @@ func (c *Client) ListDatabases(ctx context.Context, filter interface{}, opts ...
 	op := operation.NewListDatabases(filterDoc).
 		Session(sess).ReadPreference(c.readPreference).CommandMonitor(c.monitor).
 		ServerSelector(selector).ClusterClock(c.clock).Database("admin").Deployment(c.deployment).Crypt(c.crypt)
+
 	if ldo.NameOnly != nil {
 		op = op.NameOnly(*ldo.NameOnly)
 	}
+	if ldo.AuthorizedDatabases != nil {
+		op = op.AuthorizedDatabases(*ldo.AuthorizedDatabases)
+	}
+
 	retry := driver.RetryNone
 	if c.retryReads {
 		retry = driver.RetryOncePerCommand

mongo/integration/client_test.go

@@ -27,6 +27,7 @@ import (
 	"go.mongodb.org/mongo-driver/mongo/integration/mtest"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/mongo/readpref"
+	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
 	"go.mongodb.org/mongo-driver/x/mongo/driver"
 	"go.mongodb.org/mongo-driver/x/mongo/driver/drivertest"
 	"go.mongodb.org/mongo-driver/x/mongo/driver/wiremessage"
@@ -147,68 +148,106 @@ func TestClient(t *testing.T) {
 		mt.Fatal("unable to find authenticated user")
 	})
 	mt.RunOpts("list databases", noClientOpts, func(mt *mtest.T) {
-		testCases := []struct {
-			name             string
-			filter           bson.D
-			hasTestDb        bool
-			minServerVersion string
-		}{
-			{"no filter", bson.D{}, true, ""},
-			{"filter", bson.D{{"name", "foobar"}}, false, "3.6"},
-		}
-
-		for _, tc := range testCases {
-			opts := mtest.NewOptions()
-			if tc.minServerVersion != "" {
-				opts.MinServerVersion(tc.minServerVersion)
+		mt.RunOpts("filter", noClientOpts, func(mt *mtest.T) {
+			testCases := []struct {
+				name             string
+				filter           bson.D
+				hasTestDb        bool
+				minServerVersion string
+			}{
+				{"empty", bson.D{}, true, ""},
+				{"non-empty", bson.D{{"name", "foobar"}}, false, "3.6"},
 			}
 
-			mt.RunOpts(tc.name, opts, func(mt *mtest.T) {
-				res, err := mt.Client.ListDatabases(mtest.Background, tc.filter)
-				assert.Nil(mt, err, "ListDatabases error: %v", err)
+			for _, tc := range testCases {
+				opts := mtest.NewOptions()
+				if tc.minServerVersion != "" {
+					opts.MinServerVersion(tc.minServerVersion)
+				}
+
+				mt.RunOpts(tc.name, opts, func(mt *mtest.T) {
+					res, err := mt.Client.ListDatabases(mtest.Background, tc.filter)
+					assert.Nil(mt, err, "ListDatabases error: %v", err)
 
-				var found bool
-				for _, db := range res.Databases {
-					if db.Name == mtest.TestDb {
-						found = true
-						break
+					var found bool
+					for _, db := range res.Databases {
+						if db.Name == mtest.TestDb {
+							found = true
+							break
+						}
 					}
-				}
-				assert.Equal(mt, tc.hasTestDb, found, "expected to find test db: %v, found: %v", tc.hasTestDb, found)
-			})
-		}
+					assert.Equal(mt, tc.hasTestDb, found, "expected to find test db: %v, found: %v", tc.hasTestDb, found)
+				})
+			}
+		})
+		mt.Run("options", func(mt *mtest.T) {
+			allOpts := options.ListDatabases().SetNameOnly(true).SetAuthorizedDatabases(true)
+			mt.ClearEvents()
+
+			_, err := mt.Client.ListDatabases(mtest.Background, bson.D{}, allOpts)
+			assert.Nil(mt, err, "ListDatabases error: %v", err)
+
+			evt := mt.GetStartedEvent()
+			assert.Equal(mt, "listDatabases", evt.CommandName, "expected ")
+
+			expectedDoc := bsoncore.BuildDocumentFromElements(nil,
+				bsoncore.AppendBooleanElement(nil, "nameOnly", true),
+				bsoncore.AppendBooleanElement(nil, "authorizedDatabases", true),
+			)
+			err = compareDocs(mt, expectedDoc, evt.Command)
+			assert.Nil(mt, err, "compareDocs error: %v", err)
+		})
 	})
 	mt.RunOpts("list database names", noClientOpts, func(mt *mtest.T) {
-		testCases := []struct {
-			name             string
-			filter           bson.D
-			hasTestDb        bool
-			minServerVersion string
-		}{
-			{"no filter", bson.D{}, true, ""},
-			{"filter", bson.D{{"name", "foobar"}}, false, "3.6"},
-		}
-
-		for _, tc := range testCases {
-			opts := mtest.NewOptions()
-			if tc.minServerVersion != "" {
-				opts.MinServerVersion(tc.minServerVersion)
+		mt.RunOpts("filter", noClientOpts, func(mt *mtest.T) {
+			testCases := []struct {
+				name             string
+				filter           bson.D
+				hasTestDb        bool
+				minServerVersion string
+			}{
+				{"no filter", bson.D{}, true, ""},
+				{"filter", bson.D{{"name", "foobar"}}, false, "3.6"},
 			}
 
-			mt.RunOpts(tc.name, opts, func(mt *mtest.T) {
-				dbs, err := mt.Client.ListDatabaseNames(mtest.Background, tc.filter)
-				assert.Nil(mt, err, "ListDatabaseNames error: %v", err)
+			for _, tc := range testCases {
+				opts := mtest.NewOptions()
+				if tc.minServerVersion != "" {
+					opts.MinServerVersion(tc.minServerVersion)
+				}
+
+				mt.RunOpts(tc.name, opts, func(mt *mtest.T) {
+					dbs, err := mt.Client.ListDatabaseNames(mtest.Background, tc.filter)
+					assert.Nil(mt, err, "ListDatabaseNames error: %v", err)
 
-				var found bool
-				for _, db := range dbs {
-					if db == mtest.TestDb {
-						found = true
-						break
+					var found bool
+					for _, db := range dbs {
+						if db == mtest.TestDb {
+							found = true
+							break
+						}
 					}
-				}
-				assert.Equal(mt, tc.hasTestDb, found, "expected to find test db: %v, found: %v", tc.hasTestDb, found)
-			})
-		}
+					assert.Equal(mt, tc.hasTestDb, found, "expected to find test db: %v, found: %v", tc.hasTestDb, found)
+				})
+			}
+		})
+		mt.Run("options", func(mt *mtest.T) {
+			allOpts := options.ListDatabases().SetNameOnly(true).SetAuthorizedDatabases(true)
+			mt.ClearEvents()
+
+			_, err := mt.Client.ListDatabaseNames(mtest.Background, bson.D{}, allOpts)
+			assert.Nil(mt, err, "ListDatabaseNames error: %v", err)
+
+			evt := mt.GetStartedEvent()
+			assert.Equal(mt, "listDatabases", evt.CommandName, "expected ")
+
+			expectedDoc := bsoncore.BuildDocumentFromElements(nil,
+				bsoncore.AppendBooleanElement(nil, "nameOnly", true),
+				bsoncore.AppendBooleanElement(nil, "authorizedDatabases", true),
+			)
+			err = compareDocs(mt, expectedDoc, evt.Command)
+			assert.Nil(mt, err, "compareDocs error: %v", err)
+		})
 	})
 	mt.RunOpts("ping", noClientOpts, func(mt *mtest.T) {
 		mt.Run("default read preference", func(mt *mtest.T) {

mongo/integration/cmd_monitoring_helpers_test.go

@@ -171,7 +171,9 @@ func compareDocsHelper(mt *mtest.T, expected, actual bson.Raw, prefix string) er
 		}
 
 		aVal, err := actual.LookupErr(eKey)
-		assert.Nil(mt, err, "key %s not found in result", e.Key())
+		if err != nil {
+			return fmt.Errorf("key %s not found in result", fullKeyName)
+		}
 
 		if err := compareValues(mt, fullKeyName, e.Value(), aVal); err != nil {
 			return err

mongo/options/listdatabasesoptions.go

@@ -11,6 +11,11 @@ type ListDatabasesOptions struct {
 	// If true, only the Name field of the returned DatabaseSpecification objects will be populated. The default value
 	// is false.
 	NameOnly *bool
+
+	// If true, only the databases which the user is authorized to see will be returned. For more information about
+	// the behavior of this option, see https://docs.mongodb.com/manual/reference/privilege-actions/#find. The default
+	// value is true.
+	AuthorizedDatabases *bool
 }
 
 // ListDatabases creates a new ListDatabasesOptions instance.
@@ -24,6 +29,12 @@ func (ld *ListDatabasesOptions) SetNameOnly(b bool) *ListDatabasesOptions {
 	return ld
 }
 
+// SetAuthorizedDatabases sets the value for the AuthorizedDatabases field.
+func (ld *ListDatabasesOptions) SetAuthorizedDatabases(b bool) *ListDatabasesOptions {
+	ld.AuthorizedDatabases = &b
+	return ld
+}
+
 // MergeListDatabasesOptions combines the given ListDatabasesOptions instances into a single *ListDatabasesOptions in a
 // last-one-wins fashion.
 func MergeListDatabasesOptions(opts ...*ListDatabasesOptions) *ListDatabasesOptions {
@@ -35,6 +46,9 @@ func MergeListDatabasesOptions(opts ...*ListDatabasesOptions) *ListDatabasesOpti
 		if opt.NameOnly != nil {
 			ld.NameOnly = opt.NameOnly
 		}
+		if opt.AuthorizedDatabases != nil {
+			ld.AuthorizedDatabases = opt.AuthorizedDatabases
+		}
 	}
 
 	return ld

x/mongo/driver/operation/listDatabases.go

@@ -21,6 +21,10 @@ documentation = "Filter determines what results are returned from listDatabases.
 type = "boolean"
 documentation = "NameOnly specifies whether to only return database names."
 
+[request.authorizedDatabases]
+type = "boolean"
+documentation = "AuthorizedDatabases specifies whether to only return databases which the user is authorized to use."
+
 [response]
 name = "ListDatabasesResult"
 
@@ -30,4 +34,4 @@ documentation = "The sum of the size of all the database files on disk in bytes.
 
 [response.field.databases]
 type = "value"
-documentation = "An array of documents, one document for each database"
+documentation = "An array of documents, one document for each database"