/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.ignite.cli.deprecated;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.stream.Collectors.toList;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockserver.matchers.MatchType.ONLY_MATCHING_FIELDS;
import static org.mockserver.model.HttpRequest.request;
import static org.mockserver.model.HttpResponse.response;
import static org.mockserver.model.HttpStatusCode.INTERNAL_SERVER_ERROR_500;
import static org.mockserver.model.HttpStatusCode.OK_200;
import static org.mockserver.model.JsonBody.json;

import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collections;
import org.apache.ignite.cli.commands.TopLevelCliCommand;
import org.apache.ignite.cli.deprecated.builtins.init.InitIgniteCommand;
import org.apache.ignite.cli.deprecated.builtins.node.NodeManager;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockserver.integration.ClientAndServer;
import org.mockserver.junit.jupiter.MockServerExtension;
import org.mockserver.model.MediaType;
import picocli.CommandLine;

/**
 * Smoke test for Ignite CLI features and its UI. Structure of tests should be self-documented and repeat the structure of Ignite CLI
 * subcommands.
 */
@DisplayName("ignite")
@ExtendWith(MockitoExtension.class)
@ExtendWith(MockServerExtension.class)
public class IgniteCliInterfaceTest extends AbstractCliTest {
    /** DI application context. */
    ApplicationContext ctx;

    /** stderr. */
    ByteArrayOutputStream err;

    /** stdout. */
    ByteArrayOutputStream out;

    /** Configuration loader. */
    @Mock
    CliPathsConfigLoader cliPathsCfgLdr;

    /** Paths to cli working directories. */
    IgnitePaths ignitePaths = new IgnitePaths(
            Path.of("bin"),
            Path.of("work"),
            Path.of("config"),
            Path.of("log"),
            "version");

    private final ClientAndServer clientAndServer;

    private final String mockUrl;

    public IgniteCliInterfaceTest(ClientAndServer clientAndServer) {
        this.clientAndServer = clientAndServer;
        mockUrl = "http://localhost:" + clientAndServer.getPort();
    }

    /**
     * Sets up environment before test execution.
     */
    @BeforeEach
    void setup() {
        ctx = ApplicationContext.run(Environment.TEST);

        ctx.registerSingleton(cliPathsCfgLdr);

        err = new ByteArrayOutputStream();
        out = new ByteArrayOutputStream();

        clientAndServer.reset();
    }

    /**
     * Stops application context after a test.
     */
    @AfterEach
    void tearDown() {
        ctx.stop();
    }

    /**
     * Creates a new command line interpreter with the given application context.
     *
     * @return New {@code CommandLine} interpreter.
     */
    CommandLine cmd(ApplicationContext applicationCtx) {
        CommandLine.IFactory factory = new CommandFactory(applicationCtx);

        return new CommandLine(TopLevelCliCommand.class, factory)
                .setErr(new PrintWriter(err, true))
                .setOut(new PrintWriter(out, true));
    }

    private int execute(String cmdLine) {
        return cmd(ctx).execute(cmdLine.split(" "));
    }

    /**
     * Tests "bootstrap" command.
     */
    @DisplayName("bootstrap")
    @Nested
    class Bootstrap {
        @Test
        @DisplayName("bootstrap")
        void bootstrap() {
            var initIgniteCmd = mock(InitIgniteCommand.class);

            ctx.registerSingleton(InitIgniteCommand.class, initIgniteCmd);

            CommandLine cli = cmd(ctx);

            assertEquals(0, cli.execute("bootstrap"));
            verify(initIgniteCmd).init(any(), any(), any());
        }
    }

    /**
     * Tests "node" command.
     */
    @Nested
    @DisplayName("node")
    class Node {
        /** Manager of local Ignite nodes. */
        @Mock
        NodeManager nodeMgr;

        @BeforeEach
        void setUp() {
            ctx.registerSingleton(nodeMgr);
        }

