BAEL-7091 Asserting Nested Map with JUnit

testing-modules/hamcrest/pom.xml

@@ -6,6 +6,18 @@
     <artifactId>hamcrest</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <name>hamcrest</name>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>9</source>
+                    <target>9</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
     <packaging>jar</packaging>
 
     <parent>

testing-modules/hamcrest/src/test/java/com/baeldung/hamcrest/assertnestedmap/AssertNestedMapUnitTest.java

@@ -0,0 +1,94 @@
+package com.baeldung.hamcrest.assertnestedmap;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+import static com.baeldung.hamcrest.assertnestedmap.matchers.NestedMapMatcher.hasNestedMapEntry;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class AssertNestedMapUnitTest {
+
+    @Test
+    void givenNestedMap_whenUseJupiterAssertTrueWithoutCasting_thenTest() {
+        Map<String, Object> innerMap = Map.of("city", "Chicago");
+        Map<String, Map<String, Object>> outerMap = Map.of("address", innerMap);
+
+        assertTrue(outerMap.containsKey("address") && outerMap.get("address").get("city").equals("Chicago"));
+    }
+
+    @Test
+    void givenNestedMap_whenUseJupiterAssertAllAndAssertTrue_thenTest() {
+        Map<String, Object> innerMap = Map.of("city", "Chicago");
+        Map<String, Map<String, Object>> outerMap = Map.of("address", innerMap);
+
+        assertAll(
+                () -> assertTrue(outerMap.containsKey("address")),
+                () -> assertEquals(outerMap.get("address").get("city"), "Chicago")
+        );
+    }
+
+    @Test
+    void givenNestedMap_whenUseJupiterAssertTrueWithCasting_thenTest() {
+        Map<String, Object> innerMap = Map.of("city", "Chicago");
+        Map<String, Object> outerMap = Map.of("address", innerMap);
+
+        assertTrue(outerMap.containsKey("address")
+                && ((Map<String, Object>)outerMap.get("address")).get("city").equals("Chicago"));
+    }
+
+    @Test
+    void givenNestedMap_whenUseHamcrestAssertThat_thenTest() {
+        Map<String, Object> innerMap = Map.of("city", "Chicago");
+        Map<String, Map<String, Object>> outerMap = Map.of("address", innerMap);
+        assertAll(
+                () -> assertThat(outerMap, hasKey("address")),
+                () -> assertThat(outerMap.get("address"), hasEntry("city", "Chicago"))
+        );
+    }
+
+    @Test
+    void givenNestedMapOfStringAndObject_whenUseHamcrestAssertThat_thenTest() {
+        Map<String, Object> innerMap = Map.of("city", "Chicago");
+        Map<String, Map<String, Object>> outerMap = Map.of("address", innerMap);
+
+        assertThat(outerMap, hasEntry(equalTo("address"), hasEntry("city", "Chicago")));
+    }
+
+    @Test
+    void givenNestedMapOfStringAndObject_whenUseHamcrestAssertThatAndCustomMatcher_thenTest() {
+        Map<String, Object> innerMap = Map.of
+          (
+            "city", "Chicago",
+            "zip", "10005"
+          );
+        Map<String, Map<String, Object>> outerMap = Map.of("address", innerMap);
+
+        assertThat(outerMap, hasNestedMapEntry("address", innerMap));
+    }
+
+    @Test
+    void givenOuterMapOfStringAndObjectAndInnerMap_whenUseHamcrestAssertThatAndCustomMatcher_thenTest() {
+        Map<String, Object> innerMap = Map.of
+          (
+            "city", "Chicago",
+            "zip", "10005"
+          );
+        Map<String, Object> outerMap = Map.of("address", innerMap);
+
+        assertThat(outerMap, hasNestedMapEntry("address", innerMap));
+    }
+
+
+    @Test
+    void givenNestedMap_whenUseHamcrestAssertThatWithCasting_thenTest() {
+        Map<String, Object> innerMap = Map.of("city", "Chicago");
+        Map<String, Object> outerMap = Map.of("address", innerMap);
+
+        assertThat((Map<String, Object>)outerMap.get("address"), hasEntry("city", "Chicago"));
+    }
+
+}

testing-modules/hamcrest/src/test/java/com/baeldung/hamcrest/assertnestedmap/matchers/NestedMapMatcher.java

@@ -0,0 +1,38 @@
+package com.baeldung.hamcrest.assertnestedmap.matchers;
+
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+
+import java.util.Map;
+
+public class NestedMapMatcher<K, V> extends TypeSafeMatcher<Map<K, Object>> {
+    private K key;
+    private V subMapValue;
+
+    public NestedMapMatcher(K key, V subMapValue) {
+        this.key = key;
+        this.subMapValue = subMapValue;
+    }
+
+    @Override
+    protected boolean matchesSafely(Map<K, Object> item) {
+        if (item.containsKey(key)) {
+            Object actualValue = item.get(key);
+            return subMapValue.equals(actualValue);
+        }
+        return false;
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendText("a map containing key ").appendValue(key)
+                .appendText(" with value ").appendValue(subMapValue);
+    }
+
+    public static <K, V> Matcher<V> hasNestedMapEntry(K key, V expectedValue) {
+        return new NestedMapMatcher(key, expectedValue);
+    }
+}
+