Add cache location management commands for relocating .winapp packages

src/winapp-CLI/WinApp.Cli.Tests/CacheCommandTests.cs

@@ -0,0 +1,254 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using WinApp.Cli.Commands;
+using WinApp.Cli.Services;
+
+namespace WinApp.Cli.Tests;
+
+[TestClass]
+public class CacheCommandTests : BaseCommandTests
+{
+    private ICacheService _cacheService = null!;
+    private IWinappDirectoryService _winappDirectoryService = null!;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        _cacheService = GetRequiredService<ICacheService>();
+        _winappDirectoryService = GetRequiredService<IWinappDirectoryService>();
+    }
+
+    [TestMethod]
+    public void GetCacheDirectory_ReturnsDefaultLocation_WhenNoCustomLocationSet()
+    {
+        // Act
+        var cacheDir = _cacheService.GetCacheDirectory();
+        var customLocation = _cacheService.GetCustomCacheLocation();
+
+        // Assert
+        Assert.IsNotNull(cacheDir);
+        Assert.IsNull(customLocation);
+        Assert.IsTrue(cacheDir.FullName.Contains("packages"));
+    }
+
+    [TestMethod]
+    public void GetCacheDirectory_ReturnsCustomLocation_WhenSet()
+    {
+        // Arrange
+        var customPath = Path.Combine(_tempDirectory.FullName, "custom-cache");
+
+        // Act
+        _cacheService.SetCustomCacheLocation(customPath);
+        var cacheDir = _cacheService.GetCacheDirectory();
+        var customLocation = _cacheService.GetCustomCacheLocation();
+
+        // Assert
+        Assert.IsNotNull(cacheDir);
+        Assert.IsNotNull(customLocation);
+        Assert.AreEqual(customPath, customLocation);
+        Assert.AreEqual(customPath, cacheDir.FullName);
+    }
+
+    [TestMethod]
+    public void SetCustomCacheLocation_CreatesConfigFile()
+    {
+        // Arrange
+        var customPath = Path.Combine(_tempDirectory.FullName, "custom-cache");
+
+        // Act
+        _cacheService.SetCustomCacheLocation(customPath);
+
+        // Assert
+        var configFile = Path.Combine(_testWinappDirectory.FullName, "cache-config.json");
+        Assert.IsTrue(File.Exists(configFile), "Config file should be created");
+
+        var configContent = File.ReadAllText(configFile);
+        Assert.IsTrue(configContent.Contains(customPath), "Config should contain custom path");
+    }
+
+    [TestMethod]
+    public void RemoveCustomCacheLocation_DeletesConfigFile()
+    {
+        // Arrange
+        var customPath = Path.Combine(_tempDirectory.FullName, "custom-cache");
+        _cacheService.SetCustomCacheLocation(customPath);
+        var configFile = Path.Combine(_testWinappDirectory.FullName, "cache-config.json");
+        Assert.IsTrue(File.Exists(configFile), "Config file should exist");
+
+        // Act
+        _cacheService.RemoveCustomCacheLocation();
+
+        // Assert
+        Assert.IsFalse(File.Exists(configFile), "Config file should be deleted");
+    }
+
+    [TestMethod]
+    public async Task MoveCacheAsync_ThrowsException_WhenPathIsEmpty()
+    {
+        // Act & Assert
+        await Assert.ThrowsExactlyAsync<ArgumentException>(async () =>
+        {
+            await _cacheService.MoveCacheAsync("");
+        });
+    }
+
+    [TestMethod]
+    public async Task MoveCacheAsync_ThrowsException_WhenTargetDirectoryIsNotEmpty()
+    {
+        // Arrange
+        var targetDir = _tempDirectory.CreateSubdirectory("target");
+        File.WriteAllText(Path.Combine(targetDir.FullName, "test.txt"), "test");
+
+        // Act & Assert
+        await Assert.ThrowsExactlyAsync<InvalidOperationException>(async () =>
+        {
+            await _cacheService.MoveCacheAsync(targetDir.FullName);
+        });
+    }
+
+    [TestMethod]
+    public async Task MoveCacheAsync_MovesExistingCache_ToNewLocation()
+    {
+        // Arrange
+        var defaultCacheDir = _winappDirectoryService.GetPackagesDirectory();
+        defaultCacheDir.Create();
+
+        // Create some test content in the default cache
+        var testPackageDir = defaultCacheDir.CreateSubdirectory("TestPackage.1.0.0");
+        File.WriteAllText(Path.Combine(testPackageDir.FullName, "test.txt"), "test content");
+
+        var targetDir = _tempDirectory.CreateSubdirectory("new-cache-location");
+        targetDir.Delete(); // Delete so MoveCacheAsync will be prompted to create it
+
+        // Note: This test won't prompt because Program.PromptYesNo is not mocked
+        // For a real scenario, we'd need to mock the prompt
+
+        // For now, let's just test with an existing empty directory
+        targetDir.Create();
+
+        // Act
+        await _cacheService.MoveCacheAsync(targetDir.FullName);
+
+        // Assert
+        var movedPackageDir = new DirectoryInfo(Path.Combine(targetDir.FullName, "TestPackage.1.0.0"));
+        Assert.IsTrue(movedPackageDir.Exists, "Package directory should be moved");
+        Assert.IsTrue(File.Exists(Path.Combine(movedPackageDir.FullName, "test.txt")), "Package file should be moved");
+        Assert.IsFalse(testPackageDir.Exists, "Original package directory should be removed");
+
+        var customLocation = _cacheService.GetCustomCacheLocation();
+        Assert.AreEqual(targetDir.FullName, customLocation, "Custom location should be set");
+    }
+
+    [TestMethod]
+    public async Task MoveCacheAsync_SetsCustomLocation_WhenCacheDoesNotExist()
+    {
+        // Arrange
+        var defaultCacheDir = _winappDirectoryService.GetPackagesDirectory();
+        Assert.IsFalse(defaultCacheDir.Exists, "Default cache should not exist");
+
+        var targetDir = _tempDirectory.CreateSubdirectory("new-cache-location");
+
+        // Act
+        await _cacheService.MoveCacheAsync(targetDir.FullName);
+
+        // Assert
+        var customLocation = _cacheService.GetCustomCacheLocation();
+        Assert.AreEqual(targetDir.FullName, customLocation, "Custom location should be set");
+    }
+
+    [TestMethod]
+    public async Task ClearCacheAsync_RemovesAllContent_FromCacheDirectory()
+    {
+        // Arrange
+        var cacheDir = _winappDirectoryService.GetPackagesDirectory();
+        cacheDir.Create();
+
+        var testPackage1 = cacheDir.CreateSubdirectory("Package1.1.0.0");
+        File.WriteAllText(Path.Combine(testPackage1.FullName, "test1.txt"), "test1");
+
+        var testPackage2 = cacheDir.CreateSubdirectory("Package2.2.0.0");
+        File.WriteAllText(Path.Combine(testPackage2.FullName, "test2.txt"), "test2");
+
+        Assert.AreEqual(2, cacheDir.GetDirectories().Length, "Should have 2 packages");
+
+        // Act
+        await _cacheService.ClearCacheAsync();
+
+        // Assert
+        cacheDir.Refresh();
+        Assert.AreEqual(0, cacheDir.GetFileSystemInfos().Length, "Cache should be empty");
+    }
+
+    [TestMethod]
+    public async Task ClearCacheAsync_DoesNotThrow_WhenCacheDoesNotExist()
+    {
+        // Arrange
+        var cacheDir = _winappDirectoryService.GetPackagesDirectory();
+        Assert.IsFalse(cacheDir.Exists, "Cache should not exist");
+
+        // Act & Assert - should not throw
+        await _cacheService.ClearCacheAsync();
+    }
+
+    [TestMethod]
+    public void GetPackagesDirectory_ReturnsCustomLocation_WhenConfigured()
+    {
+        // Arrange
+        var customPath = Path.Combine(_tempDirectory.FullName, "custom-packages");
+        _cacheService.SetCustomCacheLocation(customPath);
+
+        // Act
+        var packagesDir = _winappDirectoryService.GetPackagesDirectory();
+
+        // Assert
+        Assert.AreEqual(customPath, packagesDir.FullName);
+    }
+
+    [TestMethod]
+    public void GetPackagesDirectory_ReturnsDefaultLocation_WhenNotConfigured()
+    {
+        // Act
+        var packagesDir = _winappDirectoryService.GetPackagesDirectory();
+
+        // Assert
+        Assert.IsTrue(packagesDir.FullName.EndsWith("packages"));
+        Assert.IsTrue(packagesDir.FullName.Contains(_testWinappDirectory.FullName));
+    }
+
+    [TestMethod]
+    public void CacheCommand_Integration_GetPath()
+    {
+        // Arrange
+        var command = GetRequiredService<CacheGetPathCommand>();
+        var handler = GetRequiredService<CacheGetPathCommand.Handler>();
+
+        // Act
+        var result = handler.InvokeAsync(command.Parse(Array.Empty<string>())).Result;
+
+        // Assert
+        Assert.AreEqual(0, result);
+        var output = ConsoleStdOut.ToString();
+        StringAssert.Contains(output, "Package cache location", "Output should contain cache location message");
+    }
+
+    [TestMethod]
+    public async Task CacheCommand_Integration_Clear()
+    {
+        // Arrange
+        var cacheDir = _winappDirectoryService.GetPackagesDirectory();
+        cacheDir.Create();
+        var testFile = Path.Combine(cacheDir.FullName, "test.txt");
+        File.WriteAllText(testFile, "test");
+
+        var command = GetRequiredService<CacheClearCommand>();
+        var handler = GetRequiredService<CacheClearCommand.Handler>();
+
+        // Mock the prompt to return yes - this is a limitation of the current test
+        // In a real scenario, we'd need to refactor to make prompting testable
+
+        // For now, just verify the command is registered
+        Assert.IsNotNull(command);
+        Assert.IsNotNull(handler);
+    }
+}

