@Test public void scanCapacity() { Scheduler scheduler = Schedulers.newSingle(Thread::new); try { assertThat(scheduler) .matches(s -> Scannable.from(s).isScanAvailable(), "isScanAvailable") .satisfies(s -> assertThat(Scannable.from(s).scan(Scannable.Attr.CAPACITY)).isEqualTo(1)); } finally { scheduler.dispose(); } } }
@Test public void scanCapacity() { Scheduler scheduler = Schedulers.newParallel(12, Thread::new); try { assertThat(scheduler) .matches(s -> Scannable.from(s).isScanAvailable(), "isScanAvailable") .satisfies(s -> assertThat(Scannable.from(s).scan(Scannable.Attr.CAPACITY)).isEqualTo(12)); } finally { scheduler.dispose(); } } }
@Test public void scanSubscriber() { Scheduler.Worker worker = Schedulers.immediate().createWorker(); CoreSubscriber<String> actual = new LambdaSubscriber<>(null, null, null, null); Subscription s = Operators.emptySubscription(); FluxDelaySequence.DelaySubscriber test = new DelaySubscriber<>(actual, Duration.ofSeconds(1), worker); test.onSubscribe(s); assertThat(test.scan(Scannable.Attr.PARENT)).isSameAs(s); SerializedSubscriber serializedSubscriber = (SerializedSubscriber) test.scan(Scannable.Attr.ACTUAL); assertThat(serializedSubscriber) .isNotNull() .satisfies(ser -> assertThat(ser.actual).isSameAs(actual)); assertThat(test.scan(Scannable.Attr.RUN_ON)).isEqualTo(worker); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); test.cancel(); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue(); test.done = true; assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); }
@Test public void responseWithoutRetryAfterShouldHaveCorrespondingSerializableException() { assertThat(RESPONSE_503_WITHOUT_RETRY_AFTER.getEntity()) .isInstanceOf(SerializableError.class) .satisfies(ExceptionMappersTest::assertSerializedFormOfRuntimeException); }
@Test public void responseWithRetryAfterShouldHaveCorrespondingSerializableException() { assertThat(RESPONSE_503_WITH_RETRY_AFTER.getEntity()) .isInstanceOf(SerializableError.class) .satisfies(ExceptionMappersTest::assertSerializedFormOfRuntimeException); }
@Test public void returnsTerminalIfBoundEqualsFreshTimestamp() { TimestampCorroborationConsistencyCheck check = createForTimestamps(42, 42); assertThat(check.apply(mock(TransactionManager.class))).satisfies( result -> { assertThat(result.consistencyState()).isEqualTo( TransactionManagerConsistencyResult.ConsistencyState.TERMINAL); assertThat(result.reasonForInconsistency()).isPresent(); }); }
@Test public void returnsTerminalIfBoundIsAboveFreshTimestamp() { TimestampCorroborationConsistencyCheck check = createForTimestamps(111, 42); assertThat(check.apply(mock(TransactionManager.class))).satisfies( result -> { assertThat(result.consistencyState()).isEqualTo( TransactionManagerConsistencyResult.ConsistencyState.TERMINAL); assertThat(result.reasonForInconsistency()).isPresent(); }); }
@Test public void canDeserializeRuntimeConfig() throws IOException { AtlasDbRuntimeConfig runtimeConfig = AtlasDbConfigs.OBJECT_MAPPER.readValue(TEST_RUNTIME_CONFIG_FILE, AtlasDbRuntimeConfig.class); assertThat(runtimeConfig.timestampClient().enableTimestampBatching()).isTrue(); assertThat(runtimeConfig.timelockRuntime()).isPresent(); assertThat(runtimeConfig.timelockRuntime().get().serversList().servers()) .containsExactlyInAnyOrder( "https://foo1:12345", "https://foo2:8421", "https://foo3:9421"); assertThat(runtimeConfig.timelockRuntime().get().serversList().sslConfiguration()).satisfies( sslConfiguration -> sslConfiguration.ifPresent(this::assertSslConfigDeserializedCorrectly)); assertThat(runtimeConfig.streamStorePersistence()).satisfies( persistenceConfig -> { assertThat(persistenceConfig.numBlocksToWriteBeforePause()).isEqualTo(7); assertThat(persistenceConfig.writePauseDurationMillis()).isEqualTo(77); }); assertThat(runtimeConfig.sweep().sweepPriorityOverrides()).satisfies( overrides -> { assertThat(overrides.priorityTables()).containsExactlyInAnyOrder("atlas.mission_critical_table"); assertThat(overrides.blacklistTables()).containsExactlyInAnyOrder( "atlas.bad_table", "atlas2.immutable_log"); }); }
@Test public void shouldListDeploymentsOfAnIntegration() { final IntegrationDeployment deployment1 = deployment(1); final IntegrationDeployment deployment2 = deployment(2); final IntegrationDeployment deployment3 = deployment(3); @SuppressWarnings("unchecked") final ArgumentCaptor<Function<ListResult<IntegrationDeployment>, ListResult<IntegrationDeployment>>> args = ArgumentCaptor .forClass(Function.class); when(dataManager.fetchAll(eq(IntegrationDeployment.class), args.capture())) .thenReturn(ListResult.of(deployment1, deployment2, deployment3)); final UriInfo uriInfo = mock(UriInfo.class); when(uriInfo.getQueryParameters()).thenReturn(new MultivaluedHashMap<>()); final ListResult<IntegrationDeployment> results = handler.list(INTEGRATION_ID, uriInfo); assertThat(results).containsExactly(deployment1, deployment2, deployment3); final List<Function<ListResult<IntegrationDeployment>, ListResult<IntegrationDeployment>>> filters = args .getAllValues(); assertThat(filters).hasSize(3); assertThat(filters.get(0)).isInstanceOf(IntegrationIdFilter.class) .satisfies(f -> assertThat(((IntegrationIdFilter) f).integrationId).isEqualTo(INTEGRATION_ID)); assertThat(filters.get(1)).isInstanceOf(ReflectiveSorter.class); assertThat(filters.get(2)).isInstanceOf(PaginationFilter.class); }
@Test public void adminToken() { final Token token = tokenService.createToken("forAdmin1", true, adminAuthor, admin).join() .content().get(); assertThat(token.isActive()).isTrue(); assertThatThrownBy(() -> tokenService.createToken("forAdmin2", true, guestAuthor, guest) .join()) .isInstanceOf(IllegalArgumentException.class); final Collection<Token> tokens = tokenService.listTokens(admin).join(); assertThat(tokens.stream().filter(t -> !StringUtil.isNullOrEmpty(t.secret()))).hasSize(1); assertThatThrownBy(() -> tokenService.deleteToken(ctx, "forAdmin1", guestAuthor, guest) .join()) .hasCauseInstanceOf(HttpResponseException.class); assertThat(tokenService.deleteToken(ctx, "forAdmin1", adminAuthor, admin).join()).satisfies(t -> { assertThat(t.appId()).isEqualTo(token.appId()); assertThat(t.isAdmin()).isEqualTo(token.isAdmin()); assertThat(t.creation()).isEqualTo(token.creation()); assertThat(t.deactivation()).isEqualTo(token.deactivation()); }); }
@Test public void peerExists() { final PeerTable table = new PeerTable(Peer.randomId(), 16); final DiscoveryPeer peer = helper.createDiscoveryPeer(); assertThat(table.tryAdd(peer).getOutcome()).isEqualTo(Outcome.ADDED); assertThat(table.tryAdd(peer)) .satisfies( result -> { assertThat(result.getOutcome()).isEqualTo(Outcome.ALREADY_EXISTED); assertThat(result.getEvictionCandidate()).isNull(); }); } }
@Test public void userToken() { final Token userToken1 = tokenService.createToken("forUser1", false, adminAuthor, admin) .join().content().get(); final Token userToken2 = tokenService.createToken("forUser2", false, guestAuthor, guest) .join().content().get(); assertThat(userToken1.isActive()).isTrue(); assertThat(userToken2.isActive()).isTrue(); final Collection<Token> tokens = tokenService.listTokens(guest).join(); assertThat(tokens.stream().filter(token -> !StringUtil.isNullOrEmpty(token.secret())).count()) .isEqualTo(0); assertThat(tokenService.deleteToken(ctx, "forUser1", adminAuthor, admin).join()).satisfies(t -> { assertThat(t.appId()).isEqualTo(userToken1.appId()); assertThat(t.isAdmin()).isEqualTo(userToken1.isAdmin()); assertThat(t.creation()).isEqualTo(userToken1.creation()); assertThat(t.deactivation()).isEqualTo(userToken1.deactivation()); }); assertThat(tokenService.deleteToken(ctx, "forUser2", guestAuthor, guest).join()).satisfies(t -> { assertThat(t.appId()).isEqualTo(userToken2.appId()); assertThat(t.isAdmin()).isEqualTo(userToken2.isAdmin()); assertThat(t.creation()).isEqualTo(userToken2.creation()); assertThat(t.deactivation()).isEqualTo(userToken2.deactivation()); }); } }
@Test default void retrieveShouldGetStoredMail() throws Exception { MailRepository testee = retrieveRepository(); Mail mail = createMail(MAIL_1); testee.store(mail); assertThat(testee.retrieve(MAIL_1)).satisfies(actual -> checkMailEquality(actual, mail)); }
@Test default void storingMessageWithSameKeyTwiceShouldUpdateMessageContent() throws Exception { MailRepository testee = retrieveRepository(); testee.store(createMail(MAIL_1)); Mail updatedMail = createMail(MAIL_1, "modified content"); testee.store(updatedMail); assertThat(testee.list()).hasSize(1); assertThat(testee.retrieve(MAIL_1)).satisfies(actual -> checkMailEquality(actual, updatedMail)); }
@Test default void storingMessageWithSameKeyTwiceShouldUpdateMessageAttributes() throws Exception { MailRepository testee = retrieveRepository(); Mail mail = createMail(MAIL_1); testee.store(mail); mail.setAttribute(TEST_ATTRIBUTE, "newValue"); testee.store(mail); assertThat(testee.list()).hasSize(1); assertThat(testee.retrieve(MAIL_1)).satisfies(actual -> checkMailEquality(actual, mail)); }
@Test default void retrieveShouldReturnAllMailProperties() throws Exception { MailRepository testee = retrieveRepository(); MailImpl mail = createMail(MAIL_1); mail.setErrorMessage("Error message"); mail.setRemoteAddr("172.5.2.3"); mail.setRemoteHost("smtp@domain.com"); mail.setLastUpdated(new Date()); mail.addSpecificHeaderForRecipient(PerRecipientHeaders.Header.builder() .name("name") .value("value") .build(), new MailAddress("bob@domain.com")); testee.store(mail); assertThat(testee.retrieve(MAIL_1)).satisfies(actual -> checkMailEquality(actual, mail)); }