Merge pull request #7230 from davidkline-ms/pkgUpdateTests

Improve package manifest update logic, add test cases

Author: David Kline

Assets/MixedRealityToolkit.Tests/EditModeTests/Core/Utilities/PackageManifestUpdaterTests.cs

@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Utilities.Editor;
+using NUnit.Framework;
+using System;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.Tests.EditMode.Core.Utilities.Editor
+{
+    /// <summary>
+    /// Tests that verify the correct behavior of the PackageManifestUpdater.
+    /// </summary>
+    public class PackageManifestUpdaterTests
+    {
+        /// <summary>
+        /// Verifies parsing of a properly formatted value returns the correct results.
+        /// </summary>
+        [Test]
+        public void TryGetValidVersion()
+        {
+            Version version;
+            float prerelease;
+
+            bool success = PackageManifestUpdater.TryGetVersionComponents("17.27.43", out version, out prerelease);
+            Assert.IsTrue(success);
+            Assert.AreEqual(version, new Version(17, 27, 43));
+            Assert.AreEqual(prerelease, 0f);
+
+            success = PackageManifestUpdater.TryGetVersionComponents("0.9.1-20200131.12", out version, out prerelease);
+            Assert.IsTrue(success);
+            Assert.AreEqual(version, new Version(0, 9, 1));
+            Assert.AreEqual(prerelease, float.Parse("20200131.12"));
+        }
+
+        /// <summary>
+        /// Verifies parsing of an improperly formatted string returns the correct failure results.
+        /// </summary>
+        [Test]
+        public void TryGetInvalidVersion()
+        {
+            Version version;
+            float prerelease;
+
+            bool success = PackageManifestUpdater.TryGetVersionComponents("x.2.3", out version, out prerelease);
+            Assert.IsFalse(success);
+            Assert.IsNull(version);
+            Assert.AreEqual(prerelease, float.NaN);
+
+            // Setting arbitrary values to ensure the function modifies them appropriately.
+            version = new Version(5, 6, 7);
+            prerelease = 17f;
+            success = PackageManifestUpdater.TryGetVersionComponents("1.2.3-v20200417.19", out version, out prerelease);
+            Assert.IsFalse(success);
+            Assert.IsNull(version);
+            Assert.AreEqual(prerelease, float.NaN);
+
+            // Setting arbitrary values to ensure the function modifies them appropriately.
+            version = new Version(5, 6, 7);
+            prerelease = 17f;
+            success = PackageManifestUpdater.TryGetVersionComponents("", out version, out prerelease);
+            Assert.IsFalse(success);
+            Assert.IsNull(version);
+            Assert.AreEqual(prerelease, float.NaN);
+        }
+
+        /// <summary>
+        /// Verifies that an outdated MSBuild for Unity version string will return the correct result.
+        /// </summary>
+        [Test]
+        public void OutdatedMSBuild()
+        {
+            string minVersion = "1.5.22-20200919.28";
+            string currentVersion = "0.7.15";
+
+            bool isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsFalse(isAppropriate);
+
+            minVersion = "9.4.2-20200622.4";
+            currentVersion = "9.4.2-20200530.9";
+
+            isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsFalse(isAppropriate);
+
+            minVersion = "1.0.0";
+            currentVersion = "0.7.15";
+
+            isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsFalse(isAppropriate);
+
+            minVersion = "0.9.19";
+            currentVersion = "0.9.19-20200101.55";
+
+            isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsFalse(isAppropriate);
+        }
+
+        /// <summary>
+        /// Verifies that an exactly matching MSBuild for Unity version returns the correct result.
+        /// </summary>
+        [Test]
+        public void MatchingMSBuild()
+        {
+            string minVersion = "28.32.44";
+            string currentVersion = "28.32.44";
+
+            bool isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsTrue(isAppropriate);
+
+            minVersion = "1.5.22-20200919.28";
+            currentVersion = "1.5.22-20200919.28";
+
+            isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsTrue(isAppropriate);
+        }
+
+        /// <summary>
+        /// Verifies that a more recent MSBuild for Unity version returns the correct result.
+        /// </summary>
+        [Test]
+        public void NewerMSBuild()
+        {
+            string minVersion = "28.32.44";
+            string currentVersion = "28.32.45";
+
+            bool isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsTrue(isAppropriate);
+
+            minVersion = "1.5.22-20200919.28";
+            currentVersion = "1.5.22-20200919.29";
+
+            isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsTrue(isAppropriate);
+
+            minVersion = "1.5.22-20200919.28";
+            currentVersion = "1.6.30-20201031.6";
+
+            isAppropriate = PackageManifestUpdater.IsAppropriateMBuildVersion(minVersion, currentVersion);
+            Assert.IsTrue(isAppropriate);
+        }
+    }
+}

