Added grouping functionality and tests.

IntegrationTests/GroupTests/GroupingTests.cs

@@ -0,0 +1,108 @@
+using IntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace IntegrationTests.GroupTests
+{
+    public class GroupingTestsDocument : Document
+    {
+        public GroupingTestsDocument()
+        {
+            Version = 2;
+            Children = new List<Child>();
+        }
+        public string SomeContent { get; set; }
+        public int GroupingKey { get; set; }
+        public List<Child> Children { get; set; }
+    }
+
+    public class ProjectedGroup
+    {
+        public int Key { get; set; }
+        public List<string> Content { get; set; } 
+    }
+
+    public class GroupingTests : BaseMongoDbRepositoryTests<GroupingTestsDocument>
+    {
+        [Test]
+        public void GroupByTProjection()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            for(var i = 0; i < documents.Count - 2; i++)
+            {
+                documents[i].GroupingKey = 1;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            for (var i = 3; i < documents.Count; i++)
+            {
+                documents[i].GroupingKey = 2;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            SUT.AddMany(documents);
+
+            // Act
+
+            var result = SUT.GroupBy<GroupingTestsDocument, int, ProjectedGroup>(
+                            e => e.GroupingKey, g => new ProjectedGroup {
+                                Key = g.Key,
+                                Content = g.Select(doc => doc.SomeContent).ToList()
+                            });
+
+            // Assert
+            var key1Group = result.First(e => e.Key == 1);
+            Assert.NotNull(key1Group);
+            Assert.AreEqual(3, key1Group.Content.Count);
+            var key2Group = result.First(e => e.Key == 2);
+            Assert.NotNull(key2Group);
+            Assert.AreEqual(2, key2Group.Content.Count);
+        }
+
+        [Test]
+        public void FilteredGroupByTProjection()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            for (var i = 0; i < documents.Count - 2; i++)
+            {
+                documents[i].GroupingKey = 4;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            for (var i = 3; i < documents.Count; i++)
+            {
+                documents[i].GroupingKey = 5;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            var guid1 = Guid.NewGuid().ToString("n");
+            var guid2 = Guid.NewGuid().ToString("n");
+            for (var i = 0; i < documents.Count - 1; i++)
+            {
+                documents[i].Children = new List<Child> {
+                    new Child(guid1, guid2)
+                };
+            }
+
+            SUT.AddMany(documents);
+
+            // Act
+            var result = SUT.GroupBy<GroupingTestsDocument, int, ProjectedGroup>(
+                            e => e.Children.Any(c => c.Type == guid1),
+                            e => e.GroupingKey, g => new ProjectedGroup
+                            {
+                                Key = g.Key,
+                                Content = g.Select(doc => doc.SomeContent).ToList()
+                            });
+
+            // Assert
+            var key1Group = result.First(e => e.Key == 4);
+            Assert.NotNull(key1Group);
+            Assert.AreEqual(3, key1Group.Content.Count);
+            var key2Group = result.First(e => e.Key == 5);
+            Assert.NotNull(key2Group);
+            Assert.AreEqual(1, key2Group.Content.Count);
+        }
+    }
+}

IntegrationTests/Infrastructure/Child.cs

@@ -0,0 +1,14 @@
+namespace IntegrationTests.Infrastructure
+{
+    public class Child
+    {
+        public Child(string type, string value)
+        {
+            Type = type;
+            Value = value;
+        }
+
+        public string Type { get; set; }
+        public string Value { get; set; }
+    }
+}

IntegrationTests/IntegrationTests.csproj

@@ -58,8 +58,10 @@
     <Compile Include="DeletePartitionedTests.cs" />
     <Compile Include="DeleteTKeyTests.cs" />
     <Compile Include="DeleteTests.cs" />
+    <Compile Include="GroupTests\GroupingTests.cs" />
     <Compile Include="Infrastructure\BaseMongoDbRepositoryTests.cs" />
     <Compile Include="CreatePartitionedTests.cs" />
+    <Compile Include="Infrastructure\Child.cs" />
     <Compile Include="Infrastructure\ITestRepository.cs" />
     <Compile Include="Infrastructure\TestRepository.cs" />
     <Compile Include="CreateTests.cs" />

IntegrationTests/UpdatePartitionedTKeyTests.cs

@@ -1,8 +1,10 @@
 using IntegrationTests.Infrastructure;
 using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
 using NUnit.Framework;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace IntegrationTests
@@ -18,9 +20,11 @@ namespace IntegrationTests
             Id = Guid.NewGuid();
             Version = 2;
             PartitionKey = "TestPartitionKey";
+            Children = new List<Child>();
         }
         public string PartitionKey { get; set; }
         public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
     }
 
     [TestFixture]
