refactor

1 files changed, 0 insertions, 366 deletions

diff --git a/pkg/utils/utils_test.go b/pkg/utils/utils_test.go
index 0e11a028c..c63028d41 100644
--- a/pkg/utils/utils_test.go
+++ b/pkg/utils/utils_test.go
@@ -6,244 +6,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-// TestSplitLines is a function.
-func TestSplitLines(t *testing.T) {
-	type scenario struct {
-		multilineString string
-		expected        []string
-	}
-
-	scenarios := []scenario{
-		{
-			"",
-			[]string{},
-		},
-		{
-			"\n",
-			[]string{},
-		},
-		{
-			"hello world !\nhello universe !\n",
-			[]string{
-				"hello world !",
-				"hello universe !",
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, SplitLines(s.multilineString))
-	}
-}
-
-// TestWithPadding is a function.
-func TestWithPadding(t *testing.T) {
-	type scenario struct {
-		str      string
-		padding  int
-		expected string
-	}
-
-	scenarios := []scenario{
-		{
-			"hello world !",
-			1,
-			"hello world !",
-		},
-		{
-			"hello world !",
-			14,
-			"hello world ! ",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, WithPadding(s.str, s.padding))
-	}
-}
-
-// TestTrimTrailingNewline is a function.
-func TestTrimTrailingNewline(t *testing.T) {
-	type scenario struct {
-		str      string
-		expected string
-	}
-
-	scenarios := []scenario{
-		{
-			"hello world !\n",
-			"hello world !",
-		},
-		{
-			"hello world !",
-			"hello world !",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, TrimTrailingNewline(s.str))
-	}
-}
-
-// TestNormalizeLinefeeds is a function.
-func TestNormalizeLinefeeds(t *testing.T) {
-	type scenario struct {
-		byteArray []byte
-		expected  []byte
-	}
-	var scenarios = []scenario{
-		{
-			// \r\n
-			[]byte{97, 115, 100, 102, 13, 10},
-			[]byte{97, 115, 100, 102, 10},
-		},
-		{
-			// bash\r\nblah
-			[]byte{97, 115, 100, 102, 13, 10, 97, 115, 100, 102},
-			[]byte{97, 115, 100, 102, 10, 97, 115, 100, 102},
-		},
-		{
-			// \r
-			[]byte{97, 115, 100, 102, 13},
-			[]byte{97, 115, 100, 102},
-		},
-		{
-			// \n
-			[]byte{97, 115, 100, 102, 10},
-			[]byte{97, 115, 100, 102, 10},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, string(s.expected), NormalizeLinefeeds(string(s.byteArray)))
-	}
-}
-
-// TestResolvePlaceholderString is a function.
-func TestResolvePlaceholderString(t *testing.T) {
-	type scenario struct {
-		templateString string
-		arguments      map[string]string
-		expected       string
-	}
-
-	scenarios := []scenario{
-		{
-			"",
-			map[string]string{},
-			"",
-		},
-		{
-			"hello",
-			map[string]string{},
-			"hello",
-		},
-		{
-			"hello {{arg}}",
-			map[string]string{},
-			"hello {{arg}}",
-		},
-		{
-			"hello {{arg}}",
-			map[string]string{"arg": "there"},
-			"hello there",
-		},
-		{
-			"hello",
-			map[string]string{"arg": "there"},
-			"hello",
-		},
-		{
-			"{{nothing}}",
-			map[string]string{"nothing": ""},
-			"",
-		},
-		{
-			"{{}} {{ this }} { should not throw}} an {{{{}}}} error",
-			map[string]string{
-				"blah": "blah",
-				"this": "won't match",
-			},
-			"{{}} {{ this }} { should not throw}} an {{{{}}}} error",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, ResolvePlaceholderString(s.templateString, s.arguments))
-	}
-}
-
-// TestDisplayArraysAligned is a function.
-func TestDisplayArraysAligned(t *testing.T) {
-	type scenario struct {
-		input    [][]string
-		expected bool
-	}
-
-	scenarios := []scenario{
-		{
-			[][]string{{"", ""}, {"", ""}},
-			true,
-		},
-		{
-			[][]string{{""}, {"", ""}},
-			false,
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, displayArraysAligned(s.input))
-	}
-}
-
-// TestGetPaddedDisplayStrings is a function.
-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))
-	}
-}
-
-// TestGetPadWidths is a function.
-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))
-	}
-}
-
 // TestMin is a function.
 func TestMin(t *testing.T) {
 	type scenario struct {
@@ -275,134 +37,6 @@ func TestMin(t *testing.T) {
 	}
 }
 
-// TestIncludesString is a function.
-func TestIncludesString(t *testing.T) {
-	type scenario struct {
-		list     []string
-		element  string
-		expected bool
-	}
-
-	scenarios := []scenario{
-		{
-			[]string{"a", "b"},
-			"a",
-			true,
-		},
-		{
-			[]string{"a", "b"},
-			"c",
-			false,
-		},
-		{
-			[]string{"a", "b"},
-			"",
-			false,
-		},
-		{
-			[]string{""},
-			"",
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, IncludesString(s.list, s.element))
-	}
-}
-
-func TestNextIndex(t *testing.T) {
-	type scenario struct {
-		testName string
-		list     []int
-		element  int
-		expected int
-	}
-
-	scenarios := []scenario{
-		{
-			// I'm not really fussed about how it behaves here
-			"no elements",
-			[]int{},
-			1,
-			-1,
-		},
-		{
-			"one element",
-			[]int{1},
-			1,
-			0,
-		},
-		{
-			"two elements",
-			[]int{1, 2},
-			1,
-			1,
-		},
-		{
-			"two elements, giving second one",
-			[]int{1, 2},
-			2,
-			1,
-		},
-		{
-			"three elements, giving second one",
-			[]int{1, 2, 3},
-			2,
-			2,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			assert.EqualValues(t, s.expected, NextIndex(s.list, s.element))
-		})
-	}
-}
-
-func TestPrevIndex(t *testing.T) {
-	type scenario struct {
-		testName string
-		list     []int
-		element  int
-		expected int
-	}
-
-	scenarios := []scenario{
-		{
-			// I'm not really fussed about how it behaves here
-			"no elements",
-			[]int{},
-			1,
-			0,
-		},
-		{
-			"one element",
-			[]int{1},
-			1,
-			0,
-		},
-		{
-			"two elements",
-			[]int{1, 2},
-			1,
-			0,
-		},
-		{
-			"three elements, giving second one",
-			[]int{1, 2, 3},
-			2,
-			0,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			assert.EqualValues(t, s.expected, PrevIndex(s.list, s.element))
-		})
-	}
-}
-
 func TestAsJson(t *testing.T) {
 	type myStruct struct {
 		a string