feat: Add livequery support

Parse.Tests/ClientTests.cs

@@ -0,0 +1,71 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Infrastructure;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class ClientTests
+{
+    [TestMethod]
+    public void TestParseClientConstructor()
+    {
+        ParseClient client = new("appId", "https://parse.example.com/", "dotnetKey");
+        Assert.AreEqual("appId", client.ServerConnectionData.ApplicationID);
+        Assert.AreEqual("https://parse.example.com/", client.ServerConnectionData.ServerURI);
+        Assert.AreEqual("dotnetKey", client.ServerConnectionData.Key);
+    }
+
+    [TestMethod]
+    public void TestParseClientLiveQueryConstructor()
+    {
+        ServerConnectionData serverConnectionData = new()
+        { 
+            ApplicationID = "appId", 
+            ServerURI = "https://parse.example.com/",
+            Key = "dotnetKey" 
+        };
+
+        LiveQueryServerConnectionData liveQueryServerConnectionData = new()
+        { 
+            ApplicationID = "appId", 
+            ServerURI = "https://parse.example.com/", 
+            Key = "dotnetKey" 
+        };
+
+        ParseClient client = new(serverConnectionData, liveQueryServerConnectionData);
+        Assert.AreEqual("appId", client.ServerConnectionData.ApplicationID);
+        Assert.AreEqual("https://parse.example.com/", client.ServerConnectionData.ServerURI);
+        Assert.AreEqual("dotnetKey", client.ServerConnectionData.Key);
+
+        Assert.AreEqual("appId", client.LiveQueryServerConnectionData.ApplicationID);
+        Assert.AreEqual("https://parse.example.com/", client.LiveQueryServerConnectionData.ServerURI);
+        Assert.AreEqual("dotnetKey", client.LiveQueryServerConnectionData.Key);
+    }
+
+    [TestMethod]
+    public void TestPublicize()
+    {
+        ParseClient previous = ParseClient.Instance;
+        ParseClient client = new("appId", "https://parse.example.com/", "dotnetKey");
+        try {
+            client.Publicize();
+            Assert.AreSame(client, ParseClient.Instance);
+        } finally {
+            previous?.Publicize();
+        }
+    }
+
+    [TestMethod]
+    public void TestConstructorWithTestTrue()
+    {
+        ServerConnectionData data = new()
+        { 
+            ApplicationID = "appId", 
+            ServerURI = "https://parse.example.com/", 
+            Key = "key", 
+            Test = true 
+        };
+        ParseClient client = new(data);
+        Assert.AreEqual("https://parse.example.com/", client.ServerConnectionData.ServerURI);
+    }
+}

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/InfrastructureTests.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Infrastructure.Utilities;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class InfrastructureTests
+{
+    [TestMethod]
+    public void TestFlexibleDictionaryWrapper()
+    {
+        // Arrange
+        Dictionary<string, int> inner = new()
+        {
+            { "char", 1 },
+            { "string", 594 }
+        };
+        FlexibleDictionaryWrapper<int, int> wrapper = new(inner);
+
+        // Act & Assert
+        Assert.AreEqual<int>(1, wrapper["char"]);
+        Assert.AreEqual<int>(594, wrapper["string"]);
+
+        wrapper["new"] = 615;
+        Assert.AreEqual<int>(615, inner["new"]);
+    }
+
+    [TestMethod]
+    public void TestFlexibleListWrapper()
+    {
+        // Arrange
+        List<object> inner = [1, 6.7f];
+        FlexibleListWrapper<int, object> wrapper = new(inner);
+
+        // Act & Assert
+        Assert.AreEqual(1, wrapper[0]);
+        Assert.AreEqual(7, wrapper[1]);
+
+        wrapper.Add(2);
+        Assert.AreEqual(2, inner[2]);
+    }
+
+    [TestMethod]
+    public void TestConversion()
+    {
+        // Test basic conversions
+        Assert.AreEqual(123, Conversion.ConvertTo<int>("123"));
+        Assert.AreEqual(123L, Conversion.ConvertTo<long>(123));
+        Assert.AreEqual(123.45, (double)Conversion.ConvertTo<double>("123.45"), 1e-10);
+    }
+
+    [TestMethod]
+    public void TestGetOrDefault()
+    {
+        Dictionary<string, string> dict = new Dictionary<string, string> { { "key", "value" } };
+        Assert.AreEqual("value", dict.GetOrDefault("key", "default"));
+        Assert.AreEqual("default", dict.GetOrDefault("missing", "default"));
+    }
+
+    [TestMethod]
+    public void TestCollectionsEqual()
+    {
+        List<int> list1 = [1, 2, 3];
+        List<int> list2 = [1, 2, 3];
+        List<int> list3 = [1, 2, 4];
+
+        Assert.IsTrue(list1.CollectionsEqual(list2));
+        Assert.IsFalse(list1.CollectionsEqual(list3));
+        Assert.IsFalse(list1.CollectionsEqual(null));
+        Assert.IsTrue(((List<int>)null).CollectionsEqual(null));
+    }
+}

