added some missing cancellation tokens and fixed incorrect tests

CoreUnitTests/.editorconfig

@@ -0,0 +1,218 @@
+# All Files
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+#########################################
+# File Extension Settings
+##########################################
+
+# .NET Style Rules
+# https://docs.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/language-rules#net-style-rules
+[*.cs]
+# "this." and "Me." qualifiers
+dotnet_style_qualification_for_field = false:warning
+dotnet_style_qualification_for_property = false:warning
+dotnet_style_qualification_for_method = false:warning
+dotnet_style_qualification_for_event = false:warning
+# Language keywords instead of framework type names for type references
+dotnet_style_predefined_type_for_locals_parameters_members = true:warning
+dotnet_style_predefined_type_for_member_access = true:warning
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = always:warning
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
+visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:warning
+dotnet_style_readonly_field = true:warning
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:warning
+# Expression-level preferences
+dotnet_style_object_initializer = true:warning
+dotnet_style_collection_initializer = true:warning
+dotnet_style_explicit_tuple_names = true:warning
+dotnet_style_prefer_inferred_tuple_names = true:warning
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
+dotnet_style_prefer_auto_properties = true:warning
+dotnet_style_prefer_conditional_expression_over_assignment = false:suggestion
+dotnet_diagnostic.IDE0045.severity = suggestion
+dotnet_style_prefer_conditional_expression_over_return = false:suggestion
+dotnet_diagnostic.IDE0046.severity = suggestion
+dotnet_style_prefer_compound_assignment = true:warning
+dotnet_style_prefer_simplified_interpolation = true:warning
+dotnet_style_prefer_simplified_boolean_expressions = true:warning
+# Null-checking preferences
+dotnet_style_coalesce_expression = true:warning
+dotnet_style_null_propagation = true:warning
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
+# File header preferences
+# file_header_template = <copyright file="{fileName}" company="PROJECT-AUTHOR">\n© PROJECT-AUTHOR\n</copyright>
+# If you use StyleCop, you'll need to disable SA1636: File header copyright text should match.
+# dotnet_diagnostic.SA1636.severity = none
+# Undocumented
+dotnet_style_operator_placement_when_wrapping = end_of_line:warning
+csharp_style_prefer_null_check_over_type_check = true:warning
+dotnet_analyzer_diagnostic.severity = warning
+dotnet_code_quality_unused_parameters = all:warning
+dotnet_remove_unnecessary_suppression_exclusions = none:warning
+dotnet_sort_system_directives_first = true
+dotnet_separate_import_directive_groups = false
+dotnet_style_namespace_match_folder = true:suggestion
+dotnet_diagnostic.IDE0130.severity = suggestion
+dotnet_naming_style.camel_case_style.capitalization = camel_case
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+dotnet_naming_style.first_upper_style.capitalization = first_word_upper
+dotnet_naming_style.prefix_interface_with_i_style.capitalization = pascal_case
+dotnet_naming_style.prefix_interface_with_i_style.required_prefix = I
+dotnet_naming_style.prefix_type_parameters_with_t_style.capitalization = pascal_case
+dotnet_naming_style.prefix_type_parameters_with_t_style.required_prefix = T
+dotnet_naming_style.disallowed_style.capitalization  = pascal_case
+dotnet_naming_style.disallowed_style.required_prefix = ____RULE_VIOLATION____
+dotnet_naming_style.disallowed_style.required_suffix = ____RULE_VIOLATION____
+dotnet_naming_style.internal_error_style.capitalization  = pascal_case
+dotnet_naming_style.internal_error_style.required_prefix = ____INTERNAL_ERROR____
+dotnet_naming_style.internal_error_style.required_suffix = ____INTERNAL_ERROR____
+dotnet_naming_symbols.public_protected_constant_fields_group.applicable_accessibilities = public, protected, protected_internal
+dotnet_naming_symbols.public_protected_constant_fields_group.required_modifiers         = const
+dotnet_naming_symbols.public_protected_constant_fields_group.applicable_kinds           = field
+dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.symbols    = public_protected_constant_fields_group
+dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.style      = pascal_case_style
+dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.severity   = warning
+dotnet_naming_symbols.public_protected_static_readonly_fields_group.applicable_accessibilities = public, protected, protected_internal
+dotnet_naming_symbols.public_protected_static_readonly_fields_group.required_modifiers         = static, readonly
+dotnet_naming_symbols.public_protected_static_readonly_fields_group.applicable_kinds           = field
+dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.symbols    = public_protected_static_readonly_fields_group
+dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.style      = pascal_case_style
+dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.severity   = warning
+dotnet_naming_symbols.other_public_protected_fields_group.applicable_accessibilities = public, protected, protected_internal
+dotnet_naming_symbols.other_public_protected_fields_group.applicable_kinds           = field
+dotnet_naming_rule.other_public_protected_fields_disallowed_rule.symbols             = other_public_protected_fields_group
+dotnet_naming_rule.other_public_protected_fields_disallowed_rule.style               = disallowed_style
+dotnet_naming_rule.other_public_protected_fields_disallowed_rule.severity            = error
+dotnet_naming_symbols.stylecop_constant_fields_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected, private
+dotnet_naming_symbols.stylecop_constant_fields_group.required_modifiers         = const
+dotnet_naming_symbols.stylecop_constant_fields_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.symbols    = stylecop_constant_fields_group
+dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.style      = pascal_case_style
+dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.severity   = warning
+dotnet_naming_symbols.stylecop_static_readonly_fields_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected, private
+dotnet_naming_symbols.stylecop_static_readonly_fields_group.required_modifiers         = static, readonly
+dotnet_naming_symbols.stylecop_static_readonly_fields_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.symbols    = stylecop_static_readonly_fields_group
+dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.style      = pascal_case_style
+dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.severity   = warning
+dotnet_naming_symbols.stylecop_fields_must_be_private_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected
+dotnet_naming_symbols.stylecop_fields_must_be_private_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.symbols               = stylecop_fields_must_be_private_group
+dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.style                 = disallowed_style
+dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.severity              = error
+dotnet_naming_symbols.stylecop_private_fields_group.applicable_accessibilities = private
+dotnet_naming_symbols.stylecop_private_fields_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.symbols     = stylecop_private_fields_group
+dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.style       = camel_case_style
+dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.severity    = warning
+dotnet_naming_symbols.stylecop_local_fields_group.applicable_accessibilities = local
+dotnet_naming_symbols.stylecop_local_fields_group.applicable_kinds           = local
+dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.symbols     = stylecop_local_fields_group
+dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.style       = camel_case_style
+dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.severity    = silent
+dotnet_naming_symbols.sanity_check_uncovered_field_case_group.applicable_accessibilities = *
+dotnet_naming_symbols.sanity_check_uncovered_field_case_group.applicable_kinds           = field
+dotnet_naming_rule.sanity_check_uncovered_field_case_rule.symbols  = sanity_check_uncovered_field_case_group
+dotnet_naming_rule.sanity_check_uncovered_field_case_rule.style    = internal_error_style
+dotnet_naming_rule.sanity_check_uncovered_field_case_rule.severity = error
+dotnet_naming_symbols.element_group.applicable_kinds = namespace, class, enum, struct, delegate, event, method, property
+dotnet_naming_rule.element_rule.symbols              = element_group
+dotnet_naming_rule.element_rule.style                = pascal_case_style
+dotnet_naming_rule.element_rule.severity             = warning
+dotnet_naming_symbols.interface_group.applicable_kinds = interface
+dotnet_naming_rule.interface_rule.symbols              = interface_group
+dotnet_naming_rule.interface_rule.style                = prefix_interface_with_i_style
+dotnet_naming_rule.interface_rule.severity             = warning
+dotnet_naming_symbols.type_parameter_group.applicable_kinds = type_parameter
+dotnet_naming_rule.type_parameter_rule.symbols              = type_parameter_group
+dotnet_naming_rule.type_parameter_rule.style                = prefix_type_parameters_with_t_style
+dotnet_naming_rule.type_parameter_rule.severity             = warning
+dotnet_naming_symbols.parameters_group.applicable_kinds = parameter
+dotnet_naming_rule.parameters_rule.symbols              = parameters_group
+dotnet_naming_rule.parameters_rule.style                = camel_case_style
+dotnet_naming_rule.parameters_rule.severity             = warning
+csharp_style_var_for_built_in_types = true:warning
+csharp_style_var_when_type_is_apparent = true:warning
+csharp_style_var_elsewhere = true:warning
+csharp_style_expression_bodied_methods = true:warning
+csharp_style_expression_bodied_constructors = true:warning
+csharp_style_expression_bodied_operators = true:warning
+csharp_style_expression_bodied_properties = true:warning
+csharp_style_expression_bodied_indexers = true:warning
+csharp_style_expression_bodied_accessors = true:warning
+csharp_style_expression_bodied_lambdas = true:warning
+csharp_style_expression_bodied_local_functions = true:warning
+csharp_style_pattern_matching_over_is_with_cast_check = true:warning
+csharp_style_pattern_matching_over_as_with_null_check = true:warning
+csharp_style_prefer_switch_expression = true:warning
+csharp_style_prefer_pattern_matching = true:warning
+csharp_style_prefer_not_pattern = true:warning
+csharp_style_inlined_variable_declaration = true:warning
+csharp_prefer_simple_default_expression = true:warning
+csharp_style_pattern_local_over_anonymous_function = true:warning
+csharp_style_deconstructed_variable_declaration = true:warning
+csharp_style_prefer_index_operator = true:warning
+csharp_style_prefer_range_operator = true:warning
+csharp_style_implicit_object_creation_when_type_is_apparent = true:warning
+csharp_style_throw_expression = true:warning
+csharp_style_conditional_delegate_call = true:warning
+csharp_prefer_braces = true:warning
+csharp_prefer_simple_using_statement = true:suggestion
+dotnet_diagnostic.IDE0063.severity = suggestion
+csharp_using_directive_placement = outside_namespace
+csharp_prefer_static_local_function = true:warning
+csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
+dotnet_diagnostic.IDE0058.severity = suggestion
+csharp_style_unused_value_assignment_preference = discard_variable:suggestion
+dotnet_diagnostic.IDE0059.severity = suggestion
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = no_change
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents_when_block = false
+csharp_space_after_cast = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_between_parentheses = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_after_comma = true
+csharp_space_before_comma = false
+csharp_space_after_dot = false
+csharp_space_before_dot = false
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_around_declaration_statements = false
+csharp_space_before_open_square_brackets = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_square_brackets = false
+csharp_preserve_single_line_statements = false
+csharp_preserve_single_line_blocks = true
+csharp_style_namespace_declarations = file_scoped:warning
+dotnet_diagnostic.CA1707.severity = none
+
+

