org.hamcrest.MatcherAssert Java Examples

@Test
public void extractsUriFromDict() {
    final String base = "http://localhost:8080";
    final String path = "/example";
    MatcherAssert.assertThat(
        new RequestUri.Of(
            new HashDict(
                new KvpOf("uri", base),
                new KvpOf("path", path),
                new KvpOf("q.first", "10"),
                new KvpOf("q.second", "someStr")
            )
        ).uri().toString(),
        new IsEqual<>(
            String.format(
                "%s?first=10&second=someStr",
                URI.create(base + path).toString()
            )
        )
    );
}
 

private String getContent(MvcResult result) throws UnsupportedEncodingException {
	String content = result.getResponse().getContentAsString();
	if (StringUtils.hasLength(this.prefix)) {
		try {
			String reason = String.format("Expected a JSON payload prefixed with \"%s\" but found: %s",
					this.prefix, StringUtils.quote(content.substring(0, this.prefix.length())));
			MatcherAssert.assertThat(reason, content, StringStartsWith.startsWith(this.prefix));
			return content.substring(this.prefix.length());
		}
		catch (StringIndexOutOfBoundsException ex) {
			throw new AssertionError("JSON prefix \"" + this.prefix + "\" not found", ex);
		}
	}
	else {
		return content;
	}
}
 

@Test
public void expandWireWithAdditionalData() throws Exception {
    final Dict response = new ExpandedWire(
        req -> req, new ContentType("application/json")
    ).send(new HashDict(new KvpOf("foo", "bar")));
    MatcherAssert.assertThat(
        new CollectionOf<>(response).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        response.get("h.Content-Type"),
        new IsEqual<>("application/json")
    );
    MatcherAssert.assertThat(
        response.get("foo"),
        new IsEqual<>("bar")
    );
}
 

@Test
public void testCrawlersSessionIdIsRemovedAfterSessionExpiry() throws IOException, ServletException {
    CrawlerSessionManagerValve valve = new CrawlerSessionManagerValve();
    valve.setCrawlerIps("216\\.58\\.206\\.174");
    valve.setCrawlerUserAgents(valve.getCrawlerUserAgents());
    valve.setNext(EasyMock.createMock(Valve.class));
    valve.setSessionInactiveInterval(0);
    StandardSession session = new StandardSession(TEST_MANAGER);
    session.setId("id");
    session.setValid(true);

    Request request = createRequestExpectations("216.58.206.174", session, true);

    EasyMock.replay(request);

    valve.invoke(request, EasyMock.createMock(Response.class));

    EasyMock.verify(request);

    MatcherAssert.assertThat(valve.getClientIpSessionId().values(), CoreMatchers.hasItem("id"));

    session.expire();

    Assert.assertEquals(0, valve.getClientIpSessionId().values().size());
}
 

@Test
public void joinsKvpWithDict() {
    final Dict dict = new JoinedDict(
        new KvpOf("first", "first"),
        new HashDict(
            new KvpOf("first", "second"),
            new KvpOf("foo", "bar")
        )
    );
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        //@checkstyle MagicNumberCheck (1 lines)
        new IsEqual<>(3)
    );
    MatcherAssert.assertThat(
        dict.get("first"),
        new IsEqual<>("second")
    );
    MatcherAssert.assertThat(
        dict.get("foo"),
        new IsEqual<>("bar")
    );
}
 

@Test
public void extractHeadersFromDict() {
    final List<Kvp> kvps = new ListOf<>(
        new Headers.Of(
            new HashDict(
                new KvpOf("test", "test"),
                new KvpOf("h.kfirst", "first"),
                new KvpOf("h.ksecond", "second")
            )
        )
    );
    MatcherAssert.assertThat(
        kvps.size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        kvps.get(0).key(),
        new IsEqual<>("kfirst")
    );
    MatcherAssert.assertThat(
        kvps.get(1).key(),
        new IsEqual<>("ksecond")
    );
}
 

@Test
public void joinsDictionaries() {
    final Dict dict = new JoinedDict(
        new HashDict(
            new KvpOf("first", "first")
        ),
        new HashDict(
            new KvpOf("first", "second"),
            new KvpOf("foo", "bar")
        )
    );
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        //@checkstyle MagicNumberCheck (1 lines)
        new IsEqual<>(3)
    );
    MatcherAssert.assertThat(
        dict.get("first"),
        new IsEqual<>("second")
    );
    MatcherAssert.assertThat(
        dict.get("foo"),
        new IsEqual<>("bar")
    );
}
 