        @Test
        @DisplayName("start node1 --config conf.json")
        void start() {
            var nodeName = "node1";

            var node =
                    new NodeManager.RunningNode(1, nodeName, Path.of("logfile"));

            when(nodeMgr.start(any(), any(), any(), any(), any(), any(), any(), any()))
                    .thenReturn(node);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            CommandLine cli = cmd(ctx);

            int exitCode = cli.execute(("node start " + nodeName + " --config conf.json").split(" "));

            assertThatExitCodeMeansSuccess(exitCode);

            verify(nodeMgr).start(
                    nodeName,
                    ignitePaths.nodesBaseWorkDir(),
                    ignitePaths.logDir,
                    ignitePaths.cliPidsDir(),
                    Path.of("conf.json"),
                    null,
                    ignitePaths.serverJavaUtilLoggingPros(),
                    cli.getOut());

            assertOutputEqual("\nNode is successfully started. To stop, type ignite node stop " + nodeName + "\n\n"
                            + "+-----------+---------+\n"
                            + "| Node name | node1   |\n"
                            + "+-----------+---------+\n"
                            + "| PID       | 1       |\n"
                            + "+-----------+---------+\n"
                            + "| Log File  | logfile |\n"
                            + "+-----------+---------+\n"
            );
            assertThatStderrIsEmpty();
        }

        @Test
        @DisplayName("start node1 --port 12345")
        void startCustomPort() {
            var nodeName = "node1";

            var node = new NodeManager.RunningNode(1, nodeName, Path.of("logfile"));

            when(nodeMgr.start(any(), any(), any(), any(), any(), any(), any(), any()))
                    .thenReturn(node);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            int exitCode = execute("node start " + nodeName + " --port 12345");

            assertThatExitCodeMeansSuccess(exitCode);

            ArgumentCaptor<String> configStrCaptor = ArgumentCaptor.forClass(String.class);
            verify(nodeMgr).start(any(), any(), any(), any(), any(), configStrCaptor.capture(), any(), any());

            assertEqualsIgnoreLineSeparators(
                    "network{port=12345}",
                    configStrCaptor.getValue()
            );
        }

        @Test
        @DisplayName("start node1 --config ignite-config.json --port 12345")
        void startCustomPortOverrideConfigFile() throws URISyntaxException {
            var nodeName = "node1";

            var node = new NodeManager.RunningNode(1, nodeName, Path.of("logfile"));

            when(nodeMgr.start(any(), any(), any(), any(), any(), any(), any(), any()))
                    .thenReturn(node);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            Path configPath = Path.of(IgniteCliInterfaceTest.class.getResource("/ignite-config.json").toURI());

            int exitCode = execute("node start " + nodeName + " --config "
                    + configPath.toAbsolutePath()
                    + " --port 12345");

            assertThatExitCodeMeansSuccess(exitCode);

            ArgumentCaptor<String> configStrCaptor = ArgumentCaptor.forClass(String.class);
            verify(nodeMgr).start(any(), any(), any(), any(), any(), configStrCaptor.capture(), any(), any());

            assertEqualsIgnoreLineSeparators(
                    "network{port=12345},rest{port=10300}",
                    configStrCaptor.getValue()
            );
        }

        @Test
        @DisplayName("start node1 --port 12345 --rest-port 12346")
        void startCustomPortAndRestPort() {
            var nodeName = "node1";

            var node = new NodeManager.RunningNode(1, nodeName, Path.of("logfile"));

            when(nodeMgr.start(any(), any(), any(), any(), any(), any(), any(), any()))
                    .thenReturn(node);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            int exitCode = execute("node start " + nodeName + " --port 12345 --rest-port 12346");

            assertThatExitCodeMeansSuccess(exitCode);

            ArgumentCaptor<String> configStrCaptor = ArgumentCaptor.forClass(String.class);
            verify(nodeMgr).start(any(), any(), any(), any(), any(), configStrCaptor.capture(), any(), any());

            assertEqualsIgnoreLineSeparators(
                    "network{port=12345},rest{port=12346}",
                    configStrCaptor.getValue()
            );
        }

