Java 类org.hamcrest.collection.IsMapContaining 实例源码

@Test
public void shouldGetMapValue() throws Exception {
    Map<String, Object> map = new HashMap<>();
    map.put("text", "extraValue");
    map.put("number", 12);
    map.put("boolean", true);
    map.put("object", Collections.singletonMap("something", "else"));

    JsonNode value = mapper.valueToTree(map);
    Claim claim = claimFromNode(value);

    assertThat(claim, is(notNullValue()));
    Map<String, Object> backMap = claim.asMap();
    assertThat(backMap, is(notNullValue()));
    assertThat(backMap, hasEntry("text", (Object) "extraValue"));
    assertThat(backMap, hasEntry("number", (Object) 12));
    assertThat(backMap, hasEntry("boolean", (Object) true));
    assertThat(backMap, hasKey("object"));
    assertThat((Map<String, Object>) backMap.get("object"), IsMapContaining.hasEntry("something", (Object) "else"));
}

@Test
public void testAnnotations() throws ParsingException, IOException {
    final Record record = parseRecord("QueryLogParserV2dTest/testAnnotations.json");
    Assert.assertNotNull(record);
    Assert.assertEquals(DateTime.parse("2014-03-24T12:15:41.010Z"), record.getTime());

    Assert.assertNotNull(record.getAnnotations());

    Assert.assertEquals(2, record.getAnnotations().size());
    Assert.assertThat(record.getAnnotations(), IsMapContaining.hasEntry("method", "POST"));
    Assert.assertThat(record.getAnnotations(), IsMapContaining.hasEntry("request_id", "c5251254-8f7c-4c21-95da-270eb66e100b"));

    Assert.assertEquals(3, record.getDimensions().size());
    Assert.assertEquals("MyHost", record.getDimensions().get(Key.HOST_DIMENSION_KEY));
    Assert.assertEquals("MyService", record.getDimensions().get(Key.SERVICE_DIMENSION_KEY));
    Assert.assertEquals("MyCluster", record.getDimensions().get(Key.CLUSTER_DIMENSION_KEY));
}

@Override
public boolean matches(ItemHint hint) {
    if (this.index + 1 > hint.getProviders().size()) {
        return false;
    }
    ItemHint.ValueProvider valueProvider = hint.getProviders().get(this.index);
    if (this.name != null && !this.name.equals(valueProvider.getName())) {
        return false;
    }
    if (this.parameters != null) {
        for (Map.Entry<String, Object> entry : this.parameters.entrySet()) {
            if (!IsMapContaining.hasEntry(entry.getKey(), entry.getValue())
                    .matches(valueProvider.getParameters())) {
                return false;
            }
        }
    }
    return true;
}

@Override
public boolean matches(ItemHint hint) {
    if (this.index + 1 > hint.getProviders().size()) {
        return false;
    }
    ItemHint.ValueProvider valueProvider = hint.getProviders().get(this.index);
    if (this.name != null && !this.name.equals(valueProvider.getName())) {
        return false;
    }
    if (this.parameters != null) {
        for (Map.Entry<String, Object> entry : this.parameters.entrySet()) {
            if (!IsMapContaining.hasEntry(entry.getKey(), entry.getValue())
                    .matches(valueProvider.getParameters())) {
                return false;
            }
        }
    }
    return true;
}

@Override
public boolean matches(Object item) {
    ItemHint hint = (ItemHint) item;
    if (this.index + 1 > hint.getProviders().size()) {
        return false;
    }
    ItemHint.ValueProvider valueProvider = hint.getProviders().get(this.index);
    if (this.name != null && !this.name.equals(valueProvider.getName())) {
        return false;
    }
    if (this.parameters != null) {
        for (Map.Entry<String, Object> entry : this.parameters.entrySet()) {
            if (!IsMapContaining.hasEntry(entry.getKey(), entry.getValue())
                    .matches(valueProvider.getParameters())) {
                return false;
            }
        }
    }
    return true;
}

@Test
public void initWithPayload() {
    // given
    Action a1Enter = new Action() {
        @Override
        public void run() {
            // then
            assertThat(mPayload, IsMapContaining.hasKey("foo"));
        }
    };
    State a1 = new State("a1").onEnter(a1Enter);
    StateMachine sm = new StateMachine(a1);
    Map<String, Object> payload = new HashMap<String, Object>();
    payload.put("foo", "bar");

    // when
    sm.init(payload);
}