@@ -57,5 +61,57 @@ namespace IntegrationTests
             Assert.IsNotNull(updatedDocument);
             Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
         }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsPartitionedTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedTKeyDocument, Guid>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsPartitionedTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedTKeyDocument, Guid>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
     }
 }

IntegrationTests/UpdatePartitionedTests.cs

@@ -1,6 +1,8 @@
 using IntegrationTests.Infrastructure;
+using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
 using NUnit.Framework;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace IntegrationTests
@@ -10,8 +12,10 @@ namespace IntegrationTests
         public UpdateTestsPartitionedDocument() : base("TestPartitionKey")
         {
             Version = 2;
+            Children = new List<Child>();
         }
         public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
     }
 
     public class UpdatePartitionedTests : BaseMongoDbRepositoryTests<UpdateTestsPartitionedDocument>
@@ -47,5 +51,155 @@ namespace IntegrationTests
             Assert.IsNotNull(updatedDocument);
             Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
         }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedDocument>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsPartitionedDocument>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedDocument>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsPartitionedDocument>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = SUT.UpdateOne(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = await SUT.UpdateOneAsync(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsPartitionedDocument>.Filter.Eq("Id", document.Id);
+            var result = SUT.UpdateOne(filter, x => x.Children, childrenToAdd, document.PartitionKey);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsPartitionedDocument>.Filter.Eq("Id", document.Id);
+            var result = await SUT.UpdateOneAsync(filter, x => x.Children, childrenToAdd, document.PartitionKey);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
     }
 }

IntegrationTests/UpdateTKeyTests.cs

@@ -1,8 +1,10 @@
 using IntegrationTests.Infrastructure;
 using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
 using NUnit.Framework;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace IntegrationTests
@@ -17,8 +19,10 @@ namespace IntegrationTests
         {
             Id = Guid.NewGuid();
             Version = 2;
+            Children = new List<Child>();
         }
         public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
     }
 
     [TestFixture]
@@ -55,5 +59,137 @@ namespace IntegrationTests
             Assert.IsNotNull(updatedDocument);
             Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
         }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var filter = Builders<UpdateTestsTKeyDocument>.Filter.Eq("Id", document.Id);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid, List<Child>>(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var filter = Builders<UpdateTestsTKeyDocument>.Filter.Eq("Id", document.Id);
+
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsTKeyDocument, Guid, List<Child>>(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var filter = Builders<UpdateTestsTKeyDocument>.Filter.Eq("Id", document.Id);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid, List<Child>>(filter, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
     }
 }

IntegrationTests/UpdateTests.cs

@@ -1,6 +1,8 @@
 using IntegrationTests.Infrastructure;
+using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
 using NUnit.Framework;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace IntegrationTests
@@ -10,8 +12,10 @@ namespace IntegrationTests
         public UpdateTestsDocument()
         {
             Version = 2;
+            Children = new List<Child>();
         }
         public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
     }
 
     public class UpdateTests : BaseMongoDbRepositoryTests<UpdateTestsDocument>
@@ -47,5 +51,155 @@ namespace IntegrationTests
             Assert.IsNotNull(updatedDocument);
             Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
         }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = await SUT.UpdateOneAsync(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = SUT.UpdateOne(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = await SUT.UpdateOneAsync(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsDocument>.Filter.Eq("Id", document.Id);
+            var result = SUT.UpdateOne(filter, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsDocument>.Filter.Eq("Id", document.Id);
+            var result = await SUT.UpdateOneAsync(filter, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
     }
 }