Change BaseProvider to use a public API for getting goal state.

jimmylewis · jimmylewis · commit b845a91b1544 · 2024-05-19T01:21:20.000-07:00
Also updated Manifest to use the goal state for the uninstall scenario.
diff --git a/src/LibraryManager.Contracts/IProvider.cs b/src/LibraryManager.Contracts/IProvider.cs
@@ -66,5 +66,10 @@ public interface IProvider
         /// </summary>
         /// <param name="library"></param>
         string GetSuggestedDestination(ILibrary library);
+
+        /// <summary>
+        /// Gets the goal state of the library installation.  Does not imply actual installation.
+        /// </summary>
+        Task<OperationResult<LibraryInstallationGoalState>> GetInstallationGoalStateAsync(ILibraryInstallationState installationState, CancellationToken cancellationToken);
     }
 }
diff --git a/src/LibraryManager/Manifest.cs b/src/LibraryManager/Manifest.cs
@@ -204,8 +204,6 @@ public async Task<ILibraryOperationResult> InstallLibraryAsync(
             string destination,
             CancellationToken cancellationToken)
         {
-            ILibraryOperationResult result;
-
             var desiredState = new LibraryInstallationState()
             {
                 Name = libraryName,
@@ -236,14 +234,14 @@ public async Task<ILibraryOperationResult> InstallLibraryAsync(
                 return conflictResults;
             }
 
-            result = await provider.InstallAsync(desiredState, cancellationToken).ConfigureAwait(false);
+            ILibraryOperationResult installResult = await provider.InstallAsync(desiredState, cancellationToken);
 
-            if (result.Success)
+            if (installResult.Success)
             {
                 AddLibrary(desiredState);
             }
 
-            return result;
+            return installResult;
         }
 
         private ILibraryInstallationState SetDefaultProviderIfNeeded(LibraryInstallationState desiredState)
@@ -510,7 +508,7 @@ private async Task<IEnumerable<FileIdentifier>> GetAllManifestFilesWithVersionsA
                 return allFiles.SelectMany(f => f).Distinct();
             }
 
-           return new List<FileIdentifier>();
+            return new List<FileIdentifier>();
         }
 
         private async Task<IEnumerable<FileIdentifier>> GetFilesWithVersionsAsync(ILibraryInstallationState state)
