• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 package com.google.protobuf;
2 
3 import static com.google.common.truth.Truth.assertThat;
4 import static protobuf_unittest.UnittestProto.redactedExtension;
5 
6 import com.google.protobuf.Descriptors.FieldDescriptor;
7 import protobuf_unittest.UnittestProto.RedactedFields;
8 import protobuf_unittest.UnittestProto.TestEmptyMessage;
9 import protobuf_unittest.UnittestProto.TestNestedMessageRedaction;
10 import org.junit.Test;
11 import org.junit.runner.RunWith;
12 import org.junit.runners.JUnit4;
13 
14 @RunWith(JUnit4.class)
15 public class DebugFormatTest {
16 
17   static final String REDACTED_REGEX = "\\[REDACTED\\]";
18   static final String UNSTABLE_PREFIX_SINGLE_LINE = getUnstablePrefix(true);
19   static final String UNSTABLE_PREFIX_MULTILINE = getUnstablePrefix(false);
20 
getUnstablePrefix(boolean singleLine)21   private static String getUnstablePrefix(boolean singleLine) {
22     return "";
23   }
24 
25   @Test
multilineMessageFormat_returnsMultiline()26   public void multilineMessageFormat_returnsMultiline() {
27     RedactedFields message = RedactedFields.newBuilder().setOptionalUnredactedString("foo").build();
28 
29     String result = DebugFormat.multiline().toString(message);
30     assertThat(result)
31         .matches(
32             String.format("%soptional_unredacted_string: \"foo\"\n", UNSTABLE_PREFIX_MULTILINE));
33   }
34 
35   @Test
singleLineMessageFormat_returnsSingleLine()36   public void singleLineMessageFormat_returnsSingleLine() {
37     RedactedFields message = RedactedFields.newBuilder().setOptionalUnredactedString("foo").build();
38 
39     String result = DebugFormat.singleLine().toString(message);
40     assertThat(result)
41         .matches(
42             String.format("%soptional_unredacted_string: \"foo\"", UNSTABLE_PREFIX_SINGLE_LINE));
43   }
44 
45   @Test
messageFormat_debugRedactFieldIsRedacted()46   public void messageFormat_debugRedactFieldIsRedacted() {
47     RedactedFields message = RedactedFields.newBuilder().setOptionalRedactedString("foo").build();
48 
49     String result = DebugFormat.multiline().toString(message);
50 
51     assertThat(result)
52         .matches(
53             String.format(
54                 "%soptional_redacted_string: %s\n", UNSTABLE_PREFIX_MULTILINE, REDACTED_REGEX));
55   }
56 
57   @Test
messageFormat_debugRedactMessageIsRedacted()58   public void messageFormat_debugRedactMessageIsRedacted() {
59     RedactedFields message =
60         RedactedFields.newBuilder()
61             .setOptionalRedactedMessage(
62                 TestNestedMessageRedaction.newBuilder().setOptionalUnredactedNestedString("foo"))
63             .build();
64 
65     String result = DebugFormat.multiline().toString(message);
66 
67     assertThat(result)
68         .matches(
69             String.format(
70                 "%soptional_redacted_message \\{\n  %s\n\\}\n",
71                 UNSTABLE_PREFIX_MULTILINE, REDACTED_REGEX));
72   }
73 
74   @Test
messageFormat_debugRedactMapIsRedacted()75   public void messageFormat_debugRedactMapIsRedacted() {
76     RedactedFields message = RedactedFields.newBuilder().putMapRedactedString("foo", "bar").build();
77 
78     String result = DebugFormat.multiline().toString(message);
79 
80     assertThat(result)
81         .matches(
82             String.format(
83                 "%smap_redacted_string \\{\\n  %s\n\\}\n",
84                 UNSTABLE_PREFIX_MULTILINE, REDACTED_REGEX));
85   }
86 
87   @Test
messageFormat_debugRedactExtensionIsRedacted()88   public void messageFormat_debugRedactExtensionIsRedacted() {
89     RedactedFields message =
90         RedactedFields.newBuilder().setExtension(redactedExtension, "foo").build();
91 
92     String result = DebugFormat.multiline().toString(message);
93 
94     assertThat(result)
95         .matches(
96             String.format(
97                 "%s\\[protobuf_unittest\\.redacted_extension\\]: %s\n",
98                 UNSTABLE_PREFIX_MULTILINE, REDACTED_REGEX));
99   }
100 
101   @Test
messageFormat_redactFalseIsNotRedacted()102   public void messageFormat_redactFalseIsNotRedacted() {
103     RedactedFields message =
104         RedactedFields.newBuilder().setOptionalRedactedFalseString("foo").build();
105 
106     String result = DebugFormat.multiline().toString(message);
107     assertThat(result)
108         .matches(
109             String.format(
110                 "%soptional_redacted_false_string: \"foo\"\n", UNSTABLE_PREFIX_MULTILINE));
111   }
112 
113   @Test
messageFormat_nonSensitiveFieldIsNotRedacted()114   public void messageFormat_nonSensitiveFieldIsNotRedacted() {
115     RedactedFields message = RedactedFields.newBuilder().setOptionalUnredactedString("foo").build();
116 
117     String result = DebugFormat.multiline().toString(message);
118 
119     assertThat(result)
120         .matches(
121             String.format("%soptional_unredacted_string: \"foo\"\n", UNSTABLE_PREFIX_MULTILINE));
122   }
123 
124   @Test
descriptorDebugFormat_returnsExpectedFormat()125   public void descriptorDebugFormat_returnsExpectedFormat() {
126     FieldDescriptor field =
127         RedactedFields.getDescriptor().findFieldByName("optional_redacted_string");
128     String result = DebugFormat.multiline().toString(field, "foo");
129     assertThat(result)
130         .matches(
131             String.format(
132                 "%soptional_redacted_string: %s\n", UNSTABLE_PREFIX_MULTILINE, REDACTED_REGEX));
133   }
134 
135   @Test
unstableFormat_isStablePerProcess()136   public void unstableFormat_isStablePerProcess() {
137     RedactedFields message1 =
138         RedactedFields.newBuilder().setOptionalUnredactedString("foo").build();
139     RedactedFields message2 =
140         RedactedFields.newBuilder().setOptionalUnredactedString("foo").build();
141     for (int i = 0; i < 5; i++) {
142       String result1 = DebugFormat.multiline().toString(message1);
143       String result2 = DebugFormat.multiline().toString(message2);
144       assertThat(result1).isEqualTo(result2);
145     }
146   }
147 
148   @Test
lazyDebugFormatMessage_supportsImplicitFormatting()149   public void lazyDebugFormatMessage_supportsImplicitFormatting() {
150     RedactedFields message = RedactedFields.newBuilder().setOptionalUnredactedString("foo").build();
151 
152     Object lazyDebug = DebugFormat.singleLine().lazyToString(message);
153 
154     assertThat(String.format("%s", lazyDebug))
155         .matches(
156             String.format("%soptional_unredacted_string: \"foo\"", UNSTABLE_PREFIX_SINGLE_LINE));
157   }
158 
makeUnknownFieldSet()159   private UnknownFieldSet makeUnknownFieldSet() {
160     return UnknownFieldSet.newBuilder()
161         .addField(
162             5,
163             UnknownFieldSet.Field.newBuilder()
164                 .addVarint(1)
165                 .addFixed32(2)
166                 .addFixed64(3)
167                 .addLengthDelimited(ByteString.copyFromUtf8("4"))
168                 .addLengthDelimited(
169                     UnknownFieldSet.newBuilder()
170                         .addField(12, UnknownFieldSet.Field.newBuilder().addVarint(6).build())
171                         .build()
172                         .toByteString())
173                 .addGroup(
174                     UnknownFieldSet.newBuilder()
175                         .addField(10, UnknownFieldSet.Field.newBuilder().addVarint(5).build())
176                         .build())
177                 .build())
178         .addField(
179             8, UnknownFieldSet.Field.newBuilder().addVarint(1).addVarint(2).addVarint(3).build())
180         .addField(
181             15,
182             UnknownFieldSet.Field.newBuilder()
183                 .addVarint(0xABCDEF1234567890L)
184                 .addFixed32(0xABCD1234)
185                 .addFixed64(0xABCDEF1234567890L)
186                 .build())
187         .build();
188   }
189 
190   @Test
unknownFieldsDebugFormat_returnsExpectedFormat()191   public void unknownFieldsDebugFormat_returnsExpectedFormat() {
192     TestEmptyMessage unknownFields =
193         TestEmptyMessage.newBuilder().setUnknownFields(makeUnknownFieldSet()).build();
194 
195     assertThat(DebugFormat.multiline().toString(unknownFields))
196         .matches(
197             String.format("%s5: UNKNOWN_VARINT %s\n", UNSTABLE_PREFIX_MULTILINE, REDACTED_REGEX)
198                 + String.format("5: UNKNOWN_FIXED32 %s\n", REDACTED_REGEX)
199                 + String.format("5: UNKNOWN_FIXED64 %s\n", REDACTED_REGEX)
200                 + String.format("5: UNKNOWN_STRING %s\n", REDACTED_REGEX)
201                 + String.format("5: \\{\n  12: UNKNOWN_VARINT %s\n\\}\n", REDACTED_REGEX)
202                 + String.format("5 \\{\n  10: UNKNOWN_VARINT %s\n\\}\n", REDACTED_REGEX)
203                 + String.format("8: UNKNOWN_VARINT %s\n", REDACTED_REGEX)
204                 + String.format("8: UNKNOWN_VARINT %s\n", REDACTED_REGEX)
205                 + String.format("8: UNKNOWN_VARINT %s\n", REDACTED_REGEX)
206                 + String.format("15: UNKNOWN_VARINT %s\n", REDACTED_REGEX)
207                 + String.format("15: UNKNOWN_FIXED32 %s\n", REDACTED_REGEX)
208                 + String.format("15: UNKNOWN_FIXED64 %s\n", REDACTED_REGEX));
209   }
210 }
211