        @Test
        @DisplayName("start node1 --port 12345 --rest-port 12346 --join localhost:12345")
        void startCustomPortRestPortAndSeedNodes() {
            var nodeName = "node1";

            var node = new NodeManager.RunningNode(1, nodeName, Path.of("logfile"));

            when(nodeMgr.start(any(), any(), any(), any(), any(), any(), any(), any()))
                    .thenReturn(node);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            int exitCode = execute("node start " + nodeName + " --port 12345 --rest-port 12346 --join localhost:12345");

            assertThatExitCodeMeansSuccess(exitCode);

            ArgumentCaptor<String> configStrCaptor = ArgumentCaptor.forClass(String.class);
            verify(nodeMgr).start(any(), any(), any(), any(), any(), configStrCaptor.capture(), any(), any());

            assertEqualsIgnoreLineSeparators(
                    "network{nodeFinder{netClusterNodes=[\"localhost:12345\"]},port=12345},rest{port=12346}",
                    configStrCaptor.getValue()
            );
        }

        @Test
        @DisplayName("stop node1")
        void stopRunning() {
            var nodeName = "node1";

            when(nodeMgr.stopWait(any(), any()))
                    .thenReturn(true);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            CommandLine cmd = cmd(ctx);
            int exitCode =
                    cmd.execute(("node stop " + nodeName).split(" "));

            assertThatExitCodeMeansSuccess(exitCode);
            verify(nodeMgr).stopWait(nodeName, ignitePaths.cliPidsDir());
            assertOutputEqual(
                    "Stopping locally running node with consistent ID "
                            + cmd.getColorScheme().parameterText(nodeName)
                            + cmd.getColorScheme().text("... @|bold,green Done!|@\n")
            );
            assertThatStderrIsEmpty();
        }

        @Test
        @DisplayName("stop unknown-node")
        void stopUnknown() {
            var nodeName = "unknown-node";

            when(nodeMgr.stopWait(any(), any()))
                    .thenReturn(false);

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            CommandLine cmd = cmd(ctx);
            int exitCode =
                    cmd.execute(("node stop " + nodeName).split(" "));

            assertThatExitCodeMeansSuccess(exitCode);
            verify(nodeMgr).stopWait(nodeName, ignitePaths.cliPidsDir());
            assertOutputEqual(
                    "Stopping locally running node with consistent ID "
                            + cmd.getColorScheme().parameterText(nodeName)
                            + cmd.getColorScheme().text("... @|bold,red Failed|@\n")
            );
            assertThatStderrIsEmpty();
        }

        @Test
        @DisplayName("list")
        void list() {
            when(nodeMgr.getRunningNodes(any(), any()))
                    .thenReturn(Arrays.asList(
                            new NodeManager.RunningNode(1, "new1", Path.of("logFile1")),
                            new NodeManager.RunningNode(2, "new2", Path.of("logFile2"))
                    ));

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            CommandLine cmd = cmd(ctx);
            int exitCode =
                    cmd.execute("node list".split(" "));

            assertThatExitCodeMeansSuccess(exitCode);
            verify(nodeMgr).getRunningNodes(ignitePaths.logDir, ignitePaths.cliPidsDir());
            assertOutputEqual(cmd.getColorScheme().text("Number of running nodes: @|bold 2|@\n\n")
                    + "+---------------+-----+----------+\n"
                    + cmd.getColorScheme().text("| @|bold Consistent ID|@ | @|bold PID|@ | @|bold Log File|@ |\n")
                    + "+---------------+-----+----------+\n"
                    + "| new1          | 1   | logFile1 |\n"
                    + "+---------------+-----+----------+\n"
                    + "| new2          | 2   | logFile2 |\n"
                    + "+---------------+-----+----------+\n"
            );
            assertThatStderrIsEmpty();
        }

