test: add E2E tests for new RPC features across all SDKs

SteveSandersonMS · Copilot · SteveSandersonMS · commit 277e52432d8b · 2026-02-17T10:50:09.000Z
- Python: test_rpc.py - mode, plan, workspace tests
- Go: rpc_test.go - mode, plan, workspace tests
- .NET: RpcTests.cs - mode, plan, workspace tests
- Fix C# codegen to use enum type for method signatures (not just request classes)

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/dotnet/src/Generated/Rpc.cs b/dotnet/src/Generated/Rpc.cs
@@ -513,7 +513,7 @@ public async Task<SessionModeGetResult> GetAsync(CancellationToken cancellationT
     }
 
     /// <summary>Calls "session.mode.set".</summary>
-    public async Task<SessionModeSetResult> SetAsync(string mode, CancellationToken cancellationToken = default)
+    public async Task<SessionModeSetResult> SetAsync(SessionModeGetResultMode mode, CancellationToken cancellationToken = default)
     {
         var request = new SetRequest { SessionId = _sessionId, Mode = mode };
         return await CopilotClient.InvokeRpcAsync<SessionModeSetResult>(_rpc, "session.mode.set", [request], cancellationToken);
diff --git a/dotnet/test/RpcTests.cs b/dotnet/test/RpcTests.cs
@@ -2,6 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *--------------------------------------------------------------------------------------------*/
 
+using GitHub.Copilot.SDK.Rpc;
 using GitHub.Copilot.SDK.Test.Harness;
 using Xunit;
 using Xunit.Abstractions;
@@ -79,4 +80,83 @@ public async Task Should_Call_Session_Rpc_Model_SwitchTo()
         var after = await session.Rpc.Model.GetCurrentAsync();
         Assert.Equal("gpt-4.1", after.ModelId);
     }
+
+    [Fact]
+    public async Task Should_Get_And_Set_Session_Mode()
+    {
+        var session = await Client.CreateSessionAsync();
+
+        // Get initial mode (default should be interactive)
+        var initial = await session.Rpc.Mode.GetAsync();
+        Assert.Equal(SessionModeGetResultMode.Interactive, initial.Mode);
+
+        // Switch to plan mode
+        var planResult = await session.Rpc.Mode.SetAsync(SessionModeGetResultMode.Plan);
+        Assert.Equal(SessionModeGetResultMode.Plan, planResult.Mode);
+
+        // Verify mode persisted
+        var afterPlan = await session.Rpc.Mode.GetAsync();
+        Assert.Equal(SessionModeGetResultMode.Plan, afterPlan.Mode);
+
+        // Switch back to interactive
+        var interactiveResult = await session.Rpc.Mode.SetAsync(SessionModeGetResultMode.Interactive);
+        Assert.Equal(SessionModeGetResultMode.Interactive, interactiveResult.Mode);
+    }
+
+    [Fact]
+    public async Task Should_Read_Update_And_Delete_Plan()
+    {
+        var session = await Client.CreateSessionAsync();
+
+        // Initially plan should not exist
+        var initial = await session.Rpc.Plan.ReadAsync();
+        Assert.False(initial.Exists);
+        Assert.Null(initial.Content);
+
+        // Create/update plan
+        var planContent = "# Test Plan\n\n- Step 1\n- Step 2";
+        await session.Rpc.Plan.UpdateAsync(planContent);
+
+        // Verify plan exists and has correct content
+        var afterUpdate = await session.Rpc.Plan.ReadAsync();
+        Assert.True(afterUpdate.Exists);
+        Assert.Equal(planContent, afterUpdate.Content);
+
+        // Delete plan
+        await session.Rpc.Plan.DeleteAsync();
+
+        // Verify plan is deleted
+        var afterDelete = await session.Rpc.Plan.ReadAsync();
+        Assert.False(afterDelete.Exists);
+        Assert.Null(afterDelete.Content);
+    }
+
+    [Fact]
+    public async Task Should_Create_List_And_Read_Workspace_Files()
+    {
+        var session = await Client.CreateSessionAsync();
+
+        // Initially no files
+        var initialFiles = await session.Rpc.Workspace.ListFilesAsync();
+        Assert.Empty(initialFiles.Files);
+
+        // Create a file
+        var fileContent = "Hello, workspace!";
+        await session.Rpc.Workspace.CreateFileAsync("test.txt", fileContent);
+
+        // List files
+        var afterCreate = await session.Rpc.Workspace.ListFilesAsync();
+        Assert.Contains("test.txt", afterCreate.Files);
+
+        // Read file
+        var readResult = await session.Rpc.Workspace.ReadFileAsync("test.txt");
+        Assert.Equal(fileContent, readResult.Content);
+
+        // Create nested file
+        await session.Rpc.Workspace.CreateFileAsync("subdir/nested.txt", "Nested content");
+
+        var afterNested = await session.Rpc.Workspace.ListFilesAsync();
+        Assert.Contains("test.txt", afterNested.Files);
+        Assert.Contains(afterNested.Files, f => f.Contains("nested.txt"));
+    }
 }
