org.hamcrest.core.StringStartsWith Java Examples

@Test
public void testPOJOWithNestedArrayNoHashCodeKeyRejection() {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<POJOWithHashCode> input = env.fromElements(
			new POJOWithHashCode(new int[] {1, 2}));

	TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple1<int[]>>(
			PrimitiveArrayTypeInfo.INT_PRIMITIVE_ARRAY_TYPE_INFO);

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedTypeInfo + " cannot be used as key."));

	input.keyBy("id");
}
 

@Test
public void testTupleNestedArrayKeyRejection() {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<Integer[], String>> input = env.fromElements(
			new Tuple2<>(new Integer[] {1, 2}, "test-test"));

	TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple2<Integer[], String>>(
			BasicArrayTypeInfo.INT_ARRAY_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO);

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedTypeInfo + " cannot be used as key."));

	input.keyBy(new KeySelector<Tuple2<Integer[], String>, Tuple2<Integer[], String>>() {
		@Override
		public Tuple2<Integer[], String> getKey(Tuple2<Integer[], String> value) throws Exception {
			return value;
		}
	});
}
 

@Test
public void testTupleNestedArrayKeyRejection() {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<Integer[], String>> input = env.fromElements(
			new Tuple2<>(new Integer[] {1, 2}, "test-test"));

	TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple2<Integer[], String>>(
			BasicArrayTypeInfo.INT_ARRAY_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO);

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedTypeInfo + " cannot be used as key."));

	input.keyBy(new KeySelector<Tuple2<Integer[], String>, Tuple2<Integer[], String>>() {
		@Override
		public Tuple2<Integer[], String> getKey(Tuple2<Integer[], String> value) throws Exception {
			return value;
		}
	});
}
 

@Test
public void testPOJOWithNestedArrayNoHashCodeKeyRejection() {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<POJOWithHashCode> input = env.fromElements(
			new POJOWithHashCode(new int[] {1, 2}));

	TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple1<int[]>>(
			PrimitiveArrayTypeInfo.INT_PRIMITIVE_ARRAY_TYPE_INFO);

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedTypeInfo + " cannot be used as key."));

	input.keyBy("id");
}
 

@Test
public void testTupleNestedArrayKeyRejection() {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<Integer[], String>> input = env.fromElements(
			new Tuple2<>(new Integer[] {1, 2}, "test-test"));

	TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple2<Integer[], String>>(
			BasicArrayTypeInfo.INT_ARRAY_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO);

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedTypeInfo + " cannot be used as key."));

	input.keyBy(new KeySelector<Tuple2<Integer[], String>, Tuple2<Integer[], String>>() {
		@Override
		public Tuple2<Integer[], String> getKey(Tuple2<Integer[], String> value) throws Exception {
			return value;
		}
	});
}
 

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 testPOJOWithNestedArrayNoHashCodeKeyRejection() {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<POJOWithHashCode> input = env.fromElements(
			new POJOWithHashCode(new int[] {1, 2}));

	TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple1<int[]>>(
			PrimitiveArrayTypeInfo.INT_PRIMITIVE_ARRAY_TYPE_INFO);

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedTypeInfo + " cannot be used as key."));

	input.keyBy("id");
}
 

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;
	}
}
 

private <K> void assertArrayKeyRejection(KeySelector<Tuple2<Integer[], String>, K> keySelector, TypeInformation<K> expectedKeyType) {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<Integer[], String>> input = env.fromElements(
			new Tuple2<>(new Integer[] {1, 2}, "barfoo"));

	Assert.assertEquals(expectedKeyType, TypeExtractor.getKeySelectorTypes(keySelector, input.getType()));

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedKeyType + " cannot be used as key."));

	input.keyBy(keySelector);
}
 

@Test
public void build_contoursAndColorsAmountMismatchExceptionThrown() throws ServicesException {
  thrown.expect(ServicesException.class);
  thrown.expectMessage(StringStartsWith.startsWith("Number of color elements must match number of minute elements provided."));
  MapboxIsochrone.builder()
    .accessToken(ACCESS_TOKEN)
    .addContoursMinutes(5,30,55)
    .addContoursColors("6706ce")
    .coordinates(testPoint)
    .profile(testProfile)
    .baseUrl(mockUrl.toString())
    .build();
}
 

@Test
public void extractSillyValue() throws Exception {

    RowCellExtractor extractor = new RowCellExtractor(3, CellType.NUMERIC);

    extractor.setRow(workbook.getSheet("sheet").getRow(0));
    thrown.expect(BlankCellException.class);
    thrown.expectMessage(new StringStartsWith("Could not extract value"));
    extractor.extract();

    extractor.setRow(workbook.getSheet("sheet").getRow(1));
    assertEquals("7.0", extractor.extract());

}
 

