extract ui into dedicated module

web/src/test/java/de/cotto/lndmanagej/UiDataServiceImplTest.java

@@ -1,143 +0,0 @@
-package de.cotto.lndmanagej;
-
-import de.cotto.lndmanagej.controller.ChannelController;
-import de.cotto.lndmanagej.controller.NodeController;
-import de.cotto.lndmanagej.controller.NotFoundException;
-import de.cotto.lndmanagej.controller.StatusController;
-import de.cotto.lndmanagej.controller.WarningsController;
-import de.cotto.lndmanagej.controller.dto.BalanceInformationDto;
-import de.cotto.lndmanagej.controller.dto.ChannelDetailsDto;
-import de.cotto.lndmanagej.controller.dto.ChannelsDto;
-import de.cotto.lndmanagej.controller.dto.FeeReportDto;
-import de.cotto.lndmanagej.controller.dto.FlowReportDto;
-import de.cotto.lndmanagej.controller.dto.NodesAndChannelsWithWarningsDto;
-import de.cotto.lndmanagej.controller.dto.OnChainCostsDto;
-import de.cotto.lndmanagej.controller.dto.PoliciesDto;
-import de.cotto.lndmanagej.controller.dto.RebalanceReportDto;
-import de.cotto.lndmanagej.service.ChannelService;
-import de.cotto.lndmanagej.service.NodeService;
-import de.cotto.lndmanagej.ui.dto.NodeDto;
-import de.cotto.lndmanagej.ui.dto.OpenChannelDto;
-import de.cotto.lndmanagej.ui.dto.StatusModel;
-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.Optional;
-import java.util.Set;
-
-import static de.cotto.lndmanagej.controller.dto.NodeDetailsDtoFixture.NODE_DETAILS_DTO;
-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.FeeReportFixtures.FEE_REPORT;
-import static de.cotto.lndmanagej.model.FlowReportFixtures.FLOW_REPORT;
-import static de.cotto.lndmanagej.model.LocalOpenChannelFixtures.LOCAL_OPEN_CHANNEL;
-import static de.cotto.lndmanagej.model.NodeFixtures.ALIAS;
-import static de.cotto.lndmanagej.model.NodeFixtures.NODE_PEER;
-import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS;
-import static de.cotto.lndmanagej.model.OpenInitiator.LOCAL;
-import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES_FOR_LOCAL_CHANNEL;
-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.warnings.ChannelWarningFixtures.CHANNEL_NUM_UPDATES_WARNING;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class UiDataServiceImplTest {
-    @InjectMocks
-    private UiDataServiceImpl uiDataService;
-
-    @Mock
-    private StatusController statusController;
-
-    @Mock
-    private WarningsController warningsController;
-
-    @Mock
-    private ChannelController channelController;
-
-    @Mock
-    private ChannelService channelService;
-
-    @Mock
-    private NodeController nodeController;
-
-    @Mock
-    private NodeService nodeService;
-
-    @Test
-    void getStatus() {
-        int blockHeight = 995;
-        NodesAndChannelsWithWarningsDto warnings = new NodesAndChannelsWithWarningsDto(List.of(), List.of());
-        when(statusController.isSyncedToChain()).thenReturn(true);
-        when(statusController.getBlockHeight()).thenReturn(blockHeight);
-        when(warningsController.getWarnings()).thenReturn(warnings);
-        StatusModel expected = new StatusModel(true, blockHeight, warnings);
-
-        assertThat(uiDataService.getStatus()).isEqualTo(expected);
-    }
-
-    @Test
-    void getOpenChannels() {
-        String alias = "remote alias";
-        PoliciesDto policies = PoliciesDto.createFromModel(POLICIES_FOR_LOCAL_CHANNEL);
-        BalanceInformationDto balance = BalanceInformationDto.createFromModel(BALANCE_INFORMATION);
-        when(channelService.getLocalChannel(CHANNEL_ID)).thenReturn(Optional.of(LOCAL_OPEN_CHANNEL));
-        when(nodeController.getAlias(PUBKEY_2)).thenReturn(alias);
-        when(channelController.getPolicies(CHANNEL_ID)).thenReturn(policies);
-        when(channelController.getBalance(CHANNEL_ID)).thenReturn(balance);
-        when(statusController.getOpenChannels()).thenReturn(new ChannelsDto(List.of(CHANNEL_ID)));
-
-        assertThat(uiDataService.getOpenChannels()).containsExactly(
-                new OpenChannelDto(CHANNEL_ID, alias, PUBKEY_2, policies, balance)
-        );
-    }
-
-    @Test
-    void getChannelDetails() throws Exception {
-        when(channelController.getDetails(CHANNEL_ID)).thenReturn(ChannelDetailsDto.createFromModel(CHANNEL_DETAILS));
-        assertThat(uiDataService.getChannelDetails(CHANNEL_ID)).isEqualTo(
-                new de.cotto.lndmanagej.ui.dto.ChannelDetailsDto(
-                        CHANNEL_ID,
-                        PUBKEY_2,
-                        ALIAS,
-                        LOCAL,
-                        BalanceInformationDto.createFromModel(BALANCE_INFORMATION),
-                        OnChainCostsDto.createFromModel(ON_CHAIN_COSTS),
-                        PoliciesDto.createFromModel(POLICIES_FOR_LOCAL_CHANNEL),
-                        FeeReportDto.createFromModel(FEE_REPORT),
-                        FlowReportDto.createFromModel(FLOW_REPORT),
-                        RebalanceReportDto.createFromModel(REBALANCE_REPORT),
-                        Set.of(CHANNEL_NUM_UPDATES_WARNING.description())
-                ));
-    }
-
-    @Test
-    void getChannelDetails_not_found() throws Exception {
-        when(channelController.getDetails(CHANNEL_ID)).thenThrow(NotFoundException.class);
-        assertThatExceptionOfType(NotFoundException.class).isThrownBy(
-                () -> uiDataService.getChannelDetails(CHANNEL_ID)
-        );
-    }
-
-    @Test
-    void getNode() {
-        when(nodeService.getNode(PUBKEY)).thenReturn(NODE_PEER);
-        assertThat(uiDataService.getNode(PUBKEY)).isEqualTo(
-                new NodeDto(PUBKEY.toString(), NODE_PEER.alias(), true)
-        );
-    }
-
-    @Test
-    void getNodeDetails() {
-        when(nodeController.getDetails(PUBKEY)).thenReturn(NODE_DETAILS_DTO);
-        assertThat(uiDataService.getNodeDetails(PUBKEY)).isEqualTo(NODE_DETAILS_DTO);
-    }
-}

