winget-cli

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

UninstallInterop.cs (16661B)

      1 // -----------------------------------------------------------------------------
      2 // <copyright file="UninstallInterop.cs" company="Microsoft Corporation">
      3 //     Copyright (c) Microsoft Corporation. Licensed under the MIT License.
      4 // </copyright>
      5 // -----------------------------------------------------------------------------
      6 
      7 namespace AppInstallerCLIE2ETests.Interop
      8 {
      9     using System;
     10     using System.IO;
     11     using System.Threading.Tasks;
     12     using AppInstallerCLIE2ETests.Helpers;
     13     using Microsoft.Management.Deployment;
     14     using Microsoft.Management.Deployment.Projection;
     15     using NUnit.Framework;
     16 
     17     /// <summary>
     18     /// Test uninstall interop.
     19     /// </summary>
     20     [TestFixtureSource(typeof(InstanceInitializersSource), nameof(InstanceInitializersSource.InProcess), Category = nameof(InstanceInitializersSource.InProcess))]
     21     [TestFixtureSource(typeof(InstanceInitializersSource), nameof(InstanceInitializersSource.OutOfProcess), Category = nameof(InstanceInitializersSource.OutOfProcess))]
     22     public class UninstallInterop : BaseInterop
     23     {
     24         private string installDir;
     25         private PackageManager packageManager;
     26         private PackageCatalogReference compositeSource;
     27 
     28         /// <summary>
     29         /// Initializes a new instance of the <see cref="UninstallInterop"/> class.
     30         /// </summary>
     31         /// <param name="initializer">Initializer.</param>
     32         public UninstallInterop(IInstanceInitializer initializer)
     33             : base(initializer)
     34         {
     35         }
     36 
     37         /// <summary>
     38         /// Set up.
     39         /// </summary>
     40         [SetUp]
     41         public void Init()
     42         {
     43             this.packageManager = this.TestFactory.CreatePackageManager();
     44             this.installDir = TestCommon.GetRandomTestDir();
     45 
     46             // Create composite package catalog source
     47             var options = this.TestFactory.CreateCreateCompositePackageCatalogOptions();
     48             var testSource = this.packageManager.GetPackageCatalogByName(Constants.TestSourceName);
     49             Assert.NotNull(testSource, $"{Constants.TestSourceName} cannot be null");
     50             options.Catalogs.Add(testSource);
     51             options.CompositeSearchBehavior = CompositeSearchBehavior.AllCatalogs;
     52             this.compositeSource = this.packageManager.CreateCompositePackageCatalog(options);
     53         }
     54 
     55         /// <summary>
     56         /// Test uninstall exe.
     57         /// </summary>
     58         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
     59         [Test]
     60         public async Task UninstallTestExe()
     61         {
     62             // Find package
     63             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.ExeInstallerPackageId);
     64 
     65             // Configure installation
     66             var installOptions = this.TestFactory.CreateInstallOptions();
     67             installOptions.PackageInstallMode = PackageInstallMode.Silent;
     68             installOptions.PreferredInstallLocation = this.installDir;
     69 
     70             // Install
     71             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
     72             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
     73 
     74             // Find package again, but this time it should detect the installed version
     75             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.ExeInstallerPackageId);
     76             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
     77 
     78             // Uninstall
     79             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
     80             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
     81             Assert.True(TestCommon.VerifyTestExeUninstalled(this.installDir));
     82         }
     83 
     84         /// <summary>
     85         /// Test uninstall msi.
     86         /// </summary>
     87         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
     88         [Test]
     89         public async Task UninstallTestMsi()
     90         {
     91             if (string.IsNullOrEmpty(TestIndex.MsiInstaller))
     92             {
     93                 Assert.Ignore("MSI installer not available");
     94             }
     95 
     96             // Find package
     97             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.MsiInstallerPackageId);
     98 
     99             // Configure installation
    100             var installOptions = this.TestFactory.CreateInstallOptions();
    101             installOptions.PreferredInstallLocation = this.installDir;
    102 
    103             // Install
    104             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    105             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    106 
    107             // Find package again, but this time it should detect the installed version
    108             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.MsiInstallerPackageId);
    109             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    110 
    111             // Uninstall
    112             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    113             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
    114             Assert.True(TestCommon.VerifyTestMsiUninstalled(this.installDir));
    115         }
    116 
    117         /// <summary>
    118         /// Test uninstall msix.
    119         /// </summary>
    120         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
    121         [Test]
    122         public async Task UninstallTestMsix()
    123         {
    124             // Find package
    125             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.MsixInstallerPackageId);
    126 
    127             // Configure installation
    128             var installOptions = this.TestFactory.CreateInstallOptions();
    129 
    130             // Install
    131             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    132             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    133 
    134             // Find package again, but this time it should detect the installed version
    135             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.MsixInstallerPackageId);
    136             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    137 
    138             // Uninstall
    139             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    140             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
    141             Assert.True(TestCommon.VerifyTestMsixUninstalled());
    142         }
    143 
    144         /// <summary>
    145         /// Test uninstall msix with machine scope.
    146         /// </summary>
    147         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
    148         [Test]
    149         public async Task UninstallTestMsixMachineScope()
    150         {
    151             // TODO: Provision and Deprovision api not supported in build server.
    152             Assert.Ignore();
    153 
    154             // Find package
    155             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.MsixInstallerPackageId);
    156 
    157             // Configure installation
    158             var installOptions = this.TestFactory.CreateInstallOptions();
    159             installOptions.PackageInstallScope = PackageInstallScope.System;
    160 
    161             // Install
    162             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    163             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    164 
    165             // Find package again, but this time it should detect the installed version
    166             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.MsixInstallerPackageId);
    167             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    168 
    169             // Uninstall
    170             var uninstallOptions = this.TestFactory.CreateUninstallOptions();
    171             uninstallOptions.PackageUninstallScope = PackageUninstallScope.System;
    172 
    173             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, uninstallOptions);
    174             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
    175             Assert.True(TestCommon.VerifyTestMsixUninstalled(true));
    176         }
    177 
    178         /// <summary>
    179         /// Test uninstall portable package.
    180         /// </summary>
    181         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
    182         [Test]
    183         public async Task UninstallPortable()
    184         {
    185             string installDir = Path.Combine(Environment.GetEnvironmentVariable(Constants.LocalAppData), "Microsoft", "WinGet", "Packages");
    186             string packageDirName = Constants.PortableExePackageDirName;
    187             string productCode = Constants.PortableExePackageDirName;
    188             string commandAlias = Constants.AppInstallerTestExeInstallerExe;
    189             string fileName = Constants.AppInstallerTestExeInstallerExe;
    190 
    191             // Find package
    192             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.PortableExePackageId);
    193 
    194             // Configure installation
    195             var installOptions = this.TestFactory.CreateInstallOptions();
    196 
    197             // Install
    198             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    199             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    200 
    201             // Find package again, but this time it should detect the installed version
    202             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.PortableExePackageId);
    203             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    204 
    205             // Uninstall
    206             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    207             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
    208             TestCommon.VerifyPortablePackage(Path.Combine(installDir, packageDirName), commandAlias, fileName, productCode, false);
    209         }
    210 
    211         /// <summary>
    212         /// Test uninstall portable package with product code.
    213         /// </summary>
    214         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
    215         [Test]
    216         public async Task UninstallPortableWithProductCode()
    217         {
    218             string installDir = Path.Combine(Environment.GetEnvironmentVariable(Constants.LocalAppData), "Microsoft", "WinGet", "Packages");
    219             string packageDirName = Constants.PortableExePackageDirName;
    220             string productCode = Constants.PortableExePackageDirName;
    221             string commandAlias = Constants.AppInstallerTestExeInstallerExe;
    222             string fileName = Constants.AppInstallerTestExeInstallerExe;
    223 
    224             // Find package
    225             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.PortableExePackageId);
    226 
    227             // Configure installation
    228             var installOptions = this.TestFactory.CreateInstallOptions();
    229 
    230             // Install
    231             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    232             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    233 
    234             // Find package again, but this time it should detect the installed version
    235             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.ProductCode, PackageFieldMatchOption.Equals, productCode);
    236             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    237 
    238             // Uninstall
    239             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    240             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
    241             TestCommon.VerifyPortablePackage(Path.Combine(installDir, packageDirName), commandAlias, fileName, productCode, false);
    242         }
    243 
    244         /// <summary>
    245         /// Test uninstall portable package modified symlink.
    246         /// </summary>
    247         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
    248         [Test]
    249         public async Task UninstallPortableModifiedSymlink()
    250         {
    251             string packageId = Constants.PortableExePackageId;
    252             string commandAlias = Constants.AppInstallerTestExeInstallerExe;
    253             string symlinkDirectory = Path.Combine(Environment.GetEnvironmentVariable(Constants.LocalAppData), "Microsoft", "WinGet", "Links");
    254             string symlinkPath = Path.Combine(symlinkDirectory, commandAlias);
    255 
    256             // Find package
    257             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, packageId);
    258 
    259             // Configure installation
    260             var installOptions = this.TestFactory.CreateInstallOptions();
    261 
    262             // Install
    263             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    264             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    265 
    266             // Replace symlink with modified symlink
    267             File.Delete(symlinkPath);
    268             FileSystemInfo modifiedSymlinkInfo = File.CreateSymbolicLink(symlinkPath, "fakeTargetExe");
    269 
    270             // Find package again, but this time it should detect the installed version
    271             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, packageId);
    272             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    273 
    274             // Uninstall
    275             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    276             Assert.AreEqual(UninstallResultStatus.UninstallError, uninstallResult.Status);
    277             Assert.True(modifiedSymlinkInfo.Exists, "Modified symlink should still exist");
    278 
    279             // Remove modified symlink as to not interfere with other tests
    280             modifiedSymlinkInfo.Delete();
    281 
    282             // Uninstall again to clean up.
    283             await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    284         }
    285 
    286         /// <summary>
    287         /// Test uninstall not indexed.
    288         /// </summary>
    289         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
    290         [Test]
    291         public async Task UninstallNotIndexed()
    292         {
    293             const string customProductCode = "{f08fc03c-0b7e-4fca-9b3c-3a384d18a9f3}";
    294 
    295             // Find package
    296             var searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.Id, PackageFieldMatchOption.Equals, Constants.ExeInstallerPackageId);
    297 
    298             // Configure installation
    299             var installOptions = this.TestFactory.CreateInstallOptions();
    300             installOptions.ReplacementInstallerArguments = $"/ProductID {customProductCode} /InstallDir {this.installDir}";
    301 
    302             // Install
    303             var installResult = await this.packageManager.InstallPackageAsync(searchResult.CatalogPackage, installOptions);
    304             Assert.AreEqual(InstallResultStatus.Ok, installResult.Status);
    305 
    306             // Find package again, but this time it should detect the installed version
    307             searchResult = this.FindOnePackage(this.compositeSource, PackageMatchField.ProductCode, PackageFieldMatchOption.Equals, customProductCode);
    308             Assert.NotNull(searchResult.CatalogPackage.InstalledVersion);
    309 
    310             // Uninstall
    311             var uninstallResult = await this.packageManager.UninstallPackageAsync(searchResult.CatalogPackage, this.TestFactory.CreateUninstallOptions());
    312             Assert.AreEqual(UninstallResultStatus.Ok, uninstallResult.Status);
    313             Assert.True(TestCommon.VerifyTestExeUninstalled(this.installDir));
    314         }
    315     }
    316 }