more tests

Author: KSemenenko

tests/ManagedCode.Presidio.Anonymizer.Tests/BatchAnonymizerEngineTests.cs

@@ -10,7 +10,8 @@ public sealed class BatchAnonymizerEngineTests
     public void AnonymizeDictReplacesValues()
     {
         var texts = new[] { "John", "Jill", "Jack" };
-        var recognizerResults = new[] { PersonEntity, PersonEntity, PersonEntity };
+
+        _ = new[] { PersonEntity, PersonEntity, PersonEntity };
 
         var engine = new BatchAnonymizerEngine();
         var input = new[]

tests/ManagedCode.Presidio.Anonymizer.Tests/DeanonymizeEngineTests.cs

@@ -82,7 +82,7 @@ public void EncryptThenDecryptRoundTrips()
         var anonymizerEngine = new AnonymizerEngine();
         var anonymized = anonymizerEngine.Anonymize(
             text,
-            recognizerResults,
+            ToCore(recognizerResults),
             new Dictionary<string, OperatorConfig>
             {
                 ["PERSON"] = new OperatorConfig("encrypt", new Dictionary<string, object?>
@@ -94,7 +94,7 @@ public void EncryptThenDecryptRoundTrips()
         var deanonymizeEngine = new DeanonymizeEngine();
         var deanonymized = deanonymizeEngine.Deanonymize(
             anonymized.Text!,
-            anonymized.Items,
+            anonymized.Items.ToList(),
             new Dictionary<string, OperatorConfig>
             {
                 ["PERSON"] = new OperatorConfig("decrypt", new Dictionary<string, object?>
@@ -139,7 +139,7 @@ public void CustomOperatorRoundTrip()
         anonymizer.AddAnonymizer(typeof(ReverserAnonymizeOperator));
         var anonymized = anonymizer.Anonymize(
             text,
-            recognizerResults,
+            ToCore(recognizerResults),
             new Dictionary<string, OperatorConfig>
             {
                 ["WORD"] = new OperatorConfig("Reverser")
@@ -151,7 +151,7 @@ public void CustomOperatorRoundTrip()
         deanonymizer.AddDeanonymizer(typeof(ReverserDeanonymizeOperator));
         var restored = deanonymizer.Deanonymize(
             anonymized.Text!,
-            anonymized.Items,
+            anonymized.Items.ToList(),
             new Dictionary<string, OperatorConfig>
             {
                 ["WORD"] = new OperatorConfig("Reverser")
@@ -160,6 +160,11 @@ public void CustomOperatorRoundTrip()
         Assert.Equal(text, restored.Text);
     }
 
+    private static IReadOnlyCollection<ManagedCode.Presidio.Core.RecognizerResult> ToCore(IEnumerable<RecognizerResult> results)
+    {
+        return results.Select(result => result.ToCore()).ToList();
+    }
+
     private sealed class CustomDeanonymizer : Operator
     {
         public override string Operate(string text, IDictionary<string, object?>? parameters = null) => text;

tests/ManagedCode.Presidio.Anonymizer.Tests/KeepOperatorTests.cs

@@ -7,18 +7,30 @@ public sealed class KeepOperatorTests
     [Fact]
     public void OperateReturnsOriginalText()
     {
-        var op = new KeepOperator();
-        var output = op.Operate("original", new Dictionary<string, object?>());
+        var output = new KeepOperator().Operate("original", new Dictionary<string, object?>());
+
+        Assert.Equal("original", output);
+    }
+
+    [Fact]
+    public void DeanonymizeVariantAlsoReturnsOriginalText()
+    {
+        var output = new DeanonymizeKeepOperator().Operate("original", new Dictionary<string, object?>());
 
         Assert.Equal("original", output);
     }
 
     [Fact]
     public void ValidateDoesNotThrow()
     {
-        var op = new KeepOperator();
+        Assert.Null(Record.Exception(() => new KeepOperator().Validate(new Dictionary<string, object?>())));
+        Assert.Null(Record.Exception(() => new DeanonymizeKeepOperator().Validate(new Dictionary<string, object?>())));
+    }
 
-        var exception = Record.Exception(() => op.Validate(new Dictionary<string, object?>()));
-        Assert.Null(exception);
+    [Fact]
+    public void OperatorNamesMatchPythonBehaviour()
+    {
+        Assert.Equal("keep", new KeepOperator().OperatorName);
+        Assert.Equal("deanonymize_keep", new DeanonymizeKeepOperator().OperatorName);
     }
 }

tests/ManagedCode.Presidio.Anonymizer.Tests/RedactOperatorTests.cs

@@ -5,20 +5,24 @@ namespace ManagedCode.Presidio.Anonymizer.Tests;
 public sealed class RedactOperatorTests
 {
     [Fact]
-    public void OperateReturnsEmptyString()
+    public void OperateReturnsEmptyStringRegardlessOfParameters()
     {
-        var op = new RedactOperator();
-        var output = op.Operate("secret", new Dictionary<string, object?>());
+        var output = new RedactOperator().Operate("secret", new Dictionary<string, object?>());
+        Assert.Equal(string.Empty, output);
 
+        output = new RedactOperator().Operate("secret", new Dictionary<string, object?> { ["new_value"] = string.Empty });
         Assert.Equal(string.Empty, output);
     }
 
     [Fact]
     public void ValidateDoesNothing()
     {
-        var op = new RedactOperator();
-        var exception = Record.Exception(() => op.Validate(new Dictionary<string, object?>()));
+        Assert.Null(Record.Exception(() => new RedactOperator().Validate(new Dictionary<string, object?>())));
+    }
 
-        Assert.Null(exception);
+    [Fact]
+    public void OperatorNameIsRedact()
+    {
+        Assert.Equal("redact", new RedactOperator().OperatorName);
     }
 }

tests/ManagedCode.Presidio.Anonymizer.Tests/ReplaceOperatorTests.cs

@@ -7,8 +7,7 @@ public sealed class ReplaceOperatorTests
     [Fact]
     public void OperateUsesProvidedReplacement()
     {
-        var op = new ReplaceOperator();
-        var output = op.Operate(
+        var output = new ReplaceOperator().Operate(
             "secret",
             new Dictionary<string, object?>
             {
@@ -19,30 +18,36 @@ public void OperateUsesProvidedReplacement()
         Assert.Equal("replacement", output);
     }
 
-    [Fact]
-    public void OperateFallsBackToEntityPlaceholder()
+    [Theory]
+    [InlineData("", "<>")]
+    [InlineData("PHONE_NUMBER", "<PHONE_NUMBER>")]
+    public void OperateFallsBackToEntityPlaceholder(string entityType, string expected)
     {
-        var op = new ReplaceOperator();
-        var output = op.Operate(
-            "secret",
-            new Dictionary<string, object?>
-            {
-                ["entity_type"] = "PERSON",
-            });
+        var parameters = new Dictionary<string, object?>
+        {
+            ["entity_type"] = entityType,
+        };
 
-        Assert.Equal("<PERSON>", output);
+        var output = new ReplaceOperator().Operate("secret", parameters);
+
+        Assert.Equal(expected, output);
     }
 
     [Fact]
     public void ValidateRejectsNonStringReplacement()
     {
-        var op = new ReplaceOperator();
         var parameters = new Dictionary<string, object?>
         {
             [ReplaceOperator.NewValueKey] = 123,
         };
 
-        var exception = Assert.Throws<InvalidParamException>(() => op.Validate(parameters));
+        var exception = Assert.Throws<InvalidParamException>(() => new ReplaceOperator().Validate(parameters));
         Assert.Equal("Invalid parameter value for new_value. Expecting 'string', but got 'number'.", exception.Message);
     }
+
+    [Fact]
+    public void OperatorNameIsReplace()
+    {
+        Assert.Equal("replace", new ReplaceOperator().OperatorName);
+    }
 }