@Test
public void teardownWithPayload() {
    // when
    State a1 = new State("a1");
    State a = new Sub("a", a1);
    State b1 = new State("b1").onEnter(new Action() {
        @Override
        public void run() {
            assertThat(mPayload, IsMapContaining.hasKey("foo"));
        }
    });

    a1.addHandler("T1", b1, TransitionKind.External).onExit(new Action() {
        @Override
        public void run() {
            mPayload.put("foo", "bar");
        }
    });

    State b = new Sub("b", a, b1);
    StateMachine sm = new StateMachine(b);
    sm.init();
    sm.handleEvent("T1");
}

@Test
public void shouldGetMapValue() throws Exception {
    Map<String, Object> map = new HashMap<>();
    map.put("text", "extraValue");
    map.put("number", 12);
    map.put("boolean", true);
    map.put("object", Collections.singletonMap("something", "else"));

    JsonNode value = mapper.valueToTree(map);
    Claim claim = claimFromNode(value);

    assertThat(claim, is(notNullValue()));
    Map<String, Object> backMap = claim.asMap();
    assertThat(backMap, is(notNullValue()));
    assertThat(backMap, hasEntry("text", (Object) "extraValue"));
    assertThat(backMap, hasEntry("number", (Object) 12));
    assertThat(backMap, hasEntry("boolean", (Object) true));
    assertThat(backMap, hasKey("object"));
    assertThat((Map<String, Object>) backMap.get("object"), IsMapContaining.hasEntry("something", (Object) "else"));
}

@SuppressWarnings("RedundantCast")
@Test
public void shouldGetClaims() throws Exception {
    HashMap<String, Object> claims = new HashMap<>();
    claims.put("iss", "auth0");
    ClaimsHolder holder = new ClaimsHolder(claims);
    assertThat(holder, is(notNullValue()));
    assertThat(holder.getClaims(), is(notNullValue()));
    assertThat(holder.getClaims(), is(instanceOf(Map.class)));
    assertThat(holder.getClaims(), is(IsMapContaining.hasEntry("iss", (Object) "auth0")));
}

@Test
public void shouldHaveTree() throws Exception {
    HashMap<String, JsonNode> map = new HashMap<>();
    JsonNode node = NullNode.getInstance();
    map.put("key", node);
    BasicHeader header = new BasicHeader(null, null, null, null, map);

    assertThat(header.getTree(), is(notNullValue()));
    assertThat(header.getTree(), is(IsMapContaining.hasEntry("key", node)));
}

@Test
public void testOutputConversionToMap() {
    final List<String> outputlist = new ArrayList<>();
    outputlist.add("Driver1:Value1");
    outputlist.add("Driver2:Value2");
    outputlist.add("Driver3:Value3");

    final Map<String, String> outputMap = DomainSerialiser.convertOutputs(outputlist);
    assertEquals(3, outputMap.size());
    assertThat(outputMap, IsMapContaining.hasEntry("Driver1", "Value1"));
    assertThat(outputMap, IsMapContaining.hasEntry("Driver2", "Value2"));
    assertThat(outputMap, IsMapContaining.hasEntry("Driver3", "Value3"));
}

@Test
public void testInvalidOutputConversion() {
    final List<String> outputlist = new ArrayList<>();
    outputlist.add("Driver1:Value1");
    outputlist.add("Driver2Value2");
    outputlist.add("Driver3:Value3");

    final Map<String, String> outputMap = DomainSerialiser.convertOutputs(outputlist);
    assertEquals(2, outputMap.size());
    assertThat(outputMap, IsMapContaining.hasEntry("Driver1", "Value1"));
    assertThat(outputMap, IsMapContaining.hasEntry("Driver3", "Value3"));
}

@Test
public void testNoModificationIfNoFormMatches() throws Exception {
    instance.log.info("testNoModificationIfNoFormMatches");
    sampler.setPath("/base/no-match");
    sampler.addArgument("name", "value");
    instance.process();
    Map<String, String> args = sampler.getArguments().getArgumentsAsMap();
    assertThat(args.size(), is(1));
    assertThat(args, IsMapContaining.hasEntry("name", "value"));
}

@Test
public void testFormIsSelectedByMethodAndURL() throws Exception {
    instance.log.info("testFormIsSelectedByMethodAndURL");
    sampler.setMethod("GET");
    instance.process();
    Map<String, String> args = sampler.getArguments().getArgumentsAsMap();
    assertThat(args.size(), is(1));
    assertThat(args, IsMapContaining.hasEntry("hidden_input", "hidden_value3"));
}

