Moved responsibilities from ParseLiveQueryController to 2 new classes

Author: theSlyest

Parse.Tests/LiveQueryDualEventArgsTests.cs

@@ -11,19 +11,13 @@ namespace Parse.Tests;
 [TestClass]
 public class LiveQueryDualEventArgsTests
 {
-    private ParseClient Client { get; set; }
+    private ParseClient Client { get; } = new ParseClient(new ServerConnectionData { Test = true });
 
-    [TestInitialize]
-    public void SetUp()
-    {
-        // Initialize the client and ensure the instance is set
-        Client = new ParseClient(new ServerConnectionData { Test = true });
+    public LiveQueryDualEventArgsTests()
+    { 
         Client.Publicize();
     }
 
-    [TestCleanup]
-    public void TearDown() => (Client.Services as ServiceHub).Reset();
-
     [TestMethod]
     public void TestConstructor()
     {
@@ -45,8 +39,8 @@ public void TestConstructor()
         objOrig.Set("test", "before");
         ParseLiveQueryDualEventArgs args = new ParseLiveQueryDualEventArgs(obj, objOrig);
 
-        Assert.AreEqual(obj, args.Object);
-        Assert.AreEqual(objOrig, args.Original);
+        Assert.AreSame(obj, args.Object);
+        Assert.AreSame(objOrig, args.Original);
     }
 
     [TestMethod]

Parse.Tests/LiveQueryEventArgsTests.cs

@@ -11,19 +11,13 @@ namespace Parse.Tests;
 [TestClass]
 public class LiveQueryEventArgsTests
 {
-    private ParseClient Client { get; set; }
+    private ParseClient Client { get; } = new ParseClient(new ServerConnectionData { Test = true });
 
-    [TestInitialize]
-    public void SetUp()
+    public LiveQueryEventArgsTests()
     {
-        // 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 TestConstructor()
     {

Parse.Tests/LiveQueryMessageBuilderTests.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Abstractions.Platform.Objects;
+using Parse.Infrastructure;
+using Parse.Platform.LiveQueries;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryMessageBuilderTests
+{
+    private ParseClient Client { get; } = new ParseClient(
+        new ServerConnectionData { Test = true },
+        new LiveQueryServerConnectionData { ApplicationID = "TestApp", Key = "t3stK3y", Test = true });
+
+    public LiveQueryMessageBuilderTests()
+    {
+        Client.Publicize();
+    }
+
+    [TestMethod]
+    public void TestConstructor()
+    {
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+
+        Assert.IsNotNull(builder, "Builder should not be null after construction.");
+    }
+
+    [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.HasCount(3, message);
+        Assert.AreEqual("connect", message["op"]);
+        Assert.AreEqual(Client.Services.LiveQueryServerConnectionData.ApplicationID, message["applicationId"]);
+        Assert.AreEqual(Client.Services.LiveQueryServerConnectionData.Key, message["windowsKey"]);
+    }
+
+    [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.HasCount(2, message);
+        Assert.AreEqual("unsubscribe", message["op"]);
+        Assert.AreEqual(requestId, message["requestId"]);
+
+        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => builder.BuildUnsubscribeMessage(0));
+    }
+
+    [TestMethod]
+    public async Task TestBuildSubscribeMessage()
+    {
+        int requestId = 2;
+        ParseLiveQuery<ParseObject> liveQuery = new ParseLiveQuery<ParseObject>(
+            Client.Services,
+            "DummyClass",
+            new Dictionary<string, object> { { "foo", "bar" } },
+            ["foo"],
+            ["foo"]);
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+        IDictionary<string, object> message = await builder.BuildSubscribeMessage<ParseObject>(requestId, liveQuery);
+
+        Assert.IsNotNull(message);
+        Assert.HasCount(3, message);
+
+        Assert.IsTrue(message.ContainsKey("op"));
+        Assert.AreEqual("subscribe", message["op"]);
+
+        Assert.IsTrue(message.ContainsKey("requestId"));
+        Assert.AreEqual(requestId, message["requestId"]);
+
+        Assert.IsTrue(message.ContainsKey("query"));
+        Assert.IsInstanceOfType<IDictionary<string, object>>(message["query"], "The 'query' value should be a Dictionary<string, object>.");
+        Assert.HasCount(4, (IDictionary<string, object>) message["query"]);
+        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<IDictionary<string, object>>(query["where"], "The 'where' property should be a Dictionary<string, object>.");
+        IDictionary<string, object> where = (IDictionary<string, object>) query["where"];
+        Assert.HasCount(1, where, "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<string[]>(query["keys"], "The 'keys' property should be a string array.");
+        Assert.HasCount(1, (string[]) query["keys"], "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<string[]>(query["watch"], "The 'watch' property should be a string array.");
+        Assert.HasCount(1, (string[]) query["watch"], "The 'watch' array should contain exactly one element.");
+        Assert.AreEqual("foo", ((string[]) query["watch"])[0], "The 'watch' parameter should contain 'foo'.");
+
+        await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () => await builder.BuildSubscribeMessage<ParseObject>(0, liveQuery));
+        await Assert.ThrowsExactlyAsync<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" } },
+            ["foo"],
+            ["foo"]);
+        ParseLiveQueryMessageBuilder builder = new ParseLiveQueryMessageBuilder();
+        IDictionary<string, object> message = await builder.BuildUpdateSubscriptionMessage<ParseObject>(requestId, liveQuery);
+
+        Assert.IsNotNull(message);
+        Assert.HasCount(3, message);
+
+        Assert.IsTrue(message.ContainsKey("op"));
+        Assert.AreEqual("update", message["op"]);
+
+        Assert.IsTrue(message.ContainsKey("requestId"));
+        Assert.AreEqual(requestId, message["requestId"]);
+
+        Assert.IsTrue(message.ContainsKey("query"));
+        Assert.IsInstanceOfType<IDictionary<string, object>>(message["query"], "The 'query' value should be a Dictionary<string, object>.");
+        Assert.HasCount(4, (IDictionary<string, object>) message["query"]);
+        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<IDictionary<string, object>>(query["where"], "The 'where' property should be a Dictionary<string, object>.");
+        IDictionary<string, object> where = (IDictionary<string, object>) query["where"];
+        Assert.HasCount(1, where, "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<string[]>(query["keys"], "The 'keys' property should be a string array.");
+        Assert.HasCount(1, (string[]) query["keys"], "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<string[]>(query["watch"], "The 'watch' property should be a string array.");
+        Assert.HasCount(1, (string[]) query["watch"], "The 'watch' array should contain exactly one element.");
+        Assert.AreEqual("foo", ((string[]) query["watch"])[0], "The 'watch' parameter should contain 'foo'.");
+
+        await Assert.ThrowsExactlyAsync<ArgumentOutOfRangeException>(async () => await builder.BuildUpdateSubscriptionMessage<ParseObject>(0, liveQuery));
+        await Assert.ThrowsExactlyAsync<ArgumentNullException>(async () => await builder.BuildUpdateSubscriptionMessage<ParseObject>(requestId, null));
+    }
+}

Parse.Tests/LiveQueryMessageParserTests.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Abstractions.Platform.Objects;
+using Parse.Infrastructure;
+using Parse.Platform.LiveQueries;
+
+namespace Parse.Tests;
+
+[TestClass]
+public class LiveQueryMessageParserTests
+{
+    private ParseClient Client { get; } = new ParseClient(new ServerConnectionData { Test = true });
+
+    public LiveQueryMessageParserTests()
+    {
+        Client.Publicize();
+    }
+
+    [TestMethod]
+    public void TestConstructor()
+    {
+        ParseLiveQueryMessageParser parser = new ParseLiveQueryMessageParser(Client.Services.Decoder);
+
+        Assert.IsNotNull(parser, "Parser should not be null after construction.");
+
+        Assert.ThrowsExactly<ArgumentNullException>(() => new ParseLiveQueryMessageParser(null));
+    }
+
+    [TestMethod]
+    public void TestGetClientId()
+    {
+        ParseLiveQueryMessageParser parser = new ParseLiveQueryMessageParser(Client.Services.Decoder);
+        string clientId = "someClientId";
+
+        IDictionary<string, object> message = new Dictionary<string, object> { { "clientId", clientId } };
+        Assert.AreEqual(clientId, parser.GetClientId(message));
+
+        Assert.ThrowsExactly<ArgumentNullException>(() => parser.GetClientId(null));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetClientId(new Dictionary<string, object> { { "wrongKey", "someClientId" } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetClientId(new Dictionary<string, object> { { "clientId", 12345 } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetClientId(new Dictionary<string, object> { { "clientId", "" } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetClientId(new Dictionary<string, object> { { "clientId", "   " } }));
+    }
+
+    [TestMethod]
+    public void TestGetRequestId()
+    {
+        ParseLiveQueryMessageParser parser = new ParseLiveQueryMessageParser(Client.Services.Decoder);
+        int requestId = 42;
+
+        IDictionary<string, object> message = new Dictionary<string, object> { { "requestId", (long) requestId } };
+        Assert.AreEqual(requestId, parser.GetRequestId(message));
+
+        Assert.ThrowsExactly<ArgumentNullException>(() => parser.GetRequestId(null));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetRequestId(new Dictionary<string, object> { { "wrongKey", 42L } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetRequestId(new Dictionary<string, object> { { "requestId", -1L } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetRequestId(new Dictionary<string, object> { { "requestId", 0L } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetRequestId(new Dictionary<string, object> { { "requestId", "notAnInteger" } }));
+    }
+
+    [TestMethod]
+    public void TestGetObjectState()
+    {
+        ParseLiveQueryMessageParser parser = new ParseLiveQueryMessageParser(Client.Services.Decoder);
+        IDictionary<string, object> objData = new Dictionary<string, object>
+        {
+            { "objectId", "obj123" },
+            { "className", "TestClass" },
+            { "createdAt", "2023-10-01T12:00.000Z" },
+            { "updatedAt", "2023-10-01T12:00.000Z" },
+            {
+                "ACL", new Dictionary<string, object>
+                {
+                    { "*", new Dictionary<string, object>{ { "read", true } } }
+                }
+            },
+            { "foo", "bar" }
+        };
+
+        IDictionary<string, object> message = new Dictionary<string, object> { { "object", objData } };
+        IObjectState state = parser.GetObjectState(message);
+        Assert.IsNotNull(state);
+        Assert.AreEqual("obj123", state.ObjectId);
+        Assert.AreEqual("bar", state["foo"]);
+
+        Assert.ThrowsExactly<ArgumentNullException>(() => parser.GetObjectState(null));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetObjectState(new Dictionary<string, object> { { "wrongKey", objData } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetObjectState(new Dictionary<string, object> { { "object", "notADictionary" } }));
+    }
+
+    [TestMethod]
+    public void TestGetOriginalState()
+    {
+        ParseLiveQueryMessageParser parser = new ParseLiveQueryMessageParser(Client.Services.Decoder);
+        IDictionary<string, object> objData = new Dictionary<string, object>
+        {
+            { "objectId", "obj123" },
+            { "className", "TestClass" },
+            { "createdAt", "2023-10-01T12:00.000Z" },
+            { "updatedAt", "2023-10-01T12:00.000Z" },
+            {
+                "ACL", new Dictionary<string, object>
+                {
+                    { "*", new Dictionary<string, object>{ { "read", true } } }
+                }
+            },
+            { "foo", "bar" }
+        };
+        IDictionary<string, object> message = new Dictionary<string, object> { { "original", objData } };
+
+        IObjectState state = parser.GetOriginalState(message);
+        Assert.IsNotNull(state);
+        Assert.AreEqual("obj123", state.ObjectId);
+        Assert.AreEqual("bar", state["foo"]);
+
+        Assert.ThrowsExactly<ArgumentNullException>(() => parser.GetOriginalState(null));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetOriginalState(new Dictionary<string, object> { { "wrongKey", objData } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetOriginalState(new Dictionary<string, object> { { "original", "notADictionary" } }));
+    }
+
+    [TestMethod]
+    public void TestGetError()
+    {
+        ParseLiveQueryMessageParser parser = new ParseLiveQueryMessageParser(Client.Services.Decoder);
+        int errorCode = 123;
+        string errorMessage = "An error occurred";
+        bool reconnect = true;
+        IDictionary<string, object> message = new Dictionary<string, object>
+        {
+            { "code", (long) errorCode },
+            { "error", errorMessage },
+            { "reconnect", reconnect }
+        };
+
+        (int code, string error, bool shouldReconnect) = parser.GetError(message);
+        Assert.AreEqual(errorCode, code);
+        Assert.AreEqual(errorMessage, error);
+        Assert.AreEqual(reconnect, shouldReconnect);
+
+        Assert.ThrowsExactly<ArgumentNullException>(() => parser.GetError(null));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetError(new Dictionary<string, object> { { "wrongField", 123 } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetError(new Dictionary<string, object> { { "code", "notALong" }, { "error", errorMessage }, { "reconnect", reconnect } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetError(new Dictionary<string, object> { { "code", (long) errorCode }, { "error", 12345 }, { "reconnect", reconnect } }));
+        Assert.ThrowsExactly<ArgumentException>(() => parser.GetError(new Dictionary<string, object> { { "code", (long) errorCode }, { "error", errorMessage }, { "reconnect", "notABoolean" } }));
+    }
+}