org.assertj.core.api.InstanceOfAssertFactories Java Examples

@Test
public void canConvertOptionsWithPrefsToCapabilitiesAndRestoreBack() {
  FirefoxOptions options = new FirefoxOptions(
      new MutableCapabilities(new FirefoxOptions()
                                  .addPreference("string.pref", "some value")
                                  .addPreference("int.pref", 42)
                                  .addPreference("boolean.pref", true)));
  Object options2 = options.asMap().get(FirefoxOptions.FIREFOX_OPTIONS);
  assertThat(options2)
      .asInstanceOf(InstanceOfAssertFactories.MAP)
      .extractingByKey("prefs")
      .asInstanceOf(InstanceOfAssertFactories.MAP)
      .containsEntry("string.pref", "some value")
      .containsEntry("int.pref", 42)
      .containsEntry("boolean.pref", true);
}
 

@Test public void scopeDecorators() {
  context = new XmlBeans(""
    + "<bean id=\"currentTraceContext\" class=\"brave.spring.beans.CurrentTraceContextFactoryBean\">\n"
    + "  <property name=\"scopeDecorators\">\n"
    + "    <list>\n"
    + "      <bean class=\"brave.propagation.StrictScopeDecorator\" factory-method=\"create\"/>\n"
    + "    </list>\n"
    + "  </property>"
    + "</bean>"
  );

  assertThat(context.getBean("currentTraceContext", CurrentTraceContext.class))
    .extracting("scopeDecorators")
    .asInstanceOf(InstanceOfAssertFactories.ARRAY)
    .isNotEmpty();
}
 

@Test public void defaultFields() {
  context = new XmlBeans(""
    + "<bean id=\"correlationDecorator\" class=\"brave.spring.beans.CorrelationScopeDecoratorFactoryBean\">\n"
    + "  <property name=\"builder\">\n"
    + "    <bean class=\"brave.context.log4j12.MDCScopeDecorator\" factory-method=\"newBuilder\"/>\n"
    + "  </property>\n"
    + "</bean>"
  );

  assertThat(context.getBean("correlationDecorator", CorrelationScopeDecorator.class))
    .extracting("fields").asInstanceOf(InstanceOfAssertFactories.ARRAY)
    .containsExactly(
      SingleCorrelationField.create(TRACE_ID),
      SingleCorrelationField.create(SPAN_ID)
    );
}
 

@Test public void bothSpanHandlers() {
  context = new XmlBeans(""
      + "<bean id=\"tracing\" class=\"brave.spring.beans.TracingFactoryBean\">\n"
      + "  <property name=\"finishedSpanHandlers\">\n"
      + "    <util:constant static-field=\"" + getClass().getName() + ".FINISHED_SPAN_HANDLER\"/>\n"
      + "  </property>\n"
      + "  <property name=\"spanHandlers\">\n"
      + "    <util:constant static-field=\"" + getClass().getName() + ".SPAN_HANDLER\"/>\n"
      + "  </property>\n"
      + "</bean>"
  );

  assertThat(context.getBean("tracing", Tracing.class))
      .extracting("tracer.spanHandler.delegate.handlers")
      .asInstanceOf(InstanceOfAssertFactories.ARRAY)
      .containsExactly(FINISHED_SPAN_HANDLER, SPAN_HANDLER);
}
 

@Test
@CmmnDeployment
public void testGetCmmnModelWithDelegateHelper() {
    CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder()
            .caseDefinitionKey("myCase")
            .start();

    assertThat(TestJavaDelegate01.cmmnModel).isNotNull();
    assertThat(TestJavaDelegate01.cmmnElement)
            .asInstanceOf(InstanceOfAssertFactories.type(PlanItem.class))
            .extracting(PlanItem::getName)
            .isEqualTo("Task One");
}
 

@Test
public void should_only_include_whitelist() {
	assertThat(this.scopeDecorator).extracting("fields")
			.asInstanceOf(
					InstanceOfAssertFactories.array(SingleCorrelationField[].class))
			.extracting(SingleCorrelationField::name)
			.containsOnly("traceId", "spanId", "bp", COUNTRY_CODE.name()); // x-vcap-request-id
																			// is not
																			// in the
																			// whitelist
}
 

