restructure project

2026-01-22 23:44:21 +01:00 · 2021-11-22 20:24:13 +01:00
parent a82cb13ef7
commit 874e8fffa6
55 changed files with 46 additions and 14 deletions
--- a/web/src/test/java/de/cotto/lndmanagej/controller/ChannelDetailsControllerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/ChannelDetailsControllerTest.java
@@ -0,0 +1,100 @@
+package de.cotto.lndmanagej.controller;
+
+import de.cotto.lndmanagej.controller.dto.ChannelDetailsDto;
+import de.cotto.lndmanagej.controller.dto.OnChainCostsDto;
+import de.cotto.lndmanagej.metrics.Metrics;
+import de.cotto.lndmanagej.model.Coins;
+import de.cotto.lndmanagej.service.BalanceService;
+import de.cotto.lndmanagej.service.ChannelService;
+import de.cotto.lndmanagej.service.NodeService;
+import de.cotto.lndmanagej.service.OnChainCostService;
+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.ChannelIdFixtures.CHANNEL_ID;
+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.PubkeyFixtures.PUBKEY_2;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ChannelDetailsControllerTest {
+    private static final Coins OPEN_COSTS = Coins.ofSatoshis(1);
+    private static final Coins CLOSE_COSTS = Coins.ofSatoshis(2);
+    private static final OnChainCostsDto ON_CHAIN_COSTS = new OnChainCostsDto(OPEN_COSTS, CLOSE_COSTS);
+    @InjectMocks
+    private ChannelDetailsController channelDetailsController;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private NodeService nodeService;
+
+    @Mock
+    private Metrics metrics;
+
+    @Mock
+    private BalanceService balanceService;
+
+    @Mock
+    private OnChainCostService onChainCostService;
+
+    @BeforeEach
+    void setUp() {
+        lenient().when(onChainCostService.getOpenCosts(CHANNEL_ID)).thenReturn(Optional.of(OPEN_COSTS));
+        lenient().when(onChainCostService.getCloseCosts(CHANNEL_ID)).thenReturn(Optional.of(CLOSE_COSTS));
+    }
+
+    @Test
+    void getDetails_channel_not_found() {
+        assertThatExceptionOfType(NotFoundException.class)
+                .isThrownBy(() -> channelDetailsController.getDetails(CHANNEL_ID));
+    }
+
+    @Test
+    void getDetails() throws NotFoundException {
+        ChannelDetailsDto expectedDetails = new ChannelDetailsDto(
+                LOCAL_OPEN_CHANNEL,
+                ALIAS_2,
+                LOCAL_OPEN_CHANNEL.getBalanceInformation(),
+                ON_CHAIN_COSTS
+        );
+        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()));
+
+        assertThat(channelDetailsController.getDetails(CHANNEL_ID)).isEqualTo(expectedDetails);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getDetails")));
+    }
+
+    @Test
+    void getDetails_private() throws NotFoundException {
+        ChannelDetailsDto expectedDetails = new ChannelDetailsDto(
+                LOCAL_OPEN_CHANNEL_PRIVATE,
+                ALIAS_2,
+                LOCAL_OPEN_CHANNEL_PRIVATE.getBalanceInformation(),
+                ON_CHAIN_COSTS
+        );
+        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(channelDetailsController.getDetails(CHANNEL_ID)).isEqualTo(expectedDetails);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getDetails")));
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/ChannelIdConverterTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/ChannelIdConverterTest.java
@@ -0,0 +1,23 @@
+package de.cotto.lndmanagej.controller;
+
+import org.junit.jupiter.api.Test;
+
+import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ChannelIdConverterTest {
+    @Test
+    void convert() {
+        assertThat(new ChannelIdConverter().convert(CHANNEL_ID.toString())).isEqualTo(CHANNEL_ID);
+    }
+
+    @Test
+    void convert_from_compact_form_with_x() {
+        assertThat(new ChannelIdConverter().convert("712345x123x1")).isEqualTo(CHANNEL_ID);
+    }
+
+    @Test
+    void convert_from_compact_form() {
+        assertThat(new ChannelIdConverter().convert("712345:123:1")).isEqualTo(CHANNEL_ID);
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/CostExceptionHandlerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/CostExceptionHandlerTest.java
@@ -0,0 +1,29 @@
+package de.cotto.lndmanagej.controller;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(MockitoExtension.class)
+class CostExceptionHandlerTest {
+    private static final CostException EXCEPTION = new CostException("abc");
+
+    @InjectMocks
+    private CostExceptionHandler costExceptionHandler;
+
+    @Test
+    void mapsToBadRequest() {
+        assertThat(costExceptionHandler.handleException(EXCEPTION).getStatusCode())
+                .isEqualTo(HttpStatus.BAD_REQUEST);
+    }
+
+    @Test
+    void returnsMessageInBody() {
+        assertThat(costExceptionHandler.handleException(EXCEPTION).getBody())
+                .isEqualTo(EXCEPTION.getMessage());
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/LegacyControllerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/LegacyControllerTest.java
@@ -0,0 +1,224 @@
+package de.cotto.lndmanagej.controller;
+
+import de.cotto.lndmanagej.metrics.Metrics;
+import de.cotto.lndmanagej.model.Coins;
+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 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.ChannelFixtures.CAPACITY;
+import static de.cotto.lndmanagej.model.ChannelFixtures.CAPACITY_2;
+import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
+import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_3;
+import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_COMPACT;
+import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID_COMPACT_4;
+import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL;
+import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL_3;
+import static de.cotto.lndmanagej.model.ForceClosingChannelFixtures.FORCE_CLOSING_CHANNEL;
+import static de.cotto.lndmanagej.model.ForceClosingChannelFixtures.FORCE_CLOSING_CHANNEL_3;
+import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL;
+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.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL_TO_NODE_3;
+import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_2;
+import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS_3;
+import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
+import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2;
+import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_3;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class LegacyControllerTest {
+    @InjectMocks
+    private LegacyController legacyController;
+
+    @Mock
+    private NodeService nodeService;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private FeeService feeService;
+
+    @Mock
+    private BalanceService balanceService;
+
+    @Mock
+    private Metrics metrics;
+
+    @Test
+    void getAllChannelIds_for_peer() {
+        when(channelService.getAllChannelsWith(PUBKEY)).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, CLOSED_CHANNEL_3));
+        assertThat(legacyController.getAllChannelIdsForPubkey(PUBKEY)).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+        verify(metrics).mark(argThat(name -> name.endsWith(".getAllChannelIdsForPubkey")));
+    }
+
+    @Test
+    void getAllChannelIds_for_peer_ordered() {
+        when(channelService.getAllChannelsWith(PUBKEY)).thenReturn(Set.of(CLOSED_CHANNEL_3, LOCAL_OPEN_CHANNEL));
+        assertThat(legacyController.getAllChannelIdsForPubkey(PUBKEY)).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+    }
+
+    @Test
+    void getOpenChannelIds() {
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, LOCAL_OPEN_CHANNEL_3));
+        assertThat(legacyController.getOpenChannelIds()).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+        verify(metrics).mark(argThat(name -> name.endsWith(".getOpenChannelIds")));
+    }
+
+    @Test
+    void getOpenChannelIds_ordered() {
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL_3, LOCAL_OPEN_CHANNEL));
+        assertThat(legacyController.getOpenChannelIds()).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+    }
+
+    @Test
+    void getOpenChannelIdsPretty() {
+        when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2);
+        when(nodeService.getAlias(PUBKEY_3)).thenReturn(ALIAS_3);
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, LOCAL_OPEN_CHANNEL_TO_NODE_3));
+        assertThat(legacyController.getOpenChannelIdsPretty()).isEqualTo(
+                CHANNEL_ID_COMPACT + "\t" + PUBKEY_2 + "\t" + CAPACITY + "\t" + ALIAS_2 + "\n" +
+                        CHANNEL_ID_COMPACT_4 + "\t" + PUBKEY_3 + "\t" + CAPACITY_2 + "\t" + ALIAS_3
+        );
+        verify(metrics).mark(argThat(name -> name.endsWith(".getOpenChannelIdsPretty")));
+    }
+
+    @Test
+    void getOpenChannelIdsPretty_ordered() {
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL_TO_NODE_3, LOCAL_OPEN_CHANNEL));
+        assertThat(legacyController.getOpenChannelIdsPretty())
+                .matches(CHANNEL_ID_COMPACT + ".*\n" + CHANNEL_ID_COMPACT_4 + ".*");
+    }
+
+    @Test
+    void getClosedChannelIds() {
+        when(channelService.getClosedChannels()).thenReturn(Set.of(CLOSED_CHANNEL, CLOSED_CHANNEL_3));
+        assertThat(legacyController.getClosedChannelIds()).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+        verify(metrics).mark(argThat(name -> name.endsWith(".getClosedChannelIds")));
+    }
+
+    @Test
+    void getClosedChannelIds_ordered() {
+        when(channelService.getClosedChannels()).thenReturn(Set.of(CLOSED_CHANNEL_3, CLOSED_CHANNEL));
+        assertThat(legacyController.getClosedChannelIds()).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+    }
+
+    @Test
+    void getForceClosingChannelIds() {
+        when(channelService.getForceClosingChannels())
+                .thenReturn(Set.of(FORCE_CLOSING_CHANNEL, FORCE_CLOSING_CHANNEL_3));
+        assertThat(legacyController.getForceClosingChannelIds()).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+        verify(metrics).mark(argThat(name -> name.endsWith(".getForceClosingChannelIds")));
+    }
+
+    @Test
+    void getForceClosingChannelIds_ordered() {
+        when(channelService.getForceClosingChannels())
+                .thenReturn(Set.of(FORCE_CLOSING_CHANNEL_3, FORCE_CLOSING_CHANNEL));
+        assertThat(legacyController.getForceClosingChannelIds()).isEqualTo(
+                CHANNEL_ID + "\n" + CHANNEL_ID_3
+        );
+    }
+
+    @Test
+    void getPeerPubkeys() {
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, LOCAL_OPEN_CHANNEL_TO_NODE_3));
+        assertThat(legacyController.getPeerPubkeys()).isEqualTo(PUBKEY_2 + "\n" + PUBKEY_3);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getPeerPubkeys")));
+    }
+
+    @Test
+    void getPeerPubkeys_sorted() {
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL_TO_NODE_3, LOCAL_OPEN_CHANNEL));
+        assertThat(legacyController.getPeerPubkeys()).isEqualTo(PUBKEY_2 + "\n" + PUBKEY_3);
+    }
+
+    @Test
+    void getPeerPubkeys_without_duplicates() {
+        when(channelService.getOpenChannels()).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, LOCAL_OPEN_CHANNEL_2));
+        assertThat(legacyController.getPeerPubkeys()).isEqualTo(PUBKEY_2.toString());
+    }
+
+    @Test
+    void getIncomingFeeRate() {
+        when(feeService.getIncomingFeeRate(CHANNEL_ID)).thenReturn(123L);
+        assertThat(legacyController.getIncomingFeeRate(CHANNEL_ID)).isEqualTo(123);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getIncomingFeeRate")));
+    }
+
+    @Test
+    void getOutgoingFeeRate() {
+        when(feeService.getOutgoingFeeRate(CHANNEL_ID)).thenReturn(123L);
+        assertThat(legacyController.getOutgoingFeeRate(CHANNEL_ID)).isEqualTo(123);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getOutgoingFeeRate")));
+    }
+
+    @Test
+    void getIncomingBaseFee() {
+        when(feeService.getIncomingBaseFee(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(10L));
+        assertThat(legacyController.getIncomingBaseFee(CHANNEL_ID)).isEqualTo(10);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getIncomingBaseFee")));
+    }
+
+    @Test
+    void getOutgoingBaseFee() {
+        when(feeService.getOutgoingBaseFee(CHANNEL_ID)).thenReturn(Coins.ofMilliSatoshis(10L));
+        assertThat(legacyController.getOutgoingBaseFee(CHANNEL_ID)).isEqualTo(10);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getOutgoingBaseFee")));
+    }
+
+    @Test
+    void getAvailableLocalBalance_channel() {
+        when(balanceService.getAvailableLocalBalance(CHANNEL_ID)).thenReturn(Coins.ofSatoshis(123L));
+        assertThat(legacyController.getAvailableLocalBalanceForChannel(CHANNEL_ID)).isEqualTo(123);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getAvailableLocalBalanceForChannel")));
+    }
+
+    @Test
+    void getAvailableRemoteBalance_channel() {
+        when(balanceService.getAvailableRemoteBalance(CHANNEL_ID)).thenReturn(Coins.ofSatoshis(123L));
+        assertThat(legacyController.getAvailableRemoteBalanceForChannel(CHANNEL_ID)).isEqualTo(123);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getAvailableRemoteBalanceForChannel")));
+    }
+
+    @Test
+    void getAvailableLocalBalance_peer() {
+        when(balanceService.getAvailableLocalBalance(PUBKEY)).thenReturn(Coins.ofSatoshis(246L));
+        assertThat(legacyController.getAvailableLocalBalanceForPeer(PUBKEY)).isEqualTo(246);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getAvailableLocalBalanceForPeer")));
+    }
+
+    @Test
+    void getAvailableRemoteBalance_peer() {
+        when(balanceService.getAvailableRemoteBalance(PUBKEY)).thenReturn(Coins.ofSatoshis(246L));
+        assertThat(legacyController.getAvailableRemoteBalanceForPeer(PUBKEY)).isEqualTo(246);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getAvailableRemoteBalanceForPeer")));
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/NodeControllerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/NodeControllerTest.java
@@ -0,0 +1,143 @@
+package de.cotto.lndmanagej.controller;
+
+import de.cotto.lndmanagej.controller.dto.BalanceInformationDto;
+import de.cotto.lndmanagej.controller.dto.ChannelsForNodeDto;
+import de.cotto.lndmanagej.controller.dto.NodeDetailsDto;
+import de.cotto.lndmanagej.controller.dto.OnChainCostsDto;
+import de.cotto.lndmanagej.metrics.Metrics;
+import de.cotto.lndmanagej.model.BalanceInformation;
+import de.cotto.lndmanagej.model.Coins;
+import de.cotto.lndmanagej.model.Node;
+import de.cotto.lndmanagej.model.Pubkey;
+import de.cotto.lndmanagej.service.BalanceService;
+import de.cotto.lndmanagej.service.ChannelService;
+import de.cotto.lndmanagej.service.NodeService;
+import de.cotto.lndmanagej.service.OnChainCostService;
+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.List;
+import java.util.Set;
+
+import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION;
+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;
+import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL_2;
+import static de.cotto.lndmanagej.model.CoopClosedChannelFixtures.CLOSED_CHANNEL_3;
+import static de.cotto.lndmanagej.model.ForceClosingChannelFixtures.FORCE_CLOSING_CHANNEL;
+import static de.cotto.lndmanagej.model.ForceClosingChannelFixtures.FORCE_CLOSING_CHANNEL_2;
+import static de.cotto.lndmanagej.model.ForceClosingChannelFixtures.FORCE_CLOSING_CHANNEL_3;
+import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL;
+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.PubkeyFixtures.PUBKEY;
+import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY_2;
+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;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class NodeControllerTest {
+    @InjectMocks
+    private NodeController nodeController;
+
+    @Mock
+    private NodeService nodeService;
+
+    @Mock
+    private Metrics metrics;
+
+    @Mock
+    private ChannelService channelService;
+
+    @Mock
+    private OnChainCostService onChainCostService;
+
+    @Mock
+    private BalanceService balanceService;
+
+    @Test
+    void getAlias() {
+        when(nodeService.getAlias(PUBKEY_2)).thenReturn(ALIAS_2);
+
+        assertThat(nodeController.getAlias(PUBKEY_2)).isEqualTo(ALIAS_2);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getAlias")));
+    }
+
+    @Test
+    void getNodeDetails_no_channels() {
+        when(onChainCostService.getOpenCostsWith(any())).thenReturn(Coins.NONE);
+        when(onChainCostService.getCloseCostsWith(any())).thenReturn(Coins.NONE);
+        when(balanceService.getBalanceInformation(any(Pubkey.class))).thenReturn(BalanceInformation.EMPTY);
+        NodeDetailsDto expectedDetails = new NodeDetailsDto(
+                PUBKEY_2,
+                ALIAS_2,
+                List.of(),
+                List.of(),
+                List.of(),
+                List.of(),
+                new OnChainCostsDto(Coins.NONE, Coins.NONE),
+                BalanceInformationDto.createFrom(BalanceInformation.EMPTY),
+                true
+        );
+        when(nodeService.getNode(PUBKEY_2)).thenReturn(new Node(PUBKEY_2, ALIAS_2, 0, true));
+
+        assertThat(nodeController.getDetails(PUBKEY_2)).isEqualTo(expectedDetails);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getDetails")));
+    }
+
+    @Test
+    void getNodeDetails_with_channels() {
+        when(nodeService.getNode(PUBKEY_2)).thenReturn(new Node(PUBKEY_2, ALIAS_2, 0, false));
+        when(channelService.getOpenChannelsWith(PUBKEY_2)).thenReturn(Set.of(LOCAL_OPEN_CHANNEL_3, LOCAL_OPEN_CHANNEL));
+        when(channelService.getClosedChannelsWith(PUBKEY_2)).thenReturn(Set.of(CLOSED_CHANNEL_2, CLOSED_CHANNEL_3));
+        when(channelService.getWaitingCloseChannelsFor(PUBKEY_2)).thenReturn(
+                Set.of(WAITING_CLOSE_CHANNEL, WAITING_CLOSE_CHANNEL_2)
+        );
+        when(channelService.getForceClosingChannelsFor(PUBKEY_2)).thenReturn(
+                Set.of(FORCE_CLOSING_CHANNEL, FORCE_CLOSING_CHANNEL_2, FORCE_CLOSING_CHANNEL_3)
+        );
+        Coins openCosts = Coins.ofSatoshis(123);
+        Coins closeCosts = Coins.ofSatoshis(456);
+        when(onChainCostService.getOpenCostsWith(PUBKEY_2)).thenReturn(openCosts);
+        when(onChainCostService.getCloseCostsWith(PUBKEY_2)).thenReturn(closeCosts);
+        when(balanceService.getBalanceInformation(PUBKEY_2)).thenReturn(BALANCE_INFORMATION);
+        NodeDetailsDto expectedDetails = new NodeDetailsDto(
+                PUBKEY_2,
+                ALIAS_2,
+                List.of(CHANNEL_ID, CHANNEL_ID_3),
+                List.of(CHANNEL_ID_2, CHANNEL_ID_3),
+                List.of(CHANNEL_ID, CHANNEL_ID_2),
+                List.of(CHANNEL_ID, CHANNEL_ID_2, CHANNEL_ID_3),
+                new OnChainCostsDto(openCosts, closeCosts),
+                BalanceInformationDto.createFrom(BALANCE_INFORMATION),
+                false
+        );
+
+        assertThat(nodeController.getDetails(PUBKEY_2)).isEqualTo(expectedDetails);
+    }
+
+    @Test
+    void getOpenChannelIds_for_peer() {
+        when(channelService.getOpenChannelsWith(PUBKEY)).thenReturn(Set.of(LOCAL_OPEN_CHANNEL, LOCAL_OPEN_CHANNEL_3));
+        assertThat(nodeController.getOpenChannelIdsForPubkey(PUBKEY))
+                .isEqualTo(new ChannelsForNodeDto(PUBKEY, List.of(CHANNEL_ID, CHANNEL_ID_3)));
+        verify(metrics).mark(argThat(name -> name.endsWith(".getOpenChannelIdsForPubkey")));
+    }
+
+    @Test
+    void getOpenChannelIds_for_peer_ordered() {
+        when(channelService.getOpenChannelsWith(PUBKEY)).thenReturn(Set.of(LOCAL_OPEN_CHANNEL_2, LOCAL_OPEN_CHANNEL));
+        assertThat(nodeController.getOpenChannelIdsForPubkey(PUBKEY))
+                .isEqualTo(new ChannelsForNodeDto(PUBKEY, List.of(CHANNEL_ID, CHANNEL_ID_2)));
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/NotFoundExceptionHandlerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/NotFoundExceptionHandlerTest.java
@@ -0,0 +1,23 @@
+package de.cotto.lndmanagej.controller;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(MockitoExtension.class)
+class NotFoundExceptionHandlerTest {
+    private static final NotFoundException EXCEPTION = new NotFoundException();
+
+    @InjectMocks
+    private NotFoundExceptionHandler exceptionHandler;
+
+    @Test
+    void mapsToNotFound() {
+        assertThat(exceptionHandler.handleException(EXCEPTION).getStatusCode())
+                .isEqualTo(HttpStatus.NOT_FOUND);
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/OnChainCostsControllerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/OnChainCostsControllerTest.java
@@ -0,0 +1,74 @@
+package de.cotto.lndmanagej.controller;
+
+import de.cotto.lndmanagej.controller.dto.OnChainCostsDto;
+import de.cotto.lndmanagej.metrics.Metrics;
+import de.cotto.lndmanagej.model.Coins;
+import de.cotto.lndmanagej.service.OnChainCostService;
+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.ChannelIdFixtures.CHANNEL_ID;
+import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class OnChainCostsControllerTest {
+    @InjectMocks
+    private OnChainCostsController onChainCostsController;
+
+    @Mock
+    private OnChainCostService onChainCostService;
+
+    @Mock
+    private Metrics metrics;
+
+    @Test
+    void getCostsForPeer() throws CostException {
+        Coins openCosts = Coins.ofSatoshis(123);
+        Coins closeCosts = Coins.ofSatoshis(456);
+        when(onChainCostService.getOpenCostsWith(PUBKEY)).thenReturn(openCosts);
+        when(onChainCostService.getCloseCostsWith(PUBKEY)).thenReturn(closeCosts);
+        OnChainCostsDto expected = new OnChainCostsDto(openCosts, closeCosts);
+        assertThat(onChainCostsController.getCostsForPeer(PUBKEY)).isEqualTo(expected);
+        verify(metrics).mark(argThat(name -> name.endsWith(".getCostsForPeer")));
+    }
+
+    @Test
+    void getOpenCostsForChannel() throws CostException {
+        Coins coins = Coins.ofSatoshis(123);
+        when(onChainCostService.getOpenCosts(CHANNEL_ID)).thenReturn(Optional.of(coins));
+        assertThat(onChainCostsController.getOpenCostsForChannel(CHANNEL_ID)).isEqualTo(coins.satoshis());
+        verify(metrics).mark(argThat(name -> name.endsWith(".getOpenCostsForChannel")));
+    }
+
+    @Test
+    void getOpenCostsForChannel_unknown() {
+        assertThatExceptionOfType(CostException.class).isThrownBy(
+                () -> onChainCostsController.getOpenCostsForChannel(CHANNEL_ID)
+        );
+    }
+
+    @Test
+    void getCloseCostsForChannel() throws CostException {
+        Coins coins = Coins.ofSatoshis(123);
+        when(onChainCostService.getCloseCosts(CHANNEL_ID)).thenReturn(Optional.of(coins));
+        assertThat(onChainCostsController.getCloseCostsForChannel(CHANNEL_ID)).isEqualTo(coins.satoshis());
+        verify(metrics).mark(argThat(name -> name.endsWith(".getCloseCostsForChannel")));
+    }
+
+    @Test
+    void getCloseCostsForChannel_unknown() {
+        assertThatExceptionOfType(CostException.class).isThrownBy(
+                () -> onChainCostsController.getCloseCostsForChannel(CHANNEL_ID)
+        );
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/PubkeyConverterTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/PubkeyConverterTest.java
@@ -0,0 +1,13 @@
+package de.cotto.lndmanagej.controller;
+
+import org.junit.jupiter.api.Test;
+
+import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PubkeyConverterTest {
+    @Test
+    void convert() {
+        assertThat(new PubkeyConverter().convert(PUBKEY.toString())).isEqualTo(PUBKEY);
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/StatusControllerTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/StatusControllerTest.java
@@ -0,0 +1,40 @@
+package de.cotto.lndmanagej.controller;
+
+import de.cotto.lndmanagej.metrics.Metrics;
+import de.cotto.lndmanagej.service.OwnNodeService;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class StatusControllerTest {
+    @InjectMocks
+    private StatusController statusController;
+
+    @Mock
+    private OwnNodeService ownNodeService;
+
+    @Mock
+    private Metrics metrics;
+
+    @Test
+    void isSyncedToChain() {
+        when(ownNodeService.isSyncedToChain()).thenReturn(true);
+
+        assertThat(statusController.isSyncedToChain()).isTrue();
+        verify(metrics).mark(argThat(name -> name.endsWith(".isSyncedToChain")));
+    }
+
+    @Test
+    void isSyncedToChain_false() {
+        when(ownNodeService.isSyncedToChain()).thenReturn(false);
+        assertThat(statusController.isSyncedToChain()).isFalse();
+    }
+}
--- a/web/src/test/java/de/cotto/lndmanagej/controller/dto/BalanceInformationDtoTest.java
+++ b/web/src/test/java/de/cotto/lndmanagej/controller/dto/BalanceInformationDtoTest.java
@@ -0,0 +1,21 @@
+package de.cotto.lndmanagej.controller.dto;
+
+import org.junit.jupiter.api.Test;
+
+import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class BalanceInformationDtoTest {
+    @Test
+    void createFrom() {
+        BalanceInformationDto expected = new BalanceInformationDto(
+                String.valueOf(BALANCE_INFORMATION.localBalance().satoshis()),
+                String.valueOf(BALANCE_INFORMATION.localReserve().satoshis()),
+                String.valueOf(BALANCE_INFORMATION.localAvailable().satoshis()),
+                String.valueOf(BALANCE_INFORMATION.remoteBalance().satoshis()),
+                String.valueOf(BALANCE_INFORMATION.remoteReserve().satoshis()),
+                String.valueOf(BALANCE_INFORMATION.remoteAvailable().satoshis())
+        );
+        assertThat(BalanceInformationDto.createFrom(BALANCE_INFORMATION)).isEqualTo(expected);
+    }
+}