        @Test
        @DisplayName("list")
        void listEmpty() {
            when(nodeMgr.getRunningNodes(any(), any()))
                    .thenReturn(Collections.emptyList());

            when(cliPathsCfgLdr.loadIgnitePathsOrThrowError())
                    .thenReturn(ignitePaths);

            CommandLine cmd = cmd(ctx);
            int exitCode =
                    cmd.execute("node list".split(" "));

            assertThatExitCodeMeansSuccess(exitCode);
            verify(nodeMgr).getRunningNodes(ignitePaths.logDir, ignitePaths.cliPidsDir());
            assertOutputEqual("Currently, there are no locally running nodes.\n\n"
                            + "Use the " + cmd.getColorScheme().commandText("ignite node start") + " command to start a new node.\n"
            );
            assertThatStderrIsEmpty();
        }

        @Test
        @DisplayName("classpath")
        void classpath() throws IOException {
            when(nodeMgr.classpathItems()).thenReturn(Arrays.asList("item1", "item2"));

            CommandLine cmd = cmd(ctx);
            int exitCode = cmd.execute("node classpath".split(" "));

            assertThatExitCodeMeansSuccess(exitCode);
            verify(nodeMgr).classpathItems();
            assertOutputEqual(
                    cmd.getColorScheme().text(
                            "@|bold Current Ignite node classpath:|@\n    item1\n    item2\n").toString()
            );
            assertThatStderrIsEmpty();
        }

        /**
         * Tests "config" command.
         */
        @Nested
        @DisplayName("config")
        class Config {
            @Test
            @DisplayName("show --node-url http://localhost:10300")
            void show() {
                clientAndServer
                        .when(request()
                                .withMethod("GET")
                                .withPath("/management/v1/configuration/node")
                        )
                        .respond(response("{\"autoAdjust\":{\"enabled\":true}}"));

                int exitCode = execute("node config show --node-url " + mockUrl);

                assertThatExitCodeMeansSuccess(exitCode);

                assertOutputEqual("{\n"
                                + "  \"autoAdjust\" : {\n"
                                + "    \"enabled\" : true\n"
                                + "  }\n"
                                + "}\n"
                );
                assertThatStderrIsEmpty();
            }

            @Test
            @DisplayName("show --node-url http://localhost:10300 --selector local.baseline")
            void showSubtree() {
                clientAndServer
                        .when(request()
                                .withMethod("GET")
                                .withPath("/management/v1/configuration/node/local.baseline")
                        )
                        .respond(response("{\"autoAdjust\":{\"enabled\":true}}"));

                int exitCode = execute("node config show --node-url " + mockUrl + " --selector local.baseline");

                assertThatExitCodeMeansSuccess(exitCode);

                assertOutputEqual("{\n"
                                + "  \"autoAdjust\" : {\n"
                                + "    \"enabled\" : true\n"
                                + "  }\n"
                                + "}\n"
                );
                assertThatStderrIsEmpty();
            }

            @Test
            @DisplayName("update --node-url http://localhost:10300 local.baseline.autoAdjust.enabled=true")
            void updateHocon() {
                clientAndServer
                        .when(request()
                                .withMethod("PATCH")
                                .withPath("/management/v1/configuration/node")
                                .withBody("local.baseline.autoAdjust.enabled=true")
                        )
                        .respond(response(null));

                int exitCode = execute("node config update --node-url " + mockUrl + " local.baseline.autoAdjust.enabled=true");

                assertThatExitCodeMeansSuccess(exitCode);

                assertOutputEqual("Node configuration was updated successfully.");
                assertThatStderrIsEmpty();
            }
        }
    }

