Matt Holloway
2164 lines
68 KiB
Go
2164 lines
68 KiB
Go
package github
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"testing"
|
|
|
|
"github.com/github/github-mcp-server/internal/toolsnaps"
|
|
"github.com/github/github-mcp-server/pkg/translations"
|
|
gh "github.com/google/go-github/v79/github"
|
|
"github.com/google/jsonschema-go/jsonschema"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func Test_ListProjects(t *testing.T) {
|
|
serverTool := ListProjects(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "list_projects", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "query")
|
|
assert.Contains(t, schema.Properties, "per_page")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner", "owner_type"})
|
|
|
|
// API returns full ProjectV2 objects; we only need minimal fields for decoding.
|
|
orgProjects := []map[string]any{{"id": 1, "node_id": "NODE1", "title": "Org Project"}}
|
|
userProjects := []map[string]any{{"id": 2, "node_id": "NODE2", "title": "User Project"}}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]interface{}
|
|
expectError bool
|
|
expectedLength int
|
|
expectedErrMsg string
|
|
}{
|
|
{
|
|
name: "success organization",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2: mockResponse(t, http.StatusOK, orgProjects),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: false,
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "success user",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2ByUsername: mockResponse(t, http.StatusOK, userProjects),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
},
|
|
expectError: false,
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "success organization with pagination & query",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2: expectQueryParams(t, map[string]string{
|
|
"per_page": "50",
|
|
"q": "roadmap",
|
|
}).andThen(mockResponse(t, http.StatusOK, orgProjects)),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"per_page": float64(50),
|
|
"query": "roadmap",
|
|
},
|
|
expectError: false,
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "failed to list projects",
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
if tc.name == "missing owner" {
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
}
|
|
if tc.name == "missing owner_type" {
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
projects, ok := response["projects"].([]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, tc.expectedLength, len(projects))
|
|
// pageInfo should exist
|
|
_, hasPageInfo := response["pageInfo"].(map[string]interface{})
|
|
assert.True(t, hasPageInfo)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_GetProject(t *testing.T) {
|
|
serverTool := GetProject(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "get_project", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.ElementsMatch(t, schema.Required, []string{"project_number", "owner", "owner_type"})
|
|
|
|
project := map[string]any{"id": 123, "title": "Project Title"}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]interface{}
|
|
expectError bool
|
|
expectedErrMsg string
|
|
}{
|
|
{
|
|
name: "success organization project fetch",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ByProject: mockResponse(t, http.StatusOK, project),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"project_number": float64(123),
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
name: "success user project fetch",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2ByUsernameByProject: mockResponse(t, http.StatusOK, project),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"project_number": float64(456),
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
},
|
|
expectError: false,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ByProject: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"project_number": float64(999),
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "failed to get project",
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"project_number": float64(123),
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"project_number": float64(123),
|
|
"owner": "octo-org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
if tc.name == "missing project_number" {
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
}
|
|
if tc.name == "missing owner" {
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
}
|
|
if tc.name == "missing owner_type" {
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var arr map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &arr)
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_ListProjectFields(t *testing.T) {
|
|
serverTool := ListProjectFields(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "list_project_fields", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "per_page")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number"})
|
|
|
|
orgFields := []map[string]any{{"id": 101, "name": "Status", "data_type": "single_select"}}
|
|
userFields := []map[string]any{{"id": 201, "name": "Priority", "data_type": "single_select"}}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]interface{}
|
|
expectError bool
|
|
expectedLength int
|
|
expectedErrMsg string
|
|
}{
|
|
{
|
|
name: "success organization fields",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2FieldsByProject: mockResponse(t, http.StatusOK, orgFields),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
},
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "success user fields with per_page override",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2FieldsByUsernameByProject: expectQueryParams(t, map[string]string{
|
|
"per_page": "50",
|
|
}).andThen(mockResponse(t, http.StatusOK, userFields)),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(456),
|
|
"per_page": float64(50),
|
|
},
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2FieldsByProject: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(789),
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "failed to list project fields",
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner_type": "org",
|
|
"project_number": 10,
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"project_number": 10,
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
if tc.name == "missing owner" {
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
}
|
|
if tc.name == "missing owner_type" {
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
}
|
|
if tc.name == "missing project_number" {
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
fields, ok := response["fields"].([]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, tc.expectedLength, len(fields))
|
|
_, hasPageInfo := response["pageInfo"].(map[string]interface{})
|
|
assert.True(t, hasPageInfo)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_GetProjectField(t *testing.T) {
|
|
serverTool := GetProjectField(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "get_project_field", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "field_id")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number", "field_id"})
|
|
|
|
orgField := map[string]any{"id": 101, "name": "Status", "dataType": "single_select"}
|
|
userField := map[string]any{"id": 202, "name": "Priority", "dataType": "single_select"}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]any
|
|
expectError bool
|
|
expectedErrMsg string
|
|
expectedID int
|
|
}{
|
|
{
|
|
name: "success organization field",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2FieldsByProjectByFieldID: mockResponse(t, http.StatusOK, orgField),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
"field_id": float64(101),
|
|
},
|
|
expectedID: 101,
|
|
},
|
|
{
|
|
name: "success user field",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2FieldsByUsernameByProjectByFieldID: mockResponse(t, http.StatusOK, userField),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(456),
|
|
"field_id": float64(202),
|
|
},
|
|
expectedID: 202,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2FieldsByProjectByFieldID: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(789),
|
|
"field_id": float64(303),
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "failed to get project field",
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner_type": "org",
|
|
"project_number": float64(10),
|
|
"field_id": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"project_number": float64(10),
|
|
"field_id": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"field_id": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing field_id",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
if tc.name == "missing owner" {
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
}
|
|
if tc.name == "missing owner_type" {
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
}
|
|
if tc.name == "missing project_number" {
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
}
|
|
if tc.name == "missing field_id" {
|
|
assert.Contains(t, text, "missing required parameter: field_id")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var field map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &field)
|
|
require.NoError(t, err)
|
|
if tc.expectedID != 0 {
|
|
assert.Equal(t, float64(tc.expectedID), field["id"])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_ListProjectItems(t *testing.T) {
|
|
serverTool := ListProjectItems(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "list_project_items", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "query")
|
|
assert.Contains(t, schema.Properties, "per_page")
|
|
assert.Contains(t, schema.Properties, "fields")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number"})
|
|
|
|
orgItems := []map[string]any{
|
|
{"id": 301, "content_type": "Issue", "project_node_id": "PR_1", "fields": []map[string]any{
|
|
{"id": 123, "name": "Status", "data_type": "single_select", "value": "value1"},
|
|
{"id": 456, "name": "Priority", "data_type": "single_select", "value": "value2"},
|
|
}},
|
|
}
|
|
userItems := []map[string]any{
|
|
{"id": 401, "content_type": "PullRequest", "project_node_id": "PR_2"},
|
|
{"id": 402, "content_type": "DraftIssue", "project_node_id": "PR_3"},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]interface{}
|
|
expectError bool
|
|
expectedLength int
|
|
expectedErrMsg string
|
|
}{
|
|
{
|
|
name: "success organization items",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProject: mockResponse(t, http.StatusOK, orgItems),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
},
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "success organization items with fields",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProject: expectQueryParams(t, map[string]string{
|
|
"fields": "123,456,789",
|
|
"per_page": "50",
|
|
}).andThen(mockResponse(t, http.StatusOK, orgItems)),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
"fields": []interface{}{"123", "456", "789"},
|
|
},
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "success user items",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2ItemsByUsernameByProject: mockResponse(t, http.StatusOK, userItems),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(456),
|
|
},
|
|
expectedLength: 2,
|
|
},
|
|
{
|
|
name: "success with pagination and query",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProject: expectQueryParams(t, map[string]string{
|
|
"per_page": "50",
|
|
"q": "bug",
|
|
}).andThen(mockResponse(t, http.StatusOK, orgItems)),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
"per_page": float64(50),
|
|
"query": "bug",
|
|
},
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProject: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(789),
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: ProjectListFailedError,
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner_type": "org",
|
|
"project_number": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"project_number": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]interface{}{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
if tc.name == "missing owner" {
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
}
|
|
if tc.name == "missing owner_type" {
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
}
|
|
if tc.name == "missing project_number" {
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
items, ok := response["items"].([]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, tc.expectedLength, len(items))
|
|
_, hasPageInfo := response["pageInfo"].(map[string]interface{})
|
|
assert.True(t, hasPageInfo)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_GetProjectItem(t *testing.T) {
|
|
serverTool := GetProjectItem(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "get_project_item", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "item_id")
|
|
assert.Contains(t, schema.Properties, "fields")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number", "item_id"})
|
|
|
|
orgItem := map[string]any{
|
|
"id": 301,
|
|
"content_type": "Issue",
|
|
"project_node_id": "PR_1",
|
|
"creator": map[string]any{"login": "octocat"},
|
|
}
|
|
userItem := map[string]any{
|
|
"id": 501,
|
|
"content_type": "PullRequest",
|
|
"project_node_id": "PR_2",
|
|
"creator": map[string]any{"login": "jane"},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]any
|
|
expectError bool
|
|
expectedErrMsg string
|
|
expectedID int
|
|
}{
|
|
{
|
|
name: "success organization item",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProjectByItemID: mockResponse(t, http.StatusOK, orgItem),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
"item_id": float64(301),
|
|
},
|
|
expectedID: 301,
|
|
},
|
|
{
|
|
name: "success organization item with fields",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProjectByItemID: expectQueryParams(t, map[string]string{
|
|
"fields": "123,456",
|
|
}).andThen(mockResponse(t, http.StatusOK, orgItem)),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
"item_id": float64(301),
|
|
"fields": []interface{}{"123", "456"},
|
|
},
|
|
expectedID: 301,
|
|
},
|
|
{
|
|
name: "success user item",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2ItemsByUsernameByProjectByItemID: mockResponse(t, http.StatusOK, userItem),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(456),
|
|
"item_id": float64(501),
|
|
},
|
|
expectedID: 501,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProjectByItemID: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(789),
|
|
"item_id": float64(999),
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "failed to get project item",
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner_type": "org",
|
|
"project_number": float64(10),
|
|
"item_id": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"project_number": float64(10),
|
|
"item_id": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"item_id": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing item_id",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
if tc.name == "missing owner" {
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
}
|
|
if tc.name == "missing owner_type" {
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
}
|
|
if tc.name == "missing project_number" {
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
}
|
|
if tc.name == "missing item_id" {
|
|
assert.Contains(t, text, "missing required parameter: item_id")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var item map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &item)
|
|
require.NoError(t, err)
|
|
if tc.expectedID != 0 {
|
|
assert.Equal(t, float64(tc.expectedID), item["id"])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_AddProjectItem(t *testing.T) {
|
|
serverTool := AddProjectItem(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "add_project_item", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "item_type")
|
|
assert.Contains(t, schema.Properties, "item_id")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number", "item_type", "item_id"})
|
|
|
|
orgItem := map[string]any{
|
|
"id": 601,
|
|
"content_type": "Issue",
|
|
"creator": map[string]any{
|
|
"login": "octocat",
|
|
"id": 1,
|
|
"html_url": "https://github.com/octocat",
|
|
"avatar_url": "https://avatars.githubusercontent.com/u/1?v=4",
|
|
},
|
|
}
|
|
|
|
userItem := map[string]any{
|
|
"id": 701,
|
|
"content_type": "PullRequest",
|
|
"creator": map[string]any{
|
|
"login": "hubot",
|
|
"id": 2,
|
|
"html_url": "https://github.com/hubot",
|
|
"avatar_url": "https://avatars.githubusercontent.com/u/2?v=4",
|
|
},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]any
|
|
expectError bool
|
|
expectedErrMsg string
|
|
expectedID int
|
|
expectedContentType string
|
|
expectedCreatorLogin string
|
|
}{
|
|
{
|
|
name: "success organization issue",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PostOrgsProjectsV2ItemsByProject: expectRequestBody(t, map[string]any{
|
|
"type": "Issue",
|
|
"id": float64(9876),
|
|
}).andThen(mockResponse(t, http.StatusCreated, orgItem)),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(321),
|
|
"item_type": "issue",
|
|
"item_id": float64(9876),
|
|
},
|
|
expectedID: 601,
|
|
expectedContentType: "Issue",
|
|
expectedCreatorLogin: "octocat",
|
|
},
|
|
{
|
|
name: "success user pull request",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PostUsersProjectsV2ItemsByUsernameByProject: expectRequestBody(t, map[string]any{
|
|
"type": "PullRequest",
|
|
"id": float64(7654),
|
|
}).andThen(mockResponse(t, http.StatusCreated, userItem)),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(222),
|
|
"item_type": "pull_request",
|
|
"item_id": float64(7654),
|
|
},
|
|
expectedID: 701,
|
|
expectedContentType: "PullRequest",
|
|
expectedCreatorLogin: "hubot",
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PostOrgsProjectsV2ItemsByProject: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(999),
|
|
"item_type": "issue",
|
|
"item_id": float64(8888),
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: ProjectAddFailedError,
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_type": "Issue",
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"project_number": float64(1),
|
|
"item_type": "Issue",
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"item_type": "Issue",
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing item_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing item_id",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_type": "Issue",
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
require.NoError(t, err)
|
|
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
switch tc.name {
|
|
case "missing owner":
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
case "missing owner_type":
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
case "missing project_number":
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
case "missing item_type":
|
|
assert.Contains(t, text, "missing required parameter: item_type")
|
|
case "missing item_id":
|
|
assert.Contains(t, text, "missing required parameter: item_id")
|
|
// case "api error":
|
|
// assert.Contains(t, text, ProjectAddFailedError)
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var item map[string]any
|
|
require.NoError(t, json.Unmarshal([]byte(textContent.Text), &item))
|
|
if tc.expectedID != 0 {
|
|
assert.Equal(t, float64(tc.expectedID), item["id"])
|
|
}
|
|
if tc.expectedContentType != "" {
|
|
assert.Equal(t, tc.expectedContentType, item["content_type"])
|
|
}
|
|
if tc.expectedCreatorLogin != "" {
|
|
creator, ok := item["creator"].(map[string]any)
|
|
require.True(t, ok)
|
|
assert.Equal(t, tc.expectedCreatorLogin, creator["login"])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_UpdateProjectItem(t *testing.T) {
|
|
serverTool := UpdateProjectItem(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "update_project_item", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "item_id")
|
|
assert.Contains(t, schema.Properties, "updated_field")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number", "item_id", "updated_field"})
|
|
|
|
orgUpdatedItem := map[string]any{
|
|
"id": 801,
|
|
"content_type": "Issue",
|
|
}
|
|
userUpdatedItem := map[string]any{
|
|
"id": 802,
|
|
"content_type": "PullRequest",
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]any
|
|
expectError bool
|
|
expectedErrMsg string
|
|
expectedID int
|
|
}{
|
|
{
|
|
name: "success organization update",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PatchOrgsProjectsV2ItemsByProjectByItemID: expectRequestBody(t, map[string]any{
|
|
"fields": []any{map[string]any{"id": float64(101), "value": "Done"}},
|
|
}).andThen(mockResponse(t, http.StatusOK, orgUpdatedItem)),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1001),
|
|
"item_id": float64(5555),
|
|
"updated_field": map[string]any{
|
|
"id": float64(101),
|
|
"value": "Done",
|
|
},
|
|
},
|
|
expectedID: 801,
|
|
},
|
|
{
|
|
name: "success user update",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PatchUsersProjectsV2ItemsByUsernameByProjectByItemID: expectRequestBody(t, map[string]any{
|
|
"fields": []any{map[string]any{"id": float64(202), "value": float64(42)}},
|
|
}).andThen(mockResponse(t, http.StatusOK, userUpdatedItem)),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(2002),
|
|
"item_id": float64(6666),
|
|
"updated_field": map[string]any{
|
|
"id": float64(202),
|
|
"value": float64(42),
|
|
},
|
|
},
|
|
expectedID: 802,
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PatchOrgsProjectsV2ItemsByProjectByItemID: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(3003),
|
|
"item_id": float64(7777),
|
|
"updated_field": map[string]any{
|
|
"id": float64(303),
|
|
"value": "In Progress",
|
|
},
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "failed to update a project item",
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(2),
|
|
"updated_field": map[string]any{
|
|
"id": float64(1),
|
|
"value": "X",
|
|
},
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(2),
|
|
"updated_field": map[string]any{
|
|
"id": float64(1),
|
|
"value": "X",
|
|
},
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"item_id": float64(2),
|
|
"updated_field": map[string]any{
|
|
"id": float64(1),
|
|
"value": "X",
|
|
},
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing item_id",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"updated_field": map[string]any{
|
|
"id": float64(1),
|
|
"value": "X",
|
|
},
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing updated_field",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(2),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "updated_field not object",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(2),
|
|
"updated_field": "not-an-object",
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "updated_field missing id",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(2),
|
|
"updated_field": map[string]any{},
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "updated_field missing value",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(2),
|
|
"updated_field": map[string]any{
|
|
"id": float64(9),
|
|
},
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
switch tc.name {
|
|
case "missing owner":
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
case "missing owner_type":
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
case "missing project_number":
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
case "missing item_id":
|
|
assert.Contains(t, text, "missing required parameter: item_id")
|
|
case "missing updated_field":
|
|
assert.Contains(t, text, "missing required parameter: updated_field")
|
|
case "updated_field not object":
|
|
assert.Contains(t, text, "field_value must be an object")
|
|
case "updated_field missing id":
|
|
assert.Contains(t, text, "updated_field.id is required")
|
|
case "updated_field missing value":
|
|
assert.Contains(t, text, "updated_field.value is required")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
var item map[string]any
|
|
require.NoError(t, json.Unmarshal([]byte(textContent.Text), &item))
|
|
if tc.expectedID != 0 {
|
|
assert.Equal(t, float64(tc.expectedID), item["id"])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_DeleteProjectItem(t *testing.T) {
|
|
serverTool := DeleteProjectItem(translations.NullTranslationHelper)
|
|
tool := serverTool.Tool
|
|
require.NoError(t, toolsnaps.Test(tool.Name, tool))
|
|
|
|
assert.Equal(t, "delete_project_item", tool.Name)
|
|
assert.NotEmpty(t, tool.Description)
|
|
schema, ok := tool.InputSchema.(*jsonschema.Schema)
|
|
require.True(t, ok, "InputSchema should be a *jsonschema.Schema")
|
|
assert.Contains(t, schema.Properties, "owner_type")
|
|
assert.Contains(t, schema.Properties, "owner")
|
|
assert.Contains(t, schema.Properties, "project_number")
|
|
assert.Contains(t, schema.Properties, "item_id")
|
|
assert.ElementsMatch(t, schema.Required, []string{"owner_type", "owner", "project_number", "item_id"})
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]any
|
|
expectError bool
|
|
expectedErrMsg string
|
|
expectedText string
|
|
}{
|
|
{
|
|
name: "success organization delete",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
DeleteOrgsProjectsV2ItemsByProjectByItemID: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(123),
|
|
"item_id": float64(555),
|
|
},
|
|
expectedText: "project item successfully deleted",
|
|
},
|
|
{
|
|
name: "success user delete",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
DeleteUsersProjectsV2ItemsByUsernameByProjectByItemID: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
"project_number": float64(456),
|
|
"item_id": float64(777),
|
|
},
|
|
expectedText: "project item successfully deleted",
|
|
},
|
|
{
|
|
name: "api error",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
DeleteOrgsProjectsV2ItemsByProjectByItemID: mockResponse(t, http.StatusInternalServerError, map[string]string{"message": "boom"}),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(321),
|
|
"item_id": float64(999),
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: ProjectDeleteFailedError,
|
|
},
|
|
{
|
|
name: "missing owner",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing owner_type",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing project_number",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"item_id": float64(10),
|
|
},
|
|
expectError: true,
|
|
},
|
|
{
|
|
name: "missing item_id",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
},
|
|
expectError: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := serverTool.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
if tc.expectError {
|
|
require.True(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, text, tc.expectedErrMsg)
|
|
}
|
|
switch tc.name {
|
|
case "missing owner":
|
|
assert.Contains(t, text, "missing required parameter: owner")
|
|
case "missing owner_type":
|
|
assert.Contains(t, text, "missing required parameter: owner_type")
|
|
case "missing project_number":
|
|
assert.Contains(t, text, "missing required parameter: project_number")
|
|
case "missing item_id":
|
|
assert.Contains(t, text, "missing required parameter: item_id")
|
|
}
|
|
return
|
|
}
|
|
|
|
require.False(t, result.IsError)
|
|
text := getTextResult(t, result).Text
|
|
assert.Contains(t, text, tc.expectedText)
|
|
})
|
|
}
|
|
}
|
|
|
|
// Tests for consolidated project tools
|
|
|
|
func Test_ProjectsList(t *testing.T) {
|
|
// Verify tool definition once
|
|
toolDef := ProjectsList(translations.NullTranslationHelper)
|
|
require.NoError(t, toolsnaps.Test(toolDef.Tool.Name, toolDef.Tool))
|
|
|
|
assert.Equal(t, "projects_list", toolDef.Tool.Name)
|
|
assert.NotEmpty(t, toolDef.Tool.Description)
|
|
inputSchema := toolDef.Tool.InputSchema.(*jsonschema.Schema)
|
|
assert.Contains(t, inputSchema.Properties, "method")
|
|
assert.Contains(t, inputSchema.Properties, "owner")
|
|
assert.Contains(t, inputSchema.Properties, "owner_type")
|
|
assert.Contains(t, inputSchema.Properties, "project_number")
|
|
assert.Contains(t, inputSchema.Properties, "query")
|
|
assert.Contains(t, inputSchema.Properties, "fields")
|
|
assert.ElementsMatch(t, inputSchema.Required, []string{"method", "owner_type", "owner"})
|
|
}
|
|
|
|
func Test_ProjectsList_ListProjects(t *testing.T) {
|
|
toolDef := ProjectsList(translations.NullTranslationHelper)
|
|
|
|
orgProjects := []map[string]any{{"id": 1, "node_id": "NODE1", "title": "Org Project"}}
|
|
userProjects := []map[string]any{{"id": 2, "node_id": "NODE2", "title": "User Project"}}
|
|
|
|
tests := []struct {
|
|
name string
|
|
mockedClient *http.Client
|
|
requestArgs map[string]any
|
|
expectError bool
|
|
expectedErrMsg string
|
|
expectedLength int
|
|
}{
|
|
{
|
|
name: "success organization",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2: mockResponse(t, http.StatusOK, orgProjects),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"method": "list_projects",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: false,
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "success user",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetUsersProjectsV2ByUsername: mockResponse(t, http.StatusOK, userProjects),
|
|
}),
|
|
requestArgs: map[string]any{
|
|
"method": "list_projects",
|
|
"owner": "octocat",
|
|
"owner_type": "user",
|
|
},
|
|
expectError: false,
|
|
expectedLength: 1,
|
|
},
|
|
{
|
|
name: "missing required parameter method",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "missing required parameter: method",
|
|
},
|
|
{
|
|
name: "unknown method",
|
|
mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{}),
|
|
requestArgs: map[string]any{
|
|
"method": "unknown_method",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
},
|
|
expectError: true,
|
|
expectedErrMsg: "unknown method: unknown_method",
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
client := gh.NewClient(tc.mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(tc.requestArgs)
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.expectError, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
|
|
if tc.expectError {
|
|
if tc.expectedErrMsg != "" {
|
|
assert.Contains(t, textContent.Text, tc.expectedErrMsg)
|
|
}
|
|
return
|
|
}
|
|
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
projects, ok := response["projects"].([]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, tc.expectedLength, len(projects))
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_ProjectsList_ListProjectFields(t *testing.T) {
|
|
toolDef := ProjectsList(translations.NullTranslationHelper)
|
|
|
|
fields := []map[string]any{{"id": 101, "name": "Status", "data_type": "single_select"}}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2FieldsByProject: mockResponse(t, http.StatusOK, fields),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "list_project_fields",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
fieldsList, ok := response["fields"].([]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, 1, len(fieldsList))
|
|
})
|
|
|
|
t.Run("missing project_number", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "list_project_fields",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "missing required parameter: project_number")
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsList_ListProjectItems(t *testing.T) {
|
|
toolDef := ProjectsList(translations.NullTranslationHelper)
|
|
|
|
items := []map[string]any{{"id": 1001, "archived_at": nil, "content": map[string]any{"title": "Issue 1"}}}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProject: mockResponse(t, http.StatusOK, items),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "list_project_items",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
itemsList, ok := response["items"].([]interface{})
|
|
require.True(t, ok)
|
|
assert.Equal(t, 1, len(itemsList))
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsGet(t *testing.T) {
|
|
// Verify tool definition once
|
|
toolDef := ProjectsGet(translations.NullTranslationHelper)
|
|
require.NoError(t, toolsnaps.Test(toolDef.Tool.Name, toolDef.Tool))
|
|
|
|
assert.Equal(t, "projects_get", toolDef.Tool.Name)
|
|
assert.NotEmpty(t, toolDef.Tool.Description)
|
|
inputSchema := toolDef.Tool.InputSchema.(*jsonschema.Schema)
|
|
assert.Contains(t, inputSchema.Properties, "method")
|
|
assert.Contains(t, inputSchema.Properties, "owner")
|
|
assert.Contains(t, inputSchema.Properties, "owner_type")
|
|
assert.Contains(t, inputSchema.Properties, "project_number")
|
|
assert.Contains(t, inputSchema.Properties, "field_id")
|
|
assert.Contains(t, inputSchema.Properties, "item_id")
|
|
assert.ElementsMatch(t, inputSchema.Required, []string{"method", "owner_type", "owner", "project_number"})
|
|
}
|
|
|
|
func Test_ProjectsGet_GetProject(t *testing.T) {
|
|
toolDef := ProjectsGet(translations.NullTranslationHelper)
|
|
|
|
project := map[string]any{"id": 123, "title": "Project Title"}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ByProject: mockResponse(t, http.StatusOK, project),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "get_project",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, response["id"])
|
|
})
|
|
|
|
t.Run("unknown method", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "unknown_method",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "unknown method: unknown_method")
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsGet_GetProjectField(t *testing.T) {
|
|
toolDef := ProjectsGet(translations.NullTranslationHelper)
|
|
|
|
field := map[string]any{"id": 101, "name": "Status", "data_type": "single_select"}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2FieldsByProjectByFieldID: mockResponse(t, http.StatusOK, field),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "get_project_field",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"field_id": float64(101),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, response["id"])
|
|
})
|
|
|
|
t.Run("missing field_id", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "get_project_field",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "missing required parameter: field_id")
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsGet_GetProjectItem(t *testing.T) {
|
|
toolDef := ProjectsGet(translations.NullTranslationHelper)
|
|
|
|
item := map[string]any{"id": 1001, "archived_at": nil, "content": map[string]any{"title": "Issue 1"}}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
GetOrgsProjectsV2ItemsByProjectByItemID: mockResponse(t, http.StatusOK, item),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "get_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(1001),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, response["id"])
|
|
})
|
|
|
|
t.Run("missing item_id", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "get_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "missing required parameter: item_id")
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsWrite(t *testing.T) {
|
|
// Verify tool definition once
|
|
toolDef := ProjectsWrite(translations.NullTranslationHelper)
|
|
require.NoError(t, toolsnaps.Test(toolDef.Tool.Name, toolDef.Tool))
|
|
|
|
assert.Equal(t, "projects_write", toolDef.Tool.Name)
|
|
assert.NotEmpty(t, toolDef.Tool.Description)
|
|
inputSchema := toolDef.Tool.InputSchema.(*jsonschema.Schema)
|
|
assert.Contains(t, inputSchema.Properties, "method")
|
|
assert.Contains(t, inputSchema.Properties, "owner")
|
|
assert.Contains(t, inputSchema.Properties, "owner_type")
|
|
assert.Contains(t, inputSchema.Properties, "project_number")
|
|
assert.Contains(t, inputSchema.Properties, "item_id")
|
|
assert.Contains(t, inputSchema.Properties, "item_type")
|
|
assert.Contains(t, inputSchema.Properties, "updated_field")
|
|
assert.ElementsMatch(t, inputSchema.Required, []string{"method", "owner_type", "owner", "project_number"})
|
|
|
|
// Verify DestructiveHint is set
|
|
assert.NotNil(t, toolDef.Tool.Annotations)
|
|
assert.NotNil(t, toolDef.Tool.Annotations.DestructiveHint)
|
|
assert.True(t, *toolDef.Tool.Annotations.DestructiveHint)
|
|
}
|
|
|
|
func Test_ProjectsWrite_AddProjectItem(t *testing.T) {
|
|
toolDef := ProjectsWrite(translations.NullTranslationHelper)
|
|
|
|
addedItem := map[string]any{"id": 2001, "archived_at": nil}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PostOrgsProjectsV2ItemsByProject: expectRequestBody(t, map[string]any{
|
|
"type": "Issue",
|
|
"id": float64(123),
|
|
}).andThen(mockResponse(t, http.StatusCreated, addedItem)),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "add_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(123),
|
|
"item_type": "issue",
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, response["id"])
|
|
})
|
|
|
|
t.Run("missing item_type", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "add_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(123),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "missing required parameter: item_type")
|
|
})
|
|
|
|
t.Run("invalid item_type", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "add_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(123),
|
|
"item_type": "invalid_type",
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "item_type must be either 'issue' or 'pull_request'")
|
|
})
|
|
|
|
t.Run("unknown method", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "unknown_method",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "unknown method: unknown_method")
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsWrite_UpdateProjectItem(t *testing.T) {
|
|
toolDef := ProjectsWrite(translations.NullTranslationHelper)
|
|
|
|
updatedItem := map[string]any{"id": 1001, "archived_at": nil}
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
PatchOrgsProjectsV2ItemsByProjectByItemID: mockResponse(t, http.StatusOK, updatedItem),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "update_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(1001),
|
|
"updated_field": map[string]any{
|
|
"id": float64(101),
|
|
"value": "In Progress",
|
|
},
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
var response map[string]any
|
|
err = json.Unmarshal([]byte(textContent.Text), &response)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, response["id"])
|
|
})
|
|
|
|
t.Run("missing updated_field", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "update_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(1001),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "missing required parameter: updated_field")
|
|
})
|
|
}
|
|
|
|
func Test_ProjectsWrite_DeleteProjectItem(t *testing.T) {
|
|
toolDef := ProjectsWrite(translations.NullTranslationHelper)
|
|
|
|
t.Run("success organization", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
|
|
DeleteOrgsProjectsV2ItemsByProjectByItemID: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}),
|
|
})
|
|
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "delete_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
"item_id": float64(1001),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.False(t, result.IsError)
|
|
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "project item successfully deleted")
|
|
})
|
|
|
|
t.Run("missing item_id", func(t *testing.T) {
|
|
mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{})
|
|
client := gh.NewClient(mockedClient)
|
|
deps := BaseDeps{
|
|
Client: client,
|
|
}
|
|
handler := toolDef.Handler(deps)
|
|
request := createMCPRequest(map[string]any{
|
|
"method": "delete_project_item",
|
|
"owner": "octo-org",
|
|
"owner_type": "org",
|
|
"project_number": float64(1),
|
|
})
|
|
result, err := handler(ContextWithDeps(context.Background(), deps), &request)
|
|
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsError)
|
|
textContent := getTextResult(t, result)
|
|
assert.Contains(t, textContent.Text, "missing required parameter: item_id")
|
|
})
|
|
}
|