web/src/test/java/de/cotto/lndmanagej/controller/dto/SelfPaymentsDtoTest.java

@@ -1,6 +1,5 @@
-package de.cotto.lndmanagej.dto;
+package de.cotto.lndmanagej.controller.dto;
 
-import de.cotto.lndmanagej.controller.dto.SelfPaymentsDto;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;

web/src/test/java/de/cotto/lndmanagej/ui/UiDataServiceTest.java

@@ -1,57 +0,0 @@
-package de.cotto.lndmanagej.ui;
-
-import de.cotto.lndmanagej.controller.dto.NodeDetailsDto;
-import de.cotto.lndmanagej.model.ChannelId;
-import de.cotto.lndmanagej.model.Pubkey;
-import de.cotto.lndmanagej.ui.dto.ChannelDetailsDto;
-import de.cotto.lndmanagej.ui.dto.NodeDto;
-import de.cotto.lndmanagej.ui.dto.OpenChannelDto;
-import de.cotto.lndmanagej.ui.dto.StatusModel;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static de.cotto.lndmanagej.controller.dto.ChannelDetailsDtoFixture.CHANNEL_DETAILS_DTO;
-import static de.cotto.lndmanagej.controller.dto.NodeDetailsDtoFixture.NODE_DETAILS_DTO;
-import static de.cotto.lndmanagej.controller.dto.NodesAndChannelsWithWarningsDto.NONE;
-import static de.cotto.lndmanagej.controller.dto.OpenChannelDtoFixture.OPEN_CHANNEL_DTO;
-import static de.cotto.lndmanagej.model.NodeFixtures.NODE;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static org.assertj.core.api.Assertions.assertThat;
-
-class UiDataServiceTest {
-    private static final NodeDto NODE_DTO = new NodeDto(PUBKEY.toString(), NODE.alias(), true);
-    private final UiDataService uiDataService = new TestableUiDataService();
-
-    @Test
-    void createNodeList() {
-        assertThat(uiDataService.createNodeList()).containsExactly(NODE_DTO);
-    }
-
-    private static class TestableUiDataService extends UiDataService {
-        @Override
-        public StatusModel getStatus() {
-            return new StatusModel(true, 123, NONE);
-        }
-
-        @Override
-        public List<OpenChannelDto> getOpenChannels() {
-            return List.of(OPEN_CHANNEL_DTO);
-        }
-
-        @Override
-        public ChannelDetailsDto getChannelDetails(ChannelId channelId) {
-            return CHANNEL_DETAILS_DTO;
-        }
-
-        @Override
-        public NodeDto getNode(Pubkey pubkey) {
-            return NODE_DTO;
-        }
-
-        @Override
-        public NodeDetailsDto getNodeDetails(Pubkey pubkey) {
-            return NODE_DETAILS_DTO;
-        }
-    }
-}

