refactor: update integration tests to use unique labels for nodes

Author: mjfwebb

test/integration/README.md

@@ -7,42 +7,47 @@ Integration tests for the Neo4j MCP server using a shared Neo4j container (inclu
 ```go
 func TestMCPIntegration_MyFeature(t *testing.T) {
     t.Parallel()
-    tc := NewTestContext(t)
+    tc := helpers.NewTestContext(t)
 
-    // Seed test data (automatically isolated and cleaned up)
-    tc.SeedNode("Person", map[string]any{"name": "Alice"})
+    // Seed test data (automatically isolated with unique labels and cleaned up)
+    personLabel, err := tc.SeedNode("Person", map[string]any{"name": "Alice"})
+    if err != nil {
+        t.Fatalf("failed to seed data: %v", err)
+    }
 
     // Call tool
-    handler := tools.ReadCypherHandler(tc.Deps)
+    handler := cypher.ReadCypherHandler(tc.Deps)
     res := tc.CallTool(handler, map[string]any{
-        "query":  "MATCH (p:Person {test_id: $testID}) RETURN p",
-        "params": map[string]any{"testID": tc.TestID},
+        "query":  "MATCH (p:" + personLabel + " {name: $name}) RETURN p",
+        "params": map[string]any{"name": "Alice"},
     })
 
     // Parse and assert
     var records []map[string]any
     tc.ParseJSONResponse(res, &records)
 
     person := records[0]["p"].(map[string]any)
-    AssertNodeProperties(t, person, map[string]any{"name": "Alice"})
+    helpers.AssertNodeProperties(t, person, map[string]any{"name": "Alice"})
+    helpers.AssertNodeHasLabel(t, person, personLabel)
 }
 ```
 
 ## Key Helpers
 
 **TestContext:**
 
-- `NewTestContext(t)` - Auto-isolation + cleanup
-- `SeedNode(label, props)` - Create test data
+- `helpers.NewTestContext(t)` - Auto-isolation + cleanup
+- `SeedNode(label, props)` - Create test data with unique label, returns `(UniqueLabel, error)`
+- `GetUniqueLabel(label)` - Get a unique label for creating nodes manually
 - `CallTool(handler, args)` - Invoke MCP tool
 - `ParseJSONResponse(res, &v)` - Parse response
 - `VerifyNodeInDB(label, props)` - Check DB state
 
 **Assertions:**
 
-- `AssertNodeProperties(t, node, props)`
-- `AssertNodeHasLabel(t, node, label)`
-- `AssertSchemaHasNodeType(t, schema, label, props)`
+- `helpers.AssertNodeProperties(t, node, props)`
+- `helpers.AssertNodeHasLabel(t, node, label)`
+- `helpers.AssertSchemaHasNodeType(t, schema, label, props)`
 
 ## Running Tests
 
@@ -75,5 +80,6 @@ go test -tags=integration ./test/integration/... -v
 ## Important
 
 - Always use `t.Parallel()` for parallel execution
-- Always include `test_id` in queries for isolation
-- Test data is automatically tagged with unique IDs and cleaned up
+- Always use the `UniqueLabel` returned by `SeedNode()` or `GetUniqueLabel()` in your queries for isolation
+- Test data is automatically tagged with unique labels and cleaned up after each test
+- Import the helpers package: `"github.com/neo4j/mcp/test/integration/helpers"`

test/integration/get_schema_test.go

@@ -14,10 +14,13 @@ func TestMCPIntegration_GetSchema(t *testing.T) {
 
 	tc := helpers.NewTestContext(t)
 
-	if err := tc.SeedNode("Person", map[string]any{"name": "Alice", "age": 30}); err != nil {
+	// Use TestID as identifier to create unique labels
+	personLabel, err := tc.SeedNode("Person", map[string]any{"name": "Alice", "age": 30})
+	if err != nil {
 		t.Fatalf("failed to seed Person node: %v", err)
 	}
-	if err := tc.SeedNode("Company", map[string]any{"name": "Neo4j", "founded": 2007}); err != nil {
+	companyLabel, err := tc.SeedNode("Company", map[string]any{"name": "Neo4j", "founded": 2007})
+	if err != nil {
 		t.Fatalf("failed to seed Company node: %v", err)
 	}
 
@@ -44,6 +47,7 @@ func TestMCPIntegration_GetSchema(t *testing.T) {
 		schemaMap[key] = value
 	}
 
-	helpers.AssertSchemaHasNodeType(t, schemaMap, "Person", []string{"name", "age"})
-	helpers.AssertSchemaHasNodeType(t, schemaMap, "Company", []string{"name", "founded"})
+	// Check for the unique labels created
+	helpers.AssertSchemaHasNodeType(t, schemaMap, personLabel, []string{"name", "age"})
+	helpers.AssertSchemaHasNodeType(t, schemaMap, companyLabel, []string{"name", "founded"})
 }

test/integration/helpers/helpers.go

@@ -23,13 +23,23 @@ import (
 	"github.com/testcontainers/testcontainers-go/wait"
 )
 
+type UniqueLabel string
+
+// String returns the string representation of the UniqueLabel.
+// This implements the fmt.Stringer interface, making it work seamlessly with fmt functions.
+func (ul UniqueLabel) String() string {
+	return string(ul)
+}
+
 // TestContext holds common test dependencies
 type TestContext struct {
-	Ctx     context.Context
-	T       *testing.T
-	TestID  string
-	Service database.Service
-	Deps    *tools.ToolDependencies
+	Ctx           context.Context
+	T             *testing.T
+	TestID        string
+	Service       database.Service
+	Deps          *tools.ToolDependencies
+	createdLabels map[string]bool
+	labelMutex    sync.Mutex
 }
 
 var (
@@ -92,9 +102,10 @@ func NewTestContext(t *testing.T) *TestContext {
 	testID := makeTestID()
 
 	tc := &TestContext{
-		Ctx:    ctx,
-		T:      t,
-		TestID: testID,
+		Ctx:           ctx,
+		T:             t,
+		TestID:        testID,
+		createdLabels: make(map[string]bool),
 	}
 
 	t.Cleanup(func() {
@@ -114,7 +125,7 @@ func NewTestContext(t *testing.T) *TestContext {
 	return tc
 }
 
-// Cleanup removes all test data tagged with this test ID
+// Cleanup removes all test data by deleting nodes with labels created during the test
 func (tc *TestContext) Cleanup() {
 	if tc.Service == nil {
 		return // Service wasn't initialized, nothing to clean up
@@ -123,27 +134,46 @@ func (tc *TestContext) Cleanup() {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	if _, err := tc.Service.ExecuteWriteQuery(
-		ctx,
-		"MATCH (n) WHERE n.test_id = $testID DETACH DELETE n",
-		map[string]any{"testID": tc.TestID},
-		cfg.Database,
-	); err != nil {
-		log.Printf("Warning: cleanup failed for test_id=%s: %v", tc.TestID, err)
+	tc.labelMutex.Lock()
+	labels := make([]string, 0, len(tc.createdLabels))
+	for label := range tc.createdLabels {
+		labels = append(labels, label)
+	}
+	tc.labelMutex.Unlock()
+
+	// Delete nodes for each unique label
+	for _, label := range labels {
+		query := fmt.Sprintf("MATCH (n:%s) DETACH DELETE n", label)
+		if _, err := tc.Service.ExecuteWriteQuery(
+			ctx,
+			query,
+			map[string]any{},
+			cfg.Database,
+		); err != nil {
+			log.Printf("Warning: cleanup failed for label=%s: %v", label, err)
+		}
 	}
 }
 
-// SeedNode creates a test node and returns it
-func (tc *TestContext) SeedNode(label string, props map[string]any) error {
+// SeedNode creates a test node with a unique label and returns it.
+func (tc *TestContext) SeedNode(label string, props map[string]any) (UniqueLabel, error) {
 	tc.T.Helper()
 
-	// Always add test_id to props
-	props["test_id"] = tc.TestID
+	if tc.TestID == "" {
+		panic("SeedNode: TestID is not set in TestContext. Did you forget to use NewTestContext?")
+	}
+
+	uniqueLabel := UniqueLabel(fmt.Sprintf("%s_%s", label, tc.TestID))
+
+	// Track this label for cleanup
+	tc.labelMutex.Lock()
+	tc.createdLabels[string(uniqueLabel)] = true
+	tc.labelMutex.Unlock()
 
 	session := (driver).NewSession(tc.Ctx, neo4j.SessionConfig{})
 	defer session.Close(tc.Ctx)
 
-	query := fmt.Sprintf("CREATE (n:%s $props) RETURN n", label)
+	query := fmt.Sprintf("CREATE (n:%s $props) RETURN n", uniqueLabel)
 	_, err := session.ExecuteWrite(tc.Ctx, func(tx neo4j.ManagedTransaction) (any, error) {
 		result, err := tx.Run(tc.Ctx, query, map[string]any{"props": props})
 		if err != nil {
@@ -153,7 +183,23 @@ func (tc *TestContext) SeedNode(label string, props map[string]any) error {
 		return nil, err
 	})
 
-	return err
+	return uniqueLabel, err
+}
+
+// GetUniqueLabel returns a unique label for the given base label and identifier.
+func (tc *TestContext) GetUniqueLabel(label string) UniqueLabel {
+	if tc.TestID == "" {
+		panic("GetUniqueLabel: TestID is not set in TestContext. Did you forget to use NewTestContext?")
+	}
+
+	uniqueLabel := UniqueLabel(fmt.Sprintf("%s_%s", label, tc.TestID))
+
+	// Track this label for cleanup
+	tc.labelMutex.Lock()
+	tc.createdLabels[string(uniqueLabel)] = true
+	tc.labelMutex.Unlock()
+
+	return uniqueLabel
 }
 
 // CallTool invokes an MCP tool and returns the response
@@ -198,13 +244,11 @@ func (tc *TestContext) ParseJSONResponse(res *mcp.CallToolResult, v any) {
 	}
 }
 
-// VerifyNodeInDB verifies that a node exists in the database with the given properties
-func (tc *TestContext) VerifyNodeInDB(label string, props map[string]any) *neo4j.Record {
+// VerifyNodeInDB verifies that a node exists in the database with the given properties.
+// The label parameter should be the unique label (e.g., "Person_test_abc123").
+func (tc *TestContext) VerifyNodeInDB(label UniqueLabel, props map[string]any) *neo4j.Record {
 	tc.T.Helper()
 
-	// Build WHERE clause for each property
-	props["test_id"] = tc.TestID
-
 	session := (driver).NewSession(tc.Ctx, neo4j.SessionConfig{})
 	defer session.Close(tc.Ctx)
 
@@ -262,7 +306,7 @@ func AssertNodeProperties(t *testing.T, node map[string]any, expectedProps map[s
 }
 
 // AssertNodeHasLabel checks if a node has a specific label
-func AssertNodeHasLabel(t *testing.T, node map[string]any, expectedLabel string) {
+func AssertNodeHasLabel(t *testing.T, node map[string]any, expectedLabel UniqueLabel) {
 	t.Helper()
 
 	labels, ok := node["Labels"].([]any)
@@ -271,7 +315,7 @@ func AssertNodeHasLabel(t *testing.T, node map[string]any, expectedLabel string)
 	}
 
 	for _, label := range labels {
-		if labelStr, ok := label.(string); ok && labelStr == expectedLabel {
+		if labelStr, ok := label.(string); ok && labelStr == string(expectedLabel) {
 			return
 		}
 	}
@@ -280,10 +324,10 @@ func AssertNodeHasLabel(t *testing.T, node map[string]any, expectedLabel string)
 }
 
 // AssertSchemaHasNodeType checks if the schema contains a node type with expected properties
-func AssertSchemaHasNodeType(t *testing.T, schemaMap map[string]map[string]any, label string, expectedProps []string) {
+func AssertSchemaHasNodeType(t *testing.T, schemaMap map[string]map[string]any, label UniqueLabel, expectedProps []string) {
 	t.Helper()
 
-	schema, ok := schemaMap[label]
+	schema, ok := schemaMap[string(label)]
 	if !ok {
 		t.Errorf("expected schema to contain '%s' label", label)
 		return
@@ -308,7 +352,8 @@ func AssertSchemaHasNodeType(t *testing.T, schemaMap map[string]map[string]any,
 
 // makeTestID returns a unique test id suitable for tagging resources created by tests.
 func makeTestID() string {
-	return fmt.Sprintf("test-%s", uuid.NewString())
+	id := fmt.Sprintf("test-%s", uuid.NewString())
+	return strings.ReplaceAll(id, "-", "_")
 }
 
 // waitForConnectivity waits for Neo4j connectivity with exponential backoff.

test/integration/read_cypher_test.go

@@ -14,14 +14,15 @@ func TestMCPIntegration_ReadCypher(t *testing.T) {
 
 	tc := helpers.NewTestContext(t)
 
-	if err := tc.SeedNode("Person", map[string]any{"name": "Alice"}); err != nil {
+	personLabel, err := tc.SeedNode("Person", map[string]any{"name": "Alice"})
+	if err != nil {
 		t.Fatalf("failed to seed data: %v", err)
 	}
 
 	read := cypher.ReadCypherHandler(tc.Deps)
 	res := tc.CallTool(read, map[string]any{
-		"query":  "MATCH (p:Person {name: $name, test_id: $testID}) RETURN p",
-		"params": map[string]any{"name": "Alice", "testID": tc.TestID},
+		"query":  "MATCH (p:" + personLabel + " {name: $name}) RETURN p",
+		"params": map[string]any{"name": "Alice"},
 	})
 
 	var records []map[string]any
@@ -37,5 +38,5 @@ func TestMCPIntegration_ReadCypher(t *testing.T) {
 			records[0]["p"])
 	}
 	helpers.AssertNodeProperties(t, pNode, map[string]any{"name": "Alice"})
-	helpers.AssertNodeHasLabel(t, pNode, "Person")
+	helpers.AssertNodeHasLabel(t, pNode, personLabel)
 }

test/integration/workflows_test.go

@@ -14,16 +14,18 @@ func TestMCPIntegration_WriteThenRead(t *testing.T) {
 
 	tc := helpers.NewTestContext(t)
 
+	companyLabel := tc.GetUniqueLabel("Company")
+
 	write := cypher.WriteCypherHandler(tc.Deps)
 	tc.CallTool(write, map[string]any{
-		"query":  "CREATE (c:Company {name: $name, industry: $industry, test_id: $testID}) RETURN c",
-		"params": map[string]any{"name": "Neo4j", "industry": "Database", "testID": tc.TestID},
+		"query":  "CREATE (c:" + companyLabel + " {name: $name, industry: $industry}) RETURN c",
+		"params": map[string]any{"name": "Neo4j", "industry": "Database"},
 	})
 
 	read := cypher.ReadCypherHandler(tc.Deps)
 	res := tc.CallTool(read, map[string]any{
-		"query":  "MATCH (c:Company {test_id: $testID}) RETURN c",
-		"params": map[string]any{"testID": tc.TestID},
+		"query":  "MATCH (c:" + companyLabel + ") RETURN c",
+		"params": map[string]any{},
 	})
 
 	var records []map[string]any
@@ -38,5 +40,5 @@ func TestMCPIntegration_WriteThenRead(t *testing.T) {
 		"name":     "Neo4j",
 		"industry": "Database",
 	})
-	helpers.AssertNodeHasLabel(t, company, "Company")
+	helpers.AssertNodeHasLabel(t, company, companyLabel)
 }

test/integration/write_cypher_test.go

@@ -14,11 +14,13 @@ func TestMCPIntegration_WriteCypher(t *testing.T) {
 
 	tc := helpers.NewTestContext(t)
 
+	personLabel := tc.GetUniqueLabel("Person")
+
 	write := cypher.WriteCypherHandler(tc.Deps)
 	tc.CallTool(write, map[string]any{
-		"query":  "CREATE (p:Person {name: $name, test_id: $testID}) RETURN p",
-		"params": map[string]any{"name": "Alice", "testID": tc.TestID},
+		"query":  "CREATE (p:" + personLabel + " {name: $name}) RETURN p",
+		"params": map[string]any{"name": "Alice"},
 	})
 
-	tc.VerifyNodeInDB("Person", map[string]any{"name": "Alice"})
+	tc.VerifyNodeInDB(personLabel, map[string]any{"name": "Alice"})
 }