CoreUnitTests/BaseMongoRepositoryTests/AddTests/AddManyTests.cs

@@ -18,7 +18,7 @@ public class AddManyTests : TestMongoRepositoryContext
     {
         // Arrange
         Creator = new Mock<IMongoDbCreator>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         var documents = new List<TestDocument>
         {
             new(), new(), new()

CoreUnitTests/BaseMongoRepositoryTests/AddTests/AddOneTests.cs

@@ -16,7 +16,7 @@ public class AddOneTests : TestMongoRepositoryContext
     {
         // Arrange
         Creator = new Mock<IMongoDbCreator>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         var document = new TestDocument();
 
         // Act

CoreUnitTests/BaseMongoRepositoryTests/DeleteTests/DeleteManyAsyncTests.cs

@@ -42,7 +42,7 @@ public class DeleteManyAsyncTests : TestMongoRepositoryContext
         // Arrange
         var documents = Fixture.CreateMany<TestDocument>().ToList();
         var count = Fixture.Create<long>();
-        var cancellationToken = new CancellationToken();
+        var cancellationToken = new CancellationToken(true);
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
@@ -89,7 +89,7 @@ public class DeleteManyAsyncTests : TestMongoRepositoryContext
         // Arrange
         var content = Fixture.Create<string>();
         var count = Fixture.Create<long>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == content;
 
@@ -144,7 +144,7 @@ public class DeleteManyAsyncTests : TestMongoRepositoryContext
         var content = Fixture.Create<string>();
         var count = Fixture.Create<long>();
         var partitionKey = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == content;
 
@@ -193,19 +193,20 @@ public class DeleteManyAsyncTests : TestMongoRepositoryContext
         // Arrange
         var documents = Fixture.CreateMany<TestDocumentWithKey<int>>().ToList();
         var count = Fixture.Create<long>();
-        var cancellationToken = new CancellationToken();
+        var cancellationToken = new CancellationToken(true);
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteManyAsync<TestDocumentWithKey<int>, int>(It.IsAny<IEnumerable<TestDocumentWithKey<int>>>(), It.IsAny<CancellationToken>()))
+            .Setup(x => x.DeleteManyAsync<TestDocumentWithKey<int>, int>(documents, cancellationToken))
-            .ReturnsAsync(count);
+            .ReturnsAsync(count)
+            .Verifiable();
 
         // Act
         var result = await Sut.DeleteManyAsync<TestDocumentWithKey<int>, int>(documents, cancellationToken);
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteManyAsync<TestDocumentWithKey<int>, int>(documents, cancellationToken), Times.Once);
+        Eraser.Verify();
     }
 
     [Fact]