web/src/test/java/de/cotto/lndmanagej/ui/controller/ChannelDetailsControllerTest.java

@@ -1,47 +0,0 @@
-package de.cotto.lndmanagej.ui.controller;
-
-import de.cotto.lndmanagej.controller.NotFoundException;
-import de.cotto.lndmanagej.ui.page.PageService;
-import de.cotto.lndmanagej.ui.page.channel.ChannelDetailsPage;
-import de.cotto.lndmanagej.ui.page.general.ErrorPage;
-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 org.springframework.ui.Model;
-
-import java.util.Map;
-
-import static de.cotto.lndmanagej.controller.dto.ChannelDetailsDtoFixture.CHANNEL_DETAILS_DTO;
-import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class ChannelDetailsControllerTest {
-    @InjectMocks
-    private ChannelDetailsController channelDetailsController;
-
-    @Mock
-    private PageService pageService;
-
-    @Mock
-    private Model model;
-
-    @Test
-    void channelDetails() throws NotFoundException {
-        when(pageService.channelDetails(CHANNEL_ID)).thenReturn(new ChannelDetailsPage(CHANNEL_DETAILS_DTO));
-        assertThat(channelDetailsController.channelDetails(CHANNEL_ID, model)).isEqualTo("channel-details");
-        verify(model).addAllAttributes(Map.of("channel", CHANNEL_DETAILS_DTO, "id", CHANNEL_ID));
-    }
-
-    @Test
-    void channelDetails_not_found() throws NotFoundException {
-        when(pageService.channelDetails(CHANNEL_ID)).thenThrow(NotFoundException.class);
-        when(pageService.error("Channel not found.")).thenReturn(new ErrorPage("x"));
-        assertThat(channelDetailsController.channelDetails(CHANNEL_ID, model)).isEqualTo("error");
-        verify(model).addAllAttributes(Map.of("error", "x"));
-    }
-}

web/src/test/java/de/cotto/lndmanagej/ui/controller/DashboardControllerTest.java