@@ -567,41 +565,31 @@ private async Task<ILibraryOperationResult> DeleteLibraryFilesAsync(ILibraryInst
             try
             {
                 IProvider provider = _dependencies.GetProvider(state.ProviderId);
-                ILibraryOperationResult updatedStateResult = await provider.UpdateStateAsync(state, CancellationToken.None).ConfigureAwait(false);
-
-                if (updatedStateResult.Success)
+                OperationResult<LibraryInstallationGoalState> getGoalState = await provider.GetInstallationGoalStateAsync(state, cancellationToken).ConfigureAwait(false);
+                if (!getGoalState.Success)
                 {
-                    List<string> filesToDelete = new List<string>();
-                    state = updatedStateResult.InstallationState;
-
-                    foreach (string file in state.Files)
+                    return new LibraryOperationResult(state, [.. getGoalState.Errors])
                     {
-                        var url = new Uri(file, UriKind.RelativeOrAbsolute);
-
-                        if (!url.IsAbsoluteUri)
-                        {
-                            string relativePath = Path.Combine(state.DestinationPath, file).Replace('\\', '/');
-                            filesToDelete.Add(relativePath);
-                        }
-                    }
+                        Cancelled = getGoalState.Cancelled,
+                    };
+                }
 
-                    bool success = true;
-                    if (deleteFilesFunction != null)
-                    {
-                        success = await deleteFilesFunction.Invoke(filesToDelete).ConfigureAwait(false);
-                    }
+                LibraryInstallationGoalState goalState = getGoalState.Result;
 
-                    if (success)
-                    {
-                        return LibraryOperationResult.FromSuccess(updatedStateResult.InstallationState);
-                    }
-                    else
-                    {
-                        return LibraryOperationResult.FromError(PredefinedErrors.CouldNotDeleteLibrary(libraryId));
-                    }
+                bool success = true;
+                if (deleteFilesFunction != null)
+                {
+                    success = await deleteFilesFunction.Invoke(goalState.InstalledFiles.Keys).ConfigureAwait(false);
                 }
 
-                return updatedStateResult;
+                if (success)
+                {
+                    return LibraryOperationResult.FromSuccess(goalState.InstallationState);
+                }
+                else
+                {
+                    return LibraryOperationResult.FromError(PredefinedErrors.CouldNotDeleteLibrary(libraryId));
+                }
             }
             catch (OperationCanceledException)
             {
diff --git a/src/LibraryManager/Providers/BaseProvider.cs b/src/LibraryManager/Providers/BaseProvider.cs
@@ -82,7 +82,7 @@ public virtual async Task<ILibraryOperationResult> InstallAsync(ILibraryInstalla
 
             if (!IsSourceCacheReady(goalState))
             {
-                ILibraryOperationResult updateCacheResult = await RefreshCacheAsync(desiredState, library, cancellationToken);
+                ILibraryOperationResult updateCacheResult = await RefreshCacheAsync(desiredState, getLibrary.Result, cancellationToken);
                 if (!updateCacheResult.Success)
                 {
                     return updateCacheResult;
@@ -231,6 +231,18 @@ public virtual async Task<ILibraryOperationResult> UpdateStateAsync(ILibraryInst
             return LibraryOperationResult.FromSuccess(desiredState);
         }
 
+        public async Task<OperationResult<LibraryInstallationGoalState>> GetInstallationGoalStateAsync(ILibraryInstallationState desiredState, CancellationToken cancellationToken)
+        {
+            // get the library from the catalog
+            OperationResult<ILibrary> getLibrary = await GetLibraryForInstallationState(desiredState, cancellationToken).ConfigureAwait(false);
+            if (!getLibrary.Success)
+            {
+                return OperationResult<LibraryInstallationGoalState>.FromErrors([.. getLibrary.Errors]);
+            }
+
+            return GenerateGoalState(desiredState, getLibrary.Result);
+        }
+
         #endregion
 
         private OperationResult<LibraryInstallationGoalState> GenerateGoalState(ILibraryInstallationState desiredState, ILibrary library)
diff --git a/test/LibraryManager.Mocks/Provider.cs b/test/LibraryManager.Mocks/Provider.cs
@@ -58,6 +58,11 @@ public Provider(IHostInteraction hostInteraction)
         /// </summary>
         public virtual ILibraryOperationResult Result { get; set; }
 
+        /// <summary>
+        /// Gets or sets the goal state to return from <see cref="GetInstallationGoalStateAsync(ILibraryInstallationState, CancellationToken)"/>
+        /// </summary>
+        public LibraryInstallationGoalState GoalState { get; set; }
+
         /// <summary>
         /// Indicates whether libraries with versions are supported.
         /// </summary>
@@ -105,5 +110,13 @@ public string GetSuggestedDestination(ILibrary library)
         {
             return library?.Name;
         }
+
+        /// <summary>
+        /// Returns a stubbed value
+        /// </summary>
+        public Task<OperationResult<LibraryInstallationGoalState>> GetInstallationGoalStateAsync(ILibraryInstallationState installationState, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(OperationResult<LibraryInstallationGoalState>.FromSuccess(GoalState));
+        }
     }
 }
diff --git a/test/LibraryManager.Test/Providers/BaseProviderTest.cs b/test/LibraryManager.Test/Providers/BaseProviderTest.cs
@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Microsoft.Web.LibraryManager.Cache;
 using Microsoft.Web.LibraryManager.Contracts;
@@ -17,6 +19,7 @@ public class BaseProviderTest
     {
         private IHostInteraction _hostInteraction;
         private ILibrary _library;
+        private readonly Mocks.LibraryCatalog _catalog;
 
         public BaseProviderTest()
         {
@@ -39,10 +42,12 @@ public BaseProviderTest()
                 },
             };
 
+            _catalog = new Mocks.LibraryCatalog()
+                .AddLibrary(_library);
         }
 
         [TestMethod]
-        public void GenerateGoalState_NoFileMapping_SpecifyFilesAtLibraryLevel()
+        public async Task GenerateGoalState_NoFileMapping_SpecifyFilesAtLibraryLevel()
         {
             ILibraryInstallationState installState = new LibraryInstallationState
             {
@@ -52,20 +57,25 @@ public void GenerateGoalState_NoFileMapping_SpecifyFilesAtLibraryLevel()
                 DestinationPath = "lib/test",
                 Files = ["folder/*.txt"],
             };
-            BaseProvider provider = new TestProvider(_hostInteraction, cacheService: null);
+            BaseProvider provider = new TestProvider(_hostInteraction, cacheService: null)
+            {
+                Catalog = _catalog,
+            };
             string expectedDestinationFile1 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.WorkingDirectory, "lib/test/folder/file3.txt"));
             string expectedSourceFile1 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.CacheDirectory, "TestProvider/test/1.0/folder/file3.txt"));
 