@Test
public void buildsPostRequest() {
    final Dict dict = new Post("/items", new ContentType("text/html"));
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("POST")
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("/items")
    );
    MatcherAssert.assertThat(
        dict.get("h.Content-Type"),
        new IsEqual<>("text/html")
    );
}
 

@Test
public void buildsPostRequestWithoutParameters() {
    final Dict dict = new Post("/items");
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("POST")
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("/items")
    );
}
 

@Test
public void buildsEmptyPostRequest() {
    final Dict dict = new Post();
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("POST")
    );
    MatcherAssert.assertThat(
        dict.get("path").isEmpty(),
        new IsEqual<>(true)
    );
}
 

@Test
public void buildsPostRequestWithEmptyPath() {
    final Dict dict = new Post(new ContentType("text/html"));
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(3)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("POST")
    );
    MatcherAssert.assertThat(
        dict.get("path").isEmpty(),
        new IsEqual<>(true)
    );
    MatcherAssert.assertThat(
        dict.get("h.Content-Type"),
        new IsEqual<>("text/html")
    );
}
 

@Test
public void buildsPutRequestWithoutParameters() {
    final Dict dict = new Put("/items");
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("PUT")
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("/items")
    );
}
 

@Test
public void testNoFallback() throws SCMException {
  assumeTrue(datanodeCount > (NODE_PER_RACK * 2) &&
      (datanodeCount <= NODE_PER_RACK * 3));
  // 5 replicas. there are only 3 racks. policy prohibit fallback should fail.
  int nodeNum = 5;
  try {
    policyNoFallback.chooseDatanodes(null, null, nodeNum, 15);
    fail("Fallback prohibited, this call should fail");
  } catch (Exception e) {
    assertEquals("SCMException", e.getClass().getSimpleName());
  }

  // get metrics
  long totalRequest = metrics.getDatanodeRequestCount();
  long successCount = metrics.getDatanodeChooseSuccessCount();
  long tryCount = metrics.getDatanodeChooseAttemptCount();
  long compromiseCount = metrics.getDatanodeChooseFallbackCount();

  Assert.assertEquals(totalRequest, nodeNum);
  MatcherAssert.assertThat("Not enough success count", successCount,
      greaterThanOrEqualTo(1L));
  MatcherAssert.assertThat("Not enough try count", tryCount,
      greaterThanOrEqualTo((long) 1L));
  Assert.assertEquals(compromiseCount, 0);
}
 

@Test
public void buildsGetRequestWithEmptyPath() {
    final Dict dict = new Get(new ContentType("text/html"));
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(3)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("GET")
    );
    MatcherAssert.assertThat(
        dict.get("path").isEmpty(),
        new IsEqual<>(true)
    );
    MatcherAssert.assertThat(
        dict.get("h.Content-Type"),
        new IsEqual<>("text/html")
    );
}
 

@Test
public void buildsGetRequestWithoutParameters() {
    final Dict dict = new Get("/items");
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("GET")
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("/items")
    );
}
 

@Test
public void buildsGetRequest() {
    final Dict dict = new Get("/items", new ContentType("text/html"));
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("GET")
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("/items")
    );
    MatcherAssert.assertThat(
        dict.get("h.Content-Type"),
        new IsEqual<>("text/html")
    );
}
 

@Test
public void concatenatesPath() {
    final Dict dict = new Path("/items")
        .apply(
            new HashDict(
                new KvpOf("aaa", "test"),
                new KvpOf("path", "localhost")
            )
        );
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(3)
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("localhost/items")
    );
}
 

@Test
public void buildsEmptyDeleteRequest() {
    final Dict dict = new Delete();
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("DELETE")
    );
    MatcherAssert.assertThat(
        dict.get("path").isEmpty(),
        new IsEqual<>(true)
    );
}
 

@Test
public void buildsPutRequestWithEmptyPath() {
    final Dict dict = new Put(new ContentType("text/html"));
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(3)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("PUT")
    );
    MatcherAssert.assertThat(
        dict.get("path").isEmpty(),
        new IsEqual<>(true)
    );
    MatcherAssert.assertThat(
        dict.get("h.Content-Type"),
        new IsEqual<>("text/html")
    );
}
 