@@ -1,95 +0,0 @@
-package de.cotto.lndmanagej.ui.controller;
-
-import de.cotto.lndmanagej.controller.dto.BalanceInformationDto;
-import de.cotto.lndmanagej.controller.dto.PoliciesDto;
-import de.cotto.lndmanagej.model.BalanceInformation;
-import de.cotto.lndmanagej.model.Coins;
-import de.cotto.lndmanagej.ui.dto.NodeDto;
-import de.cotto.lndmanagej.ui.dto.OpenChannelDto;
-import de.cotto.lndmanagej.ui.dto.StatusModel;
-import de.cotto.lndmanagej.ui.page.PageService;
-import de.cotto.lndmanagej.ui.page.channel.ChannelsPage;
-import de.cotto.lndmanagej.ui.page.general.DashboardPage;
-import de.cotto.lndmanagej.ui.page.node.NodesPage;
-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 org.springframework.ui.Model;
-
-import java.util.List;
-import java.util.Map;
-
-import static de.cotto.lndmanagej.controller.dto.NodesAndChannelsWithWarningsDto.NONE;
-import static de.cotto.lndmanagej.controller.dto.OpenChannelDtoFixture.OPEN_CHANNEL_DTO;
-import static de.cotto.lndmanagej.model.BalanceInformationFixtures.REMOTE_BALANCE;
-import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
-import static de.cotto.lndmanagej.model.NodeFixtures.NODE_PEER;
-import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES_FOR_LOCAL_CHANNEL;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class DashboardControllerTest {
-    private static final String CHANNELS_KEY = "channels";
-    private static final String NODES_KEY = "nodes";
-
-    @InjectMocks
-    private DashboardController dashboardController;
-
-    @Mock
-    private PageService pageService;
-
-    @Mock
-    private Model model;
-
-    @Test
-    void dashboard() {
-        StatusModel statusModel = new StatusModel(true, 213, NONE);
-        when(pageService.dashboard()).thenReturn(new DashboardPage(List.of(), List.of(), statusModel));
-        assertThat(dashboardController.dashboard(model)).isEqualTo("dashboard");
-        verify(model).addAllAttributes(
-                Map.of(NODES_KEY, List.of(), CHANNELS_KEY, List.of(), "status", statusModel)
-        );
-    }
-
-    @Test
-    void channels() {
-        when(pageService.channels()).thenReturn(new ChannelsPage(List.of(OPEN_CHANNEL_DTO)));
-        assertThat(dashboardController.channels(model)).isEqualTo(CHANNELS_KEY);
-        verify(model).addAllAttributes(Map.of(CHANNELS_KEY, List.of(OPEN_CHANNEL_DTO)));
-    }
-
-    @Test
-    void channels_sorted_by_outbound() {
-        OpenChannelDto channelA = withBalance(Coins.ofSatoshis(2));
-        OpenChannelDto channelB = withBalance(Coins.ofSatoshis(3));
-        OpenChannelDto channelC = withBalance(Coins.ofSatoshis(1));
-        when(pageService.channels()).thenReturn(new ChannelsPage(List.of(channelA, channelB, channelC)));
-        assertThat(dashboardController.channels(model)).isEqualTo(CHANNELS_KEY);
-        verify(model).addAllAttributes(Map.of(CHANNELS_KEY, List.of(channelC, channelA, channelB)));
-    }
-
-    @Test
-    void nodes() {
-        NodeDto nodeDto = new NodeDto(PUBKEY.toString(), NODE_PEER.alias(), true);
-        when(pageService.nodes()).thenReturn(new NodesPage(List.of(nodeDto)));
-        assertThat(dashboardController.nodes(model)).isEqualTo(NODES_KEY);
-        verify(model).addAllAttributes(Map.of(NODES_KEY, List.of(nodeDto)));
-    }
-
-    private OpenChannelDto withBalance(Coins localBalance) {
-        BalanceInformation balanceInformation =
-                new BalanceInformation(localBalance, Coins.NONE, REMOTE_BALANCE, Coins.NONE);
-        return new OpenChannelDto(
-                CHANNEL_ID,
-                "Albert",
-                PUBKEY,
-                PoliciesDto.createFromModel(POLICIES_FOR_LOCAL_CHANNEL),
-                BalanceInformationDto.createFromModel(balanceInformation)
-        );
-    }
-}

web/src/test/java/de/cotto/lndmanagej/ui/controller/NodeDetailsControllerTest.java

@@ -1,53 +0,0 @@
-package de.cotto.lndmanagej.ui.controller;
-
-import de.cotto.lndmanagej.ui.page.PageService;
-import de.cotto.lndmanagej.ui.page.general.ErrorPage;
-import de.cotto.lndmanagej.ui.page.node.NodeDetailsPage;
-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 org.springframework.ui.Model;
-
-import java.util.Map;
-import java.util.NoSuchElementException;
-
-import static de.cotto.lndmanagej.controller.dto.NodeDetailsDtoFixture.NODE_DETAILS_DTO;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class NodeDetailsControllerTest {
-    @InjectMocks
-    private NodeDetailsController nodeDetailsController;
-
-    @Mock
-    private PageService pageService;
-
-    @Mock
-    private Model model;
-
-    @Test
-    void nodeDetails() {
-        when(pageService.nodeDetails(PUBKEY)).thenReturn(new NodeDetailsPage(NODE_DETAILS_DTO));
-        assertThat(nodeDetailsController.nodeDetails(PUBKEY, model)).isEqualTo("node-details");
-        verify(model).addAllAttributes(Map.of("node", NODE_DETAILS_DTO, "pubkey", PUBKEY));
-    }
-
-    @Test
-    void nodeDetails_no_such_element() {
-        when(pageService.nodeDetails(PUBKEY)).thenThrow(NoSuchElementException.class);
-        when(pageService.error("Node not found.")).thenReturn(new ErrorPage("x"));
-        assertThat(nodeDetailsController.nodeDetails(PUBKEY, model)).isEqualTo("error");
-    }
-
-    @Test
-    void nodeDetails_illegal_argument() {
-        when(pageService.nodeDetails(PUBKEY)).thenThrow(IllegalArgumentException.class);
-        when(pageService.error("Invalid public key.")).thenReturn(new ErrorPage("x"));
-        assertThat(nodeDetailsController.nodeDetails(PUBKEY, model)).isEqualTo("error");
-    }
-}