diff --git a/go/internal/e2e/rpc_test.go b/go/internal/e2e/rpc_test.go
@@ -1,6 +1,7 @@
 package e2e
 
 import (
+	"strings"
 	"testing"
 
 	copilot "github.com/github/copilot-sdk/go"
@@ -185,4 +186,185 @@ func TestSessionRpc(t *testing.T) {
 			t.Errorf("Expected modelId 'gpt-4.1' after switch, got %v", after.ModelID)
 		}
 	})
+
+	t.Run("should get and set session mode", func(t *testing.T) {
+		session, err := client.CreateSession(t.Context(), nil)
+		if err != nil {
+			t.Fatalf("Failed to create session: %v", err)
+		}
+
+		// Get initial mode (default should be interactive)
+		initial, err := session.RPC.Mode.Get(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to get mode: %v", err)
+		}
+		if initial.Mode != rpc.Interactive {
+			t.Errorf("Expected initial mode 'interactive', got %q", initial.Mode)
+		}
+
+		// Switch to plan mode
+		planResult, err := session.RPC.Mode.Set(t.Context(), &rpc.SessionModeSetParams{Mode: rpc.Plan})
+		if err != nil {
+			t.Fatalf("Failed to set mode to plan: %v", err)
+		}
+		if planResult.Mode != rpc.Plan {
+			t.Errorf("Expected mode 'plan', got %q", planResult.Mode)
+		}
+
+		// Verify mode persisted
+		afterPlan, err := session.RPC.Mode.Get(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to get mode after plan: %v", err)
+		}
+		if afterPlan.Mode != rpc.Plan {
+			t.Errorf("Expected mode 'plan' after set, got %q", afterPlan.Mode)
+		}
+
+		// Switch back to interactive
+		interactiveResult, err := session.RPC.Mode.Set(t.Context(), &rpc.SessionModeSetParams{Mode: rpc.Interactive})
+		if err != nil {
+			t.Fatalf("Failed to set mode to interactive: %v", err)
+		}
+		if interactiveResult.Mode != rpc.Interactive {
+			t.Errorf("Expected mode 'interactive', got %q", interactiveResult.Mode)
+		}
+	})
+
+	t.Run("should read, update, and delete plan", func(t *testing.T) {
+		session, err := client.CreateSession(t.Context(), nil)
+		if err != nil {
+			t.Fatalf("Failed to create session: %v", err)
+		}
+
+		// Initially plan should not exist
+		initial, err := session.RPC.Plan.Read(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to read plan: %v", err)
+		}
+		if initial.Exists {
+			t.Error("Expected plan to not exist initially")
+		}
+		if initial.Content != nil {
+			t.Error("Expected content to be nil initially")
+		}
+
+		// Create/update plan
+		planContent := "# Test Plan\n\n- Step 1\n- Step 2"
+		_, err = session.RPC.Plan.Update(t.Context(), &rpc.SessionPlanUpdateParams{Content: planContent})
+		if err != nil {
+			t.Fatalf("Failed to update plan: %v", err)
+		}
+
+		// Verify plan exists and has correct content
+		afterUpdate, err := session.RPC.Plan.Read(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to read plan after update: %v", err)
+		}
+		if !afterUpdate.Exists {
+			t.Error("Expected plan to exist after update")
+		}
+		if afterUpdate.Content == nil || *afterUpdate.Content != planContent {
+			t.Errorf("Expected content %q, got %v", planContent, afterUpdate.Content)
+		}
+
+		// Delete plan
+		_, err = session.RPC.Plan.Delete(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to delete plan: %v", err)
+		}
+
+		// Verify plan is deleted
+		afterDelete, err := session.RPC.Plan.Read(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to read plan after delete: %v", err)
+		}
+		if afterDelete.Exists {
+			t.Error("Expected plan to not exist after delete")
+		}
+		if afterDelete.Content != nil {
+			t.Error("Expected content to be nil after delete")
+		}
+	})
+
+	t.Run("should create, list, and read workspace files", func(t *testing.T) {
+		session, err := client.CreateSession(t.Context(), nil)
+		if err != nil {
+			t.Fatalf("Failed to create session: %v", err)
+		}
+
+		// Initially no files
+		initialFiles, err := session.RPC.Workspace.ListFiles(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to list files: %v", err)
+		}
+		if len(initialFiles.Files) != 0 {
+			t.Errorf("Expected no files initially, got %v", initialFiles.Files)
+		}
+
+		// Create a file
+		fileContent := "Hello, workspace!"
+		_, err = session.RPC.Workspace.CreateFile(t.Context(), &rpc.SessionWorkspaceCreateFileParams{
+			Path:    "test.txt",
+			Content: fileContent,
+		})
+		if err != nil {
+			t.Fatalf("Failed to create file: %v", err)
+		}
+
+		// List files
+		afterCreate, err := session.RPC.Workspace.ListFiles(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to list files after create: %v", err)
+		}
+		if !containsString(afterCreate.Files, "test.txt") {
+			t.Errorf("Expected files to contain 'test.txt', got %v", afterCreate.Files)
+		}
+
+		// Read file
+		readResult, err := session.RPC.Workspace.ReadFile(t.Context(), &rpc.SessionWorkspaceReadFileParams{
+			Path: "test.txt",
+		})
+		if err != nil {
+			t.Fatalf("Failed to read file: %v", err)
+		}
+		if readResult.Content != fileContent {
+			t.Errorf("Expected content %q, got %q", fileContent, readResult.Content)
+		}
+
+		// Create nested file
+		_, err = session.RPC.Workspace.CreateFile(t.Context(), &rpc.SessionWorkspaceCreateFileParams{
+			Path:    "subdir/nested.txt",
+			Content: "Nested content",
+		})
+		if err != nil {
+			t.Fatalf("Failed to create nested file: %v", err)
+		}
+
+		afterNested, err := session.RPC.Workspace.ListFiles(t.Context())
+		if err != nil {
+			t.Fatalf("Failed to list files after nested: %v", err)
+		}
+		if !containsString(afterNested.Files, "test.txt") {
+			t.Errorf("Expected files to contain 'test.txt', got %v", afterNested.Files)
+		}
+		hasNested := false
+		for _, f := range afterNested.Files {
+			if strings.Contains(f, "nested.txt") {
+				hasNested = true
+				break
+			}
+		}
+		if !hasNested {
+			t.Errorf("Expected files to contain 'nested.txt', got %v", afterNested.Files)
+		}
+	})
+}
+
+func containsString(slice []string, str string) bool {
+	for _, s := range slice {
+		if s == str {
+			return true
+		}
+	}
+	return false
 }
