Comment affirmer Carte contient la Carte avec entrée

J'ai une unité de test que doit vérier un imbriquée valeur de la carte. Je peux obtenir mon affirmation de travail en tirant à l'entrée et à la correspondance de la sous-jacentes Map, mais je cherchais un moyen de montrer que l'assertion est en train de faire. Voici un très simplifié test:

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasEntry;

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

import org.junit.Test;

public class MapContainsMapTest {
    @Test
    public void testMapHasMap() {
        Map<String, Object> outerMap = new HashMap<String, Object>();
        Map<String, Object> nestedMap = new HashMap<String, Object>();
        nestedMap.put("foo", "bar");
        outerMap.put("nested", nestedMap);

        //works but murky
        assertThat((Map<String, Object>) outerMap.get("nested"), hasEntry("foo", "bar"));
        //fails but clear
        assertThat(outerMap, hasEntry("nested", hasEntry("foo", "bar")));
    }
}

Il semble que le problème est que l'extérieur de la carte est en cours par rapport à l'aide de hasEntry(K key, V value) tout ce que je veux utiliser est hasEntry(Matcher<? super K> keyMatcher, Matcher<? super V> valueMatcher). Je ne suis pas sûr de la façon de contraindre l'affirmation d'utiliser la seconde forme.

Merci d'avance.

"Il semble que le problème est que l'extérieur de la carte est en cours par rapport à l'aide ..." hasEntry(is("key"), is("value")) par exemple serait la cause de la deuxième formulaire à utiliser. Peut-être que vous pourriez utiliser equalTo matcher en place de is, mais de toute façon, la lisibilité est en dehors de la fenêtre.
Le problème est à l'extérieur de test, donc j'ai besoin de quelque chose comme equalTo("nested")... mais qui ne fonctionne pas sauf si je change l'extérieur type de carte à Map<String, Map<String,Object>>

OriginalL'auteur Jeff E | 2015-07-20

Je serais probablement étendre une nouvelle Matcher pour que, quelque chose comme ça (attention, les Npe tapi):

class SubMapMatcher extends BaseMatcher<Map<?,?>> {

private Object key;
private Object subMapKey;
private Object subMapValue;

public SubMapMatcher(Object key, Object subMapKey, Object subMapValue) {
    super();
    this.key = key;
    this.subMapKey = subMapKey;
    this.subMapValue = subMapValue;
}

@Override
public boolean matches(Object item) {

    Map<?,?> map = (Map<?,?>)item;

    if (!map.containsKey(key)) {
        return false;
    }

    Object o = map.get(key);

    if (!(o instanceof Map<?,?>)) {
        return false;
    }

    Map<?,?> subMap = (Map<?,?>)o;
    return subMap.containsKey(subMapKey) && subMap.get(subMapKey).equals(subMapValue);
}

@Override
public void describeTo(Description description) {
    description.appendText(String.format("contains %s -> %s : %s", key, subMapKey, subMapValue));
}

public static SubMapMatcher containsSubMapWithKeyValue(String key, String subMapKey, String subMapValue) {
    return new SubMapMatcher(key, subMapKey, subMapValue);
}

}

Merci, cette réponse œuvres. Cependant, je pense que je voudrais voir si je peux l'étendre à permettre à n'importe quel niveau d'imbrication.
Semble assez facile, vous pouvez simplement utiliser une signature comme Object value, String... keys. Puis itérer sur les touches, obtenir la sous-carte jusqu'à ce que vous atteignez le dernier (ou tomber sur une valeur null ou n'est pas-carte comme valeur) et vérifier la valeur. Par exemple containsValueInSubMap( someValue, map0Key, map1Key, map2Key); bien sûr, personnellement, je ne voudrais PAS suggérer à l'aide d'une Carte standard pour une touche -> "de la valeur OU de la sous-carte" de la cartographie, mais plutôt quelque chose de plus spécifique qui permettrait également avoir génériques types de valeur (une carte avec des sous-cartes et efficace d'un arbre, doit être facile de trouver quelque chose).

OriginalL'auteur Florian Schaetz

Si vous souhaitez uniquement mettre Map<String, Object> comme des valeurs dans votre outerMap ajuster la déclaration en conséquence. Ensuite, vous pouvez faire

@Test
public void testMapHasMap() {
    Map<String, Map<String, Object>> outerMap = new HashMap<>();
    Map<String, Object> nestedMap = new HashMap<String, Object>();
    nestedMap.put("foo", "bar");
    outerMap.put("nested", nestedMap);

    Object value = "bar";
    assertThat(outerMap, hasEntry(equalTo("nested"), hasEntry("foo", value)));  
}

Object value = "bar"; est nécessaire pour compiler des raisons. Vous pouvez également utiliser

assertThat(outerMap,
   hasEntry(equalTo("nested"), Matchers.<String, Object> hasEntry("foo", "bar")));

Mon exemple est une version simplifiée de mon test de la outerMap est un objet JSON où toutes les entrées sont des cartes, donc je dois garder la carte de la déclaration écrite.

OriginalL'auteur eee

2

Si Vous déclarez outerMap comme Map<String, Map<String, Object>> vous n'avez pas besoin de laide de fonte. Comme ceci:
```
public class MapContainsMapTest {

    @Test
    public void testMapHasMap() {
        Map<String, Map<String, Object>> outerMap = new HashMap<>();
        Map<String, Object> nestedMap = new HashMap<>();
        nestedMap.put("foo", "bar");
        outerMap.put("nested", nestedMap);

        assertThat(outerMap.get("nested"), hasEntry("foo", "bar"));
    }
}
```
si j'ai retirer le plâtre, il ne marche pas compiler, outerMap doit être déclarée comme Map<String, Map<String, Object>>.
mieux?
Mon exemple est une version simplifiée de mon test de la outerMap est un objet JSON où toutes les entrées sont des cartes, donc je dois garder la carte de la déclaration écrite.

OriginalL'auteur David Pérez Cabrera

Vous devez vous connecter pour publier un commentaire.