static ListAssert<Tuple> assertThatBaggageFieldNameToKeyNames(
		AssertableApplicationContext context) {
	return assertThat(context.getBean(Propagation.Factory.class))
			.extracting("configs").asInstanceOf(InstanceOfAssertFactories.ARRAY)
			.extracting("field.name", "keyNames.toArray")
			.asInstanceOf(InstanceOfAssertFactories.list(Tuple.class));
}
 

@Test
public void stringBasedBinaryRemainsAbsoluteIfSetAsAbsolute() {
  Map<String, Object> json = new FirefoxOptions().setBinary("/i/like/cheese").asMap();

  assertThat(json.get(FIREFOX_OPTIONS))
      .asInstanceOf(InstanceOfAssertFactories.MAP)
      .containsEntry("binary", "/i/like/cheese");
}
 

@Test
public void pathBasedBinaryRemainsAbsoluteIfSetAsAbsolute() {
  Map<String, Object> json = new FirefoxOptions().setBinary(Paths.get("/i/like/cheese")).asMap();

  assertThat(json.get(FIREFOX_OPTIONS))
    .asInstanceOf(InstanceOfAssertFactories.MAP)
    .containsEntry("binary", "/i/like/cheese");
}
 

@Test
public void canConvertOptionsWithArgsToCapabilitiesAndRestoreBack() {
  FirefoxOptions options = new FirefoxOptions(
      new MutableCapabilities(new FirefoxOptions().addArguments("-a", "-b")));
  Object options2 = options.asMap().get(FirefoxOptions.FIREFOX_OPTIONS);
  assertThat(options2)
      .asInstanceOf(InstanceOfAssertFactories.MAP)
      .containsEntry("args", Arrays.asList("-a", "-b"));
}
 

@Test
public void canConvertOptionsWithBinaryToCapabilitiesAndRestoreBack() {
  FirefoxOptions options = new FirefoxOptions(
      new MutableCapabilities(new FirefoxOptions().setBinary(new FirefoxBinary())));
  Object options2 = options.asMap().get(FirefoxOptions.FIREFOX_OPTIONS);
  assertThat(options2)
      .asInstanceOf(InstanceOfAssertFactories.MAP)
      .containsEntry("binary", new FirefoxBinary().getPath().replaceAll("\\\\", "/"));
}
 

@Test public void ignoresNoopScopeDecorator() {
  ScopeDecorator one = (context, scope) -> scope;

  CurrentTraceContext shouldHaveOnlyOne = newBuilder()
    .addScopeDecorator(ScopeDecorator.NOOP)
    .addScopeDecorator(one).build();

  assertThat(shouldHaveOnlyOne).extracting("scopeDecorators")
    .asInstanceOf(InstanceOfAssertFactories.ARRAY)
    .doesNotContain(ScopeDecorator.NOOP);
}
 

@Test public void injectKindFormats() {
  B3Propagation.Factory factory = (B3Propagation.Factory) B3Propagation.newFactoryBuilder()
    .injectFormats(Span.Kind.CLIENT, Format.SINGLE, Format.MULTI)
    .build();

  assertThat(factory.injectorFactory).extracting("clientInjectorFunction.injectorFunctions")
    .asInstanceOf(InstanceOfAssertFactories.ARRAY)
    .containsExactly(Format.SINGLE, Format.MULTI);
}
 

@Test public void extract_baggage_addsAllKeyNames_evenWhenEmpty() {
  TraceContextOrSamplingFlags extracted = extractor.extract(request);
  assertThat(extracted.extra()).hasSize(2);
  assertThat(extracted.extra().get(1))
      .asInstanceOf(InstanceOfAssertFactories.type(Extra.class))
      .extracting(a -> a.extractKeyNames)
      .asInstanceOf(InstanceOfAssertFactories.list(String.class))
      .containsExactly("x-vcap-request-id", "x-amzn-trace-id");
}
 

@Test public void create_multiple() {
  SpanHandler[] handlers = new SpanHandler[2];
  handlers[0] = one;
  handlers[1] = two;
  SpanHandler handler = NoopAwareSpanHandler.create(handlers, noop);

  assertThat(handler).extracting("delegate.handlers")
      .asInstanceOf(InstanceOfAssertFactories.array(SpanHandler[].class))
      .containsExactly(one, two);
}