src/winapp-CLI/WinApp.Cli/Commands/CacheClearCommand.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.Extensions.Logging;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using WinApp.Cli.Helpers;
+using WinApp.Cli.Services;
+
+namespace WinApp.Cli.Commands;
+
+internal class CacheClearCommand : Command
+{
+    public CacheClearCommand() : base("clear", "Clear all contents of the package cache")
+    {
+    }
+
+    public class Handler(ICacheService cacheService, ILogger<CacheClearCommand> logger) : AsynchronousCommandLineAction
+    {
+        public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Confirm before clearing
+                logger.LogWarning("This will delete all cached packages. Are you sure?");
+                if (!Program.PromptYesNo("Continue? (y/n): "))
+                {
+                    logger.LogInformation("Operation cancelled");
+                    return 1;
+                }
+
+                await cacheService.ClearCacheAsync(cancellationToken);
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError("{UISymbol} Error clearing cache: {ErrorMessage}", UiSymbols.Error, ex.Message);
+                logger.LogDebug("Stack Trace: {StackTrace}", ex.StackTrace);
+                return 1;
+            }
+        }
+    }
+}

src/winapp-CLI/WinApp.Cli/Commands/CacheCommand.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.CommandLine;
+
+namespace WinApp.Cli.Commands;
+
+internal class CacheCommand : Command
+{
+    public CacheCommand(CacheGetPathCommand cacheGetPathCommand, CacheMoveCommand cacheMoveCommand, CacheClearCommand cacheClearCommand)
+        : base("cache", "Manage the package cache location")
+    {
+        Subcommands.Add(cacheGetPathCommand);
+        Subcommands.Add(cacheMoveCommand);
+        Subcommands.Add(cacheClearCommand);
+    }
+}

