org.assertj.core.api.Assertions Java Examples

@Test
public void incomingConnection_deduplicatedWhenAlreadyConnected_peerWithLowerValueNodeId()
    throws ExecutionException, InterruptedException {
  final Bytes localNodeId = Bytes.fromHexString("0x02", EnodeURL.NODE_ID_SIZE);
  final Bytes remoteNodeId = Bytes.fromHexString("0x01", EnodeURL.NODE_ID_SIZE);

  startAgent(localNodeId);

  final Peer peer = createPeer(remoteNodeId);
  final CompletableFuture<PeerConnection> existingConnection = agent.connect(peer);
  final PeerConnection incomingConnection = connection(peer);
  connectionInitializer.simulateIncomingConnection(incomingConnection);

  // New connection should be kept
  Assertions.assertThat(agent.getPeerConnection(peer).get().get()).isEqualTo(incomingConnection);
  assertThat(agent.getConnectionCount()).isEqualTo(1);
  assertThat(existingConnection.get().isDisconnected()).isTrue();
  assertThat(((MockPeerConnection) existingConnection.get()).getDisconnectReason())
      .contains(DisconnectReason.ALREADY_CONNECTED);
}
 

@Test
public void setToolTipBuilderWithOneParam_hasToolTip() {
  //given
  ToolTipBuilder toolTipBuilder = new ToolTipBuilder() {

    @Override
    public Object call(Object x) {
      return "x=" + x;
    }

    @Override
    public int getMaximumNumberOfParameters() {
      return 1;
    }
  };
  //when
  xyGraphics.setToolTip(toolTipBuilder);
  //then
  Assertions.assertThat(xyGraphics.getToolTips().get(0)).isEqualTo("x=10");
}
 

@Test(groups = STORAGE_FORMATS)
public void testCreateTable()
        throws SQLException
{
    onPresto().executeQuery("CREATE TABLE test_create_table(a bigint, b varchar, c smallint) WITH (format='ORC')");
    onPresto().executeQuery("INSERT INTO test_create_table(a, b, c) VALUES " +
            "(NULL, NULL, NULL), " +
            "(-42, 'abc', SMALLINT '-127'), " +
            "(9223372036854775807, 'abcdefghijklmnopqrstuvwxyz', SMALLINT '32767')");
    assertThat(onPresto().executeQuery("SELECT * FROM test_create_table"))
            .containsOnly(
                    row(null, null, null),
                    row(-42, "abc", -127),
                    row(9223372036854775807L, "abcdefghijklmnopqrstuvwxyz", 32767));
    Assertions.assertThat(getTableProperty("test_create_table", "transactional"))
            // Hive 3 removes "transactional" table property when it has value "false"
            .isIn(Optional.empty(), Optional.of("false"));
    onPresto().executeQuery("DROP TABLE test_create_table");
}
 

@Test
public void testTakeSnapshot() throws InterruptedException, ReaperException, ClassNotFoundException, IOException {

  JmxProxy proxy = (JmxProxy) mock(Class.forName("io.cassandrareaper.jmx.JmxProxyImpl"));
  StorageServiceMBean storageMBean = Mockito.mock(StorageServiceMBean.class);
  JmxProxyTest.mockGetStorageServiceMBean(proxy, storageMBean);

  AppContext cxt = new AppContext();
  cxt.config = TestRepairConfiguration.defaultConfig();
  cxt.jmxConnectionFactory = mock(JmxConnectionFactory.class);
  when(cxt.jmxConnectionFactory.connectAny(any(Collection.class))).thenReturn(proxy);

  Pair<Node,String> result = SnapshotService
      .create(cxt, SNAPSHOT_MANAGER_EXECUTOR)
      .takeSnapshot("Test", Node.builder().withHostname("127.0.0.1").build());

  Assertions.assertThat(result.getLeft().getHostname()).isEqualTo("127.0.0.1");
  Assertions.assertThat(result.getRight()).isEqualTo("Test");
  verify(storageMBean, times(1)).takeSnapshot("Test");
}
 

