SDK Update: uri encoded query params

🌿 Fern Regeneration -- July 31, 2025

Author: niteshsandal-merge

src/Merge.Client.Test/Core/Pagination/StringCursorTest.cs

@@ -10,6 +10,7 @@ public class StringCursorTest
     private const string? Cursor1 = null;
     private const string Cursor2 = "cursor2";
     private const string Cursor3 = "cursor3";
+    private const string Cursor4 = "";
 
     [Test]
     public async SystemTask CursorPagerShouldWorkWithStringCursor()
@@ -80,6 +81,69 @@ public async SystemTask CursorPagerShouldWorkWithStringCursor()
         Assert.That(await pageEnumerator.MoveNextAsync(), Is.False);
     }
 
+    [Test]
+    public async SystemTask CursorPagerShouldWorkWithStringCursor_EmptyStringCursor()
+    {
+        var responses = new List<Response>
+        {
+            new()
+            {
+                Data = new Data { Items = ["item1", "item2"] },
+                Cursor = new Cursor { Next = Cursor2 },
+            },
+            new()
+            {
+                Data = new Data { Items = ["item1"] },
+                Cursor = new Cursor { Next = Cursor4 },
+            },
+            new()
+            {
+                Data = new Data { Items = ["item2"] },
+                Cursor = new Cursor { Next = Cursor3 },
+            },
+        }.GetEnumerator();
+        var cursorCopy = Cursor1;
+        Pager<object> pager = await CursorPager<
+            Request,
+            object?,
+            Response,
+            string,
+            object
+        >.CreateInstanceAsync(
+            new Request { Cursor = Cursor1 },
+            null,
+            (_, _, _) =>
+            {
+                responses.MoveNext();
+                return SystemTask.FromResult(responses.Current);
+            },
+            (request, cursor) =>
+            {
+                request.Cursor = cursor;
+                cursorCopy = cursor;
+            },
+            response => response?.Cursor?.Next,
+            response => response?.Data?.Items?.ToList()
+        );
+
+        var pageEnumerator = pager.AsPagesAsync().GetAsyncEnumerator();
+
+        // first page
+        Assert.That(await pageEnumerator.MoveNextAsync(), Is.True);
+        var page = pageEnumerator.Current;
+        Assert.That(page.Items, Has.Count.EqualTo(2));
+        Assert.That(cursorCopy, Is.EqualTo(Cursor2));
+
+        // second page (cursor is empty string)
+        Assert.That(await pageEnumerator.MoveNextAsync(), Is.True);
+        page = pageEnumerator.Current;
+        Assert.That(page.Items, Has.Count.EqualTo(1));
+        Assert.That(cursorCopy, Is.EqualTo(Cursor4));
+
+        // no more (should not reach third response)
+        Assert.That(await pageEnumerator.MoveNextAsync(), Is.False);
+    }
+
     private class Request
     {
         public required string? Cursor { get; set; }

src/Merge.Client.Test/Core/RawClientTests/QueryParameterTests.cs

@@ -0,0 +1,63 @@
+using Merge.Client.Core;
+using NUnit.Framework;
+using WireMock.Matchers;
+using WireMock.Server;
+using SystemTask = global::System.Threading.Tasks.Task;
+using WireMockRequest = WireMock.RequestBuilders.Request;
+using WireMockResponse = WireMock.ResponseBuilders.Response;
+
+namespace Merge.Client.Test.Core.RawClientTests;
+
+[TestFixture]
+[Parallelizable(ParallelScope.Self)]
+public class QueryParameterTests
+{
+    private WireMockServer _server;
+    private HttpClient _httpClient;
+    private RawClient _rawClient;
+    private string _baseUrl;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _server = WireMockServer.Start();
+        _baseUrl = _server.Url ?? "";
+        _httpClient = new HttpClient { BaseAddress = new Uri(_baseUrl) };
+        _rawClient = new RawClient(new ClientOptions { HttpClient = _httpClient });
+    }
+
+    [Test]
+    public void CreateRequest_QueryParametersEscaping()
+    {
+        _server
+            .Given(WireMockRequest.Create().WithPath("/test").WithParam("foo", "bar").UsingGet())
+            .RespondWith(WireMockResponse.Create().WithStatusCode(200).WithBody("Success"));
+
+        var request = new JsonRequest()
+        {
+            BaseUrl = _baseUrl,
+            Method = HttpMethod.Get,
+            Path = "/test",
+            Query = new Dictionary<string, object>
+            {
+                { "sample", "value" },
+                { "email", "[email protected]" },
+                { "%Complete", "100" },
+            },
+            Options = new RequestOptions(),
+        };
+
+        var url = _rawClient.CreateHttpRequest(request).RequestUri!.AbsoluteUri;
+
+        Assert.That(url, Does.Contain("sample=value"));
+        Assert.That(url, Does.Contain("email=bob%2Btest%40example.com"));
+        Assert.That(url, Does.Contain("%25Complete=100"));
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _server.Dispose();
+        _httpClient.Dispose();
+    }
+}