diff --git a/python/e2e/test_rpc.py b/python/e2e/test_rpc.py
@@ -102,3 +102,85 @@ async def test_should_call_session_rpc_model_switch_to(self, ctx: E2ETestContext
         # Verify the switch persisted
         after = await session.rpc.model.get_current()
         assert after.model_id == "gpt-4.1"
+
+    @pytest.mark.asyncio
+    async def test_get_and_set_session_mode(self, ctx: E2ETestContext):
+        """Test getting and setting session mode"""
+        from copilot.generated.rpc import Mode, SessionModeSetParams
+
+        session = await ctx.client.create_session({})
+
+        # Get initial mode (default should be interactive)
+        initial = await session.rpc.mode.get()
+        assert initial.mode == Mode.INTERACTIVE
+
+        # Switch to plan mode
+        plan_result = await session.rpc.mode.set(SessionModeSetParams(mode=Mode.PLAN))
+        assert plan_result.mode == Mode.PLAN
+
+        # Verify mode persisted
+        after_plan = await session.rpc.mode.get()
+        assert after_plan.mode == Mode.PLAN
+
+        # Switch back to interactive
+        interactive_result = await session.rpc.mode.set(SessionModeSetParams(mode=Mode.INTERACTIVE))
+        assert interactive_result.mode == Mode.INTERACTIVE
+
+    @pytest.mark.asyncio
+    async def test_read_update_and_delete_plan(self, ctx: E2ETestContext):
+        """Test reading, updating, and deleting plan"""
+        from copilot.generated.rpc import SessionPlanUpdateParams
+
+        session = await ctx.client.create_session({})
+
+        # Initially plan should not exist
+        initial = await session.rpc.plan.read()
+        assert initial.exists is False
+        assert initial.content is None
+
+        # Create/update plan
+        plan_content = "# Test Plan\n\n- Step 1\n- Step 2"
+        await session.rpc.plan.update(SessionPlanUpdateParams(content=plan_content))
+
+        # Verify plan exists and has correct content
+        after_update = await session.rpc.plan.read()
+        assert after_update.exists is True
+        assert after_update.content == plan_content
+
+        # Delete plan
+        await session.rpc.plan.delete()
+
+        # Verify plan is deleted
+        after_delete = await session.rpc.plan.read()
+        assert after_delete.exists is False
+        assert after_delete.content is None
+
+    @pytest.mark.asyncio
+    async def test_create_list_and_read_workspace_files(self, ctx: E2ETestContext):
+        """Test creating, listing, and reading workspace files"""
+        from copilot.generated.rpc import SessionWorkspaceCreateFileParams, SessionWorkspaceReadFileParams
+
+        session = await ctx.client.create_session({})
+
+        # Initially no files
+        initial_files = await session.rpc.workspace.list_files()
+        assert initial_files.files == []
+
+        # Create a file
+        file_content = "Hello, workspace!"
+        await session.rpc.workspace.create_file(SessionWorkspaceCreateFileParams(content=file_content, path="test.txt"))
+
+        # List files
+        after_create = await session.rpc.workspace.list_files()
+        assert "test.txt" in after_create.files
+
+        # Read file
+        read_result = await session.rpc.workspace.read_file(SessionWorkspaceReadFileParams(path="test.txt"))
+        assert read_result.content == file_content
+
+        # Create nested file
+        await session.rpc.workspace.create_file(SessionWorkspaceCreateFileParams(content="Nested content", path="subdir/nested.txt"))
+
+        after_nested = await session.rpc.workspace.list_files()
+        assert "test.txt" in after_nested.files
+        assert any("nested.txt" in f for f in after_nested.files)
diff --git a/scripts/codegen/csharp.ts b/scripts/codegen/csharp.ts
@@ -697,7 +697,7 @@ function emitSessionApiClass(className: string, node: Record<string, unknown>, c
 
         for (const [pName, pSchema] of paramEntries) {
             if (typeof pSchema !== "object") continue;
-            const csType = schemaTypeToCSharp(pSchema as JSONSchema7, requiredSet.has(pName), rpcKnownTypes);
+            const csType = resolveRpcType(pSchema as JSONSchema7, requiredSet.has(pName), requestClassName, toPascalCase(pName), classes);
             sigParams.push(`${csType} ${pName}`);
             bodyAssignments.push(`${toPascalCase(pName)} = ${pName}`);
         }

Original file line number	Diff line number	Diff line change
`@@ -513,7 +513,7 @@ public async Task<SessionModeGetResult> GetAsync(CancellationToken cancellationT`
`513`	`513`	`}`
`514`	`514`
`515`	`515`	`/// <summary>Calls "session.mode.set".</summary>`
`516`		`- public async Task<SessionModeSetResult> SetAsync(string mode, CancellationToken cancellationToken = default)`
	`516`	`+ public async Task<SessionModeSetResult> SetAsync(SessionModeGetResultMode mode, CancellationToken cancellationToken = default)`
`517`	`517`	`{`
`518`	`518`	`var request = new SetRequest { SessionId = _sessionId, Mode = mode };`
`519`	`519`	`return await CopilotClient.InvokeRpcAsync<SessionModeSetResult>(_rpc, "session.mode.set", [request], cancellationToken);`
Original file line number	Diff line number	Diff line change
`@@ -697,7 +697,7 @@ function emitSessionApiClass(className: string, node: Record<string, unknown>, c`
`697`	`697`
`698`	`698`	`for (const [pName, pSchema] of paramEntries) {`
`699`	`699`	`if (typeof pSchema !== "object") continue;`
`700`		`- const csType = schemaTypeToCSharp(pSchema as JSONSchema7, requiredSet.has(pName), rpcKnownTypes);`
	`700`	`+ const csType = resolveRpcType(pSchema as JSONSchema7, requiredSet.has(pName), requestClassName, toPascalCase(pName), classes);`
`701`	`701`	sigParams.push(`${csType} ${pName}`);
`702`	`702`	bodyAssignments.push(`${toPascalCase(pName)} = ${pName}`);
`703`	`703`	`}`