feat: Add livequery support

Parse.Tests/EncoderTests.cs

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

Parse.Tests/LiveQueryDualEventArgsTests.cs

@@ -0,0 +1,51 @@
+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; set; }
+
+    [TestInitialize]
+    public void SetUp()
+    {
+        // Initialize the client and ensure the instance is set
+        Client = new ParseClient(new ServerConnectionData { Test = true });
+        Client.Publicize();
+    }
+
+    [TestCleanup]
+    public void TearDown() => (Client.Services as ServiceHub).Reset();
+
+    [TestMethod]
+    public void TestParseLiveQueryDualEventArgsConstructor()
+    {
+        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.AreEqual(obj, args.Object);
+        Assert.AreEqual(objOrig, args.Original);
+    }
+}

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 TestParseLiveQueryErrorEventArgsConstructor()
+    {
+        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 TestParseLiveQueryErrorEventArgsConstructorWithoutException()
+    {
+        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,48 @@
+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; set; }
+
+    [TestInitialize]
+    public void SetUp()
+    {
+        // Initialize the client and ensure the instance is set
+        Client = new ParseClient(new ServerConnectionData { Test = true });
+        Client.Publicize();
+    }
+
+    [TestCleanup]
+    public void TearDown() => (Client.Services as ServiceHub).Reset();
+
+    [TestMethod]
+    public void TestParseLiveQueryEventArgsConstructor()
+    {
+        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);
+    }
+}

Parse.Tests/LiveQueryTests.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Infrastructure;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryTests
+{
+    public class DummyParseObject : ParseObject { }
+
+    private ParseClient Client { get; set; }
+
+    [TestInitialize]
+    public void SetUp()
+    {
+        // Initialize the client and ensure the instance is set
+        Client = new ParseClient(new ServerConnectionData { Test = true }, new LiveQueryServerConnectionData { Test = true });
+        Client.Publicize();
+    }
+
+    [TestCleanup]
+    public void TearDown() => (Client.Services as ServiceHub).Reset();
+
+    [TestMethod]
+    public void TestConstructor()
+    {
+        ParseLiveQuery<ParseObject> liveQuery = new ParseLiveQuery<ParseObject>(
+            Client.Services,
+            "DummyClass",
+            new Dictionary<string, object> { { "foo", "bar" } },
+            ["foo"]);
+
+        // Assert
+        Assert.AreEqual("DummyClass", liveQuery.ClassName, "The ClassName property of liveQuery should be 'DummyClass'.");
+        IDictionary<string, object> buildParameters = liveQuery.BuildParameters();
+        Assert.AreEqual("DummyClass", buildParameters["className"], "The ClassName property of liveQuery should be 'DummyClass'.");
+        Assert.IsTrue(buildParameters.ContainsKey("where"), "The 'where' key should be present in the build parameters.");
+        Assert.IsTrue(buildParameters.ContainsKey("keys"), "The 'keys' key should be present in the build parameters.");
+        Assert.IsInstanceOfType<Dictionary<string, object>>(buildParameters["where"], "The 'where' parameter should be a Dictionary<string, object>.");
+        Assert.IsInstanceOfType<string[]>(buildParameters["keys"], "The 'keys' parameter should be a string array.");
+        Assert.AreEqual("bar", ((Dictionary<string, object>)buildParameters["where"])["foo"], "The 'where' clause should match the query condition.");
+        Assert.AreEqual("foo", ((string[])buildParameters["keys"]).First(), "The 'keys' parameter should contain 'foo'.");
+    }
+
+    [TestMethod]
+    public void TestGetLive()
+    {
+        // Arrange
+        ParseQuery<ParseObject> query = Client.GetQuery("DummyClass")
+            .WhereEqualTo("foo", "bar")
+            .Select("foo");
+
+        // Act
+        ParseLiveQuery<ParseObject> liveQuery = query.GetLive()
+            .Watch("foo");
+
+        // Assert
+        Assert.AreEqual("DummyClass", liveQuery.ClassName, "The ClassName property of liveQuery should be 'DummyClass'.");
+        IDictionary<string, object> buildParameters = liveQuery.BuildParameters();
+        Assert.AreEqual("DummyClass", buildParameters["className"], "The ClassName property of liveQuery should be 'DummyClass'.");
+        Assert.IsTrue(buildParameters.ContainsKey("where"), "The 'where' key should be present in the build parameters.");
+        Assert.IsTrue(buildParameters.ContainsKey("keys"), "The 'keys' key should be present in the build parameters.");
+        Assert.IsTrue(buildParameters.ContainsKey("watch"), "The 'watch' key should be present in the build parameters.");
+        Assert.IsInstanceOfType<Dictionary<string, object>>(buildParameters["where"], "The 'where' parameter should be a Dictionary<string, object>.");
+        Assert.IsInstanceOfType<string[]>(buildParameters["keys"], "The 'keys' parameter should be a string array.");
+        Assert.IsInstanceOfType<string[]>(buildParameters["watch"], "The 'watch' parameter should be a string array.");
+        Assert.AreEqual("bar", ((Dictionary<string, object>)buildParameters["where"])["foo"], "The 'where' clause should match the query condition.");
+        Assert.AreEqual("foo", ((string[])buildParameters["keys"]).First(), "The 'keys' parameter should contain 'foo'.");
+        Assert.AreEqual("foo", ((string[])buildParameters["watch"]).First(), "The 'watch' parameter should contain 'foo'.");
+    }
+}