Parse.Tests/LiveQueryControllerTests.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Moq;
+using Parse.Abstractions.Infrastructure.Execution;
+using Parse.Abstractions.Platform.LiveQueries;
+using Parse.Platform.LiveQueries;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Reflection;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryControllerTests
+{
+    private readonly Mock<IWebSocketClient> _webSocketClientMock;
+    private readonly Mock<IParseLiveQueryMessageParser> _messageParserMock;
+    private readonly Mock<IParseLiveQueryMessageBuilder> _messageBuilderMock;
+    private readonly TimeSpan _timeout = TimeSpan.FromSeconds(1);
+
+    public LiveQueryControllerTests()
+    {
+        _webSocketClientMock = new Mock<IWebSocketClient>();
+        _messageParserMock = new Mock<IParseLiveQueryMessageParser>();
+        _messageBuilderMock = new Mock<IParseLiveQueryMessageBuilder>();
+    }
+
+    [TestMethod]
+    public void ProcessMessage_UnknownOperation_DoesNotThrow()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        Dictionary<string, object> message = new Dictionary<string, object> { { "op", "unknown" } };
+        MethodInfo processMessage = controller.GetType().GetMethod("ProcessMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+        processMessage.Invoke(controller, new object[] { message });
+        // No exception expected
+    }
+
+    [TestMethod]
+    public void ProcessMessage_MissingOp_DoesNotThrow()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        Dictionary<string, object> message = new Dictionary<string, object>();
+        MethodInfo processMessage = controller.GetType().GetMethod("ProcessMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+        processMessage.Invoke(controller, new object[] { message });
+        // No exception expected
+    }
+
+    [TestMethod]
+    public void ProcessConnectionMessage_SetsStateConnected()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        _messageParserMock.Setup(m => m.GetClientId(It.IsAny<IDictionary<string, object>>())).Returns("clientId");
+        Dictionary<string, object> message = new Dictionary<string, object> { { "op", "connected" } };
+        MethodInfo processConnectionMessage = controller.GetType().GetMethod("ProcessConnectionMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+        processConnectionMessage.Invoke(controller, new object[] { message });
+        Assert.AreEqual(ParseLiveQueryController.ParseLiveQueryState.Connected, controller.State);
+    }
+
+    [TestMethod]
+    public void ProcessErrorMessage_RaisesErrorEvent()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        IParseLiveQueryMessageParser.LiveQueryError error = new IParseLiveQueryMessageParser.LiveQueryError { Code = 99, Message = "err", Reconnect = false };
+        _messageParserMock.Setup(m => m.GetError(It.IsAny<IDictionary<string, object>>())).Returns(error);
+        bool raised = false;
+        controller.Error += (s, e) => { raised = true; Assert.AreEqual(99, e.Code); };
+        MethodInfo processErrorMessage = controller.GetType().GetMethod("ProcessErrorMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+        processErrorMessage.Invoke(controller, new object[] { new Dictionary<string, object>() });
+        Assert.IsTrue(raised);
+    }
+
+    [TestMethod]
+    public void Constructor_InitializesStateToClosed()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        Assert.AreEqual(ParseLiveQueryController.ParseLiveQueryState.Closed, controller.State);
+    }
+
+    [TestMethod]
+    public async Task ConnectAsync_ThrowsIfDisposed()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        controller.Dispose();
+        await Assert.ThrowsAsync<ObjectDisposedException>(() => controller.ConnectAsync());
+    }
+
+    [TestMethod]
+    public async Task DisposeAsync_ClosesConnection()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        _webSocketClientMock.Setup(w => w.CloseAsync(It.IsAny<CancellationToken>())).Returns(Task.CompletedTask).Verifiable();
+        await controller.DisposeAsync();
+        _webSocketClientMock.Verify(w => w.CloseAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [TestMethod]
+    public void Dispose_SetsDisposedFlag()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        controller.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => controller.ConnectAsync().GetAwaiter().GetResult());
+    }
+
+    [TestMethod]
+    public void Error_Event_Is_Raised_On_Error_Message()
+    {
+        ParseLiveQueryController controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        IParseLiveQueryMessageParser.LiveQueryError error = new IParseLiveQueryMessageParser.LiveQueryError { Code = 42, Message = "Test error", Reconnect = true };
+        _messageParserMock.Setup(m => m.GetError(It.IsAny<IDictionary<string, object>>())).Returns(error);
+        bool eventRaised = false;
+        controller.Error += (sender, args) =>
+        {
+            eventRaised = true;
+            Assert.AreEqual(42, args.Code);
+            Assert.AreEqual("Test error", args.Error);
+            Assert.IsTrue(args.Reconnect);
+        };
+        Dictionary<string, object> message = new Dictionary<string, object> { { "op", "error" } };
+        MethodInfo processMessage = controller.GetType().GetMethod("ProcessMessage", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        processMessage.Invoke(controller, new object[] { message });
+        Assert.IsTrue(eventRaised);
+    }
+
+    [TestMethod]
+    public void ValidateClientMessage_ReturnsFalse_WhenClientIdMissing()
+    {
+        var controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        MethodInfo validate = controller.GetType().GetMethod("ValidateClientMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        _messageParserMock.Setup(m => m.GetClientId(It.IsAny<IDictionary<string, object>>())).Returns((string)null);
+        _messageParserMock.Setup(m => m.GetRequestId(It.IsAny<IDictionary<string, object>>())).Returns(123);
+
+        var message = new Dictionary<string, object>();
+        object[] args = { message, 0 };
+        bool result = (bool)validate.Invoke(controller, args);
+
+        Assert.IsFalse(result, "Expected validation to fail when client id is null");
+        // requestId should remain default since client id was invalid
+        Assert.AreEqual(0, (int)args[1]);
+    }
+
+    [TestMethod]
+    public void ValidateClientMessage_ReturnsFalse_WhenRequestIdZero()
+    {
+        var controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        MethodInfo validate = controller.GetType().GetMethod("ValidateClientMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        _messageParserMock.Setup(m => m.GetClientId(It.IsAny<IDictionary<string, object>>())).Returns("cid");
+        _messageParserMock.Setup(m => m.GetRequestId(It.IsAny<IDictionary<string, object>>())).Returns(0);
+
+        var message = new Dictionary<string, object>();
+        object[] args = { message, 0 };
+        bool result = (bool)validate.Invoke(controller, args);
+
+        Assert.IsFalse(result, "Expected validation to fail when request id is zero");
+        Assert.AreEqual(0, (int)args[1]);
+    }
+
+    [TestMethod]
+    public void ValidateClientMessage_ReturnsTrue_AndSetsFields_WhenValid()
+    {
+        var controller = new ParseLiveQueryController(_timeout, _webSocketClientMock.Object, _messageParserMock.Object, _messageBuilderMock.Object);
+        MethodInfo validate = controller.GetType().GetMethod("ValidateClientMessage", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        _messageParserMock.Setup(m => m.GetClientId(It.IsAny<IDictionary<string, object>>())).Returns("cid");
+        _messageParserMock.Setup(m => m.GetRequestId(It.IsAny<IDictionary<string, object>>())).Returns(999);
+
+        var message = new Dictionary<string, object>();
+        object[] args = { message, 0 };
+        bool result = (bool)validate.Invoke(controller, args);
+
+        Assert.IsTrue(result, "Expected validation to succeed with valid client id and request id");
+        Assert.AreEqual(999, (int)args[1]);
+
+        // verify controller's internal ClientId property was set appropriately
+        PropertyInfo clientIdProp = controller.GetType().GetProperty("ClientId", BindingFlags.NonPublic | BindingFlags.Instance);
+        Assert.AreEqual("cid", clientIdProp.GetValue(controller));
+    }
+}