@Test
@Description("Weight is validated and saved to the Rollout.")
public void weightValidatedAndSaved() {
    final String targetPrefix = UUID.randomUUID().toString();
    testdataFactory.createTargets(4, targetPrefix);
    enableMultiAssignments();

    Assertions.assertThatExceptionOfType(ConstraintViolationException.class)
            .isThrownBy(() -> createTestRolloutWithTargetsAndDistributionSet(4, 2, "50", "80",
                    UUID.randomUUID().toString(), UUID.randomUUID().toString(), Action.WEIGHT_MAX + 1));
    Assertions.assertThatExceptionOfType(ConstraintViolationException.class)
            .isThrownBy(() -> createTestRolloutWithTargetsAndDistributionSet(4, 2, "50", "80",
                    UUID.randomUUID().toString(), UUID.randomUUID().toString(), Action.WEIGHT_MIN - 1));
    final Rollout createdRollout1 = createTestRolloutWithTargetsAndDistributionSet(4, 2, "50", "80",
            UUID.randomUUID().toString(), UUID.randomUUID().toString(), Action.WEIGHT_MAX);
    final Rollout createdRollout2 = createTestRolloutWithTargetsAndDistributionSet(4, 2, "50", "80",
            UUID.randomUUID().toString(), UUID.randomUUID().toString(), Action.WEIGHT_MIN);
    assertThat(rolloutRepository.findById(createdRollout1.getId()).get().getWeight()).get()
            .isEqualTo(Action.WEIGHT_MAX);
    assertThat(rolloutRepository.findById(createdRollout2.getId()).get().getWeight()).get()
            .isEqualTo(Action.WEIGHT_MIN);
}
 

public void testPropagatingAlgorithmException() {
    // The query should result in an error.
    try {
        // Out of allowed range (should cause an exception).
        Map<String,Object> attrs = new HashMap<>();
        attrs.put("ignoreWordIfInHigherDocsPercent", Double.MAX_VALUE);

        new ClusteringActionRequestBuilder(client)
            .setQueryHint("")
            .addSourceFieldMapping("title", LogicalField.TITLE)
            .addSourceFieldMapping("content", LogicalField.CONTENT)
            .setAlgorithm(STCClusteringAlgorithm.NAME)
            .addAttributes(attrs)
            .setSearchRequest(
              client.prepareSearch()
                    .setIndices(INDEX_TEST)
                    .setSize(100)
                    .setQuery(QueryBuilders.termQuery("content", "data"))
                    .setFetchSource(new String[] {"title", "content"}, null))
            .execute().actionGet();
        throw Preconditions.unreachable();
    } catch (ElasticsearchException e) {
        Assertions.assertThat(e)
            .hasMessageContaining("Clustering error:");
    }
}
 

@Test
public void scanSingleSubscriber() {
    CoreSubscriber<Integer> actual = new LambdaSubscriber<>(null, e -> {}, null, null);
    FluxZip.ZipSingleCoordinator<Integer, Integer> main =
new FluxZip.ZipSingleCoordinator<Integer, Integer>(actual, new Object[1], 1, i -> 5);
    FluxZip.ZipSingleSubscriber<Integer> test = new FluxZip.ZipSingleSubscriber<>(main, 0);
    Subscription parent = Operators.emptySubscription();
    test.onSubscribe(parent);

    Assertions.assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(parent);
    Assertions.assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(main);
    test.onNext(7);
    Assertions.assertThat(test.scan(Scannable.Attr.BUFFERED)).isEqualTo(1);
    Assertions.assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue();
    Assertions.assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue();
}
 