web/src/test/java/de/cotto/lndmanagej/ui/controller/SearchControllerTest.java

@@ -1,101 +0,0 @@
-package de.cotto.lndmanagej.ui.controller;
-
-import de.cotto.lndmanagej.controller.ChannelIdConverter;
-import de.cotto.lndmanagej.controller.NotFoundException;
-import de.cotto.lndmanagej.ui.UiDataService;
-import de.cotto.lndmanagej.ui.dto.NodeDto;
-import de.cotto.lndmanagej.ui.dto.OpenChannelDto;
-import de.cotto.lndmanagej.ui.page.PageService;
-import de.cotto.lndmanagej.ui.page.channel.ChannelDetailsPage;
-import de.cotto.lndmanagej.ui.page.general.ErrorPage;
-import de.cotto.lndmanagej.ui.page.node.NodeDetailsPage;
-import de.cotto.lndmanagej.ui.page.node.NodesPage;
-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 org.springframework.ui.Model;
-
-import java.util.List;
-import java.util.Optional;
-
-import static de.cotto.lndmanagej.controller.dto.ChannelDetailsDtoFixture.CHANNEL_DETAILS_DTO;
-import static de.cotto.lndmanagej.controller.dto.NodeDetailsDtoFixture.NODE_DETAILS_DTO;
-import static de.cotto.lndmanagej.controller.dto.OpenChannelDtoFixture.OPEN_CHANNEL_DTO;
-import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
-import static de.cotto.lndmanagej.model.NodeFixtures.NODE_PEER;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class SearchControllerTest {
-    @InjectMocks
-    private SearchController searchController;
-
-    @Mock
-    private PageService pageService;
-
-    @Mock
-    private UiDataService dataService;
-
-    @Mock
-    private ChannelIdConverter channelIdConverter;
-
-    @Mock
-    private Model model;
-
-    @Test
-    void by_channel_id() throws NotFoundException {
-        String query = "xyz";
-        when(dataService.getOpenChannels()).thenReturn(List.of(OPEN_CHANNEL_DTO));
-        when(pageService.channelDetails(CHANNEL_ID)).thenReturn(new ChannelDetailsPage(CHANNEL_DETAILS_DTO));
-        when(channelIdConverter.tryToConvert(query)).thenReturn(Optional.of(CHANNEL_ID));
-        assertThat(searchController.search(query, model)).isEqualTo("channel-details");
-    }
-
-    @Test
-    void by_channel_id_details_not_found() throws NotFoundException {
-        String query = "abc";
-        when(dataService.getOpenChannels()).thenReturn(List.of(OPEN_CHANNEL_DTO));
-        when(channelIdConverter.tryToConvert(query)).thenReturn(Optional.of(CHANNEL_ID));
-        when(pageService.channelDetails(CHANNEL_ID)).thenThrow(NotFoundException.class);
-        when(pageService.error("Channel not found.")).thenReturn(new ErrorPage("x"));
-        assertThat(searchController.search(query, model)).isEqualTo("error");
-    }
-
-    @Test
-    void by_pubkey() {
-        when(dataService.getOpenChannels()).thenReturn(List.of(OPEN_CHANNEL_DTO));
-        when(pageService.nodeDetails(PUBKEY)).thenReturn(new NodeDetailsPage(NODE_DETAILS_DTO));
-        assertThat(searchController.search(PUBKEY.toString(), model)).isEqualTo("node-details");
-    }
-
-    @Test
-    void by_alias_infix_one_result() {
-        String query = "BERT";
-        when(dataService.getOpenChannels()).thenReturn(List.of(OPEN_CHANNEL_DTO));
-        when(pageService.nodeDetails(PUBKEY)).thenReturn(new NodeDetailsPage(NODE_DETAILS_DTO));
-        assertThat(searchController.search(query, model)).isEqualTo("node-details");
-    }
-
-    @Test
-    void by_alias_infix_two_results() {
-        String query = "BERT";
-        List<OpenChannelDto> channels = List.of(OPEN_CHANNEL_DTO, OPEN_CHANNEL_DTO);
-        when(dataService.getOpenChannels()).thenReturn(channels);
-        NodeDto nodeDto = new NodeDto(PUBKEY.toString(), NODE_PEER.alias(), true);
-        when(pageService.nodes(channels)).thenReturn(new NodesPage(List.of(nodeDto)));
-        assertThat(searchController.search(query, model)).isEqualTo("nodes");
-    }
-
-    @Test
-    void by_alias_infix_no_result() {
-        String query = "ernie";
-        List<OpenChannelDto> channels = List.of(OPEN_CHANNEL_DTO);
-        when(dataService.getOpenChannels()).thenReturn(channels);
-        when(pageService.error("No search result.")).thenReturn(new ErrorPage("x"));
-        assertThat(searchController.search(query, model)).isEqualTo("error");
-    }
-}

