method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
NetworkUtil { public static boolean mapTcpPort(int port) { try { GatewayDiscover discover = new GatewayDiscover(); discover.discover(); GatewayDevice device = discover.getValidGateway(); if (device != null) { PortMappingEntry portMapping = new PortMappingEntry(); if (device.getSpecificPortMappingEntry(port, "TCP", portMapping)) { log.info(MessageFormat.format("Port TCP {0} already mapped", port)); return true; } else { InetAddress localAddress = device.getLocalAddress(); return device.addPortMapping(port, port, localAddress.getHostAddress(), "TCP", "Sismics Reader"); } } } catch (Exception e) { log.info("Unable to map TCP port", e); } return false; } static boolean mapTcpPort(int port); }### Answer:
@Test @Ignore public void testUpnp() throws Exception { assertTrue(NetworkUtil.mapTcpPort(4040)); } |
### Question:
ResourceUtil { public static Map<Object, Object> loadPropertiesFromUrl(URL url) throws RuntimeException { InputStream is = null; try { is = url.openStream(); Properties properties = new Properties(); properties.load(is); return properties; } catch (IOException e) { throw new RuntimeException("Cannot load properties file for url: " + url, e); } finally { if (is != null) { try { is.close(); } catch (Exception e) { } } } } static List<String> list(Class<?> clazz, String path, FilenameFilter filter); static List<String> list(Class<?> clazz, String path); static Map<Object, Object> loadPropertiesFromUrl(URL url); }### Answer:
@Test public void loadResourceFileTest() { Map<Object, Object> properties = ResourceUtil.loadPropertiesFromUrl(TestResourceUtil.class.getResource("/config.properties")); assertNotNull(properties); assertTrue(properties.size() > 0); } |
### Question:
HeapUnit { public static HeapImage captureHeap() throws IOException { String path = "target/heapunit/" + System.currentTimeMillis() + ".hprof"; return new SimpleHeapImage(HeapDumpProcuder.makeHeapDump(path, TimeUnit.SECONDS.toMillis(60))); } static HeapImage captureHeap(); }### Answer:
@Test public void test() throws IOException { @SuppressWarnings("unused") TestInstance tt = new TestInstance(); HeapImage hi = HeapUnit.captureHeap(); System.out.println("String count: " + hi.instanceCount(String.class)); Assert.assertTrue(hi.instanceCount(String.class) > 0); System.out.println("List count: " + hi.instanceCount(List.class)); Assert.assertTrue(hi.instanceCount(List.class) > 0); System.out.println("TestInstance count: " + hi.instanceCount(TestInstance.class)); assertEquals(1, hi.instanceCount(TestInstance.class)); System.out.println("(**$TestInstance) count: " + hi.instanceCount("(**$TestInstance)")); assertEquals(1, hi.instanceCount("(**$TestInstance)")); System.out.println("char[] count: " + hi.instanceCount(char[].class)); Assert.assertTrue(hi.instanceCount(char[].class) > 0); System.out.println("Object[] count: " + hi.instanceCount(Object[].class)); Assert.assertTrue(hi.instanceCount(Object[].class) > 0); TestInstance t2 = hi.rehydrateFirst("(**$TestInstance)"); System.out.println(t2); HeapInstance ti = hi.instance("(**$TestInstance)"); assertEquals(true, ti.value("bval")); assertEquals(10, ti.value("ival")); assertEquals(1.1d, ti.value("dval")); } |
### Question:
InMemoryRoutingTable implements RoutingTable<R> { @Override public Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix) { Objects.requireNonNull(addressPrefix); return this.interledgerAddressPrefixMap.removeEntry(addressPrefix); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); }### Answer:
@Test(expected = NullPointerException.class) public void testRemoveRouteNull() { try { this.routingTable.removeRoute(null); } catch (NullPointerException e) { throw e; } }
@Test public void testRemoveRoute() { final Route route = this.constructTestRoute(GLOBAL_PREFIX); this.routingTable.removeRoute(route.routePrefix()); verify(interledgerPrefixMapMock).removeEntry(route.routePrefix()); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
### Question:
InMemoryRoutingTable implements RoutingTable<R> { @Override public Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix) { Objects.requireNonNull(addressPrefix); return this.interledgerAddressPrefixMap.getEntry(addressPrefix); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); }### Answer:
@Test(expected = NullPointerException.class) public void testGetRoutesNull() { try { this.routingTable.getRouteByPrefix(null); } catch (NullPointerException e) { throw e; } }
@Test public void testGetRoutes() { final Route route = this.constructTestRoute(GLOBAL_PREFIX); this.routingTable.getRouteByPrefix(route.routePrefix()); verify(interledgerPrefixMapMock).getEntry(route.routePrefix()); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
### Question:
InMemoryRoutingTable implements RoutingTable<R> { @Override public void forEach(final BiConsumer<InterledgerAddressPrefix, R> action) { Objects.requireNonNull(action); this.interledgerAddressPrefixMap.forEach(action); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); }### Answer:
@Test(expected = NullPointerException.class) public void testForEachNull() { try { this.routingTable.forEach(null); } catch (NullPointerException e) { throw e; } }
@Test public void testForEach() { final BiConsumer<String, Collection<Route>> action = (o, o2) -> { }; this.routingTable.forEach(action); verify(interledgerPrefixMapMock).forEach(action); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
### Question:
InMemoryRoutingTable implements RoutingTable<R> { @Override public Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress) { Objects.requireNonNull(interledgerAddress, "finalDestinationAddress must not be null!"); return this.interledgerAddressPrefixMap.findNextHop(interledgerAddress); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); }### Answer:
@Test(expected = NullPointerException.class) public void testFindNextHopRouteNull() { try { this.routingTable.findNextHopRoute(null); } catch (NullPointerException e) { throw e; } }
@Test public void testFindNextHopRoute() { this.routingTable.findNextHopRoute(BOB_GLOBAL_ADDRESS); verify(interledgerPrefixMapMock).findNextHop(BOB_GLOBAL_ADDRESS); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
### Question:
ConnectorServer extends Server { @Override public void start() { super.start(); if (SpringProfileUtils.isProfileActive(getContext().getEnvironment(), "MIGRATE-ONLY")) { System.out.println("###################################################################"); System.out.println("!!! Container started with migrate-only profile. Shutting down. !!!"); System.out.println("###################################################################"); this.stop(); return; } this.emitFxInfo(); if (getConnectorSettings().get().operatorAddress().equals(Link.SELF)) { logger.info("STARTED INTERLEDGER CHILD CONNECTOR: [Operator Address pending IL-DCP]"); } else { logger.info("STARTED INTERLEDGER CONNECTOR: `{}`", getConnectorSettings().get().operatorAddress()); } } ConnectorServer(); ConnectorServer(final ConnectorSettings connectorSettings); @Override void start(); @Override void onApplicationEvent(final ApplicationEvent event); }### Answer:
@Test public void migrateOnlyCallsStop() throws InterruptedException { System.setProperty(SPRING_PROFILES_ACTIVE, "migrate-only,test"); System.setProperty(SERVER_PORT, "0"); connectorServer.start(); assertThat(connectorServer.getContext().isActive()).isFalse(); }
@Test public void serverActiveAfterStart() { System.setProperty(SPRING_PROFILES_ACTIVE, "test"); System.setProperty(SERVER_PORT, "0"); connectorServer.start(); assertThat(connectorServer.getContext().isActive()).isTrue(); } |
### Question:
InDatabaseStreamPaymentManager implements StreamPaymentManager { @Override public Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId) { return streamPaymentsRepository.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId) .map(streamPaymentFromEntityConverter::convert); } InDatabaseStreamPaymentManager(StreamPaymentsRepository streamPaymentsRepository,
StreamPaymentFromEntityConverter streamPaymentFromEntityConverter,
StreamPaymentToEntityConverter streamPaymentToEntityConverter); @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override void merge(StreamPayment streamPayment); }### Answer:
@Test public void findByAccountIdAndStreamPaymentId() { StreamPayment trx1 = transactionBuilder().build(); when(mockRepo.findByAccountIdAndStreamPaymentId(trx1.accountId(), trx1.streamPaymentId())) .thenReturn(Optional.of(streamPaymentToEntityConverter.convert(trx1))); assertThat(transactionManager.findByAccountIdAndStreamPaymentId(trx1.accountId(), trx1.streamPaymentId())) .isEqualTo(Optional.of(trx1)); } |
### Question:
InDatabaseStreamPaymentManager implements StreamPaymentManager { @Override public List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest) { return streamPaymentsRepository.findByAccountIdOrderByCreatedDateDesc(accountId, pageRequest) .stream() .map(streamPaymentFromEntityConverter::convert) .collect(Collectors.toList()); } InDatabaseStreamPaymentManager(StreamPaymentsRepository streamPaymentsRepository,
StreamPaymentFromEntityConverter streamPaymentFromEntityConverter,
StreamPaymentToEntityConverter streamPaymentToEntityConverter); @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override void merge(StreamPayment streamPayment); }### Answer:
@Test public void findByAccountId() { StreamPayment trx1 = transactionBuilder().build(); StreamPayment trx2 = transactionBuilder().build(); when(mockRepo.findByAccountIdOrderByCreatedDateDesc(eq(trx1.accountId()), any())) .thenReturn(Lists.newArrayList(streamPaymentToEntityConverter.convert(trx1), streamPaymentToEntityConverter.convert(trx2))); assertThat(transactionManager.findByAccountId(trx1.accountId(), PageRequest.of(0, 100))) .isEqualTo(Lists.newArrayList(trx1, trx2)); } |
### Question:
AccountSettingsLoadingCache implements AccountSettingsCache { @Subscribe @SuppressWarnings("PMD.UnusedPublicMethod") public void _handleAccountUpdated(AccountUpdatedEvent event) { this.accountSettingsCache.invalidate(event.accountId()); } @VisibleForTesting AccountSettingsLoadingCache(final AccountSettingsRepository accountSettingsRepository,
final EventBus eventBus); AccountSettingsLoadingCache(
final AccountSettingsRepository accountSettingsRepository,
final Cache<AccountId, Optional<AccountSettings>> accountSettingsCache,
final EventBus eventBus
); Optional<AccountSettings> getAccount(final AccountId accountId); AccountSettings safeGetAccountId(final AccountId accountId); @Subscribe @SuppressWarnings("PMD.UnusedPublicMethod") void _handleAccountUpdated(AccountUpdatedEvent event); }### Answer:
@Test public void accountUpdatedEventInvalidates() { accountSettingsLoadingCache._handleAccountUpdated( AccountUpdatedEvent.builder() .accountId(AccountId.of("ricketycricket")) .build() ); verify(accountSettingsCache, times(1)).invalidate(AccountId.of("ricketycricket")); } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackNumRateLimitedPackets(final AccountSettings accountSettings) { Objects.requireNonNull(accountSettings); PrometheusCollectors.rateLimitedPackets.labels( accountSettings.accountId().value(), accountSettings.assetCode(), stringify(accountSettings.assetScale()) ).inc(); } @Override void trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackIncomingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackIncomingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackIncomingPacketFailed(final AccountSettings accountSettings); @Override void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket); @Override void trackOutgoingPacketFulfilled(
final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket
); @Override void trackOutgoingPacketRejected(
final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket
); @Override void trackOutgoingPacketFailed(final AccountSettings accountSettings); @Override void trackNumRateLimitedPackets(final AccountSettings accountSettings); @Override void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event); @Override void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event); @Override void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event); @Override void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event); }### Answer:
@Test public void trackNumRateLimitedPackets() { final Counter counter = PrometheusCollectors.rateLimitedPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackNumRateLimitedPackets(accountSettings()); assertThat(sum(counter)).isEqualTo(i + 1); } } |
### Question:
DefaultAccessTokenManager implements AccessTokenManager { @Override public AccessToken createToken(AccountId accountId) { String newRandomToken = Base64.getEncoder().encodeToString(UUID.randomUUID().toString().getBytes()); AccessTokenEntity newEntity = new AccessTokenEntity(); newEntity.setAccountId(accountId); newEntity.setEncryptedToken(encryptToken(newRandomToken)); AccessTokenEntity saved = accessTokensRepository.save(newEntity); return AccessToken.builder() .from(accessTokensRepository.withConversion(saved)) .rawToken(newRandomToken) .build(); } DefaultAccessTokenManager(PasswordEncoder passwordEncoder,
AccessTokensRepository accessTokensRepository,
EventBus eventBus); @Override AccessToken createToken(AccountId accountId); @Override @Transactional void deleteByAccountIdAndId(AccountId accountId, long id); @Override @Transactional void deleteByAccountId(AccountId accountId); @Override List<AccessToken> findTokensByAccountId(AccountId accountId); @Override Optional<AccessToken> findByAccountIdAndRawToken(AccountId accountId, String rawToken); }### Answer:
@Test public void createToken() { AccountId accountId = AccountId.of("test"); AccessToken accessToken = manager.createToken(accountId); assertThat(accessToken.rawToken()).isNotEmpty(); assertThat(passwordEncoder.matches(accessToken.rawToken().get(), accessToken.encryptedToken())).isTrue(); } |
### Question:
ApplicationContextProvider implements ApplicationContextAware { public static Set<ApplicationContext> getAllApplicationContexts() { return findActiveContexts(ctx); } static Set<ApplicationContext> getAllApplicationContexts(); void setApplicationContext(ApplicationContext ctx); }### Answer:
@Test public void getAllApplicationContexts() { assertThat(ApplicationContextProvider.findActiveContexts( Sets.newHashSet(mockContext(() -> false), mockContext(() -> false)))).hasSize(0); assertThat(ApplicationContextProvider.findActiveContexts( Sets.newHashSet(mockContext(() -> true), mockContext(() -> false)))).hasSize(1); assertThat(ApplicationContextProvider.findActiveContexts( Sets.newHashSet(mockContext(() -> true), mockContext(() -> true)))).hasSize(2); } |
### Question:
StreamPacketUtils { public static Optional<Denomination> getDenomination(StreamPacket streamPacket) { return streamPacket.frames().stream() .filter(frame -> frame.streamFrameType().equals(StreamFrameType.ConnectionAssetDetails)) .map(frame -> ((ConnectionAssetDetailsFrame) frame)) .map(ConnectionAssetDetailsFrame::sourceDenomination) .findFirst(); } static Optional<Denomination> getDenomination(StreamPacket streamPacket); static boolean hasCloseFrame(StreamPacket streamPacket); static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket); }### Answer:
@Test public void getDenomination() { assertThat(StreamPacketUtils.getDenomination(JUST_CONNECTION_ASSET_DETAILS_FRAME)).hasValue(DENOMINATION); assertThat(StreamPacketUtils.getDenomination(ALL_THE_FRAMES)).hasValue(DENOMINATION); assertThat(StreamPacketUtils.getDenomination(JUST_MONEY_FRAME)).isEmpty(); assertThat(StreamPacketUtils.getDenomination(NO_FRAMES)).isEmpty(); } |
### Question:
StreamPacketUtils { public static boolean hasCloseFrame(StreamPacket streamPacket) { return streamPacket.frames().stream() .map(StreamFrame::streamFrameType) .anyMatch(CLOSING_FRAMES::contains); } static Optional<Denomination> getDenomination(StreamPacket streamPacket); static boolean hasCloseFrame(StreamPacket streamPacket); static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket); }### Answer:
@Test public void hasCloseFrame() { assertThat(StreamPacketUtils.hasCloseFrame(JUST_CLOSE_FRAME)).isTrue(); assertThat(StreamPacketUtils.hasCloseFrame(ALL_THE_FRAMES)).isTrue(); assertThat(StreamPacketUtils.hasCloseFrame(JUST_MONEY_FRAME)).isFalse(); assertThat(StreamPacketUtils.hasCloseFrame(NO_FRAMES)).isFalse(); } |
### Question:
StreamPacketUtils { public static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket) { return streamPacket.frames().stream() .filter(frame -> frame.streamFrameType().equals(StreamFrameType.ConnectionNewAddress)) .map(frame -> ((ConnectionNewAddressFrame) frame).sourceAddress()) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); } static Optional<Denomination> getDenomination(StreamPacket streamPacket); static boolean hasCloseFrame(StreamPacket streamPacket); static Optional<InterledgerAddress> getSourceAddress(StreamPacket streamPacket); }### Answer:
@Test public void getSourceAddress() { assertThat(StreamPacketUtils.getSourceAddress(JUST_CONNECTION_NEW_ADDRESS_FRAME)).hasValue(ADDRESS); assertThat(StreamPacketUtils.getSourceAddress(ALL_THE_FRAMES)).hasValue(ADDRESS); assertThat(StreamPacketUtils.getSourceAddress(JUST_MONEY_FRAME)).isEmpty(); assertThat(StreamPacketUtils.getSourceAddress(NO_FRAMES)).isEmpty(); } |
### Question:
AccountBalanceService { public AccountBalanceResponse getAccountBalance(final AccountId accountId) { Objects.requireNonNull(accountId); return accountSettingsRepository.findByAccountIdWithConversion(accountId) .map(settings -> AccountBalanceResponse.builder() .accountBalance(balanceTracker.balance(accountId)) .assetCode(settings.assetCode()) .assetScale((short) settings.assetScale()) .build() ).orElseThrow(() -> new AccountNotFoundProblem(accountId)); } AccountBalanceService(
final BalanceTracker balanceTracker, final AccountSettingsRepository accountSettingsRepository
); AccountBalanceResponse getAccountBalance(final AccountId accountId); }### Answer:
@Test public void getAccountBalance() { AccountId accountId = AccountId.of("test"); AccountSettings settings = AccountSettings.builder() .accountId(accountId) .description("child") .accountRelationship(AccountRelationship.CHILD) .linkType(IlpOverHttpLink.LINK_TYPE) .assetScale(2) .assetCode("XRP") .build(); AccountBalance balance = AccountBalance.builder() .accountId(accountId) .clearingBalance(1) .prepaidAmount(2) .build(); AccountBalanceResponse expected = AccountBalanceResponse.builder() .accountBalance(balance) .assetScale(settings.assetScale()) .assetCode(settings.assetCode()) .build(); when(mockSettingsRepo.findByAccountIdWithConversion(accountId)).thenReturn(Optional.of(settings)); when(mockBalanceTracker.balance(accountId)).thenReturn(balance); AccountBalanceResponse response = service.getAccountBalance(accountId); assertThat(response).isEqualTo(expected); }
@Test public void getAccountBalanceAccountNotFound() { AccountId accountId = AccountId.of("test"); when(mockSettingsRepo.findByAccountIdWithConversion(accountId)).thenReturn(Optional.empty()); expectedException.expect(AccountNotFoundProblem.class); service.getAccountBalance(accountId); } |
### Question:
ApplicationContextProvider implements ApplicationContextAware { @VisibleForTesting static Set<ApplicationContext> findActiveContexts(Set<ApplicationContext> contexts) { return contexts.stream() .filter(ctx -> ctx instanceof ConfigurableApplicationContext) .map(ctx -> (ConfigurableApplicationContext) ctx) .filter(ctx -> ctx.isActive()) .collect(Collectors.toSet()); } static Set<ApplicationContext> getAllApplicationContexts(); void setApplicationContext(ApplicationContext ctx); }### Answer:
@Test public void getAllApplicationContextsWithChangingValue() { AtomicBoolean active = new AtomicBoolean(false); HashSet<ApplicationContext> contexts = Sets.newHashSet(mockContext(() -> active.get()), mockContext(() -> false)); assertThat(ApplicationContextProvider.findActiveContexts(contexts)).hasSize(0); active.set(true); assertThat(ApplicationContextProvider.findActiveContexts(contexts)).hasSize(1); active.set(false); assertThat(ApplicationContextProvider.findActiveContexts(contexts)).hasSize(0); } |
### Question:
DefaultPacketEventPublisher implements PacketEventPublisher { @Override public void publishRejectionByNextHop(AccountSettings sourceAccountSettings, AccountSettings nextHopAccountSettings, InterledgerPreparePacket preparePacket, InterledgerPreparePacket nextHopPacket, BigDecimal fxRate, InterledgerRejectPacket rejectPacket) { eventBus.post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .exchangeRate(fxRate) .incomingPreparePacket(preparePacket) .outgoingPreparePacket(nextHopPacket) .message(rejectPacket.getMessage()) .rejection(rejectPacket) .build()); } DefaultPacketEventPublisher(EventBus eventBus); @Override void publishRejectionByNextHop(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerRejectPacket rejectPacket); @Override void publishRejectionByConnector(AccountSettings sourceAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerRejectPacket rejectPacket); @Override void publishFulfillment(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerFulfillment fulfillment); }### Answer:
@Test public void publishRejectionByNextHop() { publisher.publishRejectionByNextHop(sourceAccountSettings, nextHopAccountSettings, preparePacket, nextHopPacket, fxRate, rejectPacket); verify(eventBus).post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .exchangeRate(fxRate) .incomingPreparePacket(preparePacket) .outgoingPreparePacket(nextHopPacket) .rejection(rejectPacket) .message(rejectPacket.getMessage()) .build() ); } |
### Question:
DefaultPacketEventPublisher implements PacketEventPublisher { @Override public void publishRejectionByConnector(AccountSettings sourceAccountSettings, InterledgerPreparePacket preparePacket, InterledgerRejectPacket rejectPacket) { eventBus.post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .incomingPreparePacket(preparePacket) .message(rejectPacket.getMessage()) .rejection(rejectPacket) .build()); } DefaultPacketEventPublisher(EventBus eventBus); @Override void publishRejectionByNextHop(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerRejectPacket rejectPacket); @Override void publishRejectionByConnector(AccountSettings sourceAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerRejectPacket rejectPacket); @Override void publishFulfillment(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerFulfillment fulfillment); }### Answer:
@Test public void publishRejectionByConnector() { publisher.publishRejectionByConnector(sourceAccountSettings, preparePacket, rejectPacket); verify(eventBus).post(PacketRejectionEvent.builder() .accountSettings(sourceAccountSettings) .incomingPreparePacket(preparePacket) .rejection(rejectPacket) .message(rejectPacket.getMessage()) .build() ); } |
### Question:
DefaultPacketEventPublisher implements PacketEventPublisher { @Override public void publishFulfillment(AccountSettings sourceAccountSettings, AccountSettings nextHopAccountSettings, InterledgerPreparePacket preparePacket, InterledgerPreparePacket nextHopPacket, BigDecimal fxRate, InterledgerFulfillment fulfillment) { eventBus.post(PacketFullfillmentEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .exchangeRate(fxRate) .incomingPreparePacket(preparePacket) .outgoingPreparePacket(nextHopPacket) .fulfillment(fulfillment) .message("Fulfilled successfully") .build()); } DefaultPacketEventPublisher(EventBus eventBus); @Override void publishRejectionByNextHop(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerRejectPacket rejectPacket); @Override void publishRejectionByConnector(AccountSettings sourceAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerRejectPacket rejectPacket); @Override void publishFulfillment(AccountSettings sourceAccountSettings,
AccountSettings nextHopAccountSettings,
InterledgerPreparePacket preparePacket,
InterledgerPreparePacket nextHopPacket,
BigDecimal fxRate,
InterledgerFulfillment fulfillment); }### Answer:
@Test public void publishFulfillment() { publisher.publishFulfillment(sourceAccountSettings, nextHopAccountSettings, preparePacket, nextHopPacket, fxRate, fulfillment); verify(eventBus).post(PacketFullfillmentEvent.builder() .accountSettings(sourceAccountSettings) .destinationAccount(nextHopAccountSettings) .outgoingPreparePacket(nextHopPacket) .incomingPreparePacket(preparePacket) .exchangeRate(fxRate) .fulfillment(fulfillment) .message("Fulfilled successfully") .build() ); } |
### Question:
DefaultPacketSwitchFilterChain implements PacketSwitchFilterChain { @VisibleForTesting Link computeLink(final AccountSettings nextHopAccountSettings, final InterledgerAddress destinationAddress) { if (localDestinationAddressUtils.isLocalSpspDestinationAddress(destinationAddress)) { return this.linkManager.getOrCreateSpspReceiverLink(nextHopAccountSettings); } else { return this.linkManager.getOrCreateLink(nextHopAccountSettings); } } DefaultPacketSwitchFilterChain(
final PacketRejector packetRejector,
final List<PacketSwitchFilter> packetSwitchFilters,
final List<LinkFilter> linkFilters,
final LocalDestinationAddressUtils localDestinationAddressUtils,
final LinkManager linkManager,
final NextHopPacketMapper nextHopPacketMapper,
final AccountSettingsLoadingCache accountSettingsLoadingCache,
final PacketEventPublisher packetEventPublisher
); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings, final InterledgerPreparePacket preparePacket
); }### Answer:
@Test public void computeLinkForLocalSpsp() { when(localDestinationAddressUtilsMock.isLocalSpspDestinationAddress(any())).thenReturn(true); filterChain.computeLink(INCOMING_ACCOUNT_SETTINGS, InterledgerAddress.of("example.foo")); verify(linkManagerMock).getOrCreateSpspReceiverLink(INCOMING_ACCOUNT_SETTINGS); verifyNoMoreInteractions(linkManagerMock); }
@Test public void computeLinkForForwardingAccount() { when(localDestinationAddressUtilsMock.isLocalSpspDestinationAddress(any())).thenReturn(false); filterChain.computeLink(INCOMING_ACCOUNT_SETTINGS, InterledgerAddress.of("example.foo")); verify(linkManagerMock).getOrCreateLink(INCOMING_ACCOUNT_SETTINGS); verifyNoMoreInteractions(linkManagerMock); } |
### Question:
EthCurrencyProvider implements CurrencyProviderSpi { @Override public Set<CurrencyUnit> getCurrencies(CurrencyQuery query) { if (query.isEmpty() || query.getCurrencyCodes().contains(ETH)) { return currencyUnits; } return Collections.emptySet(); } EthCurrencyProvider(); @Override Set<CurrencyUnit> getCurrencies(CurrencyQuery query); static final String ETH; }### Answer:
@Test public void getCurrencies() { final Set<CurrencyUnit> currencyUnits = provider.getCurrencies( CurrencyQueryBuilder.of() .setCurrencyCodes(ETH) .setCountries(Locale.CANADA) .set(LocalDate.of(1970, 1, 1)) .setProviderNames(ETH).build() ); assertThat(currencyUnits.size()).isEqualTo(1); assertThat(currencyUnits.stream().findFirst().get().getCurrencyCode()).isEqualTo(ETH); } |
### Question:
DropRoundingProvider implements RoundingProviderSpi { public Set<String> getRoundingNames() { return roundingNames; } DropRoundingProvider(); MonetaryRounding getRounding(RoundingQuery query); Set<String> getRoundingNames(); }### Answer:
@Test public void getRoundingNames() { assertThat(dropRoundingProvider.getRoundingNames().size()).isEqualTo(1); assertThat(dropRoundingProvider.getRoundingNames().contains(DROP)).isTrue(); } |
### Question:
CryptoCompareRateProvider extends AbstractRateProvider { @Override public ExchangeRate getExchangeRate(ConversionQuery conversionQuery) { Objects.requireNonNull(conversionQuery); try { return this.exchangeRateCache.get(conversionQuery, fxLoader()); } catch (Exception e) { throw new MonetaryException("Failed to load currency conversion data", e); } } CryptoCompareRateProvider(
final Supplier<String> apiKeySupplier,
final RestTemplate restTemplate,
final Cache<ConversionQuery, ExchangeRate> exchangeRateCache
); @Override ExchangeRate getExchangeRate(ConversionQuery conversionQuery); }### Answer:
@Test public void getExchangeRateWithUnknownCurrencyInCryptoCompare() { expectedException.expect(MonetaryException.class); expectedException.expectMessage("Unknown currency code: FOO"); provider.getExchangeRate( ConversionQueryBuilder.of().setBaseCurrency("FOO").setTermCurrency("USD").setRateTypes(RateType.DEFERRED) .build() ); }
@Test public void getExchangeRateWithNoRateFoundInCryptoCompare() { expectedException.expect(MonetaryException.class); expectedException.expectMessage("Failed to load currency conversion data"); provider.getExchangeRate( ConversionQueryBuilder.of().setBaseCurrency("XRP").setTermCurrency("USD").setRateTypes(RateType.DEFERRED) .build() ); }
@Test public void getExchangeRateWhenRateExistsInCache() { ExchangeRate exchangeRateMock = mock(ExchangeRate.class); when(cacheMock.get(any(), any())).thenReturn(exchangeRateMock); this.provider = new CryptoCompareRateProvider(() -> "apiKey", restTemplate, cacheMock); final ExchangeRate actual = provider.getExchangeRate( ConversionQueryBuilder.of().setBaseCurrency("XRP").setTermCurrency("USD").setRateTypes(RateType.DEFERRED) .build() ); assertThat(actual).isEqualTo(exchangeRateMock); } |
### Question:
XrpCurrencyProvider implements CurrencyProviderSpi { @Override public Set<CurrencyUnit> getCurrencies(CurrencyQuery query) { if (query.isEmpty() || query.getCurrencyCodes().contains(XRP)) { return currencyUnits; } return Collections.emptySet(); } XrpCurrencyProvider(); @Override Set<CurrencyUnit> getCurrencies(CurrencyQuery query); static final String DROP; static final String XRP; }### Answer:
@Test public void getCurrencies() { final Set<CurrencyUnit> currencyUnits = provider.getCurrencies( CurrencyQueryBuilder.of() .setCurrencyCodes(XRP) .setCountries(Locale.CANADA) .set(LocalDate.of(1970, 1, 1)) .setProviderNames(XRP).build() ); assertThat(currencyUnits.size()).isEqualTo(1); assertThat(currencyUnits.stream().findFirst().get().getCurrencyCode()).isEqualTo(XRP); }
@Test public void getCurrenciesUnknownProvider() { final Set<CurrencyUnit> currencyUnits = provider.getCurrencies( CurrencyQueryBuilder.of() .setCountries(Locale.CANADA) .set(LocalDate.of(1970, 1, 1)) .setProviderNames(DROP).build() ); assertThat(currencyUnits.size()).isEqualTo(0); } |
### Question:
SpringProfileUtils { public static boolean isProfileActive(Environment environment, String profile) { return Arrays.asList(environment.getActiveProfiles()) .stream() .anyMatch(active -> active.trim().equalsIgnoreCase(profile.trim())); } static boolean isProfileActive(Environment environment, String profile); }### Answer:
@Test public void activeProfilesEmpty() { when(environment.getActiveProfiles()).thenReturn(new String[] {}); assertThat(SpringProfileUtils.isProfileActive(environment, "foo")).isFalse(); assertThat(SpringProfileUtils.isProfileActive(environment, "")).isFalse(); }
@Test public void activeProfiles() { when(environment.getActiveProfiles()).thenReturn(new String[] {"Foo", "BAR", "baz"}); assertThat(SpringProfileUtils.isProfileActive(environment, "Foo")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "foo")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "FOO")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "BAR")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "Bar")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "bar")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "baz")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "Baz")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "BAZ")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, "foobar")).isFalse(); }
@Test public void activeProfilesTrimmed() { when(environment.getActiveProfiles()).thenReturn(new String[] {"foo"}); assertThat(SpringProfileUtils.isProfileActive(environment, "foo ")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, " foo")).isTrue(); assertThat(SpringProfileUtils.isProfileActive(environment, " foo ")).isTrue(); } |
### Question:
DefaultNextHopPacketMapper implements NextHopPacketMapper { @VisibleForTesting protected Instant lesser(final Instant first, final Instant second) { if (first.isBefore(second)) { return first; } else { return second; } } DefaultNextHopPacketMapper(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final PaymentRouter<Route> externalRoutingService,
final InterledgerAddressUtils addressUtils,
final JavaMoneyUtils javaMoneyUtils,
final AccountSettingsLoadingCache accountSettingsLoadingCache
); @VisibleForTesting DefaultNextHopPacketMapper(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final PaymentRouter<Route> externalRoutingService,
final InterledgerAddressUtils addressUtils,
final JavaMoneyUtils javaMoneyUtils,
final AccountSettingsLoadingCache accountSettingsLoadingCache,
final Function<CurrencyUnit, CurrencyConversion> currencyConverter
); NextHopInfo getNextHopPacket(
final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePacket
); @Deprecated BigDecimal determineExchangeRate(
final AccountSettings sourceAccountSettings,
final AccountSettings destinationAccountSettings,
final InterledgerPreparePacket sourcePacket
); }### Answer:
@Test public void lesser() { Instant now = Instant.now(clock); Instant nowPlusOne = Instant.now(clock).plusSeconds(1); assertThat(mapper.lesser(now, nowPlusOne)).isEqualTo(now); assertThat(mapper.lesser(nowPlusOne, now)).isEqualTo(now); assertThat(mapper.lesser(now, now)).isEqualTo(now); } |
### Question:
SettlementEngineIdempotencyKeyGenerator implements KeyGenerator { @Override public Object generate(Object target, Method method, Object... params) { if (target != null && SettlementController.class.isAssignableFrom(target.getClass())) { Preconditions.checkArgument(params.length > 0, "params is expected to have at least 1 value"); Object idempotencyKey = params[0] != null ? params[0] : null; return idempotencyKey; } else { return null; } } @Override Object generate(Object target, Method method, Object... params); }### Answer:
@Test(expected = IllegalArgumentException.class) public void generateWithTooFewParams() { try { generator.generate(settlementControllerMock, null, new Object[0]); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).isEqualTo("params is expected to have at least 1 value"); throw e; } }
@Test public void generateWithNonSettlementControllerTarget() { assertThat(generator.generate(objectMock, null, new Object[0])).isNull(); }
@Test public void generateWithOneParam() { final String idempotencyId = UUID.randomUUID().toString(); assertThat(generator.generate(settlementControllerMock, null, new Object[] {idempotencyId})).isEqualTo(idempotencyId); }
@Test public void generateWithMultipleParams() { final String idempotencyId = UUID.randomUUID().toString(); assertThat(generator.generate(settlementControllerMock, null, new Object[] {idempotencyId, "foo", "bar"})).isEqualTo(idempotencyId); } |
### Question:
ByteArrayUtils { public static byte[] generate32RandomBytes() { final byte[] rndBytes = new byte[32]; secureRandom.nextBytes(rndBytes); return rndBytes; } static boolean isEqualUsingConstantTime(byte[] val1, byte[] val2); static byte[] generate32RandomBytes(); }### Answer:
@Test public void generateRandom32Bytes() { assertThat(ByteArrayUtils.generate32RandomBytes()) .hasSize(32) .isNotEqualTo(ByteArrayUtils.generate32RandomBytes()); } |
### Question:
CoordinationEventBusBridge { @Subscribe public void onCoordinatedEvent(AbstractCoordinatedEvent event) { publish(event); } CoordinationEventBusBridge(CoordinationMessagePublisher coordinationMessagePublisher, EventBus eventBus); @Subscribe void onCoordinatedEvent(AbstractCoordinatedEvent event); }### Answer:
@Test public void ignoresPreviouslyCoordinatedMessage() { TestCoordinatedEvent event = new TestCoordinatedEvent(); event.markReceivedViaCoordination(); bridge.onCoordinatedEvent(event); verifyNoInteractions(publisher); }
@Test public void nullEventFails() { expectedException.expect(NullPointerException.class); bridge.onCoordinatedEvent(null); } |
### Question:
RuntimeUtils { public static boolean gcpProfileEnabled(final Environment environment) { Objects.requireNonNull(environment); return Arrays.stream(environment.getActiveProfiles()) .anyMatch(Runtimes.GCP::equalsIgnoreCase); } static boolean gcpProfileEnabled(final Environment environment); static Optional<String> getGoogleCloudProjectId(); static KeyStoreType determineKeystoreType(Environment environment); static boolean walletModeEnabled(final Environment env); static boolean packetSwitchModeEnabled(final Environment env); }### Answer:
@Test public void testGcpProfileEnabled() { when(environmentMock.getActiveProfiles()).thenReturn(new String[] {"foo", "bar"}); assertThat(RuntimeUtils.gcpProfileEnabled(environmentMock)).isFalse(); when(environmentMock.getActiveProfiles()).thenReturn(new String[] {RuntimeProperties.Runtimes.GCP}); assertThat(RuntimeUtils.gcpProfileEnabled(environmentMock)).isTrue(); } |
### Question:
RuntimeUtils { public static Optional<String> getGoogleCloudProjectId() { return Optional.ofNullable(System.getenv().get(GOOGLE_CLOUD_PROJECT)) .filter(projectId -> !projectId.isEmpty()); } static boolean gcpProfileEnabled(final Environment environment); static Optional<String> getGoogleCloudProjectId(); static KeyStoreType determineKeystoreType(Environment environment); static boolean walletModeEnabled(final Environment env); static boolean packetSwitchModeEnabled(final Environment env); }### Answer:
@Test public void testGetGcpProjectName() throws ReflectiveOperationException { assertThat(RuntimeUtils.getGoogleCloudProjectId().isPresent()).isFalse(); System.setProperty(GOOGLE_CLOUD_PROJECT, "foo"); assertThat(RuntimeUtils.getGoogleCloudProjectId().isPresent()).isFalse(); updateEnv(GOOGLE_CLOUD_PROJECT, "foo"); assertThat(RuntimeUtils.getGoogleCloudProjectId().isPresent()).isTrue(); } |
### Question:
OerPreparePacketHttpMessageConverter extends AbstractGenericHttpMessageConverter<InterledgerPacket> implements HttpMessageConverter<InterledgerPacket> { @Override public boolean canRead(Type type, Class<?> contextClass, MediaType mediaType) { if (contextClass != null && IlpHttpController.class.isAssignableFrom(contextClass)) { return super.canRead(type, contextClass, mediaType); } else { return false; } } OerPreparePacketHttpMessageConverter(final CodecContext ilpCodecContext); @Override boolean canRead(Type type, Class<?> contextClass, MediaType mediaType); @Override InterledgerPacket read(Type type, Class<?> contextClass, HttpInputMessage inputMessage); }### Answer:
@Test public void testCanRead() { assertThat(converter.canRead(InterledgerPreparePacket.class, IlpHttpController.class, APPLICATION_JSON)).isFalse(); assertThat(converter.canRead(InterledgerPreparePacket.class, IlpHttpController.class, APPLICATION_OCTET_STREAM)).isTrue(); assertThat(converter.canRead(InterledgerPreparePacket.class, SettlementController.class, APPLICATION_JSON)).isFalse(); assertThat(converter.canRead(InterledgerPreparePacket.class, SettlementController.class, APPLICATION_OCTET_STREAM)).isFalse(); assertThat(converter.canRead(String.class, IlpHttpController.class, APPLICATION_JSON)).isFalse(); assertThat(converter.canRead(String.class, IlpHttpController.class, APPLICATION_OCTET_STREAM)).isTrue(); assertThat(converter.canRead(null, IlpHttpController.class, APPLICATION_OCTET_STREAM)).isTrue(); assertThat(converter.canRead(InterledgerPreparePacket.class, null, APPLICATION_OCTET_STREAM)).isFalse(); assertThat(converter.canRead(InterledgerPreparePacket.class, IlpHttpController.class, null)).isTrue(); assertThat(converter.canRead(null, null, null)).isFalse(); } |
### Question:
MetaDataController { @RequestMapping( path = PathConstants.SLASH, method = RequestMethod.GET, produces = {APPLICATION_JSON_VALUE, MediaTypes.PROBLEM_VALUE} ) public ResponseEntity<ConnectorSettingsResponse> getConnectorMetaData() { return new ResponseEntity<>(ConnectorSettingsResponse.builder() .operatorAddress(this.connectorSettingsSupplier.get().operatorAddress()) .version(this.buildProperties.getVersion()) .build(), HttpStatus.OK); } MetaDataController(Supplier<ConnectorSettings> connectorSettingsSupplier); @RequestMapping( path = PathConstants.SLASH, method = RequestMethod.GET, produces = {APPLICATION_JSON_VALUE, MediaTypes.PROBLEM_VALUE} ) ResponseEntity<ConnectorSettingsResponse> getConnectorMetaData(); }### Answer:
@Test public void getConnectorMetaData() { ResponseEntity<String> metaDataResponse = restTemplate.getForEntity(PathConstants.SLASH, String.class); logger.info("metaDataResponse: " + metaDataResponse.getBody()); JsonContentAssert assertJson = assertThat(jsonTester.from(metaDataResponse.getBody())); assertJson.extractingJsonPathValue("ilp_address").isEqualTo(testConnectorAddress); assertJson.hasJsonPath("version"); } |
### Question:
DelegatingEncryptionService implements EncryptionService { @Override public KeyStoreType keyStoreType() { return serviceMap.values().stream().map(EncryptionService::keyStoreType).findFirst().get(); } DelegatingEncryptionService(final Set<EncryptionService> encryptionServices); @Override KeyStoreType keyStoreType(); @Override byte[] decrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] cipherMessage); @Override EncryptedSecret encrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] plainText); @Override T withDecrypted(EncryptedSecret encryptedSecret, Function<byte[], T> callable); }### Answer:
@Test public void keyStoreType() { assertThat(new DelegatingEncryptionService(Sets.newHashSet(mockGcp)).keyStoreType()).isEqualTo(KeyStoreType.GCP); assertThat(new DelegatingEncryptionService(Sets.newHashSet(mockJks)).keyStoreType()).isEqualTo(KeyStoreType.JKS); } |
### Question:
JwksUtils { public static HttpUrl getJwksUrl(HttpUrl issuerUrl) { HttpUrl.Builder builder = new HttpUrl.Builder() .scheme(issuerUrl.scheme()) .host(issuerUrl.host()) .port(issuerUrl.port()); issuerUrl.pathSegments().forEach(builder::addPathSegment); return builder.addPathSegment(".well-known") .addPathSegment("jwks.json") .build(); } static HttpUrl getJwksUrl(HttpUrl issuerUrl); }### Answer:
@Test public void getJwksUrlAtRootPath() { HttpUrl issuer = HttpUrl.parse("https: HttpUrl expectedJwks = HttpUrl.parse("https: assertThat(JwksUtils.getJwksUrl(issuer)).isEqualTo(expectedJwks); }
@Test public void getJwksUrlAtRootPathTrailingSlash() { HttpUrl issuer = HttpUrl.parse("https: HttpUrl expectedJwks = HttpUrl.parse("https: assertThat(JwksUtils.getJwksUrl(issuer)).isEqualTo(expectedJwks); }
@Test public void getJwksUrlAtSubPath() { HttpUrl issuer = HttpUrl.parse("https: HttpUrl expectedJwks = HttpUrl.parse("https: assertThat(JwksUtils.getJwksUrl(issuer)).isEqualTo(expectedJwks); }
@Test public void getJwksUrlAtSubPathTrailingSlash() { HttpUrl issuer = HttpUrl.parse("https: HttpUrl expectedJwks = HttpUrl.parse("https: assertThat(JwksUtils.getJwksUrl(issuer)).isEqualTo(expectedJwks); } |
### Question:
BearerTokenSecurityContextRepository implements SecurityContextRepository { @Override public boolean containsContext(HttpServletRequest request) { return parseToken(request).isPresent() && parseAccountId(request).isPresent(); } BearerTokenSecurityContextRepository(byte[] ephemeralBytes); @Override SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder); @Override void saveContext(SecurityContext context, HttpServletRequest request, HttpServletResponse response); @Override boolean containsContext(HttpServletRequest request); }### Answer:
@Test public void loadContextNoAccountIdInUrl() { String token = "foo:bar"; mockRequestPath("/routes/foo/ilp"); when(mockRequest.getHeader("Authorization")).thenReturn("Bearer " + token); assertThat(repository.containsContext(mockRequest)).isFalse(); }
@Test public void containsContext() { mockRequestPath("/accounts/foo/ilp"); when(mockRequest.getHeader("Authorization")).thenReturn("Bearer token"); assertThat(repository.containsContext(mockRequest)).isTrue(); } |
### Question:
BearerTokenSecurityContextRepository implements SecurityContextRepository { @Override public SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder) { SecurityContext context = SecurityContextHolder.createEmptyContext(); parseToken(requestResponseHolder.getRequest()).ifPresent(token -> { context.setAuthentication(BearerAuthentication.builder() .isAuthenticated(false) .principal(parseAccountId(requestResponseHolder.getRequest()).get()) .hmacSha256(Hashing.hmacSha256(ephemeralBytes).hashBytes(token)) .bearerToken(token) .build()); }); return context; } BearerTokenSecurityContextRepository(byte[] ephemeralBytes); @Override SecurityContext loadContext(HttpRequestResponseHolder requestResponseHolder); @Override void saveContext(SecurityContext context, HttpServletRequest request, HttpServletResponse response); @Override boolean containsContext(HttpServletRequest request); }### Answer:
@Test public void loadContextNoAuthHeader() { mockRequestPath("/accounts/foo/ilp"); SecurityContext securityContext = repository.loadContext(holder); assertThat(securityContext.getAuthentication()).isNull(); }
@Test public void loadContextDeprecatedNoBearerPrefix() { mockRequestPath("/accounts/foo/ilp"); String deprecatedBearerToken = "undercover token"; when(mockRequest.getHeader("Authorization")).thenReturn(deprecatedBearerToken); SecurityContext securityContext = repository.loadContext(holder); assertThat(securityContext.getAuthentication()).isNotNull(); assertThat(securityContext.getAuthentication().getCredentials()).isEqualTo(deprecatedBearerToken.getBytes()); }
@Test public void loadContextBasicAuth() { mockRequestPath("/accounts/foo/ilp"); String basicAuth = "Basic token"; when(mockRequest.getHeader("Authorization")).thenReturn(basicAuth); SecurityContext securityContext = repository.loadContext(holder); assertThat(securityContext.getAuthentication()).isNull(); } |
### Question:
AsnUuidCodec extends AsnOctetStringBasedObjectCodec<UUID> { @VisibleForTesting protected final static byte[] getBytesFromUUID(final UUID uuid) { final ByteBuffer bb = ByteBuffer.wrap(new byte[16]); bb.putLong(uuid.getMostSignificantBits()); bb.putLong(uuid.getLeastSignificantBits()); return bb.array(); } AsnUuidCodec(); @Override UUID decode(); @Override void encode(final UUID value); }### Answer:
@Test public void testUUIDHas16Bytes() { final UUID uuid = UUID.randomUUID(); final byte[] result = AsnUuidCodec.getBytesFromUUID(uuid); assertThat(result.length).as("Resulting byte array should have had 16 elements.").isEqualTo(16); }
@Test public void testNotSameUUIDFromByteArray() { final UUID uuid = UUID.fromString("80de5eaf-9379-4cb5-aaa4-1250649326cc"); final byte[] result = AsnUuidCodec.getBytesFromUUID(uuid); final UUID newUuid = UUID.nameUUIDFromBytes(result); assertThat(uuid).isNotEqualTo(newUuid); } |
### Question:
DelegatingEncryptionService implements EncryptionService { @Override public byte[] decrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] cipherMessage) { return getDelegate(keyMetadata).decrypt(keyMetadata, encryptionAlgorithm, cipherMessage); } DelegatingEncryptionService(final Set<EncryptionService> encryptionServices); @Override KeyStoreType keyStoreType(); @Override byte[] decrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] cipherMessage); @Override EncryptedSecret encrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] plainText); @Override T withDecrypted(EncryptedSecret encryptedSecret, Function<byte[], T> callable); }### Answer:
@Test public void decrypt() { DelegatingEncryptionService service = new DelegatingEncryptionService(Sets.newHashSet(mockGcp, mockJks)); assertThat(service.decrypt(GCP_SECRET)).isEqualTo(GCP_DECRYPTED); assertThat(service.decrypt(JKS_SECRET)).isEqualTo(JKS_DECRYPTED); }
@Test public void decryptThrowsExceptionIfNoProvider() { DelegatingEncryptionService service = new DelegatingEncryptionService(Sets.newHashSet(mockGcp)); expectedException.expect(RuntimeException.class); service.decrypt(JKS_SECRET); } |
### Question:
CircuitBreakingLink extends AbstractLink<LinkSettings> implements Link<LinkSettings> { @Override public LinkId getLinkId() { return this.linkDelegate.getLinkId(); } @VisibleForTesting CircuitBreakingLink(final Link<?> linkDelegate); CircuitBreakingLink(
final Link<?> linkDelegate,
final CircuitBreakerConfig circuitBreakerConfig
); @Override InterledgerResponsePacket sendPacket(final InterledgerPreparePacket preparePacket); @Override LinkId getLinkId(); @Override void setLinkId(final LinkId linkId); @Override Supplier<InterledgerAddress> getOperatorAddressSupplier(); @Override LinkSettings getLinkSettings(); @Override void registerLinkHandler(LinkHandler dataHandler); @Override Optional<LinkHandler> getLinkHandler(); @Override void unregisterLinkHandler(); T getLinkDelegateTyped(); }### Answer:
@Test public void getLinkId() { this.link.setLinkId(LINK_ID); this.link.getLinkId(); verify(linkDelegateMock).getOperatorAddressSupplier(); verify(linkDelegateMock).getLinkSettings(); verify(linkDelegateMock).getLinkId(); verify(linkDelegateMock).setLinkId(any()); verifyNoMoreInteractions(linkDelegateMock); } |
### Question:
CircuitBreakingLink extends AbstractLink<LinkSettings> implements Link<LinkSettings> { @Override public Supplier<InterledgerAddress> getOperatorAddressSupplier() { return this.linkDelegate.getOperatorAddressSupplier(); } @VisibleForTesting CircuitBreakingLink(final Link<?> linkDelegate); CircuitBreakingLink(
final Link<?> linkDelegate,
final CircuitBreakerConfig circuitBreakerConfig
); @Override InterledgerResponsePacket sendPacket(final InterledgerPreparePacket preparePacket); @Override LinkId getLinkId(); @Override void setLinkId(final LinkId linkId); @Override Supplier<InterledgerAddress> getOperatorAddressSupplier(); @Override LinkSettings getLinkSettings(); @Override void registerLinkHandler(LinkHandler dataHandler); @Override Optional<LinkHandler> getLinkHandler(); @Override void unregisterLinkHandler(); T getLinkDelegateTyped(); }### Answer:
@Test public void getOperatorAddressSupplier() { this.link.getOperatorAddressSupplier(); verify(linkDelegateMock, times(2)).getOperatorAddressSupplier(); verify(linkDelegateMock).getLinkSettings(); verifyNoMoreInteractions(linkDelegateMock); } |
### Question:
CircuitBreakingLink extends AbstractLink<LinkSettings> implements Link<LinkSettings> { @Override public LinkSettings getLinkSettings() { return this.linkDelegate.getLinkSettings(); } @VisibleForTesting CircuitBreakingLink(final Link<?> linkDelegate); CircuitBreakingLink(
final Link<?> linkDelegate,
final CircuitBreakerConfig circuitBreakerConfig
); @Override InterledgerResponsePacket sendPacket(final InterledgerPreparePacket preparePacket); @Override LinkId getLinkId(); @Override void setLinkId(final LinkId linkId); @Override Supplier<InterledgerAddress> getOperatorAddressSupplier(); @Override LinkSettings getLinkSettings(); @Override void registerLinkHandler(LinkHandler dataHandler); @Override Optional<LinkHandler> getLinkHandler(); @Override void unregisterLinkHandler(); T getLinkDelegateTyped(); }### Answer:
@Test public void getLinkSettings() { this.link.getLinkSettings(); verify(linkDelegateMock).getOperatorAddressSupplier(); verify(linkDelegateMock, times(2)).getLinkSettings(); verifyNoMoreInteractions(linkDelegateMock); } |
### Question:
CircuitBreakingLink extends AbstractLink<LinkSettings> implements Link<LinkSettings> { @Override public void registerLinkHandler(LinkHandler dataHandler) throws LinkHandlerAlreadyRegisteredException { this.linkDelegate.registerLinkHandler(dataHandler); } @VisibleForTesting CircuitBreakingLink(final Link<?> linkDelegate); CircuitBreakingLink(
final Link<?> linkDelegate,
final CircuitBreakerConfig circuitBreakerConfig
); @Override InterledgerResponsePacket sendPacket(final InterledgerPreparePacket preparePacket); @Override LinkId getLinkId(); @Override void setLinkId(final LinkId linkId); @Override Supplier<InterledgerAddress> getOperatorAddressSupplier(); @Override LinkSettings getLinkSettings(); @Override void registerLinkHandler(LinkHandler dataHandler); @Override Optional<LinkHandler> getLinkHandler(); @Override void unregisterLinkHandler(); T getLinkDelegateTyped(); }### Answer:
@Test public void registerLinkHandler() { this.link.registerLinkHandler(null); verify(linkDelegateMock).getOperatorAddressSupplier(); verify(linkDelegateMock).getLinkSettings(); verify(linkDelegateMock).registerLinkHandler(any()); verifyNoMoreInteractions(linkDelegateMock); } |
### Question:
CircuitBreakingLink extends AbstractLink<LinkSettings> implements Link<LinkSettings> { @Override public Optional<LinkHandler> getLinkHandler() { return this.linkDelegate.getLinkHandler(); } @VisibleForTesting CircuitBreakingLink(final Link<?> linkDelegate); CircuitBreakingLink(
final Link<?> linkDelegate,
final CircuitBreakerConfig circuitBreakerConfig
); @Override InterledgerResponsePacket sendPacket(final InterledgerPreparePacket preparePacket); @Override LinkId getLinkId(); @Override void setLinkId(final LinkId linkId); @Override Supplier<InterledgerAddress> getOperatorAddressSupplier(); @Override LinkSettings getLinkSettings(); @Override void registerLinkHandler(LinkHandler dataHandler); @Override Optional<LinkHandler> getLinkHandler(); @Override void unregisterLinkHandler(); T getLinkDelegateTyped(); }### Answer:
@Test public void getLinkHandler() { assertThat(link.getLinkHandler()).isEqualTo(Optional.empty()); verify(linkDelegateMock).getOperatorAddressSupplier(); verify(linkDelegateMock).getLinkSettings(); verify(linkDelegateMock).getLinkHandler(); verifyNoMoreInteractions(linkDelegateMock); } |
### Question:
CircuitBreakingLink extends AbstractLink<LinkSettings> implements Link<LinkSettings> { @Override public void unregisterLinkHandler() { this.linkDelegate.unregisterLinkHandler(); } @VisibleForTesting CircuitBreakingLink(final Link<?> linkDelegate); CircuitBreakingLink(
final Link<?> linkDelegate,
final CircuitBreakerConfig circuitBreakerConfig
); @Override InterledgerResponsePacket sendPacket(final InterledgerPreparePacket preparePacket); @Override LinkId getLinkId(); @Override void setLinkId(final LinkId linkId); @Override Supplier<InterledgerAddress> getOperatorAddressSupplier(); @Override LinkSettings getLinkSettings(); @Override void registerLinkHandler(LinkHandler dataHandler); @Override Optional<LinkHandler> getLinkHandler(); @Override void unregisterLinkHandler(); T getLinkDelegateTyped(); }### Answer:
@Test public void unregisterLinkHandler() { this.link.unregisterLinkHandler(); verify(linkDelegateMock).getOperatorAddressSupplier(); verify(linkDelegateMock).getLinkSettings(); verify(linkDelegateMock).unregisterLinkHandler(); verifyNoMoreInteractions(linkDelegateMock); } |
### Question:
StaticRouteEntityConverter implements Converter<StaticRouteEntity, StaticRoute> { @Override public StaticRoute convert(StaticRouteEntity staticRouteEntity) { Objects.requireNonNull(staticRouteEntity); return StaticRoute.builder() .nextHopAccountId(staticRouteEntity.getBoxedAccountId()) .routePrefix(staticRouteEntity.getPrefix()) .createdAt(Optional.ofNullable(staticRouteEntity.getCreatedDate()).orElseGet(() -> Instant.now())) .modifiedAt(Optional.ofNullable(staticRouteEntity.getModifiedDate()).orElseGet(() -> Instant.now())) .build(); } @Override StaticRoute convert(StaticRouteEntity staticRouteEntity); }### Answer:
@Test public void convert() { StaticRouteEntityConverter converter = new StaticRouteEntityConverter(); StaticRoute route = StaticRoute.builder() .routePrefix(InterledgerAddressPrefix.of("g.example")) .nextHopAccountId(AccountId.of("foo")) .build(); StaticRouteEntity entity = new StaticRouteEntity(route); StaticRoute converted = converter.convert(entity); assertThat(converted).extracting("routePrefix", "nextHopAccountId") .containsExactly(route.routePrefix(), route.nextHopAccountId()); assertThat(converted).isEqualTo(route); assertThat(entity).isEqualTo(new StaticRouteEntity(converted)); } |
### Question:
AccountBalanceSettingsEntityConverter implements
Converter<AccountBalanceSettingsEntity, AccountBalanceSettings> { @Override public AccountBalanceSettings convert(final AccountBalanceSettingsEntity accountSettingsEntity) { Objects.requireNonNull(accountSettingsEntity); return AccountBalanceSettings.builder() .settleTo(accountSettingsEntity.getSettleTo()) .settleThreshold(accountSettingsEntity.getSettleThreshold()) .minBalance(accountSettingsEntity.getMinBalance()) .build(); } @Override AccountBalanceSettings convert(final AccountBalanceSettingsEntity accountSettingsEntity); }### Answer:
@Test public void convert() { final AccountBalanceSettings accountBalanceSettings = AccountBalanceSettings.builder() .settleThreshold(100L) .settleTo(1L) .minBalance(50L) .build(); final AccountBalanceSettingsEntity entity = new AccountBalanceSettingsEntity(accountBalanceSettings); final AccountBalanceSettings actual = converter.convert(entity); assertThat(actual.settleThreshold()).isEqualTo(accountBalanceSettings.settleThreshold()); assertThat(actual.settleTo()).isEqualTo(accountBalanceSettings.settleTo()); assertThat(actual.minBalance()).isEqualTo(accountBalanceSettings.minBalance()); } |
### Question:
RateLimitSettingsEntityConverter implements Converter<AccountRateLimitSettingsEntity, AccountRateLimitSettings> { @Override public AccountRateLimitSettings convert(final AccountRateLimitSettingsEntity entity) { return AccountRateLimitSettings.builder() .maxPacketsPerSecond(entity.getMaxPacketsPerSecond()) .build(); } @Override AccountRateLimitSettings convert(final AccountRateLimitSettingsEntity entity); }### Answer:
@Test public void convert() { final AccountRateLimitSettings rateLimitSettings = AccountRateLimitSettings.builder() .maxPacketsPerSecond(2) .build(); final AccountRateLimitSettingsEntity entity = new AccountRateLimitSettingsEntity(rateLimitSettings); AccountRateLimitSettings actual = converter.convert(entity); assertThat(actual.maxPacketsPerSecond()).isEqualTo(rateLimitSettings.maxPacketsPerSecond()); } |
### Question:
FxRateOverridesEntityConverter implements Converter<FxRateOverrideEntity, FxRateOverride> { @Override public FxRateOverride convert(FxRateOverrideEntity rateOverrideEntity) { Objects.requireNonNull(rateOverrideEntity); return FxRateOverride.builder() .id(rateOverrideEntity.getId()) .assetCodeFrom(rateOverrideEntity.getAssetCodeFrom()) .assetCodeTo(rateOverrideEntity.getAssetCodeTo()) .rate(rateOverrideEntity.getRate()) .createdAt(Optional.ofNullable(rateOverrideEntity.getCreatedDate()).orElseGet(() -> Instant.now())) .modifiedAt(Optional.ofNullable(rateOverrideEntity.getModifiedDate()).orElseGet(() -> Instant.now())) .build(); } @Override FxRateOverride convert(FxRateOverrideEntity rateOverrideEntity); }### Answer:
@Test public void convert() { FxRateOverridesEntityConverter converter = new FxRateOverridesEntityConverter(); FxRateOverride dto = FxRateOverride.builder() .id(1l) .rate(BigDecimal.ONE) .assetCodeTo("DAVEANDBUSTERS") .assetCodeFrom("CHUCKIECHEESE") .build(); FxRateOverrideEntity entity = new FxRateOverrideEntity(dto); FxRateOverride convertedDto = converter.convert(entity); assertThat(convertedDto).extracting("id", "rate", "assetCodeTo", "assetCodeFrom") .containsExactly(dto.id(), dto.rate(), dto.assetCodeTo(), dto.assetCodeFrom()); assertThat(convertedDto).isEqualTo(dto); assertThat(new FxRateOverrideEntity(convertedDto)).isEqualTo(entity); } |
### Question:
SettlementEngineDetailsEntityConverter implements
Converter<SettlementEngineDetailsEntity, SettlementEngineDetails> { @Override public SettlementEngineDetails convert(final SettlementEngineDetailsEntity settlementEngineDetailsEntity) { Objects.requireNonNull(settlementEngineDetailsEntity); return SettlementEngineDetails.builder() .settlementEngineAccountId( SettlementEngineAccountId.of(settlementEngineDetailsEntity.getSettlementEngineAccountId()) ) .baseUrl(HttpUrl.parse(settlementEngineDetailsEntity.getBaseUrl())) .customSettings(settlementEngineDetailsEntity.getCustomSettings()) .build(); } @Override SettlementEngineDetails convert(final SettlementEngineDetailsEntity settlementEngineDetailsEntity); }### Answer:
@Test public void convert() { final SettlementEngineDetails settlementEngineDetails = SettlementEngineDetails.builder() .baseUrl(HttpUrl.parse("https: .settlementEngineAccountId(SettlementEngineAccountId.of(UUID.randomUUID().toString())) .putCustomSettings("xrpAddress", "rsWs4m35EJctu7Go3FydVwQeGdMQX96XLH") .build(); final SettlementEngineDetailsEntity entity = new SettlementEngineDetailsEntity(settlementEngineDetails); SettlementEngineDetails actual = converter.convert(entity); assertThat(actual.baseUrl()).isEqualTo(settlementEngineDetails.baseUrl()); assertThat(actual.settlementEngineAccountId()).isEqualTo(settlementEngineDetails.settlementEngineAccountId()); assertThat(actual.customSettings().get("xrpAddress")).isEqualTo("rsWs4m35EJctu7Go3FydVwQeGdMQX96XLH"); } |
### Question:
InMemoryForwardingRoutingTable extends InMemoryRoutingTable<RouteUpdate> implements
ForwardingRoutingTable<RouteUpdate> { @Override public void clearRouteInLogAtEpoch(final int epoch) { this.routeUpdateLog.put(epoch, null); } InMemoryForwardingRoutingTable(); @Override RoutingTableId getRoutingTableId(); @Override int getCurrentEpoch(); @Override List<InterledgerAddressPrefix> getKeysStartingWith(InterledgerAddressPrefix addressPrefix); @Override Iterable<RouteUpdate> getPartialRouteLog(final int numberToSkip, final int limit); @Override void clearRouteInLogAtEpoch(final int epoch); @Override void setEpochValue(final int epoch, final RouteUpdate routeUpdate); }### Answer:
@Test public void clearRouteInLogAtEpoch() { assertThat(routingTable.getCurrentEpoch()).isEqualTo(0); routingTable.setEpochValue(1, createRouteUpdate(1, BOB_ACCT, BOB_PREFIX)); assertThat(routingTable.getCurrentEpoch()).isEqualTo(1); ImmutableRouteUpdate aliceRouteUpdate = createRouteUpdate(1, ALICE_ACCT, ALICE_PREFIX); routingTable.setEpochValue(2, aliceRouteUpdate); routingTable.clearRouteInLogAtEpoch(1); assertThat(routingTable.getPartialRouteLog(0, 10)).hasSize(2) .containsExactlyInAnyOrder(null, aliceRouteUpdate); } |
### Question:
InMemoryForwardingRoutingTable extends InMemoryRoutingTable<RouteUpdate> implements
ForwardingRoutingTable<RouteUpdate> { @Override public void setEpochValue(final int epoch, final RouteUpdate routeUpdate) { Objects.requireNonNull(routeUpdate); this.routeUpdateLog.put(epoch, routeUpdate); if (epoch != getCurrentEpoch() + 1) { logger.warn("Specified epoch is not 1 greater than current. epoch={}, currentEpoch={}", epoch, getCurrentEpoch()); } this.currentEpoch.set(epoch); } InMemoryForwardingRoutingTable(); @Override RoutingTableId getRoutingTableId(); @Override int getCurrentEpoch(); @Override List<InterledgerAddressPrefix> getKeysStartingWith(InterledgerAddressPrefix addressPrefix); @Override Iterable<RouteUpdate> getPartialRouteLog(final int numberToSkip, final int limit); @Override void clearRouteInLogAtEpoch(final int epoch); @Override void setEpochValue(final int epoch, final RouteUpdate routeUpdate); }### Answer:
@Test public void setEpochValue() { assertThat(routingTable.getCurrentEpoch()).isEqualTo(0); routingTable.setEpochValue(1, createRouteUpdate(1, BOB_ACCT, BOB_PREFIX)); assertThat(routingTable.getCurrentEpoch()).isEqualTo(1); routingTable.setEpochValue(2, createRouteUpdate(1, ALICE_ACCT, ALICE_PREFIX)); assertThat(routingTable.getCurrentEpoch()).isEqualTo(2); } |
### Question:
DelegatingEncryptionService implements EncryptionService { @Override public EncryptedSecret encrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] plainText) { return getDelegate(keyMetadata).encrypt(keyMetadata, encryptionAlgorithm, plainText); } DelegatingEncryptionService(final Set<EncryptionService> encryptionServices); @Override KeyStoreType keyStoreType(); @Override byte[] decrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] cipherMessage); @Override EncryptedSecret encrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] plainText); @Override T withDecrypted(EncryptedSecret encryptedSecret, Function<byte[], T> callable); }### Answer:
@Test public void encrypt() { DelegatingEncryptionService service = new DelegatingEncryptionService(Sets.newHashSet(mockGcp, mockJks)); assertThat(service.encrypt(GCP_SECRET.keyMetadata(), GCP_SECRET.encryptionAlgorithm(), GCP_DECRYPTED)) .isEqualTo(GCP_SECRET); assertThat(service.encrypt(JKS_SECRET.keyMetadata(), JKS_SECRET.encryptionAlgorithm(), JKS_DECRYPTED)) .isEqualTo(JKS_SECRET); }
@Test public void encryptThrowsExceptionIfNoProvider() { DelegatingEncryptionService service = new DelegatingEncryptionService(Sets.newHashSet(mockJks)); expectedException.expect(RuntimeException.class); service.encrypt(GCP_SECRET.keyMetadata(), GCP_SECRET.encryptionAlgorithm(), GCP_DECRYPTED); } |
### Question:
InMemoryForwardingRoutingTable extends InMemoryRoutingTable<RouteUpdate> implements
ForwardingRoutingTable<RouteUpdate> { @Override public Iterable<RouteUpdate> getPartialRouteLog(final int numberToSkip, final int limit) { return Iterables.limit(Iterables.skip(this.routeUpdateLog.values(), numberToSkip), limit); } InMemoryForwardingRoutingTable(); @Override RoutingTableId getRoutingTableId(); @Override int getCurrentEpoch(); @Override List<InterledgerAddressPrefix> getKeysStartingWith(InterledgerAddressPrefix addressPrefix); @Override Iterable<RouteUpdate> getPartialRouteLog(final int numberToSkip, final int limit); @Override void clearRouteInLogAtEpoch(final int epoch); @Override void setEpochValue(final int epoch, final RouteUpdate routeUpdate); }### Answer:
@Test public void getPartialRouteLog() { ImmutableRouteUpdate bobRouteUpdate = createRouteUpdate(1, BOB_ACCT, BOB_PREFIX); ImmutableRouteUpdate aliceRouteUpdate = createRouteUpdate(1, ALICE_ACCT, ALICE_PREFIX); routingTable.setEpochValue(1, bobRouteUpdate); routingTable.setEpochValue(2, aliceRouteUpdate); assertThat(routingTable.getPartialRouteLog(0, 10)).hasSize(2) .containsExactlyInAnyOrder(bobRouteUpdate, aliceRouteUpdate); assertThat(routingTable.getPartialRouteLog(1, 10)).hasSize(1) .containsExactlyInAnyOrder(aliceRouteUpdate); assertThat(routingTable.getPartialRouteLog(2, 10)).isEmpty(); } |
### Question:
DefaultRouteBroadcaster implements RouteBroadcaster { @Override public Optional<RoutableAccount> getCcpEnabledAccount(final AccountId accountId) { Objects.requireNonNull(accountId); return Optional.ofNullable(this.ccpEnabledAccounts.get(accountId)); } DefaultRouteBroadcaster(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final CodecContext ccpCodecContext,
final ForwardingRoutingTable<RouteUpdate> outgoingRoutingTable,
final AccountSettingsRepository accountSettingsRepository,
final LinkManager linkManager,
final ExecutorService executorService
); @Override Optional<RoutableAccount> registerCcpEnabledAccount(final AccountId accountId); @Override Optional<RoutableAccount> registerCcpEnabledAccount(final AccountSettings accountSettings); @Override Optional<RoutableAccount> getCcpEnabledAccount(final AccountId accountId); @Override Stream<RoutableAccount> getAllCcpEnabledAccounts(); }### Answer:
@Test public void getCcpEnabledAccount() { assertThat(defaultRouteBroadcaster.getCcpEnabledAccount(ACCOUNT_ID_1)).isEmpty(); Optional<RoutableAccount> optRoutableAccount = defaultRouteBroadcaster.registerCcpEnabledAccount(ACCOUNT_ID_1); assertThat(optRoutableAccount).isNotEmpty(); assertThat(defaultRouteBroadcaster.getCcpEnabledAccount(ACCOUNT_ID_1)).isEqualTo(optRoutableAccount); } |
### Question:
DefaultRouteBroadcaster implements RouteBroadcaster { @Override public Stream<RoutableAccount> getAllCcpEnabledAccounts() { return this.ccpEnabledAccounts.values().stream(); } DefaultRouteBroadcaster(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final CodecContext ccpCodecContext,
final ForwardingRoutingTable<RouteUpdate> outgoingRoutingTable,
final AccountSettingsRepository accountSettingsRepository,
final LinkManager linkManager,
final ExecutorService executorService
); @Override Optional<RoutableAccount> registerCcpEnabledAccount(final AccountId accountId); @Override Optional<RoutableAccount> registerCcpEnabledAccount(final AccountSettings accountSettings); @Override Optional<RoutableAccount> getCcpEnabledAccount(final AccountId accountId); @Override Stream<RoutableAccount> getAllCcpEnabledAccounts(); }### Answer:
@Test public void getAllCcpEnabledAccounts() { assertThat(defaultRouteBroadcaster.getAllCcpEnabledAccounts()).isEmpty(); defaultRouteBroadcaster.registerCcpEnabledAccount(ACCOUNT_ID_1); assertThat(defaultRouteBroadcaster.getAllCcpEnabledAccounts()).hasSize(1); defaultRouteBroadcaster.registerCcpEnabledAccount(ACCOUNT_ID_2); assertThat(defaultRouteBroadcaster.getAllCcpEnabledAccounts()).hasSize(2); defaultRouteBroadcaster.removeAccount(ACCOUNT_ID_1); assertThat(defaultRouteBroadcaster.getCcpEnabledAccount(ACCOUNT_ID_1)).isEmpty(); assertThat(defaultRouteBroadcaster.getCcpEnabledAccount(ACCOUNT_ID_2)).isNotEmpty(); assertThat(defaultRouteBroadcaster.getAllCcpEnabledAccounts()).hasSize(1); defaultRouteBroadcaster.removeAccount(ACCOUNT_ID_2); assertThat(defaultRouteBroadcaster.getCcpEnabledAccount(ACCOUNT_ID_1)).isEmpty(); assertThat(defaultRouteBroadcaster.getCcpEnabledAccount(ACCOUNT_ID_2)).isEmpty(); assertThat(defaultRouteBroadcaster.getAllCcpEnabledAccounts()).isEmpty(); } |
### Question:
InterledgerAddressPrefixMap { public R putEntry(final InterledgerAddressPrefix addressPrefix, final R entry) { Objects.requireNonNull(entry); synchronized (prefixMap) { return prefixMap.put(toTrieKey(addressPrefix), entry); } } InterledgerAddressPrefixMap(); int getNumKeys(); R putEntry(final InterledgerAddressPrefix addressPrefix, final R entry); Optional<R> removeEntry(final InterledgerAddressPrefix addressPrefix); void reset(); Optional<R> getEntry(final InterledgerAddressPrefix addressPrefix); Set<InterledgerAddressPrefix> getKeys(); void forEach(final BiConsumer<? super InterledgerAddressPrefix, R> action); Optional<R> findNextHop(final InterledgerAddress finalDestinationAddress); }### Answer:
@Test(expected = NullPointerException.class) public void testAddRoutingTableEntryNull() { try { prefixMap.putEntry(null, null); } catch (NullPointerException npe) { assertThat(npe.getMessage()).isNull(); throw npe; } } |
### Question:
DelegatingEncryptionService implements EncryptionService { @Override public <T> T withDecrypted(EncryptedSecret encryptedSecret, Function<byte[], T> callable) { return getDelegate(encryptedSecret.keyMetadata()).withDecrypted(encryptedSecret, callable); } DelegatingEncryptionService(final Set<EncryptionService> encryptionServices); @Override KeyStoreType keyStoreType(); @Override byte[] decrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] cipherMessage); @Override EncryptedSecret encrypt(KeyMetadata keyMetadata, EncryptionAlgorithm encryptionAlgorithm, byte[] plainText); @Override T withDecrypted(EncryptedSecret encryptedSecret, Function<byte[], T> callable); }### Answer:
@Test public void withDecrypted() { DelegatingEncryptionService service = new DelegatingEncryptionService(Sets.newHashSet(mockGcp, mockJks)); assertThat(service.withDecrypted(GCP_SECRET, regurgitate)).isEqualTo(GCP_DECRYPTED); assertThat(service.withDecrypted(JKS_SECRET,regurgitate)).isEqualTo(JKS_DECRYPTED); }
@Test public void withDecryptedThrowsExceptionIfNoProvider() { DelegatingEncryptionService service = new DelegatingEncryptionService(Sets.newHashSet(mockJks)); expectedException.expect(RuntimeException.class); service.withDecrypted(GCP_SECRET, regurgitate); } |
### Question:
InterledgerAddressPrefixMap { public Optional<R> getEntry(final InterledgerAddressPrefix addressPrefix) { Objects.requireNonNull(addressPrefix, "addressPrefix must not be null!"); return Optional.ofNullable(this.prefixMap.get(toTrieKey(addressPrefix))); } InterledgerAddressPrefixMap(); int getNumKeys(); R putEntry(final InterledgerAddressPrefix addressPrefix, final R entry); Optional<R> removeEntry(final InterledgerAddressPrefix addressPrefix); void reset(); Optional<R> getEntry(final InterledgerAddressPrefix addressPrefix); Set<InterledgerAddressPrefix> getKeys(); void forEach(final BiConsumer<? super InterledgerAddressPrefix, R> action); Optional<R> findNextHop(final InterledgerAddress finalDestinationAddress); }### Answer:
@Test(expected = NullPointerException.class) public void testGetRoutingTableEntryNull() { try { prefixMap.getEntry(null); } catch (NullPointerException npe) { assertThat(npe.getMessage()).isEqualTo("addressPrefix must not be null!"); throw npe; } } |
### Question:
InterledgerAddressPrefixMap { public void forEach(final BiConsumer<? super InterledgerAddressPrefix, R> action) { Objects.requireNonNull(action); final BiConsumer<String, R> translatedAction = (ilpPrefixAsString, entry) -> { final String strippedPrefix; if (ilpPrefixAsString.endsWith(".")) { strippedPrefix = ilpPrefixAsString.substring(0, ilpPrefixAsString.length() - 1); } else { strippedPrefix = ilpPrefixAsString; } action.accept(InterledgerAddressPrefix.of(strippedPrefix), entry); }; prefixMap.forEach(translatedAction); } InterledgerAddressPrefixMap(); int getNumKeys(); R putEntry(final InterledgerAddressPrefix addressPrefix, final R entry); Optional<R> removeEntry(final InterledgerAddressPrefix addressPrefix); void reset(); Optional<R> getEntry(final InterledgerAddressPrefix addressPrefix); Set<InterledgerAddressPrefix> getKeys(); void forEach(final BiConsumer<? super InterledgerAddressPrefix, R> action); Optional<R> findNextHop(final InterledgerAddress finalDestinationAddress); }### Answer:
@Test public void testForEach() { final Route globalRoutingTableEntry = ImmutableRoute.builder() .routePrefix(DEFAULT_TARGET_ADDRESS_PREFIX) .nextHopAccountId(DEFAULT_CONNECTOR_ACCOUNT) .build(); prefixMap.putEntry(globalRoutingTableEntry.routePrefix(), globalRoutingTableEntry); final Route globalRoutingTableEntry2 = ImmutableRoute.builder() .routePrefix(DEFAULT_TARGET_ADDRESS_PREFIX.with("foo")) .nextHopAccountId(DEFAULT_CONNECTOR_ACCOUNT) .build(); prefixMap.putEntry(globalRoutingTableEntry2.routePrefix(), globalRoutingTableEntry2); final AtomicInteger atomicInteger = new AtomicInteger(); prefixMap.forEach((targetAddress, routingTableEntry) -> atomicInteger.getAndIncrement()); assertThat(atomicInteger.get()).isEqualTo(2); } |
### Question:
InterledgerAddressPrefixMap { public Set<InterledgerAddressPrefix> getKeys() { return this.prefixMap.keySet().stream() .map(this::stripTrailingDot) .map(InterledgerAddressPrefix::of) .collect(Collectors.toSet()); } InterledgerAddressPrefixMap(); int getNumKeys(); R putEntry(final InterledgerAddressPrefix addressPrefix, final R entry); Optional<R> removeEntry(final InterledgerAddressPrefix addressPrefix); void reset(); Optional<R> getEntry(final InterledgerAddressPrefix addressPrefix); Set<InterledgerAddressPrefix> getKeys(); void forEach(final BiConsumer<? super InterledgerAddressPrefix, R> action); Optional<R> findNextHop(final InterledgerAddress finalDestinationAddress); }### Answer:
@Test public void testGetPrefixMapKeys() { this.prefixMap = this.constructPopulatedPrefixMap(); assertThat(this.prefixMap.getKeys().size()).isEqualTo(5); } |
### Question:
InMemoryRoutingTable implements RoutingTable<R> { @Override public R addRoute(final R route) { Objects.requireNonNull(route); return this.interledgerAddressPrefixMap.putEntry(route.routePrefix(), route); } InMemoryRoutingTable(); InMemoryRoutingTable(final InterledgerAddressPrefixMap interledgerAddressPrefixMap); @Override R addRoute(final R route); @Override Optional<R> removeRoute(final InterledgerAddressPrefix addressPrefix); @Override Optional<R> getRouteByPrefix(final InterledgerAddressPrefix addressPrefix); @Override Iterable<InterledgerAddressPrefix> getAllPrefixes(); @Override void forEach(final BiConsumer<InterledgerAddressPrefix, R> action); @Override Optional<R> findNextHopRoute(final InterledgerAddress interledgerAddress); @Override void reset(); }### Answer:
@Test(expected = NullPointerException.class) public void testAddRouteNull() { try { this.routingTable.addRoute(null); } catch (NullPointerException e) { throw e; } }
@Test public void testAddRoute() { final Route route = this.constructTestRoute(GLOBAL_PREFIX); this.routingTable.addRoute(route); verify(interledgerPrefixMapMock).putEntry(route.routePrefix(), route); verifyNoMoreInteractions(interledgerPrefixMapMock); } |
### Question:
AttractionCollection { public int getHeaderTitle() { return headerTitle; } AttractionCollection(int headerTextResId, List<Attraction> listOfAttractions); int getHeaderTitle(); List<Attraction> getAttractions(); }### Answer:
@Test public void saveResIdAsHeaderTitle() { assertThat(subject.getHeaderTitle(), is(TEST_HEADER)); } |
### Question:
AttractionCollection { public List<Attraction> getAttractions() { return listOfAttractions; } AttractionCollection(int headerTextResId, List<Attraction> listOfAttractions); int getHeaderTitle(); List<Attraction> getAttractions(); }### Answer:
@Test public void savesAttractionType_getAttractions() { assertThat(subject.getAttractions().get(0), isA(Attraction.class)); }
@Test public void returnsAList_getAttractions() { assertThat(subject.getAttractions(), instanceOf(List.class)); } |
### Question:
Attraction implements Parcelable { public int getImageResourceId() { return imageResourceId; } Attraction(int imageResourceId, int titleTextResId, int shortDescTextResId,
int longDescTextResId, int mapQueryStrId); protected Attraction(Parcel in); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); int getImageResourceId(); int getTitle(); int getShortDesc(); int getLongDesc(); int getMapQueryStrId(); static final Creator<Attraction> CREATOR; }### Answer:
@Test public void storesResIdForImage() { assertThat(subject.getImageResourceId(), is(TEST_IMAGE)); } |
### Question:
Attraction implements Parcelable { public int getTitle() { return titleTextResId; } Attraction(int imageResourceId, int titleTextResId, int shortDescTextResId,
int longDescTextResId, int mapQueryStrId); protected Attraction(Parcel in); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); int getImageResourceId(); int getTitle(); int getShortDesc(); int getLongDesc(); int getMapQueryStrId(); static final Creator<Attraction> CREATOR; }### Answer:
@Test public void storesResIdAsTitle() { assertThat(subject.getTitle(), is(TEST_TITLE)); } |
### Question:
Attraction implements Parcelable { public int getShortDesc() { return shortDescTextResId; } Attraction(int imageResourceId, int titleTextResId, int shortDescTextResId,
int longDescTextResId, int mapQueryStrId); protected Attraction(Parcel in); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); int getImageResourceId(); int getTitle(); int getShortDesc(); int getLongDesc(); int getMapQueryStrId(); static final Creator<Attraction> CREATOR; }### Answer:
@Test public void storesResIdAsShortDesc() { assertThat(subject.getShortDesc(), is(TEST_SHORT_DESC)); } |
### Question:
Attraction implements Parcelable { public int getLongDesc() { return longDescTextResId; } Attraction(int imageResourceId, int titleTextResId, int shortDescTextResId,
int longDescTextResId, int mapQueryStrId); protected Attraction(Parcel in); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); int getImageResourceId(); int getTitle(); int getShortDesc(); int getLongDesc(); int getMapQueryStrId(); static final Creator<Attraction> CREATOR; }### Answer:
@Test public void storesResIdAsLongDesc() { assertThat(subject.getLongDesc(), is(TEST_LONG_DESC)); } |
### Question:
AttractionRepository { @VisibleForTesting static AttractionCollection buildBreweriesCollection() { ArrayList<Attraction> attractions = new ArrayList<>(); attractions.add(new Attraction( R.drawable.new_belgium, R.string.new_belgium_title, R.string.new_belgium_free_tours, R.string.new_belgium_detailed_desc, R.string.mq_new_belgium ) ); attractions.add(new Attraction( R.drawable.odell_brewing, R.string.odell_brewing_title, R.string.odell_microbrew, R.string.odell_brewing_detailed_desc, R.string.mq_odell_brewing ) ); attractions.add(new Attraction( R.drawable.anheuser_busch, R.string.anheuser_busch_title, R.string.grand_tour, R.string.anheuser_busch_detailed_desc, R.string.mq_anheuser_busch ) ); attractions.add(new Attraction( R.drawable.coopersmith_brewing, R.string.coopersmith_title, R.string.coopersmith_mixed_desc, R.string.coopersmith_detailed_desc, R.string.mq_coopersmith ) ); return new AttractionCollection(R.string.top_breweries, attractions); } private AttractionRepository(Context context); static AttractionRepository getInstance(Context packageContext); AttractionCollection getCollection(int sectionTitle); List<AttractionCollection> getCollections(); }### Answer:
@Test public void saveAsAttractionCollection_buildBreweriesCollection() { assertThat(AttractionRepository.buildBreweriesCollection(), instanceOf(AttractionCollection.class)); } |
### Question:
ToDoController { @RequestMapping(value = "/", method = RequestMethod.GET, produces = "text/html") public String dashboard() { return "dashboard"; } @RequestMapping(value = "/", method = RequestMethod.GET, produces = "text/html") String dashboard(); @RequestMapping(value = "/todo/listdata", method = RequestMethod.GET, produces = "application/json") @ResponseBody Page<ToDo> listData(Pageable pageable, Authentication authentication); static Predicate constructPredicate(ToDoShareAccount toDoShareAccount); @RequestMapping(value = "/todo/list", method = RequestMethod.GET, produces = "text/html") String list(Model model, Authentication authentication); @RequestMapping(value = "/todo/{toDoId}", method = RequestMethod.GET, produces = "text/html") String edit(@PathVariable("toDoId") @ModelAttribute("toDoForm") ToDoForm toDoForm, Model model); @RequestMapping(value = "/todo/{toDoId}", method = RequestMethod.PUT, produces = "text/html") String update(@Valid ToDoForm toDoForm, BindingResult bindingResult, Authentication authentication, ModelMap model, RedirectAttributes redirectAttributes); @RequestMapping(value = "/todo/", method = RequestMethod.POST, produces = "text/html") String save(@Valid ToDoForm toDoForm, BindingResult bindingResult, Authentication authentication, ModelMap model, RedirectAttributes redirectAttributes); @RequestMapping(value = "/todo/{toDoId}", method = RequestMethod.DELETE, produces = "text/html") String delete(@PathVariable("toDoId") @ModelAttribute("toDoForm") ToDoForm toDoForm, RedirectAttributes redirectAttributes); }### Answer:
@Test public void testDashboard() throws Exception { mockMvc.perform(get("/")) .andExpect(status().isOk()) .andExpect(view().name("dashboard")); } |
### Question:
ProfileController { @RequestMapping(value = "/profile", method = RequestMethod.GET, produces = "text/html") public String showProfile() { return "profile"; } @RequestMapping(value = "/profile", method = RequestMethod.GET, produces = "text/html") String showProfile(); }### Answer:
@Test public void testShowProfile() throws Exception { mockMvc.perform(get("/profile")) .andExpect(status().isOk()); } |
### Question:
TracingKafkaUtils { public static void inject(SpanContext spanContext, Headers headers, Tracer tracer) { tracer.inject(spanContext, Format.Builtin.TEXT_MAP, new HeadersMapInjectAdapter(headers)); } static SpanContext extractSpanContext(Headers headers, Tracer tracer); static void inject(SpanContext spanContext, Headers headers,
Tracer tracer); static Span buildAndInjectSpan(ProducerRecord<K, V> record, Tracer tracer); static Span buildAndInjectSpan(ProducerRecord<K, V> record, Tracer tracer,
BiFunction<String, ProducerRecord, String> producerSpanNameProvider,
SpanContext parent); static Span buildAndInjectSpan(ProducerRecord<K, V> record, Tracer tracer,
BiFunction<String, ProducerRecord, String> producerSpanNameProvider,
SpanContext parent, Collection<SpanDecorator> spanDecorators); static void buildAndFinishChildSpan(ConsumerRecord<K, V> record, Tracer tracer); static void buildAndFinishChildSpan(ConsumerRecord<K, V> record, Tracer tracer,
BiFunction<String, ConsumerRecord, String> consumerSpanNameProvider); static void buildAndFinishChildSpan(ConsumerRecord<K, V> record, Tracer tracer,
BiFunction<String, ConsumerRecord, String> consumerSpanNameProvider,
Collection<SpanDecorator> spanDecorators); static final String TO_PREFIX; static final String FROM_PREFIX; }### Answer:
@Test public void inject() { MockSpan span = mockTracer.buildSpan("test").start(); Headers headers = new RecordHeaders(); assertEquals(0, headers.toArray().length); TracingKafkaUtils.inject(span.context(), headers, mockTracer); assertTrue(headers.toArray().length > 0); } |
### Question:
TracingKafkaUtils { public static SpanContext extractSpanContext(Headers headers, Tracer tracer) { return tracer .extract(Format.Builtin.TEXT_MAP, new HeadersMapExtractAdapter(headers)); } static SpanContext extractSpanContext(Headers headers, Tracer tracer); static void inject(SpanContext spanContext, Headers headers,
Tracer tracer); static Span buildAndInjectSpan(ProducerRecord<K, V> record, Tracer tracer); static Span buildAndInjectSpan(ProducerRecord<K, V> record, Tracer tracer,
BiFunction<String, ProducerRecord, String> producerSpanNameProvider,
SpanContext parent); static Span buildAndInjectSpan(ProducerRecord<K, V> record, Tracer tracer,
BiFunction<String, ProducerRecord, String> producerSpanNameProvider,
SpanContext parent, Collection<SpanDecorator> spanDecorators); static void buildAndFinishChildSpan(ConsumerRecord<K, V> record, Tracer tracer); static void buildAndFinishChildSpan(ConsumerRecord<K, V> record, Tracer tracer,
BiFunction<String, ConsumerRecord, String> consumerSpanNameProvider); static void buildAndFinishChildSpan(ConsumerRecord<K, V> record, Tracer tracer,
BiFunction<String, ConsumerRecord, String> consumerSpanNameProvider,
Collection<SpanDecorator> spanDecorators); static final String TO_PREFIX; static final String FROM_PREFIX; }### Answer:
@Test public void extract_no_context() { Headers headers = new RecordHeaders(); MockSpan.MockContext spanContext = (MockSpan.MockContext) TracingKafkaUtils .extractSpanContext(headers, mockTracer); assertNull(spanContext); } |
### Question:
HeadersMapExtractAdapter implements TextMap { @Override public Iterator<Entry<String, String>> iterator() { return map.entrySet().iterator(); } HeadersMapExtractAdapter(Headers headers); @Override Iterator<Entry<String, String>> iterator(); @Override void put(String key, String value); }### Answer:
@Test public void verifyNullHeaderHandled() { Headers headers = new RecordHeaders(); headers.add("test_null_header", null); HeadersMapExtractAdapter headersMapExtractAdapter = new HeadersMapExtractAdapter(headers); Entry<String, String> header = headersMapExtractAdapter.iterator().next(); assertNotNull(header); assertEquals(header.getKey(), "test_null_header"); assertNull(header.getValue()); } |
### Question:
RateThisApp { @Deprecated public static void onStart(Context context) { onCreate(context); } static void init(Config config); static void setCallback(Callback callback); static void onCreate(Context context); @Deprecated static void onStart(Context context); static boolean showRateDialogIfNeeded(final Context context); static boolean showRateDialogIfNeeded(final Context context, int themeId); static boolean shouldShowRateDialog(); static void showRateDialog(final Context context); static void showRateDialog(final Context context, int themeId); static void stopRateDialog(final Context context); static int getLaunchCount(final Context context); static final boolean DEBUG; }### Answer:
@Test public void onStart_isSuccess() { Context context = RuntimeEnvironment.application.getApplicationContext(); RateThisApp.onStart(context); SharedPreferences sharedPreferences = RuntimeEnvironment.application.getSharedPreferences( PREF_NAME, Context.MODE_PRIVATE); long expectedInstallDate = 0L; PackageManager packMan = context.getPackageManager(); try { PackageInfo pkgInfo = packMan.getPackageInfo(context.getPackageName(), 0); expectedInstallDate = new Date(pkgInfo.firstInstallTime).getTime(); } catch (PackageManager.NameNotFoundException e) { e.printStackTrace(); } Assert.assertEquals(expectedInstallDate, sharedPreferences.getLong(KEY_INSTALL_DATE, 0L)); Assert.assertEquals(1, sharedPreferences.getInt(KEY_LAUNCH_TIMES, 0)); } |
### Question:
RateThisApp { public static void stopRateDialog(final Context context){ setOptOut(context, true); } static void init(Config config); static void setCallback(Callback callback); static void onCreate(Context context); @Deprecated static void onStart(Context context); static boolean showRateDialogIfNeeded(final Context context); static boolean showRateDialogIfNeeded(final Context context, int themeId); static boolean shouldShowRateDialog(); static void showRateDialog(final Context context); static void showRateDialog(final Context context, int themeId); static void stopRateDialog(final Context context); static int getLaunchCount(final Context context); static final boolean DEBUG; }### Answer:
@Test public void stopRateDialog_IsSuccess() { Context context = RuntimeEnvironment.application.getApplicationContext(); RateThisApp.stopRateDialog(context); SharedPreferences sharedPreferences = RuntimeEnvironment.application.getSharedPreferences( PREF_NAME, Context.MODE_PRIVATE); Assert.assertTrue(sharedPreferences.getBoolean(KEY_OPT_OUT, false)); } |
### Question:
DateTrigger implements Trigger { @Override public Date nextExecutionTime(TriggerContext triggerContext) { Date result = null; if (nextFireDates.size() > 0) { try { result = nextFireDates.remove(0); } catch (IndexOutOfBoundsException e) { logger.debug(e.getMessage()); } } return result; } DateTrigger(Date... dates); @Override Date nextExecutionTime(TriggerContext triggerContext); }### Answer:
@Test public void testConstructor() { Date epoch = new Date(0); Calendar currentCalendar = Calendar.getInstance(); Date current = currentCalendar.getTime(); currentCalendar.add(Calendar.HOUR, -1); Date past = currentCalendar.getTime(); currentCalendar.add(Calendar.HOUR, 2); Date future = currentCalendar.getTime(); DateTrigger dateTrigger = new DateTrigger(current, epoch, future, past); Date nextExecutionTime = dateTrigger.nextExecutionTime(null); assertNotNull("Should return epoch", nextExecutionTime); assertTrue("Should be epoch", epoch.compareTo(nextExecutionTime) == 0); nextExecutionTime = dateTrigger.nextExecutionTime(null); assertNotNull("Should return past", nextExecutionTime); assertTrue("Should be past", past.compareTo(nextExecutionTime) == 0); nextExecutionTime = dateTrigger.nextExecutionTime(null); assertNotNull("Should return current", nextExecutionTime); assertTrue("Should be current", current.compareTo(nextExecutionTime) == 0); nextExecutionTime = dateTrigger.nextExecutionTime(null); assertNotNull("Should return future", nextExecutionTime); assertTrue("Should be future", future.compareTo(nextExecutionTime) == 0); nextExecutionTime = dateTrigger.nextExecutionTime(null); assertNull("All entries should have been pulled, the nextExecutionTime should have been null.", nextExecutionTime); } |
### Question:
ShellWordsParser { List<String> parse(String s) { List<String> words = new ArrayList<>(); String field = ""; Matcher matcher = SHELLWORDS.matcher(s); while (matcher.find()) { String word = matcher.group(1); String sq = matcher.group(2); String dq = matcher.group(3); String esc = matcher.group(4); String garbage = matcher.group(5); String sep = matcher.group(6); if (garbage != null) { throw new IllegalArgumentException("Unmatched double quote: " + s); } if (word != null) { field = word; } else if (sq != null) { field = sq; } else if (dq != null) { field = dq.replaceAll("\\\\(?=.)", ""); } else if (esc != null) { field = esc.replaceAll("\\\\(?=.)", ""); } if (sep != null) { words.add(field); field = ""; } } return words; } }### Answer:
@Test(expected = IllegalArgumentException.class) public void throwsExceptionWhenDoubleQuotedStringsAreMisQuoted() { this.parser.parse("a \"b c d e"); }
@Test(expected = IllegalArgumentException.class) public void throwsExceptionWhenSingleQuotedStringsAreMisQuoted() { this.parser.parse("a 'b c d e"); } |
### Question:
MappedAnalytic implements Analytic<I, O> { @Override @SuppressWarnings("unchecked") public O evaluate(I input) { Assert.notNull(input, "input"); MI modelInput = inputMapper.mapInput((A) this, input); MO modelOutput = evaluateInternal(modelInput); O output = outputMapper.mapOutput((A) this, input, modelOutput); return output; } MappedAnalytic(InputMapper<I, A, MI> inputMapper, OutputMapper<I, O, A, MO> outputMapper); @Override @SuppressWarnings("unchecked") O evaluate(I input); }### Answer:
@Test public void testEvaluateDummyMappedAnalytic() { Tuple input = TupleBuilder.tuple().of("k1", "v1", "k2", "v2"); Tuple output = analytic.evaluate(input); assertNotSame(input, output); assertThat(output.getString("k1"), is("V1")); assertThat(output.getString("k2"), is("V2")); } |
### Question:
CommonUtils { public static boolean isValidEmail(String emailAddress) { return emailAddress.matches(EMAIL_VALIDATION_REGEX); } private CommonUtils(); static String padRight(String inputString, int size, char paddingChar); static String padRight(String string, int size); static String collectionToCommaDelimitedString(Collection<String> list); static void closeReader(Reader reader); static boolean isValidEmail(String emailAddress); static String maskPassword(String password); static String getLocalTime(Date date, TimeZone timeZone); static String getTimeZoneNameWithOffset(TimeZone timeZone); static final String NOT_AVAILABLE; }### Answer:
@Test public void testValidEmailAddress() { assertTrue(CommonUtils.isValidEmail("[email protected]")); }
@Test public void testInValidEmailAddress() { assertFalse(CommonUtils.isValidEmail("test123")); } |
### Question:
CommonUtils { public static String padRight(String inputString, int size, char paddingChar) { final String stringToPad; if (inputString == null) { stringToPad = ""; } else { stringToPad = inputString; } StringBuilder padded = new StringBuilder(stringToPad); while (padded.length() < size) { padded.append(paddingChar); } return padded.toString(); } private CommonUtils(); static String padRight(String inputString, int size, char paddingChar); static String padRight(String string, int size); static String collectionToCommaDelimitedString(Collection<String> list); static void closeReader(Reader reader); static boolean isValidEmail(String emailAddress); static String maskPassword(String password); static String getLocalTime(Date date, TimeZone timeZone); static String getTimeZoneNameWithOffset(TimeZone timeZone); static final String NOT_AVAILABLE; }### Answer:
@Test public void testPadRightWithNullString() { assertEquals(" ", CommonUtils.padRight(null, 5)); }
@Test public void testPadRightWithEmptyString() { assertEquals(" ", CommonUtils.padRight("", 5)); }
@Test public void testPadRight() { assertEquals("foo ", CommonUtils.padRight("foo", 5)); } |
### Question:
CommonUtils { public static String maskPassword(String password) { int lengthOfPassword = password.length(); StringBuilder stringBuilder = new StringBuilder(lengthOfPassword); for (int i = 0; i < lengthOfPassword; i++) { stringBuilder.append('*'); } return stringBuilder.toString(); } private CommonUtils(); static String padRight(String inputString, int size, char paddingChar); static String padRight(String string, int size); static String collectionToCommaDelimitedString(Collection<String> list); static void closeReader(Reader reader); static boolean isValidEmail(String emailAddress); static String maskPassword(String password); static String getLocalTime(Date date, TimeZone timeZone); static String getTimeZoneNameWithOffset(TimeZone timeZone); static final String NOT_AVAILABLE; }### Answer:
@Test public void testMaskPassword() { assertEquals("******", CommonUtils.maskPassword("foobar")); } |
### Question:
LibreOfficeLauncherHelper { public static String getOperatingSystem(String operatingSystemIndentifier) { if ("linux".equalsIgnoreCase(operatingSystemIndentifier)) { return OS_LINUX; } if (operatingSystemIndentifier != null && operatingSystemIndentifier.toLowerCase().contains("windows")) { return OS_WINDOWS; } else if (operatingSystemIndentifier != null && operatingSystemIndentifier.toLowerCase().contains("mac os x")) { return OS_MACOSX; } else { return OS_UNSUPPORTED; } } static String getOperatingSystem(String operatingSystemIndentifier); static String generateLibreOfficeOpenUrl(String cmisUrl, String repositoryId, String filePath); static final String OS_WINDOWS; static final String OS_LINUX; static final String OS_MACOSX; static final String OS_UNSUPPORTED; }### Answer:
@Test public void testGetOperatingSystem() { assertEquals(LibreOfficeLauncherHelper.OS_LINUX, LibreOfficeLauncherHelper.getOperatingSystem("linux")); assertEquals(LibreOfficeLauncherHelper.OS_LINUX, LibreOfficeLauncherHelper.getOperatingSystem("Linux")); assertEquals(LibreOfficeLauncherHelper.OS_WINDOWS, LibreOfficeLauncherHelper.getOperatingSystem("Windows XP")); assertEquals(LibreOfficeLauncherHelper.OS_WINDOWS, LibreOfficeLauncherHelper.getOperatingSystem("windows 5.1")); assertEquals(LibreOfficeLauncherHelper.OS_MACOSX, LibreOfficeLauncherHelper.getOperatingSystem("mac os x")); assertEquals(LibreOfficeLauncherHelper.OS_MACOSX, LibreOfficeLauncherHelper.getOperatingSystem("Mac OS X")); assertEquals(LibreOfficeLauncherHelper.OS_UNSUPPORTED, LibreOfficeLauncherHelper.getOperatingSystem("Solaris")); assertEquals(LibreOfficeLauncherHelper.OS_UNSUPPORTED, LibreOfficeLauncherHelper.getOperatingSystem("")); } |
### Question:
LibreOfficeLauncherHelper { public static String generateLibreOfficeOpenUrl(String cmisUrl, String repositoryId, String filePath) throws UnsupportedEncodingException { StringBuilder openUrlSb = new StringBuilder(); openUrlSb.append(LibreOfficeLauncherHelper.LIBREOFFICE_HANDLER); openUrlSb.append(": StringBuilder cmisUrlSb = new StringBuilder(); cmisUrlSb.append(cmisUrl); cmisUrlSb.append("#"); cmisUrlSb.append(repositoryId); String urlEncodedString = URLEncoder.encode(cmisUrlSb.toString(), "UTF-8").replaceAll("\\+", "%20"); openUrlSb.append(urlEncodedString + filePath); return openUrlSb.toString(); } static String getOperatingSystem(String operatingSystemIndentifier); static String generateLibreOfficeOpenUrl(String cmisUrl, String repositoryId, String filePath); static final String OS_WINDOWS; static final String OS_LINUX; static final String OS_MACOSX; static final String OS_UNSUPPORTED; }### Answer:
@Test public void testGenerateLibreOfficeOpenUrl() throws UnsupportedEncodingException { assertEquals("vnd.libreoffice.cmis: LibreOfficeLauncherHelper.generateLibreOfficeOpenUrl("http: "/Sites/libreoffice-test/documentLibrary/Testdocument.odt")); } |
### Question:
NotificationMessage implements Serializable { public String getPayloadString(String name) { return payload.get(name) == null ? null : String.valueOf(payload.get(name)); } static String buildSubjectPrefix(String nsPath); Map<String, Object> getPayload(); String getPayloadString(String name); void putPayloadEntry(String name, Object value); void putPayloadEntries(Map<String, Object> payloadEntries); String getNsPath(); void setNsPath(String nsPath); String getSource(); void setSource(String source); long getTimestamp(); void setTimestamp(long timestamp); long getCmsId(); void setCmsId(long cmsId); NotificationSeverity getSeverity(); void setSeverity(NotificationSeverity severity); NotificationType getType(); void setType(NotificationType type); String getSubject(); void setSubject(String subject); String getTemplateName(); void setTemplateName(String templateName); String getTemplateParams(); void setTemplateParams(String templateParams); String getText(); void setText(String text); String getEnvironmentProfileName(); void setEnvironmentProfileName(String envProfile); String getAdminStatus(); void setAdminStatus(String adminStatus); long getManifestCiId(); void setManifestCiId(long manifestCiId); String getCloudName(); void setCloudName(String cloudName); void appendText(String notes); String asString(); List<CmsCISimple> getCis(); void setCis(List<CmsCISimple> cis); }### Answer:
@Test public void testGetPayloadStringForNull() { assertNull(new NotificationMessage().getPayloadString(ENTRY_NAME)); } |
### Question:
CmsCryptoDES implements CmsCrypto { public void init() throws IOException, GeneralSecurityException { Security.addProvider(new BouncyCastleProvider()); this.secretKeyFile = System.getenv("CMS_DES_PEM"); if (this.secretKeyFile == null) { this.secretKeyFile = System.getProperty("com.kloopz.crypto.cms_des_pem"); } if (this.secretKeyFile == null) { logger.error(">>>>>>>>>>>>>>Failed to init DES Encryptor/Decryptor no key faile is set, use CMS_DES_PEM env var to set location!"); throw new FileNotFoundException("Failed to init DES Encryptor/Decryptor no key faile is set, use CMS_DES_PEM env var to set location!"); } initEncryptorDecryptor(); } @Override String encrypt(String instr); @Override String decrypt(String instr); @Override String decryptVars(String instr); void init(); static void generateDESKey(String file); static void main(String[] args); void setSecretKeyFile(String secretKeyFile); void init(String secretKeyFile); }### Answer:
@Test(expectedExceptions = CmsException.class) public void badDESEnvTest() throws Exception { CmsCryptoDES crypto1 = new CmsCryptoDES(); try { crypto1.init(); } catch (FileNotFoundException e) { throw new CmsException(33, "File not found, likely a devbox, throwing CmsException"); } }
@Test(expectedExceptions = IOException.class) public void badFileTest() throws Exception { CmsCryptoDES crypto1 = new CmsCryptoDES(); crypto1.init("this-is-not-a-key-file"); } |
### Question:
CmsCryptoDES implements CmsCrypto { @Override public String decrypt(String instr) throws GeneralSecurityException { if (instr.startsWith(ENC_PREFIX)) { instr = instr.substring(ENC_PREFIX.length()); } return decryptStr(instr); } @Override String encrypt(String instr); @Override String decrypt(String instr); @Override String decryptVars(String instr); void init(); static void generateDESKey(String file); static void main(String[] args); void setSecretKeyFile(String secretKeyFile); void init(String secretKeyFile); }### Answer:
@Test(threadPoolSize = 10, invocationCount = 3, timeOut = 10000) public void testDecrypt() throws Exception { String decryptedUUID = crypto.decrypt(encryptedString); Assert.assertTrue(rawString.equals(decryptedUUID)); }
@Test public void testEmptyString() throws Exception { String decryptedText = crypto.decrypt(CmsCrypto.ENC_PREFIX); Assert.assertTrue(StringUtils.EMPTY.equals(decryptedText)); } |
### Question:
ListUtils { public <V> Map<K, V> toMap(List<V> list, String keyField) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { String accessor = convertFieldToAccessor(keyField); Map<K, V> map = new HashMap<K, V>(); for(V obj : list) { Method method = obj.getClass().getMethod(accessor); @SuppressWarnings("unchecked") K key = (K)method.invoke(obj); map.put(key, obj); } return map; } Map<K, V> toMap(List<V> list, String keyField); Map<K, List<V>> toMapOfList(List<V> list, String keyField); }### Answer:
@Test public void testList1() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { List<MyBean> listOfBeans = new ArrayList<MyBean>(LIST_SIZE); for (int i = 1; i <= LIST_SIZE; i++) { MyBean m = new MyBean(String.valueOf(i)); listOfBeans.add(m); } Map<String, MyBean> outMap = util.toMap(listOfBeans, KEY_FIELD); assertEquals(LIST_SIZE, outMap.size()); for(MyBean listMember : listOfBeans){ assertEquals(listMember, outMap.get(listMember.getSpecialValue())); } System.out.println(outMap); } |
### Question:
CapacityProcessor { public boolean isCapacityManagementEnabled(String nsPath) { CmsVar softQuotaEnabled = cmProcessor.getCmSimpleVar(CAPACITY_MANAGEMENT_VAR_NAME); if (softQuotaEnabled != null) { String value = softQuotaEnabled.getValue(); if (Boolean.TRUE.toString().equalsIgnoreCase(value)) return true; if (nsPath != null && !value.isEmpty()) { return Arrays.stream(value.split(",")).anyMatch(nsPath::startsWith); } } return false; } void setCmProcessor(CmsCmProcessor cmProcessor); void setRfcProcessor(CmsRfcProcessor rfcProcessor); void setTektonClient(TektonClient tektonClient); boolean isCapacityManagementEnabled(String nsPath); CapacityEstimate estimateCapacity(String nsPath, Collection<CmsRfcCI> cis, Collection<CmsRfcRelation> deployedToRels); void reserveCapacityForDeployment(CmsDeployment deployment); void discardCapacityForDeployment(CmsDeployment deployment); void commitCapacity(CmsWorkOrder workOrder); void releaseCapacity(CmsWorkOrder workOrder); }### Answer:
@Test public void capacityManagementEnabled() { cmsVarCapacityManagement.setValue("false"); boolean enabled = capacityProcessor.isCapacityManagementEnabled(null); assertEquals(enabled, false, "Capacity Management should be disabled when CAPACITY_MANAGEMENT=false"); cmsVarCapacityManagement.setValue("true"); enabled = capacityProcessor.isCapacityManagementEnabled(null); assertEquals(enabled, true, "Capacity Management should be enabled when CAPACITY_MANAGEMENT=true"); cmsVarCapacityManagement.setValue("/org1,/org2,/org3"); enabled = capacityProcessor.isCapacityManagementEnabled("/org2/a1/e1"); assertEquals(enabled, true, "Capacity Management should be enabled for ns included in CAPACITY_MANAGEMENT"); enabled = capacityProcessor.isCapacityManagementEnabled("/org4/a1"); assertEquals(enabled, false, "Capacity Management should be disabled for ns when not included in CAPACITY_MANAGEMENT"); } |
### Question:
SubscriberService { public List<BasicSubscriber> getSubscribersForNs(String nsPath) { try { return sinkCache.instance().get(new SinkKey(nsPath)); } catch (Exception e) { logger.error("Can't retrieve subscribers for nspath " + nsPath + " from sink cache", e); return Collections.singletonList(defaultSystemSubscriber); } } @Autowired SubscriberService(URLSubscriber defaultSystemSubscriber, SinkCache sinkCache); List<BasicSubscriber> getSubscribersForNs(String nsPath); }### Answer:
@Test public void getSubscribersForNsTest() { } |
### Question:
EmailService implements NotificationSender { @Override public boolean postMessage(NotificationMessage msg, BasicSubscriber subscriber) { EmailSubscriber esub; if (subscriber instanceof EmailSubscriber) { esub = (EmailSubscriber) subscriber; } else { throw new ClassCastException("invalid subscriber " + subscriber.getClass().getName()); } List<String> emails = new ArrayList<>(); if (esub.getEmail() != null) { emails.add(esub.getEmail()); } if (emails.size() > 0) { EmailMessage emsg = buildEMessage(msg, emails); return sendEmail(emsg); } return true; } String getAwsAccessKey(); void setAwsAccessKey(String awsAccessKey); String getAwsSecretKey(); void setAwsSecretKey(String awsSecretKey); void init(); @Override boolean postMessage(NotificationMessage msg,
BasicSubscriber subscriber); boolean sendEmail(EmailMessage eMsg); }### Answer:
@Test public void postMessage() { NotificationMessage msg = new NotificationMessage(); EmailSubscriber sub = mock(EmailSubscriber.class); when(sub.getEmail()).thenReturn(null); boolean result = this.emailService.postMessage(msg, sub); assertTrue(result); } |
### Question:
AntennaListener implements MessageListener { public void onMessage(Message msg) { msgs.mark(); Context tc = msgTime.time(); try { NotificationMessage notify = null; if (msg instanceof TextMessage) { try { notify = parseMsg((TextMessage) msg); } catch (JsonParseException e) { logger.error("Got the bad message, not a valid json format - \n" + ((TextMessage) msg).getText() + "\n" + e.getMessage()); msg.acknowledge(); } } else if (msg instanceof ObjectMessage) { notify = (NotificationMessage) ((ObjectMessage) msg).getObject(); } if (notify != null) { logger.debug("Notification message received: " + notify.getText()); if (notify.getTimestamp() == 0) { notify.setTimestamp(System.currentTimeMillis()); } dispatcher.dispatch(notify); } msg.acknowledge(); } catch (Exception ex) { logger.error("Can't process the notification message.", ex); } finally { tc.stop(); } } @Autowired AntennaListener(Dispatcher dispatcher,
Gson gson,
MetricRegistry metrics); @Autowired void setDmlc(DefaultMessageListenerContainer dmlc); @PostConstruct void init(); void onMessage(Message msg); @Override String toString(); }### Answer:
@Test public void onBadMessage() { TextMessage mockMessage = mock(TextMessage.class); try { when(mockMessage.getText()).thenReturn(""); } catch (JMSException e) { ; } this.listener.onMessage(mockMessage); } |
### Question:
InductorPublisher { protected String getCtxtId(CmsWorkOrderSimpleBase wo) { String ctxtId = ""; if (wo instanceof CmsWorkOrderSimple) { CmsWorkOrderSimple woSimple = CmsWorkOrderSimple.class.cast(wo); ctxtId = "d-" + woSimple.getDeploymentId() + "-" + woSimple.rfcCi.getRfcId() + "-" + woSimple.rfcCi.getExecOrder() + "-" + woSimple.rfcCi.getCiId(); } else if (wo instanceof CmsActionOrderSimple) { CmsActionOrderSimple ao = CmsActionOrderSimple.class.cast(wo); ctxtId = "a-" + ao.getProcedureId() + "-" + ao.getActionId() + "-" + ao.getCiId(); } return ctxtId; } void setConnFactory(ActiveMQConnectionFactory connFactory); void init(); void publishMessage(DelegateExecution exec, String waitTaskName, String woType); void publishMessage(String processId, String execId, CmsWorkOrderSimpleBase wo, String waitTaskName, String woType); void getConnectionStats(); void cleanup(); void closeConnection(); }### Answer:
@Test public void getCtxtId(){ CmsActionOrderSimple ao = new CmsActionOrderSimple(); ao.setProcedureId(1234); ao.setActionId(456); ao.setCiId(789); Assert.assertEquals("a-1234-456-789",publisher.getCtxtId(ao)); }
@Test public void getCtxtIdForDeployment(){ CmsWorkOrderSimple wo = new CmsWorkOrderSimple(); wo.setDeploymentId(1234); CmsRfcCISimple rfc = new CmsRfcCISimple(); rfc.setRfcId(456); rfc.setCiId(789); rfc.setExecOrder(5); wo.rfcCi=rfc; Assert.assertEquals("d-1234-456-5-789",publisher.getCtxtId(wo)); } |
### Question:
InductorPublisher { public void cleanup() { logger.info("Closing AMQ connection"); closeConnection(); } void setConnFactory(ActiveMQConnectionFactory connFactory); void init(); void publishMessage(DelegateExecution exec, String waitTaskName, String woType); void publishMessage(String processId, String execId, CmsWorkOrderSimpleBase wo, String waitTaskName, String woType); void getConnectionStats(); void cleanup(); void closeConnection(); }### Answer:
@Test (priority=2) public void cleanupTest() throws Exception{ publisher.getConnectionStats(); publisher.cleanup(); } |
### Question:
InductorListener implements MessageListener { public void onMessage(Message message) { try { if (message instanceof TextMessage) { if (logger.isDebugEnabled()) { logger.debug("got message: " + ((TextMessage) message).getText()); } try { processResponseMessage((TextMessage) message); } catch (ActivitiException ae) { logger.error("ActivityException in onMessage ", ae); logger.error("Will retry in 10 seconds \n" + ((TextMessage) message).getText()); throw ae; } } } catch (JMSException e) { logger.error("JMSException in onMessage", e); } } SensorClient getSensorClient(); void setSensorClient(SensorClient sensorClient); void setControllerUtil(ControllerUtil controllerUtil); void setWfController(WorkflowController wfController); void setConnFactory(ActiveMQConnectionFactory connFactory); void setWoPublisher(WoPublisher woPublisher); void init(); void onMessage(Message message); void getConnectionStats(); void cleanup(); void setExecutionManager(ExecutionManager executionManager); }### Answer:
@Test public void testBadMessage() throws JMSException { TextMessage message = mock(TextMessage.class); when(message.getJMSCorrelationID()).thenThrow(new JMSException("mock-force")); listener.onMessage(message); } |
### Question:
WorkflowController { public String startReleaseProcess(String processKey, Map<String,Object> params){ logger.info("starting process for " + processKey + " with params: " + params.toString()); ProcessInstance pi = runtimeService.startProcessInstanceByKey(processKey, params); logger.info("started process with id - " + pi.getId()); return pi.getId(); } DeploymentNotifier getNotifier(); void setNotifier(DeploymentNotifier notifier); void setRuntimeService(RuntimeService runtimeService); String startDpmtProcess(String processKey, Map<String,Object> params); String startReleaseProcess(String processKey, Map<String,Object> params); String startOpsProcess(String processKey, Map<String,Object> params); void pokeProcess(String processId); void pokeSubProcess(String processId, String executionId, Map<String,Object> params); void checkSyncWait(String processId, String executionId); static final String WO_SUBMITTED; static final String WO_FAILED; static final String WO_RECEIVED; static final String WO_STATE; static final String SUB_PROC_END_VAR; }### Answer:
@Test public void startReleaseProcessTest(){ Map<String, Object> params = new HashMap<String, Object>(); params.put("k", "v"); wfc.setRuntimeService(runtimeServiceExecutionMock); String pid = wfc.startReleaseProcess(RUNNER_PID, params); assertEquals(pid,NEW_PID); } |
### Question:
WorkflowController { public String startOpsProcess(String processKey, Map<String,Object> params){ logger.info("starting process for " + processKey + " with params: " + params.toString()); ProcessInstance pi = runtimeService.startProcessInstanceByKey(processKey, params); logger.info("started process with id - " + pi.getId()); return pi.getId(); } DeploymentNotifier getNotifier(); void setNotifier(DeploymentNotifier notifier); void setRuntimeService(RuntimeService runtimeService); String startDpmtProcess(String processKey, Map<String,Object> params); String startReleaseProcess(String processKey, Map<String,Object> params); String startOpsProcess(String processKey, Map<String,Object> params); void pokeProcess(String processId); void pokeSubProcess(String processId, String executionId, Map<String,Object> params); void checkSyncWait(String processId, String executionId); static final String WO_SUBMITTED; static final String WO_FAILED; static final String WO_RECEIVED; static final String WO_STATE; static final String SUB_PROC_END_VAR; }### Answer:
@Test public void startOpsProcessTest(){ Map<String, Object> params = new HashMap<String, Object>(); params.put("k", "v"); wfc.setRuntimeService(runtimeServiceExecutionMock); String pid = wfc.startOpsProcess(RUNNER_PID, params); assertEquals(pid,NEW_PID); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.