@Test
public void buildTestNoOutboundInternetTrafficBothVpcCidrsAndPrefixListsAreGiven() {
    //GIVEN
    //WHEN
    modelContext = new ModelContext()
            .withAuthenticatedContext(authenticatedContext)
            .withStack(cloudStack)
            .withExistingVpc(true)
            .withExistingIGW(true)
            .withExistingSubnetCidr(singletonList(existingSubnetCidr))
            .mapPublicIpOnLaunch(true)
            .withEnableInstanceProfile(true)
            .withInstanceProfileAvailable(true)
            .withOutboundInternetTraffic(OutboundInternetTraffic.DISABLED)
            .withVpcCidrs(List.of("vpccidr1", "vpccidr2"))
            .withPrefixListIds(List.of("prefix1", "prefix2"))
            .withTemplate(awsCloudFormationTemplate);
    String templateString = cloudFormationTemplateBuilder.build(modelContext);

    //THEN
    Assertions.assertThat(JsonUtil.isValid(templateString)).overridingErrorMessage("Invalid JSON: " + templateString).isTrue();
    assertThat(templateString, stringContainsInOrder("SecurityGroupEgress", "vpccidr1", "vpccidr2", "prefix1", "prefix2"));
}
 

@Test
@SuppressWarnings("unchecked")
public void testHandlerBean() throws Exception {
	ConfigurableApplicationContext context = SpringApplication.run(this.configClass,
			"--spring.cloud.stream.bindings.output.contentType=application/json",
			"--server.port=0");
	MessageCollector collector = context.getBean(MessageCollector.class);
	Processor processor = context.getBean(Processor.class);
	String id = UUID.randomUUID().toString();
	processor.input()
			.send(MessageBuilder.withPayload("{\"foo\":\"barbar" + id + "\"}")
					.setHeader("contentType", "application/json").build());
	HandlerBean handlerBean = context.getBean(HandlerBean.class);
	Assertions.assertThat(handlerBean.receivedPojos).hasSize(1);
	Assertions.assertThat(handlerBean.receivedPojos.get(0))
			.hasFieldOrPropertyWithValue("foo", "barbar" + id);
	Message<String> message = (Message<String>) collector
			.forChannel(processor.output()).poll(1, TimeUnit.SECONDS);
	assertThat(message).isNotNull();
	assertThat(message.getPayload()).isEqualTo("{\"bar\":\"barbar" + id + "\"}");
	assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class)
			.includes(MimeTypeUtils.APPLICATION_JSON));
	context.close();
}
 

@Test
public void shouldSetInvocationsPerBatchType() {
  // given
  configuration.getInvocationsPerBatchJobByBatchType()
      .put(Batch.TYPE_HISTORIC_DECISION_INSTANCE_DELETION, 42);

  HistoricDecisionInstanceQuery query = historyService.createHistoricDecisionInstanceQuery()
      .decisionDefinitionKey(DECISION);

  // when
  Batch batch = historyService.deleteHistoricDecisionInstancesAsync(query, null);

  // then
  Assertions.assertThat(batch.getInvocationsPerBatchJob()).isEqualTo(42);

  // clear
  configuration.setInvocationsPerBatchJobByBatchType(new HashMap<>());
}
 

@Test
public void newCharge_whenDoesNotExist() {

    existingCharge = null;

    context.checking(new Expectations() {
        {
            oneOf(mockServiceRegistry2).injectServicesInto(with(any(Charge.class)));
            oneOf(mockRepositoryService).persistAndFlush(with(any(Charge.class)));
        }
    });

    final Charge newCharge = chargeRepository.upsert("CG-REF", "CG-Name", "CG-Description",
            newApplicationTenancy("/it"), Applicability.IN_AND_OUT, tax, chargeGroup
    );
    Assertions.assertThat(newCharge.getReference()).isEqualTo("CG-REF");
    Assertions.assertThat(newCharge.getName()).isEqualTo("CG-Name");
    Assertions.assertThat(newCharge.getDescription()).isEqualTo("CG-Description");
    Assertions.assertThat(newCharge.getTax()).isEqualTo(tax);
    Assertions.assertThat(newCharge.getGroup()).isEqualTo(chargeGroup);
}
 

