examples: add a 'listeverything' client example, and reorganize
Add a client example that lists all features on a stdio server. Since this is our first client example, organize examples by client / server -- otherwise it is too difficult to find client examples. For #33
This commit is contained in:
Rob Findley
Robert Findley
parent
c132621eb0
commit
e00c485969
1 changed files with 65 additions and 0 deletions
703
examples/server/memory/kb_test.go
Normal file
703
examples/server/memory/kb_test.go
Normal file
|
|
@ -0,0 +1,703 @@
|
|||
// Copyright 2025 The Go MCP SDK Authors. All rights reserved.
|
||||
// Use of this source code is governed by an MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/modelcontextprotocol/go-sdk/mcp"
|
||||
)
|
||||
|
||||
// stores provides test factories for both storage implementations.
|
||||
func stores() map[string]func(t *testing.T) store {
|
||||
return map[string]func(t *testing.T) store{
|
||||
"file": func(t *testing.T) store {
|
||||
tempDir, err := os.MkdirTemp("", "kb-test-file-*")
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create temp dir: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { os.RemoveAll(tempDir) })
|
||||
return &fileStore{path: filepath.Join(tempDir, "test-memory.json")}
|
||||
},
|
||||
"memory": func(t *testing.T) store {
|
||||
return &memoryStore{}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// TestKnowledgeBaseOperations verifies CRUD operations work correctly.
|
||||
func TestKnowledgeBaseOperations(t *testing.T) {
|
||||
for name, newStore := range stores() {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
// Verify empty graph loads correctly
|
||||
graph, err := kb.loadGraph()
|
||||
if err != nil {
|
||||
t.Fatalf("failed to load empty graph: %v", err)
|
||||
}
|
||||
if len(graph.Entities) != 0 || len(graph.Relations) != 0 {
|
||||
t.Errorf("expected empty graph, got %+v", graph)
|
||||
}
|
||||
|
||||
// Create and verify entities
|
||||
testEntities := []Entity{
|
||||
{
|
||||
Name: "Alice",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Likes coffee"},
|
||||
},
|
||||
{
|
||||
Name: "Bob",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Likes tea"},
|
||||
},
|
||||
}
|
||||
|
||||
createdEntities, err := kb.createEntities(testEntities)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create entities: %v", err)
|
||||
}
|
||||
if len(createdEntities) != 2 {
|
||||
t.Errorf("expected 2 created entities, got %d", len(createdEntities))
|
||||
}
|
||||
|
||||
// Verify entities persist
|
||||
graph, err = kb.loadGraph()
|
||||
if err != nil {
|
||||
t.Fatalf("failed to read graph: %v", err)
|
||||
}
|
||||
if len(graph.Entities) != 2 {
|
||||
t.Errorf("expected 2 entities, got %d", len(graph.Entities))
|
||||
}
|
||||
|
||||
// Create and verify relations
|
||||
testRelations := []Relation{
|
||||
{
|
||||
From: "Alice",
|
||||
To: "Bob",
|
||||
RelationType: "friend",
|
||||
},
|
||||
}
|
||||
|
||||
createdRelations, err := kb.createRelations(testRelations)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create relations: %v", err)
|
||||
}
|
||||
if len(createdRelations) != 1 {
|
||||
t.Errorf("expected 1 created relation, got %d", len(createdRelations))
|
||||
}
|
||||
|
||||
// Add observations to entities
|
||||
testObservations := []Observation{
|
||||
{
|
||||
EntityName: "Alice",
|
||||
Contents: []string{"Works as developer", "Lives in New York"},
|
||||
},
|
||||
}
|
||||
|
||||
addedObservations, err := kb.addObservations(testObservations)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to add observations: %v", err)
|
||||
}
|
||||
if len(addedObservations) != 1 || len(addedObservations[0].Contents) != 2 {
|
||||
t.Errorf("expected 1 observation with 2 contents, got %+v", addedObservations)
|
||||
}
|
||||
|
||||
// Search nodes by content
|
||||
searchResult, err := kb.searchNodes("developer")
|
||||
if err != nil {
|
||||
t.Fatalf("failed to search nodes: %v", err)
|
||||
}
|
||||
if len(searchResult.Entities) != 1 || searchResult.Entities[0].Name != "Alice" {
|
||||
t.Errorf("expected to find Alice when searching for 'developer', got %+v", searchResult)
|
||||
}
|
||||
|
||||
// Retrieve specific nodes
|
||||
openResult, err := kb.openNodes([]string{"Bob"})
|
||||
if err != nil {
|
||||
t.Fatalf("failed to open nodes: %v", err)
|
||||
}
|
||||
if len(openResult.Entities) != 1 || openResult.Entities[0].Name != "Bob" {
|
||||
t.Errorf("expected to find Bob when opening 'Bob', got %+v", openResult)
|
||||
}
|
||||
|
||||
// Remove specific observations
|
||||
deleteObs := []Observation{
|
||||
{
|
||||
EntityName: "Alice",
|
||||
Observations: []string{"Works as developer"},
|
||||
},
|
||||
}
|
||||
err = kb.deleteObservations(deleteObs)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to delete observations: %v", err)
|
||||
}
|
||||
|
||||
// Confirm observation removal
|
||||
graph, _ = kb.loadGraph()
|
||||
aliceIndex := slices.IndexFunc(graph.Entities, func(e Entity) bool {
|
||||
return e.Name == "Alice"
|
||||
})
|
||||
if aliceIndex == -1 {
|
||||
t.Errorf("entity 'Alice' not found after deleting observation")
|
||||
} else {
|
||||
alice := graph.Entities[aliceIndex]
|
||||
if slices.Contains(alice.Observations, "Works as developer") {
|
||||
t.Errorf("observation 'Works as developer' should have been deleted")
|
||||
}
|
||||
}
|
||||
|
||||
// Remove relations
|
||||
err = kb.deleteRelations(testRelations)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to delete relations: %v", err)
|
||||
}
|
||||
|
||||
// Confirm relation removal
|
||||
graph, _ = kb.loadGraph()
|
||||
if len(graph.Relations) != 0 {
|
||||
t.Errorf("expected 0 relations after deletion, got %d", len(graph.Relations))
|
||||
}
|
||||
|
||||
// Remove entities
|
||||
err = kb.deleteEntities([]string{"Alice"})
|
||||
if err != nil {
|
||||
t.Fatalf("failed to delete entities: %v", err)
|
||||
}
|
||||
|
||||
// Confirm entity removal
|
||||
graph, _ = kb.loadGraph()
|
||||
if len(graph.Entities) != 1 || graph.Entities[0].Name != "Bob" {
|
||||
t.Errorf("expected only Bob to remain after deleting Alice, got %+v", graph.Entities)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestSaveAndLoadGraph ensures data persists correctly across save/load cycles.
|
||||
func TestSaveAndLoadGraph(t *testing.T) {
|
||||
for name, newStore := range stores() {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
// Setup test data
|
||||
testGraph := KnowledgeGraph{
|
||||
Entities: []Entity{
|
||||
{
|
||||
Name: "Charlie",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Likes hiking"},
|
||||
},
|
||||
},
|
||||
Relations: []Relation{
|
||||
{
|
||||
From: "Charlie",
|
||||
To: "Mountains",
|
||||
RelationType: "enjoys",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// Persist to storage
|
||||
err := kb.saveGraph(testGraph)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to save graph: %v", err)
|
||||
}
|
||||
|
||||
// Reload from storage
|
||||
loadedGraph, err := kb.loadGraph()
|
||||
if err != nil {
|
||||
t.Fatalf("failed to load graph: %v", err)
|
||||
}
|
||||
|
||||
// Verify data integrity
|
||||
if !reflect.DeepEqual(testGraph, loadedGraph) {
|
||||
t.Errorf("loaded graph does not match saved graph.\nExpected: %+v\nGot: %+v", testGraph, loadedGraph)
|
||||
}
|
||||
|
||||
// Test malformed data handling
|
||||
if fs, ok := s.(*fileStore); ok {
|
||||
err := os.WriteFile(fs.path, []byte("invalid json"), 0600)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to write invalid json: %v", err)
|
||||
}
|
||||
|
||||
_, err = kb.loadGraph()
|
||||
if err == nil {
|
||||
t.Errorf("expected error when loading invalid JSON, got nil")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestDuplicateEntitiesAndRelations verifies duplicate prevention logic.
|
||||
func TestDuplicateEntitiesAndRelations(t *testing.T) {
|
||||
for name, newStore := range stores() {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
// Setup initial state
|
||||
initialEntities := []Entity{
|
||||
{
|
||||
Name: "Dave",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Plays guitar"},
|
||||
},
|
||||
}
|
||||
|
||||
_, err := kb.createEntities(initialEntities)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create initial entities: %v", err)
|
||||
}
|
||||
|
||||
// Attempt duplicate creation
|
||||
duplicateEntities := []Entity{
|
||||
{
|
||||
Name: "Dave",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Sings well"},
|
||||
},
|
||||
{
|
||||
Name: "Eve",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Plays piano"},
|
||||
},
|
||||
}
|
||||
|
||||
newEntities, err := kb.createEntities(duplicateEntities)
|
||||
if err != nil {
|
||||
t.Fatalf("failed when adding duplicate entities: %v", err)
|
||||
}
|
||||
|
||||
// Verify only new entities created
|
||||
if len(newEntities) != 1 || newEntities[0].Name != "Eve" {
|
||||
t.Errorf("expected only 'Eve' to be created, got %+v", newEntities)
|
||||
}
|
||||
|
||||
// Setup initial relation
|
||||
initialRelation := []Relation{
|
||||
{
|
||||
From: "Dave",
|
||||
To: "Eve",
|
||||
RelationType: "friend",
|
||||
},
|
||||
}
|
||||
|
||||
_, err = kb.createRelations(initialRelation)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create initial relation: %v", err)
|
||||
}
|
||||
|
||||
// Test relation deduplication
|
||||
duplicateRelations := []Relation{
|
||||
{
|
||||
From: "Dave",
|
||||
To: "Eve",
|
||||
RelationType: "friend",
|
||||
},
|
||||
{
|
||||
From: "Eve",
|
||||
To: "Dave",
|
||||
RelationType: "friend",
|
||||
},
|
||||
}
|
||||
|
||||
newRelations, err := kb.createRelations(duplicateRelations)
|
||||
if err != nil {
|
||||
t.Fatalf("failed when adding duplicate relations: %v", err)
|
||||
}
|
||||
|
||||
// Verify only new relations created
|
||||
if len(newRelations) != 1 || newRelations[0].From != "Eve" || newRelations[0].To != "Dave" {
|
||||
t.Errorf("expected only 'Eve->Dave' relation to be created, got %+v", newRelations)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestErrorHandling verifies proper error responses for invalid operations.
|
||||
func TestErrorHandling(t *testing.T) {
|
||||
t.Run("FileStoreWriteError", func(t *testing.T) {
|
||||
// Test file write to invalid path
|
||||
kb := knowledgeBase{
|
||||
s: &fileStore{path: filepath.Join("nonexistent", "directory", "file.json")},
|
||||
}
|
||||
|
||||
testEntities := []Entity{
|
||||
{Name: "TestEntity"},
|
||||
}
|
||||
|
||||
_, err := kb.createEntities(testEntities)
|
||||
if err == nil {
|
||||
t.Errorf("expected error when writing to non-existent directory, got nil")
|
||||
}
|
||||
})
|
||||
|
||||
for name, newStore := range stores() {
|
||||
t.Run(fmt.Sprintf("AddObservationToNonExistentEntity_%s", name), func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
// Setup valid entity for comparison
|
||||
_, err := kb.createEntities([]Entity{{Name: "RealEntity"}})
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create test entity: %v", err)
|
||||
}
|
||||
|
||||
// Test invalid entity reference
|
||||
nonExistentObs := []Observation{
|
||||
{
|
||||
EntityName: "NonExistentEntity",
|
||||
Contents: []string{"This shouldn't work"},
|
||||
},
|
||||
}
|
||||
|
||||
_, err = kb.addObservations(nonExistentObs)
|
||||
if err == nil {
|
||||
t.Errorf("expected error when adding observations to non-existent entity, got nil")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestFileFormatting verifies the JSON storage format structure.
|
||||
func TestFileFormatting(t *testing.T) {
|
||||
for name, newStore := range stores() {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
// Setup test entity
|
||||
testEntities := []Entity{
|
||||
{
|
||||
Name: "FileTest",
|
||||
EntityType: "TestEntity",
|
||||
Observations: []string{"Test observation"},
|
||||
},
|
||||
}
|
||||
|
||||
_, err := kb.createEntities(testEntities)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to create test entity: %v", err)
|
||||
}
|
||||
|
||||
// Extract raw storage data
|
||||
data, err := s.Read()
|
||||
if err != nil {
|
||||
t.Fatalf("failed to read from store: %v", err)
|
||||
}
|
||||
|
||||
// Validate JSON format
|
||||
var items []kbItem
|
||||
err = json.Unmarshal(data, &items)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to parse store data JSON: %v", err)
|
||||
}
|
||||
|
||||
// Check data structure
|
||||
if len(items) != 1 {
|
||||
t.Fatalf("expected 1 item in memory file, got %d", len(items))
|
||||
}
|
||||
|
||||
item := items[0]
|
||||
if item.Type != "entity" ||
|
||||
item.Name != "FileTest" ||
|
||||
item.EntityType != "TestEntity" ||
|
||||
len(item.Observations) != 1 ||
|
||||
item.Observations[0] != "Test observation" {
|
||||
t.Errorf("store item format incorrect: %+v", item)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestMCPServerIntegration tests the knowledge base through MCP server layer.
|
||||
func TestMCPServerIntegration(t *testing.T) {
|
||||
for name, newStore := range stores() {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
// Create mock server session
|
||||
ctx := context.Background()
|
||||
serverSession := &mcp.ServerSession{}
|
||||
|
||||
// Test CreateEntities through MCP
|
||||
createEntitiesParams := &mcp.CallToolParamsFor[CreateEntitiesArgs]{
|
||||
Arguments: CreateEntitiesArgs{
|
||||
Entities: []Entity{
|
||||
{
|
||||
Name: "TestPerson",
|
||||
EntityType: "Person",
|
||||
Observations: []string{"Likes testing"},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
createResult, err := kb.CreateEntities(ctx, serverSession, createEntitiesParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP CreateEntities failed: %v", err)
|
||||
}
|
||||
if createResult.IsError {
|
||||
t.Fatalf("MCP CreateEntities returned error: %v", createResult.Content)
|
||||
}
|
||||
if len(createResult.StructuredContent.Entities) != 1 {
|
||||
t.Errorf("expected 1 entity created, got %d", len(createResult.StructuredContent.Entities))
|
||||
}
|
||||
|
||||
// Test ReadGraph through MCP
|
||||
readParams := &mcp.CallToolParamsFor[struct{}]{}
|
||||
readResult, err := kb.ReadGraph(ctx, serverSession, readParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP ReadGraph failed: %v", err)
|
||||
}
|
||||
if readResult.IsError {
|
||||
t.Fatalf("MCP ReadGraph returned error: %v", readResult.Content)
|
||||
}
|
||||
if len(readResult.StructuredContent.Entities) != 1 {
|
||||
t.Errorf("expected 1 entity in graph, got %d", len(readResult.StructuredContent.Entities))
|
||||
}
|
||||
|
||||
// Test CreateRelations through MCP
|
||||
createRelationsParams := &mcp.CallToolParamsFor[CreateRelationsArgs]{
|
||||
Arguments: CreateRelationsArgs{
|
||||
Relations: []Relation{
|
||||
{
|
||||
From: "TestPerson",
|
||||
To: "Testing",
|
||||
RelationType: "likes",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
relationsResult, err := kb.CreateRelations(ctx, serverSession, createRelationsParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP CreateRelations failed: %v", err)
|
||||
}
|
||||
if relationsResult.IsError {
|
||||
t.Fatalf("MCP CreateRelations returned error: %v", relationsResult.Content)
|
||||
}
|
||||
if len(relationsResult.StructuredContent.Relations) != 1 {
|
||||
t.Errorf("expected 1 relation created, got %d", len(relationsResult.StructuredContent.Relations))
|
||||
}
|
||||
|
||||
// Test AddObservations through MCP
|
||||
addObsParams := &mcp.CallToolParamsFor[AddObservationsArgs]{
|
||||
Arguments: AddObservationsArgs{
|
||||
Observations: []Observation{
|
||||
{
|
||||
EntityName: "TestPerson",
|
||||
Contents: []string{"Works remotely", "Drinks coffee"},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
obsResult, err := kb.AddObservations(ctx, serverSession, addObsParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP AddObservations failed: %v", err)
|
||||
}
|
||||
if obsResult.IsError {
|
||||
t.Fatalf("MCP AddObservations returned error: %v", obsResult.Content)
|
||||
}
|
||||
if len(obsResult.StructuredContent.Observations) != 1 {
|
||||
t.Errorf("expected 1 observation result, got %d", len(obsResult.StructuredContent.Observations))
|
||||
}
|
||||
|
||||
// Test SearchNodes through MCP
|
||||
searchParams := &mcp.CallToolParamsFor[SearchNodesArgs]{
|
||||
Arguments: SearchNodesArgs{
|
||||
Query: "coffee",
|
||||
},
|
||||
}
|
||||
|
||||
searchResult, err := kb.SearchNodes(ctx, serverSession, searchParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP SearchNodes failed: %v", err)
|
||||
}
|
||||
if searchResult.IsError {
|
||||
t.Fatalf("MCP SearchNodes returned error: %v", searchResult.Content)
|
||||
}
|
||||
if len(searchResult.StructuredContent.Entities) != 1 {
|
||||
t.Errorf("expected 1 entity from search, got %d", len(searchResult.StructuredContent.Entities))
|
||||
}
|
||||
|
||||
// Test OpenNodes through MCP
|
||||
openParams := &mcp.CallToolParamsFor[OpenNodesArgs]{
|
||||
Arguments: OpenNodesArgs{
|
||||
Names: []string{"TestPerson"},
|
||||
},
|
||||
}
|
||||
|
||||
openResult, err := kb.OpenNodes(ctx, serverSession, openParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP OpenNodes failed: %v", err)
|
||||
}
|
||||
if openResult.IsError {
|
||||
t.Fatalf("MCP OpenNodes returned error: %v", openResult.Content)
|
||||
}
|
||||
if len(openResult.StructuredContent.Entities) != 1 {
|
||||
t.Errorf("expected 1 entity from open, got %d", len(openResult.StructuredContent.Entities))
|
||||
}
|
||||
|
||||
// Test DeleteObservations through MCP
|
||||
deleteObsParams := &mcp.CallToolParamsFor[DeleteObservationsArgs]{
|
||||
Arguments: DeleteObservationsArgs{
|
||||
Deletions: []Observation{
|
||||
{
|
||||
EntityName: "TestPerson",
|
||||
Observations: []string{"Works remotely"},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
deleteObsResult, err := kb.DeleteObservations(ctx, serverSession, deleteObsParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP DeleteObservations failed: %v", err)
|
||||
}
|
||||
if deleteObsResult.IsError {
|
||||
t.Fatalf("MCP DeleteObservations returned error: %v", deleteObsResult.Content)
|
||||
}
|
||||
|
||||
// Test DeleteRelations through MCP
|
||||
deleteRelParams := &mcp.CallToolParamsFor[DeleteRelationsArgs]{
|
||||
Arguments: DeleteRelationsArgs{
|
||||
Relations: []Relation{
|
||||
{
|
||||
From: "TestPerson",
|
||||
To: "Testing",
|
||||
RelationType: "likes",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
deleteRelResult, err := kb.DeleteRelations(ctx, serverSession, deleteRelParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP DeleteRelations failed: %v", err)
|
||||
}
|
||||
if deleteRelResult.IsError {
|
||||
t.Fatalf("MCP DeleteRelations returned error: %v", deleteRelResult.Content)
|
||||
}
|
||||
|
||||
// Test DeleteEntities through MCP
|
||||
deleteEntParams := &mcp.CallToolParamsFor[DeleteEntitiesArgs]{
|
||||
Arguments: DeleteEntitiesArgs{
|
||||
EntityNames: []string{"TestPerson"},
|
||||
},
|
||||
}
|
||||
|
||||
deleteEntResult, err := kb.DeleteEntities(ctx, serverSession, deleteEntParams)
|
||||
if err != nil {
|
||||
t.Fatalf("MCP DeleteEntities failed: %v", err)
|
||||
}
|
||||
if deleteEntResult.IsError {
|
||||
t.Fatalf("MCP DeleteEntities returned error: %v", deleteEntResult.Content)
|
||||
}
|
||||
|
||||
// Verify final state
|
||||
finalRead, err := kb.ReadGraph(ctx, serverSession, readParams)
|
||||
if err != nil {
|
||||
t.Fatalf("Final MCP ReadGraph failed: %v", err)
|
||||
}
|
||||
if len(finalRead.StructuredContent.Entities) != 0 {
|
||||
t.Errorf("expected empty graph after deletion, got %d entities", len(finalRead.StructuredContent.Entities))
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestMCPErrorHandling tests error scenarios through MCP layer.
|
||||
func TestMCPErrorHandling(t *testing.T) {
|
||||
for name, newStore := range stores() {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
s := newStore(t)
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
ctx := context.Background()
|
||||
serverSession := &mcp.ServerSession{}
|
||||
|
||||
// Test adding observations to non-existent entity
|
||||
addObsParams := &mcp.CallToolParamsFor[AddObservationsArgs]{
|
||||
Arguments: AddObservationsArgs{
|
||||
Observations: []Observation{
|
||||
{
|
||||
EntityName: "NonExistentEntity",
|
||||
Contents: []string{"This should fail"},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
_, err := kb.AddObservations(ctx, serverSession, addObsParams)
|
||||
if err == nil {
|
||||
t.Errorf("expected MCP AddObservations to return error for non-existent entity")
|
||||
} else {
|
||||
// Verify the error message contains expected text
|
||||
want := "entity with name NonExistentEntity not found"
|
||||
if !strings.Contains(err.Error(), want) {
|
||||
t.Errorf("expected error message to contain '%s', got: %v", want, err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestMCPResponseFormat verifies MCP response format consistency.
|
||||
func TestMCPResponseFormat(t *testing.T) {
|
||||
s := &memoryStore{}
|
||||
kb := knowledgeBase{s: s}
|
||||
|
||||
ctx := context.Background()
|
||||
serverSession := &mcp.ServerSession{}
|
||||
|
||||
// Test CreateEntities response format
|
||||
createParams := &mcp.CallToolParamsFor[CreateEntitiesArgs]{
|
||||
Arguments: CreateEntitiesArgs{
|
||||
Entities: []Entity{
|
||||
{Name: "FormatTest", EntityType: "Test"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
result, err := kb.CreateEntities(ctx, serverSession, createParams)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateEntities failed: %v", err)
|
||||
}
|
||||
|
||||
// Verify response has both Content and StructuredContent
|
||||
if len(result.Content) == 0 {
|
||||
t.Errorf("expected Content field to be populated")
|
||||
}
|
||||
if len(result.StructuredContent.Entities) == 0 {
|
||||
t.Errorf("expected StructuredContent.Entities to be populated")
|
||||
}
|
||||
|
||||
// Verify Content contains simple success message
|
||||
if textContent, ok := result.Content[0].(*mcp.TextContent); ok {
|
||||
expectedMessage := "Entities created successfully"
|
||||
if textContent.Text != expectedMessage {
|
||||
t.Errorf("expected Content field to contain '%s', got '%s'", expectedMessage, textContent.Text)
|
||||
}
|
||||
} else {
|
||||
t.Errorf("expected Content[0] to be TextContent")
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue