method2testcases
stringlengths 118
6.63k
|
|---|
### 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:
InMemoryExternalRoutingService implements ExternalRoutingService { @Override public void start() { this.initRoutingTables(); } InMemoryExternalRoutingService(
final EventBus eventBus,
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final Decryptor decryptor,
final AccountSettingsRepository accountSettingsRepository,
final StaticRoutesRepository staticRoutesRepository,
final LocalDestinationAddressPaymentRouter localDestinationAddressPaymentRouter,
final RoutingTable<Route> localRoutingTable,
final ForwardingRoutingTable<RouteUpdate> outgoingRoutingTable,
final RouteBroadcaster routeBroadcaster
); @Override void start(); @Override List<Route> getAllRoutes(); @Override Optional<Route> findBestNexHop(final InterledgerAddress finalDestinationAddress); @Override Set<StaticRoute> getAllStaticRoutes(); @Override void deleteStaticRouteByPrefix(InterledgerAddressPrefix prefix); @Override StaticRoute createStaticRoute(StaticRoute route); }### Answer:
@Test public void peersAndParentsGetsAutoRegisteredForCcp() { LinkType ilpoverhttp = LinkType.of("ILPOVERHTTP"); AccountSettings peer = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("peer")) .accountRelationship(AccountRelationship.PEER) .build(); AccountSettings child = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("child")) .accountRelationship(AccountRelationship.CHILD) .build(); AccountSettings parent = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("parent")) .accountRelationship(AccountRelationship.PARENT) .build(); when(accountSettingsRepository.findByAccountRelationshipIsWithConversion(AccountRelationship.PEER)) .thenReturn(Lists.newArrayList(peer)); when(accountSettingsRepository.findByAccountRelationshipIsWithConversion(AccountRelationship.PARENT)) .thenReturn(Lists.newArrayList(parent)); service.start(); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(peer); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(parent); verify(routeBroadcaster, times(0)).registerCcpEnabledAccount(child); }
@Test public void misconfiguredAccountsAreGracefullyHandled() { LinkType ilpoverhttp = LinkType.of("ILPOVERHTTP"); AccountSettings goodPeer = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("good_peer")) .accountRelationship(AccountRelationship.PEER) .build(); AccountSettings badPeer = AccountSettings.builder() .assetCode("XRP") .assetScale(9) .linkType(ilpoverhttp) .accountId(AccountId.of("bad_peer")) .accountRelationship(AccountRelationship.PEER) .build(); when(accountSettingsRepository.findByAccountRelationshipIsWithConversion(AccountRelationship.PEER)) .thenReturn(Lists.newArrayList(badPeer, goodPeer)); when(routeBroadcaster.registerCcpEnabledAccount(badPeer)).thenThrow(new RuntimeException("fake exception!")); when(routeBroadcaster.registerCcpEnabledAccount(goodPeer)).thenReturn(Optional.empty()); service.start(); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(badPeer); verify(routeBroadcaster, times(1)).registerCcpEnabledAccount(goodPeer); } |
### 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:
InMemoryExternalRoutingService implements ExternalRoutingService { @Override public Optional<Route> findBestNexHop(final InterledgerAddress finalDestinationAddress) { Objects.requireNonNull(finalDestinationAddress); return localDestinationAddressPaymentRouter.findBestNexHop(finalDestinationAddress) .map(Optional::ofNullable) .orElseGet(() -> localRoutingTable.findNextHopRoute(finalDestinationAddress)); } InMemoryExternalRoutingService(
final EventBus eventBus,
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final Decryptor decryptor,
final AccountSettingsRepository accountSettingsRepository,
final StaticRoutesRepository staticRoutesRepository,
final LocalDestinationAddressPaymentRouter localDestinationAddressPaymentRouter,
final RoutingTable<Route> localRoutingTable,
final ForwardingRoutingTable<RouteUpdate> outgoingRoutingTable,
final RouteBroadcaster routeBroadcaster
); @Override void start(); @Override List<Route> getAllRoutes(); @Override Optional<Route> findBestNexHop(final InterledgerAddress finalDestinationAddress); @Override Set<StaticRoute> getAllStaticRoutes(); @Override void deleteStaticRouteByPrefix(InterledgerAddressPrefix prefix); @Override StaticRoute createStaticRoute(StaticRoute route); }### Answer:
@Test public void testFindBestNexHopFromLocalPaymentRouter() { final Route routeMock = mock(Route.class); when(localDestinationAddressPaymentRouter.findBestNexHop(any())).thenReturn(Optional.of(routeMock)); final Optional<Route> actual = service.findBestNexHop(InterledgerAddress.of("example.foo.bar")); assertThat(actual).isPresent(); assertThat(actual.get()).isEqualTo(routeMock); }
@Test public void testFindBestNexHopFromForwardingPaymentRouter() { final Route routeMock = mock(Route.class); when(localDestinationAddressPaymentRouter.findBestNexHop(any())).thenReturn(Optional.empty()); when(localRoutingTableMock.findNextHopRoute(any())).thenReturn(Optional.of(routeMock)); final Optional<Route> actual = service.findBestNexHop(InterledgerAddress.of("example.foo.bar")); assertThat(actual).isPresent(); assertThat(actual.get()).isEqualTo(routeMock); }
@Test public void testFindBestNexHopWhenBothTablesAreEmpty() { when(localDestinationAddressPaymentRouter.findBestNexHop(any())).thenReturn(Optional.empty()); when(localRoutingTableMock.findNextHopRoute(any())).thenReturn(Optional.empty()); final Optional<Route> actual = service.findBestNexHop(InterledgerAddress.of("example.foo.bar")); assertThat(actual).isNotPresent(); } |
### Question:
InMemoryStreamPaymentManager implements StreamPaymentManager { @Override public synchronized void merge(StreamPayment streamPayment) { StreamPayment merged = upsertAmounts(streamPayment); if (streamPayment.deliveredAssetCode().isPresent()) { merged = put(StreamPayment.builder().from(merged) .deliveredAssetCode(streamPayment.deliveredAssetCode()) .deliveredAssetScale(streamPayment.deliveredAssetScale()) .build()); } if (!streamPayment.status().equals(StreamPaymentStatus.PENDING)) { put(StreamPayment.builder().from(merged) .status(streamPayment.status()) .build()); } } @Override List<StreamPayment> findByAccountId(AccountId accountId, PageRequest pageRequest); @Override Optional<StreamPayment> findByAccountIdAndStreamPaymentId(AccountId accountId, String streamPaymentId); @Override synchronized void merge(StreamPayment streamPayment); }### Answer:
@Test public void merge() { AccountId accountId = AccountId.of(generateUuid()); String streamPaymentId = generateUuid(); String streamPaymentId2 = generateUuid(); final StreamPayment entity1 = newTransaction(accountId, streamPaymentId, 10); paymentTransactionManager.merge(entity1); final StreamPayment loadedAccessTokenEntity = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId).get(); assertEqual(loadedAccessTokenEntity, entity1); final StreamPayment entity2 = newTransaction(accountId, streamPaymentId, 20); paymentTransactionManager.merge(entity2); assertThat(paymentTransactionManager.findByAccountId(accountId, DEFAULT_PAGE)).hasSize(1); Optional<StreamPayment> transaction1 = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId); assertThat(transaction1).isPresent(); assertThat(transaction1.get().packetCount()).isEqualTo(2); assertThat(transaction1.get().amount()).isEqualTo(BigInteger.valueOf(30)); paymentTransactionManager.merge(newTransaction(accountId, streamPaymentId2, 33)); assertThat(paymentTransactionManager.findByAccountId(accountId, DEFAULT_PAGE)).hasSize(2); Optional<StreamPayment> transaction1Again = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId); Optional<StreamPayment> transaction2 = paymentTransactionManager.findByAccountIdAndStreamPaymentId(accountId, streamPaymentId2); assertEqual(transaction1Again.get(), transaction1.get()); assertThat(transaction2).isPresent(); assertThat(transaction2.get().amount()).isEqualTo(BigInteger.valueOf(33)); assertThat(transaction2.get().packetCount()).isEqualTo(1); } |
### Question:
FulfillmentGeneratedEventConverter implements Converter<FulfillmentGeneratedEvent, StreamPayment> { @VisibleForTesting protected Optional<SharedSecret> getSharedSecret(InterledgerPacket... packets) { return Lists.newArrayList(packets).stream() .map(InterledgerPacket::typedData) .filter(Optional::isPresent) .map(Optional::get) .filter(typedData -> typedData instanceof StreamPacket) .map(typedData -> (StreamPacket) typedData) .map(StreamPacket::sharedSecret) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); } FulfillmentGeneratedEventConverter(StreamEncryptionService streamEncryptionService,
CodecContext streamCodecContext); @Override StreamPayment convert(FulfillmentGeneratedEvent source); }### Answer:
@Test public void findSharedSecretInIlpPackets() { final SharedSecret sharedSecret1 = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); final SharedSecret sharedSecret2 = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); final SharedSecret sharedSecret3 = SharedSecret.of(ByteArrayUtils.generate32RandomBytes()); assertThat(this.converter.getSharedSecret(new InterledgerPacket[0])).isEmpty(); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] {constructInterledgerPacketWithStreamPacket(Optional.empty())} )).isEmpty(); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] {constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret1))} )).get().isEqualTo(sharedSecret1); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()) } )).isEmpty(); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret1)), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret2)), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret3)) } )).get().isEqualTo(sharedSecret1); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret1)), constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()) } )).get().isEqualTo(sharedSecret1); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret2)), constructInterledgerPacketWithStreamPacket(Optional.empty()) } )).get().isEqualTo(sharedSecret2); assertThat(this.converter.getSharedSecret( new InterledgerPacket[] { constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.empty()), constructInterledgerPacketWithStreamPacket(Optional.of(sharedSecret3)) } )).get().isEqualTo(sharedSecret3); } |
### 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:
InDatabaseStreamPaymentManager implements StreamPaymentManager { @Override public void merge(StreamPayment streamPayment) { streamPaymentsRepository.upsertAmounts(streamPaymentToEntityConverter.convert(streamPayment)); streamPayment.sourceAddress().ifPresent(sourceAddress -> { streamPaymentsRepository.updateSourceAddress(streamPayment.accountId(), streamPayment.streamPaymentId(), sourceAddress.getValue()); }); streamPayment.deliveredAssetScale().ifPresent(assetScale -> { streamPaymentsRepository.udpdateDeliveredDenomination(streamPayment.accountId(), streamPayment.streamPaymentId(), streamPayment.deliveredAssetCode().orElse("unknown"), assetScale); }); if (!streamPayment.status().equals(StreamPaymentStatus.PENDING)) { streamPaymentsRepository.updateStatus(streamPayment.accountId(), streamPayment.streamPaymentId(), streamPayment.status()); } } 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 mergePending() { StreamPayment trx = transactionBuilder().build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verifyNoMoreInteractions(mockRepo); }
@Test public void mergeAndUpdateStatus() { StreamPayment trx = transactionBuilder() .status(StreamPaymentStatus.CLOSED_BY_STREAM) .build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verify(mockRepo, times(1)).updateStatus(trx.accountId(), trx.streamPaymentId(), trx.status()); verifyNoMoreInteractions(mockRepo); }
@Test public void mergeAndUpdateSourceAddress() { InterledgerAddress source = InterledgerAddress.of("test.sender"); StreamPayment trx = transactionBuilder() .sourceAddress(source) .build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verify(mockRepo, times(1)).updateSourceAddress(trx.accountId(), trx.streamPaymentId(), source.getValue()); verifyNoMoreInteractions(mockRepo); }
@Test public void mergeAndUpdateDeliveredDetails() { String assetCode = "XRP"; short assetScale = 9; StreamPayment trx = transactionBuilder() .deliveredAssetScale(assetScale) .deliveredAssetCode(assetCode) .build(); transactionManager.merge(trx); verify(mockRepo, times(1)).upsertAmounts(streamPaymentToEntityConverter.convert(trx)); verify(mockRepo, times(1)).udpdateDeliveredDenomination(trx.accountId(), trx.streamPaymentId(), assetCode, assetScale); verifyNoMoreInteractions(mockRepo); } |
### Question:
SpspController { @VisibleForTesting protected final Optional<String> cleanupSpspUrlPath(String spspUrlPath) { String cleanedUpSpspUrlPath = spspUrlPath; if (StringUtils.isBlank(cleanedUpSpspUrlPath) || StringUtils.equals(cleanedUpSpspUrlPath, "/")) { return Optional.empty(); } else { if (!cleanedUpSpspUrlPath.startsWith("/")) { cleanedUpSpspUrlPath = "/" + cleanedUpSpspUrlPath; } if (cleanedUpSpspUrlPath.endsWith("/")) { cleanedUpSpspUrlPath = cleanedUpSpspUrlPath.substring(0, cleanedUpSpspUrlPath.length() - 1); } cleanedUpSpspUrlPath = cleanedUpSpspUrlPath.replaceAll(" return Optional.ofNullable(cleanedUpSpspUrlPath); } } SpspController(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final StreamReceiver streamReceiver,
@Value("${" + SPSP__URL_PATH + ":}") final String spspUrlPath
); @RequestMapping( path = "/**", method = RequestMethod.GET, produces = {APPLICATION_SPSP4_JSON_VALUE, APPLICATION_JSON_VALUE, MediaTypes.PROBLEM_VALUE} ) ResponseEntity<StreamConnectionDetails> getSpspResponse(final HttpServletRequest httpServletRequest); }### Answer:
@Test public void cleanupSpspUrlPathWithNullBlankEmpty() { assertThat(spspController.cleanupSpspUrlPath(null)).isEmpty(); assertThat(spspController.cleanupSpspUrlPath("")).isEmpty(); assertThat(spspController.cleanupSpspUrlPath(" ")).isEmpty(); assertThat(spspController.cleanupSpspUrlPath("/")).isEmpty(); }
@Test public void cleanupSpspUrlPathWithVariants() { assertThat(spspController.cleanupSpspUrlPath("p")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("/p")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("p/")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("/p/")).get().isEqualTo("/p"); assertThat(spspController.cleanupSpspUrlPath("/p/foo/")).get().isEqualTo("/p/foo"); assertThat(spspController.cleanupSpspUrlPath("p/foo")).get().isEqualTo("/p/foo"); assertThat(spspController.cleanupSpspUrlPath("/p/foo/")).get().isEqualTo("/p/foo"); } |
### Question:
NumberScalingUtils { public static BigInteger translate( final BigInteger sourceAmount, final int sourceScale, final int destinationScale ) { Objects.requireNonNull(sourceAmount, "sourceAmount must not be null"); Preconditions.checkArgument(sourceAmount.compareTo(BigInteger.ZERO) >= 0, "sourceAmount must be positive"); Preconditions.checkArgument(sourceScale >= 0, "sourceScale must be positive"); Preconditions.checkArgument(destinationScale >= 0, "destinationScale must be positive"); final int scaleDifference = destinationScale - sourceScale; final BigInteger scaledAmount = scaleDifference > 0 ? sourceAmount.multiply(BigInteger.TEN.pow(scaleDifference)) : sourceAmount.divide((BigInteger.TEN.pow(scaleDifference * -1))); return scaledAmount; } static BigInteger translate(
final BigInteger sourceAmount, final int sourceScale, final int destinationScale
); }### Answer:
@Test(expected = NullPointerException.class) public void translateWithNullSourceQuantity() { try { NumberScalingUtils.translate(null, 1, 2); fail("Should have thrown an NPE"); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("sourceAmount must not be null"); throw e; } }
@Test(expected = IllegalArgumentException.class) public void translateWithNegativeSourceScale() { try { NumberScalingUtils.translate(BigInteger.ZERO, -11, 2); fail("Should have thrown an NPE"); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("sourceScale must not be negative"); throw e; } }
@Test(expected = IllegalArgumentException.class) public void translateWithNegativeDestinationScale() { try { NumberScalingUtils.translate(BigInteger.ZERO, 1, -1); fail("Should have thrown an NPE"); } catch (NullPointerException e) { assertThat(e.getMessage()).isEqualTo("destinationScale must not be negative"); throw e; } }
@Test public void translate() { assertThat(NumberScalingUtils.translate( sourceSettlementQuantity.amount(), sourceSettlementQuantity.scale(), expectedSettlementQuantity.scale() )).as(description).isEqualTo(expectedSettlementQuantity.amount()); } |
### 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 trackIncomingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(preparePacket); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.PREPARED.name(), EMPTY_REJECT_CODE, 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 trackIncomingPacketPrepared() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketPrepared(accountSettings(), preparePacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketFulfilled( final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(fulfillPacket); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.FULFILLED.name(), EMPTY_REJECT_CODE, 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 trackIncomingPacketFulfilled() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketFulfilled(accountSettings(), fulfillPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketRejected( final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(rejectPacket); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.REJECTED.name(), rejectPacket.getCode().getCode(), 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 trackIncomingPacketRejected() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketRejected(accountSettings(), rejectPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingPacketFailed(final AccountSettings accountSettings) { Objects.requireNonNull(accountSettings); PrometheusCollectors.incomingPackets.labels( PacketStatusResult.FAILED.name(), EMPTY_REJECT_CODE, 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 trackIncomingPacketFailed() { final Counter counter = PrometheusCollectors.incomingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingPacketFailed(accountSettings()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(i + 1); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketPrepared(AccountSettings accountSettings, InterledgerPreparePacket preparePacket) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(preparePacket); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.PREPARED.name(), EMPTY_REJECT_CODE, 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 trackOutgoingPacketPrepared() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketPrepared(accountSettings(), preparePacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketFulfilled( final AccountSettings accountSettings, final InterledgerFulfillPacket fulfillPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(fulfillPacket); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.FULFILLED.name(), EMPTY_REJECT_CODE, 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 trackOutgoingPacketFulfilled() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketFulfilled(accountSettings(), fulfillPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketRejected( final AccountSettings accountSettings, final InterledgerRejectPacket rejectPacket ) { Objects.requireNonNull(accountSettings); Objects.requireNonNull(rejectPacket); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.REJECTED.name(), rejectPacket.getCode().getCode(), 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 trackOutgoingPacketRejected() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketRejected(accountSettings(), rejectPacket()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(i + 1); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(0); } } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingPacketFailed(final AccountSettings accountSettings) { Objects.requireNonNull(accountSettings); PrometheusCollectors.outgoingPackets.labels( PacketStatusResult.FAILED.name(), EMPTY_REJECT_CODE, 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 trackOutgoingPacketFailed() { final Counter counter = PrometheusCollectors.outgoingPackets; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingPacketFailed(accountSettings()); assertThat(sum(counter, PacketStatusResult.PREPARED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FULFILLED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.REJECTED.name())).isEqualTo(0); assertThat(sum(counter, PacketStatusResult.FAILED.name())).isEqualTo(i + 1); } } |
### 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:
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingSettlementSucceeded(IncomingSettlementSucceededEvent event) { Objects.requireNonNull(event); event.accountSettings().ifPresent(accountSettings -> PrometheusCollectors.incomingSettlements.labels( SETTLEMENT_SUCCEEDED, accountSettings.accountId().value(), accountSettings.assetCode(), 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 trackIncomingSettlementSucceeded() { final Counter counter = PrometheusCollectors.incomingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingSettlementSucceeded(incomingSettlementSucceededEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(0); } metricsService.trackIncomingSettlementFailed(incomingSettlementFailedEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(100); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(1); } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackIncomingSettlementFailed(IncomingSettlementFailedEvent event) { Objects.requireNonNull(event); PrometheusCollectors.incomingSettlements.labels( SETTLEMENT_FAILED, event.requestedAccountId().value(), event.accountSettings().map(AccountSettings::assetCode).orElse(null), event.accountSettings().map(as -> as.assetScale() + "").orElse(null) ).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 trackIncomingSettlementFailed() { final Counter counter = PrometheusCollectors.incomingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackIncomingSettlementFailed(incomingSettlementFailedEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(0); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(i + 1); } metricsService.trackIncomingSettlementSucceeded(incomingSettlementSucceededEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(100); } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingSettlementInitiationSucceeded(final OutgoingSettlementInitiationSucceededEvent event) { Objects.requireNonNull(event); event.accountSettings().ifPresent(accountSettings -> PrometheusCollectors.outgoingSettlements.labels( SETTLEMENT_SUCCEEDED, accountSettings.accountId().value(), accountSettings.assetCode(), 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 trackOutgoingSettlementInitiationSucceeded() { final Counter counter = PrometheusCollectors.outgoingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingSettlementInitiationSucceeded(outgoingSettlementInitiationSucceededEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(0); } metricsService.trackOutgoingSettlementInitiationFailed(outgoingSettlementInitiationFailedEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(100); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(1); } |
### Question:
PrometheusMetricsService implements MetricsService { @Override public void trackOutgoingSettlementInitiationFailed(OutgoingSettlementInitiationFailedEvent event) { Objects.requireNonNull(event); event.accountSettings().ifPresent(accountSettings -> PrometheusCollectors.outgoingSettlements.labels( SETTLEMENT_FAILED, accountSettings.accountId().value(), accountSettings.assetCode(), 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 trackOutgoingSettlementInitiationFailed() { final Counter counter = PrometheusCollectors.outgoingSettlements; assertThat(sum(counter)).isEqualTo(0); for (int i = 0; i < 100; i++) { metricsService.trackOutgoingSettlementInitiationFailed(outgoingSettlementInitiationFailedEvent()); assertThat(sum(counter)).isEqualTo(i + 1); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(0); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(i + 1); } metricsService.trackOutgoingSettlementInitiationSucceeded(outgoingSettlementInitiationSucceededEvent()); assertThat(sum(counter)).isEqualTo(101); assertThat(sum(counter, SETTLEMENT_SUCCEEDED)).isEqualTo(1); assertThat(sum(counter, SETTLEMENT_FAILED)).isEqualTo(100); } |
### Question:
SpspReceiverEnabledCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { final Environment env = context.getEnvironment(); if (isSpspEnabled(env)) { Preconditions.checkArgument(isLocalSpspFulfillmentEnabled(env), "Local SPSP fulfillment may not be disabled if `%s` is enabled", SPSP_ENABLED ); } if (isLocalSpspFulfillmentEnabled(env)) { return true; } else { return isSpspEnabled(env); } } @Override boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata); }### Answer:
@Test public void exceptionWhenMissingAndMissing() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(null); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(null); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void matchesWhenMissingAndTrue() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(null); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(TRUE); assertThat(condition.matches(contextMock, metadataMock)).isTrue(); }
@Test public void matchesWhenMissingAndFalse() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(null); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(FALSE); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void exceptionWhenTrueAndMissing() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(PRECONDITION_MESSAGE); when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(TRUE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(null); condition.matches(contextMock, metadataMock); }
@Test public void matchesWhenTrueAndFalse() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(PRECONDITION_MESSAGE); when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(TRUE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(FALSE); condition.matches(contextMock, metadataMock); }
@Test public void matchesWhenTrueAndTrue() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(TRUE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(TRUE); assertThat(condition.matches(contextMock, metadataMock)).isTrue(); }
@Test public void exceptionWhenFalseAndMissing() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(FALSE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(null); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void exceptionWhenFalseAndFalse() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(FALSE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(FALSE); assertThat(condition.matches(contextMock, metadataMock)).isFalse(); }
@Test public void exceptionWhenFalseAndTrue() { when(environmentMock.getProperty(ENABLED_PROTOCOLS + DOT + SPSP_ENABLED)).thenReturn(FALSE); when(environmentMock.getProperty(ENABLED_FEATURES + DOT + LOCAL_SPSP_FULFILLMENT_ENABLED)).thenReturn(TRUE); assertThat(condition.matches(contextMock, metadataMock)).isTrue(); } |
### Question:
DefaultAccountIdResolver implements BtpAccountIdResolver, IlpOverHttpAccountIdResolver, AccountIdResolver { @Override public AccountId resolveAccountId(final Link<?> link) { Objects.requireNonNull(link); if (link instanceof StatefulLink && !(((StatefulLink<?>) link).isConnected())) { throw new LinkNotConnectedException("Disconnected Plugins do not have an associated account!", link.getLinkId()); } else { return AccountId.of(link.getLinkId().value()); } } @Override AccountId resolveAccountId(final Link<?> link); @Override AccountId resolveAccountId(final BtpSession btpSession); @Override AccountId resolveAccountId(final Authentication authentication); }### Answer:
@Test public void resolveAccountIdWithNullLink() { expectedException.expect(NullPointerException.class); Link link = null; accountIdResolver.resolveAccountId(link); }
@Test public void resolveAccountIdWithLink() { assertThat(accountIdResolver.resolveAccountId(linkMock)).isEqualTo(AccountId.of(LINK_ID.value())); }
@Test public void resolveAccountIdWithStatefulLinkNotConnected() { when(statefulLinkMock.isConnected()).thenReturn(false); expectedException.expect(LinkNotConnectedException.class); accountIdResolver.resolveAccountId(statefulLinkMock); }
@Test public void resolveAccountIdWithStatefulLinkConnected() { when(statefulLinkMock.isConnected()).thenReturn(true); accountIdResolver.resolveAccountId(statefulLinkMock); assertThat(accountIdResolver.resolveAccountId(statefulLinkMock)).isEqualTo(AccountId.of(LINK_ID.value())); }
@Test public void testResolveAccountWithNullAuthentication() { expectedException.expect(NullPointerException.class); Authentication authentication = null; accountIdResolver.resolveAccountId(authentication); }
@Test public void testResolveAccountWithAuthentication() { Authentication authenticationMock = mock(Authentication.class); when(authenticationMock.getPrincipal()).thenReturn("foo"); assertThat(accountIdResolver.resolveAccountId(authenticationMock)).isEqualTo(AccountId.of("foo")); }
@Test public void testResolveAccountWithNullBtpSession() { expectedException.expect(NullPointerException.class); BtpSession btpSession = null; accountIdResolver.resolveAccountId(btpSession); }
@Test public void testResolveAccountWithBtpSessionWithNoCreds() { expectedException.expect(RuntimeException.class); expectedException.expectMessage("No BtpSessionCredentials found!"); BtpSession btpSessionMock = mock(BtpSession.class); Optional<BtpSessionCredentials> btpSessionCredentials = Optional.empty(); when(btpSessionMock.getBtpSessionCredentials()).thenReturn(btpSessionCredentials); assertThat(accountIdResolver.resolveAccountId(btpSessionMock)); }
@Test public void testResolveAccountWithBtpSessionWithNoAuthUsername() { expectedException.expect(RuntimeException.class); expectedException.expectMessage("Not yet implemented"); BtpSession btpSessionMock = mock(BtpSession.class); Optional<BtpSessionCredentials> btpSessionCredentials = Optional.of(BtpSessionCredentials.builder() .authToken("authToken") .build()); when(btpSessionMock.getBtpSessionCredentials()).thenReturn(btpSessionCredentials); assertThat(accountIdResolver.resolveAccountId(btpSessionMock)).isEqualTo(AccountId.of("foo")); }
@Test public void testResolveAccountWithBtpSession() { BtpSession btpSessionMock = mock(BtpSession.class); Optional<BtpSessionCredentials> btpSessionCredentials = Optional.of(BtpSessionCredentials.builder() .authToken("authToken") .authUsername("authUsername") .build()); when(btpSessionMock.getBtpSessionCredentials()).thenReturn(btpSessionCredentials); assertThat(accountIdResolver.resolveAccountId(btpSessionMock)).isEqualTo(AccountId.of("authUsername")); } |
### 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:
DefaultAccountManager implements AccountManager { @VisibleForTesting protected AccountSettingsEntity persistAccountSettingsEntity(AccountSettingsEntity accountSettingsEntity) { AccountSettingsEntity entity; try { entity = this.accountSettingsRepository.save(accountSettingsEntity); } catch (Exception e) { if (e.getCause() instanceof ConstraintViolationException) { ConstraintViolationException cause = (ConstraintViolationException) e.getCause(); if (cause.getConstraintName().contains(DataConstants.ConstraintNames.ACCOUNT_SETTINGS_SETTLEMENT_ENGINE)) { throw new AccountSettlementEngineAlreadyExistsProblem(accountSettingsEntity.getAccountId(), accountSettingsEntity.getSettlementEngineDetailsEntity().getSettlementEngineAccountId()); } } throw e; } return entity; } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); }### Answer:
@Test public void failOnDupeSettlementEngineId() { AccountSettingsEntity entity = mock(AccountSettingsEntity.class); SettlementEngineDetailsEntity engineEntity = mock(SettlementEngineDetailsEntity.class); when(entity.getSettlementEngineDetailsEntity()).thenReturn(engineEntity); String daveandbusters = "daveandbusters"; when(engineEntity.getSettlementEngineAccountId()).thenReturn(daveandbusters); AccountId mac = AccountId.of("mac"); when(entity.getAccountId()).thenReturn(mac); when(accountSettingsRepository.save(entity)) .thenThrow(new AccountSettlementEngineAlreadyExistsProblem(mac, daveandbusters)); expectedException.expect(AccountSettlementEngineAlreadyExistsProblem.class); expectedException.expectMessage("Account Settlement Engine Already Exists " + "[accountId: `" + mac.value() + "`, settlementEngineId: `" + daveandbusters + "`]"); accountManager.persistAccountSettingsEntity(entity); } |
### Question:
DefaultAccountManager implements AccountManager { @Override public AccountSettings validateLinkSettings(AccountSettings accountSettings) { try { LinkSettings linkSettings = linkSettingsValidator .validateSettings(linkSettingsFactory.constructTyped(accountSettings)); if (accountSettings.linkType().equals(IlpOverHttpLink.LINK_TYPE)) { IlpOverHttpLinkSettings ilpOverHttpLinkSettings = (IlpOverHttpLinkSettings) linkSettings; return AccountSettings.builder() .from(accountSettings) .customSettings(ilpOverHttpLinkSettings.getCustomSettings()) .build(); } return accountSettings; } catch (IllegalArgumentException e) { throw new InvalidAccountSettingsProblem(e.getMessage(), accountSettings.accountId()); } } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); }### Answer:
@Test public void validateLinkSettingsFailsOnInvalidLinkType() { AccountSettings accountSettings = AccountSettings.builder() .accountId(AccountId.of("UnsupportedLinkTypeGuy")) .assetCode("XRP") .assetScale(9) .linkType(LinkType.of("UnsupportedLinkType")) .accountRelationship(AccountRelationship.PEER) .build(); expectedException.expect(InvalidAccountSettingsProblem.class); expectedException.expectMessage("Unsupported LinkType:"); when(linkSettingsFactory.constructTyped(accountSettings)).thenThrow(new IllegalArgumentException("Unsupported LinkType: " + accountSettings.linkType())); accountManager.validateLinkSettings(accountSettings); } |
### Question:
DefaultAccountManager implements AccountManager { @Override @Transactional public void deleteByAccountId(AccountId accountId) { Optional<AccountSettingsEntity> entity = accountSettingsRepository.findByAccountId(accountId); if (!entity.isPresent()) { throw new AccountNotFoundProblem(accountId); } deletedAccountSettingsRepository.save(new DeletedAccountSettingsEntity(entity.get())); accountSettingsRepository.delete(entity.get()); } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); }### Answer:
@Test public void deleteAccount() { AccountId accountId = AccountId.of("egg"); final AccountSettings accountSettings = AccountSettings.builder() .accountId(accountId) .assetCode("XRP") .assetScale(9) .linkType(LinkType.of("Loopback")) .accountRelationship(AccountRelationship.PEER) .build(); AccountSettingsEntity account = new AccountSettingsEntity(accountSettings); when(accountSettingsRepository.findByAccountId(accountId)).thenReturn(Optional.of(account)); accountManager.deleteByAccountId(accountId); verify(accountSettingsRepository, times(1)).findByAccountId(accountId); verify(deletedAccountSettingsRepository, times(1)) .save(new DeletedAccountSettingsEntity(account)); }
@Test public void deleteMissingAccountThrowsNotFound() { AccountId accountId = AccountId.of("egg"); when(accountSettingsRepository.findByAccountId(accountId)).thenReturn(Optional.empty()); expectedException.expect(AccountNotFoundProblem.class); accountManager.deleteByAccountId(accountId); } |
### Question:
DefaultAccountManager implements AccountManager { @Override public AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId) { Objects.requireNonNull(accountId); final AccountSettingsEntity parentAccountSettingsEntity = accountSettingsRepository.safeFindByAccountId(accountId); final Link<?> link = this.getLinkManager().getOrCreateLink( conversionService.convert(parentAccountSettingsEntity, AccountSettings.class) ); final IldcpResponse ildcpResponse = ildcpFetcherFactory.construct(link).fetch(IldcpRequest.builder().build()); if (this.connectorSettingsSupplier.get() instanceof ModifiableConnectorSettings) { ((ModifiableConnectorSettings) this.connectorSettingsSupplier.get()) .setOperatorAddress(ildcpResponse.getClientAddress()); } else if (this.connectorSettingsSupplier.get() instanceof ConnectorSettingsFromPropertyFile) { ((ConnectorSettingsFromPropertyFile) this.connectorSettingsSupplier.get()) .setNodeIlpAddress(ildcpResponse.getClientAddress()); } parentAccountSettingsEntity.setAssetCode(ildcpResponse.getAssetCode()); parentAccountSettingsEntity.setAssetScale(ildcpResponse.getAssetScale()); final AccountSettingsEntity updatedAccountSettings = accountSettingsRepository.save(parentAccountSettingsEntity); logger.info( "IL-DCP Succeeded! Operator Address: `{}`", connectorSettingsSupplier.get().operatorAddress() ); return conversionService.convert(updatedAccountSettings, AccountSettings.class); } DefaultAccountManager(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final ConversionService conversionService,
final AccountSettingsRepository accountSettingsRepository,
final DeletedAccountSettingsRepository deletedAccountSettingsRepository,
final LinkManager linkManager,
final SettlementEngineClient settlementEngineClient,
final LinkSettingsFactory linkSettingsFactory,
final LinkSettingsValidator linkSettingsValidator,
final IldcpFetcherFactory ildcpFetcherFactory,
final EventBus eventBus
); @Override LinkManager getLinkManager(); @Override Optional<AccountSettings> findAccountById(AccountId accountId); @Override List<AccountSettings> getAccounts(); @Override AccountSettings createAccount(final AccountSettings accountSettings); @Override AccountSettings updateAccount(final AccountId accountId, final AccountSettings accountSettings); @Override AccountSettings validateLinkSettings(AccountSettings accountSettings); @Override AccountSettings initializeParentAccountSettingsViaIlDcp(final AccountId accountId); @Override @Transactional void deleteByAccountId(AccountId accountId); }### Answer:
@Test public void initializeParentAccountSettingsViaIlDcpWithModifiableConfig() { ModifiableConnectorSettings modifiableConnectorSettings = ModifiableConnectorSettings.create(); InterledgerAddress ildcpAddress = InterledgerAddress.of("g.parent.child"); AccountId accountId = simulateIldcp(modifiableConnectorSettings, ildcpAddress); assertThat(modifiableConnectorSettings.operatorAddress()).isEqualTo(InterledgerAddress.of("self.node")); accountManager.initializeParentAccountSettingsViaIlDcp(accountId); assertThat(modifiableConnectorSettings.operatorAddress()).isEqualTo(ildcpAddress); }
@Test public void initializeParentAccountSettingsViaIlDcpWithPropertiesConfig() { ConnectorSettingsFromPropertyFile connectorSettingsFromPropertyFile = new ConnectorSettingsFromPropertyFile(); InterledgerAddress ildcpAddress = InterledgerAddress.of("g.parent.child"); AccountId accountId = simulateIldcp(connectorSettingsFromPropertyFile, ildcpAddress); assertThat(connectorSettingsFromPropertyFile.operatorAddress()).isEqualTo(InterledgerAddress.of("self.node")); accountManager.initializeParentAccountSettingsViaIlDcp(accountId); assertThat(connectorSettingsFromPropertyFile.operatorAddress()).isEqualTo(ildcpAddress); } |
### 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:
SpringConnectorWebMvc implements WebMvcConfigurer { @Override public void extendMessageConverters(List<HttpMessageConverter<?>> converters) { converters.replaceAll(messageConverter -> { if (messageConverter instanceof MappingJackson2HttpMessageConverter) { if (((MappingJackson2HttpMessageConverter) messageConverter).getObjectMapper().getRegisteredModuleIds() .contains(ProblemModule.class.getName())) { return messageConverter; } return new MappingJackson2HttpMessageConverter(objectMapper); } else { return messageConverter; } }); } @Override void configureMessageConverters(List<HttpMessageConverter<?>> converters); @Override void extendMessageConverters(List<HttpMessageConverter<?>> converters); @Override void addFormatters(FormatterRegistry registry); }### Answer:
@Test public void testExtendMessageConvertersWhenEmpty() { List<HttpMessageConverter<?>> messageConverters = Lists.newArrayList(); springConnectorWebMvc.extendMessageConverters(messageConverters); assertThat(messageConverters.size()).isEqualTo(0); }
@Test public void testExtendMessageConvertersWithoutProblemsJsonHttpConverters() { final List<HttpMessageConverter<?>> originalMessageConverters = configureInitialMessageConvertersWithoutProblems(); final List<HttpMessageConverter<?>> adjustedMessageConverters = new ArrayList<>(originalMessageConverters); springConnectorWebMvc.extendMessageConverters(adjustedMessageConverters); assertThat(originalMessageConverters.size()).isEqualTo(3); assertThat(adjustedMessageConverters.size()).isEqualTo(3); assertThat(originalMessageConverters.get(0)).isEqualTo(adjustedMessageConverters.get(0)); assertThat(originalMessageConverters.get(1)).isNotEqualTo(adjustedMessageConverters.get(1)); assertThat(originalMessageConverters.get(2)).isEqualTo(adjustedMessageConverters.get(2)); }
@Test public void testExtendMessageConvertersWithMultipleTypesOfHttpConverter() { final List<HttpMessageConverter<?>> originalMessageConverters = configureInitialMessageConvertersWithProblems(); final List<HttpMessageConverter<?>> adjustedMessageConverters = new ArrayList<>(originalMessageConverters); springConnectorWebMvc.extendMessageConverters(adjustedMessageConverters); assertThat(originalMessageConverters.size()).isEqualTo(4); assertThat(adjustedMessageConverters.size()).isEqualTo(4); assertThat(originalMessageConverters.get(0)).isEqualTo(adjustedMessageConverters.get(0)); assertThat(originalMessageConverters.get(1)).isEqualTo(adjustedMessageConverters.get(1)); assertThat(originalMessageConverters.get(2)).isNotEqualTo(adjustedMessageConverters.get(2)); assertThat(originalMessageConverters.get(3)).isEqualTo(adjustedMessageConverters.get(3)); } |
### 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:
MaxPacketAmountFilter extends AbstractPacketFilter implements PacketSwitchFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePreparePacket, final PacketSwitchFilterChain filterChain ) { Objects.requireNonNull(sourceAccountSettings); Objects.requireNonNull(sourcePreparePacket); Objects.requireNonNull(filterChain); return sourceAccountSettings.maximumPacketAmount() .filter(maxPacketAmount -> sourcePreparePacket.getAmount().compareTo(maxPacketAmount) > 0) .map(maxPacketAmount -> { logger.error( "Rejecting packet for exceeding max amount. accountId={} maxAmount={} actualAmount={}", sourceAccountSettings.accountId(), maxPacketAmount, sourcePreparePacket.getAmount() ); return (InterledgerResponsePacket) packetRejector.reject( LinkId.of(sourceAccountSettings.accountId().value()), sourcePreparePacket, InterledgerErrorCode.F08_AMOUNT_TOO_LARGE, String.format( "Packet size too large: maxAmount=%s actualAmount=%s", maxPacketAmount, sourcePreparePacket.getAmount()) ); }) .orElseGet(() -> filterChain.doFilter(sourceAccountSettings, sourcePreparePacket)); } MaxPacketAmountFilter(final PacketRejector packetRejector); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings,
final InterledgerPreparePacket sourcePreparePacket,
final PacketSwitchFilterChain filterChain
); }### Answer:
@Test public void filterHatesNullSettings() { MaxPacketAmountFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(null, createPrepareWithAmount(10), filterChain); }
@Test public void filterHatesNullPrepare() { MaxPacketAmountFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(100)), null, filterChain); }
@Test public void filterHatesNullChain() { MaxPacketAmountFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(100)), createPrepareWithAmount(10), null); }
@Test public void passAlongWhenBelowMax() { MaxPacketAmountFilter filter = createFilter(); AccountSettings settings = createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(1000)); InterledgerPreparePacket prepare = createPrepareWithAmount(999); filter.doFilter(settings, prepare, filterChain); verify(filterChain, times(1)).doFilter(settings, prepare); }
@Test public void rejectWhenBeyondMax() { MaxPacketAmountFilter filter = createFilter(); AccountSettings settings = createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(1000)); InterledgerPreparePacket prepare = createPrepareWithAmount(1001); InterledgerResponsePacket response = filter.doFilter(settings, prepare, filterChain); assertThat(response).isInstanceOf(InterledgerRejectPacket.class) .extracting("code", "message") .containsExactly(InterledgerErrorCode.F08_AMOUNT_TOO_LARGE, "Packet size too large: maxAmount=1000 actualAmount=1001"); verify(filterChain, times(0)).doFilter(settings, prepare); } |
### Question:
PacketMetricsFilter extends AbstractPacketFilter implements PacketSwitchFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings sourceAccountSettings, final InterledgerPreparePacket sourcePreparePacket, final PacketSwitchFilterChain filterChain ) { try { this.metricsService.trackIncomingPacketPrepared(sourceAccountSettings, sourcePreparePacket); return filterChain.doFilter(sourceAccountSettings, sourcePreparePacket) .map( (interledgerFulfillPacket) -> { this.metricsService.trackIncomingPacketFulfilled(sourceAccountSettings, interledgerFulfillPacket); return interledgerFulfillPacket; }, (interledgerRejectPacket) -> { this.metricsService.trackIncomingPacketRejected(sourceAccountSettings, interledgerRejectPacket); return interledgerRejectPacket; } ); }catch (InterledgerProtocolException e) { this.metricsService.trackIncomingPacketRejected(sourceAccountSettings, e.getInterledgerRejectPacket()); throw e; } catch (Exception e) { this.metricsService.trackIncomingPacketFailed(sourceAccountSettings); throw e; } } PacketMetricsFilter(final PacketRejector packetRejector, MetricsService metricsService); @Override InterledgerResponsePacket doFilter(
final AccountSettings sourceAccountSettings,
final InterledgerPreparePacket sourcePreparePacket,
final PacketSwitchFilterChain filterChain
); }### Answer:
@Test public void doFilterWithFulfill() { when(filterChainMock.doFilter(accountSettings(), preparePacket())).thenReturn(fulfillPacket()); final InterledgerResponsePacket actual = filter.doFilter(accountSettings(), preparePacket(), filterChainMock); assertThat(actual).isEqualTo(fulfillPacket()); verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings(), preparePacket()); verify(metricsServiceMock).trackIncomingPacketFulfilled(accountSettings(), fulfillPacket()); verifyNoMoreInteractions(metricsServiceMock); }
@Test public void doFilterWithReject() { when(filterChainMock.doFilter(accountSettings(), preparePacket())).thenReturn(rejectPacket()); final InterledgerResponsePacket actual = filter.doFilter(accountSettings(), preparePacket(), filterChainMock); assertThat(actual).isEqualTo(rejectPacket()); verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings(), preparePacket()); verify(metricsServiceMock).trackIncomingPacketRejected(accountSettings(), rejectPacket()); verifyNoMoreInteractions(metricsServiceMock); }
@Test public void doFilterWithInterledgerProtocolException() { final AccountSettings accountSettings = accountSettings(); final InterledgerPreparePacket preparePacket = preparePacket(); expectedException.expect(InterledgerProtocolException.class); expectedException.expectMessage("Interledger Rejection: "); doThrow(new InterledgerProtocolException(rejectPacket())) .when(filterChainMock) .doFilter(eq(accountSettings), eq(preparePacket)); try { filter.doFilter(accountSettings, preparePacket, filterChainMock); fail("cannot run doFilter"); } catch (Exception e) { verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings, preparePacket); verify(metricsServiceMock).trackIncomingPacketRejected(accountSettings, rejectPacket()); verifyNoMoreInteractions(metricsServiceMock); throw e; } }
@Test public void doFilterWithException() { final AccountSettings accountSettings = accountSettings(); final InterledgerPreparePacket preparePacket = preparePacket(); expectedException.expect(RuntimeException.class); expectedException.expectMessage("foo"); doThrow(new RuntimeException("foo")).when(filterChainMock).doFilter(eq(accountSettings), eq(preparePacket)); try { filter.doFilter(accountSettings, preparePacket, filterChainMock); fail("cannot run doFilter"); } catch (Exception e) { verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackIncomingPacketPrepared(accountSettings, preparePacket); verify(metricsServiceMock).trackIncomingPacketFailed(accountSettings); verifyNoMoreInteractions(metricsServiceMock); throw e; } } |
### Question:
SpspRequestMatcher implements RequestMatcher { @Override public boolean matches(final HttpServletRequest httpServletRequest) { return spspEnabled && hasCorrectSpspUrlPath(httpServletRequest) && hasCorrectAcceptHeader(httpServletRequest); } SpspRequestMatcher(final boolean spspEnabled, final String initialSpspUrlPath); @Override boolean matches(final HttpServletRequest httpServletRequest); }### Answer:
@Test public void testWhenDisabled() { this.spspRequestMatcher = new SpspRequestMatcher(false, "/p"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "text/plain"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.setServletPath("/p/bob"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.setServletPath("/q/bob"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); }
@Test public void testWhenEnabled() { this.spspRequestMatcher = new SpspRequestMatcher(true, "/p"); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "text/plain"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "text/html, application/spsp4+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json,application/spsp+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/p/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json,application/spsp+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isTrue(); servletRequest.setRequestURI("/q/bob"); servletRequest.removeHeader("Accept"); servletRequest.addHeader("Accept", "application/spsp4+json,application/spsp+json"); assertThat(spspRequestMatcher.matches(servletRequest)).isFalse(); } |
### Question:
InterledgerAddressUtils { public boolean isExternalForwardingAllowed(final InterledgerAddress destinationAddress) { Objects.requireNonNull(destinationAddress); if (destinationAddress.startsWith(connectorSettingsSupplier.get().operatorAddress())) { return EXTERNAL_FORWARDING_NOT_ALLOWED; } else if ( isPaymentNetworkAddress(destinationAddress) ) { return EXTERNAL_FORWARDING_ALLOWED; } else { return EXTERNAL_FORWARDING_NOT_ALLOWED; } } InterledgerAddressUtils(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final AccountSettingsRepository accountSettingsRepository
); boolean isExternalForwardingAllowed(final InterledgerAddress destinationAddress); boolean isDestinationAllowedFromAccount(
final AccountId sourceAccountId, final InterledgerAddress destinationAddress
); }### Answer:
@Test public void isExternalForwardingAllowedWithNull() { expectedException.expect(NullPointerException.class); interledgerAddressUtils.isExternalForwardingAllowed(null); }
@Test public void isExternalForwardingAllowed() { when(connectorSettingsMock.operatorAddress()).thenReturn(InterledgerAddress.of("test.bar")); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.bar"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.bar.bar"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.b"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("g.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test1.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test2.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("test3.foo"))).isTrue(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("example.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("private.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("peer.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("self.foo"))).isFalse(); assertThat(interledgerAddressUtils.isExternalForwardingAllowed(InterledgerAddress.of("local.foo"))).isFalse(); } |
### Question:
InterledgerAddressUtils { public boolean isDestinationAllowedFromAccount( final AccountId sourceAccountId, final InterledgerAddress destinationAddress ) { Objects.requireNonNull(sourceAccountId); Objects.requireNonNull(destinationAddress); if (isPaymentNetworkAddress(destinationAddress)) { return ALLOWED; } else if (destinationAddress.startsWith(connectorSettingsSupplier.get().operatorAddress())) { return ALLOWED; } else if (destinationAddress.startsWith(InterledgerAddressPrefix.PRIVATE.getValue())) { return accountSettingsRepository.isInternal(sourceAccountId).orElse(NOT_ALLOWED); } else if (destinationAddress.startsWith(InterledgerAddressPrefix.PEER.getValue())) { return accountSettingsRepository.isNotInternal(sourceAccountId).orElse(NOT_ALLOWED); } else if (destinationAddress.startsWith(InterledgerAddressPrefix.SELF.getValue())) { return accountSettingsRepository.isInternal(sourceAccountId).orElse(NOT_ALLOWED); } else { return NOT_ALLOWED; } } InterledgerAddressUtils(
final Supplier<ConnectorSettings> connectorSettingsSupplier,
final AccountSettingsRepository accountSettingsRepository
); boolean isExternalForwardingAllowed(final InterledgerAddress destinationAddress); boolean isDestinationAllowedFromAccount(
final AccountId sourceAccountId, final InterledgerAddress destinationAddress
); }### Answer:
@Test public void isDestinationAllowedFromAccount() { assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("g.foo.receiver")) ).isTrue(); when(connectorSettingsMock.operatorAddress()).thenReturn(InterledgerAddress.of("g.foo")); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("g.foo.receiver")) ).isTrue(); mockAccountAsInternal(true); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("private.foo.receiver")) ).isTrue(); mockAccountAsInternal(false); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("private.foo.receiver")) ).isFalse(); mockAccountAsInternal(true); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("peer.foo.receiver")) ).isFalse(); mockAccountAsInternal(false); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("peer.foo.receiver")) ).isTrue(); mockAccountAsInternal(true); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("self.foo.receiver")) ).isTrue(); mockAccountAsInternal(false); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("self.foo.receiver")) ).isFalse(); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("example.foo.receiver")) ).isFalse(); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("local.foo.receiver")) ).isFalse(); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("test.foo.receiver")) ).isTrue(); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("test1.foo.receiver")) ).isTrue(); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("test2.foo.receiver")) ).isTrue(); assertThat(interledgerAddressUtils.isDestinationAllowedFromAccount( ACCOUNT_ID, InterledgerAddress.of("test3.foo.receiver")) ).isTrue(); } |
### 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 MonetaryRounding getRounding(RoundingQuery query) { final CurrencyUnit currency = query.getCurrency(); if (currency != null && (XRP.equals(currency.getCurrencyCode()))) { return dropsRounding; } else if (DROP.equals(query.getRoundingName())) { return dropsRounding; } return null; } DropRoundingProvider(); MonetaryRounding getRounding(RoundingQuery query); Set<String> getRoundingNames(); }### Answer:
@Test public void testRoundDropsWithAllDecimals() { final MonetaryAmount xrpAmount = Monetary.getAmountFactory(Money.class) .setCurrency(XRP) .setNumber(new BigDecimal("0.123456789")) .create(); assertThat(xrpAmount.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.123456789")); final MonetaryAmount xrpRounded = xrpAmount.with(Monetary.getRounding(xrpAmount.getCurrency())); assertThat(xrpRounded.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.123457")); }
@Test public void testRoundXrpWhenSmallerThanDrops() { final MonetaryAmount xrpAmount = Monetary.getAmountFactory(Money.class) .setCurrency(XRP) .setNumber(new BigDecimal("0.000000001")) .create(); assertThat(xrpAmount.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0.000000001")); final MonetaryAmount xrpRounded = xrpAmount.with(Monetary.getRounding(xrpAmount.getCurrency())); assertThat(xrpRounded.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("0")); }
@Test public void testRoundDropsWith1Xrp() { final Money xrpAmount = Monetary.getAmountFactory(Money.class) .setCurrency(XRP) .setNumber(new BigDecimal("1.123456789")) .create(); assertThat(xrpAmount.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1.123456789")); final MonetaryAmount xrpRounded = xrpAmount.with(Monetary.getRounding(xrpAmount.getCurrency())); assertThat(xrpRounded.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("1.123457")); }
@Test public void testRoundDrops() { final MonetaryAmount xrpAmount = Monetary.getAmountFactory(Money.class) .setCurrency(XRP) .setNumber(new BigDecimal("221.123456")) .create(); assertThat(xrpAmount.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("221.123456")); final MonetaryAmount xrpRounded = xrpAmount.with(Monetary.getRounding(xrpAmount.getCurrency())); assertThat(xrpRounded.getNumber().numberValue(BigDecimal.class)).isEqualTo(new BigDecimal("221.123456")); }
@Test public void getRounding() { final MonetaryRounding rounding = dropRoundingProvider.getRounding(RoundingQueryBuilder.of() .setCurrency(Monetary.getCurrency(XRP)) .build()); assertThat(rounding.getRoundingContext().getProviderName()).isEqualTo("DropsProvider"); assertThat(rounding.getRoundingContext().getRoundingName()).isEqualTo(DROP); }
@Test(expected = UnknownCurrencyException.class) public void getRoundingNotFound() { try { dropRoundingProvider.getRounding(RoundingQueryBuilder.of() .setCurrency(Monetary.getCurrency("Foo")) .build()); } catch (UnknownCurrencyException e) { assertThat(e.getMessage()).isEqualTo("Unknown currency code: Foo"); throw e; } } |
### 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:
DefaultLinkManager implements LinkManager, LinkConnectionEventListener { @Override public Link<? extends LinkSettings> getOrCreateLink(final AccountId accountId) { Objects.requireNonNull(accountId); return Optional.ofNullable(this.connectedLinks.get(accountId)) .orElseGet(() -> { final AccountSettings accountSettings = accountSettingsRepository.findByAccountIdWithConversion(accountId) .orElseThrow(() -> new AccountNotFoundProblem(accountId)); return (Link) getOrCreateLink(accountSettings); }); } DefaultLinkManager(
final Supplier<InterledgerAddress> operatorAddressSupplier,
final AccountSettingsRepository accountSettingsRepository,
final LinkSettingsFactory linkSettingsFactory,
final LinkFactoryProvider linkFactoryProvider,
final AccountIdResolver accountIdResolver,
final CircuitBreakerConfig defaultCircuitBreakerConfig,
final LocalDestinationAddressUtils localDestinationAddressUtils,
final EventBus eventBus
); @Override Link<? extends LinkSettings> getOrCreateLink(final AccountId accountId); @Override Link<? extends LinkSettings> getOrCreateLink(final AccountSettings accountSettings); @Override Link<? extends LinkSettings> getOrCreateLink(final AccountId accountId, final LinkSettings linkSettings); @Override Set<Link<? extends LinkSettings>> getAllConnectedLinks(); @Override Link<? extends LinkSettings> getOrCreateSpspReceiverLink(final AccountSettings accountSettings); @Override @Subscribe void onConnect(final LinkConnectedEvent event); @Override @Subscribe void onDisconnect(final LinkDisconnectedEvent event); }### Answer:
@Test public void getOrCreateLinkWithNullAccountSettings() { expectedException.expect(NullPointerException.class); expectedException.expectMessage("accountId must not be null"); final AccountSettings nullAccountSettings = null; defaultLinkManager.getOrCreateLink(nullAccountSettings); }
@Test public void getOrCreateLinkForPingLink() { when(localDestinationAddressUtilsMock.isConnectorPingAccountId(any())).thenReturn(true); when(linkFactoryProviderMock.getLinkFactory(PingLoopbackLink.LINK_TYPE).constructLink(any(), any())) .thenReturn(pingLinkMock); final AccountSettings accountSettingsMock = mock(AccountSettings.class); when(accountSettingsMock.accountId()).thenReturn(LocalDestinationAddressUtils.PING_ACCOUNT_ID); final Link<? extends LinkSettings> link = defaultLinkManager.getOrCreateLink(accountSettingsMock); assertThat(link).isEqualTo(pingLinkMock); Mockito.verifyNoInteractions(linkSettingsFactoryMock); }
@Test public void getOrCreateLinkForNonPingLink() { final LinkSettings linkSettingsMock = mock(LinkSettings.class); when(nonPingLinkMock.getOperatorAddressSupplier()).thenReturn(INTERLEDGER_ADDRESS_SUPPLIER); when(nonPingLinkMock.getLinkSettings()).thenReturn(linkSettingsMock); when(localDestinationAddressUtilsMock.isConnectorPingAccountId(any())).thenReturn(false); when(linkFactoryProviderMock.getLinkFactory(any()).constructLink(any(), any())).thenReturn(nonPingLinkMock); when(linkSettingsFactoryMock.construct(any())).thenReturn(linkSettingsMock); final AccountSettings accountSettingsMock = mock(AccountSettings.class); when(accountSettingsMock.accountId()).thenReturn(AccountId.of("foo")); final Link<? extends LinkSettings> link = defaultLinkManager.getOrCreateLink(accountSettingsMock); assertThat(link.getLinkId()).isEqualTo(nonPingLinkMock.getLinkId()); } |
### Question:
OutgoingMetricsLinkFilter extends AbstractLinkFilter implements LinkFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings destinationAccountSettings, final InterledgerPreparePacket outgoingPreparePacket, final LinkFilterChain filterChain ) { Objects.requireNonNull(destinationAccountSettings); Objects.requireNonNull(outgoingPreparePacket); Objects.requireNonNull(filterChain); try { this.metricsService.trackOutgoingPacketPrepared(destinationAccountSettings, outgoingPreparePacket); return filterChain.doFilter(destinationAccountSettings, outgoingPreparePacket) .map( (interledgerFulfillPacket) -> { metricsService.trackOutgoingPacketFulfilled(destinationAccountSettings, interledgerFulfillPacket); return interledgerFulfillPacket; }, (interledgerRejectPacket) -> { metricsService.trackOutgoingPacketRejected(destinationAccountSettings, interledgerRejectPacket); return interledgerRejectPacket; } ); } catch (InterledgerProtocolException e) { this.metricsService.trackOutgoingPacketRejected(destinationAccountSettings, e.getInterledgerRejectPacket()); throw e; } catch (Exception e) { metricsService.trackOutgoingPacketFailed(destinationAccountSettings); throw e; } } OutgoingMetricsLinkFilter(
final Supplier<InterledgerAddress> operatorAddressSupplier, final MetricsService metricsService
); @Override InterledgerResponsePacket doFilter(
final AccountSettings destinationAccountSettings,
final InterledgerPreparePacket outgoingPreparePacket,
final LinkFilterChain filterChain
); }### Answer:
@Test public void doFilterWithFulfill() { when(filterChainMock.doFilter(accountSettings(), preparePacket())).thenReturn(fulfillPacket()); final InterledgerResponsePacket actual = filter.doFilter(accountSettings(), preparePacket(), filterChainMock); assertThat(actual).isEqualTo(fulfillPacket()); verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackOutgoingPacketPrepared(accountSettings(), preparePacket()); verify(metricsServiceMock).trackOutgoingPacketFulfilled(accountSettings(), fulfillPacket()); verifyNoMoreInteractions(metricsServiceMock); }
@Test public void doFilterWithReject() { when(filterChainMock.doFilter(accountSettings(), preparePacket())).thenReturn(rejectPacket()); final InterledgerResponsePacket actual = filter.doFilter(accountSettings(), preparePacket(), filterChainMock); assertThat(actual).isEqualTo(rejectPacket()); verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackOutgoingPacketPrepared(accountSettings(), preparePacket()); verify(metricsServiceMock).trackOutgoingPacketRejected(accountSettings(), rejectPacket()); verifyNoMoreInteractions(metricsServiceMock); }
@Test public void doFilterWithInterledgerProtocolException() { final AccountSettings accountSettings = accountSettings(); final InterledgerPreparePacket preparePacket = preparePacket(); expectedException.expect(InterledgerProtocolException.class); expectedException.expectMessage("Interledger Rejection: "); doThrow(new InterledgerProtocolException(rejectPacket())) .when(filterChainMock) .doFilter(eq(accountSettings), eq(preparePacket)); try { filter.doFilter(accountSettings, preparePacket, filterChainMock); fail("cannot run doFilter"); } catch (Exception e) { verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackOutgoingPacketPrepared(accountSettings, preparePacket); verify(metricsServiceMock).trackOutgoingPacketRejected(accountSettings, rejectPacket()); verifyNoMoreInteractions(metricsServiceMock); throw e; } }
@Test public void doFilterWithException() { final AccountSettings accountSettings = accountSettings(); final InterledgerPreparePacket preparePacket = preparePacket(); expectedException.expect(RuntimeException.class); expectedException.expectMessage("foo"); doThrow(new RuntimeException("foo")).when(filterChainMock).doFilter(eq(accountSettings), eq(preparePacket)); try { filter.doFilter(accountSettings, preparePacket, filterChainMock); fail("cannot run doFilter"); } catch (Exception e) { verifyNoMoreInteractions(packetRejectorMock); verify(metricsServiceMock).trackOutgoingPacketPrepared(accountSettings, preparePacket); verify(metricsServiceMock).trackOutgoingPacketFailed(accountSettings); verifyNoMoreInteractions(metricsServiceMock); throw e; } } |
### 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:
OutgoingMaxPacketAmountLinkFilter extends AbstractLinkFilter implements LinkFilter { @Override public InterledgerResponsePacket doFilter( final AccountSettings destinationAccountSettings, final InterledgerPreparePacket destPreparePacket, final LinkFilterChain filterChain ) { Objects.requireNonNull(destinationAccountSettings); Objects.requireNonNull(destPreparePacket); Objects.requireNonNull(filterChain); return destinationAccountSettings.maximumPacketAmount() .filter(maxPacketAmount -> destPreparePacket.getAmount().compareTo(maxPacketAmount) > 0) .map(maxPacketAmount -> { logger.error( "Rejecting packet for exceeding max amount. accountId={} maxAmount={} actualAmount={}", destinationAccountSettings.accountId(), maxPacketAmount, destPreparePacket.getAmount() ); return (InterledgerResponsePacket) reject( destinationAccountSettings.accountId(), destPreparePacket, InterledgerErrorCode.F08_AMOUNT_TOO_LARGE, String.format( "Packet size too large: maxAmount=%s actualAmount=%s", maxPacketAmount, destPreparePacket.getAmount()) ); }) .orElseGet(() -> filterChain.doFilter(destinationAccountSettings, destPreparePacket)); } OutgoingMaxPacketAmountLinkFilter(Supplier<InterledgerAddress> operatorAddressSupplier); @Override InterledgerResponsePacket doFilter(
final AccountSettings destinationAccountSettings,
final InterledgerPreparePacket destPreparePacket,
final LinkFilterChain filterChain
); }### Answer:
@Test public void filterHatesNullSettings() { OutgoingMaxPacketAmountLinkFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(null, createPrepareWithAmount(10), filterChain); }
@Test public void filterHatesNullPrepare() { OutgoingMaxPacketAmountLinkFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(100)), null, filterChain); }
@Test public void filterHatesNullChain() { OutgoingMaxPacketAmountLinkFilter filter = createFilter(); expectedException.expect(NullPointerException.class); filter.doFilter(createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(100)), createPrepareWithAmount(10), null); }
@Test public void passAlongWhenBelowMax() { OutgoingMaxPacketAmountLinkFilter filter = createFilter(); AccountSettings settings = createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(1000)); InterledgerPreparePacket prepare = createPrepareWithAmount(999); filter.doFilter(settings, prepare, filterChain); verify(filterChain, times(1)).doFilter(settings, prepare); }
@Test public void rejectWhenBeyondMax() { OutgoingMaxPacketAmountLinkFilter filter = createFilter(); AccountSettings settings = createAccountSettingsWithMaxAmount(UnsignedLong.valueOf(1000)); InterledgerPreparePacket prepare = createPrepareWithAmount(1001); InterledgerResponsePacket response = filter.doFilter(settings, prepare, filterChain); assertThat(response).isInstanceOf(InterledgerRejectPacket.class) .extracting("code", "message") .containsExactly(InterledgerErrorCode.F08_AMOUNT_TOO_LARGE, "Packet size too large: maxAmount=1000 actualAmount=1001"); verify(filterChain, times(0)).doFilter(settings, prepare); } |
### 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:
RuntimeUtils { public static KeyStoreType determineKeystoreType(Environment environment) { Objects.requireNonNull(environment); if (isGcpKmsEnabled(environment)) { return KeyStoreType.GCP; } else if (isJksKmsEnabled(environment)) { return KeyStoreType.JKS; } else { throw new RuntimeException( String.format("Unsupported Keystore Type. Please defined either `%s` or `%s`", INTERLEDGER_CONNECTOR_KEYSTORE_GCP_ENABLED, INTERLEDGER_CONNECTOR_KEYSTORE_JKS_ENABLED) ); } } 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 testDetermineKeystoreTypeGcpKmsNull() { when(environmentMock.getProperty(INTERLEDGER_CONNECTOR_KEYSTORE_GCP_ENABLED)).thenReturn(null); expectedException.expect(RuntimeException.class); expectedException.expectMessage(ERR_MESSAGE); RuntimeUtils.determineKeystoreType(environmentMock); }
@Test public void testDetermineKeystoreTypeGcpKmsFalse() { when(environmentMock.getProperty(INTERLEDGER_CONNECTOR_KEYSTORE_GCP_ENABLED)).thenReturn(Boolean.FALSE.toString()); expectedException.expect(RuntimeException.class); expectedException.expectMessage(ERR_MESSAGE); RuntimeUtils.determineKeystoreType(environmentMock); }
@Test public void testDetermineKeystoreTypeGcpKmsTrue() { when(environmentMock.getProperty(INTERLEDGER_CONNECTOR_KEYSTORE_GCP_ENABLED)).thenReturn(Boolean.TRUE.toString()); assertThat(RuntimeUtils.determineKeystoreType(environmentMock)).isEqualTo(KeyStoreType.GCP); }
@Test public void testDetermineKeystoreTypeJksNull() { when(environmentMock.getProperty(INTERLEDGER_CONNECTOR_KEYSTORE_JKS_ENABLED)).thenReturn(null); expectedException.expect(RuntimeException.class); expectedException.expectMessage(ERR_MESSAGE); RuntimeUtils.determineKeystoreType(environmentMock); }
@Test public void testDetermineKeystoreTypeJksFalse() { when(environmentMock.getProperty(INTERLEDGER_CONNECTOR_KEYSTORE_JKS_ENABLED)).thenReturn(Boolean.FALSE.toString()); expectedException.expect(RuntimeException.class); expectedException.expectMessage(ERR_MESSAGE); RuntimeUtils.determineKeystoreType(environmentMock); }
@Test public void testDetermineKeystoreTypeJksTrue() { when(environmentMock.getProperty(INTERLEDGER_CONNECTOR_KEYSTORE_JKS_ENABLED)).thenReturn(Boolean.TRUE.toString()); assertThat(RuntimeUtils.determineKeystoreType(environmentMock)).isEqualTo(KeyStoreType.JKS); } |
### 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:
InterledgerAddressPrefixMap { public Optional<R> findNextHop(final InterledgerAddress finalDestinationAddress) { Objects.requireNonNull(finalDestinationAddress); return this.findLongestPrefix(InterledgerAddressPrefix.from(finalDestinationAddress)) .map(this::getEntry) .orElse(Optional.empty()); } 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 testGetNextHopRoutingTableEntryWithNoRoutingTableEntrysInMap() { assertThat(prefixMap.findNextHop(DEFAULT_CONNECTOR_ADDRESS.with("bob")).isPresent()).isFalse(); }
@Test public void testGetNextHopRoutingTableEntryWithDifferringLengthsInTable() { this.prefixMap = this.constructPopulatedPrefixMap(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("self.me")).isPresent()).isFalse(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.1.me")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.1.m")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.1")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.2")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.foo.bob")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.bar.bob")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.baz.boo.alice")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.baz.boo.bob")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.baz.boo.bar.alice")).isPresent()).isTrue(); assertThat(prefixMap.findNextHop(InterledgerAddress.of("g.baz.boo.bar.bob")).isPresent()).isTrue(); } |
### 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)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.