@Test
public void rxObservableIntFallback() {
  server.enqueue(new MockResponse().setResponseCode(500));

  final TestInterface api = target();

  final Observable<Integer> observable = api.intObservable();

  assertThat(observable).isNotNull();
  assertThat(server.getRequestCount()).isEqualTo(0);

  final TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>();
  observable.subscribe(testSubscriber);
  testSubscriber.awaitTerminalEvent();
  Assertions.assertThat(testSubscriber.getOnNextEvents().get(0)).isEqualTo(new Integer(0));
}
 

@Test
public void concatRemittanceInformation_works() throws Exception {

    // given
    PaymentBatch paymentBatch = new PaymentBatch();
    // when
    List<PaymentLine> lines = new ArrayList<>();
    // then
    Assertions.assertThat(paymentBatch.concatRemittanceInformationAndTruncateIfNeeded(lines)).isEqualTo("");

    // and when
    final PaymentLine line1 = new PaymentLine();
    line1.setRemittanceInformation("info1");
    lines.add(line1);
    // then
    Assertions.assertThat(paymentBatch.concatRemittanceInformationAndTruncateIfNeeded(lines)).isEqualTo("info1");

    // and when
    final PaymentLine line2 = new PaymentLine();
    line2.setRemittanceInformation("info2");
    lines.add(line2);
    // then
    Assertions.assertThat(paymentBatch.concatRemittanceInformationAndTruncateIfNeeded(lines)).isEqualTo("info1;info2");

}
 

@Test
public void testOrFailOK() {
    Mockito.when(repository.get("1"))
            .thenReturn(Optional.of(order));

    AggregateRoot<?> aggregateRoot = null;
    try {
        aggregateRoot = underTest.fromRepository()
                .orFail();
    } catch (AggregateNotFoundException e) {
        fail();
    }

    Assertions.assertThat(aggregateRoot)
            .isNotNull();
    Assertions.assertThat(aggregateRoot)
            .isEqualTo(order);

    Assertions.assertThat(((Order) aggregateRoot).getProduct())
            .isEqualTo("lightsaber");
}
 

@Test
public void testCreate_4() {
  Cluster cluster = Cluster.builder()
      .withName("test")
      .withSeedHosts(ImmutableSet.of("127.0.0.1", "127.0.0.2"))
      .withPartitioner("murmur3")
      .withJmxPort(9999)
      .withState(Cluster.State.ACTIVE)
      .build();

  Assertions.assertThat(cluster.getName()).isEqualTo("test");
  Assertions.assertThat(cluster.getSeedHosts()).hasSize(2);
  Assertions.assertThat(cluster.getSeedHosts()).contains("127.0.0.1", "127.0.0.2");
  Assertions.assertThat(cluster.getPartitioner()).isPresent();
  Assertions.assertThat(cluster.getPartitioner().get()).isEqualTo("murmur3");
  Assertions.assertThat(cluster.getJmxPort()).isEqualTo(9999);
  Assertions.assertThat(cluster.getState()).isEqualTo(Cluster.State.ACTIVE);
  Assertions.assertThat(cluster.getLastContact()).isEqualTo(LocalDate.MIN);
}
 

@Test
public void testToDtos() {
    underTest2 = new AssembleMultipleImpl<>(context, Stream.of(new Order("lightsaber"), new Order("death star")),
            null);

    List<OrderDto> orderDtos = underTest2.toListOf(OrderDto.class);
    Assertions.assertThat(orderDtos)
            .isNotNull();
    Assertions.assertThat(orderDtos)
            .isNotEmpty();
    Assertions.assertThat(orderDtos.get(0)
            .getProduct())
            .isEqualTo("lightsaber");
    Assertions.assertThat(orderDtos.get(1)
            .getProduct())
            .isEqualTo("death star");
}
 

public DirectoryAssert hasSameContentAs(Path path) {
    FileAssert fileAssert = new FileAssert(actual.toFile());
    fileAssert.exists().isDirectory();

    Arrays
        .stream(path.toFile().listFiles())
        .map(File::toPath)
        .forEach(expectedFile -> {
            Path actualFile = actual.resolve(expectedFile.getFileName());
            if (expectedFile.toFile().isDirectory()) {
                assertThatDirectory(actualFile).hasSameContentAs(expectedFile);
            } else {
                Assertions.assertThat(actualFile).exists().isRegularFile().hasSameContentAs(expectedFile);
            }
        });

    return this;
}
 

