Print aggregate output as commands complete (#5)

jclem · web-flow · commit bb5fe92d9782 · 2022-09-21T12:56:47.000-04:00
Closes #3
diff --git a/cmd/concurrently.go b/cmd/concurrently.go
@@ -49,12 +49,6 @@ var cCommand = cobra.Command{
 			dbg.Prettyln(commands)
 		}
 
-		if commands != nil && aggregateOutput {
-			for _, cmd := range commands {
-				fmt.Print(cmd.ReadOut())
-			}
-		}
-
 		return err
 	},
 }
diff --git a/integration/helpers.go b/integration/helpers.go
@@ -0,0 +1,75 @@
+package test
+
+import (
+	"fmt"
+	"os/exec"
+	"sort"
+	"strings"
+	"testing"
+)
+
+type runner struct {
+	cmd   string
+	flags []string
+	env   []string
+}
+
+func newRunner(cmd string) runner {
+	return runner{cmd: cmd}
+}
+
+func (r runner) withFlags(flags ...string) runner {
+	r.flags = append(r.flags, flags...)
+	return r
+}
+
+func (r runner) withEnv(env ...string) runner {
+	r.env = append(r.env, env...)
+	return r
+}
+
+func (r runner) run(t *testing.T) (string, error) {
+	t.Helper()
+
+	out := new(strings.Builder)
+	fullCmd := append([]string{r.cmd}, r.flags...)
+	cmd := exec.Command("bin/konk", fullCmd...)
+	cmd.Stdout = out
+	cmd.Stderr = out
+	cmd.Env = append(cmd.Env, r.env...)
+
+	err := cmd.Run()
+	return out.String(), err
+}
+
+func sortOut(t *testing.T, out string) string {
+	t.Helper()
+
+	lines := strings.Split(out, "\n")
+	mapByPrefix := make(map[string][]string)
+
+	for _, line := range lines {
+		prefix := strings.SplitN(line, "]", 2)[0]
+
+		if prefix == "" {
+			continue
+		}
+
+		mapByPrefix[prefix] = append(mapByPrefix[prefix], line)
+	}
+
+	keys := make([]string, 0, len(mapByPrefix))
+	for k := range mapByPrefix {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	var sortedLines []string
+
+	for _, k := range keys {
+		sortedLines = append(sortedLines, mapByPrefix[k]...)
+	}
+
+	// Our output always ends in a newline.
+	return fmt.Sprintf("%s\n", strings.Join(sortedLines, "\n"))
+}
diff --git a/integration/proc_test.go b/integration/proc_test.go
@@ -1,9 +1,6 @@
 package test
 
 import (
-	"os/exec"
-	"sort"
-	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -12,96 +9,58 @@ import (
 func TestProc(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "proc",
-		"-w", "fixtures/proc")
-	cmd.Stdout = out
-	cmd.Stderr = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newProcRunner().run(t)
+	assert.NoError(t, err)
 
-	lines := strings.Split(out.String(), "\n")
-	sort.Strings(lines)
-	sortedOut := strings.Join(lines, "\n")
-
-	assert.Equal(t, `
-[echo-a] a
+	assert.Equal(t, `[echo-a] a
 [echo-b] b
-[echo-c] `, sortedOut, "output did not match expected output")
+[echo-c] 
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestProcEnvSpaces(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "proc",
+	out, err := newProcRunner().withFlags(
 		"-e", ".env-spaces",
-		"-p", "Procfile-spaces",
-		"-w", "fixtures/proc")
-	cmd.Stdout = out
-	cmd.Stderr = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
-
-	lines := strings.Split(out.String(), "\n")
-	sort.Strings(lines)
-	sortedOut := strings.Join(lines, "\n")
+		"-p", "Procfile-spaces").
+		run(t)
+	assert.NoError(t, err)
 
-	assert.Equal(t, `
-[echo-abc] a b c
-[echo-def] d "e" f`, sortedOut, "output did not match expected output")
+	assert.Equal(t, `[echo-abc] a b c
+[echo-def] d "e" f
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestProcWithExternalEnvNoEnv(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "proc", "-E",
-		"-w", "fixtures/proc")
-	cmd.Env = append(cmd.Env, "A=new-a")
-	cmd.Env = append(cmd.Env, "B=new-b")
-	cmd.Env = append(cmd.Env, "C=new-c")
-	cmd.Stdout = out
-	cmd.Stderr = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
-
-	lines := strings.Split(out.String(), "\n")
-	sort.Strings(lines)
-	sortedOut := strings.Join(lines, "\n")
+	out, err := newProcRunner().
+		withFlags("-E").
+		withEnv("A=new-a", "B=new-b", "C=new-c").
+		run(t)
+	assert.NoError(t, err)
 
-	assert.Equal(t, `
-[echo-a] new-a
+	assert.Equal(t, `[echo-a] new-a
 [echo-b] new-b
-[echo-c] new-c`, sortedOut, "output did not match expected output")
+[echo-c] new-c
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestProcWithExternalEnvAndEnv(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "proc",
-		"-w", "fixtures/proc")
-	cmd.Env = append(cmd.Env, "C=c")
-	cmd.Stdout = out
-	cmd.Stderr = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newProcRunner().
+		withEnv("C=c").
+		run(t)
+	assert.NoError(t, err)
 
-	lines := strings.Split(out.String(), "\n")
-	sort.Strings(lines)
-	sortedOut := strings.Join(lines, "\n")
-
-	assert.Equal(t, `
-[echo-a] a
+	assert.Equal(t, `[echo-a] a
 [echo-b] b
-[echo-c] c`, sortedOut, "output did not match expected output")
+[echo-c] c
+`, sortOut(t, out), "output did not match expected output")
+}
+
+func newProcRunner() runner {
+	return newRunner("proc").withFlags("-w", "fixtures/proc")
 }
diff --git a/integration/run_c_test.go b/integration/run_c_test.go
@@ -2,7 +2,6 @@ package test
 
 import (
 	"os/exec"
-	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -11,88 +10,74 @@ import (
 func TestRunConcurrently(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command("bin/konk", "run", "concurrently", "-g",
-		"echo a", "echo b", "echo c")
-	cmd.Stdout = out
-	cmd.Stderr = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newGroupedConcurrentRunner().
+		withFlags("echo a", "echo b", "echo c").
+		run(t)
+	assert.NoError(t, err)
+
 	assert.Equal(t, `[0] a
 [1] b
 [2] c
-`, out.String(), "output did not match expected output")
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestRunConcurrentlyWithLabels(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "run", "concurrently", "-g",
-		"-l", "a", "-l", "b", "-l", "c",
-		"echo a", "echo b", "echo c")
-	cmd.Stdout = out
-	cmd.Stderr = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newGroupedConcurrentRunner().
+		withFlags(
+			"-l", "a", "-l", "b", "-l", "c",
+			"echo a", "echo b", "echo c").
+		run(t)
+	assert.NoError(t, err)
+
 	assert.Equal(t, `[a] a
 [b] b
 [c] c
-`, out.String(), "output did not match expected output")
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestRunConcurrentlyWithLabelsMismatch(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "run", "concurrently", "-g",
-		"-l", "a", "-l", "b",
-		"echo a", "echo b", "echo c")
-	cmd.Stdout = out
-	cmd.Stderr = out
+	out, err := newGroupedConcurrentRunner().
+		withFlags(
+			"-l", "a", "-l", "b",
+			"echo a", "echo b", "echo c").
+		run(t)
 
-	err := cmd.Run()
 	if assert.Error(t, err) {
 		assert.IsType(t, &exec.ExitError{}, err)
 	}
 
-	assert.Equal(t, "Error: number of names must match number of commands\n", out.String(), "error output did not match expectation")
+	assert.Equal(t, "Error: number of names must match number of commands\n", out, "error output did not match expectation")
 }
 
 func TestRunConcurrentlyWithCommandLabels(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "run", "concurrently", "-gL",
-		"echo a", "echo b", "echo c")
-	cmd.Stdout = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newGroupedConcurrentRunner().
+		withFlags("-L", "echo a", "echo b", "echo c").
+		run(t)
+	assert.NoError(t, err)
+
 	assert.Equal(t, `[echo a] a
 [echo b] b
 [echo c] c
-`, out.String(), "output did not match expected output")
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestRunConcurrentlyWithNpm(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "run", "concurrently", "-g",
-		"-w", "fixtures/npm",
-		"--npm", "echo-a",
-		"--npm", "echo-b")
-	cmd.Stdout = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newGroupedConcurrentRunner().
+		withFlags(
+			"-w", "fixtures/npm",
+			"--npm", "echo-a",
+			"--npm", "echo-b").
+		run(t)
+	assert.NoError(t, err)
+
 	assert.Equal(t, `[0] 
 [0] > echo-a
 [0] > echo a
@@ -103,21 +88,19 @@ func TestRunConcurrentlyWithNpm(t *testing.T) {
 [1] > echo b
 [1] 
 [1] b
-`, out.String(), "output did not match expected output")
+`, sortOut(t, out), "output did not match expected output")
 }
 
 func TestRunConcurrentlyWithNpmGlob(t *testing.T) {
 	t.Parallel()
 
-	out := new(strings.Builder)
-	cmd := exec.Command(
-		"bin/konk", "run", "concurrently", "-g",
-		"-w", "fixtures/npm",
-		"--npm", "echo-*")
-	cmd.Stdout = out
-	if err := cmd.Run(); err != nil {
-		t.Error(err)
-	}
+	out, err := newGroupedConcurrentRunner().
+		withFlags(
+			"-w", "fixtures/npm",
+			"--npm", "echo-*").
+		run(t)
+	assert.NoError(t, err)
+
 	assert.Equal(t, `[0] 
 [0] > echo-a
 [0] > echo a
@@ -128,5 +111,9 @@ func TestRunConcurrentlyWithNpmGlob(t *testing.T) {
 [1] > echo b
 [1] 
 [1] b
-`, out.String(), "output did not match expected output")
+`, sortOut(t, out), "output did not match expected output")
+}
+
+func newGroupedConcurrentRunner() runner {
+	return newRunner("run").withFlags("concurrently", "-g")
 }
diff --git a/integration/run_s_test.go b/integration/run_s_test.go
diff --git a/konk/command.go b/konk/command.go

Original file line number	Diff line number	Diff line change
`@@ -49,12 +49,6 @@ var cCommand = cobra.Command{`
`49`	`49`	`dbg.Prettyln(commands)`
`50`	`50`	`}`
`51`	`51`
`52`		`- if commands != nil && aggregateOutput {`
`53`		`- for _, cmd := range commands {`
`54`		`- fmt.Print(cmd.ReadOut())`
`55`		`- }`
`56`		`- }`
`57`		`-`
`58`	`52`	`return err`
`59`	`53`	`},`
`60`	`54`	`}`