Merge pull request #905 from PlayEveryWare/feat/more-unit-tests

More Unit Tests

Author: paulhazen

Assets/Tests/PlayMode/Extensions/AuthScopeFlagsExtensionsTests.cs

@@ -47,5 +47,19 @@ public static void CustomMappings_Exists()
         {
             CustomMappings_Exist(AuthScopeFlagsExtensions.CustomMappings);
         }
+        
+        /// <summary>
+        /// Guarantees that the TryParse method works for all the valid strings
+        /// that can be parsed, and that parsing of an invalid string is handled
+        /// correctly.
+        /// </summary>
+        [Test]
+        public static void Test_TryParse()
+        {
+            Test_TryParse(
+                AuthScopeFlagsExtensions.CustomMappings,
+                AuthScopeFlagsExtensions.TryParse
+            );
+        }
     }
 }

Assets/Tests/PlayMode/Extensions/CustomMappedEnumTestBase.cs

@@ -30,6 +30,9 @@ namespace PlayEveryWare.EpicOnlineServices.Tests.Extensions
 
     public class CustomMappedEnumTestBase<TEnum> where TEnum : struct, Enum
     {
+        // Define a delegate that matches the signature of a TryParse method
+        protected delegate bool TryParseDelegate(IList<string> input, out TEnum result);
+
         /// <summary>
         /// Helper function that retrieves an IEnumerable of all the values
         /// defined within the indicated enum.
@@ -63,10 +66,10 @@ protected static void AllValues_HaveDescription(
                 // exception because it can signal to the developer that the 
                 // custom mapping is out of date with the definition of the enum
                 // it is mapped against.
-                Assert.DoesNotThrow(() => getDescriptionFn(enumValue), 
-                    $"The extension class for the enum {typeof(TEnum).Name} " +
-                    $"does not have a switch clause providing a description " +
-                    $"text for the enum value \"{enumValue}\".");
+                Assert.DoesNotThrow(() => getDescriptionFn(enumValue),
+                $"The extension class for the enum {typeof(TEnum).Name} " +
+                $"does not have a switch clause providing a description " +
+                $"text for the enum value \"{enumValue}\".");
             }
         }
 
@@ -84,9 +87,58 @@ protected static void CustomMappings_Exist(
             foreach (TEnum enumValue in GetEnumValues())
             {
                 Assert.IsTrue(customMappings.ContainsValue(enumValue),
-                    $"The extension class for the enum {typeof(TEnum).Name} " +
-                    $"does not have a custom mapping defined for the enum " +
-                    $"value \"{enumValue}\".");
+                $"The extension class for the enum {typeof(TEnum).Name} " +
+                $"does not have a custom mapping defined for the enum " +
+                $"value \"{enumValue}\".");
+            }
+        }
+
+        /// <summary>
+        /// Checks to make sure that the TryParse extension method for the
+        /// indicated enum is functioning properly.
+        /// </summary>
+        /// <param name="customMappings">
+        /// The dictionary that provides mapping from custom string values to
+        /// specific values within the enum.
+        /// </param>
+        /// <param name="tryParseFunc">
+        /// The extension method used to try and parse a string into an enum
+        /// value.
+        /// </param>
+        protected static void Test_TryParse(
+            Dictionary<string, TEnum> customMappings,
+            TryParseDelegate tryParseFunc
+        )
+        {
+            // Reuse the variables for whether parse was successful and what the
+            // parsed value was.
+            bool parsed = false;
+            TEnum parsedValue = default;
+
+            // test that an incorrect string will result in the TryParse method
+            // functioning as expected
+            const string INVALID_MAPPING = "ASDFASDFASDFASDF";
+            parsed = tryParseFunc(new List<string>() { INVALID_MAPPING }, out parsedValue);
+
+            // Assert that the parsing failed (as expected)
+            Assert.IsFalse(parsed);
+
+            // Assert that in the case of a failed parse, the default value is
+            // set.
+            Assert.AreEqual(parsedValue, default(TEnum));
+
+            // Test each of the custom mappings for accurate parsing.
+            foreach (string customMapping in customMappings.Keys)
+            {
+                parsed = tryParseFunc(new List<string>() { customMapping }, out parsedValue);
+                Assert.IsTrue(parsed);
+                Assert.AreEqual(parsedValue, customMappings[customMapping]);
+
+                // Convert custom mapped to string, and test that that parsing works
+                string stringValue = parsedValue.ToString();
+                parsed = tryParseFunc(new List<string>() { stringValue }, out TEnum reparsedValue);
+                Assert.IsTrue(parsed);
+                Assert.AreEqual(reparsedValue, parsedValue);
             }
         }
     }

