ValueProcessorTests Class — spring-boot Architecture

Source Code

core/spring-boot/src/test/java/org/springframework/boot/json/JsonWriterTests.java lines 724–983

	@Nested
	class ValueProcessorTests {

		@Test
		void of() {
			ValueProcessor<String> processor = ValueProcessor.of(stringToUppercase());
			assertThat(processor.processValue(MemberPath.ROOT, "test")).isEqualTo("TEST");
		}

		@Test
		@SuppressWarnings("NullAway") // Test null check
		void ofWhenNull() {
			assertThatIllegalArgumentException().isThrownBy(() -> ValueProcessor.of(null))
				.withMessage("'action' must not be null");
		}

		@Test
		void whenHasPathWithStringWhenPathMatches() {
			ValueProcessor<String> processor = ValueProcessor.of(stringToUppercase()).whenHasPath("foo");
			assertThat(processor.processValue(MemberPath.ROOT.child("foo"), "test")).isEqualTo("TEST");
		}

		@Test
		void whenHasPathWithStringWhenPathDoesNotMatch() {
			ValueProcessor<String> processor = ValueProcessor.<String>of(stringToUppercase()).whenHasPath("foo");
			assertThat(processor.processValue(MemberPath.ROOT.child("bar"), "test")).isEqualTo("test");
		}

		@Test
		void whenHasPathWithPredicateWhenPathMatches() {
			ValueProcessor<String> processor = ValueProcessor.<String>of(stringToUppercase())
				.whenHasPath((path) -> path.toString().startsWith("f"));
			assertThat(processor.processValue(MemberPath.ROOT.child("foo"), "test")).isEqualTo("TEST");
		}

		@Test
		void whenHasPathWithPredicateWhenPathDoesNotMatch() {
			ValueProcessor<String> processor = ValueProcessor.<String>of(stringToUppercase())
				.whenHasPath((path) -> path.toString().startsWith("f"));
			assertThat(processor.processValue(MemberPath.ROOT.child("bar"), "test")).isEqualTo("test");
		}

		@Test
		void whenInstanceOfWhenInstanceMatches() {
			ValueProcessor<Object> processor = ValueProcessor.of(objectToUppercase()).whenInstanceOf(String.class);
			assertThat(processor.processValue(MemberPath.ROOT, "test")).hasToString("TEST");
		}

		@Test
		void whenInstanceOfWhenInstanceDoesNotMatch() {
			ValueProcessor<Object> processor = ValueProcessor.of(objectToUppercase()).whenInstanceOf(String.class);
			assertThat(processor.processValue(MemberPath.ROOT, new StringBuilder("test"))).hasToString("test");
		}

		@Test
		void whenWhenPredicateMatches() {
			Predicate<@Nullable String> equals = "test"::equals;
			ValueProcessor<String> processor = ValueProcessor.of(stringToUppercase()).when(equals);
			assertThat(processor.processValue(MemberPath.ROOT, "test")).isEqualTo("TEST");
		}

		@Test
		void whenWhenPredicateDoesNotMatch() {
			Predicate<@Nullable String> equals = "test"::equals;
			ValueProcessor<String> processor = ValueProcessor.of(stringToUppercase()).when(equals);
			assertThat(processor.processValue(MemberPath.ROOT, "other")).isEqualTo("other");
		}

		@Test
		void processValueWhenSimpleValue() {
			JsonWriter<String> writer = simpleWriterWithUppercaseProcessor();
			assertThat(writer.writeToString("test")).isEqualTo("\"TEST\"");
		}

		@Test
		void processValueWhenMemberValue() {
			JsonWriter<Person> writer = JsonWriter.of((members) -> {
				members.add("first", Person::firstName);
				members.add("last", Person::lastName);
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()));
			});
			assertThat(writer.writeToString(new Person("spring", "boot", 10))).isEqualTo("""
					{"first":"Spring","last":"Boot"}""");
		}

		@Test
		void processValueWhenInMap() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()));
			});
			assertThat(writer.writeToString(Map.of("spring", "boot"))).isEqualTo("""
					{"spring":"Boot"}""");
		}

		@Test
		void processValueWhenInNestedMap() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()));
			});
			assertThat(writer.writeToString(Map.of("test", Map.of("spring", "boot")))).isEqualTo("""
					{"test":{"spring":"Boot"}}""");
		}

		@Test
		void processValueWhenInPairs() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add().usingPairs(Map::forEach);
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()));
			});
			assertThat(writer.writeToString(Map.of("spring", "boot"))).isEqualTo("""
					{"spring":"Boot"}""");
		}

		@Test
		void processValueWhenCalledWithMultipleTypesIgnoresLambdaErrors() {
			JsonWriter<Object> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()));
			});
			assertThat(writer.writeToString("spring")).isEqualTo("\"Spring\"");
			assertThat(writer.writeToString(123)).isEqualTo("123");
			assertThat(writer.writeToString(true)).isEqualTo("true");
		}

		@Test
		void processValueWhenLimitedToPath() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()).whenHasPath("spring"));
			});
			assertThat(writer.writeToString(Map.of("spring", "boot"))).isEqualTo("""
					{"spring":"Boot"}""");
			assertThat(writer.writeToString(Map.of("boot", "spring"))).isEqualTo("""
					{"boot":"spring"}""");
		}

		@Test
		void processValueWhen() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add();
				Predicate<@Nullable String> startsWithB = (candidate) -> candidate != null && candidate.startsWith("b");
				members.applyingValueProcessor(ValueProcessor.of(stringCapitalize()).when(startsWithB));
			});
			assertThat(writer.writeToString(Map.of("spring", "boot"))).isEqualTo("""
					{"spring":"Boot"}""");
			assertThat(writer.writeToString(Map.of("boot", "spring"))).isEqualTo("""
					{"boot":"spring"}""");
		}

		@Test
		void processValueWhenHasNestedMembers() {
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			JsonWriter<Couple> writer = JsonWriter.of((members) -> {
				members.from(Couple::person1)
					.usingMembers((personMembers) -> personMembers.add("one", Person::toString));
				members.from(Couple::person2)
					.usingMembers((personMembers) -> personMembers.add("two", Person::toString));
				UnaryOperator<@Nullable String> toUpperCase = (string) -> (string != null)
						? string.toUpperCase(Locale.ROOT) : null;
				members.applyingValueProcessor(ValueProcessor.of(String.class, toUpperCase));
			});
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"one":"SPRING BOOT (10)","two":"SPRING FRAMEWORK (20)"}""");
		}

		@Test
		void processValueWhenHasNestedMembersWithAdditionalValueProcessor() {
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			JsonWriter<Couple> writer = JsonWriter.of((members) -> {
				members.from(Couple::person1)
					.usingMembers((personMembers) -> personMembers.add("one", Person::toString));
				members.from(Couple::person2).usingMembers((personMembers) -> {
					personMembers.add("two", Person::toString);
					UnaryOperator<@Nullable String> operator = (item) -> item + "!";
					personMembers.applyingValueProcessor(ValueProcessor.of(String.class, operator));
				});
				UnaryOperator<@Nullable String> toUpperCase = (string) -> (string != null)
						? string.toUpperCase(Locale.ROOT) : null;
				members.applyingValueProcessor(ValueProcessor.of(String.class, toUpperCase));
			});
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"one":"SPRING BOOT (10)","two":"SPRING FRAMEWORK (20)!"}""");
		}

		@Test
		void processValueWhenDeeplyNestedUsesCompoundPaths() {
			List<String> paths = new ArrayList<>();
			JsonWriter<Couple> writer = JsonWriter.of((members) -> {
				members.add("one", Couple::person1).usingMembers((personMembers) -> {
					personMembers.add("first", Person::firstName);
					personMembers.add("last", Person::lastName);
				});
				members.add("two", Couple::person2).usingMembers((personMembers) -> {
					personMembers.add("first", Person::firstName);
					personMembers.add("last", Person::lastName);
				});
				members.applyingValueProcessor((path, value) -> {
					paths.add(path.toString());
					return value;
				});
			});
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			writer.writeToString(couple);
			assertThat(paths).containsExactly("one", "one.first", "one.last", "two", "two.first", "two.last");
		}

		@Test
		void processValueWhenUsingListUsesIndexedPaths() {
			List<String> paths = new ArrayList<>();
			JsonWriter<List<String>> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingValueProcessor((path, value) -> {
					paths.add(path.toString());
					return value;
				});
			});
			writer.writeToString(List.of("a", "b", "c"));
			assertThat(paths).containsExactly("", "[0]", "[1]", "[2]");
		}

		@Test
		void processValueUsesUnprocessedNameInPath() {
			List<String> paths = new ArrayList<>();
			JsonWriter<Person> writer = JsonWriter.of((members) -> {
				members.add("first", Person::firstName);
				members.add("last", Person::lastName);
				members.applyingValueProcessor((path, value) -> {
					paths.add(path.toString());
					return value;
				});
				members.applyingNameProcessor((path, existingName) -> "the-" + existingName);
			});
			writer.writeToString(PERSON);
			assertThat(paths).containsExactly("first", "last");
		}

		private static UnaryOperator<@Nullable String> stringToUppercase() {
			return (string) -> (string != null) ? string.toUpperCase(Locale.ROOT) : null;
		}

		private static UnaryOperator<@Nullable Object> objectToUppercase() {
			return (string) -> (string != null) ? string.toString().toUpperCase(Locale.ROOT) : null;
		}

		private static UnaryOperator<@Nullable String> stringCapitalize() {
			return (string) -> (string != null) ? StringUtils.capitalize(string) : null;
		}

		private JsonWriter<String> simpleWriterWithUppercaseProcessor() {
			return JsonWriter.of((members) -> {
				members.add();
				UnaryOperator<@Nullable String> toUpperCase = (string) -> (string != null)
						? string.toUpperCase(Locale.ROOT) : null;
				members.applyingValueProcessor(ValueProcessor.of(String.class, toUpperCase));
			});
		}

	}