org.assertj.core.api.AbstractObjectAssert Java Examples

@Test
void okAndPreparedOk() {
    AbstractObjectAssert<?, OkMessage> ok = assertThat(decode(okLike(), DecodeContext.command()))
        .isExactlyInstanceOf(OkMessage.class)
        .extracting(message -> (OkMessage) message);

    ok.extracting(OkMessage::getAffectedRows).isEqualTo(1L);
    ok.extracting(OkMessage::getLastInsertId).isEqualTo(0x10000L); // 65536
    ok.extracting(OkMessage::getServerStatuses).isEqualTo((short) 0x100); // 256
    ok.extracting(OkMessage::getWarnings).isEqualTo(0);

    AbstractObjectAssert<?, PreparedOkMessage> preparedOk = assertThat(decode(okLike(), DecodeContext.prepareQuery()))
        .isExactlyInstanceOf(PreparedOkMessage.class)
        .extracting(message -> (PreparedOkMessage) message);

    preparedOk.extracting(PreparedOkMessage::getStatementId).isEqualTo(0xFD01); // 64769
    preparedOk.extracting(PreparedOkMessage::getTotalColumns).isEqualTo(1);
    preparedOk.extracting(PreparedOkMessage::getTotalParameters).isEqualTo(1);
}
 

@Test
void okAndPreparedOk() {
    AbstractObjectAssert<?, OkMessage> ok = assertThat(decode(okLike(), DecodeContext.command()))
        .isExactlyInstanceOf(OkMessage.class)
        .extracting(message -> (OkMessage) message);

    ok.extracting(OkMessage::getAffectedRows).isEqualTo(1L);
    ok.extracting(OkMessage::getLastInsertId).isEqualTo(0x10000L); // 65536
    ok.extracting(OkMessage::getServerStatuses).isEqualTo((short) 0x100); // 256
    ok.extracting(OkMessage::getWarnings).isEqualTo(0);

    AbstractObjectAssert<?, PreparedOkMessage> preparedOk = assertThat(decode(okLike(), DecodeContext.prepareQuery()))
        .isExactlyInstanceOf(PreparedOkMessage.class)
        .extracting(message -> (PreparedOkMessage) message);

    preparedOk.extracting(PreparedOkMessage::getStatementId).isEqualTo(0xFD01); // 64769
    preparedOk.extracting(PreparedOkMessage::getTotalColumns).isEqualTo(1);
    preparedOk.extracting(PreparedOkMessage::getTotalParameters).isEqualTo(1);
}
 

public AbstractObjectAssert<?, Object> hasPath(String path) {
	try {
		return Assertions.assertThat(this.actual.read(path, Object.class));
	}
	catch (PathNotFoundException ex) {
		failWithMessage("The JSON " + this.actual.jsonString() + " does not contain the path '" + path + "'");
		return null;
	}
}
 

/**
 * Asserts there is a validation error, and allows further assertions on it.
 */
public AbstractObjectAssert<?,?> validationError() {
    return Assertions.assertThat(validationError(Object.class));
}
 

/**
 * Asserts the results are valid and NOT already applied, and performs further assertions on the reply message.
 */
public AbstractObjectAssert<?,?> nonIdempotentReply() {
    return Assertions.assertThat(nonIdempotentReply(Object.class));
}
 

@SuppressWarnings("unchecked")
private <T> AbstractObjectAssert<?, T> assertAt(int index, Class<T> type) {
    AbstractObjectAssert<?, ?> anAssert = Assertions.assertThat(events.get(index));
    anAssert.isInstanceOf(type);
    return (AbstractObjectAssert<?, T>) anAssert;
}
 

public <T> AbstractObjectAssert<?, T> assertFirst(Class<T> type) {
    return this.assertAt(0, type);
}
 

public <T> AbstractObjectAssert<?, T> assertLast(Class<T> type) {
    return this.assertAt(events.size() - 1, type);
}
 

public AbstractObjectAssert<?, Object> hasPath(String path) {
	return Assertions.assertThat(actual.read(path, Object.class));
}
 

private AbstractObjectAssert<?, Number> assertStat(String key) {
  return assertThat((Number) onHeap.getKnownStatistics().get(key).value());
}
 

private AbstractObjectAssert<?, Number> assertStat(String key) {
  return assertThat((Number) cacheStatistics.getKnownStatistics().get(key).value());
}
 

private AbstractObjectAssert<?, Number> assertStat(String key) {
  return assertThat((Number) onHeap.getKnownStatistics().get(key).value());
}
 

static <T> AbstractObjectAssert<?, T> assertThat(T actual) {
    return new ObjectAssert<>(actual);
}
 

/**
 * Make equality assertions on {@link org.eclipse.ditto.model.base.headers.WithDittoHeaders} comparing only
 * the external headers.
 *
 * @param actual a signal.
 * @return an Assert object for the signal.
 */
default AbstractObjectAssert<?, WithDittoHeaders> assertWithExternalHeadersThat(final WithDittoHeaders actual) {
    return new WithFilteredHeadersAssert(actual, DittoProtocolAdapter.getHeaderTranslator(), true);
}
 

/**
 * Asserts the results are valid and already applied, and performs further assertions on the reply message.
 *
 * It is recommended that subclasses declare a more specific overload of this method, e.g.
 * <pre>
 *    public AbstractObjectAssert<?, MyResponseType> idempotentReply() {
 *      return Assertions.assertThat(idempotentReply(MyResponseType.class));
 *    }
 * </pre>
 */
public AbstractObjectAssert<?,?> idempotentReply() {
    return Assertions.assertThat(idempotentReply(Object.class));
}
 

/**
 * A little wrapper over {@code assertThat} that just mention that this what we expect from the test. So if the
 * expectation fails, it's probably the test that is wrong, not the implementation.
 *
 * @param actual actual value
 * @return an AssertJ assertion
 */
protected static <T> AbstractObjectAssert<?, T> expect(T actual) {
  return assertThat(actual);
}