wehub-resource-sync
e04ed9c211
CF: Deploy Dev Docs / deploy (push) Has been cancelled
Sync Labels / build (push) Has been cancelled
tests / unit tests (macos-latest) (push) Has been cancelled
tests / unit tests (windows-latest) (push) Has been cancelled
tests / unit tests (ubuntu-latest) (push) Has been cancelled
394 lines
11 KiB
Go
394 lines
11 KiB
Go
// Copyright 2026 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package skills
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/googleapis/mcp-toolbox/cmd/internal"
|
|
_ "github.com/googleapis/mcp-toolbox/internal/sources/sqlite"
|
|
_ "github.com/googleapis/mcp-toolbox/internal/tools/sqlite/sqlitesql"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
func invokeCommand(args []string) (string, error) {
|
|
parentCmd := &cobra.Command{
|
|
Use: "toolbox",
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
}
|
|
|
|
buf := new(bytes.Buffer)
|
|
opts := internal.NewToolboxOptions(internal.WithIOStreams(buf, buf))
|
|
internal.PersistentFlags(parentCmd, opts)
|
|
|
|
parentCmd.SetOut(buf)
|
|
parentCmd.SetErr(buf)
|
|
|
|
cmd := NewCommand(opts)
|
|
parentCmd.AddCommand(cmd)
|
|
parentCmd.SetArgs(args)
|
|
|
|
err := parentCmd.Execute()
|
|
return buf.String(), err
|
|
}
|
|
|
|
func TestGenerateSkill(t *testing.T) {
|
|
// Create a temporary directory for tests
|
|
tmpDir := t.TempDir()
|
|
outputDir := filepath.Join(tmpDir, "skills")
|
|
|
|
// Create a tools.yaml file with a sqlite tool
|
|
toolsFileContent := `
|
|
sources:
|
|
my-sqlite:
|
|
kind: sqlite
|
|
database: ":memory:"
|
|
tools:
|
|
hello-sqlite:
|
|
kind: sqlite-sql
|
|
source: my-sqlite
|
|
description: "hello tool"
|
|
statement: "SELECT 'hello' as greeting"
|
|
`
|
|
|
|
toolsFilePath := filepath.Join(tmpDir, "tools.yaml")
|
|
if err := os.WriteFile(toolsFilePath, []byte(toolsFileContent), 0644); err != nil {
|
|
t.Fatalf("failed to write config: %v", err)
|
|
}
|
|
|
|
args := []string{
|
|
"skills-generate",
|
|
"--config", toolsFilePath,
|
|
"--output-dir", outputDir,
|
|
"--name", "hello-sqlite",
|
|
"--description", "hello tool",
|
|
}
|
|
|
|
got, err := invokeCommand(args)
|
|
if err != nil {
|
|
t.Fatalf("command failed: %v\nOutput: %s", err, got)
|
|
}
|
|
|
|
// Verify generated directory structure
|
|
skillPath := filepath.Join(outputDir, "hello-sqlite")
|
|
if _, err := os.Stat(skillPath); os.IsNotExist(err) {
|
|
t.Fatalf("skill directory not created: %s", skillPath)
|
|
}
|
|
|
|
// Check SKILL.md
|
|
skillMarkdown := filepath.Join(skillPath, "SKILL.md")
|
|
content, err := os.ReadFile(skillMarkdown)
|
|
if err != nil {
|
|
t.Fatalf("failed to read SKILL.md: %v", err)
|
|
}
|
|
|
|
expectedFrontmatter := `---
|
|
name: hello-sqlite
|
|
description: hello tool
|
|
---`
|
|
if !strings.HasPrefix(string(content), expectedFrontmatter) {
|
|
t.Errorf("SKILL.md does not have expected frontmatter format.\nExpected prefix:\n%s\nGot:\n%s", expectedFrontmatter, string(content))
|
|
}
|
|
|
|
if !strings.Contains(string(content), "## Usage") {
|
|
t.Errorf("SKILL.md does not contain '## Usage' section")
|
|
}
|
|
|
|
if !strings.Contains(string(content), "## Scripts") {
|
|
t.Errorf("SKILL.md does not contain '## Scripts' section")
|
|
}
|
|
|
|
if !strings.Contains(string(content), "### hello-sqlite") {
|
|
t.Errorf("SKILL.md does not contain '### hello-sqlite' tool header")
|
|
}
|
|
|
|
// Check script file
|
|
scriptFilename := "hello-sqlite.js"
|
|
scriptPath := filepath.Join(skillPath, "scripts", scriptFilename)
|
|
if _, err := os.Stat(scriptPath); os.IsNotExist(err) {
|
|
t.Fatalf("script file not created: %s", scriptPath)
|
|
}
|
|
|
|
scriptContent, err := os.ReadFile(scriptPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read script file: %v", err)
|
|
}
|
|
if !strings.Contains(string(scriptContent), "hello-sqlite") {
|
|
t.Errorf("script file does not contain expected tool name")
|
|
}
|
|
|
|
// Check assets
|
|
assetPath := filepath.Join(skillPath, "assets", "tools.yaml")
|
|
if _, err := os.Stat(assetPath); os.IsNotExist(err) {
|
|
t.Fatalf("asset file not created: %s", assetPath)
|
|
}
|
|
assetContent, err := os.ReadFile(assetPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read asset file: %v", err)
|
|
}
|
|
if !strings.Contains(string(assetContent), "hello-sqlite") {
|
|
t.Errorf("asset file does not contain expected tool name")
|
|
}
|
|
}
|
|
|
|
func TestGenerateSkill_Toolsets(t *testing.T) {
|
|
// Create a temporary directory for tests
|
|
tmpDir := t.TempDir()
|
|
outputDir := filepath.Join(tmpDir, "skills")
|
|
|
|
// Create a tools.yaml file with a sqlite tool
|
|
toolsFileContent := `
|
|
sources:
|
|
my-sqlite:
|
|
kind: sqlite
|
|
database: ":memory:"
|
|
tools:
|
|
hello-sqlite:
|
|
kind: sqlite-sql
|
|
source: my-sqlite
|
|
description: "hello tool"
|
|
statement: "SELECT 'hello' as greeting"
|
|
bye-sqlite:
|
|
kind: sqlite-sql
|
|
source: my-sqlite
|
|
description: "bye tool"
|
|
statement: "SELECT 'bye' as greeting"
|
|
toolsets:
|
|
greeting:
|
|
tools:
|
|
- hello-sqlite
|
|
farewell:
|
|
tools:
|
|
- bye-sqlite
|
|
`
|
|
|
|
toolsFilePath := filepath.Join(tmpDir, "tools.yaml")
|
|
if err := os.WriteFile(toolsFilePath, []byte(toolsFileContent), 0644); err != nil {
|
|
t.Fatalf("failed to write tools file: %v", err)
|
|
}
|
|
|
|
args := []string{
|
|
"skills-generate",
|
|
"--tools-file", toolsFilePath,
|
|
"--output-dir", outputDir,
|
|
"--name", "my-skill",
|
|
"--description", "My toolset skills",
|
|
}
|
|
|
|
got, err := invokeCommand(args)
|
|
if err != nil {
|
|
t.Fatalf("command failed: %v\nOutput: %s", err, got)
|
|
}
|
|
|
|
// Verify generated directory structures
|
|
// First toolset skill
|
|
skillPath1 := filepath.Join(outputDir, "my-skill-greeting")
|
|
if _, err := os.Stat(skillPath1); os.IsNotExist(err) {
|
|
t.Fatalf("skill directory not created: %s", skillPath1)
|
|
}
|
|
|
|
skillMarkdown1 := filepath.Join(skillPath1, "SKILL.md")
|
|
content1, err := os.ReadFile(skillMarkdown1)
|
|
if err != nil {
|
|
t.Fatalf("failed to read SKILL.md: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(string(content1), "### hello-sqlite") {
|
|
t.Errorf("SKILL.md does not contain '### hello-sqlite' tool header")
|
|
}
|
|
if strings.Contains(string(content1), "### bye-sqlite") {
|
|
t.Errorf("SKILL.md should not contain '### bye-sqlite' tool header")
|
|
}
|
|
|
|
// Second toolset skill
|
|
skillPath2 := filepath.Join(outputDir, "my-skill-farewell")
|
|
if _, err := os.Stat(skillPath2); os.IsNotExist(err) {
|
|
t.Fatalf("skill directory not created: %s", skillPath2)
|
|
}
|
|
|
|
skillMarkdown2 := filepath.Join(skillPath2, "SKILL.md")
|
|
content2, err := os.ReadFile(skillMarkdown2)
|
|
if err != nil {
|
|
t.Fatalf("failed to read SKILL.md: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(string(content2), "### bye-sqlite") {
|
|
t.Errorf("SKILL.md does not contain '### bye-sqlite' tool header")
|
|
}
|
|
if strings.Contains(string(content2), "### hello-sqlite") {
|
|
t.Errorf("SKILL.md should not contain '### hello-sqlite' tool header")
|
|
}
|
|
}
|
|
|
|
func TestGenerateSkill_SpecificToolset(t *testing.T) {
|
|
// Create a temporary directory for tests
|
|
tmpDir := t.TempDir()
|
|
outputDir := filepath.Join(tmpDir, "skills")
|
|
|
|
// Create a tools.yaml file with a sqlite tool
|
|
toolsFileContent := `
|
|
sources:
|
|
my-sqlite:
|
|
kind: sqlite
|
|
database: ":memory:"
|
|
tools:
|
|
hello-sqlite:
|
|
kind: sqlite-sql
|
|
source: my-sqlite
|
|
description: "hello tool"
|
|
statement: "SELECT 'hello' as greeting"
|
|
bye-sqlite:
|
|
kind: sqlite-sql
|
|
source: my-sqlite
|
|
description: "bye tool"
|
|
statement: "SELECT 'bye' as greeting"
|
|
toolsets:
|
|
greeting:
|
|
tools:
|
|
- hello-sqlite
|
|
farewell:
|
|
tools:
|
|
- bye-sqlite
|
|
`
|
|
|
|
toolsFilePath := filepath.Join(tmpDir, "tools.yaml")
|
|
if err := os.WriteFile(toolsFilePath, []byte(toolsFileContent), 0644); err != nil {
|
|
t.Fatalf("failed to write tools file: %v", err)
|
|
}
|
|
|
|
args := []string{
|
|
"skills-generate",
|
|
"--tools-file", toolsFilePath,
|
|
"--output-dir", outputDir,
|
|
"--name", "my-specific-skill",
|
|
"--description", "My toolset skill",
|
|
"--toolset", "farewell",
|
|
}
|
|
|
|
got, err := invokeCommand(args)
|
|
if err != nil {
|
|
t.Fatalf("command failed: %v\nOutput: %s", err, got)
|
|
}
|
|
|
|
// Because we specified a toolset, it outputs directly into my-specific-skill
|
|
skillPath := filepath.Join(outputDir, "my-specific-skill")
|
|
if _, err := os.Stat(skillPath); os.IsNotExist(err) {
|
|
t.Fatalf("skill directory not created: %s", skillPath)
|
|
}
|
|
|
|
// Ensure other toolsets are not generated
|
|
skillPathGreeting := filepath.Join(outputDir, "my-specific-skill-greeting")
|
|
if _, err := os.Stat(skillPathGreeting); !os.IsNotExist(err) {
|
|
t.Fatalf("skill directory should not have been created: %s", skillPathGreeting)
|
|
}
|
|
|
|
skillMarkdown := filepath.Join(skillPath, "SKILL.md")
|
|
content, err := os.ReadFile(skillMarkdown)
|
|
if err != nil {
|
|
t.Fatalf("failed to read SKILL.md: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(string(content), "### bye-sqlite") {
|
|
t.Errorf("SKILL.md does not contain '### bye-sqlite' tool header")
|
|
}
|
|
if strings.Contains(string(content), "### hello-sqlite") {
|
|
t.Errorf("SKILL.md should not contain '### hello-sqlite' tool header")
|
|
}
|
|
}
|
|
|
|
func TestGenerateSkill_NoConfig(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
outputDir := filepath.Join(tmpDir, "skills")
|
|
|
|
args := []string{
|
|
"skills-generate",
|
|
"--output-dir", outputDir,
|
|
"--name", "test",
|
|
"--description", "test",
|
|
}
|
|
|
|
_, err := invokeCommand(args)
|
|
if err == nil {
|
|
t.Fatal("expected command to fail when no configuration is provided and tools.yaml is missing")
|
|
}
|
|
|
|
// Should not have created the directory if no config was processed
|
|
if _, err := os.Stat(outputDir); !os.IsNotExist(err) {
|
|
t.Errorf("output directory should not have been created")
|
|
}
|
|
}
|
|
|
|
func TestGenerateSkill_MissingArguments(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
toolsFilePath := filepath.Join(tmpDir, "tools.yaml")
|
|
if err := os.WriteFile(toolsFilePath, []byte("tools: {}"), 0644); err != nil {
|
|
t.Fatalf("failed to write config: %v", err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
args []string
|
|
}{
|
|
{
|
|
name: "missing name",
|
|
args: []string{"skills-generate", "--config", toolsFilePath, "--description", "test"},
|
|
},
|
|
{
|
|
name: "missing description",
|
|
args: []string{"skills-generate", "--config", toolsFilePath, "--name", "test"},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := invokeCommand(tt.args)
|
|
if err == nil {
|
|
t.Fatalf("expected command to fail due to missing arguments, but it succeeded\nOutput: %s", got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenerateSkill_FlagValidation(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
args []string
|
|
wantSub string
|
|
}{
|
|
{
|
|
name: "unexpected positional arg",
|
|
args: []string{"skills-generate", "--name", "test", "--description", "test", "extra"},
|
|
wantSub: "unknown command \"extra\"",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := invokeCommand(tt.args)
|
|
if err == nil {
|
|
t.Fatalf("expected error containing %q, but got nil\nOutput: %s", tt.wantSub, got)
|
|
}
|
|
if !strings.Contains(err.Error(), tt.wantSub) && !strings.Contains(got, tt.wantSub) {
|
|
t.Errorf("expected error or output to contain %q\nError: %v\nOutput: %s", tt.wantSub, err, got)
|
|
}
|
|
})
|
|
}
|
|
}
|