@@ -240,7 +241,7 @@ public class DeleteManyAsyncTests : TestMongoRepositoryContext
         // Arrange
         var content = Fixture.Create<string>();
         var count = Fixture.Create<long>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 
@@ -295,7 +296,7 @@ public class DeleteManyAsyncTests : TestMongoRepositoryContext
         var content = Fixture.Create<string>();
         var count = Fixture.Create<long>();
         var partitionKey = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 

CoreUnitTests/BaseMongoRepositoryTests/DeleteTests/DeleteOneAsyncTests.cs

@@ -40,7 +40,7 @@ public class DeleteOneAsyncTests : TestMongoRepositoryContext
         // Arrange
         var document = Fixture.Create<TestDocument>();
         var count = Fixture.Create<long>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Eraser = new Mock<IMongoDbEraser>();
 
@@ -85,7 +85,7 @@ public class DeleteOneAsyncTests : TestMongoRepositoryContext
         // Arrange
         var count = Fixture.Create<long>();
         var content = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == content;
 
@@ -134,7 +134,7 @@ public class DeleteOneAsyncTests : TestMongoRepositoryContext
         var count = Fixture.Create<long>();
         var content = Fixture.Create<string>();
         var partitionKey = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == content;
 
@@ -180,7 +180,7 @@ public class DeleteOneAsyncTests : TestMongoRepositoryContext
         // Arrange
         var document = Fixture.Create<TestDocumentWithKey<int>>();
         var count = Fixture.Create<long>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Eraser = new Mock<IMongoDbEraser>();
 
@@ -225,7 +225,7 @@ public class DeleteOneAsyncTests : TestMongoRepositoryContext
         // Arrange
         var count = Fixture.Create<long>();
         var content = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 
@@ -274,7 +274,7 @@ public class DeleteOneAsyncTests : TestMongoRepositoryContext
         var count = Fixture.Create<long>();
         var content = Fixture.Create<string>();
         var partitionKey = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 

CoreUnitTests/BaseMongoRepositoryTests/DeleteTests/DeleteOneTests.cs

@@ -1,15 +1,16 @@
-using System;
+namespace CoreUnitTests.BaseMongoRepositoryTests.DeleteTests;
+
+using System;
 using System.Linq.Expressions;
+using System.Threading;
 using AutoFixture;
-using CoreUnitTests.Infrastructure;
-using CoreUnitTests.Infrastructure.Model;
 using FluentAssertions;
+using Infrastructure;
+using Infrastructure.Model;
 using MongoDbGenericRepository.DataAccess.Delete;
 using Moq;
 using Xunit;
 
-namespace CoreUnitTests.BaseMongoRepositoryTests.DeleteTests;
-
 public class DeleteOneTests : TestMongoRepositoryContext
 {
     [Fact]
@@ -21,7 +22,7 @@ public class DeleteOneTests : TestMongoRepositoryContext
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocument, Guid>(It.IsAny<TestDocument>()))
+            .Setup(x => x.DeleteOne<TestDocument, Guid>(It.IsAny<TestDocument>(), It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -29,7 +30,28 @@ public class DeleteOneTests : TestMongoRepositoryContext
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(document), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(document, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void WithDocumentAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var document = Fixture.Create<TestDocument>();
+        var count = Fixture.Create<long>();
+        var token = new CancellationToken(true);
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(x => x.DeleteOne<TestDocument, Guid>(It.IsAny<TestDocument>(), It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne(document, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(document, token), Times.Once);
     }
 
     [Fact]
@@ -44,7 +66,7 @@ public class DeleteOneTests : TestMongoRepositoryContext
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocument, Guid>(It.IsAny<Expression<Func<TestDocument, bool>>>(), It.IsAny<string>()))
+            .Setup(x => x.DeleteOne<TestDocument, Guid>(It.IsAny<Expression<Func<TestDocument, bool>>>(), It.IsAny<string>(), It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -52,7 +74,35 @@ public class DeleteOneTests : TestMongoRepositoryContext
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(filter, null), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(filter, null, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void WithFilterAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var content = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == content;
+
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(
+                x => x.DeleteOne<TestDocument, Guid>(
+                    It.IsAny<Expression<Func<TestDocument, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne(filter, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(filter, null, token), Times.Once);
     }
 
     [Fact]
@@ -68,7 +118,11 @@ public class DeleteOneTests : TestMongoRepositoryContext
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocument, Guid>(It.IsAny<Expression<Func<TestDocument, bool>>>(), It.IsAny<string>()))
+            .Setup(
+                x => x.DeleteOne<TestDocument, Guid>(
+                    It.IsAny<Expression<Func<TestDocument, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -76,7 +130,36 @@ public class DeleteOneTests : TestMongoRepositoryContext
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(filter, partitionKey), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(filter, partitionKey, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void WithFilterAndPartitionKeyAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var content = Fixture.Create<string>();
+        var partitionKey = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        Expression<Func<TestDocument, bool>> filter = x => x.SomeContent == content;
+
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(
+                x => x.DeleteOne<TestDocument, Guid>(
+                    It.IsAny<Expression<Func<TestDocument, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne(filter, partitionKey, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocument, Guid>(filter, partitionKey, token), Times.Once);
     }
 
     [Fact]
@@ -88,7 +171,7 @@ public class DeleteOneTests : TestMongoRepositoryContext
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<TestDocumentWithKey<int>>()))
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<TestDocumentWithKey<int>>(), It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -96,8 +179,30 @@ public class DeleteOneTests : TestMongoRepositoryContext
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(document), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(document, CancellationToken.None), Times.Once);
     }
+
+    [Fact]
+    public void WithKeyedDocumentAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var document = Fixture.Create<TestDocumentWithKey<int>>();
+        var count = Fixture.Create<long>();
+        var token = new CancellationToken(true);
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<TestDocumentWithKey<int>>(), It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne<TestDocumentWithKey<int>, int>(document, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(document, token), Times.Once);
+    }
+
     [Fact]
     public void Keyed_WithFilter_ShouldDeleteOne()
     {
@@ -110,7 +215,11 @@ public class DeleteOneTests : TestMongoRepositoryContext
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(), It.IsAny<string>()))
+            .Setup(
+                x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                    It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -118,7 +227,35 @@ public class DeleteOneTests : TestMongoRepositoryContext
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, null), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, null, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void Keyed_WithFilterAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var content = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
+
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(
+                x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                    It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne<TestDocumentWithKey<int>, int>(filter, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, null, token), Times.Once);
     }
 
     [Fact]
@@ -134,7 +271,11 @@ public class DeleteOneTests : TestMongoRepositoryContext
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(), It.IsAny<string>()))
+            .Setup(
+                x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                    It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -142,6 +283,35 @@ public class DeleteOneTests : TestMongoRepositoryContext
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void Keyed_WithFilterAndPartitionKeyAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var content = Fixture.Create<string>();
+        var partitionKey = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
+
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(
+                x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                    It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey, token), Times.Once);
     }
 }