/**
 * Test equals.
 */
@Test
void canFindEquality() {
    final Cluster.Builder builder = new Cluster.Builder(NAME, USER, VERSION, ClusterStatus.UP);
    builder.withConfigs(null);
    builder.withDependencies(null);
    builder.withCreated(null);
    builder.withDescription(null);
    builder.withId(UUID.randomUUID().toString());
    builder.withTags(null);
    builder.withUpdated(null);
    final Cluster cluster1 = builder.build();
    final Cluster cluster2 = builder.build();
    builder.withDescription(UUID.randomUUID().toString());
    final Cluster cluster3 = builder.build();
    builder.withId(UUID.randomUUID().toString());
    final Cluster cluster4 = builder.build();

    Assertions.assertThat(cluster1).isEqualTo(cluster2);
    Assertions.assertThat(cluster1).isEqualTo(cluster3);
    Assertions.assertThat(cluster1).isNotEqualTo(cluster4);
}
 

@Before
public void before() {
    new Expectations() {
        {
            restConfig.getPath();
            result = REST_PATH;
            restConfig.getBaseRel();
            result = BASE_REL;
            restConfig.getBaseParam();
            result = BASE_PARAM;
        }
    };

    ResourceScanner resourceScanner = new ResourceScanner(restConfig, SERVLET_CONTEXT_PATH);
    resourceScanner.scan(Lists.newArrayList(
            MethodResource.class,
            ClassResource.class,
            ClassAndMethodResource.class,
            ClassAndMethodResource2.class,
            ClassAndMethodResource3.class
    ));
    resourceMap = resourceScanner.jsonHomeResources();
    Assertions.assertThat(resourceMap).isNotNull();
}
 

@Test
public void seoFinished_shouldSetPayload() throws Exception {
  //given
  Object payload = new Object();
  //when
  seo.finished(payload);
  //then
  Assertions.assertThat(seo.getPayload()).isEqualTo(payload);
}
 

@Test
public void buildTestWithVPCAndRoleWithoutIGWAndPublicIpOnLaunchAndInstanceProfile() {
    CloudStack cloudStack = initCloudStackWithInstanceProfile();
    //WHEN
    modelContext = new ModelContext()
            .withAuthenticatedContext(authenticatedContext)
            .withStack(cloudStack)
            .withExistingVpc(true)
            .withExistingIGW(false)
            .withExistingSubnetCidr(singletonList(existingSubnetCidr))
            .mapPublicIpOnLaunch(false)
            .withEnableInstanceProfile(false)
            .withInstanceProfileAvailable(true)
            .withOutboundInternetTraffic(OutboundInternetTraffic.ENABLED)
            .withTemplate(awsCloudFormationTemplate);
    String templateString = cloudFormationTemplateBuilder.build(modelContext);
    //THEN
    Assertions.assertThat(JsonUtil.isValid(templateString)).overridingErrorMessage("Invalid JSON: " + templateString).isTrue();
    assertThat(templateString, containsString("InstanceProfile"));
    assertThat(templateString, containsString("VPCId"));
    assertThat(templateString, not(containsString("SubnetCIDR")));
    assertThat(templateString, containsString("SubnetId"));
    assertThat(templateString, not(containsString("SubnetConfig")));
    assertThat(templateString, not(containsString("\"AttachGateway\"")));
    assertThat(templateString, not(containsString("\"InternetGateway\"")));
    assertThat(templateString, containsString("AvailabilitySet"));
    assertThat(templateString, not(containsString("EIP")));
}
 

public AbstractGridItemViewAssert hasSecondaryTextView() {
  isNotNull();
  Assertions.assertThat(actual.findViewById(R.id.grid_list_label_line_2))
      .overridingErrorMessage("Expected secondary text view to be present but it is not.")
      .isNotNull();
  return myself;
}
 

