MembersTest Class — spring-boot Architecture

Source Code

core/spring-boot/src/test/java/org/springframework/boot/json/JsonWriterTests.java lines 241–476

	@Nested
	class MembersTest {

		@Test
		void whenNotNull() {
			JsonWriter<String> writer = JsonWriter.of((members) -> members.add().whenNotNull());
			assertThat(writer.writeToString("test")).isEqualTo(quoted("test"));
			assertThat(writer.writeToString(null)).isEmpty();
		}

		@Test
		void whenNotNullExtracted() {
			Person personWithNull = new Person("Spring", null, 10);
			Function<@Nullable Person, @Nullable Object> lastName = (person) -> (person != null) ? person.lastName()
					: null;
			JsonWriter<Person> writer = JsonWriter.of((members) -> members.add().whenNotNull(lastName));
			assertThat(writer.writeToString(PERSON)).isEqualTo(quoted("Spring Boot (10)"));
			assertThat(writer.writeToString(personWithNull)).isEmpty();
		}

		@Test
		void whenHasLength() {
			JsonWriter<String> writer = JsonWriter.of((members) -> members.add().whenHasLength());
			assertThat(writer.writeToString("test")).isEqualTo(quoted("test"));
			assertThat(writer.writeToString("")).isEmpty();
			assertThat(writer.writeToString(null)).isEmpty();
		}

		@Test
		void whenHasLengthOnNonString() {
			JsonWriter<StringBuilder> writer = JsonWriter.of((members) -> members.add().whenHasLength());
			assertThat(writer.writeToString(new StringBuilder("test"))).isEqualTo(quoted("test"));
			assertThat(writer.writeToString(new StringBuilder())).isEmpty();
			assertThat(writer.writeToString(null)).isEmpty();
		}

		@Test
		void whenNotEmpty() {
			JsonWriter<Object> writer = JsonWriter.of((members) -> members.add().whenNotEmpty());
			assertThat(writer.writeToString(List.of("a"))).isEqualTo("""
					["a"]""");
			assertThat(writer.writeToString(Collections.emptyList())).isEmpty();
			assertThat(writer.writeToString(new Object[] {})).isEmpty();
			assertThat(writer.writeToString(new int[] {})).isEmpty();
			assertThat(writer.writeToString(null)).isEmpty();
		}

		@Test
		void whenNot() {
			Predicate<@Nullable List<String>> isEmpty = List::isEmpty;
			JsonWriter<List<String>> writer = JsonWriter.of((members) -> members.add().whenNot(isEmpty));
			assertThat(writer.writeToString(List.of("a"))).isEqualTo("""
					["a"]""");
			assertThat(writer.writeToString(Collections.emptyList())).isEmpty();
		}

		@Test
		void when() {
			Predicate<@Nullable List<String>> isEmpty = List::isEmpty;
			JsonWriter<List<String>> writer = JsonWriter.of((members) -> members.add().when(isEmpty));
			assertThat(writer.writeToString(List.of("a"))).isEmpty();
			assertThat(writer.writeToString(Collections.emptyList())).isEqualTo("[]");
		}

		@Test
		void chainedPredicates() {
			Set<String> banned = Set.of("Spring", "Boot");
			Predicate<@Nullable String> stringLengthPredicate = (string) -> string != null && string.length() <= 2;
			Predicate<@Nullable String> bannedPredicate = (string) -> string != null && banned.contains(string);
			JsonWriter<String> writer = JsonWriter
				.of((members) -> members.add().whenHasLength().whenNot(bannedPredicate).whenNot(stringLengthPredicate));
			assertThat(writer.writeToString("")).isEmpty();
			assertThat(writer.writeToString("a")).isEmpty();
			assertThat(writer.writeToString("Boot")).isEmpty();
			assertThat(writer.writeToString("JSON")).isEqualTo(quoted("JSON"));
		}

		@Test
		void as() {
			JsonWriter<String> writer = JsonWriter.of((members) -> members.add().as(Integer::valueOf));
			assertThat(writer.writeToString("123")).isEqualTo("123");
		}

		@Test
		void asWhenValueIsNullDoesNotCallAdapter() {
			JsonWriter<String> writer = JsonWriter.of((members) -> members.add().as((value) -> {
				throw new RuntimeException("bad");
			}));
			writer.writeToString(null);
		}

		@Test
		void chainedAs() {
			Extractor<Integer, Boolean> booleanExtractor = (integer) -> integer != 0;
			JsonWriter<String> writer = JsonWriter
				.of((members) -> members.add().as(Integer::valueOf).as(booleanExtractor));
			assertThat(writer.writeToString("0")).isEqualTo("false");
			assertThat(writer.writeToString("1")).isEqualTo("true");
		}

		@Test
		void chainedAsAndPredicates() {
			Extractor<Integer, Boolean> booleanExtractor = (integer) -> integer != 0;
			Predicate<@Nullable String> isEmpty = (string) -> !StringUtils.hasLength(string);
			JsonWriter<String> writer = JsonWriter.of((members) -> members.add()
				.whenNot(isEmpty)
				.as(Integer::valueOf)
				.when((integer) -> integer < 2)
				.as(booleanExtractor));
			assertThat(writer.writeToString("")).isEmpty();
			assertThat(writer.writeToString("0")).isEqualTo("false");
			assertThat(writer.writeToString("1")).isEqualTo("true");
			assertThat(writer.writeToString("2")).isEmpty();
		}

		@Test
		void usingExtractedPairsWithExtractor() {
			Map<String, Object> map = new LinkedHashMap<>();
			map.put("a", "A");
			map.put("b", "B");
			PairExtractor<Map.Entry<String, Object>> extractor = PairExtractor.of(Map.Entry::getKey,
					Map.Entry::getValue);
			JsonWriter<Map<String, Object>> writer = JsonWriter
				.of((members) -> members.add().as(Map::entrySet).usingExtractedPairs(Set::forEach, extractor));
			assertThat(writer.writeToString(map)).isEqualTo("""
					{"a":"A","b":"B"}""");
		}

		@Test
		void usingExtractedPairs() {
			Map<String, Object> map = new LinkedHashMap<>();
			map.put("a", "A");
			map.put("b", "B");
			Function<Map.Entry<String, Object>, String> nameExtractor = Map.Entry::getKey;
			Function<Map.Entry<String, Object>, Object> valueExtractor = Map.Entry::getValue;
			JsonWriter<Map<String, Object>> writer = JsonWriter.of((members) -> members.add()
				.as(Map::entrySet)
				.usingExtractedPairs(Set::forEach, nameExtractor, valueExtractor));
			assertThat(writer.writeToString(map)).isEqualTo("""
					{"a":"A","b":"B"}""");
		}

		@Test
		void usingPairs() {
			Map<String, Object> map = new LinkedHashMap<>();
			map.put("a", "A");
			map.put("b", "B");
			JsonWriter<Map<String, Object>> writer = JsonWriter.of((members) -> members.add().usingPairs(Map::forEach));
			assertThat(writer.writeToString(map)).isEqualTo("""
					{"a":"A","b":"B"}""");
		}

		@Test
		void usingPairsWhenAlreadyDeclaredThrowsException() {
			assertThatIllegalStateException().isThrownBy(() -> JsonWriter.of((
					members) -> members.from(Collections.emptyMap()).usingPairs(Map::forEach).usingPairs(Map::forEach)))
				.withMessage("Pairs cannot be declared multiple times");
		}

		@Test
		void usingPairsWhenUsingMembersThrowsException() {
			assertThatIllegalStateException()
				.isThrownBy(() -> JsonWriter.of((members) -> members.from(Collections.emptyMap())
					.usingMembers((mapMembers) -> mapMembers.add("test"))
					.usingPairs(Map::forEach)))
				.withMessage("Pairs cannot be declared when using members");
		}

		@Test
		void usingMembers() {
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			JsonWriter<Couple> writer = JsonWriter.of((members) -> {
				members.add("personOne", Couple::person1).usingMembers((personMembers) -> {
					personMembers.add("fn", Person::firstName);
					personMembers.add("ln", Person::lastName);
				});
				members.add("personTwo", Couple::person2).usingMembers((personMembers) -> {
					personMembers.add("details", Person::toString);
					personMembers.add("eldest", true);
				});
			});
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"personOne":{"fn":"Spring","ln":"Boot"},""" + """
					"personTwo":{"details":"Spring Framework (20)","eldest":true}}""");
		}

		@Test
		void usingMembersWithoutName() {
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			JsonWriter<Couple> writer = JsonWriter.of((members) -> {
				members.add("version", 1);
				members.from(Couple::person1)
					.usingMembers((personMembers) -> personMembers.add("one", Person::toString));
				members.from(Couple::person2)
					.usingMembers((personMembers) -> personMembers.add("two", Person::toString));
			});
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"version":1,"one":"Spring Boot (10)","two":"Spring Framework (20)"}""");
		}

		@Test
		void usingMembersWithoutNameInMember() {
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			JsonWriter<Couple> writer = JsonWriter.of((members) -> members.add("only", Couple::person2)
				.usingMembers((personMembers) -> personMembers.from(Person::toString)));
			assertThat(writer.writeToString(couple)).isEqualTo("""
					{"only":"Spring Framework (20)"}""");
		}

		@Test
		void usingMembersWithoutNameAtAll() {
			Couple couple = new Couple(PERSON, new Person("Spring", "Framework", 20));
			JsonWriter<Couple> writer = JsonWriter.of((members) -> members.from(Couple::person2)
				.usingMembers((personMembers) -> personMembers.from(Person::toString)));
			assertThat(writer.writeToString(couple)).isEqualTo(quoted("Spring Framework (20)"));
		}

		@Test
		void usingMembersWhenAlreadyDeclaredThrowsException() {
			assertThatIllegalStateException()
				.isThrownBy(() -> JsonWriter.of((members) -> members.from(Collections.emptyMap())
					.usingMembers((mapMembers) -> mapMembers.add("test"))
					.usingMembers((mapMembers) -> mapMembers.add("test"))))
				.withMessage("Members cannot be declared multiple times");
		}

		@Test
		void usingMembersWhenUsingPairsThrowsException() {
			assertThatIllegalStateException()
				.isThrownBy(() -> JsonWriter.of((members) -> members.from(Collections.emptyMap())
					.usingPairs(Map::forEach)
					.usingMembers((mapMembers) -> mapMembers.add("test"))))
				.withMessage("Members cannot be declared when using pairs");
		}

	}