web/src/test/java/de/cotto/lndmanagej/ui/dto/ChannelDetailsDtoTest.java

@@ -1,83 +0,0 @@
-package de.cotto.lndmanagej.ui.dto;
-
-import de.cotto.lndmanagej.controller.dto.BalanceInformationDto;
-import de.cotto.lndmanagej.controller.dto.FeeReportDto;
-import de.cotto.lndmanagej.controller.dto.FlowReportDto;
-import de.cotto.lndmanagej.controller.dto.OnChainCostsDto;
-import de.cotto.lndmanagej.controller.dto.PoliciesDto;
-import de.cotto.lndmanagej.controller.dto.RebalanceReportDto;
-import de.cotto.lndmanagej.model.OpenInitiator;
-import org.junit.jupiter.api.Test;
-
-import static de.cotto.lndmanagej.controller.dto.ChannelDetailsDtoFixture.CHANNEL_DETAILS_DTO;
-import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION;
-import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
-import static de.cotto.lndmanagej.model.FeeReportFixtures.FEE_REPORT;
-import static de.cotto.lndmanagej.model.FlowReportFixtures.FLOW_REPORT;
-import static de.cotto.lndmanagej.model.OnChainCostsFixtures.ON_CHAIN_COSTS;
-import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES_FOR_LOCAL_CHANNEL;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static de.cotto.lndmanagej.model.RebalanceReportFixtures.REBALANCE_REPORT;
-import static de.cotto.lndmanagej.model.warnings.ChannelWarningsFixtures.CHANNEL_WARNINGS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-class ChannelDetailsDtoTest {
-    // CPD-OFF
-    @Test
-    void channelId() {
-        assertThat(CHANNEL_DETAILS_DTO.channelId()).isEqualTo(CHANNEL_ID);
-    }
-
-    @Test
-    void remotePubkey() {
-        assertThat(CHANNEL_DETAILS_DTO.remotePubkey()).isEqualTo(PUBKEY);
-    }
-
-    @Test
-    void remoteAlias() {
-        assertThat(CHANNEL_DETAILS_DTO.remoteAlias()).isEqualTo("Albert");
-    }
-
-    @Test
-    void openInitiator() {
-        assertThat(CHANNEL_DETAILS_DTO.openInitiator()).isEqualTo(OpenInitiator.LOCAL);
-    }
-
-    @Test
-    void balanceInformation() {
-        assertThat(CHANNEL_DETAILS_DTO.balanceInformation())
-                .isEqualTo(BalanceInformationDto.createFromModel(BALANCE_INFORMATION));
-    }
-
-    @Test
-    void onChainCosts() {
-        assertThat(CHANNEL_DETAILS_DTO.onChainCosts()).isEqualTo(OnChainCostsDto.createFromModel(ON_CHAIN_COSTS));
-    }
-
-    @Test
-    void policies() {
-        assertThat(CHANNEL_DETAILS_DTO.policies()).isEqualTo(PoliciesDto.createFromModel(POLICIES_FOR_LOCAL_CHANNEL));
-    }
-
-    @Test
-    void feeReport() {
-        assertThat(CHANNEL_DETAILS_DTO.feeReport()).isEqualTo(FeeReportDto.createFromModel(FEE_REPORT));
-    }
-
-    @Test
-    void flowReport() {
-        assertThat(CHANNEL_DETAILS_DTO.flowReport()).isEqualTo(FlowReportDto.createFromModel(FLOW_REPORT));
-    }
-
-    @Test
-    void rebalanceReport() {
-        assertThat(CHANNEL_DETAILS_DTO.rebalanceReport())
-                .isEqualTo(RebalanceReportDto.createFromModel(REBALANCE_REPORT));
-    }
-
-    @Test
-    void warnings() {
-        assertThat(CHANNEL_DETAILS_DTO.warnings()).isEqualTo(CHANNEL_WARNINGS.descriptions());
-    }
-    // CPD-ON
-}