Parse.Tests/RelationTests.cs

@@ -114,7 +114,7 @@ public async Task AddRelationToUserAsync_ThrowsException_WhenUserIsNull()
     public async Task AddRelationToUserAsync_ThrowsException_WhenRelationFieldIsNull()
     {
         var user = new ParseUser() { Username = "TestUser", Password = "TestPass", Services = Client.Services };
-        await user.SignUpAsync();
+
         var relatedObjects = new List<ParseObject>
             {
                     new ParseObject("Friend", Client.Services) { ["name"] = "Friend1" }
@@ -143,7 +143,6 @@ public async Task UpdateUserRelationAsync_ThrowsException_WhenUserIsNull()
     public async Task UpdateUserRelationAsync_ThrowsException_WhenRelationFieldIsNull()
     {
         var user = new ParseUser() { Username = "TestUser", Password = "TestPass", Services = Client.Services };
-        await user.SignUpAsync();
 
         var relatedObjectsToAdd = new List<ParseObject>
             {
@@ -168,8 +167,6 @@ public async Task DeleteUserRelationAsync_ThrowsException_WhenUserIsNull()
     public async Task DeleteUserRelationAsync_ThrowsException_WhenRelationFieldIsNull()
     {
         var user = new ParseUser() { Username = "TestUser", Password = "TestPass", Services = Client.Services };
-        await user.SignUpAsync();
-
         await Assert.ThrowsExceptionAsync<ArgumentException>(() => UserManagement.DeleteUserRelationAsync(user, null));
     }
     [TestMethod]
@@ -183,7 +180,6 @@ public async Task GetUserRelationsAsync_ThrowsException_WhenUserIsNull()
     public async Task GetUserRelationsAsync_ThrowsException_WhenRelationFieldIsNull()
     {
         var user = new ParseUser() { Username = "TestUser", Password = "TestPass", Services = Client.Services };
-        await user.SignUpAsync();
 
         await Assert.ThrowsExceptionAsync<ArgumentException>(() => UserManagement.GetUserRelationsAsync(user, null));
     }
@@ -196,7 +192,6 @@ public async Task AddRelationToUserAsync_ThrowsException_WhenRelatedObjectIsUnsa
     {
         // Arrange: Create and sign up a test user.
         var user = new ParseUser() { Username = "TestUser", Password = "TestPass", Services = Client.Services };
-        await user.SignUpAsync();
 
         // Create an unsaved Friend object (do NOT call SaveAsync).
         var unsavedFriend = new ParseObject("Friend", Client.Services) { ["name"] = "UnsavedFriend" };
@@ -205,6 +200,7 @@ public async Task AddRelationToUserAsync_ThrowsException_WhenRelatedObjectIsUnsa
         // Act & Assert: Expect an exception when trying to add an unsaved object.
         await Assert.ThrowsExceptionAsync<ArgumentException>(() =>
             UserManagement.AddRelationToUserAsync(user, "friends", relatedObjects));
+
     }
 
 

Parse.Tests/UserTests.cs

@@ -165,7 +165,7 @@ public async Task TestLogOut()
         // Mock LogOutAsync to ensure it can execute its logic
         mockCurrentUserController
             .Setup(obj => obj.LogOutAsync(It.IsAny<IServiceHub>(), It.IsAny<CancellationToken>()))
-            .CallBase(); // Use the actual LogOutAsync implementation
+            .Returns(Task.CompletedTask);
 
         // Mock SessionController for session revocation
         var mockSessionController = new Mock<IParseSessionController>();
@@ -182,6 +182,7 @@ public async Task TestLogOut()
 
         // Inject mocks into ParseClient
         var client = new ParseClient(new ServerConnectionData { Test = true }, hub);
+        user.Bind(client);
 
         // Act: Perform logout
         await client.LogOutAsync(CancellationToken.None);

Parse/Abstractions/Infrastructure/CustomServiceHub.cs

@@ -5,6 +5,7 @@
 using Parse.Abstractions.Platform.Configuration;
 using Parse.Abstractions.Platform.Files;
 using Parse.Abstractions.Platform.Installations;
+using Parse.Abstractions.Platform.LiveQueries;
 using Parse.Abstractions.Platform.Objects;
 using Parse.Abstractions.Platform.Push;
 using Parse.Abstractions.Platform.Queries;
@@ -31,6 +32,8 @@ public abstract class CustomServiceHub : ICustomServiceHub
 
     public virtual IParseCommandRunner CommandRunner => Services.CommandRunner;
 
+    public virtual IWebSocketClient WebSocketClient => Services.WebSocketClient;
+
     public virtual IParseCloudCodeController CloudCodeController => Services.CloudCodeController;
 
     public virtual IParseConfigurationController ConfigurationController => Services.ConfigurationController;
@@ -41,6 +44,8 @@ public abstract class CustomServiceHub : ICustomServiceHub
 
     public virtual IParseQueryController QueryController => Services.QueryController;
 
+    public virtual IParseLiveQueryController LiveQueryController => Services.LiveQueryController;
+
     public virtual IParseSessionController SessionController => Services.SessionController;
 
     public virtual IParseUserController UserController => Services.UserController;
@@ -59,6 +64,8 @@ public abstract class CustomServiceHub : ICustomServiceHub
 
     public virtual IServerConnectionData ServerConnectionData => Services.ServerConnectionData;
 
+    public virtual ILiveQueryServerConnectionData LiveQueryServerConnectionData => Services.LiveQueryServerConnectionData;
+
     public virtual IParseDataDecoder Decoder => Services.Decoder;
 
     public virtual IParseInstallationDataFinalizer InstallationDataFinalizer => Services.InstallationDataFinalizer;

Parse/Abstractions/Infrastructure/Execution/IWebSocketClient.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Parse.Infrastructure.Execution;
+
+namespace Parse.Abstractions.Infrastructure.Execution;
+
+/// <summary>
+/// Represents an interface for a WebSocket client to handle WebSocket connections and communications.
+/// </summary>
+public interface IWebSocketClient
+{
+    /// <summary>
+    /// An event that is triggered when a message is received via the WebSocket connection.
+    /// </summary>
+    /// <remarks>
+    /// The event handler receives the message as a string parameter. This can be used to process incoming
+    /// WebSocket messages, such as notifications, commands, or data updates.
+    /// </remarks>
+    public event EventHandler<MessageReceivedEventArgs> MessageReceived;
+
+    /// <summary>
+    /// An event that is triggered when an error occurs during the WebSocket operation.
+    /// </summary>
+    /// <remarks>
+    /// This event communicates WebSocket-specific errors along with additional details encapsulated in
+    /// the <see cref="ErrorEventArgs"/> object. It can be used to handle and log errors during WebSocket
+    /// communication or connection lifecycle.
+    /// </remarks>
+    public event EventHandler<ErrorEventArgs> WebsocketError;
+
+    /// <summary>
+    /// An event that is triggered when an unknown or unexpected error occurs during WebSocket communication.
+    /// </summary>
+    /// <remarks>
+    /// This event can be used to handle errors that do not fall under typical WebSocket error events. The event
+    /// handler receives an <see cref="ErrorEventArgs"/> parameter containing details about the error.
+    /// </remarks>
+    public event EventHandler<ErrorEventArgs> UnknownError;
+
+    /// <summary>
+    /// Establishes a WebSocket connection to the specified server URI.
+    /// </summary>
+    /// <param name="serverUri">The URI of the WebSocket server to connect to.</param>
+    /// <param name="cancellationToken">
+    /// A token to observe cancellation requests. The operation will stop if the token is canceled.
+    /// </param>
+    /// <returns>A task that represents the asynchronous operation of opening the WebSocket connection.</returns>
+    public Task OpenAsync(string serverUri, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Closes the active WebSocket connection asynchronously.
+    /// </summary>
+    /// <param name="cancellationToken">
+    /// A token to observe cancellation requests. The operation will stop if the token is canceled.
+    /// </param>
+    /// <returns>A task that represents the asynchronous operation of closing the WebSocket connection.</returns>
+    public Task CloseAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Sends a message over the established WebSocket connection asynchronously.
+    /// </summary>
+    /// <param name="message">The message to send through the WebSocket connection.</param>
+    /// <param name="cancellationToken">
+    /// A token to observe cancellation requests. The operation will stop if the token is canceled.
+    /// </param>
+    /// <returns>A task that represents the asynchronous operation of sending the message.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when trying to send a message on a WebSocket connection that is not in the Open state.</exception>
+    public Task SendAsync(string message, CancellationToken cancellationToken = default);
+}