-            LibraryInstallationGoalState goalState = provider.GenerateGoalState(installState, _library);
+            OperationResult<LibraryInstallationGoalState> getGoalState = await provider.GetInstallationGoalStateAsync(installState, CancellationToken.None);
 
+            Assert.IsTrue(getGoalState.Success);
+            LibraryInstallationGoalState goalState = getGoalState.Result;
             Assert.IsNotNull(goalState);
             Assert.AreEqual(1, goalState.InstalledFiles.Count);
             Assert.IsTrue(goalState.InstalledFiles.TryGetValue(expectedDestinationFile1, out string file1));
             Assert.AreEqual(expectedSourceFile1, file1);
         }
 
         [TestMethod]
-        public void GenerateGoalState_NoFileMapping_NoFilesAtLibraryLevel()
+        public async Task GenerateGoalState_NoFileMapping_NoFilesAtLibraryLevel()
         {
             ILibraryInstallationState installState = new LibraryInstallationState
             {
@@ -74,15 +84,21 @@ public void GenerateGoalState_NoFileMapping_NoFilesAtLibraryLevel()
                 ProviderId = "TestProvider",
                 DestinationPath = "lib/test",
             };
-            BaseProvider provider = new TestProvider(_hostInteraction, cacheService: null);
+            BaseProvider provider = new TestProvider(_hostInteraction, cacheService: null)
+            {
+                Catalog = _catalog,
+            };
             string expectedDestinationFile1 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.WorkingDirectory, "lib/test/file1.txt"));
             string expectedSourceFile1 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.CacheDirectory, "TestProvider/test/1.0/file1.txt"));
             string expectedDestinationFile2 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.WorkingDirectory, "lib/test/file2.txt"));
             string expectedSourceFile2 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.CacheDirectory, "TestProvider/test/1.0/file2.txt"));
             string expectedDestinationFile3 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.WorkingDirectory, "lib/test/folder/file3.txt"));
             string expectedSourceFile3 = FileHelpers.NormalizePath(Path.Combine(provider.HostInteraction.CacheDirectory, "TestProvider/test/1.0/folder/file3.txt"));
 
-            LibraryInstallationGoalState goalState = provider.GenerateGoalState(installState, _library);
+            OperationResult<LibraryInstallationGoalState> getGoalState = await provider.GetInstallationGoalStateAsync(installState, CancellationToken.None);
+
+            Assert.IsTrue(getGoalState.Success);
+            LibraryInstallationGoalState goalState = getGoalState.Result;
 
             Assert.IsNotNull(goalState);
             Assert.AreEqual(3, goalState.InstalledFiles.Count);
@@ -105,10 +121,9 @@ public TestProvider(IHostInteraction hostInteraction, CacheService cacheService)
 
             public override string LibraryIdHintText => Text.CdnjsLibraryIdHintText;
 
