ignore casing in vs code extensions

internal/vscode.go

@@ -6,14 +6,12 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-var (
-	vscodeExe = "code"
-)
+var vscodeExe = "code"
 
 // VSCode holds the information to automatically install VSCode extensions.
 type VSCode struct {
-	Extensions  []string
-	Commander Commander
+	Extensions []string
+	Commander  Commander
 }
 
 // GetMissingPackages returns a list of VSCode extensions which are configured
@@ -24,15 +22,15 @@ func (v VSCode) GetMissingPackages() ([]string, error) {
 		return nil, err
 	}
 	logrus.WithField("output", string(stdout)).Debug("homebrew stdout")
-	installedBottles := strings.Split(string(stdout), "\n")
+	installedBottles := strings.Split(strings.ToLower(string(stdout)), "\n")
 	installedMap := map[string]bool{}
 	for _, p := range installedBottles {
 		installedMap[p] = true
 	}
 
 	missingBottles := []string{}
 	for _, bottle := range v.Extensions {
-		if ok := installedMap[bottle]; !ok {
+		if ok := installedMap[strings.ToLower(bottle)]; !ok {
 			missingBottles = append(missingBottles, bottle)
 		}
 	}

internal/vscode_test.go

@@ -7,16 +7,51 @@ import (
 )
 
 func TestGetMissingVSCodeExtension(t *testing.T) {
-	commander := mockCommander{}
-	defer commander.AssertExpectations(t)
-	commander.ExpectOutput("code", []string{"--list-extensions"}, []byte("bar"), nil)
-	b := VSCode{
-		Extensions:  []string{"bar", "foo"},
-		Commander: commander.Output,
+	testCases := []struct {
+		name              string
+		input             []string
+		applicationOutput []byte
+		expected          []string
+	}{
+		{
+			name:              "normal case",
+			input:             []string{"bar", "foo"},
+			applicationOutput: []byte("bar"),
+			expected:          []string{"foo"},
+		},
+		{
+			name:              "multiple in output",
+			input:             []string{"bar", "foo"},
+			applicationOutput: []byte("bar\nbaz"),
+			expected:          []string{"foo"},
+		},
+		{
+			name:              "upper-case in input",
+			input:             []string{"Bar", "foo"},
+			applicationOutput: []byte("bar"),
+			expected:          []string{"foo"},
+		},
+		{
+			name:              "upper-case in output",
+			input:             []string{"bar", "foo"},
+			applicationOutput: []byte("Bar"),
+			expected:          []string{"foo"},
+		},
+	}
+
+	for _, testCase := range testCases {
+
+		commander := mockCommander{}
+		defer commander.AssertExpectations(t)
+		commander.ExpectOutput("code", []string{"--list-extensions"}, testCase.applicationOutput, nil)
+		b := VSCode{
+			Extensions: testCase.input,
+			Commander:  commander.Output,
+		}
+		missingPackages, err := b.GetMissingPackages()
+		assert.NoError(t, err)
+		assert.Equal(t, testCase.expected, missingPackages, testCase.name)
 	}
-	missingPackages, err := b.GetMissingPackages()
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"foo"}, missingPackages)
 }
 
 func TestInstallingVSCodeExtension(t *testing.T) {