CoreUnitTests/BaseMongoRepositoryTests/IndexTests/CreateAscendingIndexTests.cs

@@ -16,7 +16,7 @@ public class CreateAscendingIndexTests : BaseIndexTests
     {
         // Arrange
         IndexHandler = new Mock<IMongoDbIndexHandler>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         // Act
         Expression<Func<TestDocument, object>> fieldExpression = t => t.SomeContent2;

CoreUnitTests/BaseMongoRepositoryTests/IndexTests/CreateTextIndexTests.cs

@@ -67,7 +67,7 @@ public class CreateTextIndexTests : BaseIndexTests
     {
         // Arrange
         IndexHandler = new Mock<IMongoDbIndexHandler>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         // Act
         await Sut.CreateTextIndexAsync<TestDocument>(_fieldExpression, token);
@@ -82,7 +82,7 @@ public class CreateTextIndexTests : BaseIndexTests
     {
         // Arrange
         IndexHandler = new Mock<IMongoDbIndexHandler>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         var options = new IndexCreationOptions { Name = "theIndexName" };
 
         // Act
@@ -99,7 +99,7 @@ public class CreateTextIndexTests : BaseIndexTests
     {
         // Arrange
         const string partitionKey = "thePartitionKey";
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         IndexHandler = new Mock<IMongoDbIndexHandler>();
 
         // Act
@@ -130,7 +130,7 @@ public class CreateTextIndexTests : BaseIndexTests
     {
         // Arrange
         IndexHandler = new Mock<IMongoDbIndexHandler>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         // Act
         await Sut.CreateTextIndexAsync<TestDocumentWithKey, int>(t => t.SomeContent2, token);
@@ -179,7 +179,7 @@ public class CreateTextIndexTests : BaseIndexTests
         // Arrange
         const string partitionKey = "thePartitionKey";
         const string indexName = "theIndexName";
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         var options = new IndexCreationOptions { Name = indexName };
         IndexHandler = new Mock<IMongoDbIndexHandler>();
 

CoreUnitTests/BaseMongoRepositoryTests/IndexTests/GetIndexNamesTests.cs

@@ -37,7 +37,7 @@ public class GetIndexNamesTests : BaseIndexTests
     {
         // Arrange
         const string indexName = "theIndexName";
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         IndexHandler = new Mock<IMongoDbIndexHandler>();
         IndexHandler
             .Setup(x => x.GetIndexesNamesAsync<TestDocument, Guid>(null, token))
@@ -78,7 +78,7 @@ public class GetIndexNamesTests : BaseIndexTests
         // Arrange
         const string partitionKey = "thePartitionKey";
         const string indexName = "theIndexName";
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         IndexHandler = new Mock<IMongoDbIndexHandler>();
         IndexHandler
@@ -117,7 +117,7 @@ public class GetIndexNamesTests : BaseIndexTests
     {
         // Arrange
         const string indexName = "theIndexName";
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
         IndexHandler = new Mock<IMongoDbIndexHandler>();
         IndexHandler
             .Setup(x => x.GetIndexesNamesAsync<TestDocumentWithKey, int>(null, token))
@@ -157,7 +157,7 @@ public class GetIndexNamesTests : BaseIndexTests
         // Arrange
         const string indexName = "theIndexName";
         const string partitionKey = "thePartitionKey";
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         IndexHandler = new Mock<IMongoDbIndexHandler>();
         IndexHandler

CoreUnitTests/BaseMongoRepositoryTests/MainTests/AnyTests.cs

@@ -16,7 +16,7 @@ public class AnyTests : TestMongoRepositoryContext
     public async Task AnyAsync_EnsureTokenPassed()
     {
         // Arrange
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Reader = new Mock<IMongoDbReader>();
         Reader

CoreUnitTests/BaseMongoRepositoryTests/MainTests/CountTests.cs

@@ -16,7 +16,7 @@ public class CountTests : TestMongoRepositoryContext
     public async Task CountAsync_EnsureTokenPassed()
     {
         // Arrange
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Reader = new Mock<IMongoDbReader>();
         Reader

CoreUnitTests/CoreUnitTests.csproj

@@ -5,10 +5,13 @@
         <Nullable>warnings</Nullable>
 
         <IsPackable>false</IsPackable>
+        <EnableNETAnalyzers>true</EnableNETAnalyzers>
+        <AnalysisLevel>latest</AnalysisLevel>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="AutoFixture" Version="4.18.0" />
+        <PackageReference Include="AutoFixture.AutoMoq" Version="4.18.0" />
         <PackageReference Include="FluentAssertions" Version="6.11.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
         <PackageReference Include="Moq" Version="4.18.4" />

CoreUnitTests/DataAccessTests/MongoDbEraserTests/DeleteOneTests.cs

@@ -0,0 +1,202 @@
+using System;
+using System.Linq.Expressions;
+using System.Threading;
+using AutoFixture;
+using CoreUnitTests.Infrastructure;
+using CoreUnitTests.Infrastructure.Model;
+using FluentAssertions;
+using MongoDB.Driver;
+using MongoDbGenericRepository;
+using MongoDbGenericRepository.DataAccess.Delete;
+using Moq;
+using Xunit;
+
+namespace CoreUnitTests.DataAccessTests.MongoDbEraserTests;
+
+public class DeleteOneTests : GenericTestContext<MongoDbEraser>
+{
+    [Fact]
+    public void WithDocument_DeletesOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var document = Fixture.Create<TestDocument>();
+        var collection = MockOf<IMongoCollection<TestDocument>>();
+
+        collection
+            .Setup(x => x.DeleteOne(It.IsAny<FilterDefinition<TestDocument>>(), It.IsAny<CancellationToken>()))
+            .Returns(new DeleteResult.Acknowledged(count));
+
+        var dbContext = MockOf<IMongoDbContext>();
+        dbContext
+            .Setup(x => x.GetCollection<TestDocument>(null))
+            .Returns(Fixture.Create<IMongoCollection<TestDocument>>());
+
+        // Act
+        var result = Sut.DeleteOne<TestDocument, Guid>(document);
+
+        // Assert
+        result.Should().Be(count);
+
+        var expectedFilter = Builders<TestDocument>.Filter.Eq("Id", document.Id);
+        collection.Verify(
+            x => x.DeleteOne(
+                It.Is<FilterDefinition<TestDocument>>(f => f.EquivalentTo(expectedFilter)),
+                CancellationToken.None));
+    }
+
+    [Fact]
+    public void WithDocumentAndCancellationToken_DeletesOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var document = Fixture.Create<TestDocument>();
+        var token = new CancellationToken(true);
+
+        var collection = MockOf<IMongoCollection<TestDocument>>();
+        collection
+            .Setup(x => x.DeleteOne(It.IsAny<FilterDefinition<TestDocument>>(), It.IsAny<CancellationToken>()))
+            .Returns(new DeleteResult.Acknowledged(count));
+
+        var dbContext = MockOf<IMongoDbContext>();
+        dbContext
+            .Setup(x => x.GetCollection<TestDocument>(null))
+            .Returns(Fixture.Create<IMongoCollection<TestDocument>>());
+
+        // Act
+        var result = Sut.DeleteOne<TestDocument, Guid>(document, token);
+
+        // Assert
+        result.Should().Be(count);
+
+        var expectedFilter = Builders<TestDocument>.Filter.Eq("Id", document.Id);
+        collection.Verify(
+            x => x.DeleteOne(
+                It.Is<FilterDefinition<TestDocument>>(f => f.EquivalentTo(expectedFilter)),
+                token));
+    }
+
+    [Fact]
+    public void WithFilter_DeletesOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var document = Fixture.Create<TestDocument>();
+
+        var collection = MockOf<IMongoCollection<TestDocument>>();
+        collection
+            .Setup(x => x.DeleteOne(It.IsAny<FilterDefinition<TestDocument>>(), It.IsAny<CancellationToken>()))
+            .Returns(new DeleteResult.Acknowledged(count));
+
+        var dbContext = MockOf<IMongoDbContext>();
+        dbContext
+            .Setup(x => x.GetCollection<TestDocument>(null))
+            .Returns(Fixture.Create<IMongoCollection<TestDocument>>());
+
+        Expression<Func<TestDocument, bool>> filter = d => d.SomeContent == document.SomeContent;
+
+        // Act
+        var result = Sut.DeleteOne<TestDocument, Guid>(filter);
+
+        // Assert
+        result.Should().Be(count);
+        collection.Verify(
+            x => x.DeleteOne(
+            It.Is<FilterDefinition<TestDocument>>(f => f.EquivalentTo(filter)), CancellationToken.None));
+    }
+
+    [Fact]
+    public void WithFilterAndCancellationToken_DeletesOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var document = Fixture.Create<TestDocument>();
+        var token = new CancellationToken(true);
+
+        var collection = MockOf<IMongoCollection<TestDocument>>();
+        collection
+            .Setup(x => x.DeleteOne(It.IsAny<FilterDefinition<TestDocument>>(), It.IsAny<CancellationToken>()))
+            .Returns(new DeleteResult.Acknowledged(count));
+
+        var dbContext = MockOf<IMongoDbContext>();
+        dbContext
+            .Setup(x => x.GetCollection<TestDocument>(null))
+            .Returns(Fixture.Create<IMongoCollection<TestDocument>>());
+
+        Expression<Func<TestDocument, bool>> filter = d => d.Id == document.Id;
+
+        // Act
+        var result = Sut.DeleteOne<TestDocument, Guid>(filter, cancellationToken: token);
+
+        // Assert
+        result.Should().Be(count);
+        collection.Verify(
+            x => x.DeleteOne(
+                It.Is<FilterDefinition<TestDocument>>(f => f.EquivalentTo(filter)), token));
+    }
+
+    [Fact]
+    public void WithFilterAndPartitionKey_DeletesOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var document = Fixture.Create<TestDocument>();
+        var partitionKey = Fixture.Create<string>();
+
+        var collection = MockOf<IMongoCollection<TestDocument>>();
+        collection
+            .Setup(x => x.DeleteOne(It.IsAny<FilterDefinition<TestDocument>>(), It.IsAny<CancellationToken>()))
+            .Returns(new DeleteResult.Acknowledged(count));
+
+        var dbContext = MockOf<IMongoDbContext>();
+        dbContext
+            .Setup(x => x.GetCollection<TestDocument>(It.IsAny<string>()))
+            .Returns(Fixture.Create<IMongoCollection<TestDocument>>());
+
+        Expression<Func<TestDocument, bool>> filter = d => d.Id == document.Id;
+
+        // Act
+        var result = Sut.DeleteOne<TestDocument, Guid>(filter, partitionKey);
+
+        // Assert
+        result.Should().Be(count);
+        collection.Verify(
+            x => x.DeleteOne(
+                It.Is<FilterDefinition<TestDocument>>(f => f.EquivalentTo(filter)), CancellationToken.None));
+
+        dbContext.Verify(x => x.GetCollection<TestDocument>(partitionKey));
+    }
+
+    [Fact]
+    public void WithFilterAndPartitionKeyAndCancellationToken_DeletesOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var document = Fixture.Create<TestDocument>();
+        var partitionKey = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        var collection = MockOf<IMongoCollection<TestDocument>>();
+        collection
+            .Setup(x => x.DeleteOne(It.IsAny<FilterDefinition<TestDocument>>(), It.IsAny<CancellationToken>()))
+            .Returns(new DeleteResult.Acknowledged(count));
+
+        var dbContext = MockOf<IMongoDbContext>();
+        dbContext
+            .Setup(x => x.GetCollection<TestDocument>(It.IsAny<string>()))
+            .Returns(Fixture.Create<IMongoCollection<TestDocument>>());
+
+        Expression<Func<TestDocument, bool>> filter = d => d.Id == document.Id;
+
+        // Act
+        var result = Sut.DeleteOne<TestDocument, Guid>(filter, partitionKey, token);
+
+        // Assert
+        result.Should().Be(count);
+        collection.Verify(
+            x => x.DeleteOne(
+                It.Is<FilterDefinition<TestDocument>>(f => f.EquivalentTo(filter)), token));
+
+        dbContext.Verify(x => x.GetCollection<TestDocument>(partitionKey));
+    }
+}

CoreUnitTests/Infrastructure/FilterDefinitionExtensions.cs

@@ -0,0 +1,14 @@
+namespace CoreUnitTests.Infrastructure;
+
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver;
+
+public static class FilterDefinitionExtensions
+{
+    public static string RenderToJson<TDocument>(this FilterDefinition<TDocument> filter)
+        => filter.Render(BsonSerializer.SerializerRegistry.GetSerializer<TDocument>(), BsonSerializer.SerializerRegistry).ToJson();
+
+    public static bool EquivalentTo<TDocument>(this FilterDefinition<TDocument> filter, FilterDefinition<TDocument> other)
+        => filter.RenderToJson() == other.RenderToJson();
+}

CoreUnitTests/Infrastructure/GenericTestContext.cs

@@ -0,0 +1,23 @@
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Moq;
+
+namespace CoreUnitTests.Infrastructure;
+
+public class GenericTestContext<TSut>
+{
+    public GenericTestContext()
+    {
+        Fixture = new Fixture().Customize(new AutoMoqCustomization());
+    }
+
+    protected Mock<T> MockOf<T>()
+        where T : class
+    {
+        return Fixture.Freeze<Mock<T>>();
+    }
+
+    protected IFixture Fixture { get; set; }
+
+    protected TSut Sut { get => Fixture.Create<TSut>(); }
+}

CoreUnitTests/Infrastructure/Model/PartitionedTestDocument.cs

@@ -0,0 +1,9 @@
+using MongoDbGenericRepository.Models;
+
+namespace CoreUnitTests.Infrastructure.Model;
+
+public class PartitionedTestDocument : TestDocument, IPartitionedDocument
+{
+    /// <inheritdoc />
+    public string PartitionKey { get; set; } = "PartitionedTestDocument";
+}

CoreUnitTests/KeyTypedRepositoryTests/DeleteTests/DeleteManyAsyncTests.cs

@@ -42,7 +42,7 @@ public class DeleteManyAsyncTests : TestKeyedMongoRepositoryContext<int>
         // Arrange
         var documents = Fixture.CreateMany<TestDocumentWithKey<int>>().ToList();
         var count = Fixture.Create<long>();
-        var cancellationToken = new CancellationToken();
+        var cancellationToken = new CancellationToken(true);
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
@@ -89,7 +89,7 @@ public class DeleteManyAsyncTests : TestKeyedMongoRepositoryContext<int>
         // Arrange
         var content = Fixture.Create<string>();
         var count = Fixture.Create<long>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 
@@ -144,7 +144,7 @@ public class DeleteManyAsyncTests : TestKeyedMongoRepositoryContext<int>
         var content = Fixture.Create<string>();
         var count = Fixture.Create<long>();
         var partitionKey = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 

CoreUnitTests/KeyTypedRepositoryTests/DeleteTests/DeleteOneAsyncTests.cs

@@ -40,7 +40,7 @@ public class DeleteOneAsyncTests : TestKeyedMongoRepositoryContext<int>
         // Arrange
         var document = Fixture.Create<TestDocumentWithKey<int>>();
         var count = Fixture.Create<long>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Eraser = new Mock<IMongoDbEraser>();
 
@@ -85,7 +85,7 @@ public class DeleteOneAsyncTests : TestKeyedMongoRepositoryContext<int>
         // Arrange
         var count = Fixture.Create<long>();
         var content = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 
@@ -134,7 +134,7 @@ public class DeleteOneAsyncTests : TestKeyedMongoRepositoryContext<int>
         var count = Fixture.Create<long>();
         var content = Fixture.Create<string>();
         var partitionKey = Fixture.Create<string>();
-        var token = new CancellationToken();
+        var token = new CancellationToken(true);
 
         Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
 

CoreUnitTests/KeyTypedRepositoryTests/DeleteTests/DeleteOneTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq.Expressions;
+using System.Threading;
 using AutoFixture;
 using CoreUnitTests.Infrastructure;
 using CoreUnitTests.Infrastructure.Model;
@@ -21,7 +22,9 @@ public class DeleteOneTests : TestKeyedMongoRepositoryContext<int>
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<TestDocumentWithKey<int>>()))
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                It.IsAny<TestDocumentWithKey<int>>(),
+                It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -29,7 +32,30 @@ public class DeleteOneTests : TestKeyedMongoRepositoryContext<int>
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(document), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(document, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void WithDocumentAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var document = Fixture.Create<TestDocumentWithKey<int>>();
+        var count = Fixture.Create<long>();
+        var token = new CancellationToken(true);
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                It.IsAny<TestDocumentWithKey<int>>(),
+                It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne(document, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(document, token), Times.Once);
     }
 
     [Fact]
@@ -44,7 +70,10 @@ public class DeleteOneTests : TestKeyedMongoRepositoryContext<int>
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(), It.IsAny<string>()))
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -52,7 +81,34 @@ public class DeleteOneTests : TestKeyedMongoRepositoryContext<int>
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, null), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, null, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void WithFilterAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var content = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
+
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne(filter, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, null, token), Times.Once);
     }
 
     [Fact]