Assets/MixedRealityToolkit.Tests/EditModeTests/Core/Utilities/PackageManifestUpdaterTests.cs.meta

@@ -4,9 +4,13 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.CompilerServices;
 using UnityEditor.PackageManager;
 using UnityEngine;
+using UnityEngine.Networking;
+using Version = System.Version;
 
+[assembly: InternalsVisibleTo("Microsoft.MixedReality.Toolkit.Tests.EditModeTests")]
 namespace Microsoft.MixedReality.Toolkit.Utilities.Editor
 {
     /// <summary>
@@ -19,7 +23,7 @@ internal static class PackageManifestUpdater
         private static string[] MSBuildRegistryScopes = new string[] { "com.microsoft" };
 
         internal const string MSBuildPackageName = "com.microsoft.msbuildforunity";
-        internal const string MSBuildPackageVersion = "0.9.1";
+        internal const string MSBuildPackageVersion = "0.9.1-20200131.12";
 
         /// <summary>
         /// Finds and returns the fully qualified path to the Unity Package Manager manifest
@@ -42,10 +46,102 @@ private static string GetPackageManifestFilePath()
             return manifestPath;
         }
 
+        internal static bool TryGetVersionComponents(
+            string packageVersion,
+            out Version version,
+            out float prerelease)
+        {
+            char[] trimChars = new char[] { ' ', '\"', ',' };
+
+            // Note: The version is in the following format Major.Minor.Revision[-Date.Build]
+
+            // Attempt to split the version string into version and float components
+            string[] versionComponents = packageVersion.Split(new char[] { '-' }, 2);
+
+            // Parse the version component.
+            string versionString = versionComponents[0].Trim(trimChars);
+            if (Version.TryParse(versionString, out version))
+            {
+                if (versionComponents.Length == 2)
+                {
+                    // Parse the float component
+                    string prereleaseString = versionComponents[1].Trim(trimChars);
+                    if (float.TryParse(prereleaseString, out prerelease))
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    prerelease = 0f;
+                    return true;
+                }
+            }
+
+            version = null;
+            prerelease = float.NaN;
+            return false;
+        }
+
         /// <summary>
         /// Reports whether or not the appropriate version of MSBuild for Unity is specified
         /// in the Unity Package Manager manifest.
         /// </summary>