Assets/Tests/PlayMode/Extensions/FileInfoExtensionsTests.cs

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2024 PlayEveryWare
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+namespace PlayEveryWare.EpicOnlineServices.Tests.Extensions
+{
+    using NUnit.Framework;
+    using System;
+    using System.IO;
+    using PlayEveryWare.EpicOnlineServices.Extensions;
+    using System.Collections.Generic;
+
+    [TestFixture]
+    public class FileInfoExtensionsTests
+    {
+        private string tempDir;
+
+        [SetUp]
+        public void SetUp()
+        {
+            tempDir = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString())).FullName;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, true);
+            }
+        }
+
+        private FileInfo CreateFile(string fileName, string content = null)
+        {
+            string filePath = Path.Combine(tempDir, fileName);
+            if (content != null)
+            {
+                File.WriteAllText(filePath, content);
+            }
+
+            return new FileInfo(filePath);
+        }
+
+        private void AssertSemanticEquality(string content1, string content2, bool expected,
+            bool createFirstFile = true, bool createSecondFile = true)
+        {
+            FileInfo fileInfo1 = createFirstFile ? CreateFile("file1.txt", content1) : CreateFile("nonexistent1.txt");
+            FileInfo fileInfo2 = createSecondFile ? CreateFile("file2.txt", content2) : CreateFile("nonexistent2.txt");
+
+            bool result = fileInfo1.AreContentsSemanticallyEqual(fileInfo2);
+            Assert.AreEqual(expected, result,
+                $"Expected files with content \"{content1}\" and \"{content2}\" to be semantically {(expected ? "equal" : "not equal")}.");
+        }
+
+        [Test]
+        public void ComputeSHA_CorrectlyComputesSHAOfFile()
+        {
+            Dictionary<string, string> hashToContents = new()
+            {
+                { "0a0a9f2a6772942557ab5355d76af442f8f65e01", "Hello, World!" },
+                // Test a string that is only slightly different
+                { "907d14fb3af2b0d4f18c2d46abe8aedce17367bd", "Hello, World" },
+                { "9be35056f6abcc721f8514f526d865f08fa88403", "So long, and thanks for all the fish!" }
+            };
+
+            foreach (string hash in hashToContents.Keys)
+            {
+                Assert.AreEqual(
+                    hash,
+                    CreateFile(hashToContents[hash], hashToContents[hash]).ComputeSHA(),
+                    "The computed SHA should match the expected SHA."
+                );
+            }
+        }
+
+        [TestCase("Same content", "Same content", true)]
+        [TestCase("Content A", "Content B", false)]
+        [TestCase("Short", "Longer content", false)]
+        [TestCase(null, null, true, false, false)] // Neither file exists
+        [TestCase("Some content", null, false, true, false)] // One file exists, other does not
+        [TestCase("Some content", "Some content", true, true, true)] // Same file path
+        public void AreContentsSemanticallyEqual_VariousScenarios_ReturnsExpected(string content1, string content2,
+            bool expected, bool createFirstFile = true, bool createSecondFile = true)
+        {
+            AssertSemanticEquality(content1, content2, expected, createFirstFile, createSecondFile);
+        }
+    }
+}

Assets/Tests/PlayMode/Extensions/FileInfoExtensionsTests.cs.meta

@@ -47,5 +47,19 @@ public static void CustomMappings_Exists()
         {
             CustomMappings_Exist(IntegratedPlatformManagementFlagsExtensions.CustomMappings);
         }
