Add live query and live query event arg tests

Author: theSlyest

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 TestParseLiveQueryErrorEventArgsConstructor()
+    {
+        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 TestParseLiveQueryErrorEventArgsConstructor()
+    {
+        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 Clean() => (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/Platform/LiveQueries/ParseLiveQueryErrorEventArgs.cs

@@ -39,6 +39,14 @@ public class ParseLiveQueryErrorEventArgs : EventArgs
     /// </remarks>
     public bool Reconnect { get; }
 
+    /// <summary>
+    /// Gets the local exception that occurred during a live query operation, if any.
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="LocalException"/> property contains the exception instance that was thrown locally,
+    /// providing additional context or details about the error that occurred during the live query operation.
+    /// This property may be <c>null</c> if no local exception was thrown.
+    /// </remarks>
     public Exception LocalException { get; }
 
     /// <summary>

Parse/Platform/Queries/ParseQuery.cs

@@ -920,7 +920,7 @@ public override int GetHashCode()
     public ParseLiveQuery<T> GetLive()
     {
         ArgumentNullException.ThrowIfNull(Filters);
-        IDictionary<string, object> filters = BuildParameters().TryGetValue("where", out object where) ? where as IDictionary<string, object> : null;
+        IDictionary<string, object> filters = PointerOrLocalIdEncoder.Instance.Encode(Filters, Services) as IDictionary<string, object>;
         return new ParseLiveQuery<T>(Services, ClassName, filters, KeySelections);
     }
 }