@Test
public void testNoModificationToExplicitValue() throws Exception {
    instance.log.info("testNoModificationToExplicitValue");
    sampler.setPath("/other-form");
    sampler.addArgument("text_input", "explicit_value");
    instance.process();
    Map<String, String> args = sampler.getArguments().getArgumentsAsMap();
    assertThat(args.size(), is(2));
    assertThat(args, IsMapContaining.hasEntry("hidden_input", "hidden_value"));
    assertThat(args, IsMapContaining.hasEntry("text_input", "explicit_value"));
}

@Test
public void testFormIsSelectedByExplicitSubmit() throws Exception {
    instance.log.info("testFormIsSelectedByExplicitSubmit");
    sampler.addArgument("submit", "submit_value3");
    instance.process();
    Map<String, String> args = sampler.getArguments().getArgumentsAsMap();
    assertThat(args.size(), is(2));
    assertThat(args, IsMapContaining.hasEntry("submit", "submit_value3"));
    assertThat(args, IsMapContaining.hasEntry("hidden_input", "hidden_value2"));
}

@Test
public void testNoModificationIfAmbiguous() throws Exception {
    instance.log.info("testNoModificationIfAmbiguous");
    sampler.addArgument("submit", "submit_value2");
    instance.process();
    Map<String, String> args = sampler.getArguments().getArgumentsAsMap();
    assertThat(args.size(), is(1));
    assertThat(args, IsMapContaining.hasEntry("submit", "submit_value2"));
}

@Test
public void testAnnotations() throws ParsingException, IOException {
    final Record record = parseRecord("QueryLogParserV2cTest/testAnnotations.json");

    Assert.assertNotNull(record);

    Assert.assertEquals(3, record.getDimensions().size());
    Assert.assertEquals("MyHost", record.getDimensions().get(Key.HOST_DIMENSION_KEY));
    Assert.assertEquals("MyService", record.getDimensions().get(Key.SERVICE_DIMENSION_KEY));
    Assert.assertEquals("MyCluster", record.getDimensions().get(Key.CLUSTER_DIMENSION_KEY));

    Assert.assertEquals(2, record.getAnnotations().size());
    Assert.assertThat(record.getAnnotations(), IsMapContaining.hasEntry("method", "POST"));
    Assert.assertThat(record.getAnnotations(), IsMapContaining.hasEntry("request_id", "c5251254-8f7c-4c21-95da-270eb66e100b"));
}

@Test
public void shouldAddASingleParameter() throws Exception {
    baseRequest.addParameter("name", "value");

    final Map<String, Object> result = parameterBuilder.asDictionary();
    assertThat(result, IsMapWithSize.aMapWithSize(1));
    assertThat(result, IsMapContaining.hasEntry("name", (Object) "value"));
}

@Test
public void shouldAddParameters() throws Exception {
    Map<String, Object> params = new HashMap<>();
    params.put("name", "value");
    params.put("asd", "123");
    baseRequest.addParameters(params);

    final Map<String, Object> result = parameterBuilder.asDictionary();
    assertThat(result, IsMapWithSize.aMapWithSize(2));
    assertThat(result, IsMapContaining.hasEntry("name", (Object) "value"));
    assertThat(result, IsMapContaining.hasEntry("asd", (Object) "123"));
}

@Test
public void shouldParseUnsuccessfulJsonResponse() throws Exception {
    String payload = "{key: \"value\", asd: \"123\"}";
    final Response response = createJsonResponse(payload, 401);
    baseRequest.parseUnsuccessfulResponse(response);

    verify(errorBuilder).from(mapCaptor.capture());
    assertThat(mapCaptor.getValue(), IsMapContaining.hasEntry("key", (Object) "value"));
    assertThat(mapCaptor.getValue(), IsMapContaining.hasEntry("asd", (Object) "123"));
}

@Test
public void testRegistration() {
  for (Registrar registrar :
      ServiceLoader.load(Registrar.class)) {
    if (registrar instanceof BeamFnDataWriteRunner.Registrar) {
      assertThat(
          registrar.getPTransformRunnerFactories(),
          IsMapContaining.hasKey(RemoteGrpcPortWrite.URN));
      return;
    }
  }
  fail("Expected registrar not found.");
}