+
+        /// <summary>
+        /// Guarantees that the TryParse method works for all the valid strings
+        /// that can be parsed, and that parsing of an invalid string is handled
+        /// correctly.
+        /// </summary>
+        [Test]
+        public static void Test_TryParse()
+        {
+            Test_TryParse(
+                IntegratedPlatformManagementFlagsExtensions.CustomMappings,
+                IntegratedPlatformManagementFlagsExtensions.TryParse
+            );
+        }
     }
 }

Assets/Tests/PlayMode/Extensions/IntegratedPlatformManagementFlagsExtensionsTests.cs

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2024 PlayEveryWare
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+namespace PlayEveryWare.EpicOnlineServices.Tests.Extensions
+{
+    using NUnit.Framework;
+    using PlayEveryWare.EpicOnlineServices.Extensions;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    [TestFixture]
+    public class ListExtensionsTests
+    {
+        /// <summary>
+        /// Test to verify that the Shuffle method changes the order of elements in the list.
+        /// </summary>
+        [Test]
+        public void Shuffle_ChangesOrderOfElements()
+        {
+            // Arrange
+            List<int> originalList = Enumerable.Range(1, 100).ToList();
+            List<int> shuffledList = new(originalList);
+
+            // Act
+            shuffledList.Shuffle();
+
+            // Assert
+            Assert.AreNotEqual(originalList, shuffledList,
+                "The shuffled list should not be in the same order as the original list.");
+            Assert.AreEqual(originalList.Count, shuffledList.Count,
+                "The shuffled list should have the same number of elements as the original list.");
+            Assert.IsTrue(originalList.All(shuffledList.Contains),
+                "The shuffled list should contain all elements from the original list.");
+        }
+
+        /// <summary>
+        /// Test to verify that the Shuffle method does not lose any elements.
+        /// </summary>
+        [Test]
+        public void Shuffle_DoesNotLoseElements()
+        {
+            // Arrange
+            List<int> originalList = new()
+            {
+                1,
+                2,
+                3,
+                4,
+                5
+            };
+            List<int> shuffledList = new(originalList);
+
+            // Act
+            shuffledList.Shuffle();
+
+            // Assert
+            CollectionAssert.AreEquivalent(originalList, shuffledList,
+                "The shuffled list should contain the same elements as the original list.");
+        }
+
+        /// <summary>
+        /// Test to verify that shuffling an empty list does not throw an exception.
+        /// </summary>
+        [Test]
+        public void Shuffle_EmptyList_NoException()
+        {
+            // Arrange
+            List<int> emptyList = new();
+
+            // Act & Assert
+            Assert.DoesNotThrow(() => emptyList.Shuffle(), "Shuffling an empty list should not throw an exception.");
+        }
+
+        /// <summary>
+        /// Test to verify that shuffling a single-element list does not change its order.
+        /// </summary>
+        [Test]
+        public void Shuffle_SingleElementList_NoChange()
+        {
+            // Arrange
+            List<int> singleElementList = new() { 42 };
+
+            // Act
+            singleElementList.Shuffle();
+
+            // Assert
+            Assert.AreEqual(1, singleElementList.Count,
+                "A single-element list should still have one element after shuffling.");
+            Assert.AreEqual(42, singleElementList[0], "A single-element list should remain unchanged after shuffling.");
+        }
+    }
+}

Assets/Tests/PlayMode/Extensions/ListExtensionsTests.cs

@@ -47,5 +47,19 @@ public static void CustomMappings_Exists()
         {
             CustomMappings_Exist(PlatformFlagsExtensions.CustomMappings);
         }
+
+        /// <summary>
+        /// Guarantees that the TryParse method works for all the valid strings
+        /// that can be parsed, and that parsing of an invalid string is handled
+        /// correctly.
+        /// </summary>
+        [Test]
+        public static void Test_TryParse()
+        {
+            Test_TryParse(
+                PlatformFlagsExtensions.CustomMappings,
+                PlatformFlagsExtensions.TryParse
+            );
+        }
     }
 }