web/src/test/java/de/cotto/lndmanagej/ui/dto/OpenChannelDtoTest.java

@@ -1,78 +0,0 @@
-package de.cotto.lndmanagej.ui.dto;
-
-import de.cotto.lndmanagej.controller.dto.BalanceInformationDto;
-import de.cotto.lndmanagej.controller.dto.PoliciesDto;
-import de.cotto.lndmanagej.model.BalanceInformation;
-import de.cotto.lndmanagej.model.Coins;
-import org.junit.jupiter.api.Test;
-
-import static de.cotto.lndmanagej.controller.dto.OpenChannelDtoFixture.OPEN_CHANNEL_DTO;
-import static de.cotto.lndmanagej.model.BalanceInformationFixtures.BALANCE_INFORMATION;
-import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
-import static de.cotto.lndmanagej.model.PolicyFixtures.POLICIES_FOR_LOCAL_CHANNEL;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static org.assertj.core.api.Assertions.assertThat;
-
-class OpenChannelDtoTest {
-    @Test
-    void channelId() {
-        assertThat(OPEN_CHANNEL_DTO.channelId()).isEqualTo(CHANNEL_ID);
-    }
-
-    @Test
-    void remoteAlias() {
-        assertThat(OPEN_CHANNEL_DTO.remoteAlias()).isEqualTo("Albert");
-    }
-
-    @Test
-    void remotePubkey() {
-        assertThat(OPEN_CHANNEL_DTO.remotePubkey()).isEqualTo(PUBKEY);
-    }
-
-    @Test
-    void policies() {
-        assertThat(OPEN_CHANNEL_DTO.policies()).isEqualTo(PoliciesDto.createFromModel(POLICIES_FOR_LOCAL_CHANNEL));
-    }
-
-    @Test
-    void balanceInformation() {
-        assertThat(OPEN_CHANNEL_DTO.balanceInformation())
-                .isEqualTo(BalanceInformationDto.createFromModel(BALANCE_INFORMATION));
-    }
-
-    @Test
-    void getRatio() {
-        assertThat(OPEN_CHANNEL_DTO.getRatio()).isEqualTo("· · | · · · · · · · · · · · · · · · · ·");
-    }
-
-    @Test
-    void getRatio_no_dots_left_of_bar() {
-        BalanceInformation balanceInformation = new BalanceInformation(
-                Coins.ofSatoshis(199),
-                Coins.NONE,
-                Coins.ofSatoshis(1),
-                Coins.NONE
-        );
-        assertThat(dtoWithBalance(balanceInformation).getRatio()).isEqualTo(" | · · · · · · · · · · · · · · · · · · ·");
-    }
-
-    @Test
-    void formatInbound() {
-        assertThat(OPEN_CHANNEL_DTO.formatInbound()).isEqualTo("123");
-    }
-
-    @Test
-    void formatOutbound() {
-        assertThat(OPEN_CHANNEL_DTO.formatOutbound()).isEqualTo("1,000");
-    }
-
-    private OpenChannelDto dtoWithBalance(BalanceInformation balanceInformation) {
-        return new OpenChannelDto(
-                CHANNEL_ID,
-                "Albert",
-                PUBKEY,
-                PoliciesDto.createFromModel(POLICIES_FOR_LOCAL_CHANNEL),
-                BalanceInformationDto.createFromModel(balanceInformation)
-        );
-    }
-}

web/src/test/java/de/cotto/lndmanagej/ui/page/PageServiceTest.java

