diff --git a/backend/src/main/java/de/cotto/lndmanagej/service/ChannelDetailsService.java b/backend/src/main/java/de/cotto/lndmanagej/service/ChannelDetailsService.java new file mode 100644 index 00000000..d1cbe248 --- /dev/null +++ b/backend/src/main/java/de/cotto/lndmanagej/service/ChannelDetailsService.java @@ -0,0 +1,63 @@ +package de.cotto.lndmanagej.service; + +import de.cotto.lndmanagej.model.BalanceInformation; +import de.cotto.lndmanagej.model.ChannelDetails; +import de.cotto.lndmanagej.model.ChannelId; +import de.cotto.lndmanagej.model.LocalChannel; +import de.cotto.lndmanagej.model.OpenCloseStatus; +import de.cotto.lndmanagej.model.Policies; +import de.cotto.lndmanagej.model.Pubkey; +import org.springframework.stereotype.Component; + +@Component +public class ChannelDetailsService { + private final OnChainCostService onChainCostService; + private final RebalanceService rebalanceService; + private final NodeService nodeService; + private final BalanceService balanceService; + private final PolicyService policyService; + private final FeeService feeService; + + public ChannelDetailsService( + OnChainCostService onChainCostService, + RebalanceService rebalanceService, + NodeService nodeService, + BalanceService balanceService, + PolicyService policyService, + FeeService feeService + ) { + this.onChainCostService = onChainCostService; + this.rebalanceService = rebalanceService; + this.nodeService = nodeService; + this.balanceService = balanceService; + this.policyService = policyService; + this.feeService = feeService; + } + + public ChannelDetails getDetails(LocalChannel localChannel) { + Pubkey remotePubkey = localChannel.getRemotePubkey(); + String remoteAlias = nodeService.getAlias(remotePubkey); + ChannelId channelId = localChannel.getId(); + return new ChannelDetails( + localChannel, + remoteAlias, + getBalanceInformation(channelId), + onChainCostService.getOnChainCostsForChannelId(channelId), + getPoliciesForChannel(localChannel), + feeService.getFeeReportForChannel(channelId), + rebalanceService.getReportForChannel(localChannel.getId()) + ); + } + + private BalanceInformation getBalanceInformation(ChannelId channelId) { + return balanceService.getBalanceInformation(channelId) + .orElse(BalanceInformation.EMPTY); + } + + private Policies getPoliciesForChannel(LocalChannel channel) { + if (channel.getStatus().openCloseStatus() != OpenCloseStatus.OPEN) { + return Policies.UNKNOWN; + } + return policyService.getPolicies(channel.getId()); + } +} diff --git a/backend/src/main/java/de/cotto/lndmanagej/service/OffChainCostService.java b/backend/src/main/java/de/cotto/lndmanagej/service/OffChainCostService.java deleted file mode 100644 index 9a1ab971..00000000 --- a/backend/src/main/java/de/cotto/lndmanagej/service/OffChainCostService.java +++ /dev/null @@ -1,62 +0,0 @@ -package de.cotto.lndmanagej.service; - -import com.codahale.metrics.annotation.Timed; -import de.cotto.lndmanagej.model.ChannelId; -import de.cotto.lndmanagej.model.Coins; -import de.cotto.lndmanagej.model.OffChainCosts; -import de.cotto.lndmanagej.model.Pubkey; -import de.cotto.lndmanagej.model.SelfPayment; -import org.springframework.stereotype.Component; - -import java.util.Set; - -@Component -public class OffChainCostService { - private final RebalanceService rebalanceService; - - public OffChainCostService(RebalanceService rebalanceService) { - this.rebalanceService = rebalanceService; - } - - @Timed - public OffChainCosts getOffChainCostsForPeer(Pubkey pubkey) { - return new OffChainCosts( - getRebalanceSourceCostsForPeer(pubkey), - getRebalanceTargetCostsForPeer(pubkey) - ); - } - - @Timed - public OffChainCosts getOffChainCostsForChannel(ChannelId channelId) { - return new OffChainCosts( - getRebalanceSourceCostsForChannel(channelId), - getRebalanceTargetCostsForChannel(channelId) - ); - } - - @Timed - public Coins getRebalanceSourceCostsForChannel(ChannelId channelId) { - return getSumOfFees(rebalanceService.getRebalancesFromChannel(channelId)); - } - - @Timed - public Coins getRebalanceSourceCostsForPeer(Pubkey pubkey) { - return getSumOfFees(rebalanceService.getRebalancesFromPeer(pubkey)); - } - - @Timed - public Coins getRebalanceTargetCostsForChannel(ChannelId channelId) { - return getSumOfFees(rebalanceService.getRebalancesToChannel(channelId)); - } - - @Timed - public Coins getRebalanceTargetCostsForPeer(Pubkey pubkey) { - return getSumOfFees(rebalanceService.getRebalancesToPeer(pubkey)); - } - - private Coins getSumOfFees(Set selfPayments) { - return selfPayments.stream() - .map(SelfPayment::fees) - .reduce(Coins.NONE, Coins::add); - } -} diff --git a/backend/src/main/java/de/cotto/lndmanagej/service/RebalanceService.java b/backend/src/main/java/de/cotto/lndmanagej/service/RebalanceService.java index 4180ce7c..dd76ad38 100644 --- a/backend/src/main/java/de/cotto/lndmanagej/service/RebalanceService.java +++ b/backend/src/main/java/de/cotto/lndmanagej/service/RebalanceService.java @@ -5,6 +5,7 @@ import de.cotto.lndmanagej.model.Channel; import de.cotto.lndmanagej.model.ChannelId; import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.Pubkey; +import de.cotto.lndmanagej.model.RebalanceReport; import de.cotto.lndmanagej.model.SelfPayment; import org.springframework.stereotype.Component; @@ -24,19 +25,78 @@ public class RebalanceService { } @Timed - public Set getRebalancesFromChannel(ChannelId channelId) { + public RebalanceReport getReportForChannel(ChannelId channelId) { + return new RebalanceReport( + getSourceCostsForChannel(channelId), + getAmountFromChannel(channelId), + getTargetCostsForChannel(channelId), + getAmountToChannel(channelId) + ); + } + + @Timed + public RebalanceReport getReportForPeer(Pubkey pubkey) { + return new RebalanceReport( + getSourceCostsForPeer(pubkey), + getAmountFromPeer(pubkey), + getTargetCostsForPeer(pubkey), + getAmountToPeer(pubkey) + ); + } + + @Timed + public Coins getSourceCostsForChannel(ChannelId channelId) { + return getSumOfFees(getRebalancesFromChannel(channelId)); + } + + @Timed + public Coins getSourceCostsForPeer(Pubkey pubkey) { + return getSumOfFees(getRebalancesFromPeer(pubkey)); + } + + @Timed + public Coins getTargetCostsForChannel(ChannelId channelId) { + return getSumOfFees(getRebalancesToChannel(channelId)); + } + + @Timed + public Coins getTargetCostsForPeer(Pubkey pubkey) { + return getSumOfFees(getRebalancesToPeer(pubkey)); + } + + @Timed + public Coins getAmountFromChannel(ChannelId channelId) { + return getSumOfAmountPaid(getRebalancesFromChannel(channelId)); + } + + @Timed + public Coins getAmountFromPeer(Pubkey pubkey) { + return getSumOfAmountPaid(getRebalancesFromPeer(pubkey)); + } + + @Timed + public Coins getAmountToChannel(ChannelId channelId) { + return getSumOfAmountPaid(getRebalancesToChannel(channelId)); + } + + @Timed + public Coins getAmountToPeer(Pubkey pubkey) { + return getSumOfAmountPaid(getRebalancesToPeer(pubkey)); + } + + private Set getRebalancesFromChannel(ChannelId channelId) { return selfPaymentsService.getSelfPaymentsFromChannel(channelId).stream() .filter(selfPayment -> memoMentionsChannel(selfPayment, channelId)) .collect(toSet()); } - @Timed - public Coins getRebalanceAmountFromChannel(ChannelId channelId) { - return getSumOfAmountPaid(getRebalancesFromChannel(channelId)); + private Set getRebalancesToChannel(ChannelId channelId) { + return selfPaymentsService.getSelfPaymentsToChannel(channelId).stream() + .filter(this::memoDoesNotMentionFirstHopChannel) + .collect(toSet()); } - @Timed - public Set getRebalancesFromPeer(Pubkey pubkey) { + private Set getRebalancesFromPeer(Pubkey pubkey) { return channelService.getAllChannelsWith(pubkey).parallelStream() .map(Channel::getId) .map(this::getRebalancesFromChannel) @@ -44,25 +104,7 @@ public class RebalanceService { .collect(toSet()); } - @Timed - public Coins getRebalanceAmountFromPeer(Pubkey pubkey) { - return getSumOfAmountPaid(getRebalancesFromPeer(pubkey)); - } - - @Timed - public Set getRebalancesToChannel(ChannelId channelId) { - return selfPaymentsService.getSelfPaymentsToChannel(channelId).stream() - .filter(this::memoDoesNotMentionFirstHopChannel) - .collect(toSet()); - } - - @Timed - public Coins getRebalanceAmountToChannel(ChannelId channelId) { - return getSumOfAmountPaid(getRebalancesToChannel(channelId)); - } - - @Timed - public Set getRebalancesToPeer(Pubkey pubkey) { + private Set getRebalancesToPeer(Pubkey pubkey) { return channelService.getAllChannelsWith(pubkey).parallelStream() .map(Channel::getId) .map(this::getRebalancesToChannel) @@ -70,17 +112,18 @@ public class RebalanceService { .collect(toSet()); } - @Timed - public Coins getRebalanceAmountToPeer(Pubkey pubkey) { - return getSumOfAmountPaid(getRebalancesToPeer(pubkey)); - } - private Coins getSumOfAmountPaid(Collection selfPayments) { return selfPayments.stream() .map(SelfPayment::amountPaid) .reduce(Coins.NONE, Coins::add); } + private Coins getSumOfFees(Set selfPayments) { + return selfPayments.stream() + .map(SelfPayment::fees) + .reduce(Coins.NONE, Coins::add); + } + private boolean memoMentionsChannel(SelfPayment selfPayment, ChannelId expectedChannel) { String memo = selfPayment.memo(); return memo.contains(String.valueOf(expectedChannel.getShortChannelId())) diff --git a/backend/src/test/java/de/cotto/lndmanagej/service/ChannelDetailsServiceTest.java b/backend/src/test/java/de/cotto/lndmanagej/service/ChannelDetailsServiceTest.java new file mode 100644 index 00000000..48fc570b --- /dev/null +++ b/backend/src/test/java/de/cotto/lndmanagej/service/ChannelDetailsServiceTest.java @@ -0,0 +1,116 @@ +package de.cotto.lndmanagej.service; + +import de.cotto.lndmanagej.model.BalanceInformation; +import de.cotto.lndmanagej.model.ChannelDetails; +import de.cotto.lndmanagej.model.LocalChannel; +import de.cotto.lndmanagej.model.Policies; +import de.cotto.lndmanagej.model.RebalanceReport; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.Optional; + +import static de.cotto.lndmanagej.model.ChannelDetailsFixtures.CHANNEL_DETAILS; +import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID; +import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL; +import static de.cotto.lndmanagej.model.FeeReportFixtures.FEE_REPORT; +import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_PRIVATE; +import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS; +import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_2; +import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; +import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES; +import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2; +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; +import static de.cotto.lndmanagej.model.WaitingCloseChannelFixtures.WAITING_CLOSE_CHANNEL; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class ChannelDetailsServiceTest { + @InjectMocks + private ChannelDetailsService channelDetailsService; + + @Mock + private OnChainCostService onChainCostService; + + @Mock + private RebalanceService rebalanceService; + + @Mock + private NodeService nodeService; + + @Mock + private BalanceService balanceService; + + @Mock + private FeeService feeService; + + @Mock + private PolicyService policyService; + + @BeforeEach + void setUp() { + lenient().when(onChainCostService.getOnChainCostsForChannelId(CHANNEL_ID)).thenReturn(ON_CHAIN_COSTS); + lenient().when(rebalanceService.getReportForChannel(CHANNEL_ID)).thenReturn(RebalanceReport.EMPTY); + lenient().when(feeService.getFeeReportForChannel(CHANNEL_ID)).thenReturn(FEE_REPORT); + lenient().when(policyService.getPolicies(CHANNEL_ID)).thenReturn(POLICIES); + } + + @Test + void getDetails() { + when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS); + when(balanceService.getBalanceInformation(CHANNEL_ID)) + .thenReturn(Optional.ofNullable(LOCAL_OPEN_CHANNEL_PRIVATE.getBalanceInformation())); + when(rebalanceService.getReportForChannel(CHANNEL_ID)).thenReturn(REBALANCE_REPORT); + assertThat(channelDetailsService.getDetails(LOCAL_OPEN_CHANNEL_PRIVATE)).isEqualTo(CHANNEL_DETAILS); + } + + @Test + void getDetails_private() { + ChannelDetails expectedDetails = new ChannelDetails( + LOCAL_OPEN_CHANNEL_PRIVATE, + ALIAS_2, + LOCAL_OPEN_CHANNEL_PRIVATE.getBalanceInformation(), + ON_CHAIN_COSTS, + POLICIES, + FEE_REPORT, + RebalanceReport.EMPTY + ); + when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2); + when(balanceService.getBalanceInformation(CHANNEL_ID)) + .thenReturn(Optional.ofNullable(LOCAL_OPEN_CHANNEL_PRIVATE.getBalanceInformation())); + + assertThat(channelDetailsService.getDetails(LOCAL_OPEN_CHANNEL_PRIVATE)).isEqualTo(expectedDetails); + } + + @Test + void getDetails_closed() { + ChannelDetails expectedDetails = mockForChannelWithoutPolicies(CLOSED_CHANNEL); + assertThat(channelDetailsService.getDetails(CLOSED_CHANNEL)).isEqualTo(expectedDetails); + } + + @Test + void getDetails_waiting_close() { + ChannelDetails expectedDetails = mockForChannelWithoutPolicies(WAITING_CLOSE_CHANNEL); + assertThat(channelDetailsService.getDetails(WAITING_CLOSE_CHANNEL)).isEqualTo(expectedDetails); + } + + private ChannelDetails mockForChannelWithoutPolicies(LocalChannel channel) { + when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2); + when(balanceService.getBalanceInformation(CHANNEL_ID)).thenReturn(Optional.empty()); + return new ChannelDetails( + channel, + ALIAS_2, + BalanceInformation.EMPTY, + ON_CHAIN_COSTS, + Policies.UNKNOWN, + FEE_REPORT, + RebalanceReport.EMPTY + ); + } +} \ No newline at end of file diff --git a/backend/src/test/java/de/cotto/lndmanagej/service/OffChainCostServiceTest.java b/backend/src/test/java/de/cotto/lndmanagej/service/OffChainCostServiceTest.java deleted file mode 100644 index 0e33746d..00000000 --- a/backend/src/test/java/de/cotto/lndmanagej/service/OffChainCostServiceTest.java +++ /dev/null @@ -1,110 +0,0 @@ -package de.cotto.lndmanagej.service; - -import de.cotto.lndmanagej.model.Coins; -import de.cotto.lndmanagej.model.OffChainCosts; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; - -import java.util.Set; - -import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID; -import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_2; -import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_4; -import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY; -import static de.cotto.lndmanagej.model.SelfPaymentFixtures.SELF_PAYMENT; -import static de.cotto.lndmanagej.model.SelfPaymentFixtures.SELF_PAYMENT_2; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.when; - -@ExtendWith(MockitoExtension.class) -class OffChainCostServiceTest { - private static final Coins COST_FOR_TWO_SELF_PAYMENTS = SELF_PAYMENT.fees().add(SELF_PAYMENT_2.fees()); - - @InjectMocks - private OffChainCostService offChainCostService; - - @Mock - private RebalanceService rebalanceService; - - @Test - void getOffChainCostsForPeer_source() { - when(rebalanceService.getRebalancesFromPeer(PUBKEY)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - OffChainCosts expected = new OffChainCosts( - COST_FOR_TWO_SELF_PAYMENTS, - Coins.NONE - ); - assertThat(offChainCostService.getOffChainCostsForPeer(PUBKEY)).isEqualTo(expected); - } - - @Test - void getOffChainCostsForPeer_target() { - when(rebalanceService.getRebalancesToPeer(PUBKEY)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - OffChainCosts expected = new OffChainCosts( - Coins.NONE, - COST_FOR_TWO_SELF_PAYMENTS - ); - assertThat(offChainCostService.getOffChainCostsForPeer(PUBKEY)).isEqualTo(expected); - } - - @Test - void getOffChainCostsForChannel_source() { - when(rebalanceService.getRebalancesFromChannel(CHANNEL_ID_4)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - OffChainCosts expected = new OffChainCosts( - COST_FOR_TWO_SELF_PAYMENTS, - Coins.NONE - ); - assertThat(offChainCostService.getOffChainCostsForChannel(CHANNEL_ID_4)).isEqualTo(expected); - } - - @Test - void getOffChainCostsForChannel_target() { - when(rebalanceService.getRebalancesToChannel(CHANNEL_ID_4)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - OffChainCosts expected = new OffChainCosts( - Coins.NONE, - COST_FOR_TWO_SELF_PAYMENTS - ); - assertThat(offChainCostService.getOffChainCostsForChannel(CHANNEL_ID_4)).isEqualTo(expected); - } - - @Test - void getRebalanceSourceCostsForChannel_no_self_payments() { - assertThat(offChainCostService.getRebalanceSourceCostsForChannel(CHANNEL_ID)).isEqualTo(Coins.NONE); - } - - @Test - void getRebalanceSourceCostsForChannel() { - when(rebalanceService.getRebalancesFromChannel(CHANNEL_ID)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - assertThat(offChainCostService.getRebalanceSourceCostsForChannel(CHANNEL_ID)) - .isEqualTo(COST_FOR_TWO_SELF_PAYMENTS); - } - - @Test - void getRebalanceSourceCostsForPeer() { - when(rebalanceService.getRebalancesFromPeer(PUBKEY)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - assertThat(offChainCostService.getRebalanceSourceCostsForPeer(PUBKEY)) - .isEqualTo(COST_FOR_TWO_SELF_PAYMENTS); - } - - @Test - void getRebalanceTargetCostsForChannel_no_self_payments() { - assertThat(offChainCostService.getRebalanceTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(Coins.NONE); - } - - @Test - void getRebalanceTargetCostsForChannel() { - when(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - assertThat(offChainCostService.getRebalanceTargetCostsForChannel(CHANNEL_ID_2)) - .isEqualTo(COST_FOR_TWO_SELF_PAYMENTS); - } - - @Test - void getRebalanceTargetCostsForPeer() { - when(rebalanceService.getRebalancesToPeer(PUBKEY)).thenReturn(Set.of(SELF_PAYMENT, SELF_PAYMENT_2)); - assertThat(offChainCostService.getRebalanceTargetCostsForPeer(PUBKEY)) - .isEqualTo(COST_FOR_TWO_SELF_PAYMENTS); - } - -} \ No newline at end of file diff --git a/backend/src/test/java/de/cotto/lndmanagej/service/RebalanceServiceTest.java b/backend/src/test/java/de/cotto/lndmanagej/service/RebalanceServiceTest.java index 1edf2648..365dd03f 100644 --- a/backend/src/test/java/de/cotto/lndmanagej/service/RebalanceServiceTest.java +++ b/backend/src/test/java/de/cotto/lndmanagej/service/RebalanceServiceTest.java @@ -5,6 +5,7 @@ import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.Payment; import de.cotto.lndmanagej.model.PaymentHop; import de.cotto.lndmanagej.model.PaymentRoute; +import de.cotto.lndmanagej.model.RebalanceReport; import de.cotto.lndmanagej.model.SelfPayment; import de.cotto.lndmanagej.model.SettledInvoice; import org.junit.jupiter.api.Test; @@ -39,6 +40,9 @@ import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) class RebalanceServiceTest { + private static final Coins FEE_FOR_TWO_REBALANCES = Coins.ofMilliSatoshis(20); + private static final Coins AMOUNT_FOR_TWO_REBALANCES = Coins.ofMilliSatoshis(246); + @InjectMocks private RebalanceService rebalanceService; @@ -49,124 +53,165 @@ class RebalanceServiceTest { private ChannelService channelService; @Test - void getRebalancesFromPeer() { - Set selfPayments = mockTwoChannelsAndPaymentsFromPeer(); - assertThat(rebalanceService.getRebalancesFromPeer(PUBKEY)).isEqualTo(selfPayments); + void getRebalanceReportForChannel_empty() { + assertThat(rebalanceService.getReportForChannel(CHANNEL_ID)).isEqualTo(RebalanceReport.EMPTY); } @Test - void getRebalancesToPeer() { - Set selfPayments = mockTwoChannelsAndPaymentsToPeer(); - assertThat(rebalanceService.getRebalancesToPeer(PUBKEY)).isEqualTo(selfPayments); - } - - @Test - void getRebalanceAmountFromPeer() { - mockTwoChannelsAndPaymentsFromPeer(); - assertThat(rebalanceService.getRebalanceAmountFromPeer(PUBKEY)).isEqualTo(AMOUNT_PAID.add(AMOUNT_PAID)); - } - - @Test - void getRebalanceAmountToPeer() { - mockTwoChannelsAndPaymentsToPeer(); - assertThat(rebalanceService.getRebalanceAmountToPeer(PUBKEY)).isEqualTo(AMOUNT_PAID.add(AMOUNT_PAID)); - } - - @Test - void getRebalanceAmountFromChannel() { + void getRebalanceReportForChannel_source() { + RebalanceReport expected = + new RebalanceReport(FEE_FOR_TWO_REBALANCES, AMOUNT_FOR_TWO_REBALANCES, Coins.NONE, Coins.NONE); mockSelfPaymentsFromChannel("from " + CHANNEL_ID.getShortChannelId()); - assertThat(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).isEqualTo(AMOUNT_PAID.add(AMOUNT_PAID)); + assertThat(rebalanceService.getReportForChannel(CHANNEL_ID)).isEqualTo(expected); } @Test - void getRebalanceAmountToChannel() { + void getRebalanceReportForChannel_target() { + RebalanceReport expected = + new RebalanceReport(Coins.NONE, Coins.NONE, FEE_FOR_TWO_REBALANCES, AMOUNT_FOR_TWO_REBALANCES); mockSelfPaymentsToChannel("to " + CHANNEL_ID_2.getShortChannelId()); - assertThat(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID_2)).isEqualTo(AMOUNT_PAID.add(AMOUNT_PAID)); + assertThat(rebalanceService.getReportForChannel(CHANNEL_ID_2)).isEqualTo(expected); } @Test - void getRebalancesFromChannel_short_channel_id_in_memo() { - mockSelfPaymentsFromChannel("rebalance from " + CHANNEL_ID.getShortChannelId()); - assertThat(rebalanceService.getRebalancesFromChannel(CHANNEL_ID)).hasSize(2); + void getRebalanceReportForPeer_source() { + RebalanceReport expected = + new RebalanceReport(FEE_FOR_TWO_REBALANCES, AMOUNT_FOR_TWO_REBALANCES, Coins.NONE, Coins.NONE); + mockTwoChannelsAndPaymentsFromPeer(); + assertThat(rebalanceService.getReportForPeer(PUBKEY)).isEqualTo(expected); } @Test - void getRebalanceSourceCostsForChannel_compact_channel_id_in_memo() { + void getRebalanceReportForPeer_target() { + RebalanceReport expected = + new RebalanceReport(Coins.NONE, Coins.NONE, FEE_FOR_TWO_REBALANCES, AMOUNT_FOR_TWO_REBALANCES); + mockTwoChannelsAndPaymentsToPeer(); + assertThat(rebalanceService.getReportForPeer(PUBKEY)).isEqualTo(expected); + } + + @Test + void getSourceCostsForChannel() { + mockSelfPaymentsFromChannel("from " + CHANNEL_ID.getShortChannelId()); + assertThat(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).isEqualTo(FEE_FOR_TWO_REBALANCES); + } + + @Test + void getTargetCostsForChannel() { + mockSelfPaymentsToChannel("to " + CHANNEL_ID_2.getShortChannelId()); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(FEE_FOR_TWO_REBALANCES); + } + + @Test + void getSourceCostsForPeer() { + mockTwoChannelsAndPaymentsFromPeer(); + assertThat(rebalanceService.getSourceCostsForPeer(PUBKEY)).isEqualTo(FEE_FOR_TWO_REBALANCES); + } + + @Test + void getTargetCostsForPeer() { + mockTwoChannelsAndPaymentsToPeer(); + assertThat(rebalanceService.getTargetCostsForPeer(PUBKEY)).isEqualTo(FEE_FOR_TWO_REBALANCES); + } + + @Test + void getAmountFromPeer() { + mockTwoChannelsAndPaymentsFromPeer(); + assertThat(rebalanceService.getAmountFromPeer(PUBKEY)).isEqualTo(AMOUNT_FOR_TWO_REBALANCES); + } + + @Test + void getAmountToPeer() { + mockTwoChannelsAndPaymentsToPeer(); + assertThat(rebalanceService.getAmountToPeer(PUBKEY)).isEqualTo(AMOUNT_FOR_TWO_REBALANCES); + } + + @Test + void getAmountFromChannel() { + mockSelfPaymentsFromChannel("from " + CHANNEL_ID.getShortChannelId()); + assertThat(rebalanceService.getAmountFromChannel(CHANNEL_ID)).isEqualTo(AMOUNT_FOR_TWO_REBALANCES); + } + + @Test + void getAmountToChannel() { + mockSelfPaymentsToChannel("to " + CHANNEL_ID_2.getShortChannelId()); + assertThat(rebalanceService.getAmountToChannel(CHANNEL_ID_2)).isEqualTo(AMOUNT_FOR_TWO_REBALANCES); + } + + @Test + void getSourceCostsForChannel_short_channel_id_as_infix_in_memo() { + mockSelfPaymentsFromChannel("111" + CHANNEL_ID.getShortChannelId() + "222"); + assertThat(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).isEqualTo(FEE_FOR_TWO_REBALANCES); + } + + @Test + void getSourceCostsForChannel_compact_channel_id_in_memo() { mockSelfPaymentsFromChannel("rebalance from " + CHANNEL_ID.getCompactForm()); - assertThat(rebalanceService.getRebalancesFromChannel(CHANNEL_ID)).hasSize(2); + assertThat(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalanceSourceCostsForChannel_compact_lnd_channel_id_in_memo() { + void getSourceCostsForChannel_compact_lnd_channel_id_in_memo() { mockSelfPaymentsFromChannel("rebalance from " + CHANNEL_ID.getCompactFormLnd()); - assertThat(rebalanceService.getRebalancesFromChannel(CHANNEL_ID)).hasSize(2); + assertThat(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalanceSourceCostsForChannel_id_not_in_memo() { + void getSourceCostsForChannel_id_not_in_memo() { mockSelfPaymentsFromChannel("something"); - assertThat(rebalanceService.getRebalancesFromChannel(CHANNEL_ID)).isEmpty(); + assertThat(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).isEqualTo(Coins.NONE); } @Test - void getRebalancesToChannel_no_self_payments() { - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).isEmpty(); + void getTargetCostsForChannel_no_self_payments() { + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(Coins.NONE); } @Test - void getRebalancesToChannel_short_channel_id_in_memo() { + void getTargetCostsForChannel_short_channel_id_in_memo() { mockSelfPaymentsToChannel("foo bar " + CHANNEL_ID_2.getShortChannelId() + "!"); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).hasSize(2); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalancesToChannel_compact_channel_id_in_memo() { - mockSelfPaymentsToChannel("something something " + CHANNEL_ID_2.getCompactForm()); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).hasSize(2); + void getTargetCostsForChannel_compact_channel_id_in_memo() { + mockSelfPaymentsToChannel("111" + CHANNEL_ID_2.getCompactForm() + "222"); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalancesToChannel_compact_lnd_channel_id_in_memo() { + void getTargetCostsForChannel_compact_lnd_channel_id_in_memo() { mockSelfPaymentsToChannel(CHANNEL_ID_2.getCompactFormLnd()); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).hasSize(2); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalancesToChannel_id_not_in_memo() { + void getTargetCostsForChannel_id_not_in_memo() { mockSelfPaymentsToChannel("something"); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).hasSize(2); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalancesToChannel_other_channel_id_in_memo() { + void getTargetCostsForChannel_other_channel_id_in_memo() { mockSelfPaymentsToChannel("rebalance to " + CHANNEL_ID_3); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).hasSize(2); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(FEE_FOR_TWO_REBALANCES); } @Test - void getRebalancesToChannel_source_channel_id_in_memo() { + void getTargetCostsForChannel_source_channel_id_in_memo() { mockSelfPaymentsToChannel("something: " + CHANNEL_ID); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).isEmpty(); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(Coins.NONE); } @Test - void getRebalancesToChannel_without_first_channel_information() { + void getTargetCostsForChannel_source_channel_not_known() { + List noRoute = List.of(new PaymentRoute(List.of())); Payment payment = new Payment( - PAYMENT_INDEX, PAYMENT_HASH, PAYMENT_CREATION_DATE_TIME, PAYMENT_VALUE, PAYMENT_FEES, List.of() + PAYMENT_INDEX, PAYMENT_HASH, PAYMENT_CREATION_DATE_TIME, PAYMENT_VALUE, PAYMENT_FEES, noRoute ); - SettledInvoice settledInvoice = new SettledInvoice( - ADD_INDEX, - SETTLE_INDEX, - SETTLE_DATE, - HASH, - AMOUNT_PAID, - "something: " + CHANNEL_ID, - Optional.empty(), - Optional.of(CHANNEL_ID_2) - ); - SelfPayment selfPayment = new SelfPayment(payment, settledInvoice); - when(selfPaymentsService.getSelfPaymentsToChannel(CHANNEL_ID_2)).thenReturn(List.of(selfPayment)); - assertThat(rebalanceService.getRebalancesToChannel(CHANNEL_ID_2)).containsExactly(selfPayment); + SettledInvoice settledInvoice = getSettledInvoice("something", 0); + when(selfPaymentsService.getSelfPaymentsToChannel(CHANNEL_ID_2)) + .thenReturn(List.of(new SelfPayment(payment, settledInvoice))); + assertThat(rebalanceService.getTargetCostsForChannel(CHANNEL_ID_2)).isEqualTo(PAYMENT_FEES); } private void mockSelfPaymentsFromChannel(String memo) { @@ -188,7 +233,12 @@ class RebalanceServiceTest { Payment payment = new Payment( PAYMENT_INDEX, PAYMENT_HASH, PAYMENT_CREATION_DATE_TIME, PAYMENT_VALUE, PAYMENT_FEES, routes ); - SettledInvoice settledInvoice = new SettledInvoice( + SettledInvoice settledInvoice = getSettledInvoice(memo, offset); + return new SelfPayment(payment, settledInvoice); + } + + private SettledInvoice getSettledInvoice(String memo, int offset) { + return new SettledInvoice( ADD_INDEX, SETTLE_INDEX, SETTLE_DATE.plusSeconds(offset), @@ -198,7 +248,6 @@ class RebalanceServiceTest { Optional.empty(), Optional.of(CHANNEL_ID_2) ); - return new SelfPayment(payment, settledInvoice); } private List getSingleRoute() { @@ -208,27 +257,23 @@ class RebalanceServiceTest { return List.of(route); } - private Set mockTwoChannelsAndPaymentsToPeer() { + private void mockTwoChannelsAndPaymentsToPeer() { ChannelId id1 = LOCAL_OPEN_CHANNEL_3.getId(); ChannelId id2 = CLOSED_CHANNEL_2.getId(); when(channelService.getAllChannelsWith(PUBKEY)).thenReturn(Set.of(LOCAL_OPEN_CHANNEL_3, CLOSED_CHANNEL_2)); SelfPayment selfPayment1 = getSelfPayment(id1.toString(), 0); SelfPayment selfPayment2 = getSelfPayment(id2.toString(), 1); - Set selfPayments = Set.of(selfPayment1, selfPayment2); when(selfPaymentsService.getSelfPaymentsToChannel(id1)).thenReturn(List.of(selfPayment1)); when(selfPaymentsService.getSelfPaymentsToChannel(id2)).thenReturn(List.of(selfPayment2)); - return selfPayments; } - private Set mockTwoChannelsAndPaymentsFromPeer() { + private void mockTwoChannelsAndPaymentsFromPeer() { ChannelId id1 = LOCAL_OPEN_CHANNEL.getId(); ChannelId id2 = CLOSED_CHANNEL_2.getId(); when(channelService.getAllChannelsWith(PUBKEY)).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, CLOSED_CHANNEL_2)); SelfPayment selfPayment1 = getSelfPayment(id1.toString(), 0); SelfPayment selfPayment2 = getSelfPayment(id2.toString(), 1); - Set selfPayments = Set.of(selfPayment1, selfPayment2); when(selfPaymentsService.getSelfPaymentsFromChannel(id1)).thenReturn(List.of(selfPayment1)); when(selfPaymentsService.getSelfPaymentsFromChannel(id2)).thenReturn(List.of(selfPayment2)); - return selfPayments; } } \ No newline at end of file diff --git a/model/src/main/java/de/cotto/lndmanagej/model/ChannelDetails.java b/model/src/main/java/de/cotto/lndmanagej/model/ChannelDetails.java new file mode 100644 index 00000000..9c148047 --- /dev/null +++ b/model/src/main/java/de/cotto/lndmanagej/model/ChannelDetails.java @@ -0,0 +1,12 @@ +package de.cotto.lndmanagej.model; + +public record ChannelDetails( + LocalChannel localChannel, + String remoteAlias, + BalanceInformation balanceInformation, + OnChainCosts onChainCosts, + Policies policies, + FeeReport feeReport, + RebalanceReport rebalanceReport +) { +} diff --git a/model/src/main/java/de/cotto/lndmanagej/model/OffChainCosts.java b/model/src/main/java/de/cotto/lndmanagej/model/OffChainCosts.java deleted file mode 100644 index db408f9e..00000000 --- a/model/src/main/java/de/cotto/lndmanagej/model/OffChainCosts.java +++ /dev/null @@ -1,15 +0,0 @@ -package de.cotto.lndmanagej.model; - -public record OffChainCosts( - Coins rebalanceSource, - Coins rebalanceTarget -) { - public static final OffChainCosts NONE = new OffChainCosts(Coins.NONE, Coins.NONE); - - public OffChainCosts add(OffChainCosts other) { - return new OffChainCosts( - rebalanceSource.add(other.rebalanceSource), - rebalanceTarget.add(other.rebalanceTarget) - ); - } -} diff --git a/model/src/main/java/de/cotto/lndmanagej/model/Policies.java b/model/src/main/java/de/cotto/lndmanagej/model/Policies.java index dcc2c23b..7a10a432 100644 --- a/model/src/main/java/de/cotto/lndmanagej/model/Policies.java +++ b/model/src/main/java/de/cotto/lndmanagej/model/Policies.java @@ -4,4 +4,5 @@ public record Policies( Policy local, Policy remote ) { + public static final Policies UNKNOWN = new Policies(Policy.UNKNOWN, Policy.UNKNOWN); } diff --git a/model/src/main/java/de/cotto/lndmanagej/model/Policy.java b/model/src/main/java/de/cotto/lndmanagej/model/Policy.java index 2333f279..6d9be845 100644 --- a/model/src/main/java/de/cotto/lndmanagej/model/Policy.java +++ b/model/src/main/java/de/cotto/lndmanagej/model/Policy.java @@ -1,4 +1,5 @@ package de.cotto.lndmanagej.model; public record Policy(long feeRate, Coins baseFee, boolean enabled) { + public static final Policy UNKNOWN = new Policy(0, Coins.NONE, false); } diff --git a/model/src/main/java/de/cotto/lndmanagej/model/RebalanceReport.java b/model/src/main/java/de/cotto/lndmanagej/model/RebalanceReport.java new file mode 100644 index 00000000..ccd55aa3 --- /dev/null +++ b/model/src/main/java/de/cotto/lndmanagej/model/RebalanceReport.java @@ -0,0 +1,10 @@ +package de.cotto.lndmanagej.model; + +public record RebalanceReport( + Coins sourceCost, + Coins sourceAmount, + Coins targetCost, + Coins targetAmount +) { + public static final RebalanceReport EMPTY = new RebalanceReport(Coins.NONE, Coins.NONE, Coins.NONE, Coins.NONE); +} diff --git a/model/src/test/java/de/cotto/lndmanagej/model/ChannelDetailsTest.java b/model/src/test/java/de/cotto/lndmanagej/model/ChannelDetailsTest.java new file mode 100644 index 00000000..1d94ec70 --- /dev/null +++ b/model/src/test/java/de/cotto/lndmanagej/model/ChannelDetailsTest.java @@ -0,0 +1,50 @@ +package de.cotto.lndmanagej.model; + +import org.junit.jupiter.api.Test; + +import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION; +import static de.cotto.lndmanagej.model.ChannelDetailsFixtures.CHANNEL_DETAILS; +import static de.cotto.lndmanagej.model.FeeReportFixtures.FEE_REPORT; +import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_PRIVATE; +import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS; +import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; +import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES; +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; +import static org.assertj.core.api.Assertions.assertThat; + +class ChannelDetailsTest { + @Test + void localChannel() { + assertThat(CHANNEL_DETAILS.localChannel()).isEqualTo(LOCAL_OPEN_CHANNEL_PRIVATE); + } + + @Test + void remoteAlias() { + assertThat(CHANNEL_DETAILS.remoteAlias()).isEqualTo(ALIAS); + } + + @Test + void balanceInformation() { + assertThat(CHANNEL_DETAILS.balanceInformation()).isEqualTo(BALANCE_INFORMATION); + } + + @Test + void onChainCosts() { + assertThat(CHANNEL_DETAILS.onChainCosts()).isEqualTo(ON_CHAIN_COSTS); + } + + @Test + void policies() { + assertThat(CHANNEL_DETAILS.policies()).isEqualTo(POLICIES); + } + + @Test + void feeReport() { + assertThat(CHANNEL_DETAILS.feeReport()).isEqualTo(FEE_REPORT); + } + + @Test + void rebalanceReport() { + assertThat(CHANNEL_DETAILS.rebalanceReport()).isEqualTo(REBALANCE_REPORT); + } +} \ No newline at end of file diff --git a/model/src/test/java/de/cotto/lndmanagej/model/FeeReportTest.java b/model/src/test/java/de/cotto/lndmanagej/model/FeeReportTest.java index 94920526..c667c0a0 100644 --- a/model/src/test/java/de/cotto/lndmanagej/model/FeeReportTest.java +++ b/model/src/test/java/de/cotto/lndmanagej/model/FeeReportTest.java @@ -2,12 +2,10 @@ package de.cotto.lndmanagej.model; import org.junit.jupiter.api.Test; +import static de.cotto.lndmanagej.model.FeeReportFixtures.FEE_REPORT; import static org.assertj.core.api.Assertions.assertThat; class FeeReportTest { - - private static final FeeReport FEE_REPORT = new FeeReport(Coins.ofMilliSatoshis(1_234), Coins.ofMilliSatoshis(567)); - @Test void earned() { assertThat(FEE_REPORT.earned()).isEqualTo(Coins.ofMilliSatoshis(1_234)); diff --git a/model/src/test/java/de/cotto/lndmanagej/model/OffChainCostsTest.java b/model/src/test/java/de/cotto/lndmanagej/model/OffChainCostsTest.java deleted file mode 100644 index 0a6cefe5..00000000 --- a/model/src/test/java/de/cotto/lndmanagej/model/OffChainCostsTest.java +++ /dev/null @@ -1,36 +0,0 @@ -package de.cotto.lndmanagej.model; - -import org.junit.jupiter.api.Test; - -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; -import static org.assertj.core.api.Assertions.assertThat; - -class OffChainCostsTest { - @Test - void none() { - assertThat(OffChainCosts.NONE).isEqualTo(new OffChainCosts(Coins.NONE, Coins.NONE)); - } - - @Test - void add_none_to_none() { - assertThat(OffChainCosts.NONE.add(OffChainCosts.NONE)).isEqualTo(OffChainCosts.NONE); - } - - @Test - void add() { - assertThat(OFF_CHAIN_COSTS.add(OFF_CHAIN_COSTS)).isEqualTo(new OffChainCosts( - Coins.ofSatoshis(2000), - Coins.ofSatoshis(4000) - )); - } - - @Test - void rebalanceSourceCosts() { - assertThat(OFF_CHAIN_COSTS.rebalanceSource()).isEqualTo(Coins.ofSatoshis(1000)); - } - - @Test - void rebalanceTargetCosts() { - assertThat(OFF_CHAIN_COSTS.rebalanceTarget()).isEqualTo(Coins.ofSatoshis(2000)); - } -} \ No newline at end of file diff --git a/model/src/test/java/de/cotto/lndmanagej/model/PoliciesTest.java b/model/src/test/java/de/cotto/lndmanagej/model/PoliciesTest.java index 809aa00a..0e082c95 100644 --- a/model/src/test/java/de/cotto/lndmanagej/model/PoliciesTest.java +++ b/model/src/test/java/de/cotto/lndmanagej/model/PoliciesTest.java @@ -17,4 +17,9 @@ class PoliciesTest { void remote() { assertThat(POLICIES.remote()).isEqualTo(POLICY_2); } + + @Test + void unknown() { + assertThat(Policies.UNKNOWN).isEqualTo(new Policies(Policy.UNKNOWN, Policy.UNKNOWN)); + } } diff --git a/model/src/test/java/de/cotto/lndmanagej/model/PolicyTest.java b/model/src/test/java/de/cotto/lndmanagej/model/PolicyTest.java index 988992ae..f4901852 100644 --- a/model/src/test/java/de/cotto/lndmanagej/model/PolicyTest.java +++ b/model/src/test/java/de/cotto/lndmanagej/model/PolicyTest.java @@ -20,4 +20,9 @@ class PolicyTest { void enabled() { assertThat(POLICY_1.enabled()).isFalse(); } + + @Test + void unknown() { + assertThat(Policy.UNKNOWN).isEqualTo(new Policy(0, Coins.NONE, false)); + } } \ No newline at end of file diff --git a/model/src/test/java/de/cotto/lndmanagej/model/RebalanceReportTest.java b/model/src/test/java/de/cotto/lndmanagej/model/RebalanceReportTest.java new file mode 100644 index 00000000..8c3fcd69 --- /dev/null +++ b/model/src/test/java/de/cotto/lndmanagej/model/RebalanceReportTest.java @@ -0,0 +1,35 @@ +package de.cotto.lndmanagej.model; + +import org.junit.jupiter.api.Test; + +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; +import static org.assertj.core.api.Assertions.assertThat; + +class RebalanceReportTest { + + @Test + void empty() { + RebalanceReport empty = new RebalanceReport(Coins.NONE, Coins.NONE, Coins.NONE, Coins.NONE); + assertThat(RebalanceReport.EMPTY).isEqualTo(empty); + } + + @Test + void sourceCost() { + assertThat(REBALANCE_REPORT.sourceCost()).isEqualTo(Coins.ofSatoshis(1000)); + } + + @Test + void sourceAmount() { + assertThat(REBALANCE_REPORT.sourceAmount()).isEqualTo(Coins.ofSatoshis(665)); + } + + @Test + void targetCost() { + assertThat(REBALANCE_REPORT.targetCost()).isEqualTo(Coins.ofSatoshis(2000)); + } + + @Test + void targetAmount() { + assertThat(REBALANCE_REPORT.targetAmount()).isEqualTo(Coins.ofSatoshis(991)); + } +} \ No newline at end of file diff --git a/model/src/testFixtures/java/de/cotto/lndmanagej/model/ChannelDetailsFixtures.java b/model/src/testFixtures/java/de/cotto/lndmanagej/model/ChannelDetailsFixtures.java new file mode 100644 index 00000000..a6b58d04 --- /dev/null +++ b/model/src/testFixtures/java/de/cotto/lndmanagej/model/ChannelDetailsFixtures.java @@ -0,0 +1,32 @@ +package de.cotto.lndmanagej.model; + +import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION; +import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL; +import static de.cotto.lndmanagej.model.FeeReportFixtures.FEE_REPORT; +import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_PRIVATE; +import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS; +import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; +import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES; +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; + +public class ChannelDetailsFixtures { + public static final ChannelDetails CHANNEL_DETAILS = new ChannelDetails( + LOCAL_OPEN_CHANNEL_PRIVATE, + ALIAS, + BALANCE_INFORMATION, + ON_CHAIN_COSTS, + POLICIES, + FEE_REPORT, + REBALANCE_REPORT + ); + + public static final ChannelDetails CHANNEL_DETAILS_CLOSED = new ChannelDetails( + CLOSED_CHANNEL, + ALIAS, + BalanceInformation.EMPTY, + ON_CHAIN_COSTS, + Policies.UNKNOWN, + FEE_REPORT, + REBALANCE_REPORT + ); +} diff --git a/model/src/testFixtures/java/de/cotto/lndmanagej/model/FeeReportFixtures.java b/model/src/testFixtures/java/de/cotto/lndmanagej/model/FeeReportFixtures.java new file mode 100644 index 00000000..a5ab58d6 --- /dev/null +++ b/model/src/testFixtures/java/de/cotto/lndmanagej/model/FeeReportFixtures.java @@ -0,0 +1,5 @@ +package de.cotto.lndmanagej.model; + +public class FeeReportFixtures { + public static final FeeReport FEE_REPORT = new FeeReport(Coins.ofMilliSatoshis(1_234), Coins.ofMilliSatoshis(567)); +} diff --git a/model/src/testFixtures/java/de/cotto/lndmanagej/model/OffChainCostsFixtures.java b/model/src/testFixtures/java/de/cotto/lndmanagej/model/OffChainCostsFixtures.java deleted file mode 100644 index 7dc4a209..00000000 --- a/model/src/testFixtures/java/de/cotto/lndmanagej/model/OffChainCostsFixtures.java +++ /dev/null @@ -1,8 +0,0 @@ -package de.cotto.lndmanagej.model; - -public class OffChainCostsFixtures { - public static final OffChainCosts OFF_CHAIN_COSTS = new OffChainCosts( - Coins.ofSatoshis(1000), - Coins.ofSatoshis(2000) - ); -} diff --git a/model/src/testFixtures/java/de/cotto/lndmanagej/model/RebalanceReportFixtures.java b/model/src/testFixtures/java/de/cotto/lndmanagej/model/RebalanceReportFixtures.java new file mode 100644 index 00000000..22022677 --- /dev/null +++ b/model/src/testFixtures/java/de/cotto/lndmanagej/model/RebalanceReportFixtures.java @@ -0,0 +1,10 @@ +package de.cotto.lndmanagej.model; + +public class RebalanceReportFixtures { + public static final RebalanceReport REBALANCE_REPORT = new RebalanceReport( + Coins.ofSatoshis(1000), + Coins.ofSatoshis(665), + Coins.ofSatoshis(2000), + Coins.ofSatoshis(991) + ); +} diff --git a/web/src/integrationTest/java/de/cotto/lndmanagej/controller/ChannelControllerIT.java b/web/src/integrationTest/java/de/cotto/lndmanagej/controller/ChannelControllerIT.java index 00c4bf1c..309ba28f 100644 --- a/web/src/integrationTest/java/de/cotto/lndmanagej/controller/ChannelControllerIT.java +++ b/web/src/integrationTest/java/de/cotto/lndmanagej/controller/ChannelControllerIT.java @@ -3,16 +3,12 @@ package de.cotto.lndmanagej.controller; import de.cotto.lndmanagej.model.ChannelIdResolver; import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.FeeReport; -import de.cotto.lndmanagej.model.OffChainCosts; -import de.cotto.lndmanagej.model.OnChainCosts; import de.cotto.lndmanagej.service.BalanceService; +import de.cotto.lndmanagej.service.ChannelDetailsService; import de.cotto.lndmanagej.service.ChannelService; import de.cotto.lndmanagej.service.FeeService; import de.cotto.lndmanagej.service.NodeService; -import de.cotto.lndmanagej.service.OffChainCostService; -import de.cotto.lndmanagej.service.OnChainCostService; import de.cotto.lndmanagej.service.PolicyService; -import de.cotto.lndmanagej.service.RebalanceService; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; @@ -22,6 +18,8 @@ import org.springframework.test.web.servlet.MockMvc; import java.util.Optional; import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION_2; +import static de.cotto.lndmanagej.model.ChannelDetailsFixtures.CHANNEL_DETAILS; +import static de.cotto.lndmanagej.model.ChannelDetailsFixtures.CHANNEL_DETAILS_CLOSED; import static de.cotto.lndmanagej.model.ChannelFixtures.CAPACITY; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_2; @@ -36,9 +34,8 @@ import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.TOTAL_RECEIVED; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.TOTAL_RECEIVED_2; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.TOTAL_SENT; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.TOTAL_SENT_2; +import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS; import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_2; -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; -import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES; import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2; import static org.hamcrest.core.Is.is; @@ -67,12 +64,6 @@ class ChannelControllerIT { @SuppressWarnings("unused") private ChannelIdResolver channelIdResolver; - @MockBean - private OnChainCostService onChainCostService; - - @MockBean - private OffChainCostService offChainCostService; - @MockBean private BalanceService balanceService; @@ -83,7 +74,7 @@ class ChannelControllerIT { private FeeService feeService; @MockBean - private RebalanceService rebalanceService; + private ChannelDetailsService channelDetailsService; @Test void getBasicInformation_not_found() throws Exception { @@ -131,22 +122,15 @@ class ChannelControllerIT { @Test void getChannelDetails() throws Exception { - when(policyService.getPolicies(CHANNEL_ID)).thenReturn(POLICIES); - when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2); when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(LOCAL_OPEN_CHANNEL_PRIVATE)); - when(onChainCostService.getOnChainCostsForChannelId(CHANNEL_ID)).thenReturn(ON_CHAIN_COSTS); - when(offChainCostService.getOffChainCostsForChannel(CHANNEL_ID)).thenReturn(OFF_CHAIN_COSTS); - when(balanceService.getBalanceInformation(CHANNEL_ID)).thenReturn(Optional.of(BALANCE_INFORMATION_2)); - when(feeService.getFeeReportForChannel(CHANNEL_ID)).thenReturn(FEE_REPORT); - when(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(1)); - when(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(2)); + when(channelDetailsService.getDetails(LOCAL_OPEN_CHANNEL_PRIVATE)).thenReturn(CHANNEL_DETAILS); mockMvc.perform(get(DETAILS_PREFIX)) .andExpect(jsonPath("$.channelIdShort", is(String.valueOf(CHANNEL_ID.getShortChannelId())))) .andExpect(jsonPath("$.channelIdCompact", is(CHANNEL_ID.getCompactForm()))) .andExpect(jsonPath("$.channelIdCompactLnd", is(CHANNEL_ID.getCompactFormLnd()))) .andExpect(jsonPath("$.channelPoint", is(CHANNEL_POINT.toString()))) .andExpect(jsonPath("$.remotePubkey", is(PUBKEY_2.toString()))) - .andExpect(jsonPath("$.remoteAlias", is(ALIAS_2))) + .andExpect(jsonPath("$.remoteAlias", is(ALIAS))) .andExpect(jsonPath("$.capacity", is(String.valueOf(CAPACITY.satoshis())))) .andExpect(jsonPath("$.totalSent", is(String.valueOf(TOTAL_SENT.satoshis())))) .andExpect(jsonPath("$.totalReceived", is(String.valueOf(TOTAL_RECEIVED.satoshis())))) @@ -159,16 +143,16 @@ class ChannelControllerIT { .andExpect(jsonPath("$.onChainCosts.openCosts", is("1000"))) .andExpect(jsonPath("$.onChainCosts.closeCosts", is("2000"))) .andExpect(jsonPath("$.onChainCosts.sweepCosts", is("3000"))) - .andExpect(jsonPath("$.offChainCosts.rebalanceSource", is("1000000"))) - .andExpect(jsonPath("$.offChainCosts.rebalanceTarget", is("2000000"))) - .andExpect(jsonPath("$.rebalanceSourceAmount", is("1"))) - .andExpect(jsonPath("$.rebalanceTargetAmount", is("2"))) - .andExpect(jsonPath("$.balance.localBalance", is("2000"))) - .andExpect(jsonPath("$.balance.localReserve", is("200"))) - .andExpect(jsonPath("$.balance.localAvailable", is("1800"))) - .andExpect(jsonPath("$.balance.remoteBalance", is("223"))) - .andExpect(jsonPath("$.balance.remoteReserve", is("20"))) - .andExpect(jsonPath("$.balance.remoteAvailable", is("203"))) + .andExpect(jsonPath("$.rebalanceReport.sourceCosts", is("1000000"))) + .andExpect(jsonPath("$.rebalanceReport.sourceAmount", is("665000"))) + .andExpect(jsonPath("$.rebalanceReport.targetCosts", is("2000000"))) + .andExpect(jsonPath("$.rebalanceReport.targetAmount", is("991000"))) + .andExpect(jsonPath("$.balance.localBalance", is("1000"))) + .andExpect(jsonPath("$.balance.localReserve", is("100"))) + .andExpect(jsonPath("$.balance.localAvailable", is("900"))) + .andExpect(jsonPath("$.balance.remoteBalance", is("123"))) + .andExpect(jsonPath("$.balance.remoteReserve", is("10"))) + .andExpect(jsonPath("$.balance.remoteAvailable", is("113"))) .andExpect(jsonPath("$.policies.local.enabled", is(false))) .andExpect(jsonPath("$.policies.remote.enabled", is(true))) .andExpect(jsonPath("$.policies.local.feeRatePpm", is(100))) @@ -182,11 +166,7 @@ class ChannelControllerIT { @Test void getChannelDetails_closed_channel() throws Exception { when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(CLOSED_CHANNEL)); - when(feeService.getFeeReportForChannel(CHANNEL_ID)).thenReturn(new FeeReport(Coins.NONE, Coins.NONE)); - when(onChainCostService.getOnChainCostsForChannelId(CHANNEL_ID)).thenReturn(OnChainCosts.NONE); - when(offChainCostService.getOffChainCostsForChannel(CHANNEL_ID)).thenReturn(OffChainCosts.NONE); - when(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).thenReturn(Coins.NONE); - when(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID)).thenReturn(Coins.NONE); + when(channelDetailsService.getDetails(CLOSED_CHANNEL)).thenReturn(CHANNEL_DETAILS_CLOSED); mockMvc.perform(get(DETAILS_PREFIX)) .andExpect(jsonPath("$.closeDetails.initiator", is("REMOTE"))) .andExpect(jsonPath("$.closeDetails.height", is(987_654))) diff --git a/web/src/integrationTest/java/de/cotto/lndmanagej/controller/NodeControllerIT.java b/web/src/integrationTest/java/de/cotto/lndmanagej/controller/NodeControllerIT.java index a6f21913..32e3c55a 100644 --- a/web/src/integrationTest/java/de/cotto/lndmanagej/controller/NodeControllerIT.java +++ b/web/src/integrationTest/java/de/cotto/lndmanagej/controller/NodeControllerIT.java @@ -8,7 +8,6 @@ import de.cotto.lndmanagej.service.BalanceService; import de.cotto.lndmanagej.service.ChannelService; import de.cotto.lndmanagej.service.FeeService; import de.cotto.lndmanagej.service.NodeService; -import de.cotto.lndmanagej.service.OffChainCostService; import de.cotto.lndmanagej.service.OnChainCostService; import de.cotto.lndmanagej.service.RebalanceService; import org.junit.jupiter.api.Test; @@ -21,6 +20,7 @@ import java.util.List; import java.util.Set; import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION; +import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION_2; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_2; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_3; @@ -31,9 +31,9 @@ import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHAN import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_2; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_3; import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_2; -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2; +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; import static de.cotto.lndmanagej.model.WaitingCloseChannelFixtures.WAITING_CLOSE_CHANNEL; import static org.hamcrest.core.Is.is; import static org.mockito.Mockito.when; @@ -58,9 +58,6 @@ class NodeControllerIT { @MockBean private OnChainCostService onChainCostService; - @MockBean - private OffChainCostService offChainCostService; - @MockBean @SuppressWarnings("unused") private ChannelIdResolver channelIdResolver; @@ -89,11 +86,9 @@ class NodeControllerIT { when(channelService.getWaitingCloseChannelsWith(PUBKEY_2)).thenReturn(Set.of(WAITING_CLOSE_CHANNEL)); when(channelService.getForceClosingChannelsWith(PUBKEY_2)).thenReturn(Set.of(FORCE_CLOSING_CHANNEL_2)); when(onChainCostService.getOnChainCostsForPeer(PUBKEY_2)).thenReturn(ON_CHAIN_COSTS); - when(offChainCostService.getOffChainCostsForPeer(PUBKEY_2)).thenReturn(OFF_CHAIN_COSTS); - when(balanceService.getBalanceInformationForPeer(PUBKEY_2)).thenReturn(BALANCE_INFORMATION); + when(balanceService.getBalanceInformationForPeer(PUBKEY_2)).thenReturn(BALANCE_INFORMATION_2); when(feeService.getFeeReportForPeer(PUBKEY_2)).thenReturn(FEE_REPORT); - when(rebalanceService.getRebalanceAmountFromPeer(PUBKEY_2)).thenReturn(Coins.ofMilliSatoshis(1)); - when(rebalanceService.getRebalanceAmountToPeer(PUBKEY_2)).thenReturn(Coins.ofMilliSatoshis(2)); + when(rebalanceService.getReportForPeer(PUBKEY_2)).thenReturn(REBALANCE_REPORT); List channelIds = List.of(CHANNEL_ID.toString(), CHANNEL_ID_2.toString()); List closedChannelIds = List.of(CHANNEL_ID.toString(), CHANNEL_ID_3.toString()); List waitingCloseChannelIds = List.of(CHANNEL_ID.toString()); @@ -105,21 +100,21 @@ class NodeControllerIT { .andExpect(jsonPath("$.closedChannels", is(closedChannelIds))) .andExpect(jsonPath("$.waitingCloseChannels", is(waitingCloseChannelIds))) .andExpect(jsonPath("$.pendingForceClosingChannels", is(forceClosingChannelIds))) - .andExpect(jsonPath("$.offChainCosts.rebalanceSource", is("1000000"))) - .andExpect(jsonPath("$.offChainCosts.rebalanceTarget", is("2000000"))) - .andExpect(jsonPath("$.balance.localBalance", is("1000"))) - .andExpect(jsonPath("$.balance.localReserve", is("100"))) - .andExpect(jsonPath("$.balance.localAvailable", is("900"))) - .andExpect(jsonPath("$.balance.remoteBalance", is("123"))) - .andExpect(jsonPath("$.balance.remoteReserve", is("10"))) - .andExpect(jsonPath("$.balance.remoteAvailable", is("113"))) + .andExpect(jsonPath("$.rebalanceReport.sourceCosts", is("1000000"))) + .andExpect(jsonPath("$.rebalanceReport.targetCosts", is("2000000"))) + .andExpect(jsonPath("$.rebalanceReport.sourceAmount", is("665000"))) + .andExpect(jsonPath("$.rebalanceReport.targetAmount", is("991000"))) + .andExpect(jsonPath("$.balance.localBalance", is("2000"))) + .andExpect(jsonPath("$.balance.localReserve", is("200"))) + .andExpect(jsonPath("$.balance.localAvailable", is("1800"))) + .andExpect(jsonPath("$.balance.remoteBalance", is("223"))) + .andExpect(jsonPath("$.balance.remoteReserve", is("20"))) + .andExpect(jsonPath("$.balance.remoteAvailable", is("203"))) .andExpect(jsonPath("$.feeReport.earned", is("1234"))) .andExpect(jsonPath("$.feeReport.sourced", is("567"))) .andExpect(jsonPath("$.onChainCosts.openCosts", is("1000"))) .andExpect(jsonPath("$.onChainCosts.closeCosts", is("2000"))) .andExpect(jsonPath("$.onChainCosts.sweepCosts", is("3000"))) - .andExpect(jsonPath("$.rebalanceSourceAmount", is("1"))) - .andExpect(jsonPath("$.rebalanceTargetAmount", is("2"))) .andExpect(jsonPath("$.online", is(true))); } diff --git a/web/src/integrationTest/java/de/cotto/lndmanagej/controller/RebalancesControllerIT.java b/web/src/integrationTest/java/de/cotto/lndmanagej/controller/RebalancesControllerIT.java index c2ce84a4..45ff3aa7 100644 --- a/web/src/integrationTest/java/de/cotto/lndmanagej/controller/RebalancesControllerIT.java +++ b/web/src/integrationTest/java/de/cotto/lndmanagej/controller/RebalancesControllerIT.java @@ -2,7 +2,6 @@ package de.cotto.lndmanagej.controller; import de.cotto.lndmanagej.model.ChannelIdResolver; import de.cotto.lndmanagej.model.Coins; -import de.cotto.lndmanagej.service.OffChainCostService; import de.cotto.lndmanagej.service.RebalanceService; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -28,64 +27,61 @@ class RebalancesControllerIT { @SuppressWarnings("unused") private ChannelIdResolver channelIdResolver; - @MockBean - private OffChainCostService offChainCostService; - @MockBean private RebalanceService rebalanceService; @Test void getRebalanceSourceCostsForChannel() throws Exception { - when(offChainCostService.getRebalanceSourceCostsForChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(123)); + when(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(123)); mockMvc.perform(get(CHANNEL_PREFIX + "/rebalance-source-costs/")) .andExpect(content().string("123")); } @Test void getRebalanceSourceAmountForChannel() throws Exception { - when(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(456)); + when(rebalanceService.getAmountFromChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(456)); mockMvc.perform(get(CHANNEL_PREFIX + "/rebalance-source-amount/")) .andExpect(content().string("456")); } @Test void getRebalanceSourceCostsForPeer() throws Exception { - when(offChainCostService.getRebalanceSourceCostsForPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(124)); + when(rebalanceService.getSourceCostsForPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(124)); mockMvc.perform(get(NODE_PREFIX + "/rebalance-source-costs/")) .andExpect(content().string("124")); } @Test void getRebalanceSourceAmountForPeer() throws Exception { - when(rebalanceService.getRebalanceAmountFromPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(666)); + when(rebalanceService.getAmountFromPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(666)); mockMvc.perform(get(NODE_PREFIX + "/rebalance-source-amount/")) .andExpect(content().string("666")); } @Test void getRebalanceTargetCostsForChannel() throws Exception { - when(offChainCostService.getRebalanceTargetCostsForChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(125)); + when(rebalanceService.getTargetCostsForChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(125)); mockMvc.perform(get(CHANNEL_PREFIX + "/rebalance-target-costs/")) .andExpect(content().string("125")); } @Test void getRebalanceTargetAmountForChannel() throws Exception { - when(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(7777)); + when(rebalanceService.getAmountToChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(7777)); mockMvc.perform(get(CHANNEL_PREFIX + "/rebalance-target-amount/")) .andExpect(content().string("7777")); } @Test void getRebalanceTargetCostsForPeer() throws Exception { - when(offChainCostService.getRebalanceTargetCostsForPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(126)); + when(rebalanceService.getTargetCostsForPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(126)); mockMvc.perform(get(NODE_PREFIX + "/rebalance-target-costs/")) .andExpect(content().string("126")); } @Test void getRebalanceTargetAmountForPeer() throws Exception { - when(rebalanceService.getRebalanceAmountToPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(999)); + when(rebalanceService.getAmountToPeer(PUBKEY)).thenReturn(Coins.ofMilliSatoshis(999)); mockMvc.perform(get(NODE_PREFIX + "/rebalance-target-amount/")) .andExpect(content().string("999")); } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/ChannelController.java b/web/src/main/java/de/cotto/lndmanagej/controller/ChannelController.java index 5226ae6d..2f791524 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/ChannelController.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/ChannelController.java @@ -11,59 +11,43 @@ import de.cotto.lndmanagej.controller.dto.PoliciesDto; import de.cotto.lndmanagej.model.BalanceInformation; import de.cotto.lndmanagej.model.ChannelId; import de.cotto.lndmanagej.model.ClosedChannel; -import de.cotto.lndmanagej.model.FeeReport; import de.cotto.lndmanagej.model.LocalChannel; import de.cotto.lndmanagej.model.OpenCloseStatus; import de.cotto.lndmanagej.model.Policies; -import de.cotto.lndmanagej.model.Pubkey; import de.cotto.lndmanagej.service.BalanceService; +import de.cotto.lndmanagej.service.ChannelDetailsService; import de.cotto.lndmanagej.service.ChannelService; import de.cotto.lndmanagej.service.FeeService; -import de.cotto.lndmanagej.service.NodeService; -import de.cotto.lndmanagej.service.OffChainCostService; -import de.cotto.lndmanagej.service.OnChainCostService; import de.cotto.lndmanagej.service.PolicyService; -import de.cotto.lndmanagej.service.RebalanceService; import org.springframework.context.annotation.Import; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; -import javax.annotation.Nullable; - @RestController @Import(ObjectMapperConfiguration.class) @SuppressWarnings("PMD.ExcessiveImports") @RequestMapping("/api/channel/{channelId}") public class ChannelController { private final ChannelService channelService; - private final NodeService nodeService; private final BalanceService balanceService; - private final OnChainCostService onChainCostService; private final PolicyService policyService; private final FeeService feeService; - private final OffChainCostService offChainCostService; - private final RebalanceService rebalanceService; + private final ChannelDetailsService channelDetailsService; public ChannelController( ChannelService channelService, - NodeService nodeService, BalanceService balanceService, - OnChainCostService onChainCostService, PolicyService policyService, FeeService feeService, - OffChainCostService offChainCostService, - RebalanceService rebalanceService + ChannelDetailsService channelDetailsService ) { this.channelService = channelService; - this.nodeService = nodeService; this.balanceService = balanceService; - this.onChainCostService = onChainCostService; this.policyService = policyService; this.feeService = feeService; - this.offChainCostService = offChainCostService; - this.rebalanceService = rebalanceService; + this.channelDetailsService = channelDetailsService; } @Timed @@ -73,8 +57,7 @@ public class ChannelController { if (localChannel == null) { throw new NotFoundException(); } - ClosedChannelDetailsDto closeDetailsForChannel = getCloseDetailsForChannel(localChannel); - return new ChannelDto(localChannel, closeDetailsForChannel); + return new ChannelDto(localChannel); } @Timed @@ -84,20 +67,7 @@ public class ChannelController { if (localChannel == null) { throw new NotFoundException(); } - Pubkey remotePubkey = localChannel.getRemotePubkey(); - String remoteAlias = nodeService.getAlias(remotePubkey); - return new ChannelDetailsDto( - localChannel, - remoteAlias, - getBalanceInformation(channelId), - onChainCostService.getOnChainCostsForChannelId(channelId), - offChainCostService.getOffChainCostsForChannel(channelId), - getPoliciesForChannel(localChannel), - getCloseDetailsForChannel(localChannel), - getFeeReportFromService(localChannel.getId()), - rebalanceService.getRebalanceAmountFromChannel(localChannel.getId()), - rebalanceService.getRebalanceAmountToChannel(localChannel.getId()) - ); + return ChannelDetailsDto.createFromModel(channelDetailsService.getDetails(localChannel)); } @Timed @@ -112,7 +82,10 @@ public class ChannelController { @GetMapping("/policies") public PoliciesDto getPolicies(@PathVariable ChannelId channelId) { LocalChannel localChannel = channelService.getLocalChannel(channelId).orElse(null); - return getPoliciesForChannel(localChannel); + if (localChannel == null || localChannel.getStatus().openCloseStatus() != OpenCloseStatus.OPEN) { + return PoliciesDto.createFromModel(Policies.UNKNOWN); + } + return PoliciesDto.createFromModel(policyService.getPolicies(localChannel.getId())); } @Timed @@ -128,27 +101,7 @@ public class ChannelController { @Timed @GetMapping("/fee-report") public FeeReportDto getFeeReport(@PathVariable ChannelId channelId) { - return FeeReportDto.createFromModel(getFeeReportFromService(channelId)); + return FeeReportDto.createFromModel(feeService.getFeeReportForChannel(channelId)); } - private FeeReport getFeeReportFromService(ChannelId channelId) { - return feeService.getFeeReportForChannel(channelId); - } - - private PoliciesDto getPoliciesForChannel(@Nullable LocalChannel channel) { - if (channel == null || channel.getStatus().openCloseStatus() != OpenCloseStatus.OPEN) { - return PoliciesDto.EMPTY; - } - Policies policies = policyService.getPolicies(channel.getId()); - return PoliciesDto.createFromModel(policies); - } - - private BalanceInformation getBalanceInformation(ChannelId channelId) { - return balanceService.getBalanceInformation(channelId) - .orElse(BalanceInformation.EMPTY); - } - - private ClosedChannelDetailsDto getCloseDetailsForChannel(LocalChannel localChannel) { - return ClosedChannelDetailsDto.createFromModel(localChannel); - } } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/NodeController.java b/web/src/main/java/de/cotto/lndmanagej/controller/NodeController.java index d69b95ad..df77da3d 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/NodeController.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/NodeController.java @@ -6,20 +6,16 @@ import de.cotto.lndmanagej.controller.dto.ChannelsForNodeDto; import de.cotto.lndmanagej.controller.dto.FeeReportDto; import de.cotto.lndmanagej.controller.dto.NodeDetailsDto; import de.cotto.lndmanagej.controller.dto.ObjectMapperConfiguration; -import de.cotto.lndmanagej.controller.dto.OffChainCostsDto; -import de.cotto.lndmanagej.controller.dto.OnChainCostsDto; import de.cotto.lndmanagej.model.BalanceInformation; import de.cotto.lndmanagej.model.Channel; import de.cotto.lndmanagej.model.ChannelId; import de.cotto.lndmanagej.model.Node; -import de.cotto.lndmanagej.model.OffChainCosts; import de.cotto.lndmanagej.model.OnChainCosts; import de.cotto.lndmanagej.model.Pubkey; import de.cotto.lndmanagej.service.BalanceService; import de.cotto.lndmanagej.service.ChannelService; import de.cotto.lndmanagej.service.FeeService; import de.cotto.lndmanagej.service.NodeService; -import de.cotto.lndmanagej.service.OffChainCostService; import de.cotto.lndmanagej.service.OnChainCostService; import de.cotto.lndmanagej.service.RebalanceService; import org.springframework.context.annotation.Import; @@ -38,7 +34,6 @@ public class NodeController { private final NodeService nodeService; private final ChannelService channelService; private final OnChainCostService onChainCostService; - private final OffChainCostService offChainCostService; private final BalanceService balanceService; private final FeeService feeService; private final RebalanceService rebalanceService; @@ -47,7 +42,6 @@ public class NodeController { NodeService nodeService, ChannelService channelService, OnChainCostService onChainCostService, - OffChainCostService offChainCostService, BalanceService balanceService, FeeService feeService, RebalanceService rebalanceService @@ -55,7 +49,6 @@ public class NodeController { this.nodeService = nodeService; this.channelService = channelService; this.onChainCostService = onChainCostService; - this.offChainCostService = offChainCostService; this.balanceService = balanceService; this.feeService = feeService; this.rebalanceService = rebalanceService; @@ -72,7 +65,6 @@ public class NodeController { public NodeDetailsDto getDetails(@PathVariable Pubkey pubkey) { Node node = nodeService.getNode(pubkey); OnChainCosts onChainCosts = onChainCostService.getOnChainCostsForPeer(pubkey); - OffChainCosts offChainCosts = offChainCostService.getOffChainCostsForPeer(pubkey); BalanceInformation balanceInformation = balanceService.getBalanceInformationForPeer(pubkey); return new NodeDetailsDto( pubkey, @@ -81,13 +73,11 @@ public class NodeController { toSortedList(channelService.getClosedChannelsWith(pubkey)), toSortedList(channelService.getWaitingCloseChannelsWith(pubkey)), toSortedList(channelService.getForceClosingChannelsWith(pubkey)), - OnChainCostsDto.createFromModel(onChainCosts), - OffChainCostsDto.createFromModel(offChainCosts), - BalanceInformationDto.createFromModel(balanceInformation), + onChainCosts, + balanceInformation, node.online(), - getFeeReportDto(pubkey), - String.valueOf(rebalanceService.getRebalanceAmountFromPeer(pubkey).milliSatoshis()), - String.valueOf(rebalanceService.getRebalanceAmountToPeer(pubkey).milliSatoshis()) + feeService.getFeeReportForPeer(pubkey), + rebalanceService.getReportForPeer(pubkey) ); } @@ -114,10 +104,6 @@ public class NodeController { @Timed @GetMapping("/fee-report") public FeeReportDto getFeeReport(@PathVariable Pubkey pubkey) { - return getFeeReportDto(pubkey); - } - - private FeeReportDto getFeeReportDto(Pubkey pubkey) { return FeeReportDto.createFromModel(feeService.getFeeReportForPeer(pubkey)); } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/RebalancesController.java b/web/src/main/java/de/cotto/lndmanagej/controller/RebalancesController.java index 36d8dee8..e93fdd85 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/RebalancesController.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/RebalancesController.java @@ -3,7 +3,6 @@ package de.cotto.lndmanagej.controller; import com.codahale.metrics.annotation.Timed; import de.cotto.lndmanagej.model.ChannelId; import de.cotto.lndmanagej.model.Pubkey; -import de.cotto.lndmanagej.service.OffChainCostService; import de.cotto.lndmanagej.service.RebalanceService; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @@ -13,59 +12,57 @@ import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/api/") public class RebalancesController { - private final OffChainCostService offChainCostService; private final RebalanceService rebalanceService; - public RebalancesController(OffChainCostService offChainCostService, RebalanceService rebalanceService) { - this.offChainCostService = offChainCostService; + public RebalancesController(RebalanceService rebalanceService) { this.rebalanceService = rebalanceService; } @Timed @GetMapping("/node/{pubkey}/rebalance-source-costs") public long getRebalanceSourceCostsForPeer(@PathVariable Pubkey pubkey) { - return offChainCostService.getRebalanceSourceCostsForPeer(pubkey).milliSatoshis(); + return rebalanceService.getSourceCostsForPeer(pubkey).milliSatoshis(); } @Timed @GetMapping("/node/{pubkey}/rebalance-source-amount") public long getRebalanceSourceAmountForPeer(@PathVariable Pubkey pubkey) { - return rebalanceService.getRebalanceAmountFromPeer(pubkey).milliSatoshis(); + return rebalanceService.getAmountFromPeer(pubkey).milliSatoshis(); } @Timed @GetMapping("/channel/{channelId}/rebalance-source-costs") public long getRebalanceSourceCostsForChannel(@PathVariable ChannelId channelId) { - return offChainCostService.getRebalanceSourceCostsForChannel(channelId).milliSatoshis(); + return rebalanceService.getSourceCostsForChannel(channelId).milliSatoshis(); } @Timed @GetMapping("/channel/{channelId}/rebalance-source-amount") public long getRebalanceSourceAmountForChannel(@PathVariable ChannelId channelId) { - return rebalanceService.getRebalanceAmountFromChannel(channelId).milliSatoshis(); + return rebalanceService.getAmountFromChannel(channelId).milliSatoshis(); } @Timed @GetMapping("/node/{pubkey}/rebalance-target-costs") public long getRebalanceTargetCostsForPeer(@PathVariable Pubkey pubkey) { - return offChainCostService.getRebalanceTargetCostsForPeer(pubkey).milliSatoshis(); + return rebalanceService.getTargetCostsForPeer(pubkey).milliSatoshis(); } @Timed @GetMapping("/node/{pubkey}/rebalance-target-amount") public long getRebalanceTargetAmountForPeer(@PathVariable Pubkey pubkey) { - return rebalanceService.getRebalanceAmountToPeer(pubkey).milliSatoshis(); + return rebalanceService.getAmountToPeer(pubkey).milliSatoshis(); } @Timed @GetMapping("/channel/{channelId}/rebalance-target-costs") public long getRebalanceTargetCostsForChannel(@PathVariable ChannelId channelId) { - return offChainCostService.getRebalanceTargetCostsForChannel(channelId).milliSatoshis(); + return rebalanceService.getTargetCostsForChannel(channelId).milliSatoshis(); } @Timed @GetMapping("/channel/{channelId}/rebalance-target-amount") public long getRebalanceTargetAmountForChannel(@PathVariable ChannelId channelId) { - return rebalanceService.getRebalanceAmountToChannel(channelId).milliSatoshis(); + return rebalanceService.getAmountToChannel(channelId).milliSatoshis(); } } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDto.java b/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDto.java index a3970e93..afbc9421 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDto.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDto.java @@ -1,14 +1,15 @@ package de.cotto.lndmanagej.controller.dto; import de.cotto.lndmanagej.model.BalanceInformation; +import de.cotto.lndmanagej.model.ChannelDetails; import de.cotto.lndmanagej.model.ChannelPoint; -import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.FeeReport; import de.cotto.lndmanagej.model.LocalChannel; -import de.cotto.lndmanagej.model.OffChainCosts; import de.cotto.lndmanagej.model.OnChainCosts; import de.cotto.lndmanagej.model.OpenInitiator; +import de.cotto.lndmanagej.model.Policies; import de.cotto.lndmanagej.model.Pubkey; +import de.cotto.lndmanagej.model.RebalanceReport; public record ChannelDetailsDto( String channelIdShort, @@ -25,23 +26,19 @@ public record ChannelDetailsDto( ChannelStatusDto status, BalanceInformationDto balance, OnChainCostsDto onChainCosts, - OffChainCostsDto offChainCosts, PoliciesDto policies, ClosedChannelDetailsDto closeDetails, FeeReportDto feeReport, - String rebalanceSourceAmount, - String rebalanceTargetAmount + RebalanceReportDto rebalanceReport ) { public ChannelDetailsDto( ChannelDto channelDto, String remoteAlias, BalanceInformation balanceInformation, OnChainCosts onChainCosts, - OffChainCosts offChainCosts, - PoliciesDto policies, + Policies policies, FeeReport feeReport, - Coins rebalanceSourceAmount, - Coins rebalanceTargetAmount + RebalanceReport rebalanceReport ) { this( channelDto.channelIdShort(), @@ -58,38 +55,42 @@ public record ChannelDetailsDto( channelDto.status(), BalanceInformationDto.createFromModel(balanceInformation), OnChainCostsDto.createFromModel(onChainCosts), - OffChainCostsDto.createFromModel(offChainCosts), - policies, + PoliciesDto.createFromModel(policies), channelDto.closeDetails(), FeeReportDto.createFromModel(feeReport), - String.valueOf(rebalanceSourceAmount.milliSatoshis()), - String.valueOf(rebalanceTargetAmount.milliSatoshis()) + RebalanceReportDto.createFromModel(rebalanceReport) ); } - @SuppressWarnings("PMD.ExcessiveParameterList") public ChannelDetailsDto( LocalChannel localChannel, String remoteAlias, BalanceInformation balanceInformation, OnChainCosts onChainCosts, - OffChainCosts offChainCosts, - PoliciesDto policies, - ClosedChannelDetailsDto closeDetails, + Policies policies, FeeReport feeReport, - Coins rebalanceSourceAmount, - Coins rebalanceTargetAmount + RebalanceReport rebalanceReport ) { this( - new ChannelDto(localChannel, closeDetails), + new ChannelDto(localChannel), remoteAlias, balanceInformation, onChainCosts, - offChainCosts, policies, feeReport, - rebalanceSourceAmount, - rebalanceTargetAmount + rebalanceReport + ); + } + + public static ChannelDetailsDto createFromModel(ChannelDetails channelDetails) { + return new ChannelDetailsDto( + channelDetails.localChannel(), + channelDetails.remoteAlias(), + channelDetails.balanceInformation(), + channelDetails.onChainCosts(), + channelDetails.policies(), + channelDetails.feeReport(), + channelDetails.rebalanceReport() ); } } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDto.java b/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDto.java index 8d0be17b..c716fbc4 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDto.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/dto/ChannelDto.java @@ -19,7 +19,7 @@ public record ChannelDto( OpenInitiator openInitiator, ClosedChannelDetailsDto closeDetails ) { - public ChannelDto(LocalChannel localChannel, ClosedChannelDetailsDto closeDetails) { + public ChannelDto(LocalChannel localChannel) { this( String.valueOf(localChannel.getId().getShortChannelId()), localChannel.getId().getCompactForm(), @@ -32,7 +32,7 @@ public record ChannelDto( String.valueOf(localChannel.getTotalReceived().satoshis()), ChannelStatusDto.createFromModel(localChannel.getStatus()), localChannel.getOpenInitiator(), - closeDetails + ClosedChannelDetailsDto.createFromModel(localChannel) ); } } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/dto/NodeDetailsDto.java b/web/src/main/java/de/cotto/lndmanagej/controller/dto/NodeDetailsDto.java index 82d8cabf..99d3816a 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/dto/NodeDetailsDto.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/dto/NodeDetailsDto.java @@ -2,8 +2,12 @@ package de.cotto.lndmanagej.controller.dto; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.fasterxml.jackson.databind.ser.std.ToStringSerializer; +import de.cotto.lndmanagej.model.BalanceInformation; import de.cotto.lndmanagej.model.ChannelId; +import de.cotto.lndmanagej.model.FeeReport; +import de.cotto.lndmanagej.model.OnChainCosts; import de.cotto.lndmanagej.model.Pubkey; +import de.cotto.lndmanagej.model.RebalanceReport; import java.util.List; @@ -15,11 +19,37 @@ public record NodeDetailsDto( List waitingCloseChannels, List pendingForceClosingChannels, OnChainCostsDto onChainCosts, - OffChainCostsDto offChainCosts, BalanceInformationDto balance, boolean online, FeeReportDto feeReport, - String rebalanceSourceAmount, - String rebalanceTargetAmount + RebalanceReportDto rebalanceReport ) { + @SuppressWarnings("PMD.ExcessiveParameterList") + public NodeDetailsDto( + Pubkey pubkey, + String alias, + List channels, + List closedChannels, + List waitingCloseChannels, + List pendingForceClosingChannels, + OnChainCosts onChainCosts, + BalanceInformation balanceInformation, + boolean online, + FeeReport feeReport, + RebalanceReport rebalanceReport + ) { + this( + pubkey, + alias, + channels, + closedChannels, + waitingCloseChannels, + pendingForceClosingChannels, + OnChainCostsDto.createFromModel(onChainCosts), + BalanceInformationDto.createFromModel(balanceInformation), + online, + FeeReportDto.createFromModel(feeReport), + RebalanceReportDto.createFromModel(rebalanceReport) + ); + } } diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/dto/OffChainCostsDto.java b/web/src/main/java/de/cotto/lndmanagej/controller/dto/OffChainCostsDto.java deleted file mode 100644 index 28e2b749..00000000 --- a/web/src/main/java/de/cotto/lndmanagej/controller/dto/OffChainCostsDto.java +++ /dev/null @@ -1,18 +0,0 @@ -package de.cotto.lndmanagej.controller.dto; - -import de.cotto.lndmanagej.model.Coins; -import de.cotto.lndmanagej.model.OffChainCosts; - -public record OffChainCostsDto(String rebalanceSource, String rebalanceTarget) { - public OffChainCostsDto(Coins rebalanceSource, Coins rebalanceTarget) { - this( - String.valueOf(rebalanceSource.milliSatoshis()), - String.valueOf(rebalanceTarget.milliSatoshis()) - ); - } - - public static OffChainCostsDto createFromModel(OffChainCosts offChainCosts) { - return new OffChainCostsDto(offChainCosts.rebalanceSource(), offChainCosts.rebalanceTarget()); - } - -} diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/dto/PoliciesDto.java b/web/src/main/java/de/cotto/lndmanagej/controller/dto/PoliciesDto.java index 13eda07b..bf156eb9 100644 --- a/web/src/main/java/de/cotto/lndmanagej/controller/dto/PoliciesDto.java +++ b/web/src/main/java/de/cotto/lndmanagej/controller/dto/PoliciesDto.java @@ -6,9 +6,6 @@ public record PoliciesDto( PolicyDto local, PolicyDto remote ) { - public static final PoliciesDto EMPTY = - new PoliciesDto(PolicyDto.EMPTY, PolicyDto.EMPTY); - public static PoliciesDto createFromModel(Policies policies) { return new PoliciesDto( PolicyDto.createFromModel(policies.local()), diff --git a/web/src/main/java/de/cotto/lndmanagej/controller/dto/RebalanceReportDto.java b/web/src/main/java/de/cotto/lndmanagej/controller/dto/RebalanceReportDto.java new file mode 100644 index 00000000..26b00028 --- /dev/null +++ b/web/src/main/java/de/cotto/lndmanagej/controller/dto/RebalanceReportDto.java @@ -0,0 +1,28 @@ +package de.cotto.lndmanagej.controller.dto; + +import de.cotto.lndmanagej.model.Coins; +import de.cotto.lndmanagej.model.RebalanceReport; + +public record RebalanceReportDto(String sourceCosts, String sourceAmount, String targetCosts, String targetAmount) { + public RebalanceReportDto(Coins sourceCost, Coins sourceAmount, Coins targetCost, Coins targetAmount) { + this( + toMilliSatoshisString(sourceCost), + toMilliSatoshisString(sourceAmount), + toMilliSatoshisString(targetCost), + toMilliSatoshisString(targetAmount) + ); + } + + public static RebalanceReportDto createFromModel(RebalanceReport rebalanceReport) { + return new RebalanceReportDto( + rebalanceReport.sourceCost(), + rebalanceReport.sourceAmount(), + rebalanceReport.targetCost(), + rebalanceReport.targetAmount() + ); + } + + private static String toMilliSatoshisString(Coins coins) { + return String.valueOf(coins.milliSatoshis()); + } +} diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/ChannelControllerTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/ChannelControllerTest.java index f51814f0..c22494d5 100644 --- a/web/src/test/java/de/cotto/lndmanagej/controller/ChannelControllerTest.java +++ b/web/src/test/java/de/cotto/lndmanagej/controller/ChannelControllerTest.java @@ -9,16 +9,12 @@ import de.cotto.lndmanagej.controller.dto.PoliciesDto; import de.cotto.lndmanagej.model.BalanceInformation; import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.FeeReport; -import de.cotto.lndmanagej.model.LocalChannel; +import de.cotto.lndmanagej.model.Policies; import de.cotto.lndmanagej.service.BalanceService; +import de.cotto.lndmanagej.service.ChannelDetailsService; import de.cotto.lndmanagej.service.ChannelService; import de.cotto.lndmanagej.service.FeeService; -import de.cotto.lndmanagej.service.NodeService; -import de.cotto.lndmanagej.service.OffChainCostService; -import de.cotto.lndmanagej.service.OnChainCostService; import de.cotto.lndmanagej.service.PolicyService; -import de.cotto.lndmanagej.service.RebalanceService; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; @@ -28,24 +24,19 @@ import org.mockito.junit.jupiter.MockitoExtension; import java.util.Optional; import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION; +import static de.cotto.lndmanagej.model.ChannelDetailsFixtures.CHANNEL_DETAILS; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID; import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL; -import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_PRIVATE; -import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_2; -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; -import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES; -import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2; import static de.cotto.lndmanagej.model.WaitingCloseChannelFixtures.WAITING_CLOSE_CHANNEL; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; -import static org.mockito.Mockito.lenient; import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) class ChannelControllerTest { - private static final PoliciesDto FEE_CONFIGURATION_DTO = PoliciesDto.createFromModel(POLICIES); + private static final PoliciesDto POLICIES_DTO = PoliciesDto.createFromModel(POLICIES); private static final ClosedChannelDetailsDto CLOSED_CHANNEL_DETAILS_DTO = ClosedChannelDetailsDto.createFromModel(CLOSED_CHANNEL); private static final FeeReport FEE_REPORT = new FeeReport(Coins.ofMilliSatoshis(1_234), Coins.ofMilliSatoshis(567)); @@ -56,18 +47,9 @@ class ChannelControllerTest { @Mock private ChannelService channelService; - @Mock - private NodeService nodeService; - @Mock private BalanceService balanceService; - @Mock - private OnChainCostService onChainCostService; - - @Mock - private OffChainCostService offChainCostService; - @Mock private PolicyService policyService; @@ -75,17 +57,7 @@ class ChannelControllerTest { private FeeService feeService; @Mock - private RebalanceService rebalanceService; - - @BeforeEach - void setUp() { - lenient().when(onChainCostService.getOnChainCostsForChannelId(CHANNEL_ID)).thenReturn(ON_CHAIN_COSTS); - lenient().when(offChainCostService.getOffChainCostsForChannel(CHANNEL_ID)).thenReturn(OFF_CHAIN_COSTS); - lenient().when(policyService.getPolicies(CHANNEL_ID)).thenReturn(POLICIES); - lenient().when(feeService.getFeeReportForChannel(CHANNEL_ID)).thenReturn(FEE_REPORT); - lenient().when(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).thenReturn(Coins.NONE); - lenient().when(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID)).thenReturn(Coins.NONE); - } + private ChannelDetailsService channelDetailsService; @Test void getBasicInformation_channel_not_found() { @@ -95,14 +67,14 @@ class ChannelControllerTest { @Test void getBasicInformation() throws NotFoundException { - ChannelDto basicInformation = new ChannelDto(LOCAL_OPEN_CHANNEL, ClosedChannelDetailsDto.UNKNOWN); + ChannelDto basicInformation = new ChannelDto(LOCAL_OPEN_CHANNEL); when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(LOCAL_OPEN_CHANNEL)); assertThat(channelController.getBasicInformation(CHANNEL_ID)).isEqualTo(basicInformation); } @Test void getBasicInformation_closed_channel() throws NotFoundException { - ChannelDto basicInformation = new ChannelDto(CLOSED_CHANNEL, CLOSED_CHANNEL_DETAILS_DTO); + ChannelDto basicInformation = new ChannelDto(CLOSED_CHANNEL); when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(CLOSED_CHANNEL)); assertThat(channelController.getBasicInformation(CHANNEL_ID)).isEqualTo(basicInformation); } @@ -115,60 +87,11 @@ class ChannelControllerTest { @Test void getDetails() throws NotFoundException { - ChannelDetailsDto expectedDetails = new ChannelDetailsDto( - LOCAL_OPEN_CHANNEL, - ALIAS_2, - LOCAL_OPEN_CHANNEL.getBalanceInformation(), - ON_CHAIN_COSTS, - OFF_CHAIN_COSTS, - FEE_CONFIGURATION_DTO, - ClosedChannelDetailsDto.UNKNOWN, - FEE_REPORT, - Coins.ofMilliSatoshis(1), - Coins.ofMilliSatoshis(2) - ); - when(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(1)); - when(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(2)); - when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2); when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(LOCAL_OPEN_CHANNEL)); - when(balanceService.getBalanceInformation(CHANNEL_ID)) - .thenReturn(Optional.ofNullable(LOCAL_OPEN_CHANNEL.getBalanceInformation())); + when(channelDetailsService.getDetails(LOCAL_OPEN_CHANNEL)).thenReturn(CHANNEL_DETAILS); - assertThat(channelController.getDetails(CHANNEL_ID)).isEqualTo(expectedDetails); - } - - @Test - void getDetails_private() throws NotFoundException { - ChannelDetailsDto expectedDetails = new ChannelDetailsDto( - LOCAL_OPEN_CHANNEL_PRIVATE, - ALIAS_2, - LOCAL_OPEN_CHANNEL_PRIVATE.getBalanceInformation(), - ON_CHAIN_COSTS, - OFF_CHAIN_COSTS, - FEE_CONFIGURATION_DTO, - ClosedChannelDetailsDto.UNKNOWN, - FEE_REPORT, - Coins.NONE, - Coins.NONE - ); - when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2); - when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(LOCAL_OPEN_CHANNEL_PRIVATE)); - when(balanceService.getBalanceInformation(CHANNEL_ID)) - .thenReturn(Optional.ofNullable(LOCAL_OPEN_CHANNEL_PRIVATE.getBalanceInformation())); - - assertThat(channelController.getDetails(CHANNEL_ID)).isEqualTo(expectedDetails); - } - - @Test - void getDetails_closed() throws NotFoundException { - ChannelDetailsDto expectedDetails = mockForChannelWithoutPolicies(CLOSED_CHANNEL); - assertThat(channelController.getDetails(CHANNEL_ID)).isEqualTo(expectedDetails); - } - - @Test - void getDetails_waiting_close() throws NotFoundException { - ChannelDetailsDto expectedDetails = mockForChannelWithoutPolicies(WAITING_CLOSE_CHANNEL); - assertThat(channelController.getDetails(CHANNEL_ID)).isEqualTo(expectedDetails); + assertThat(channelController.getDetails(CHANNEL_ID)) + .isEqualTo(ChannelDetailsDto.createFromModel(CHANNEL_DETAILS)); } @Test @@ -189,12 +112,18 @@ class ChannelControllerTest { void getPolicies() { when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(LOCAL_OPEN_CHANNEL)); when(policyService.getPolicies(CHANNEL_ID)).thenReturn(POLICIES); - assertThat(channelController.getPolicies(CHANNEL_ID)).isEqualTo(FEE_CONFIGURATION_DTO); + assertThat(channelController.getPolicies(CHANNEL_ID)).isEqualTo(POLICIES_DTO); } @Test void getPolicies_waiting_close() { - assertThat(channelController.getPolicies(CHANNEL_ID)).isEqualTo(PoliciesDto.EMPTY); + when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(WAITING_CLOSE_CHANNEL)); + assertThat(channelController.getPolicies(CHANNEL_ID)).isEqualTo(PoliciesDto.createFromModel(Policies.UNKNOWN)); + } + + @Test + void getPolicies_channel_not_found() { + assertThat(channelController.getPolicies(CHANNEL_ID)).isEqualTo(PoliciesDto.createFromModel(Policies.UNKNOWN)); } @Test @@ -214,22 +143,4 @@ class ChannelControllerTest { when(feeService.getFeeReportForChannel(CHANNEL_ID)).thenReturn(FEE_REPORT); assertThat(channelController.getFeeReport(CHANNEL_ID)).isEqualTo(FeeReportDto.createFromModel(FEE_REPORT)); } - - private ChannelDetailsDto mockForChannelWithoutPolicies(LocalChannel channel) { - when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2); - when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(channel)); - when(balanceService.getBalanceInformation(CHANNEL_ID)).thenReturn(Optional.empty()); - return new ChannelDetailsDto( - channel, - ALIAS_2, - BalanceInformation.EMPTY, - ON_CHAIN_COSTS, - OFF_CHAIN_COSTS, - PoliciesDto.EMPTY, - ClosedChannelDetailsDto.createFromModel(channel), - FEE_REPORT, - Coins.NONE, - Coins.NONE - ); - } } \ No newline at end of file diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/NodeControllerTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/NodeControllerTest.java index f4b2481d..10bd1618 100644 --- a/web/src/test/java/de/cotto/lndmanagej/controller/NodeControllerTest.java +++ b/web/src/test/java/de/cotto/lndmanagej/controller/NodeControllerTest.java @@ -4,20 +4,19 @@ import de.cotto.lndmanagej.controller.dto.BalanceInformationDto; import de.cotto.lndmanagej.controller.dto.ChannelsForNodeDto; import de.cotto.lndmanagej.controller.dto.FeeReportDto; import de.cotto.lndmanagej.controller.dto.NodeDetailsDto; -import de.cotto.lndmanagej.controller.dto.OffChainCostsDto; import de.cotto.lndmanagej.controller.dto.OnChainCostsDto; +import de.cotto.lndmanagej.controller.dto.RebalanceReportDto; import de.cotto.lndmanagej.model.BalanceInformation; import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.FeeReport; import de.cotto.lndmanagej.model.Node; -import de.cotto.lndmanagej.model.OffChainCosts; import de.cotto.lndmanagej.model.OnChainCosts; import de.cotto.lndmanagej.model.Pubkey; +import de.cotto.lndmanagej.model.RebalanceReport; import de.cotto.lndmanagej.service.BalanceService; import de.cotto.lndmanagej.service.ChannelService; import de.cotto.lndmanagej.service.FeeService; import de.cotto.lndmanagej.service.NodeService; -import de.cotto.lndmanagej.service.OffChainCostService; import de.cotto.lndmanagej.service.OnChainCostService; import de.cotto.lndmanagej.service.RebalanceService; import org.junit.jupiter.api.Test; @@ -42,9 +41,9 @@ import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHAN import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_2; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_3; import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_2; -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY; import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2; +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; import static de.cotto.lndmanagej.model.WaitingCloseChannelFixtures.WAITING_CLOSE_CHANNEL; import static de.cotto.lndmanagej.model.WaitingCloseChannelFixtures.WAITING_CLOSE_CHANNEL_2; import static org.assertj.core.api.Assertions.assertThat; @@ -67,9 +66,6 @@ class NodeControllerTest { @Mock private OnChainCostService onChainCostService; - @Mock - private OffChainCostService offChainCostService; - @Mock private BalanceService balanceService; @@ -89,11 +85,9 @@ class NodeControllerTest { @Test void getNodeDetails_no_channels() { when(onChainCostService.getOnChainCostsForPeer(any())).thenReturn(OnChainCosts.NONE); - when(offChainCostService.getOffChainCostsForPeer(any())).thenReturn(OffChainCosts.NONE); when(balanceService.getBalanceInformationForPeer(any(Pubkey.class))).thenReturn(BalanceInformation.EMPTY); when(feeService.getFeeReportForPeer(any())).thenReturn(new FeeReport(Coins.NONE, Coins.NONE)); - when(rebalanceService.getRebalanceAmountFromPeer(PUBKEY_2)).thenReturn(Coins.NONE); - when(rebalanceService.getRebalanceAmountToPeer(PUBKEY_2)).thenReturn(Coins.NONE); + when(rebalanceService.getReportForPeer(PUBKEY_2)).thenReturn(RebalanceReport.EMPTY); NodeDetailsDto expectedDetails = new NodeDetailsDto( PUBKEY_2, ALIAS_2, @@ -102,12 +96,10 @@ class NodeControllerTest { List.of(), List.of(), OnChainCostsDto.createFromModel(OnChainCosts.NONE), - OffChainCostsDto.createFromModel(OffChainCosts.NONE), BalanceInformationDto.createFromModel(BalanceInformation.EMPTY), true, new FeeReportDto("0", "0"), - "0", - "0" + RebalanceReportDto.createFromModel(RebalanceReport.EMPTY) ); when(nodeService.getNode(PUBKEY_2)).thenReturn(new Node(PUBKEY_2, ALIAS_2, 0, true)); @@ -131,10 +123,8 @@ class NodeControllerTest { Coins.ofSatoshis(789) ); when(onChainCostService.getOnChainCostsForPeer(PUBKEY_2)).thenReturn(onChainCosts); - when(offChainCostService.getOffChainCostsForPeer(PUBKEY_2)).thenReturn(OFF_CHAIN_COSTS); when(balanceService.getBalanceInformationForPeer(PUBKEY_2)).thenReturn(BALANCE_INFORMATION); - when(rebalanceService.getRebalanceAmountFromPeer(PUBKEY_2)).thenReturn(Coins.ofMilliSatoshis(111)); - when(rebalanceService.getRebalanceAmountToPeer(PUBKEY_2)).thenReturn(Coins.ofMilliSatoshis(222)); + when(rebalanceService.getReportForPeer(PUBKEY_2)).thenReturn(REBALANCE_REPORT); when(feeService.getFeeReportForPeer(PUBKEY_2)).thenReturn(FEE_REPORT); NodeDetailsDto expectedDetails = new NodeDetailsDto( PUBKEY_2, @@ -144,12 +134,10 @@ class NodeControllerTest { List.of(CHANNEL_ID, CHANNEL_ID_2), List.of(CHANNEL_ID, CHANNEL_ID_2, CHANNEL_ID_3), OnChainCostsDto.createFromModel(onChainCosts), - OffChainCostsDto.createFromModel(OFF_CHAIN_COSTS), BalanceInformationDto.createFromModel(BALANCE_INFORMATION), false, - new FeeReportDto("1234", "567"), - "111", - "222" + FeeReportDto.createFromModel(FEE_REPORT), + RebalanceReportDto.createFromModel(REBALANCE_REPORT) ); assertThat(nodeController.getDetails(PUBKEY_2)).isEqualTo(expectedDetails); @@ -193,6 +181,6 @@ class NodeControllerTest { @Test void getFeeReport() { when(feeService.getFeeReportForPeer(PUBKEY)).thenReturn(FEE_REPORT); - assertThat(nodeController.getFeeReport(PUBKEY)).isEqualTo(new FeeReportDto("1234", "567")); + assertThat(nodeController.getFeeReport(PUBKEY)).isEqualTo(FeeReportDto.createFromModel(FEE_REPORT)); } } \ No newline at end of file diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/RebalancesControllerTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/RebalancesControllerTest.java index d6290639..b4372794 100644 --- a/web/src/test/java/de/cotto/lndmanagej/controller/RebalancesControllerTest.java +++ b/web/src/test/java/de/cotto/lndmanagej/controller/RebalancesControllerTest.java @@ -1,7 +1,6 @@ package de.cotto.lndmanagej.controller; import de.cotto.lndmanagej.model.Coins; -import de.cotto.lndmanagej.service.OffChainCostService; import de.cotto.lndmanagej.service.RebalanceService; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -21,57 +20,54 @@ class RebalancesControllerTest { @InjectMocks private RebalancesController rebalancesController; - @Mock - private OffChainCostService offChainCostService; - @Mock private RebalanceService rebalanceService; @Test void getRebalanceSourceCostsForChannel() { - when(offChainCostService.getRebalanceSourceCostsForChannel(CHANNEL_ID)).thenReturn(COINS); + when(rebalanceService.getSourceCostsForChannel(CHANNEL_ID)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceSourceCostsForChannel(CHANNEL_ID)).isEqualTo(123); } @Test void getRebalanceSourceCostsForPeer() { - when(offChainCostService.getRebalanceSourceCostsForPeer(PUBKEY)).thenReturn(COINS); + when(rebalanceService.getSourceCostsForPeer(PUBKEY)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceSourceCostsForPeer(PUBKEY)).isEqualTo(123); } @Test void getRebalanceTargetCostsForChannel() { - when(offChainCostService.getRebalanceTargetCostsForChannel(CHANNEL_ID)).thenReturn(COINS); + when(rebalanceService.getTargetCostsForChannel(CHANNEL_ID)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceTargetCostsForChannel(CHANNEL_ID)).isEqualTo(123); } @Test void getRebalanceTargetCostsForPeer() { - when(offChainCostService.getRebalanceTargetCostsForPeer(PUBKEY)).thenReturn(COINS); + when(rebalanceService.getTargetCostsForPeer(PUBKEY)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceTargetCostsForPeer(PUBKEY)).isEqualTo(123); } @Test void getRebalanceSourceAmountForChannel() { - when(rebalanceService.getRebalanceAmountFromChannel(CHANNEL_ID)).thenReturn(COINS); + when(rebalanceService.getAmountFromChannel(CHANNEL_ID)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceSourceAmountForChannel(CHANNEL_ID)).isEqualTo(123); } @Test void getRebalanceSourceAmountForPeer() { - when(rebalanceService.getRebalanceAmountFromPeer(PUBKEY)).thenReturn(COINS); + when(rebalanceService.getAmountFromPeer(PUBKEY)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceSourceAmountForPeer(PUBKEY)).isEqualTo(123); } @Test void getRebalanceTargetAmountForChannel() { - when(rebalanceService.getRebalanceAmountToChannel(CHANNEL_ID)).thenReturn(COINS); + when(rebalanceService.getAmountToChannel(CHANNEL_ID)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceTargetAmountForChannel(CHANNEL_ID)).isEqualTo(123); } @Test void getRebalanceTargetAmountForPeer() { - when(rebalanceService.getRebalanceAmountToPeer(PUBKEY)).thenReturn(COINS); + when(rebalanceService.getAmountToPeer(PUBKEY)).thenReturn(COINS); assertThat(rebalancesController.getRebalanceTargetAmountForPeer(PUBKEY)).isEqualTo(123); } } \ No newline at end of file diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDtoTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDtoTest.java index 89bb8757..6f8bb529 100644 --- a/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDtoTest.java +++ b/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDetailsDtoTest.java @@ -4,19 +4,24 @@ import de.cotto.lndmanagej.model.ChannelStatus; import de.cotto.lndmanagej.model.Coins; import de.cotto.lndmanagej.model.FeeReport; import de.cotto.lndmanagej.model.OpenInitiator; +import de.cotto.lndmanagej.model.Policies; +import de.cotto.lndmanagej.model.RebalanceReport; import org.junit.jupiter.api.Test; import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION; +import static de.cotto.lndmanagej.model.ChannelDetailsFixtures.CHANNEL_DETAILS; import static de.cotto.lndmanagej.model.ChannelFixtures.CAPACITY; import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID; import static de.cotto.lndmanagej.model.ChannelPointFixtures.CHANNEL_POINT; import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL; import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL; +import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_PRIVATE; import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS; -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS; import static de.cotto.lndmanagej.model.OpenCloseStatus.OPEN; +import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES; import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2; +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; import static org.assertj.core.api.Assertions.assertThat; class ChannelDetailsDtoTest { @@ -30,14 +35,25 @@ class ChannelDetailsDtoTest { ALIAS, BALANCE_INFORMATION, ON_CHAIN_COSTS, - OFF_CHAIN_COSTS, - PoliciesDto.EMPTY, - CLOSE_DETAILS, + Policies.UNKNOWN, FEE_REPORT, - Coins.ofMilliSatoshis(123), - Coins.ofMilliSatoshis(456) + REBALANCE_REPORT ); + @Test + void createFromModel() { + ChannelDetailsDto expected = new ChannelDetailsDto( + LOCAL_OPEN_CHANNEL_PRIVATE, + ALIAS, + BALANCE_INFORMATION, + ON_CHAIN_COSTS, + POLICIES, + FEE_REPORT, + REBALANCE_REPORT + ); + assertThat(ChannelDetailsDto.createFromModel(CHANNEL_DETAILS)).isEqualTo(expected); + } + @Test void channelIdShort() { assertThat(CHANNEL_DETAILS_DTO.channelIdShort()).isEqualTo(String.valueOf(CHANNEL_ID.getShortChannelId())); @@ -90,12 +106,9 @@ class ChannelDetailsDtoTest { ALIAS, BALANCE_INFORMATION, ON_CHAIN_COSTS, - OFF_CHAIN_COSTS, - PoliciesDto.EMPTY, - CLOSE_DETAILS, + Policies.UNKNOWN, FEE_REPORT, - Coins.NONE, - Coins.NONE + RebalanceReport.EMPTY ); ChannelStatusDto channelStatusDto = ChannelStatusDto.createFromModel(new ChannelStatus(false, true, false, OPEN)); @@ -123,17 +136,9 @@ class ChannelDetailsDtoTest { } @Test - void offChainCosts() { - assertThat(CHANNEL_DETAILS_DTO.offChainCosts()).isEqualTo(OffChainCostsDto.createFromModel(OFF_CHAIN_COSTS)); - } + void rebalanceReport() { + assertThat(CHANNEL_DETAILS_DTO.rebalanceReport()) + .isEqualTo(RebalanceReportDto.createFromModel(REBALANCE_REPORT)); - @Test - void rebalanceSourceAmount() { - assertThat(CHANNEL_DETAILS_DTO.rebalanceSourceAmount()).isEqualTo("123"); - } - - @Test - void rebalanceTargetAmount() { - assertThat(CHANNEL_DETAILS_DTO.rebalanceTargetAmount()).isEqualTo("456"); } } \ No newline at end of file diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDtoTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDtoTest.java index 6a8bae74..08da4943 100644 --- a/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDtoTest.java +++ b/web/src/test/java/de/cotto/lndmanagej/controller/dto/ChannelDtoTest.java @@ -18,7 +18,7 @@ import static org.assertj.core.api.Assertions.assertThat; class ChannelDtoTest { private static final ClosedChannelDetailsDto CLOSE_DETAILS = ClosedChannelDetailsDto.createFromModel(CLOSED_CHANNEL); - private static final ChannelDto CHANNEL_DTO = new ChannelDto(CLOSED_CHANNEL, CLOSE_DETAILS); + private static final ChannelDto CHANNEL_DTO = new ChannelDto(CLOSED_CHANNEL); @Test void channelIdShort() { @@ -57,13 +57,13 @@ class ChannelDtoTest { @Test void totalSent() { - assertThat(new ChannelDto(LOCAL_OPEN_CHANNEL, CLOSE_DETAILS).totalSent()) + assertThat(new ChannelDto(LOCAL_OPEN_CHANNEL).totalSent()) .isEqualTo(String.valueOf(TOTAL_SENT.satoshis())); } @Test void totalReceived() { - assertThat(new ChannelDto(LOCAL_OPEN_CHANNEL, CLOSE_DETAILS).totalReceived()) + assertThat(new ChannelDto(LOCAL_OPEN_CHANNEL).totalReceived()) .isEqualTo(String.valueOf(TOTAL_RECEIVED.satoshis())); } @@ -79,7 +79,7 @@ class ChannelDtoTest { @Test void status() { - ChannelDto dto = new ChannelDto(LOCAL_OPEN_CHANNEL, CLOSE_DETAILS); + ChannelDto dto = new ChannelDto(LOCAL_OPEN_CHANNEL); ChannelStatusDto channelStatusDto = ChannelStatusDto.createFromModel(new ChannelStatus(false, true, false, OPEN)); assertThat(dto.status()).isEqualTo(channelStatusDto); diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/dto/OffChainCostsDtoTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/dto/OffChainCostsDtoTest.java deleted file mode 100644 index d4ce63ed..00000000 --- a/web/src/test/java/de/cotto/lndmanagej/controller/dto/OffChainCostsDtoTest.java +++ /dev/null @@ -1,22 +0,0 @@ -package de.cotto.lndmanagej.controller.dto; - -import de.cotto.lndmanagej.model.Coins; -import org.junit.jupiter.api.Test; - -import static de.cotto.lndmanagej.model.OffChainCostsFixtures.OFF_CHAIN_COSTS; -import static org.assertj.core.api.Assertions.assertThat; - -class OffChainCostsDtoTest { - @Test - void converts_to_msat_strings() { - OffChainCostsDto dto = new OffChainCostsDto(Coins.ofMilliSatoshis(1), Coins.ofMilliSatoshis(1_234)); - assertThat(dto.rebalanceSource()).isEqualTo("1"); - assertThat(dto.rebalanceTarget()).isEqualTo("1234"); - } - - @Test - void createFromModel() { - assertThat(OffChainCostsDto.createFromModel(OFF_CHAIN_COSTS)) - .isEqualTo(new OffChainCostsDto("1000000", "2000000")); - } -} \ No newline at end of file diff --git a/web/src/test/java/de/cotto/lndmanagej/controller/dto/RebalanceReportDtoTest.java b/web/src/test/java/de/cotto/lndmanagej/controller/dto/RebalanceReportDtoTest.java new file mode 100644 index 00000000..415c9f27 --- /dev/null +++ b/web/src/test/java/de/cotto/lndmanagej/controller/dto/RebalanceReportDtoTest.java @@ -0,0 +1,44 @@ +package de.cotto.lndmanagej.controller.dto; + +import de.cotto.lndmanagej.model.Coins; +import org.junit.jupiter.api.Test; + +import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT; +import static org.assertj.core.api.Assertions.assertThat; + +class RebalanceReportDtoTest { + + private static final RebalanceReportDto REBALANCE_REPORT_DTO = new RebalanceReportDto( + Coins.ofMilliSatoshis(1_234), + Coins.ofSatoshis(9_000), + Coins.ofMilliSatoshis(567), + Coins.ofSatoshis(1_000) + ); + + @Test + void sourceCosts() { + assertThat(REBALANCE_REPORT_DTO.sourceCosts()).isEqualTo("1234"); + } + + @Test + void sourceAmount() { + assertThat(REBALANCE_REPORT_DTO.sourceAmount()).isEqualTo("9000000"); + } + + @Test + void targetCosts() { + assertThat(REBALANCE_REPORT_DTO.targetCosts()).isEqualTo("567"); + } + + @Test + void targetAmount() { + assertThat(REBALANCE_REPORT_DTO.targetAmount()).isEqualTo("1000000"); + } + + @Test + void createFromModel() { + assertThat(RebalanceReportDto.createFromModel(REBALANCE_REPORT)).isEqualTo( + new RebalanceReportDto("1000000", "665000", "2000000", "991000") + ); + } +} \ No newline at end of file