-            public override ILibraryCatalog GetCatalog()
-            {
-                throw new NotImplementedException();
-            }
+            public ILibraryCatalog Catalog { get; set; }
+
+            public override ILibraryCatalog GetCatalog() => Catalog;
 
             public override string GetSuggestedDestination(ILibrary library)
             {
diff --git a/test/Microsoft.Web.LibraryManager.Vsix.Test/Shared/LibraryCommandServiceTest.cs b/test/Microsoft.Web.LibraryManager.Vsix.Test/Shared/LibraryCommandServiceTest.cs
@@ -28,6 +28,14 @@ public async Task UninstallAsync_DeletesFilesFromDisk()
             var mockTaskStatusCenterService = new Mock<ITaskStatusCenterService>();
             mockTaskStatusCenterService.Setup(m => m.CreateTaskHandlerAsync(It.IsAny<string>()))
                                        .Returns(Task.FromResult(new Mock<ITaskHandler>().Object));
+            var testInstallationState = new LibraryInstallationState
+            {
+                ProviderId = "testProvider",
+                Files = new[] { "test.js" },
+                DestinationPath = "testDestination",
+            };
+            var testGoalState = new LibraryInstallationGoalState(testInstallationState);
+            testGoalState.InstalledFiles.Add(Path.Combine(mockInteraction.WorkingDirectory, "testDestination", "test.js"), Path.Combine(mockInteraction.WorkingDirectory, "test.js"));
             var mockDependencies = new Dependencies(mockInteraction, new IProvider[]
             {
                 new Mocks.Provider(mockInteraction)
@@ -36,13 +44,9 @@ public async Task UninstallAsync_DeletesFilesFromDisk()
                     Catalog = new Mocks.LibraryCatalog(),
                     Result = new LibraryOperationResult
                     {
-                        InstallationState = new LibraryInstallationState
-                        {
-                            ProviderId = "testProvider",
-                            Files = new [] { "test.js" },
-                            DestinationPath = "testDestination",
-                        }
+                        InstallationState = testInstallationState
                     },
+                    GoalState = testGoalState,
                     SupportsLibraryVersions = true,
                 }
             });

Original file line number	Diff line number	Diff line change
`@@ -66,5 +66,10 @@ public interface IProvider`
`66`	`66`	`/// </summary>`
`67`	`67`	`/// <param name="library"></param>`
`68`	`68`	`string GetSuggestedDestination(ILibrary library);`
	`69`	`+`
	`70`	`+ /// <summary>`
	`71`	`+ /// Gets the goal state of the library installation. Does not imply actual installation.`
	`72`	`+ /// </summary>`
	`73`	`+ Task<OperationResult<LibraryInstallationGoalState>> GetInstallationGoalStateAsync(ILibraryInstallationState installationState, CancellationToken cancellationToken);`
`69`	`74`	`}`
`70`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,11 @@ public Provider(IHostInteraction hostInteraction)`
`58`	`58`	`/// </summary>`
`59`	`59`	`public virtual ILibraryOperationResult Result { get; set; }`
`60`	`60`
	`61`	`+ /// <summary>`
	`62`	`+ /// Gets or sets the goal state to return from <see cref="GetInstallationGoalStateAsync(ILibraryInstallationState, CancellationToken)"/>`
	`63`	`+ /// </summary>`
	`64`	`+ public LibraryInstallationGoalState GoalState { get; set; }`
	`65`	`+`
`61`	`66`	`/// <summary>`
`62`	`67`	`/// Indicates whether libraries with versions are supported.`
`63`	`68`	`/// </summary>`
`@@ -105,5 +110,13 @@ public string GetSuggestedDestination(ILibrary library)`
`105`	`110`	`{`
`106`	`111`	`return library?.Name;`
`107`	`112`	`}`
	`113`	`+`
	`114`	`+ /// <summary>`
	`115`	`+ /// Returns a stubbed value`
	`116`	`+ /// </summary>`
	`117`	`+ public Task<OperationResult<LibraryInstallationGoalState>> GetInstallationGoalStateAsync(ILibraryInstallationState installationState, CancellationToken cancellationToken)`
	`118`	`+ {`
	`119`	`+ return Task.FromResult(OperationResult<LibraryInstallationGoalState>.FromSuccess(GoalState));`
	`120`	`+ }`
`108`	`121`	`}`
`109`	`122`	`}`