winget-cli

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

WinGetUtilManifest.cs (7647B)

      1 // -----------------------------------------------------------------------------
      2 // <copyright file="WinGetUtilManifest.cs" company="Microsoft Corporation">
      3 //     Copyright (c) Microsoft Corporation. Licensed under the MIT License.
      4 // </copyright>
      5 // -----------------------------------------------------------------------------
      6 
      7 namespace AppInstallerCLIE2ETests.WinGetUtil
      8 {
      9     using System;
     10     using System.IO;
     11     using AppInstallerCLIE2ETests.Helpers;
     12     using NUnit.Framework;
     13 
     14     /// <summary>
     15     /// Test winget util manifest.
     16     /// </summary>
     17     public class WinGetUtilManifest
     18     {
     19         private IntPtr indexHandle;
     20 
     21         /// <summary>
     22         /// Set up.
     23         /// </summary>
     24         [SetUp]
     25         public void SetUp()
     26         {
     27             this.indexHandle = IntPtr.Zero;
     28             var sqliteFile = TestCommon.GetRandomTestFile(".db");
     29             uint majorVersion = 1;
     30             uint minorVersion = 2;
     31             WinGetUtilWrapper.WinGetSQLiteIndexCreate(sqliteFile, majorVersion, minorVersion, out this.indexHandle);
     32         }
     33 
     34         /// <summary>
     35         /// Tear down.
     36         /// </summary>
     37         [TearDown]
     38         public void TearDown()
     39         {
     40             WinGetUtilWrapper.WinGetSQLiteIndexClose(this.indexHandle);
     41         }
     42 
     43         /// <summary>
     44         /// Test validate manifest.
     45         /// </summary>
     46         /// <param name="createManifestOption">Create manifest options.</param>
     47         [Test]
     48         [TestCase(WinGetUtilWrapper.CreateManifestOption.NoValidation)]
     49         [TestCase(WinGetUtilWrapper.CreateManifestOption.SchemaAndSemanticValidation)]
     50         public void WinGetUtil_ValidateManifest_Success(WinGetUtilWrapper.CreateManifestOption createManifestOption)
     51         {
     52             string manifestsDir = TestCommon.GetTestDataFile(@"WinGetUtil\Manifests\Unmerged\ValidateManifest");
     53             string mergedManifestPath = TestCommon.GetRandomTestFile(".yaml");
     54 
     55             // Create manifest
     56             WinGetUtilWrapper.WinGetCreateManifest(
     57                 manifestsDir,
     58                 out bool succeeded,
     59                 out IntPtr manifestHandle,
     60                 out string createFailureMessage,
     61                 mergedManifestPath,
     62                 createManifestOption);
     63 
     64             Assert.True(succeeded);
     65             Assert.AreNotEqual(IntPtr.Zero, manifestHandle);
     66             Assert.IsNull(createFailureMessage);
     67             Assert.True(File.Exists(mergedManifestPath));
     68 
     69             // Validate manifest
     70             WinGetUtilWrapper.WinGetValidateManifestV3(
     71                 manifestHandle,
     72                 this.indexHandle,
     73                 out WinGetUtilWrapper.ValidateManifestResultCode resultCode,
     74                 out string validateFailureMessage,
     75                 WinGetUtilWrapper.ValidateManifestOptionV2.ArpVersionValidation,
     76                 WinGetUtilWrapper.ValidateManifestOperationType.Add);
     77 
     78             Assert.AreEqual(WinGetUtilWrapper.ValidateManifestResultCode.Success, resultCode);
     79             Assert.IsEmpty(validateFailureMessage);
     80 
     81             // Close manifest
     82             WinGetUtilWrapper.WinGetCloseManifest(manifestHandle);
     83         }
     84 
     85         /// <summary>
     86         /// Test validate manifest with schema header.
     87         /// </summary>
     88         /// <param name="createManifestOption">Create manifest options.</param>
     89         [Test]
     90         [TestCase(WinGetUtilWrapper.CreateManifestOption.NoValidation)]
     91         [TestCase(WinGetUtilWrapper.CreateManifestOption.SchemaAndSemanticValidation)]
     92         public void WinGetUtil_ValidateManifest_V1_10_WithSchemaHeader_Success(WinGetUtilWrapper.CreateManifestOption createManifestOption)
     93         {
     94             string manifestsFilePath = TestCommon.GetTestDataFile(@"Manifests\TestGoodManifestV1_10-SchemaHeader.yaml");
     95 
     96             // Create manifest
     97             WinGetUtilWrapper.WinGetCreateManifest(
     98                 manifestsFilePath,
     99                 out bool succeeded,
    100                 out IntPtr manifestHandle,
    101                 out string createFailureMessage,
    102                 string.Empty,
    103                 createManifestOption);
    104 
    105             Assert.True(succeeded);
    106             Assert.AreNotEqual(IntPtr.Zero, manifestHandle);
    107             Assert.IsNull(createFailureMessage);
    108 
    109             // Close manifest
    110             WinGetUtilWrapper.WinGetCloseManifest(manifestHandle);
    111         }
    112 
    113         /// <summary>
    114         /// Test validate manifest with schema header for failure scenarios.
    115         /// </summary>
    116         /// <param name="createManifestOption">Create manifest options.</param>
    117         [Test]
    118         [TestCase(WinGetUtilWrapper.CreateManifestOption.SchemaAndSemanticValidation)]
    119         public void WinGetUtil_ValidateManifest_V1_10_WithSchemaHeader_Failure(WinGetUtilWrapper.CreateManifestOption createManifestOption)
    120         {
    121             // Schema header not found
    122             string manifestsFilePath = TestCommon.GetTestDataFile(@"Manifests\TestWarningManifestV1_10-SchemaHeaderNotFound.yaml");
    123             string expectedError = "Manifest Error: Schema header not found.";
    124             ValidateSchemaHeaderFailure(manifestsFilePath, createManifestOption, expectedError);
    125 
    126             // Schema header invalid
    127             manifestsFilePath = TestCommon.GetTestDataFile(@"Manifests\TestWarningManifestV1_10-SchemaHeaderInvalid.yaml");
    128             expectedError = "Manifest Error: The schema header is invalid. Please verify that the schema header is present and formatted correctly.";
    129             ValidateSchemaHeaderFailure(manifestsFilePath, createManifestOption, expectedError);
    130 
    131             // Schema header URL pattern mismatch
    132             manifestsFilePath = TestCommon.GetTestDataFile(@"Manifests\TestWarningManifestV1_10-SchemaHeaderURLPatternMismatch.yaml");
    133             expectedError = "Manifest Error: The schema header URL does not match the expected pattern.";
    134             ValidateSchemaHeaderFailure(manifestsFilePath, createManifestOption, expectedError);
    135 
    136             // Schema header manifest type mismatch
    137             manifestsFilePath = TestCommon.GetTestDataFile(@"Manifests\TestWarningManifestV1_10-SchemaHeaderManifestTypeMismatch.yaml");
    138             expectedError = "Manifest Error: The manifest type in the schema header does not match the ManifestType property value in the manifest.";
    139             ValidateSchemaHeaderFailure(manifestsFilePath, createManifestOption, expectedError);
    140 
    141             // Schema header version mismatch
    142             manifestsFilePath = TestCommon.GetTestDataFile(@"Manifests\TestWarningManifestV1_10-SchemaHeaderVersionMismatch.yaml");
    143             expectedError = "Manifest Error: The manifest version in the schema header does not match the ManifestVersion property value in the manifest.";
    144             ValidateSchemaHeaderFailure(manifestsFilePath, createManifestOption, expectedError);
    145         }
    146 
    147         private static void ValidateSchemaHeaderFailure(string manifestsFilePath, WinGetUtilWrapper.CreateManifestOption createManifestOption, string expectedError)
    148         {
    149             // Create manifest
    150             WinGetUtilWrapper.WinGetCreateManifest(
    151                 manifestsFilePath,
    152                 out bool succeeded,
    153                 out IntPtr manifestHandle,
    154                 out string createFailureMessage,
    155                 string.Empty,
    156                 createManifestOption);
    157 
    158             Assert.False(succeeded);
    159             Assert.AreEqual(IntPtr.Zero, manifestHandle);
    160             Assert.IsNotNull(createFailureMessage);
    161             Assert.IsTrue(createFailureMessage.Contains(expectedError));
    162         }
    163     }
    164 }