Utilizzo di Mockito, come si combacia con la coppia chiave-valore di una mappa?

Question

Devo inviare un valore specifico da un oggetto fittizio basato su un valore chiave specifico.

Dalla classe concreta:

map.put("xpath", "PRICE"); 
search(map); 

Dal banco di prova:

IOurXMLDocument mock = mock(IOurXMLDocument.class); 
when(mock.search(.....need help here).thenReturn("$100.00"); 

Come faccio beffe di questa chiamata al metodo per questa coppia chiave-valore?

Answer 1

Non funziona?

Map<String, String> map = new HashMap<String, String>(); 
map.put("xpath", "PRICE"); 
when(mock.search(map)).thenReturn("$100.00"); 

Il parametro Map dovrebbe comportarsi allo stesso modo di altri parametri.

Answer 2

Sembra come quello che vi serve è un Answer:

IOurXMLDocument doc = mock(IOurXMLDocument.class); 
when(doc.search(Matchers.<Map<String,String>>any())).thenAnswer(new Answer<String>() { 
    @Override 
    public String answer(InvocationOnMock invocation) throws Throwable { 
     Map<String, String> map = (Map<String, String>) invocation.getArguments()[0]; 
     String value = map.get("xpath"); 
     if ("PRICE".equals(value)) { 
      return "$100.00"; 
     } else if ("PRODUCTNAME".equals(value)) { 
      return "Candybar"; 
     } else { 
      return null; 
     } 
    } 
}); 

Ma quello che sembra una migliore idea è di non utilizzare primitiva Map come parametro per il metodo di ricerca - probabilmente si potrebbe trasformare questa mappa in un POJO con price e productName attributi. Solo un'idea :)

Answer 3

Ho trovato questo cercando di risolvere un problema simile creando uno stub Mockito con un parametro Map. Non volevo scrivere un matcher personalizzato per la mappa in questione e poi ho trovato una soluzione più elegante: utilizzare i matchers supplementari in hamcrest-library con argThat di Mockito:

when(mock.search(argThat(hasEntry("xpath", "PRICE"))).thenReturn("$100.00"); 

Se avete bisogno di controllare contro più voci poi è possibile utilizzare altre chicche hamcrest:

when(mock.search(argThat(allOf(hasEntry("xpath", "PRICE"), hasEntry("otherKey", "otherValue")))).thenReturn("$100.00"); 

Questo inizia ad arrivare a lungo con le mappe non banali, così ho finito per l'estrazione di metodi per raccogliere i matchers entrata e li bloccati nelle nostre TestUtils:

import static org.hamcrest.Matchers.allOf; 
import static org.hamcrest.Matchers.anyOf; 
import static org.hamcrest.Matchers.hasEntry; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.Map; 

import org.hamcrest.Matcher; 
--------------------------------- 
public static <K, V> Matcher<Map<K, V>> matchesEntriesIn(Map<K, V> map) { 
    return allOf(buildMatcherArray(map)); 
} 

public static <K, V> Matcher<Map<K, V>> matchesAnyEntryIn(Map<K, V> map) { 
    return anyOf(buildMatcherArray(map)); 
} 

@SuppressWarnings("unchecked") 
private static <K, V> Matcher<Map<? extends K, ? extends V>>[] buildMatcherArray(Map<K, V> map) { 
    List<Matcher<Map<? extends K, ? extends V>>> entries = new ArrayList<Matcher<Map<? extends K, ? extends V>>>(); 
    for (K key : map.keySet()) { 
     entries.add(hasEntry(key, map.get(key))); 
    } 
    return entries.toArray(new Matcher[entries.size()]); 
} 

Quindi mi rimane:

when(mock.search(argThat(matchesEntriesIn(map))).thenReturn("$100.00"); 
when(mock.search(argThat(matchesAnyEntryIn(map))).thenReturn("$100.00"); 

C'è qualche bruttura associato ai farmaci generici e sto sopprimendo un avvertimento, ma almeno è asciutto e nascosto nella TestUtil.

Un'ultima nota, attenzione allo embedded hamcrest issues in JUnit 4.10. Con Maven, consiglio di importare prima la libreria hamcrest e poi la JUnit 4.11 (ora 4.12) ed escludono hamcrest-core da JUnit per buona misura:

<dependency> 
    <groupId>org.hamcrest</groupId> 
    <artifactId>hamcrest-library</artifactId> 
    <version>1.3</version> 
    <scope>test</scope> 
</dependency> 
<dependency> 
    <groupId>junit</groupId> 
    <artifactId>junit</artifactId> 
    <version>4.12</version> 
    <scope>test</scope> 
    <exclusions> 
     <exclusion> 
      <groupId>org.hamcrest</groupId> 
      <artifactId>hamcrest-core</artifactId> 
     </exclusion> 
    </exclusions> 
</dependency> 
<dependency> 
    <groupId>org.mockito</groupId> 
    <artifactId>mockito-all</artifactId> 
    <version>1.9.5</version> 
    <scope>test</scope> 
</dependency> 

---

Edit: 1 SETTEMBRE 2017 - Per alcuni dei commenti, ho aggiornato la mia risposta per mostrare la mia dipendenza Mockito, le mie importazioni in l'util di prova, e un JUnit che esegue verde a partire da oggi:

import static blah.tool.testutil.TestUtil.matchesAnyEntryIn; 
import static blah.tool.testutil.TestUtil.matchesEntriesIn; 
import static org.hamcrest.MatcherAssert.assertThat; 
import static org.hamcrest.Matchers.is; 
import static org.mockito.Matchers.argThat; 
import static org.mockito.Mockito.mock; 
import static org.mockito.Mockito.when; 

import java.util.HashMap; 
import java.util.Map; 

import org.junit.Test; 

public class TestUtilTest { 

    @Test 
    public void test() { 
     Map<Integer, String> expected = new HashMap<Integer, String>(); 
     expected.put(1, "One"); 
     expected.put(3, "Three"); 

     Map<Integer, String> actual = new HashMap<Integer, String>(); 
     actual.put(1, "One"); 
     actual.put(2, "Two"); 

     assertThat(actual, matchesAnyEntryIn(expected)); 

     expected.remove(3); 
     expected.put(2, "Two"); 
     assertThat(actual, matchesEntriesIn(expected)); 
    } 

    @Test 
    public void mockitoTest() { 
     SystemUnderTest sut = mock(SystemUnderTest.class); 
     Map<Integer, String> expected = new HashMap<Integer, String>(); 
     expected.put(1, "One"); 
     expected.put(3, "Three"); 

     Map<Integer, String> actual = new HashMap<Integer, String>(); 
     actual.put(1, "One"); 

     when(sut.search(argThat(matchesAnyEntryIn(expected)))).thenReturn("Response"); 
     assertThat(sut.search(actual), is("Response")); 
    } 

    protected class SystemUnderTest { 
     // We don't really care what this does 
     public String search(Map<Integer, String> map) { 
      if (map == null) return null; 
      return map.get(0); 
     } 
    } 
} 

Answer 4

Se si vuole solo "match" contro una particolare mappa, è possibile utilizzare per alcune delle risposte di cui sopra, o un "matcher" personalizzato che estende Map, o un ArgumentCaptor, come questo:

ArgumentCaptor<Map> argumentsCaptured = ArgumentCaptor.forClass(Map.class); 
verify(mock, times(1)).method((Map<String, String>) argumentsCaptured.capture()); 
assert argumentsCaptured.getValue().containsKey("keyname"); 
// .getValue() will be the Map it called it with. 

Vedi anche più risposte qui: Verify object attribute value with mockito