@Test
public void buildsEmptyPutRequest() {
    final Dict dict = new Put();
    MatcherAssert.assertThat(
        new CollectionOf<>(dict).size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("PUT")
    );
    MatcherAssert.assertThat(
        dict.get("path").isEmpty(),
        new IsEqual<>(true)
    );
}
 

@Test
public void buildsPutRequest() {
    final Dict dict = new Put("/items", new ContentType("text/html"));
    MatcherAssert.assertThat(
        dict.get("method"),
        new IsEqual<>("PUT")
    );
    MatcherAssert.assertThat(
        dict.get("path"),
        new IsEqual<>("/items")
    );
    MatcherAssert.assertThat(
        dict.get("h.Content-Type"),
        new IsEqual<>("text/html")
    );
}
 

@Test(timeout = 10000)
public void testOnEventLoopIteration() throws Exception {
    CountingRunnable onIteration = new CountingRunnable();
    loopC.executeAfterEventLoopIteration(onIteration);
    CountingRunnable noopTask = new CountingRunnable();
    loopC.submit(noopTask).sync();
    loopC.iterationEndSignal.take();
    MatcherAssert.assertThat("Unexpected invocation count for regular task.",
                             noopTask.getInvocationCount(), is(1));
    MatcherAssert.assertThat("Unexpected invocation count for on every eventloop iteration task.",
                             onIteration.getInvocationCount(), is(1));
}
 

@Override
public <T extends S, R> T value(Function<B, R> bodyMapper, Matcher<R> matcher) {
	this.result.assertWithDiagnostics(() -> {
		B body = this.result.getResponseBody();
		MatcherAssert.assertThat(bodyMapper.apply(body), matcher);
	});
	return self();
}
 

@Test
public void extractsHeaderFromDict() {
    final String name = "John";
    MatcherAssert.assertThat(
        new Header.Of(
            "name",
            new HashDict(
                new KvpOf("h.Name", name),
                new KvpOf("surname", "Smith")
            )
        ).asString(),
        new IsEqual<>(name)
    );
}
 

@Test
public void entityListWithConsumer() {

	this.client.get()
			.exchange()
			.expectStatus().isOk()
			.expectHeader().contentType(MediaType.APPLICATION_JSON_UTF8)
			.expectBodyList(Person.class).value(people -> {
				MatcherAssert.assertThat(people, hasItem(new Person("Jason")));
			});
}
 

@Test
public void appliesMethodToRequest() {
    final String method = "GET";
    MatcherAssert.assertThat(
        new Method(method).apply(new HashDict()).get("method"),
        new IsEqual<>(method)
    );
}
 

@Test
public void deveRetornarABuscaPeloNome() {
    HttpHeaders headers = new HttpHeaders();
    headers.set("Accept", MediaType.APPLICATION_JSON_VALUE);

    UriComponentsBuilder builder = UriComponentsBuilder
            .fromHttpUrl(getUrl())
            .queryParam("nome", "Val")
            .queryParam("altura", 190)
            .queryParam("foto", "url");

    ResponseEntity<List<Person>> entity = template.exchange(builder.toUriString(),
            HttpMethod.GET,
            new HttpEntity<>(headers),
            new ParameterizedTypeReference<List<Person>>() {
            });

    Assertions.assertEquals(HttpStatus.OK, entity.getStatusCode());

    List<Person> pessoas = entity.getBody();
    Assertions.assertEquals(1, pessoas.size());
    List<String> nomes = pessoas.stream().map(Person::getNome).collect(Collectors.toList());

    MatcherAssert.assertThat(nomes, Matchers.contains("Val"));


}
 

@Test
public void addsAuthorizationHeaderToRequest() {
    final String value = "basic";
    MatcherAssert.assertThat(
        new Authorization(value)
            .apply(new HashDict())
            .get("h.Authorization"),
        new IsEqual<>(value)
    );
}
 

@Test
public void extractsJsonReaderFromDict() {
    MatcherAssert.assertThat(
        new JsonBody.Of(
            new HashDict(
                new KvpOf("body", "{}"),
                new KvpOf("unknown", "")
            )
        ).reader(),
        new IsNot<>(new IsNull<>())
    );
}
 

@Override
public <T extends S, R> T value(Function<B, R> bodyMapper, Matcher<R> matcher) {
	this.result.assertWithDiagnostics(() -> {
		B body = this.result.getResponseBody();
		MatcherAssert.assertThat(bodyMapper.apply(body), matcher);
	});
	return self();
}