+        /// <param name="minPackageVersion">The minimum version of the package, as listed in the manifest.</param>
+        /// <param name="packageVersion">The version of the package, as listed in the manifest.</param>
+        /// <returns>
+        /// True if an appropriate verson of MS Build for Unity is configured in the manifest, otherwise false.
+        /// </returns>
+        internal static bool IsAppropriateMBuildVersion(string minPackageVersion, string packageVersion)
+        {
+            // Get the version of the package.
+            // Note: The version is in the following format Major.Minor.Revision[-Date.Build]
+
+            Version minVersion;
+            float minPrerelease;
+
+            // Get the min version
+            if (!TryGetVersionComponents(minPackageVersion, out minVersion, out minPrerelease))
+            {
+                return false;
+            }
+
+            // Get the current version from the manifest
+            Version currentVersion;
+            float currentPrerelease;
+            if (!TryGetVersionComponents(packageVersion, out currentVersion, out currentPrerelease))
+            {
+                return false;
+            }
+
+            // Evaluate the results.
+            // * (currentVersion > minVersion)                                                                  return true;
+            // * (currentVersion == minVersion && currentPrerelease == minPrerelease)                           return true;
+            // * (currentVersion == minVersion && minPrerelease != 0 && currentPrerelease >= minPrerelease)   return true;
+            // * all other combinatons                                                                          return false;
+            if (currentVersion > minVersion)
+            { 
+                return true; 
+            }
+            else if (currentVersion == minVersion)
+            {
+                // The current and minumum versions are the same, check the prerelease portion
+                if (currentPrerelease == minPrerelease) 
+                { 
+                    return true; 
+                }
+                else if ((minPrerelease != 0f) && (currentPrerelease >= minPrerelease)) 
+                { 
+                    return true; 
+                };
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Reports whether or not the MSBuild for Unity is properly enabled in the Unity Package Manager manifest.
+        /// </summary>
         /// <returns>
         /// True if an appropriate verson of MS Build for Unity is configured in the manifest, otherwise false.
         /// </returns>
@@ -65,9 +161,6 @@ internal static bool IsMSBuildForUnityEnabled()
             }
 
             // Read the package manifest a line at a time.
-            bool msBuildFound = false;
-            bool isAppropriateVersion = false;
-            Version minVersion = Version.Parse(MSBuildPackageVersion);
             using (FileStream manifestStream = new FileStream(manifestPath, FileMode.Open, FileAccess.Read))
             {
                 using (StreamReader reader = new StreamReader(manifestStream))
@@ -78,38 +171,16 @@ internal static bool IsMSBuildForUnityEnabled()
                         string line = reader.ReadLine();
                         if (line.Contains(MSBuildPackageName))
                         {
-                            msBuildFound = true;
-
-                            // Next, check the version.
-                            string[] splitLine = line.Split(new char[] { ':' });
-                            if (splitLine.Length == 2)
-                            {
-                                // Ensure correct formatting of the version string, before we attempt to parse it.
-                                string versionString = splitLine[1].Trim(new char[] { ' ', '\"', ',' });
-                                bool replaceOnEquals = false;
-                                if (versionString.Contains("-"))
-                                {
-                                    // The string references a preview version. Truncate at the '-'.
-                                    versionString = versionString.Substring(0, versionString.IndexOf('-'));
-                                    
-                                    // We want to update preview versions to the final.
-                                    replaceOnEquals = true;
-                                }
-
-                                Version version;
-                                if (Version.TryParse(versionString, out version))
-                                {
-                                    isAppropriateVersion = replaceOnEquals ? (version > minVersion) : (version >= minVersion);
-                                }
-                            }
-
-                            break;
+                            // Split the line into packageName : packageVersion
+                            string[] lineComponents = line.Split(new char[] { ':' }, 2);
+
+                            return IsAppropriateMBuildVersion(MSBuildPackageVersion, lineComponents[1]);
                         }
                     }
                 }
             }
 
-            return (msBuildFound && isAppropriateVersion);
+            return false;
         }
 
         /// <summary>
@@ -189,10 +260,14 @@ internal static void EnsureMSBuildForUnity()
             int scopedRegistriesEndIndex = -1;
             int packageLine = -1;
 
+            // Presume that we need to add the MSBuild for Unity package. If this value is false,
+            // we will check to see if the currently configured version meets or exceeds the
+            // minimum requirements.
+            bool needToAddPackage = true;
+
             // Attempt to find the MSBuild for Unity package entry in the dependencies collection
             // This loop also identifies the dependecies collection line and the start / end of a
             // pre-existing scoped registries collections
-            bool addPackage = true;
             for (int i = 0; i < manifestFileLines.Count; i++)
             {
                 if (manifestFileLines[i].Contains("\"scopedRegistries\":"))
@@ -210,12 +285,12 @@ internal static void EnsureMSBuildForUnity()
                 if (manifestFileLines[i].Contains(MSBuildPackageName))
                 {
                     packageLine = i;
-                    addPackage = false;
+                    needToAddPackage = false;
                 }
             }
 
             // If no package was found add it to the dependencies collection.
-            if (addPackage)
+            if (needToAddPackage)
             {
                 // Add the package to the collection (pad the entry with four spaces)
                 manifestFileLines.Insert(dependenciesStartIndex + 1, $"    \"{MSBuildPackageName}\": \"{MSBuildPackageVersion}\",");