package github
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestCleanToolsets(t *testing.T) {
tests := []struct {
name string
input []string
expected []string
expectedInvalid []string
}{
{
name: "empty slice",
input: []string{},
expected: []string{},
},
{
name: "nil input slice",
input: nil,
expected: []string{},
},
// CleanToolsets only cleans - it does NOT filter out special keywords
{
name: "default keyword preserved",
input: []string{"default"},
expected: []string{"default"},
},
{
name: "default with additional toolsets",
input: []string{"default", "actions", "gists"},
expected: []string{"default", "actions", "gists"},
},
{
name: "all keyword preserved",
input: []string{"all", "actions"},
expected: []string{"all", "actions"},
},
{
name: "no special keywords",
input: []string{"actions", "gists", "notifications"},
expected: []string{"actions", "gists", "notifications"},
},
{
name: "duplicate toolsets without special keywords",
input: []string{"actions", "gists", "actions"},
expected: []string{"actions", "gists"},
},
{
name: "duplicate toolsets with default",
input: []string{"context", "repos", "issues", "pull_requests", "users", "default"},
expected: []string{"context", "repos", "issues", "pull_requests", "users", "default"},
},
{
name: "default appears multiple times - duplicates removed",
input: []string{"default", "actions", "default", "gists", "default"},
expected: []string{"default", "actions", "gists"},
},
// Whitespace test cases
{
name: "whitespace check - leading and trailing whitespace on regular toolsets",
input: []string{" actions ", " gists ", "notifications"},
expected: []string{"actions", "gists", "notifications"},
},
{
name: "whitespace check - default toolset with whitespace",
input: []string{" actions ", " default ", "notifications"},
expected: []string{"actions", "default", "notifications"},
},
{
name: "whitespace check - all toolset with whitespace",
input: []string{" all ", " actions "},
expected: []string{"all", "actions"},
},
// Invalid toolset test cases
{
name: "mix of valid and invalid toolsets",
input: []string{"actions", "invalid_toolset", "gists", "typo_repo"},
expected: []string{"actions", "invalid_toolset", "gists", "typo_repo"},
expectedInvalid: []string{"invalid_toolset", "typo_repo"},
},
{
name: "invalid with whitespace",
input: []string{" invalid_tool ", " actions ", " typo_gist "},
expected: []string{"invalid_tool", "actions", "typo_gist"},
expectedInvalid: []string{"invalid_tool", "typo_gist"},
},
{
name: "empty string in toolsets",
input: []string{"", "actions", " ", "gists"},
expected: []string{"actions", "gists"},
expectedInvalid: []string{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, invalid := CleanToolsets(tt.input)
require.Len(t, result, len(tt.expected), "result length should match expected length")
if tt.expectedInvalid == nil {
tt.expectedInvalid = []string{}
}
require.Len(t, invalid, len(tt.expectedInvalid), "invalid length should match expected invalid length")
resultMap := make(map[string]bool)
for _, toolset := range result {
resultMap[toolset] = true
}
expectedMap := make(map[string]bool)
for _, toolset := range tt.expected {
expectedMap[toolset] = true
}
invalidMap := make(map[string]bool)
for _, toolset := range invalid {
invalidMap[toolset] = true
}
expectedInvalidMap := make(map[string]bool)
for _, toolset := range tt.expectedInvalid {
expectedInvalidMap[toolset] = true
}
assert.Equal(t, expectedMap, resultMap, "result should contain all expected toolsets without duplicates")
assert.Equal(t, expectedInvalidMap, invalidMap, "invalid should contain all expected invalid toolsets")
assert.Len(t, resultMap, len(result), "result should not contain duplicates")
})
}
}
func TestAddDefaultToolset(t *testing.T) {
tests := []struct {
name string
input []string
expected []string
}{
{
name: "no default keyword - return unchanged",
input: []string{"actions", "gists"},
expected: []string{"actions", "gists"},
},
{
name: "default keyword present - expand and remove default",
input: []string{"default"},
expected: []string{
"context",
"repos",
"issues",
"pull_requests",
"users",
},
},
{
name: "default with additional toolsets",
input: []string{"default", "actions", "gists"},
expected: []string{
"actions",
"gists",
"context",
"repos",
"issues",
"pull_requests",
"users",
},
},
{
name: "default with overlapping toolsets - should not duplicate",
input: []string{"default", "context", "repos"},
expected: []string{
"context",
"repos",
"issues",
"pull_requests",
"users",
},
},
{
name: "empty input",
input: []string{},
expected: []string{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := AddDefaultToolset(tt.input)
require.Len(t, result, len(tt.expected), "result length should match expected length")
resultMap := make(map[string]bool)
for _, toolset := range result {
resultMap[toolset] = true
}
expectedMap := make(map[string]bool)
for _, toolset := range tt.expected {
expectedMap[toolset] = true
}
assert.Equal(t, expectedMap, resultMap, "result should contain all expected toolsets")
assert.False(t, resultMap["default"], "result should not contain 'default' keyword")
})
}
}
func TestRemoveToolset(t *testing.T) {
tests := []struct {
name string
tools []string
toRemove string
expected []string
}{
{
name: "remove existing toolset",
tools: []string{"actions", "gists", "notifications"},
toRemove: "gists",
expected: []string{"actions", "notifications"},
},
{
name: "remove from empty slice",
tools: []string{},
toRemove: "actions",
expected: []string{},
},
{
name: "remove duplicate entries",
tools: []string{"actions", "gists", "actions", "notifications"},
toRemove: "actions",
expected: []string{"gists", "notifications"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := RemoveToolset(tt.tools, tt.toRemove)
assert.Equal(t, tt.expected, result)
})
}
}
func TestContainsToolset(t *testing.T) {
tests := []struct {
name string
tools []string
toCheck string
expected bool
}{
{
name: "toolset exists",
tools: []string{"actions", "gists", "notifications"},
toCheck: "gists",
expected: true,
},
{
name: "toolset does not exist",
tools: []string{"actions", "gists", "notifications"},
toCheck: "repos",
expected: false,
},
{
name: "empty slice",
tools: []string{},
toCheck: "actions",
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := ContainsToolset(tt.tools, tt.toCheck)
assert.Equal(t, tt.expected, result)
})
}
}
