feat: Add livequery support

Parse.Tests/ClientTests.cs

@@ -0,0 +1,45 @@
+using System;
+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 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/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));
+}