NameProcessorTests Class — spring-boot Architecture

Source Code

core/spring-boot/src/test/java/org/springframework/boot/json/JsonWriterTests.java lines 588–719

	@Nested
	class NameProcessorTests {

		@Test
		void processNameWhenSimpleValue() {
			JsonWriter<String> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
			});
			assertThat(writer.writeToString("test")).isEqualTo("\"test\"");
		}

		@Test
		void processNameWhenMember() {
			JsonWriter<Person> writer = JsonWriter.of((members) -> {
				members.add("first", Person::firstName);
				members.add("last", Person::lastName);
				members.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
			});
			assertThat(writer.writeToString(new Person("spring", "boot", 10))).isEqualTo("""
					{"FIRST":"spring","LAST":"boot"}""");
		}

		@Test
		void processNameWhenInMap() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
			});
			assertThat(writer.writeToString(Map.of("spring", "boot"))).isEqualTo("""
					{"SPRING":"boot"}""");
		}

		@Test
		void processNameWhenInNestedMap() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add();
				members.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
			});
			assertThat(writer.writeToString(Map.of("test", Map.of("spring", "boot")))).isEqualTo("""
					{"TEST":{"SPRING":"boot"}}""");
		}

		@Test
		void processNameWhenInPairs() {
			JsonWriter<Map<?, ?>> writer = JsonWriter.of((members) -> {
				members.add().usingPairs(Map::forEach);
				members.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
			});
			assertThat(writer.writeToString(Map.of("spring", "boot"))).isEqualTo("""
					{"SPRING":"boot"}""");
		}

		@Test
		void processNameWhenHasNestedMembers() {
			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));
				members.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
			});
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"ONE":"Spring Boot (10)","TWO":"Spring Framework (20)"}""");
		}

		@Test
		void processNameWhenHasNestedMembersWithAdditionalValueProcessor() {
			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);
					personMembers.applyingNameProcessor(NameProcessor.of(String::toUpperCase));
				});
				members.applyingNameProcessor(NameProcessor.of((name) -> name + "!"));
			});
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"one!":"Spring Boot (10)","TWO!":"Spring Framework (20)"}""");
		}

		@Test
		void processNameWhenDeeplyNestedUsesCompoundPaths() {
			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.applyingNameProcessor((path, existingName) -> {
					paths.add(path.toString());
					return existingName;
				});
			});
			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 processNameWhenReturnsNullThrowsException() {
			JsonWriter<Person> writer = JsonWriter.of((members) -> {
				members.add("first", Person::firstName);
				members.add("last", Person::lastName);
				members
					.applyingNameProcessor((path, existingName) -> !"first".equals(existingName) ? existingName : null);
			});
			assertThatIllegalStateException().isThrownBy(() -> writer.writeToString(new Person("spring", "boot", 10)))
				.withMessageContaining("NameProcessor")
				.withMessageContaining("returned an empty result");
		}

		@Test
		void processNameWhenReturnsEmptyStringThrowsException() {
			JsonWriter<Person> writer = JsonWriter.of((members) -> {
				members.add("first", Person::firstName);
				members.add("last", Person::lastName);
				members
					.applyingNameProcessor((path, existingName) -> !"first".equals(existingName) ? existingName : "");
			});
			assertThatIllegalStateException().isThrownBy(() -> writer.writeToString(new Person("spring", "boot", 10)))
				.withMessageContaining("NameProcessor")
				.withMessageContaining("returned an empty result");
		}

	}