@@ -68,7 +124,10 @@ public class DeleteOneTests : TestKeyedMongoRepositoryContext<int>
         Eraser = new Mock<IMongoDbEraser>();
 
         Eraser
-            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(), It.IsAny<string>()))
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
             .Returns(count);
 
         // Act
@@ -76,6 +135,34 @@ public class DeleteOneTests : TestKeyedMongoRepositoryContext<int>
 
         // Assert
         result.Should().Be(count);
-        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey), Times.Once);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey, CancellationToken.None), Times.Once);
+    }
+
+    [Fact]
+    public void WithFilterAndPartitionKeyAndCancellationToken_ShouldDeleteOne()
+    {
+        // Arrange
+        var count = Fixture.Create<long>();
+        var content = Fixture.Create<string>();
+        var partitionKey = Fixture.Create<string>();
+        var token = new CancellationToken(true);
+
+        Expression<Func<TestDocumentWithKey<int>, bool>> filter = x => x.SomeContent == content;
+
+        Eraser = new Mock<IMongoDbEraser>();
+
+        Eraser
+            .Setup(x => x.DeleteOne<TestDocumentWithKey<int>, int>(
+                It.IsAny<Expression<Func<TestDocumentWithKey<int>, bool>>>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
+            .Returns(count);
+
+        // Act
+        var result = Sut.DeleteOne(filter, partitionKey, token);
+
+        // Assert
+        result.Should().Be(count);
+        Eraser.Verify(x => x.DeleteOne<TestDocumentWithKey<int>, int>(filter, partitionKey, token), Times.Once);
     }
 }

MongoDbGenericRepository/BaseMongoRepository.Delete.cs

@@ -36,6 +36,49 @@ namespace MongoDbGenericRepository
 
         #region Delete
 
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(TDocument document)
+            where TDocument : IDocument<Guid>
+        {
+            return DeleteOne(document, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(TDocument document, CancellationToken cancellationToken)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, Guid>(document, cancellationToken);
+        }
+
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter)
+            where TDocument : IDocument<Guid>
+        {
+            return DeleteOne(filter, null, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, CancellationToken cancellationToken)
+            where TDocument : IDocument<Guid>
+        {
+            return DeleteOne(filter, null, cancellationToken);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey)
+            where TDocument : IDocument<Guid>
+        {
+            return DeleteOne(filter, partitionKey, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, Guid>(filter, partitionKey, cancellationToken);
+        }
+
         /// <inheritdoc />
         public virtual async Task<long> DeleteOneAsync<TDocument>(TDocument document)
             where TDocument : IDocument<Guid>
@@ -50,20 +93,6 @@ namespace MongoDbGenericRepository
             return await MongoDbEraser.DeleteOneAsync<TDocument, Guid>(document, cancellationToken);
         }
 
-        /// <inheritdoc />
-        public virtual long DeleteOne<TDocument>(TDocument document)
-            where TDocument : IDocument<Guid>
-        {
-            return MongoDbEraser.DeleteOne<TDocument, Guid>(document);
-        }
-
-        /// <inheritdoc />
-
-        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<Guid>
-        {
-            return MongoDbEraser.DeleteOne<TDocument, Guid>(filter, partitionKey);
-        }
 
         /// <inheritdoc />
         public virtual async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter)
@@ -118,7 +147,7 @@ namespace MongoDbGenericRepository
         public async Task<long> DeleteManyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
             where TDocument : IDocument<Guid>
         {
-            return await MongoDbEraser.DeleteManyAsync<TDocument, Guid>(filter, partitionKey, CancellationToken.None);
+            return await MongoDbEraser.DeleteManyAsync<TDocument, Guid>(filter, partitionKey, cancellationToken);
         }
 
         /// <inheritdoc />
@@ -158,15 +187,47 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return MongoDbEraser.DeleteOne<TDocument, TKey>(document);
+            return DeleteOne<TDocument, TKey>(document, CancellationToken.None);
         }
 
         /// <inheritdoc />