@Test
public void extractUnhandledCellType() throws Exception {

    RowCellExtractor extractor = new RowCellExtractor(4, CellType.FORMULA);

    extractor.setRow(workbook.getSheet("sheet").getRow(0));
    thrown.expect(ExtractorException.class);
    thrown.expectMessage(new StringStartsWith("Unhandled cell type"));
    extractor.extract();
}
 

@Test
public void extractNonExistingColumn() throws Exception {

    RowCellExtractor extractor = new RowCellExtractor(4, CellType.FORMULA);

    extractor.setRow(workbook.getSheet("sheet").getRow(1));
    thrown.expect(ExtractorException.class);
    thrown.expectMessage(new StringStartsWith("Column with index 4 does not exit"));
    extractor.extract();
}
 

@Test
public void defaultMethodForAFakeResquestIsGet() throws IOException {
    MatcherAssert.assertThat(
        "Can't add a method to a servlet request",
        new RqPrint(
            new RqFrom(
                new HttpServletRequestFake(
                    new RqFake()
                )
            )
        ).printHead(),
        new StringStartsWith(RqFromTest.GET_METHOD)
    );
}
 

@Test
public void containsMethodAndHeader() throws IOException {
    final String method = "GET /a-test";
    final String header = "foo: bar";
    MatcherAssert.assertThat(
        "Can't add a header to a servlet request",
        new RqPrint(
            new RqFrom(
                new HttpServletRequestFake(
                    new RqFake(
                        new ListOf<>(
                            method,
                            header
                        ),
                        ""
                    )
                )
            )
        ).printHead(),
        new StringStartsWith(
            new Joined(
                RqFromTest.EOL,
                method,
                "Host: localhost",
                header,
                RqFromTest.LOCAL_ADDRESS,
                RqFromTest.REMOTE_ADDRESS
            ).asString()
        )
    );
}
 

@Test
public void containsHostHeaderInHeader() throws IOException {
    final String method = "GET /one-more-test";
    final String header = "Host: www.thesite.com";
    MatcherAssert.assertThat(
        "Can't set a host in a servlet request",
        new RqPrint(
            new RqFrom(
                new HttpServletRequestFake(
                    new RqFake(
                        new ListOf<>(
                            method,
                            header
                        ),
                        ""
                    )
                )
            )
        ).printHead(),
        new StringStartsWith(
            new Joined(
                RqFromTest.EOL,
                method,
                header,
                RqFromTest.LOCAL_ADDRESS,
                RqFromTest.REMOTE_ADDRESS
            ).asString()
        )
    );
}
 

@Test
public void containsHostAndPortInHeader() throws IOException {
    final String method = "GET /b-test";
    final String header = "Host: 192.168.0.1:12345";
    MatcherAssert.assertThat(
        "Can't set a host and port in a servlet request",
        new RqPrint(
            new RqFrom(
                new HttpServletRequestFake(
                    new RqFake(
                        new ListOf<>(
                            method,
                            header
                        ),
                        ""
                    )
                )
            )
        ).printHead(),
        new StringStartsWith(
            new Joined(
                RqFromTest.EOL,
                method,
                header,
                RqFromTest.LOCAL_ADDRESS,
                RqFromTest.REMOTE_ADDRESS
            ).asString()
        )
    );
}
 

@Test
public void build_invalidAccessTokenExceptionThrown() throws ServicesException {
  thrown.expect(ServicesException.class);
  thrown.expectMessage(StringStartsWith.startsWith("Using Mapbox Services requires setting a valid access token"));
  MapboxTilequery.builder()
    .accessToken("")
    .query("-122.42901,37.80633")
    .tilesetIds("mapbox.mapbox-streets-v7")
    .baseUrl(mockUrl.toString())
    .build();
}
 

@Test
public void testEnumKeyRejection() {
	KeySelector<Tuple2<TestEnum, String>, TestEnum> keySelector = value -> value.f0;

	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<TestEnum, String>> input = env.fromElements(
			Tuple2.of(TestEnum.FOO, "Foo"),
			Tuple2.of(TestEnum.BAR, "Bar"));

	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + EnumTypeInfo.of(TestEnum.class) + " cannot be used as key."));

	input.keyBy(keySelector);
}
 

private void validateLockRequestException(LockRequest lockRequest, String message)
    throws Exception {
  exception.expect(ServiceException.class);
  exception.expectCause(IsInstanceOf.instanceOf(DoNotRetryIOException.class));
  exception.expectMessage(
      StringStartsWith.startsWith("org.apache.hadoop.hbase.DoNotRetryIOException: "
          + "java.lang.IllegalArgumentException: " + message));
  masterRpcService.requestLock(null, lockRequest);
}
 

@Test
public void convertsIterableToMap() {
    MatcherAssert.assertThat(
        "Can't convert iterable to map",
        new MapOf<Integer, String>(
            new MapEntry<>(0, "hello, "),
            new MapEntry<>(1, "world!")
        ),
        new IsMapContaining<>(
            new IsEqual<>(0),
            new StringStartsWith("hello")
        )
    );
}
 

