Merge pull request #31 from fsantiag/log_command_output

Log command output when debug is enabled

Author: fsantiag

src/main/java/org/sonar/plugins/clojure/sensors/CommandRunner.java

@@ -3,22 +3,49 @@
 import org.sonar.api.batch.ScannerSide;
 import org.sonar.api.utils.command.Command;
 import org.sonar.api.utils.command.CommandExecutor;
+import org.sonar.api.utils.log.Logger;
+import org.sonar.api.utils.log.Loggers;
+
+import java.util.Arrays;
 
 @ScannerSide
 public class CommandRunner {
 
+    private static final Logger STATIC_LOGGER = Loggers.get(CommandRunner.class);
     private static final long TIMEOUT = 300_000;
+    private static final String DELIMITER = "\n";
 
-    public CommandStreamConsumer run(String command, String... arguments) {
-        CommandStreamConsumer stdOut = new CommandStreamConsumer();
-        CommandStreamConsumer stdErr = new CommandStreamConsumer();
+    private final Logger logger;
+    private final CommandExecutor commandExecutor;
+
+    public CommandRunner(Logger log, CommandExecutor commandExecutor) {
+        this.logger = log;
+        this.commandExecutor = commandExecutor;
+    }
+
+    public CommandRunner() {
+        this(STATIC_LOGGER, CommandExecutor.create());
+    }
+
+    CommandStreamConsumer run(String command, CommandStreamConsumer stdout,
+                                     CommandStreamConsumer stderr, String... arguments) {
         Command cmd = Command.create(command);
-        for (String arg: arguments) {
-            if (arg != null) {
-                cmd.addArgument(arg);
-            }
+        Arrays.stream(arguments).forEach(cmd::addArgument);
+
+        commandExecutor.execute(cmd, stdout, stderr, TIMEOUT);
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("Stdout: " + String.join(DELIMITER, stdout.getData()));
+        }
+
+        if (!stderr.getData().isEmpty()) {
+            logger.warn("Stderr: " + String.join(DELIMITER, stderr.getData()));
         }
-        CommandExecutor.create().execute(cmd, stdOut, stdErr, TIMEOUT);
-        return stdOut;
+
+        return stdout;
+    }
+
+    public CommandStreamConsumer run(String command, String... arguments) {
+        return run(command, new CommandStreamConsumer(), new CommandStreamConsumer(), arguments);
     }
 }

src/main/java/org/sonar/plugins/clojure/sensors/CommandStreamConsumer.java

@@ -2,11 +2,11 @@
 
 import org.sonar.api.utils.command.StreamConsumer;
 
-import java.util.LinkedList;
+import java.util.ArrayList;
 import java.util.List;
 
 public class CommandStreamConsumer implements StreamConsumer {
-    private List<String> data = new LinkedList<>();
+    private List<String> data = new ArrayList<>();
 
     @Override
     public void consumeLine(String line) {

src/main/java/org/sonar/plugins/clojure/sensors/eastwood/EastwoodSensor.java

@@ -42,7 +42,6 @@ public void describe(SensorDescriptor descriptor) {
     @Override
     public void execute(SensorContext context) {
         if (!checkIfPluginIsDisabled(context, ClojureProperties.EASTWOOD_DISABLED)) {
-            LOG.info("Clojure project detected");
             LOG.info("Running Eastwood");
             String options = context.config().get(ClojureProperties.EASTWOOD_OPTIONS).orElse(null);
             CommandStreamConsumer stdOut = this.commandRunner.run(LEIN_COMMAND, EASTWOOD_COMMAND, options);

src/test/java/org/sonar/plugins/clojure/sensors/CommandRunnerTest.java

@@ -1,18 +1,86 @@
 package org.sonar.plugins.clojure.sensors;
 
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.sonar.api.utils.command.Command;
+import org.sonar.api.utils.command.CommandExecutor;
+import org.sonar.api.utils.log.Logger;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.anyLong;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
+@RunWith(MockitoJUnitRunner.class)
 public class CommandRunnerTest {
 
+    @Mock
+    private Logger logger;
+
+    @Mock
+    private CommandExecutor commandExecutor;
+
+    private CommandRunner commandRunner;
+
+    @Before
+    public void setUp() {
+        commandRunner = new CommandRunner(logger, commandExecutor);
+    }
+
+    @Test
+    public void shouldTakeMultipleArgumentsForCommand() {
+        doReturn(0).when(commandExecutor).execute(
+                any(),
+                any(),
+                any(),
+                anyLong());
+
+        commandRunner.run("echo", "argument1", "argument2");
+
+        ArgumentCaptor<Command> commandCaptor = ArgumentCaptor.forClass(Command.class);
+        verify(commandExecutor, times(1))
+                .execute(
+                        commandCaptor.capture(),
+                        any(CommandStreamConsumer.class),
+                        any(CommandStreamConsumer.class),
+                        anyLong());
+
+        Command cmd = commandCaptor.getValue();
+        assertThat(cmd.getArguments().size(), is(2));
+        assertThat(cmd.getArguments().get(0), is("argument1"));
+        assertThat(cmd.getArguments().get(1), is("argument2"));
+    }
+
     @Test
-    public void testMultipleArgumentsCommand() {
-        //TODO This test fails on windows
-        CommandStreamConsumer stdOut = new CommandRunner().run("echo", "argument1", "argument2");
-        assertThat(stdOut.getData().get(0), is("argument1 argument2"));
-        assertThat(stdOut.getData().size(), is(1));
+    public void shouldLogCommandOutputWhenDebugIsEnabled() {
+        when(logger.isDebugEnabled()).thenReturn(true);
+        CommandStreamConsumer stdout = new CommandStreamConsumer();
+        String commandOutput = "command output";
+        stdout.consumeLine(commandOutput);
+
+        commandRunner.run("echo", stdout, new CommandStreamConsumer(), "argument1", "argument2");
+
+        verify(logger).debug("Stdout: command output");
+    }
+
+    @Test
+    public void shouldLogWarningForErrorsInStderr() {
+        when(logger.isDebugEnabled()).thenReturn(true);
+        CommandStreamConsumer stderr = new CommandStreamConsumer();
+        String error = "some error message";
+        stderr.consumeLine(error);
+
+        commandRunner.run("echo", new CommandStreamConsumer(), stderr, "argument1", "argument2");
+
+        verify(logger).warn("Stderr: some error message");
     }
 
 }