feat: Architectural Refactor of Dependency Injection and Query System

Parse.Tests/ACLTests.cs

@@ -1,12 +1,12 @@
-using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq; // Add Moq for mocking if not already added
-using Parse.Infrastructure;
-using Parse.Platform.Objects;
+using Moq;
 using Parse.Abstractions.Infrastructure;
 using Parse.Abstractions.Platform.Objects;
-
-namespace Parse.Tests;
+using Parse.Infrastructure;
+using Parse.Platform.Objects;
+using Parse;
+using System.Collections.Generic;
+using System;
 
 [TestClass]
 public class ACLTests
@@ -35,6 +35,7 @@ public void Initialize()
                 return user;
             });
 
+
         // Set up ParseClient with the mocked ServiceHub
         Client = new ParseClient(new ServerConnectionData { Test = true })
         {
@@ -47,13 +48,23 @@ public void Initialize()
         // Add valid classes to the client
         Client.AddValidClass<ParseUser>();
         Client.AddValidClass<ParseSession>();
+        Client.AddValidClass<ParseRole>();
     }
 
     [TestCleanup]
     public void Clean() => (Client.Services as ServiceHub)?.Reset();
 
     [TestMethod]
-    public void TestCheckPermissionsWithParseUserConstructor()
+    [Description("Tests if default ParseACL is created without errors.")]
+    public void TestParseACLDefaultConstructor() // 1
+    {
+        var acl = new ParseACL();
+        Assert.IsNotNull(acl);
+
+    }
+    [TestMethod]
+    [Description("Tests ACL creation using ParseUser constructor.")]
+    public void TestCheckPermissionsWithParseUserConstructor() // 1
     {
         // Arrange
         ParseUser owner = GenerateUser("OwnerUser");
@@ -70,7 +81,8 @@ public void TestCheckPermissionsWithParseUserConstructor()
     }
 
     [TestMethod]
-    public void TestReadWriteMutationWithParseUserConstructor()
+    [Description("Tests that users permission change accordingly")]
+    public void TestReadWriteMutationWithParseUserConstructor()// 1
     {
         // Arrange
         ParseUser owner = GenerateUser("OwnerUser");
@@ -93,7 +105,8 @@ public void TestReadWriteMutationWithParseUserConstructor()
     }
 
     [TestMethod]
