feat: Add livequery support

Parse.Tests/DecoderTests.cs

@@ -12,6 +12,11 @@ public class DecoderTests
 {
     ParseClient Client { get; } = new ParseClient(new ServerConnectionData { Test = true });
 
+    public DecoderTests()
+    {
+        Client.Publicize();
+    }
+
     [TestMethod]
     public void TestParseDate()
     {

Parse.Tests/EncoderTests.cs

@@ -28,6 +28,11 @@ class ParseEncoderTestClass : ParseDataEncoder
         protected override IDictionary<string, object> EncodeObject(ParseObject value) => null;
     }
 
+    public EncoderTests()
+    {
+        Client.Publicize();
+    }
+
     [TestMethod]
     public void TestIsValidType()
     {

Parse.Tests/LiveQueryDualEventArgsTests.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Abstractions.Platform.Objects;
+using Parse.Infrastructure;
+using Parse.Platform.LiveQueries;
+using Parse.Platform.Objects;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryDualEventArgsTests
+{
+    private ParseClient Client { get; } = new ParseClient(new ServerConnectionData { Test = true });
+
+    public LiveQueryDualEventArgsTests()
+    { 
+        Client.Publicize();
+    }
+
+    [TestMethod]
+    public void TestConstructor()
+    {
+        IObjectState state = new MutableObjectState
+        {
+            ObjectId = "waGiManPutr4Pet1r",
+            ClassName = "Pagi",
+            CreatedAt = new DateTime { },
+            ServerData = new Dictionary<string, object>
+            {
+                ["username"] = "kevin",
+                ["sessionToken"] = "se551onT0k3n"
+            }
+        };
+
+        ParseObject obj = Client.GenerateObjectFromState<ParseObject>(state, "Corgi");
+        obj.Set("test", "after");
+        ParseObject objOrig = Client.GenerateObjectFromState<ParseObject>(state, "Corgi");
+        objOrig.Set("test", "before");
+        ParseLiveQueryDualEventArgs args = new ParseLiveQueryDualEventArgs(obj, objOrig);
+
+        Assert.AreSame(obj, args.Object);
+        Assert.AreSame(objOrig, args.Original);
+    }
+
+    [TestMethod]
+    public void TestCurrent()
+    {
+        IObjectState state = new MutableObjectState
+        {
+            ObjectId = "waGiManPutr4Pet1r",
+            ClassName = "Pagi",
+            CreatedAt = new DateTime { },
+            ServerData = new Dictionary<string, object>
+            {
+                ["username"] = "kevin",
+                ["sessionToken"] = "se551onT0k3n"
+            }
+        };
+
+        ParseObject objOrig = Client.GenerateObjectFromState<ParseObject>(state, "Corgi");
+        Assert.ThrowsExactly<ArgumentNullException>(() => new ParseLiveQueryDualEventArgs(null, objOrig));
+    }
+
+    [TestMethod]
+    public void TestConstructorExceptionOriginal()
+    {
+        IObjectState state = new MutableObjectState
+        {
+            ObjectId = "waGiManPutr4Pet1r",
+            ClassName = "Pagi",
+            CreatedAt = new DateTime { },
+            ServerData = new Dictionary<string, object>
+            {
+                ["username"] = "kevin",
+                ["sessionToken"] = "se551onT0k3n"
+            }
+        };
+
+        ParseObject obj = Client.GenerateObjectFromState<ParseObject>(state, "Corgi");
+        Assert.ThrowsExactly<ArgumentNullException>(() => new ParseLiveQueryDualEventArgs(obj, null));
+    }
+}

Parse.Tests/LiveQueryErrorEventArgsTests.cs

@@ -0,0 +1,34 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Platform.LiveQueries;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryErrorEventArgsTests
+{
+    [TestMethod]
+    public void TestConstructor()
+    {
+        InvalidOperationException exception = new InvalidOperationException("Test exception");
+        ParseLiveQueryErrorEventArgs args = new ParseLiveQueryErrorEventArgs(42, "Test error", false, exception);
+
+        // Assert
+        Assert.AreEqual(42, args.Code);
+        Assert.AreEqual("Test error", args.Error);
+        Assert.AreEqual(false, args.Reconnect);
+        Assert.AreEqual(exception, args.LocalException);
+    }
+
+    [TestMethod]
+    public void TestConstructorWithoutException()
+    {
+        ParseLiveQueryErrorEventArgs args = new ParseLiveQueryErrorEventArgs(42, "Test error", true);
+
+        // Assert
+        Assert.AreEqual(42, args.Code);
+        Assert.AreEqual("Test error", args.Error);
+        Assert.AreEqual(true, args.Reconnect);
+        Assert.AreEqual(null, args.LocalException);
+    }
+}

Parse.Tests/LiveQueryEventArgsTests.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Abstractions.Platform.Objects;
+using Parse.Infrastructure;
+using Parse.Platform.LiveQueries;
+using Parse.Platform.Objects;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryEventArgsTests
+{
+    private ParseClient Client { get; } = new ParseClient(new ServerConnectionData { Test = true });
+
+    public LiveQueryEventArgsTests()
+    {
+        Client.Publicize();
+    }
+
+    [TestMethod]
+    public void TestConstructor()
+    {
+        IObjectState state = new MutableObjectState
+        {
+            ObjectId = "waGiManPutr4Pet1r",
+            ClassName = "Pagi",
+            CreatedAt = new DateTime { },
+            ServerData = new Dictionary<string, object>
+            {
+                ["username"] = "kevin",
+                ["sessionToken"] = "se551onT0k3n"
+            }
+        };
+
+        ParseObject obj = Client.GenerateObjectFromState<ParseObject>(state, "Corgi");
+        ParseLiveQueryEventArgs args = new ParseLiveQueryEventArgs(obj);
+
+        // Assert
+        Assert.AreEqual(obj, args.Object);
+    }
+
+    [TestMethod]
+    public void TestConstructorException()
+        => Assert.ThrowsExactly<ArgumentNullException>(() => new ParseLiveQueryEventArgs(null));
+}

Parse.Tests/LiveQueryMessageBuilderTests.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Parse.Abstractions.Infrastructure;
+using Parse.Abstractions.Platform.Users;
+using Parse.Infrastructure;
+using Parse.Platform.LiveQueries;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryMessageBuilderTests
+{
+    private readonly Mock<IParseCurrentUserController> _mockCurrentUserController;
+    private readonly MutableServiceHub _hub;
+
+    private ParseClient Client { get; }
+
+    public LiveQueryMessageBuilderTests()
+    {
+        _mockCurrentUserController = new Mock<IParseCurrentUserController>();
+
+        _mockCurrentUserController
+            .Setup(controller => controller.GetCurrentSessionTokenAsync(It.IsAny<IServiceHub>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync("s3ss!0nT0k3n");
+
+        _hub = new MutableServiceHub { CurrentUserController = _mockCurrentUserController.Object };
+
+        Client = new ParseClient(
+            new ServerConnectionData { Test = true },
+            new LiveQueryServerConnectionData { ApplicationID = "TestApp", Key = "t3stK3y", Test = true },
+            _hub);
+
+        Client.Publicize();
+    }
+
+    [TestMethod]
+    public async Task TestBuildConnectMessage()
+    {
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+        IDictionary<string, object> message = await builder.BuildConnectMessage();
+
+        Assert.IsNotNull(message);
+        Assert.IsTrue(message.ContainsKey("op"));
+        Assert.IsTrue(message.ContainsKey("applicationId"));
+        Assert.IsTrue(message.ContainsKey("windowsKey"));
+        Assert.IsTrue(message.ContainsKey("sessionToken"));
+        Assert.AreEqual(4, message.Count);
+        Assert.AreEqual("connect", message["op"]);
+        Assert.AreEqual(Client.Services.LiveQueryServerConnectionData.ApplicationID, message["applicationId"]);
+        Assert.AreEqual(Client.Services.LiveQueryServerConnectionData.Key, message["windowsKey"]);
+        Assert.AreEqual(await Client.Services.GetCurrentSessionToken(), message["sessionToken"]);
+    }
+
+    [TestMethod]
+    public void TestBuildUnsubscribeMessage()
+    {
+        int requestId = 2;
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+        IDictionary<string, object> message = builder.BuildUnsubscribeMessage(requestId);
+
+        Assert.IsNotNull(message);
+        Assert.IsTrue(message.ContainsKey("op"));
+        Assert.IsTrue(message.ContainsKey("requestId"));
+        Assert.AreEqual(2, message.Count);
+        Assert.AreEqual("unsubscribe", message["op"]);
+        Assert.AreEqual(requestId, message["requestId"]);
+
+        Assert.ThrowsException<ArgumentOutOfRangeException>(() => builder.BuildUnsubscribeMessage(0));
+    }
+
+    private void ValidateSubscriptionMessage(IDictionary<string, object> message, string expectedOp, int requestId)
+    {
+        Assert.IsNotNull(message);
+        Assert.AreEqual(4, message.Count);
+
+        Assert.IsTrue(message.ContainsKey("op"));
+        Assert.AreEqual(expectedOp, message["op"]);
+
+        Assert.IsTrue(message.ContainsKey("requestId"));
+        Assert.AreEqual(requestId, message["requestId"]);
+
+        Assert.IsTrue(message.ContainsKey("query"));
+        Assert.IsInstanceOfType(message["query"], typeof(IDictionary<string, object>), "The 'query' value should be a Dictionary<string, object>.");
+        Assert.AreEqual(4, ((IDictionary<string, object>) message["query"]).Count);
+        IDictionary<string, object> query = message["query"] as IDictionary<string, object>;
+
+        Assert.IsTrue(query.ContainsKey("className"), "The 'query' dictionary should contain the 'className' key.");
+        Assert.AreEqual("DummyClass", query["className"], "The 'className' property should be 'DummyClass'.");
+
+        Assert.IsTrue(query.ContainsKey("where"), "The 'query' dictionary should contain the 'where' key.");
+        Assert.IsInstanceOfType(query["where"], typeof(IDictionary<string, object>), "The 'where' property should be a Dictionary<string, object>.");
+        IDictionary<string, object> where = (IDictionary<string, object>) query["where"];
+        Assert.AreEqual(1, where.Count, "The 'where' dictionary should contain exactly one key-value pair.");
+        Assert.IsTrue(where.ContainsKey("foo"), "The 'where' dictionary should contain the 'foo' key.");
+        Assert.AreEqual("bar", where["foo"], "The 'foo' property in 'where' should be 'bar'.");
+
+        Assert.IsTrue(query.ContainsKey("keys"), "The 'query' dictionary should contain the 'keys' key.");
+        Assert.IsInstanceOfType(query["keys"], typeof(string[]), "The 'keys' property should be a string array.");
+        Assert.AreEqual(1, ((string[]) query["keys"]).Length, "The 'keys' array should contain exactly one element.");
+        Assert.AreEqual("foo", ((string[]) query["keys"])[0], "The 'keys' parameter should contain 'foo'.");
+
+        Assert.IsTrue(query.ContainsKey("watch"), "The 'query' dictionary should contain the 'watch' key.");
+        Assert.IsInstanceOfType(query["watch"], typeof(string[]), "The 'watch' property should be a string array.");
+        Assert.AreEqual(1, ((string[]) query["watch"]).Length, "The 'watch' array should contain exactly one element.");
+        Assert.AreEqual("foo", ((string[]) query["watch"])[0], "The 'watch' parameter should contain 'foo'.");
+
+    }
+
+    [TestMethod]
+    public async Task TestBuildSubscribeMessage()
+    {
+        int requestId = 2;
+        ParseLiveQuery<ParseObject> liveQuery = new ParseLiveQuery<ParseObject>(
+            Client.Services,
+            "DummyClass",
+            new Dictionary<string, object> { { "foo", "bar" } },
+            new[] { "foo" },
+            new[] { "foo" });
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+        IDictionary<string, object> message = await builder.BuildSubscribeMessage<ParseObject>(requestId, liveQuery);
+
+        ValidateSubscriptionMessage(message, "subscribe", requestId);
+
+        await Assert.ThrowsExceptionAsync<ArgumentOutOfRangeException>(async () => await builder.BuildSubscribeMessage<ParseObject>(0, liveQuery));
+        await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => await builder.BuildSubscribeMessage<ParseObject>(requestId, null));
+    }
+
+    [TestMethod]
+    public async Task TestBuildUpdateSubscriptionMessage()
+    {
+        int requestId = 2;
+        ParseLiveQuery<ParseObject> liveQuery = new ParseLiveQuery<ParseObject>(
+            Client.Services,
+            "DummyClass",
+            new Dictionary<string, object> { { "foo", "bar" } },
+            new[] { "foo" },
+            new[] { "foo" });
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+        IDictionary<string, object> message = await builder.BuildUpdateSubscriptionMessage<ParseObject>(requestId, liveQuery);
+
+        ValidateSubscriptionMessage(message, "update", requestId);
+
+        await Assert.ThrowsExceptionAsync<ArgumentOutOfRangeException>(async () => await builder.BuildUpdateSubscriptionMessage<ParseObject>(0, liveQuery));
+        await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => await builder.BuildUpdateSubscriptionMessage<ParseObject>(requestId, null));
+    }
+}