src/Merge.Client.Test/Unit/MockServer/Accounting/CreateTest.cs

@@ -0,0 +1,54 @@
+using global::System.Threading.Tasks;
+using Merge.Client.Accounting;
+using Merge.Client.Core;
+using Merge.Client.Test.Unit.MockServer;
+using NUnit.Framework;
+
+namespace Merge.Client.Test.Unit.MockServer.Accounting;
+
+[TestFixture]
+public class CreateTest : BaseMockServerTest
+{
+    [Test]
+    public async global::System.Threading.Tasks.Task MockServerTest()
+    {
+        const string requestJson = """
+            {
+              "event": "event",
+              "is_active": true
+            }
+            """;
+
+        const string mockResponse = """
+            {
+              "event": "event",
+              "is_active": true,
+              "key": "key"
+            }
+            """;
+
+        Server
+            .Given(
+                WireMock
+                    .RequestBuilders.Request.Create()
+                    .WithPath("/accounting/v1/webhook-receivers")
+                    .WithHeader("Content-Type", "application/json")
+                    .UsingPost()
+                    .WithBodyAsJson(requestJson)
+            )
+            .RespondWith(
+                WireMock
+                    .ResponseBuilders.Response.Create()
+                    .WithStatusCode(200)
+                    .WithBody(mockResponse)
+            );
+
+        var response = await Client.Accounting.WebhookReceivers.CreateAsync(
+            new WebhookReceiverRequest { Event = "event", IsActive = true }
+        );
+        Assert.That(
+            response,
+            Is.EqualTo(JsonUtils.Deserialize<WebhookReceiver>(mockResponse)).UsingDefaults()
+        );
+    }
+}

src/Merge.Client.Test/Unit/MockServer/Accounting/DefaultScopesRetrieveTest.cs

@@ -0,0 +1,73 @@
+using global::System.Threading.Tasks;
+using Merge.Client.Accounting;
+using Merge.Client.Core;
+using Merge.Client.Test.Unit.MockServer;
+using NUnit.Framework;
+
+namespace Merge.Client.Test.Unit.MockServer.Accounting;
+
+[TestFixture]
+public class DefaultScopesRetrieveTest : BaseMockServerTest
+{
+    [Test]
+    public async global::System.Threading.Tasks.Task MockServerTest()
+    {
+        const string mockResponse = """
+            {
+              "common_models": [
+                {
+                  "model_name": "Employee",
+                  "model_permissions": {
+                    "READ": {
+                      "is_enabled": true
+                    },
+                    "WRITE": {
+                      "is_enabled": false
+                    }
+                  },
+                  "field_permissions": {
+                    "enabled_fields": [
+                      "avatar",
+                      "created_at",
+                      "custom_fields",
+                      "date_of_birth",
+                      "first_name",
+                      "gender",
+                      "remote_created_at",
+                      "remote_data"
+                    ],
+                    "disabled_fields": [
+                      "company",
+                      "employments",
+                      "groups",
+                      "home_location",
+                      "manager",
+                      "work_location"
+                    ]
+                  }
+                }
+              ]
+            }
+            """;
+
+        Server
+            .Given(
+                WireMock
+                    .RequestBuilders.Request.Create()
+                    .WithPath("/accounting/v1/default-scopes")
+                    .UsingGet()
+            )
+            .RespondWith(
+                WireMock
+                    .ResponseBuilders.Response.Create()
+                    .WithStatusCode(200)
+                    .WithBody(mockResponse)
+            );
+
+        var response = await Client.Accounting.Scopes.DefaultScopesRetrieveAsync();
+        Assert.That(
+            response,
+            Is.EqualTo(JsonUtils.Deserialize<CommonModelScopeApi>(mockResponse)).UsingDefaults()
+        );
+    }
+}

src/Merge.Client.Test/Unit/MockServer/Accounting/DeleteTest.cs

@@ -0,0 +1,23 @@
+using Merge.Client.Test.Unit.MockServer;
+using NUnit.Framework;
+
+namespace Merge.Client.Test.Unit.MockServer.Accounting;
+
+[TestFixture]
+public class DeleteTest : BaseMockServerTest
+{
+    [Test]
+    public void MockServerTest()
+    {
+        Server
+            .Given(
+                WireMock
+                    .RequestBuilders.Request.Create()
+                    .WithPath("/accounting/v1/delete-account")
+                    .UsingPost()
+            )
+            .RespondWith(WireMock.ResponseBuilders.Response.Create().WithStatusCode(200));
+
+        Assert.DoesNotThrowAsync(async () => await Client.Accounting.DeleteAccount.DeleteAsync());
+    }
+}