@Test
public void testRegistration() {
  for (Registrar registrar :
      ServiceLoader.load(Registrar.class)) {
    if (registrar instanceof BoundedSourceRunner.Registrar) {
      assertThat(registrar.getPTransformRunnerFactories(), IsMapContaining.hasKey(URN));
      return;
    }
  }
  fail("Expected registrar not found.");
}

@Test
public void testRegistration() {
  for (Registrar registrar :
      ServiceLoader.load(Registrar.class)) {
    if (registrar instanceof BeamFnDataReadRunner.Registrar) {
      assertThat(
          registrar.getPTransformRunnerFactories(),
          IsMapContaining.hasKey(RemoteGrpcPortRead.URN));
      return;
    }
  }
  fail("Expected registrar not found.");
}

@Test
public void testRegistration() {
  for (Registrar registrar :
      ServiceLoader.load(Registrar.class)) {
    if (registrar instanceof FnApiDoFnRunner.Registrar) {
      assertThat(registrar.getPTransformRunnerFactories(),
          IsMapContaining.hasKey(ParDoTranslation.CUSTOM_JAVA_DO_FN_URN));
      return;
    }
  }
  fail("Expected registrar not found.");
}

@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<>();
    for (K key : map.keySet()) {
        entries.add(IsMapContaining.hasEntry(key, map.get(key)));
    }
    return entries.toArray(new Matcher[entries.size()]);
}

@Test
public void testEvaluation() {
    Map<String, String> payload = new HashMap<>();
    payload.put("sepalLength", "6.4");
    payload.put("sepalWidth", "3.2");
    payload.put("petalLength", "4.5");
    payload.put("petalWidth", "1.5");
    channels.input().send(MessageBuilder.withPayload(payload).build());

    assertThat(messageCollector.forChannel(channels.output()),
            receivesPayloadThat(IsMapContaining.hasEntry("predictedSpecies", "versicolor")));
}

@Test
public void testEvaluation() {
    Map<String, Object> payload = new HashMap<>();
    Map<String, String> sepal = new HashMap<>();
    Map<String, String> petal = new HashMap<>();
    payload.put("Sepal", sepal);
    payload.put("Petal", petal);
    sepal.put("Length", "6.4");
    sepal.put("Width", "3.2");
    petal.put("Length", "4.5");
    petal.put("Width", "1.5");
    channels.input().send(MessageBuilder.withPayload(payload).build());

    assertThat(messageCollector.forChannel(channels.output()), receivesPayloadThat(IsMapContaining.hasEntry("Predicted_Species", "versicolor")));
}

@Test
public void testRequalifyShortWhiteListedProperty() {
    StreamAppDefinition appDefinition = new StreamAppDefinition.Builder().setRegisteredAppName("my-app")
            .setProperty("timezone", "GMT+2").build("streamname");

    Resource app = new ClassPathResource("/apps/whitelist-source");
    AppDefinition modified = this.appDeploymentRequestCreator.mergeAndExpandAppProperties(appDefinition, app,
            new HashMap<>());

    org.junit.Assert.assertThat(modified.getProperties(), IsMapContaining.hasEntry("date.timezone", "GMT+2"));
    org.junit.Assert.assertThat(modified.getProperties(), not(IsMapContaining.hasKey("timezone")));
}

@Test
public void testSameNamePropertiesOKAsLongAsNotUsedAsShorthand() {
    StreamAppDefinition appDefinition = new StreamAppDefinition.Builder().setRegisteredAppName("my-app")
            .setProperty("time.format", "hh").setProperty("date.format", "yy").build("streamname");

    Resource app = new ClassPathResource("/apps/whitelist-source");
    AppDefinition modified = this.appDeploymentRequestCreator.mergeAndExpandAppProperties(appDefinition, app,
            new HashMap<>());

    org.junit.Assert.assertThat(modified.getProperties(), IsMapContaining.hasEntry("date.format", "yy"));
    org.junit.Assert.assertThat(modified.getProperties(), IsMapContaining.hasEntry("time.format", "hh"));
}

@Test
public void testShorthandsAcceptRelaxedVariations() {
    StreamAppDefinition appDefinition = new StreamAppDefinition.Builder().setRegisteredAppName("my-app")
            .setProperty("someLongProperty", "yy") // Use camelCase here
            .build("streamname");

    Resource app = new ClassPathResource("/apps/whitelist-source");
    AppDefinition modified = this.appDeploymentRequestCreator.mergeAndExpandAppProperties(appDefinition, app,
            new HashMap<>());

    org.junit.Assert.assertThat(modified.getProperties(),
            IsMapContaining.hasEntry("date.some-long-property", "yy"));

}