-        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual long DeleteOne<TDocument, TKey>(TDocument document, CancellationToken cancellationToken)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey);
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(document, cancellationToken);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return DeleteOne<TDocument, TKey>(filter, null, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return DeleteOne<TDocument, TKey>(filter, null, cancellationToken);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return DeleteOne<TDocument, TKey>(filter, partitionKey, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey, cancellationToken);
         }
 
         /// <inheritdoc />
@@ -265,13 +326,7 @@ namespace MongoDbGenericRepository
             return await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(documents, cancellationToken);
         }
 
-        /// <summary>
+        /// <inheritdoc />
-        /// Deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
         public virtual long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
@@ -279,14 +334,7 @@ namespace MongoDbGenericRepository
             return MongoDbEraser.DeleteMany<TDocument, TKey>(documents);
         }
 
-        /// <summary>
+        /// <inheritdoc />
-        /// Deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
         public virtual long DeleteMany<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>

MongoDbGenericRepository/DataAccess/Delete/IMongoDbEraser.cs

@@ -19,8 +19,9 @@ namespace MongoDbGenericRepository.DataAccess.Delete
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="document">The document you want to delete.</param>
+        /// <param name="cancellationToken">An optional cancellation token</param>
         /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument, TKey>(TDocument document)
+        long DeleteOne<TDocument, TKey>(TDocument document, CancellationToken cancellationToken = default)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
@@ -31,8 +32,9 @@ namespace MongoDbGenericRepository.DataAccess.Delete
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation token</param>
         /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null, CancellationToken cancellationToken = default)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 

MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs

@@ -1,12 +1,12 @@
-using MongoDB.Driver;
+using System;
-using MongoDbGenericRepository.DataAccess.Base;
-using MongoDbGenericRepository.Models;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
+using MongoDB.Driver;
+using MongoDbGenericRepository.DataAccess.Base;
+using MongoDbGenericRepository.Models;
 
 namespace MongoDbGenericRepository.DataAccess.Delete
 {
@@ -24,12 +24,20 @@ namespace MongoDbGenericRepository.DataAccess.Delete
         #region Delete TKey
 
         /// <inheritdoc />
-        public virtual long DeleteOne<TDocument, TKey>(TDocument document)
+        public virtual long DeleteOne<TDocument, TKey>(TDocument document, CancellationToken cancellationToken = default)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
             var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
-            return HandlePartitioned<TDocument, TKey>(document).DeleteOne(filter).DeletedCount;
+            return HandlePartitioned<TDocument, TKey>(document).DeleteOne(filter, cancellationToken).DeletedCount;
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null, CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(filter, cancellationToken).DeletedCount;
         }
 
         /// <inheritdoc />
@@ -42,15 +50,10 @@ namespace MongoDbGenericRepository.DataAccess.Delete
         }
 
         /// <inheritdoc />
-        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(
-            where TDocument : IDocument<TKey>
+            Expression<Func<TDocument, bool>> filter,
-            where TKey : IEquatable<TKey>
+            string partitionKey,
-        {
+            CancellationToken cancellationToken)
-            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(filter).DeletedCount;
-        }
-
-        /// <inheritdoc />
-        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
@@ -58,7 +61,10 @@ namespace MongoDbGenericRepository.DataAccess.Delete
         }
 
         /// <inheritdoc />