    /**
     * Tests "cluster" command.
     */
    @Nested
    @DisplayName("cluster")
    class Cluster {
        @Test
        @DisplayName("init --cluster-endpoint-url http://localhost:10300 --meta-storage-node node1ConsistentId --meta-storage-node node2ConsistentId "
                + "--cmg-node node2ConsistentId --cmg-node node3ConsistentId --cluster-name cluster")
        void initSuccess() {
            var expectedSentContent = "{\"metaStorageNodes\":[\"node1ConsistentId\",\"node2ConsistentId\"],"
                    + "\"cmgNodes\":[\"node2ConsistentId\",\"node3ConsistentId\"],"
                    + "\"clusterName\":\"cluster\"}";

            clientAndServer
                    .when(request()
                            .withMethod("POST")
                            .withPath("/management/v1/cluster/init")
                            .withBody(json(expectedSentContent, ONLY_MATCHING_FIELDS))
                            .withContentType(MediaType.APPLICATION_JSON_UTF_8)
                    )
                    .respond(response(null));


            int exitCode = cmd(ctx).execute(
                    "cluster", "init",
                    "--cluster-endpoint-url", mockUrl,
                    "--meta-storage-node", "node1ConsistentId",
                    "--meta-storage-node", "node2ConsistentId",
                    "--cmg-node", "node2ConsistentId",
                    "--cmg-node", "node3ConsistentId",
                    "--cluster-name", "cluster"
            );

            assertThatExitCodeMeansSuccess(exitCode);

            assertOutputEqual("Cluster was initialized successfully.");
            assertThatStderrIsEmpty();
        }

        @Test
        void initError() {
            clientAndServer
                    .when(request()
                            .withMethod("POST")
                            .withPath("/management/v1/cluster/init")
                    )
                    .respond(response()
                            .withStatusCode(INTERNAL_SERVER_ERROR_500.code())
                            .withBody("Oops")
                    );

            int exitCode = cmd(ctx).execute(
                    "cluster", "init",
                    "--cluster-endpoint-url", mockUrl,
                    "--meta-storage-node", "node1ConsistentId",
                    "--meta-storage-node", "node2ConsistentId",
                    "--cmg-node", "node2ConsistentId",
                    "--cmg-node", "node3ConsistentId",
                    "--cluster-name", "cluster"
            );

            assertThatExitCodeIs(1, exitCode);

            assertThatStdoutIsEmpty();
            assertErrOutputEqual("An error occurred [errorCode=500, response=Oops]");
        }

        @Test
        @DisplayName("init --cluster-endpoint-url http://localhost:10300 --cmg-node node2ConsistentId --cmg-node node3ConsistentId")
        void metastorageNodesAreMandatoryForInit() {
            int exitCode = cmd(ctx).execute(
                    "cluster", "init",
                    "--cluster-endpoint-url", mockUrl,
                    "--cmg-node", "node2ConsistentId",
                    "--cmg-node", "node3ConsistentId",
                    "--cluster-name", "cluster"
            );

            assertThatExitCodeIs(2, exitCode);

            assertThatStdoutIsEmpty();
            assertThat(err.toString(UTF_8), startsWith("Missing required option: '--meta-storage-node=<metaStorageNodes>'"));
        }

        @Test
        @DisplayName("init --cluster-endpoint-url http://localhost:10300 --meta-storage-node node2ConsistentId --meta-storage-node node3ConsistentId")
        void cmgNodesAreNotMandatoryForInit() {
            clientAndServer
                    .when(request()
                            .withMethod("POST")
                            .withPath("/management/v1/cluster/init")
                    )
                    .respond(response().withStatusCode(OK_200.code()));

            int exitCode = cmd(ctx).execute(
                    "cluster", "init",
                    "--cluster-endpoint-url", mockUrl,
                    "--meta-storage-node", "node1ConsistentId",
                    "--meta-storage-node", "node2ConsistentId",
                    "--cluster-name", "cluster"
            );

            assertThatExitCodeMeansSuccess(exitCode);

            assertOutputEqual("Cluster was initialized successfully.");
            assertThatStderrIsEmpty();
        }

        @Test
        @DisplayName("init --cluster-endpoint-url http://localhost:10300 --meta-storage-node node1ConsistentId --cmg-node node2ConsistentId")
        void clusterNameIsMandatoryForInit() {
            int exitCode = cmd(ctx).execute(
                    "cluster", "init",
                    "--cluster-endpoint-url", mockUrl,
                    "--meta-storage-node", "node1ConsistentId",
                    "--cmg-node", "node2ConsistentId"
            );

            assertThatExitCodeIs(2, exitCode);

            assertThatStdoutIsEmpty();
            assertThat(err.toString(UTF_8), startsWith("Missing required option: '--cluster-name=<clusterName>'"));
        }

