Added common method BsonType --> string and removed unnecessary files.

Author: papafe

src/MongoDB.Bson/Serialization/BsonTypeExtensions.cs

@@ -0,0 +1,57 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+
+namespace MongoDB.Bson.Serialization
+{
+    /// <summary>
+    /// A static class containing extension methods for <see cref="BsonType"/>.
+    /// </summary>
+    public static class BsonTypeExtensions
+    {
+        /// <summary>
+        /// Maps a <see cref="BsonType"/> to its corresponding string representation.
+        /// </summary>
+        /// <param name="type">The input type to map.</param>
+        public static string ToStringRepresentation(this BsonType type)
+        {
+            return type switch
+            {
+                BsonType.Array => "array",
+                BsonType.Binary => "binData",
+                BsonType.Boolean => "bool",
+                BsonType.DateTime => "date",
+                BsonType.Decimal128 => "decimal",
+                BsonType.Document => "object",
+                BsonType.Double => "double",
+                BsonType.Int32 => "int",
+                BsonType.Int64 => "long",
+                BsonType.JavaScript => "javascript",
+                BsonType.JavaScriptWithScope => "javascriptWithScope",
+                BsonType.MaxKey => "maxKey",
+                BsonType.MinKey => "minKey",
+                BsonType.Null => "null",
+                BsonType.ObjectId => "objectId",
+                BsonType.RegularExpression => "regex",
+                BsonType.String => "string",
+                BsonType.Symbol => "symbol",
+                BsonType.Timestamp => "timestamp",
+                BsonType.Undefined => "undefined",
+                _ => throw new ArgumentException($"Unexpected BSON type: {type}.", nameof(type))
+            };
+        }
+    }
+}

src/MongoDB.Driver.Encryption/CsfleSchemaBuilder.cs

@@ -281,7 +281,7 @@ private static BsonDocument CreateEncryptDocument(
 
             if (bsonTypes != null)
             {
-                var convertedBsonTypes = bsonTypes.Select(MapBsonTypeToString).ToList();
+                var convertedBsonTypes = bsonTypes.Select(type => type.ToStringRepresentation()).ToList();
 
                 if (convertedBsonTypes.Count == 0)
                 {
@@ -331,30 +331,6 @@ private void AddToProperties(string field, BsonDocument document)
             properties[field] = document;
         }
 
-        private static string MapBsonTypeToString(BsonType type)
-        {
-            return type switch
-            {
-                BsonType.Array => "array",
-                BsonType.Binary => "binData",
-                BsonType.Boolean => "bool",
-                BsonType.DateTime => "date",
-                BsonType.Decimal128 => "decimal",
-                BsonType.Document => "object",
-                BsonType.Double => "double",
-                BsonType.Int32 => "int",
-                BsonType.Int64 => "long",
-                BsonType.JavaScript => "javascript",
-                BsonType.JavaScriptWithScope => "javascriptWithScope",
-                BsonType.ObjectId => "objectId",
-                BsonType.RegularExpression => "regex",
-                BsonType.String => "string",
-                BsonType.Symbol => "symbol",
-                BsonType.Timestamp => "timestamp",
-                _ => throw new ArgumentException($"Unsupported BSON type: {type}.", nameof(type))
-            };
-        }
-
         private static string MapCsfleEncryptionAlgorithmToString(EncryptionAlgorithm algorithm)
         {
             return algorithm switch

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/AstEnumExtensions.cs

@@ -15,38 +15,13 @@
 
 using System;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Ast
 {
     internal static class AstEnumExtensions
     {
-        public static string Render(this BsonType type)
-        {
-            return type switch
-            {
-                BsonType.Array => "array",
-                BsonType.Binary => "binData",
-                BsonType.Boolean => "bool",
-                BsonType.DateTime => "date",
-                BsonType.Decimal128 => "decimal",
-                BsonType.Document => "object",
-                BsonType.Double => "double",
-                BsonType.Int32 => "int",
-                BsonType.Int64 => "long",
-                BsonType.JavaScript => "javascript",
-                BsonType.JavaScriptWithScope => "javascriptWithScope",
-                BsonType.MaxKey => "maxKey",
-                BsonType.MinKey => "minKey",
-                BsonType.Null => "null",
-                BsonType.ObjectId => "objectId",
-                BsonType.RegularExpression => "regex",
-                BsonType.String => "string",
-                BsonType.Symbol => "symbol",
-                BsonType.Timestamp => "timestamp",
-                BsonType.Undefined => "undefined",
-                _ => throw new ArgumentException($"Unexpected BSON type: {type}.", nameof(type))
-            };
-        }
+        public static string Render(this BsonType type) => type.ToStringRepresentation();
 
         public static string Render(this ByteOrder byteOrder)
         {

src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Filters/AstTypeFilterOperation.cs

@@ -17,6 +17,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Visitors;
 using MongoDB.Driver.Linq.Linq3Implementation.Misc;
@@ -51,39 +52,11 @@ public override BsonValue Render()
             if (_types.Count == 1)
             {
                 var type = _types[0];
-                return new BsonDocument("$type", MapBsonTypeToString(type));
+                return new BsonDocument("$type", type.ToStringRepresentation());
             }
             else
             {
-                return new BsonDocument("$type", new BsonArray(_types.Select(type => MapBsonTypeToString(type))));
-            }
-        }
-
-        private string MapBsonTypeToString(BsonType type)
-        {
-            switch (type)
-            {
-                case BsonType.Array: return "array";
-                case BsonType.Binary: return "binData";
-                case BsonType.Boolean: return "bool";
-                case BsonType.DateTime: return "date";
-                case BsonType.Decimal128: return "decimal";
-                case BsonType.Document: return "object";
-                case BsonType.Double: return "double";
-                case BsonType.Int32: return "int";
-                case BsonType.Int64: return "long";
-                case BsonType.JavaScript: return "javascript";
-                case BsonType.JavaScriptWithScope: return "javascriptWithScope";
-                case BsonType.MaxKey: return "maxKey";
-                case BsonType.MinKey: return "minKey";
-                case BsonType.Null: return "null";
-                case BsonType.ObjectId: return "objectId";
-                case BsonType.RegularExpression: return "regex";
-                case BsonType.String: return "string";
-                case BsonType.Symbol: return "symbol";
-                case BsonType.Timestamp: return "timestamp";
-                case BsonType.Undefined: return "undefined";
-                default: throw new ArgumentException($"Unexpected BSON type: {type}.", nameof(type));
+                return new BsonDocument("$type", new BsonArray(_types.Select(type => type.ToStringRepresentation())));
             }
         }
     }

tests/MongoDB.Driver.Tests/Encryption/CsfleSchemaBuilderTests.cs

@@ -156,7 +156,7 @@ public void CsfleSchemaBuilder_with_multiple_types_works_as_expected()
                             EncryptionAlgorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Random);
                 });
 
-                schemaBuilder.Encrypt<TestClass>(_collectionNamespace, builder =>
+                schemaBuilder.Encrypt<TestClass>(testCollectionNamespace, builder =>
                 {
                     builder.Property(t => t.TestString, BsonType.String);
                 });