-    public void TestParseACLCreationWithNullObjectIdParseUser()
+    [Description("Tests if throws if try to instantiate using a ParseUser without objectId.")]
+    public void TestParseACLCreationWithNullObjectIdParseUser() // 1
     {
         // Assert
         Assert.ThrowsException<ArgumentException>(() => new ParseACL(GenerateUser(default)));
@@ -102,22 +115,25 @@ public void TestParseACLCreationWithNullObjectIdParseUser()
     ParseUser GenerateUser(string objectID)
     {
         // Use the mock to simulate generating a ParseUser
-        var state = new MutableObjectState { ObjectId = objectID };
+        var state = new MutableObjectState { ObjectId = objectID, ClassName = "_User" };
         return Client.GenerateObjectFromState<ParseUser>(state, "_User");
+
     }
 
     [TestMethod]
-    public void TestGenerateObjectFromState()
+    [Description("Tests to create a ParseUser via IParseClassController, that is set when calling Bind.")]
+    public void TestGenerateObjectFromState() // 1
     {
         // Arrange
         var state = new MutableObjectState { ObjectId = "123", ClassName = null };
         var defaultClassName = "_User";
 
+
         var serviceHubMock = new Mock<IServiceHub>();
         var classControllerMock = new Mock<IParseObjectClassController>();
 
         classControllerMock.Setup(controller => controller.Instantiate(It.IsAny<string>(), It.IsAny<IServiceHub>()))
-            .Returns<string, IServiceHub>((className, hub) => new ParseUser());
+             .Returns<string, IServiceHub>((className, hub) => new ParseUser());
 
         // Act
         var user = classControllerMock.Object.GenerateObjectFromState<ParseUser>(state, defaultClassName, serviceHubMock.Object);
@@ -126,5 +142,137 @@ public void TestGenerateObjectFromState()
         Assert.IsNotNull(user);
         Assert.AreEqual(defaultClassName, user.ClassName);
     }
+    [TestMethod]
+    [Description("Tests for public read and write access values.")]
+    public void TestPublicReadWriteAccessValues() // 1
+    {
+        var acl = new ParseACL();
+        Assert.IsFalse(acl.PublicReadAccess);
+        Assert.IsFalse(acl.PublicWriteAccess);
+
+        acl.PublicReadAccess = true;
+        acl.PublicWriteAccess = true;
+        Assert.IsTrue(acl.PublicReadAccess);
+        Assert.IsTrue(acl.PublicWriteAccess);
+    }
+
+    [TestMethod]
+    [Description("Tests that sets and gets properly for string UserIds.")]
+    public void TestSetGetAccessWithStringId() // 1
+    {
+        var acl = new ParseACL();
+        var testUser = GenerateUser("test");
+        acl.SetReadAccess(testUser.ObjectId, true);
+        acl.SetWriteAccess(testUser.ObjectId, true);
+
+        Assert.IsTrue(acl.GetReadAccess(testUser.ObjectId));
+        Assert.IsTrue(acl.GetWriteAccess(testUser.ObjectId));
+
+        acl.SetReadAccess(testUser.ObjectId, false);
+        acl.SetWriteAccess(testUser.ObjectId, false);
+
+        Assert.IsFalse(acl.GetReadAccess(testUser.ObjectId));
+        Assert.IsFalse(acl.GetWriteAccess(testUser.ObjectId));
+    }
+
+    [TestMethod]
+    [Description("Tests that methods thow exceptions if user id is null.")]
+    public void SetGetAccessThrowsForNull() // 1
+    {
+        var acl = new ParseACL();
+
+        Assert.ThrowsException<ArgumentException>(() => acl.SetReadAccess(userId:null, false));
+        Assert.ThrowsException<ArgumentException>(() => acl.SetWriteAccess(userId: null, false));
+        Assert.ThrowsException<ArgumentException>(() => acl.GetReadAccess(userId:null));
+        Assert.ThrowsException<ArgumentException>(() => acl.GetWriteAccess(userId:null));
+
+    }
+    [TestMethod]
+    [Description("Tests that a Get access using a ParseUser is correct.")]
+    public void TestSetGetAccessWithParseUser() // 1
+    {
+        var acl = new ParseACL();
+        ParseUser test = GenerateUser("test");
+
+        acl.SetReadAccess(test, true);
+        acl.SetWriteAccess(test, true);
+        Assert.IsTrue(acl.GetReadAccess(test));
+        Assert.IsTrue(acl.GetWriteAccess(test));
+
+        acl.SetReadAccess(test, false);
+        acl.SetWriteAccess(test, false);
+
+        Assert.IsFalse(acl.GetReadAccess(test));
+        Assert.IsFalse(acl.GetWriteAccess(test));
+
+    }
+
+    [TestMethod]
+    [Description("Tests that the default ParseACL returns correct roles for read/write")]
+    public void TestDefaultRolesForReadAndWriteAccess() // 1
+    {
+        var acl = new ParseACL();
+        Assert.IsFalse(acl.GetRoleReadAccess("role"));
+        Assert.IsFalse(acl.GetRoleWriteAccess("role"));
+
+    }
 
-}
+    [TestMethod]
+    [Description("Tests role read/write access with role names correctly and get methods.")]
+    public void TestSetGetRoleReadWriteAccessWithRoleName() // 1
+    {
+        var acl = new ParseACL();
+        acl.SetRoleReadAccess("test", true);
+        acl.SetRoleWriteAccess("test", true);
+        Assert.IsTrue(acl.GetRoleReadAccess("test"));
+        Assert.IsTrue(acl.GetRoleWriteAccess("test"));
+
+        acl.SetRoleReadAccess("test", false);
+        acl.SetRoleWriteAccess("test", false);
+        Assert.IsFalse(acl.GetRoleReadAccess("test"));
+        Assert.IsFalse(acl.GetRoleWriteAccess("test"));
+    }
+
+    [TestMethod]
+    [Description("Tests ACL can use and correctly convert to JSON object via ConvertToJSON.")]
+    public void TestConvertToJSON() // 3
+    {
+        var acl = new ParseACL();
+        ParseUser user = GenerateUser("test");
+
+        acl.SetReadAccess(user, true);
+        acl.SetWriteAccess(user, false);
+        acl.SetRoleReadAccess("test", true);
+        var json = (acl as IJsonConvertible).ConvertToJSON();
+        Assert.IsInstanceOfType(json, typeof(IDictionary<string, object>));
+
+        var jsonObject = json as IDictionary<string, object>;
+        Assert.IsTrue(jsonObject.ContainsKey(user.ObjectId));
+        Assert.IsTrue(jsonObject.ContainsKey("role:test"));
+        var test = jsonObject[user.ObjectId] as Dictionary<string, object>;
+        Assert.AreEqual(1, test.Count);
+    }
+
+
+    [TestMethod]
+    [Description("Tests that ProcessAclData can handle invalid values for public key.")]
+    public void TestProcessAclData_HandlesInvalidDataForPublic() // 1
+    {
+        var aclData = new Dictionary<string, object> { { "*", 123 } };
+        var acl = new ParseACL(aclData);
+        Assert.IsFalse(acl.PublicReadAccess);
+        Assert.IsFalse(acl.PublicWriteAccess);
+    }
+    [TestMethod]
+    [Description("Tests if ACL skips keys that don't represent valid JSON data dictionaries")]
+    public void TestProcessAclData_SkipsInvalidKeys()  // 1
+    {
+        var aclData = new Dictionary<string, object> {
+              {"userId", 123 }
+              };
+        var acl = new ParseACL(aclData);
+
+        Assert.IsFalse(acl.GetReadAccess("userId"));
+        Assert.IsFalse(acl.GetWriteAccess("userId"));
+    }
+}