        @Nested
        @DisplayName("config")
        class Config {
            @Test
            @DisplayName("show --cluster-endpoint-url http://localhost:10300")
            void show() {
                clientAndServer
                        .when(request()
                                .withMethod("GET")
                                .withPath("/management/v1/configuration/cluster")
                        )
                        .respond(response("{\"autoAdjust\":{\"enabled\":true}}"));

                int exitCode = execute("cluster config show --cluster-endpoint-url " + mockUrl);

                assertThatExitCodeMeansSuccess(exitCode);

                assertOutputEqual("{\n"
                        + "  \"autoAdjust\" : {\n"
                        + "    \"enabled\" : true\n"
                        + "  }\n"
                        + "}\n");
                assertThatStderrIsEmpty();
            }

            @Test
            @DisplayName("show --cluster-endpoint-url http://localhost:10300 --selector local.baseline")
            void showSubtree() {
                clientAndServer
                        .when(request()
                                .withMethod("GET")
                                .withPath("/management/v1/configuration/cluster/local.baseline")
                        )
                        .respond(response("{\"autoAdjust\":{\"enabled\":true}}"));

                int exitCode = execute("cluster config show --cluster-endpoint-url " + mockUrl + " --selector local.baseline");

                assertThatExitCodeMeansSuccess(exitCode);

                assertOutputEqual("{\n"
                        + "  \"autoAdjust\" : {\n"
                        + "    \"enabled\" : true\n"
                        + "  }\n"
                        + "}\n");
                assertThatStderrIsEmpty();
            }

            @Test
            @DisplayName("update --cluster-endpoint-url http://localhost:10300 local.baseline.autoAdjust.enabled=true")
            void updateHocon() {
                clientAndServer
                        .when(request()
                                .withMethod("PATCH")
                                .withPath("/management/v1/configuration/cluster")
                                .withBody("local.baseline.autoAdjust.enabled=true")
                        )
                        .respond(response(null));

                int exitCode = execute("cluster config update --cluster-endpoint-url "
                        + mockUrl + " local.baseline.autoAdjust.enabled=true");

                assertThatExitCodeMeansSuccess(exitCode);

                assertOutputEqual("Cluster configuration was updated successfully.");
                assertThatStderrIsEmpty();
            }
        }
    }

    private void assertThatStdoutIsEmpty() {
        assertThat(out.toString(UTF_8), is(""));
    }

    private void assertThatStderrIsEmpty() {
        assertThat(err.toString(UTF_8), is(""));
    }

    private void assertThatExitCodeMeansSuccess(int exitCode) {
        assertThatExitCodeIs(0, exitCode);
    }

    private void assertThatExitCodeIs(int expectedCode, int exitCode) {
        assertEquals(expectedCode, exitCode, outputStreams());
    }

    private String outputStreams() {
        return "stdout:\n" + out.toString(UTF_8) + "\n" + "stderr:\n" + err.toString(UTF_8);
    }

    /**
     * <em>Assert</em> that {@code expected} and {@code actual} are equals ignoring differences in line separators.
     *
     * <p>If both are {@code null}, they are considered equal.
     *
     * @param exp Expected result.
     * @param actual Actual result.
     * @see Object#equals(Object)
     */
    private static void assertEqualsIgnoreLineSeparators(String exp, String actual) {
        assertEquals(
                exp.lines().collect(toList()),
                actual.lines().collect(toList())
        );
    }

    private void assertOutputEqual(String exp) {
        assertEqualsIgnoreLineSeparators(exp, out.toString(UTF_8));
    }

    private void assertErrOutputEqual(String exp) {
        assertEqualsIgnoreLineSeparators(exp, err.toString(UTF_8));
    }
}