From 950cfeff6f97d94b4ab5166214ea6cb5b38b77f0 Mon Sep 17 00:00:00 2001
From: Jesse Duffield <jessedduffield@gmail.com>
Date: Wed, 19 Sep 2018 18:03:44 +1000
Subject: [PATCH] add specs for menu utils

---
 pkg/utils/utils.go      |  11 ++-
 pkg/utils/utils_test.go | 181 ++++++++++++++++++++++++++++++++++++----
 2 files changed, 174 insertions(+), 18 deletions(-)

diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go
index 3efa67a91..aef653c50 100644
--- a/pkg/utils/utils.go
+++ b/pkg/utils/utils.go
@@ -158,8 +158,11 @@ func renderDisplayableList(items []Displayable) (string, error) {
 }
 
 func getPadWidths(stringArrays [][]string) []int {
-	padWidths := make([]int, len(stringArrays[0]))
-	for i, _ := range padWidths {
+	if len(stringArrays[0]) <= 1 {
+		return []int{}
+	}
+	padWidths := make([]int, len(stringArrays[0])-1)
+	for i := range padWidths {
 		for _, strings := range stringArrays {
 			if len(strings[i]) > padWidths[i] {
 				padWidths[i] = len(strings[i])
@@ -172,9 +175,13 @@ func getPadWidths(stringArrays [][]string) []int {
 func getPaddedDisplayStrings(stringArrays [][]string, padWidths []int) []string {
 	paddedDisplayStrings := make([]string, len(stringArrays))
 	for i, stringArray := range stringArrays {
+		if len(stringArray) == 0 {
+			continue
+		}
 		for j, padWidth := range padWidths {
 			paddedDisplayStrings[i] += WithPadding(stringArray[j], padWidth) + " "
 		}
+		paddedDisplayStrings[i] += stringArray[len(padWidths)]
 	}
 	return paddedDisplayStrings
 }
diff --git a/pkg/utils/utils_test.go b/pkg/utils/utils_test.go
index a088ed849..045bf9c64 100644
--- a/pkg/utils/utils_test.go
+++ b/pkg/utils/utils_test.go
@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -168,32 +169,180 @@ func TestResolvePlaceholderString(t *testing.T) {
 	}
 }
 
-func TestMin(t *testing.T) {
+func TestDisplayArraysAligned(t *testing.T) {
 	type scenario struct {
-		a        int
-		b        int
-		expected int
+		input    [][]string
+		expected bool
 	}
 
 	scenarios := []scenario{
 		{
-			2,
-			4,
-			2,
+			[][]string{{"", ""}, {"", ""}},
+			true,
 		},
 		{
-			2,
-			1,
-			1,
-		},
-		{
-			1,
-			1,
-			1,
+			[][]string{{""}, {"", ""}},
+			false,
 		},
 	}
 
 	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, Min(s.a, s.b))
+		assert.EqualValues(t, s.expected, displayArraysAligned(s.input))
+	}
+}
+
+type myDisplayable struct {
+	strings []string
+}
+
+type myStruct struct{}
+
+func (d *myDisplayable) GetDisplayStrings() []string {
+	return d.strings
+}
+
+func TestGetDisplayStringArrays(t *testing.T) {
+	type scenario struct {
+		input    []Displayable
+		expected [][]string
+	}
+
+	scenarios := []scenario{
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a", "b"}}),
+				Displayable(&myDisplayable{[]string{"a", "b"}}),
+			},
+			[][]string{{"a", "b"}, {"c", "d"}},
+		},
+	}
+
+	for _, s := range scenarios {
+		assert.EqualValues(t, s.expected, getDisplayStringArrays(s.input))
+	}
+}
+
+func TestRenderDisplayableList(t *testing.T) {
+	type scenario struct {
+		input          []Displayable
+		expectedString string
+		expectedError  error
+	}
+
+	scenarios := []scenario{
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{}}),
+				Displayable(&myDisplayable{[]string{}}),
+			},
+			"\n",
+			nil,
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"aa", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			"aa b\nc  d",
+			nil,
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a"}}),
+				Displayable(&myDisplayable{[]string{"b", "c"}}),
+			},
+			"",
+			errors.New("Each item must return the same number of strings to display"),
+		},
+	}
+
+	for _, s := range scenarios {
+		str, err := renderDisplayableList(s.input)
+		assert.EqualValues(t, s.expectedString, str)
+		assert.EqualValues(t, s.expectedError, err)
+	}
+}
+
+func TestRenderList(t *testing.T) {
+	type scenario struct {
+		input          interface{}
+		expectedString string
+		expectedError  error
+	}
+
+	scenarios := []scenario{
+		{
+			[]*myDisplayable{
+				{[]string{"aa", "b"}},
+				{[]string{"c", "d"}},
+			},
+			"aa b\nc  d",
+			nil,
+		},
+		{
+			[]*myStruct{
+				{},
+				{},
+			},
+			"",
+			errors.New("item does not implement the Displayable interface"),
+		},
+		{
+			&myStruct{},
+			"",
+			errors.New("RenderList given a non-slice type"),
+		},
+	}
+
+	for _, s := range scenarios {
+		str, err := RenderList(s.input)
+		assert.EqualValues(t, s.expectedString, str)
+		assert.EqualValues(t, s.expectedError, err)
+	}
+}
+
+func TestGetPaddedDisplayStrings(t *testing.T) {
+	type scenario struct {
+		stringArrays [][]string
+		padWidths    []int
+		expected     []string
+	}
+
+	scenarios := []scenario{
+		{
+			[][]string{{"a", "b"}, {"c", "d"}},
+			[]int{1},
+			[]string{"a b", "c d"},
+		},
+	}
+
+	for _, s := range scenarios {
+		assert.EqualValues(t, s.expected, getPaddedDisplayStrings(s.stringArrays, s.padWidths))
+	}
+}
+
+func TestGetPadWidths(t *testing.T) {
+	type scenario struct {
+		stringArrays [][]string
+		expected     []int
+	}
+
+	scenarios := []scenario{
+		{
+			[][]string{{""}, {""}},
+			[]int{},
+		},
+		{
+			[][]string{{"a"}, {""}},
+			[]int{},
+		},
+		{
+			[][]string{{"aa", "b", "ccc"}, {"c", "d", "e"}},
+			[]int{2, 1},
+		},
+	}
+
+	for _, s := range scenarios {
+		assert.EqualValues(t, s.expected, getPadWidths(s.stringArrays))
 	}
 }