Add support for masking multiple JSON values in the same input (#175)

Fixes #173

src/main/java/dev/blaauwendraad/masker/json/KeyContainsMasker.java

@@ -48,8 +48,12 @@ public byte[] mask(byte[] input) {
                 keyMaskingConfig = keyMatcher.getMaskConfigIfMatched(maskingState.getMessage(), -1, -1, maskingState.getCurrentJsonPathNode());
             }
 
-            stepOverWhitespaceCharacters(maskingState);
-            visitValue(maskingState, keyMaskingConfig);
+            while (!maskingState.endOfJson()) {
+                stepOverWhitespaceCharacters(maskingState);
+                if (!visitValue(maskingState, keyMaskingConfig)) {
+                    maskingState.next();
+                }
+            }
 
             return maskingState.flushReplacementOperations();
         } catch (ArrayIndexOutOfBoundsException | StackOverflowError e) {
@@ -63,10 +67,12 @@ public byte[] mask(byte[] input) {
      * @param maskingState     the current masking state
      * @param keyMaskingConfig if not null it means that the current value is being masked otherwise the value is not
      *                         being masked
+     *
+     * @return whether a value was found, if returned false the calling code must advance to avoid infinite loops
      */
-    private void visitValue(MaskingState maskingState, @Nullable KeyMaskingConfig keyMaskingConfig) {
+    private boolean visitValue(MaskingState maskingState, @Nullable KeyMaskingConfig keyMaskingConfig) {
         if (maskingState.endOfJson()) {
-            return;
+            return true;
         }
         // using switch-case over 'if'-statements to improve performance by ~20% (measured in benchmarks)
         switch (maskingState.byteAtCurrentIndex()) {
@@ -101,8 +107,11 @@ private void visitValue(MaskingState maskingState, @Nullable KeyMaskingConfig ke
                 }
             }
             case 'n' -> maskingState.incrementIndex(4);
-            default -> { /* return */ }
+            default -> {
+                return false;
+            }
         }
+        return true;
     }
 
     /**

src/test/JSONTestSuite/masked/n_structure_object_with_trailing_garbage.json

@@ -1 +1 @@
-{"a": "&&&"} "x"
+{"a": "&&&"} "***"

src/test/java/dev/blaauwendraad/masker/json/JSONTestSuiteTest.java

@@ -33,9 +33,9 @@ public class JSONTestSuiteTest {
     private static final List<String> INVALID_UTF_8 = List.of(
             "i_string_1st_surrogate_but_2nd_missing.json",
             "i_string_1st_valid_surrogate_2nd_invalid.json",
-            "i_string_incomplete_surrogates_escape_valid.json",
             "i_string_incomplete_surrogate_and_escape_valid.json",
             "i_string_incomplete_surrogate_pair.json",
+            "i_string_incomplete_surrogates_escape_valid.json",
             "i_string_invalid_lonely_surrogate.json",
             "i_string_invalid_surrogate.json",
             "i_string_inverted_surrogates_U+1D11E.json",
@@ -45,9 +45,9 @@ public class JSONTestSuiteTest {
             "n_string_1_surrogate_then_escape_u1.json",
             "n_string_1_surrogate_then_escape_u1x.json",
             "n_string_backslash_00.json",
+            "n_string_escape_x.json",
             "n_string_escaped_ctrl_char_tab.json",
             "n_string_escaped_emoji.json",
-            "n_string_escape_x.json",
             "n_string_incomplete_escaped_character.json",
             "n_string_incomplete_surrogate.json",
             "n_string_incomplete_surrogate_escape_invalid.json",
@@ -59,11 +59,13 @@ public class JSONTestSuiteTest {
             "n_structure_open_open.json"
     );
 
-    private static final List<String> JACKSON_IS_DIFFERENT_FROM_TO_STRING = List.of(
+    private static final List<String> INVALID_JSON_JACKSON_DIFFERENT_BEHAVIOR = List.of(
+            "i_string_UTF-16LE_with_BOM.json",
+            "i_string_UTF8_surrogate_U+D800.json",
             "i_string_not_in_unicode_range.json",
             "i_string_overlong_sequence_2_bytes.json",
-            "i_string_utf16LE_no_BOM.json",
-            "i_string_UTF8_surrogate_U+D800.json"
+            "i_string_utf16BE_no_BOM.json",
+            "i_string_utf16LE_no_BOM.json"
     );
     public static final Path JSON_TEST_SUITE_PATH = Path.of("src/test/JSONTestSuite/");
 
@@ -107,7 +109,7 @@ void mayPassSuiteWithNoopMaskerShouldNotFail(String testName, JsonTestSuiteFile
 
         byte[] actual = jsonMasker.mask(file.originalContent);
 
-        if (JACKSON_IS_DIFFERENT_FROM_TO_STRING.contains(file.name)) {
+        if (INVALID_JSON_JACKSON_DIFFERENT_BEHAVIOR.contains(file.name)) {
             // for these jackson behavior is different from java.lang.String parsing of UTF-8 characters
             return;
         }

src/test/java/dev/blaauwendraad/masker/json/MultiJsonTest.java

@@ -0,0 +1,81 @@
+package dev.blaauwendraad.masker.json;
+
+import dev.blaauwendraad.masker.json.config.JsonMaskingConfig;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+public class MultiJsonTest {
+
+    @Test
+    void shouldMaskJsonLinesObjects() {
+        JsonMasker jsonMasker = JsonMasker.getMasker(Set.of("maskMe"));
+
+        Assertions.assertThat(jsonMasker.mask(
+                        """
+                                {"maskMe":"secret"}
+                                {"maskMe":"secret"}
+                                {"maskMe":"secret"}
+                                """))
+                .isEqualTo(
+                        """
+                                {"maskMe":"***"}
+                                {"maskMe":"***"}
+                                {"maskMe":"***"}
+                                """);
+    }
+
+    @Test
+    void shouldMaskJsonLinesArrays() {
+        JsonMasker jsonMasker = JsonMasker.getMasker(Set.of("maskMe"));
+
+        Assertions.assertThat(jsonMasker.mask(
+                        """
+                                [{"maskMe":"secret"}]
+                                [{"maskMe":"secret"}]
+                                [{"maskMe":"secret"}]
+                                """))
+                .isEqualTo(
+                        """
+                                [{"maskMe":"***"}]
+                                [{"maskMe":"***"}]
+                                [{"maskMe":"***"}]
+                                """);
+    }
+
+    @Test
+    void shouldMaskJsonLinesMixedTypes() {
+        JsonMasker jsonMasker = JsonMasker.getMasker(JsonMaskingConfig.builder().allowKeys().build());
+
+        Assertions.assertThat(jsonMasker.mask(
+                        """
+                                "secret"
+                                true
+                                false
+                                null
+                                123
+                                """))
+                .isEqualTo(
+                        """
+                                "***"
+                                "&&&"
+                                "&&&"
+                                null
+                                "###"
+                                """);
+    }
+    @Test
+    void shouldMaskRepeatedJsonsWithoutNewLines() {
+        JsonMasker jsonMasker = JsonMasker.getMasker(Set.of("maskMe"));
+
+        Assertions.assertThat(jsonMasker.mask(
+                        """
+                                {"maskMe":"secret"}{"maskMe":"secret"}   {"maskMe":"secret"}
+                                """))
+                .isEqualTo(
+                        """
+                                {"maskMe":"***"}{"maskMe":"***"}   {"maskMe":"***"}
+                                """);
+    }
+}