@@ -1,107 +0,0 @@
-package de.cotto.lndmanagej.ui.page;
-
-import de.cotto.lndmanagej.controller.NotFoundException;
-import de.cotto.lndmanagej.controller.dto.NodesAndChannelsWithWarningsDto;
-import de.cotto.lndmanagej.ui.UiDataService;
-import de.cotto.lndmanagej.ui.dto.ChannelDetailsDto;
-import de.cotto.lndmanagej.ui.dto.NodeDto;
-import de.cotto.lndmanagej.ui.dto.OpenChannelDto;
-import de.cotto.lndmanagej.ui.dto.StatusModel;
-import de.cotto.lndmanagej.ui.page.channel.ChannelDetailsPage;
-import de.cotto.lndmanagej.ui.page.channel.ChannelsPage;
-import de.cotto.lndmanagej.ui.page.general.DashboardPage;
-import de.cotto.lndmanagej.ui.page.general.ErrorPage;
-import de.cotto.lndmanagej.ui.page.node.NodeDetailsPage;
-import de.cotto.lndmanagej.ui.page.node.NodesPage;
-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 static de.cotto.lndmanagej.controller.dto.ChannelDetailsDtoFixture.CHANNEL_DETAILS_DTO;
-import static de.cotto.lndmanagej.controller.dto.NodeDetailsDtoFixture.NODE_DETAILS_DTO;
-import static de.cotto.lndmanagej.controller.dto.OpenChannelDtoFixture.OPEN_CHANNEL_DTO;
-import static de.cotto.lndmanagej.model.ChannelIdFixtures.CHANNEL_ID;
-import static de.cotto.lndmanagej.model.NodeFixtures.NODE;
-import static de.cotto.lndmanagej.model.PubkeyFixtures.PUBKEY;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class PageServiceTest {
-    @InjectMocks
-    private PageService pageService;
-
-    @Mock
-    private UiDataService dataService;
-
-    @Test
-    void dashboard() {
-        List<OpenChannelDto> channels = List.of(OPEN_CHANNEL_DTO);
-        List<NodeDto> nodes = List.of(new NodeDto(PUBKEY.toString(), NODE.alias(), true));
-        StatusModel statusModel = new StatusModel(true, 123, new NodesAndChannelsWithWarningsDto(List.of(), List.of()));
-        when(dataService.getOpenChannels()).thenReturn(channels);
-        when(dataService.createNodeList()).thenReturn(nodes);
-        when(dataService.getStatus()).thenReturn(statusModel);
-
-        assertThat(pageService.dashboard()).usingRecursiveComparison().isEqualTo(
-                new DashboardPage(channels, nodes, statusModel)
-        );
-    }
-
-    @Test
-    void channels() {
-        when(dataService.getOpenChannels()).thenReturn(List.of(OPEN_CHANNEL_DTO));
-        assertThat(pageService.channels()).usingRecursiveComparison().isEqualTo(
-                new ChannelsPage(List.of(OPEN_CHANNEL_DTO))
-        );
-    }
-
-    @Test
-    void channelDetails() throws NotFoundException {
-        ChannelDetailsDto details = CHANNEL_DETAILS_DTO;
-        when(dataService.getChannelDetails(CHANNEL_ID)).thenReturn(details);
-
-        assertThat(pageService.channelDetails(CHANNEL_ID)).usingRecursiveComparison().isEqualTo(
-                new ChannelDetailsPage(details)
-        );
-    }
-
-    @Test
-    void nodes() {
-        NodeDto nodeDto = new NodeDto(PUBKEY.toString(), NODE.alias(), true);
-        when(dataService.createNodeList()).thenReturn(List.of(nodeDto));
-
-        assertThat(pageService.nodes()).usingRecursiveComparison().isEqualTo(
-                new NodesPage(List.of(nodeDto))
-        );
-    }
-
-    @Test
-    void nodes_for_channels() {
-        NodeDto nodeDto = new NodeDto(PUBKEY.toString(), NODE.alias(), true);
-        List<OpenChannelDto> channels = List.of(OPEN_CHANNEL_DTO);
-        when(dataService.createNodeList(channels)).thenReturn(List.of(nodeDto));
-
-        assertThat(pageService.nodes(channels)).usingRecursiveComparison().isEqualTo(
-                new NodesPage(List.of(nodeDto))
-        );
-    }
-
-    @Test
-    void nodeDetails() {
-        when(dataService.getNodeDetails(PUBKEY)).thenReturn(NODE_DETAILS_DTO);
-        assertThat(pageService.nodeDetails(PUBKEY)).usingRecursiveComparison().isEqualTo(
-                new NodeDetailsPage(NODE_DETAILS_DTO)
-        );
-    }
-
-    @Test
-    void error() {
-        String errorMessage = "foo";
-        assertThat(pageService.error(errorMessage)).usingRecursiveComparison().isEqualTo(new ErrorPage(errorMessage));
-    }
-}