@Test
  public void contentEncodingWorks( ) throws IOException
  {
      final Client client = Haligate.defaultClient( );
      @SuppressWarnings( "serial" )
final Map< String, String > content = client.from( rootUri ).follow( "movies", "movie[name:The Matrix]" ).asObject( new TypeToken< Map< String, String > >( ) { } );

      assertThat( content, IsMapContaining.hasKey( "aka" ) );
      assertThat( content.get( "aka" ), equalTo( "Матрица" ) );
  }

@SuppressWarnings("RedundantCast")
@Test
public void shouldGetClaims() throws Exception {
    HashMap<String, Object> claims = new HashMap<>();
    claims.put("iss", "auth0");
    ClaimsHolder holder = new ClaimsHolder(claims);
    assertThat(holder, is(notNullValue()));
    assertThat(holder.getClaims(), is(notNullValue()));
    assertThat(holder.getClaims(), is(instanceOf(Map.class)));
    assertThat(holder.getClaims(), is(IsMapContaining.hasEntry("iss", (Object) "auth0")));
}

@Test
public void shouldHaveTree() throws Exception {
    HashMap<String, JsonNode> map = new HashMap<>();
    JsonNode node = NullNode.getInstance();
    map.put("key", node);
    BasicHeader header = new BasicHeader(null, null, null, null, map);

    assertThat(header.getTree(), is(notNullValue()));
    assertThat(header.getTree(), is(IsMapContaining.hasEntry("key", node)));
}

private void serviceRegisterTest(ConsulClient consulClient) {
    NewService newService = new NewService();
    String serviceName = "abc";
    newService.setName(serviceName);
    consulClient.agentServiceRegister(newService);

    Response<Map<String, Service>> agentServicesResponse = consulClient.getAgentServices();
    Map<String, Service> services = agentServicesResponse.getValue();
    assertThat(services, IsMapContaining.hasKey(serviceName));
}

@Test
public void flattenMap() {
  Multimap<String, Object> multiMap = HashMultimap.create();
  multiMap.put("foo", "bar");
  multiMap.put("foo", "baz");
  assertThat(CypherUtil.flattenMap(multiMap), IsMapContaining.hasKey("foo"));
}

private void assertValidMetadata(Map<String, Object> map) {
    assertThat(map, is(notNullValue()));
    assertThat(map, IsMapContaining.hasKey("user_metadata"));
    Map<String, String> resultMetadata = (Map<String, String>) map.get("user_metadata");
    assertThat(resultMetadata, IsMapContaining.hasEntry("key", "value"));
    assertThat(resultMetadata, IsMapContaining.hasEntry("abc", "123"));
}

@Test
public void testReadOverlappingWildcradsShouldPlaceStringInMultipleMatchingFields() {
    SolrDocument document = new SolrDocument();
    document.addField("some_key_s", "value_1");

    BeanWithOverlappingWildcards target = converter.read(BeanWithOverlappingWildcards.class, document);
    Assert.assertThat(target.justAString, IsNull.nullValue(String.class));
    Assert.assertThat(target.keys, IsMapContaining.hasEntry("some_key_s", "value_1"));
    Assert.assertThat(target.strings, IsMapContaining.hasEntry("some_key_s", "value_1"));
}

@Test
public void testReadOverlappingWildcradsShouldPlaceStringInOnlyOneMatchingFieldWhenNoFullMatch() {
    SolrDocument document = new SolrDocument();
    document.addField("some_different_s", "value_1");

    BeanWithOverlappingWildcards target = converter.read(BeanWithOverlappingWildcards.class, document);
    Assert.assertThat(target.justAString, IsNull.nullValue(String.class));
    Assert.assertThat(target.keys, IsNull.nullValue(Map.class));
    Assert.assertThat(target.strings, IsMapContaining.hasEntry("some_different_s", "value_1"));
}

@Test
@SuppressWarnings("unchecked")
public void testConvertFieldWithEmtpyCollectionsAddsNullValueForUpdate() {
    PartialUpdate update = new PartialUpdate("id", "1");
    update.add("field_1", Collections.emptyList());

    SolrInputDocument document = converter.convert(update);
    Assert.assertThat((Map<String, Object>)document.getFieldValue("field_1"), IsMapContaining.hasEntry("set", null));
}