/**
 * Make sure a tag can't be validated if the value is blank.
 */
@Test
void cantCreateTagEntityDueToNoTag() {
    final TagEntity tagEntity = new TagEntity();
    final String tag = "";
    tagEntity.setTag(tag);
    Assertions
        .assertThatExceptionOfType(ConstraintViolationException.class)
        .isThrownBy(() -> this.validate(tagEntity));
}
 

@Test
public void using_predicates() throws Exception {

    final ReasonBuffer2 buf = ReasonBuffer2.forAll("Cannot change");

    buf.append(() -> false, "reason #1");
    buf.append(false, "reason #2");
    buf.append(true, "reason #3");
    buf.append(() -> true, "reason #4");

    Assertions.assertThat(buf.getReason()).isEqualTo("Cannot change: reason #3; reason #4");
}
 

@Test
public void failsOnUnknownProvider() {
    String nonExistingProvider = UUID.randomUUID().toString();
    Assertions
        .assertThatThrownBy(() -> {
            ConnectionFactories.get(String.format("r2dbc:tc:%s:///db", nonExistingProvider));
        })
        .hasMessageContaining("Missing provider")
        .hasMessageContaining(nonExistingProvider);
}
 

/**
 * Test to get a {@link Service} with a qualifier from the {@link DomainRegistry}.
 */
@Test
public void testServiceWithQualifierAndComposite() {
    Type type = new TypeLiteral<RebateService<Composite<Long>>>() {}.getType();
    RebateService<Composite<Long>> service = this.domainRegistry.getService(type, ServiceQualifier.class);
    Assertions.assertThat(service)
            .isInstanceOf(RebateServiceInternalWithQualifierComposite.class);

}
 

@Test
void shouldThrowExceptionOnMalformedMetadata_wellknowninstead() {
  Assertions.assertThatThrownBy(
          () ->
              AuthMetadataFlyweight.decodeCustomAuthType(
                  AuthMetadataFlyweight.encodeMetadata(
                      ByteBufAllocator.DEFAULT,
                      WellKnownAuthType.BEARER,
                      Unpooled.copiedBuffer(new byte[] {'a', 'b'}))))
      .hasMessage("Unable to decode custom Auth type. Incorrect auth type length");
}
 

@Test
void updateTelegrafConfig() {

    Telegraf telegrafConfig = telegrafsApi
            .createTelegraf(generateName("tc"), "test-config", organization, Arrays.asList(newOutputPlugin(), newKernelPlugin()));

    Assertions.assertThat(telegrafConfig.getConfig()).isNotEqualTo("my-updated-config");
    telegrafConfig.setDescription("updated");
    telegrafConfig.setConfig("my-updated-config");

    telegrafConfig = telegrafsApi.updateTelegraf(telegrafConfig);

    Assertions.assertThat(telegrafConfig.getDescription()).isEqualTo("updated");
    Assertions.assertThat(telegrafConfig.getConfig()).isEqualTo("my-updated-config");
}
 

@Test
public void testWithUrlAndReadContent() throws IOException {
    YamlToJson res = YamlToJson.builder()
            .withYamlInputPath(
                    "https://raw.githubusercontent.com/zalando/nakadi/nakadi-jvm/api/nakadi-event-bus-api.yaml")
            .build();
    String yamlFilename = res.getYamlFilename();
    Assertions.assertThat(yamlFilename).isNotNull();
    String json = res.getYamlFileContentAsJson();
    Assertions.assertThat(json).isNotNull();
    Assertions.assertThat(json).isNotEmpty();
    Assertions.assertThat(json).startsWith("{").endsWith("}");
}
 

@Test
public void givenNoExplicitContructor_whenUsed_thenFails() {
    BankAccount account = new BankAccount();
    Assertions.assertThatThrownBy(() -> {
        account.toString();
    }).isInstanceOf(Exception.class);
}