Let’s say you encounter a situation where you have a Map of Maps where the nested Map has a value of Object. These were the cards I was dealt while refactoring a bit of code recently. This case may be a bit too generic and likely warrants a more specific domain object at the least; however, I maintained this structure to remain backward compatible I did some TDD to make sure nothing was broken by the refactoring.<\/p>\n\n\n\n
There are many options for unit testing a Map of Maps, but I’m particularly more fond of the Let’s say you encounter a situation where you have a Map of Maps where the nested Map has a value of Object. These were the cards I was dealt while refactoring a bit of code recently. This case may be a bit too generic and likely warrants a more specific…<\/p>\nassertThat<\/code> approach with Matchers. I will always strive to use these over the rudimentary assertEquals<\/code>, assertTrue<\/code> and assertFalse<\/code>, which provides little value for reporting and troubleshooting. Hamcrest is one of those open-source libraries in Java that has become so popular that it has basically received the ultimate form of flattery in the newer versions of Java’s JUnit<\/a>. Below you can find several examples of how to leverage JUnit to test Maps of Maps:<\/p>\n\n\n\n import org.hamcrest.CoreMatchers;\n import org.hamcrest.collection.IsMapContaining;\n import org.junit.Before;\n import org.junit.Test;\n import org.junit.runner.RunWith;\n import org.mockito.InjectMocks;\n import org.mockito.Mock;\n import org.mockito.Mockito;\n import org.mockito.junit.MockitoJUnitRunner;\n\n import java.io.IOException;\n import java.util.HashMap;\n import java.util.Map;\n \n import static org.hamcrest.CoreMatchers.equalTo;\n import static org.hamcrest.CoreMatchers.is;\n import static org.hamcrest.CoreMatchers.notNullValue;\n import static org.hamcrest.collection.IsMapContaining.hasEntry;\n \n @RunWith(MockitoJUnitRunner.class)\n public class MapOfMapTest {\n\n @InjectMocks\n private Processor processor;\n \n @Test\n public void testProcess_CloseIsTrue_ExpectTrue() throws Exception {\n \/\/ setup\n ...\n \n \/\/ when\n ...\n \n \/\/ test\n Map<String, Map<String, Object>> mapOfMaps = (Map<String, Map<String, Object>>) processor.process();\n assertThat(mapOfMaps, is(notNullValue()));\n\n Map<String, Object> cusipMap = new HashMap<>();\n cusipMap.put(\"ticker\", \"BGNIXS\");\n String cusip = \"091929695\";\n cusipMap.put(\"cusip\", cusip);\n cusipMap.put(\"name\", \"BlackRock GNMA Instl\");\n cusipMap.put(\"closed\", true);\n cusipMap.put(\"scale\", 3);\n Map<String, Object> actual = mapOfMaps.get(cusip);\n \n compareMaps(mapOfMaps, cusipMap, cusip, actual);\n }\n\n protected void compareMaps(Map<String, Map<String, Object>> mapOfMaps, Map<String, Object> cusipMap, String cusip,\n Map<String, Object> actual) {\n \/\/ The most basic pure JUnit assertion, but probably the least preferred option. This is not expressive and will provide poor feedback on failure\n assertTrue(actual.equals(cusipMap));\n \n \/\/ The second most basic pure JUnit assertion, and only marginally better than the above. This is not expressive and will provide poor feedback on failure\n assertEquals(actual, cusipMap);\n \n \/\/ Mildly more expressive and would be preferred in my opinion over the above two options\n assertThat(actual, is(cusipMap));\n \n \/\/ ----------------------------------------------------------------------------------------------------\n\n \/\/ Using Hamcrest CoreMatchers - more expressive than the above\n assertThat(actual, CoreMatchers.<Map<String, Object>>equalTo(cusipMap));\n \n \/\/ Using Hamcrest CoreMatchers - check a specific key and value and is more expressive than the above\n assertThat(mapOfMaps, hasEntry(equalTo(cusip), CoreMatchers.<Map<String, Object>>equalTo(cusipMap)));\n \n \/\/ ----------------------------------------------------------------------------------------------------\n \n \/\/ Using Hamcrest: Ensure the key used for the outer map is present\n assertThat(mapOfMaps, IsMapContaining.hasKey(cusip));\n \n \/\/ Using Hamcrest: Ensure the actual inner Map value is present in the output Map ... this is obvious\n assertThat(mapOfMaps, IsMapContaining.hasValue(actual));\n \n \/\/ Using Hamcrest: Ensure the generated inner Map value is present in the output Map ... this is the more valid test\n assertThat(mapOfMaps, IsMapContaining.hasValue(cusipMap));\n \n \/\/ Using Hamcrest: Two for one assertion that takes care of checking the key and the value ... use this one\n assertThat(mapOfMaps, IsMapContaining.hasEntry(cusip, cusipMap));\n }\n } <\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"