Parse.Tests/AnalyticsTests.cs

@@ -13,46 +13,14 @@ namespace Parse.Tests;
 [TestClass]
 public class AnalyticsTests
 {
+#warning Skipped post-test-evaluation cleaning method may be needed.
 
-    private Mock<IParseAnalyticsController> _mockAnalyticsController;
-    private Mock<IParseCurrentUserController> _mockCurrentUserController;
-    private MutableServiceHub _hub;
-    private ParseClient _client;
-
-
-    [TestInitialize]
-    public void Initialize()
-    {
-        _mockAnalyticsController = new Mock<IParseAnalyticsController>();
-        _mockCurrentUserController = new Mock<IParseCurrentUserController>();
-
-        _mockCurrentUserController
-            .Setup(controller => controller.GetCurrentSessionTokenAsync(It.IsAny<IServiceHub>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync("sessionToken");
-
-
-        _hub = new MutableServiceHub
-        {
-            AnalyticsController = _mockAnalyticsController.Object,
-            CurrentUserController = _mockCurrentUserController.Object
-        };
-        _client = new ParseClient(new ServerConnectionData { Test = true }, _hub);
-    }
-
-    [TestCleanup]
-    public void Cleanup()
-    {
-        _mockAnalyticsController = null;
-        _mockCurrentUserController = null;
-        _hub = null;
-        _client = null;
-    }
-
+    // [TestCleanup]
+    // public void TearDown() => (Client.Services as ServiceHub).Reset();
 
     [TestMethod]
     public async Task TestTrackEvent()
     {
-
         // Arrange
         var hub = new MutableServiceHub();
         var client = new ParseClient(new ServerConnectionData { Test = true }, hub);

Parse.Tests/AttributeTests.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Parse.Infrastructure.Control;
+using Parse.Infrastructure.Utilities;
+
+namespace Parse.Tests;
+
+
+[TestClass]
+public class AttributeTests
+{
+    [TestMethod]
+    [Description("Tests that PreserveAttribute can set its boolean properties correctly.")]
+    public void PreserveAttribute_SetPropertiesCorrectly()
+    {
+        var preserve = new PreserveAttribute { AllMembers = true, Conditional = true };
+        Assert.IsTrue(preserve.AllMembers);
+        Assert.IsTrue(preserve.Conditional);
+        preserve.AllMembers = false;
+        preserve.Conditional = false;
+        Assert.IsFalse(preserve.AllMembers);
+        Assert.IsFalse(preserve.Conditional);
+    }
+    [TestMethod]
+    [Description("Test LinkerSafe attribute and ensures there is not exceptions on constructor.")]
+    public void LinkerSafeAttribute_CanBeCreatedWithoutErrors()
+    {
+        var safe = new LinkerSafeAttribute();
+        Assert.IsNotNull(safe);
+    }
+    [TestMethod]
+    [Description("Tests that the PreserveWrapperTypes class has the Preserve attribute")]
+    public void PreserveWrapperTypes_HasPreserveAttribute()
+    {
+        var attribute = typeof(PreserveWrapperTypes).GetTypeInfo().GetCustomAttribute<PreserveAttribute>(true);
+        Assert.IsNotNull(attribute);
+        Assert.IsTrue(attribute.AllMembers);
+    }
+
+    [TestMethod]
+    [Description("Test that types exists in the AOTPreservations List with correct types.")]
+    public void PreserveWrapperTypes_HasCorrectlyAOTTypesRegistered()// 1
+    {
+        var property = typeof(PreserveWrapperTypes).GetTypeInfo().GetDeclaredProperty("AOTPreservations");
+        var list = property.GetValue(null) as List<object>;
+
+        Assert.IsNotNull(list);
+        Assert.IsTrue(list.Any(p => p.Equals(typeof(FlexibleListWrapper<object, object>))));
+        Assert.IsTrue(list.Any(p => p.Equals(typeof(FlexibleListWrapper<float, float>))));
+
+        Assert.IsTrue(list.Any(p => p.Equals(typeof(FlexibleDictionaryWrapper<object, object>))));
+        Assert.IsTrue(list.Any(p => p.Equals(typeof(FlexibleDictionaryWrapper<double, float>))));
+    }
+
+
+}