private <K> void testKeyRejection(KeySelector<Tuple2<Integer[], String>, K> keySelector, TypeInformation<K> expectedKeyType) {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<Integer[], String>> input = env.fromElements(
			new Tuple2<>(new Integer[] {1, 2}, "barfoo")
	);

	Assert.assertEquals(expectedKeyType, TypeExtractor.getKeySelectorTypes(keySelector, input.getType()));

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedKeyType + " cannot be used as key."));

	input.keyBy(keySelector);
}
 

private <K> void testKeyRejection(KeySelector<Tuple2<Integer[], String>, K> keySelector, TypeInformation<K> expectedKeyType) {
	StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

	DataStream<Tuple2<Integer[], String>> input = env.fromElements(
			new Tuple2<>(new Integer[] {1, 2}, "barfoo")
	);

	Assert.assertEquals(expectedKeyType, TypeExtractor.getKeySelectorTypes(keySelector, input.getType()));

	// adjust the rule
	expectedException.expect(InvalidProgramException.class);
	expectedException.expectMessage(new StringStartsWith("Type " + expectedKeyType + " cannot be used as key."));

	input.keyBy(keySelector);
}
 

/**
 * RtLogs can fetch the Container's logs (return them as a String).
 * @throws Exception If something goes wrong.
 */
@Test
public void fetchesLogs() throws Exception {
    final Container container =  new UnixDocker(
        new File("/var/run/docker.sock")
    ).images().pull("hello-world", "latest").run();
    final String logs = container.logs().fetch();
    MatcherAssert.assertThat(
        logs,
        new StringStartsWith("\nHello from Docker!")
    );
}
 

/**
 * RtLogs can follow the Container's logs (return them as a Reader).
 * @throws Exception If something goes wrong.
 */
@Test
@Ignore
public void followsLogs() throws Exception {
    final Container container =  new UnixDocker(
        new File("/var/run/docker.sock")
    ).images().pull("ubuntu", "latest").run();
    final String logs = IOUtils.toString(container.logs().follow());
    MatcherAssert.assertThat(
        logs.trim(),
        new StringStartsWith("Hello from Docker!")
    );
}
 

@Theory
public void badParams(String badValue) {
    // setup
    formParams.put(HeartbeatAdapter.FROM_PLACE_NAME, Arrays.asList(badValue));
    formParams.put(HeartbeatAdapter.TO_PLACE_NAME, Arrays.asList(badValue));

    // test
    final Response response = target(HEARTBEAT_ACTION).request().post(Entity.form(formParams));

    // verify
    final int status = response.getStatus();
    assertThat(status, equalTo(500));
    final String result = response.readEntity(String.class);
    assertThat(result, StringStartsWith.startsWith("Heartbeat failed"));
}
 

@Test
public void assertCallFailure() throws Exception {
    ContentExchange actual = sentRequest("{\"string\":\"test\",\"integer\":\"invalid_number\"}");
    Assert.assertThat(actual.getResponseStatus(), Is.is(500));
    Assert.assertThat(actual.getResponseContent(), StringStartsWith.startsWith("java.lang.NumberFormatException"));
    Mockito.verify(caller).call("test");
}
 

@Test
public void assertNew() {
    TaskContext actual = new TaskContext("test_job", Lists.newArrayList(0), ExecutionType.READY, "slave-S0");
    Assert.assertThat(actual.getMetaInfo().getJobName(), Is.is("test_job"));
    Assert.assertThat(actual.getMetaInfo().getShardingItems().get(0), Is.is(0));
    Assert.assertThat(actual.getType(), Is.is(ExecutionType.READY));
    Assert.assertThat(actual.getSlaveId(), Is.is("slave-S0"));
    Assert.assertThat(actual.getId(), StringStartsWith.startsWith(TaskNode.builder().build().getTaskNodeValue().substring(0, TaskNode.builder().build().getTaskNodeValue().length() - 1)));
}
 

@Test
public void build_invalidAccessTokenExceptionThrown() throws ServicesException {
  thrown.expect(ServicesException.class);
  thrown.expectMessage(StringStartsWith.startsWith("Using the Mapbox Isochrone API requires setting a valid access token."));
  MapboxIsochrone.builder()
    .accessToken("")
    .addContoursMinutes(5,30,55)
    .coordinates(testPoint)
    .profile(testProfile)
    .baseUrl(mockUrl.toString())
    .build();
}
 

@Test
public void prunePathB() {
    int orgPathsCnt = swagger.getPaths().size();
    int orgDefCnt = swagger.getDefinitions().size();
    new PathPrunner()
            .prunePath("/b")
            .accept(swagger);
    assertEquals(orgPathsCnt - 4, swagger.getPaths().size());
    assertEquals(orgDefCnt, swagger.getDefinitions().size());
    Assert.assertThat(swagger.getPaths().keySet(), Every.everyItem(not(StringStartsWith.startsWith("/b"))));
}