-        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
+        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(
+            Expression<Func<TDocument, bool>> filter,
+            string partitionKey,
+            CancellationToken cancellationToken)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
@@ -85,14 +91,16 @@ namespace MongoDbGenericRepository.DataAccess.Delete
                 {
                     var groupIdsToDelete = group.Select(e => e.Id).ToArray();
                     deleteCount += (await HandlePartitioned<TDocument, TKey>(group.FirstOrDefault())
-                            .DeleteManyAsync(x => groupIdsToDelete.Contains(x.Id), cancellationToken: cancellationToken))
+                            .DeleteManyAsync(x => groupIdsToDelete.Contains(x.Id), cancellationToken))
                         .DeletedCount;
                 }
+
                 return deleteCount;
             }
 
             var idsToDelete = documentList.Select(e => e.Id).ToArray();
-            return (await HandlePartitioned<TDocument, TKey>(documentList.FirstOrDefault()).DeleteManyAsync(x => idsToDelete.Contains(x.Id), cancellationToken: cancellationToken)).DeletedCount;
+            return (await HandlePartitioned<TDocument, TKey>(documentList.FirstOrDefault()).DeleteManyAsync(x => idsToDelete.Contains(x.Id), cancellationToken))
+                .DeletedCount;
         }
 
         /// <summary>
@@ -120,8 +128,9 @@ namespace MongoDbGenericRepository.DataAccess.Delete
                 foreach (var group in documentList.GroupBy(e => ((IPartitionedDocument) e).PartitionKey))
                 {
                     var groupIdsToDelete = group.Select(e => e.Id).ToArray();
-                    deleteCount += (HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).DeleteMany(x => groupIdsToDelete.Contains(x.Id))).DeletedCount;
+                    deleteCount += HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).DeleteMany(x => groupIdsToDelete.Contains(x.Id)).DeletedCount;
                 }
+
                 return deleteCount;
             }
 
@@ -145,6 +154,5 @@ namespace MongoDbGenericRepository.DataAccess.Delete
         }
 
         #endregion
-
     }
 }

MongoDbGenericRepository/IBaseMongoRepository.Delete.cs

@@ -23,6 +23,66 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        ///     Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(TDocument document, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        ///     Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        ///     Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="cancellationToken">The cancellation token</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        ///     Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        ///     Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
         /// <summary>
         ///     Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -46,18 +106,6 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         ///     Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>

MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs

@@ -38,14 +38,42 @@ namespace MongoDbGenericRepository
         public virtual long DeleteOne<TDocument>(TDocument document)
             where TDocument : IDocument<TKey>
         {
-            return MongoDbEraser.DeleteOne<TDocument, TKey>(document);
+            return DeleteOne(document, CancellationToken.None);
         }
 
         /// <inheritdoc />
-        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual long DeleteOne<TDocument>(TDocument document, CancellationToken cancellationToken)
             where TDocument : IDocument<TKey>
         {
-            return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey);
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(document, cancellationToken);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter)
+            where TDocument : IDocument<TKey>
+        {
+            return DeleteOne(filter, null, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+        {
+            return DeleteOne(filter, null, cancellationToken);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey)
+            where TDocument : IDocument<TKey>
+        {
+            return DeleteOne(filter, partitionKey, CancellationToken.None);
+        }
+
+        /// <inheritdoc />
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey, cancellationToken);
         }
 
         /// <inheritdoc />

MongoDbGenericRepository/KeyTypedRepository/IBaseMongoRepository.TKey.Delete.cs

@@ -23,6 +23,56 @@ namespace MongoDbGenericRepository
         long DeleteOne<TDocument>(TDocument document)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(TDocument document, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey, CancellationToken cancellationToken)
+            where TDocument : IDocument<TKey>;
+
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -42,15 +92,6 @@ namespace MongoDbGenericRepository
         Task<long> DeleteOneAsync<TDocument>(TDocument document, CancellationToken cancellationToken)
             where TDocument : IDocument<TKey>;
 
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>;
 
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.