src/winapp-CLI/WinApp.Cli/Commands/CacheGetPathCommand.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.Extensions.Logging;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using WinApp.Cli.Helpers;
+using WinApp.Cli.Services;
+
+namespace WinApp.Cli.Commands;
+
+internal class CacheGetPathCommand : Command
+{
+    public CacheGetPathCommand() : base("get-path", "Get the current package cache directory path")
+    {
+    }
+
+    public class Handler(ICacheService cacheService, ILogger<CacheGetPathCommand> logger) : AsynchronousCommandLineAction
+    {
+        public override Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var cacheDir = cacheService.GetCacheDirectory();
+                var customLocation = cacheService.GetCustomCacheLocation();
+
+                if (!string.IsNullOrEmpty(customLocation))
+                {
+                    logger.LogInformation("{UISymbol} Package cache location (custom): {Path}", UiSymbols.Folder, cacheDir.FullName);
+                }
+                else
+                {
+                    logger.LogInformation("{UISymbol} Package cache location (default): {Path}", UiSymbols.Folder, cacheDir.FullName);
+                }
+
+                if (!cacheDir.Exists)
+                {
+                    logger.LogInformation("{UISymbol} Cache directory does not exist yet", UiSymbols.Note);
+                }
+
+                return Task.FromResult(0);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError("{UISymbol} Error getting cache path: {ErrorMessage}", UiSymbols.Error, ex.Message);
+                logger.LogDebug("Stack Trace: {StackTrace}", ex.StackTrace);
+                return Task.FromResult(1);
+            }
+        }
+    }
+}