feat: Missing Methods and Implementations after v4.0.

CHANGELOG.md

@@ -13,7 +13,7 @@
 ## [3.0.2](https://github.com/parse-community/Parse-SDK-dotNET/compare/3.0.1...3.0.2) (2024-05-24)
 
 
-### Bug Fixes
+### Initial Release!
 
 * Cannot access objects without user login ([#368](https://github.com/parse-community/Parse-SDK-dotNET/issues/368)) ([aa278df](https://github.com/parse-community/Parse-SDK-dotNET/commit/aa278df8147516a2ff8a95e1fa0f5f7972c63cc4))
 
@@ -34,4 +34,4 @@
 
 ### BREAKING CHANGES
 
-* This changes the license to Apache 2.0. This release may contain breaking changes which are not listed here, so please make sure to test your app carefully when upgrading. ([6887aff](6887aff))
+* This changes the license to Apache 2.0. This release may contain breaking changes which are not listed here, so please make sure to test your app carefully when upgrading. ([6887aff](6887aff))

CONTRIBUTING.md

@@ -4,22 +4,16 @@ We want to make contributing to this project as easy and transparent as possible
 
 ### Pull Requests
 
-We actively welcome your pull requests. When we get one, we'll run some tests on it first. From here, we'll need to get a core member to sign off on the changes and then merge the pull request.
+PRs are welcomed!
 
 1. Fork the repo and create your branch from `master`.
-2. Add unit tests for any new code you add.
-3. If you've changed APIs, update the documentation.
-4. Ensure the test suite passes.
-5. Make sure your code lints.
+2. If you've changed APIs, update the documentation.
 
 ## Style Guide
 
-We're still working on providing a more concise code style for your IDE and getting a linter on GitHub, but for now try to keep the following:
+- Please ALWAYS unwrap your long methods to enhance readability. If your code is quickly readable, then we can quickly sketch out what it does, but if wrapped, it gets UNNECESSARILY longer to understand.
 
-* We use [editorconfig](https://editorconfig.org) to manage basic editor settings, please install a compatible plugin for your preferred environment.
 * Most importantly, match the existing code style as much as possible.
 * Try to keep lines under 120 characters, if possible.
 
 ## License
-
-By contributing to Parse .NET SDK, you agree that your contributions will be licensed under its license

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() // Mock difficulty: 1
+    {
+        var acl = new ParseACL();
+        Assert.IsNotNull(acl);
+
+    }
+    [TestMethod]
+    [Description("Tests ACL creation using ParseUser constructor.")]
+    public void TestCheckPermissionsWithParseUserConstructor() // Mock difficulty: 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()// Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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() // Mock difficulty: 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()  // Mock difficulty: 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,14 +13,46 @@ namespace Parse.Tests;
 [TestClass]
 public class AnalyticsTests
 {
-#warning Skipped post-test-evaluation cleaning method may be needed.
 
-    // [TestCleanup]
-    // public void TearDown() => (Client.Services as ServiceHub).Reset();
+    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;
+    }
+
 
     [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()// Mock difficulty: 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>))));
+    }
+
+
+}