/// <summary>
/// Verifies UX Payload file information in Burn_Manifest.xml
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="acctualFilePath">Path to the acctual file that was packed in the cab.</param>
/// <param name="expectedFileName">Expected file name of the file.</param>
/// <param name="verifyFileIsPrimaryPayload">Check if this file is the primary payload for the UX.</param>
public static void VerifyUXPayloadInformation(string embededResourcesDirectoryPath, string acctualFilePath, string expectedFileName, bool verifyFileIsPrimaryPayload)
{
string expectedFileSize = new FileInfo(acctualFilePath).Length.ToString();
string expectedHash = FileVerifier.ComputeFileSHA1Hash(acctualFilePath);
string burnManifestXPath = string.Format(@"//burn:UX/burn:Payload[@FilePath='{0}']", expectedFileName);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.True(1 == burnManifestNodes.Count, String.Format("No UX payload with the name: '{0}' was found in Burn_Manifest.xml.", expectedFileName));
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "FileSize", expectedFileSize);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Sha1Hash", expectedHash);
// verify the file is the primary payload for the UX
if (verifyFileIsPrimaryPayload)
{
string burnManifestPayloadsXPath = @"//burn:UX/burn:Payload";
XmlNodeList burnManifestPayloadNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestPayloadsXPath);
if (null == burnManifestPayloadNodes[0].Attributes["FilePath"] || burnManifestPayloadNodes[0].Attributes["FilePath"].Value != expectedFileName)
{
Assert.True(false, String.Format("The primary UX Payload in Burn_Manifest.xml is not '{0}'.", expectedFileName));
}
}
// verify the correct file is added to the ux container
string extractedFilePath = Path.Combine(Builder.UXContainerFolderName, expectedFileName);
FileVerifier.VerifyFilesAreIdentical(acctualFilePath, extractedFilePath);
}
/// <summary>
/// Verifies Registration information in Burn_Manifest.xml
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>/// <param name="expectedExecutableName"></param>
/// <param name="expectedDisplayName">Expected value of @Name</param>
/// <param name="expectedVersion">Expected value of @Version</param>
/// <param name="expectedManufacturer">Expected value of @Manufacturer</param>
/// <param name="expectedUpgradeCode">Expected value of @UpgradeCode</param>
/// <param name="expectedAboutUrl">Expected value of @AboutUrl</param>
/// <param name="expectedHelpUrl">Expected value of @HelpUrl</param>
/// <param name="expectedUpdateUrl">Expected value of @UpdateUrl</param>
/// <param name="expectedHelpTelephone">Expected value of @HelpTelephone</param>
/// <param name="expectedDisableModify">Expected value of @DisableModify</param>
/// <param name="expectedDisableRemove">Expected value of @DisableRemove</param>
/// <param name="expectedDisableRepair">Expected value of @DiableRepair</param>
public static void VerifyRegistrationInformation(string embededResourcesDirectoryPath, string expectedExecutableName, string expectedDisplayName, string expectedVersion, string expectedManufacturer,
string expectedUpgradeCode, string expectedAboutUrl, string expectedHelpUrl, string expectedUpdateUrl, string expectedHelpTelephone,
bool expectedDisableModify, bool expectedDisableRemove, bool expectedDisableRepair)
{
string burnManifestXRegistrationPath = @"//burn:Registration";
XmlNodeList burnManifestRegistrationNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXRegistrationPath);
Assert.True(1 == burnManifestRegistrationNodes.Count, "No Registration node was found in Burn_Manifest.xml.");
BundleTests.VerifyAttributeValue(burnManifestRegistrationNodes[0], "ExecutableName", expectedExecutableName);
BundleTests.VerifyAttributeValue(burnManifestRegistrationNodes[0], "Version", expectedVersion);
BundleTests.VerifyAttributeValue(burnManifestRegistrationNodes[0], "UpgradeCode", expectedUpgradeCode);
string burnManifestArpXPath = @"//burn:Registration/burn:Arp";
XmlNodeList burnManifestArpNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestArpXPath);
Assert.True(1 == burnManifestArpNodes.Count, "No Registration/Arp node was found in Burn_Manifest.xml.");
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "DisplayName", expectedDisplayName);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "Publisher", expectedManufacturer);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "HelpLink", expectedHelpUrl);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "HelpTelephone", expectedHelpTelephone);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "AboutUrl", expectedAboutUrl);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "UpdateUrl", expectedUpdateUrl);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "DisableModify", expectedDisableModify ? "yes" : null);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "DisableRepair", expectedDisableRepair ? "yes" : null);
BundleTests.VerifyAttributeValue(burnManifestArpNodes[0], "DisableRemove", expectedDisableRemove ? "yes" : null);
}
/// <summary>
/// Verify the order of elements in BurnManifest.XML
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are</param>
/// <param name="elementName">Elements to look for.</param>
/// <param name="idAttributeName">The attribute to use as an Id for the elements</param>
/// <param name="expectedOrderedValueList">Expected ordered list of the values of the id attribute.</param>
public static void VerifyBurnManifestElementOrder(string embededResourcesDirectoryPath, string elementName, string idAttributeName, string[] expectedOrderedValueList)
{
string burnManifestXPath = string.Format(@"//burn:{0}", elementName);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
BundleTests.VerifyElementOrder(burnManifestNodes, idAttributeName, expectedOrderedValueList);
}
/// <summary>
/// Verify the pacakge Payload information in Burn_Manifest.xml
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="expectedParentPackageType">Parent Package type.</param>
/// <param name="expectedParentPackageName">Parent Package name; this is the attribute used to locate the package.</param>
/// <param name="expectedFileName">Payload name; this is the attribute used to locate the payload.</param>
/// <param name="expectedDownloadURL">@DownloadURL expected value.</param>
/// <param name="acctualFilePath">Path to the acctual file to compate against file in cab.</param>
public static void VerifyPackagePayloadInformation(string embededResourcesDirectoryPath, PackageTests.PackageType expectedParentPackageType, string expectedParentPackageName, string expectedParentPackageId, string expectedFileName, string expectedDownloadURL, string acctualFilePath)
{
string expectedFileSize = new FileInfo(acctualFilePath).Length.ToString();
string expectedHash = FileVerifier.ComputeFileSHA1Hash(acctualFilePath);
// find the Payload element
string payloadXPath = string.Format(@"//burn:Payload[@FilePath='{0}']", expectedFileName);
XmlNodeList payloadNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, payloadXPath);
Assert.AreEqual(1, payloadNodes.Count, "No Package payload with the name: '{0}' was found in Burn_Manifest.xml.", expectedFileName);
BundleTests.VerifyAttributeValue(payloadNodes[0], "FileSize", expectedFileSize);
BundleTests.VerifyAttributeValue(payloadNodes[0], "Sha1Hash", expectedHash);
BundleTests.VerifyAttributeValue(payloadNodes[0], "DownloadUrl", expectedDownloadURL);
// make sure the payload is added to the package
string payloadId = payloadNodes[0].Attributes["Id"].Value;
string packagePayloadRefXPath = string.Format(@"//burn:{0}[@Id='{1}']/burn:PayloadRef[@Id='{2}']", GetPackageElementName(expectedParentPackageType), expectedParentPackageId, payloadId);
XmlNodeList packagePayloadRefNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, packagePayloadRefXPath);
Assert.AreEqual(1, packagePayloadRefNodes.Count, "Package payload with the name: '{0}' was found under Package '{1}'.", expectedFileName, expectedParentPackageId);
// verify the correct file is added to the attached container
if (null == expectedDownloadURL)
{
string extractedFilePath = Path.Combine(Builder.AttachedContainerFolderName, expectedFileName);
FileVerifier.VerifyFilesAreIdentical(acctualFilePath, extractedFilePath);
}
}
/// <summary>
/// Verify MsiPackage elements appear in a specific order
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="packageNames">Names of the MsiPackage elements in order.</param>
public static void VerifyMsiPackageOrder(string embededResourcesDirectoryPath, params string[] packageNames)
{
string burnManifestXPath = @"//burn:MsiPackage |//burn:MspPackage |//burn:MsuPackage |//burn:ExePackage";
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
BundleTests.VerifyElementOrder(burnManifestNodes, "FileName", packageNames);
}
/// <summary>
/// Verifies MsiProperty information Burn_Manifest.xml
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="msiPackageId">Package name; this is the attribute used to locate the package.</param>
/// <param name="expectedPropertyName">Expected MsiProperty @Name value.</param>
/// <param name="expectedPropertyValue">Expected MsiProperty @Value value.</param>
public static void VerifyMsiPropertyInformation(string embededResourcesDirectoryPath, string msiPackageId, string expectedPropertyName, string expectedPropertyValue)
{
string burnManifestXPath = string.Format(@"//burn:{0}[@Id='{1}']/burn:MsiProperty[@Id='{2}'] ", GetPackageElementName(PackageType.MSI), msiPackageId, expectedPropertyName);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.AreEqual(1, burnManifestNodes.Count, "No MsiProperty with the Id: '{0}' was found under MsiPackage: '{1}' in Burn_Manifest.xml.", expectedPropertyName, msiPackageId);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Value", expectedPropertyValue);
}
/// <summary>
/// Verifies Variable information in Burn_Manifest.xml.
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="variableName">Expected name of the variable.</param>
/// <param name="variableValue">Expected value of the variable.</param>
/// <param name="variableType">Expected Type of the variable.</param>
public static void VerifyVariableInformation(string embededResourcesDirectoryPath, string variableName, string variableValue, VariableType variableType)
{
string expectedVariableTypeName = GetVariableTypeName(variableType);
string burnManifestXPath = string.Format(@"//burn:Variable[@Id='{0}']", variableName);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.AreEqual(1, burnManifestNodes.Count, "No Variable with the name: '{0}' was found in Burn_Manifest.xml.", variableName);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Value", variableValue);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Type", expectedVariableTypeName);
}
/// <summary>
/// Verifies FileSearch information in Burn_Manifest.xml.
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="expectedId">Expected FileSearch @Id; this attribute is used to search for the element.</param>
/// <param name="expectedPath">Expected FileSearch @Path value.</param>
/// <param name="expectedVariableName">Expected FileSearch @Variable value.</param>
/// <param name="expectedCondition">Expected FileSearch @Condition value.</param>
/// <param name="expectedResult">Expected FileSearch @Attribute value.</param>
public static void VerifyFileSearchInformation(string embededResourcesDirectoryPath, string expectedId, string expectedPath, string expectedVariableName, string expectedCondition, string expectedResult)
{
string burnManifestXPath = string.Format(@"//burn:FileSearch[@Id='{0}']", expectedId);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.True(1 == burnManifestNodes.Count, String.Format("No FileSearch with the Id: '{0}' was found in Burn_Manifest.xml.", expectedId));
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Path", expectedPath);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Variable", expectedVariableName);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Type", expectedResult);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Condition", expectedCondition);
}
/// <summary>
/// Verifies ComponentSearch information in Burn_Manifest.xml.
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="expectedId">Expected ComponentSearch @Id; this attribute is used to search for the element.</param>
/// <param name="expectedProdcutCode">Expected ComponentSearch @ProductCode value.</param>
/// <param name="expectedGuid">Expected ComponentSearch @Guid value.</param>
/// <param name="expectedVariableName">Expected ComponentSearch @Variable value.</param>
/// <param name="expectedCondition">Expected ComponentSearch @Condition value.</param>
/// <param name="expectedResult">Expected ComponentSearch @Attribute value.</param>
public static void VerifyComponentSearchInformation(string embededResourcesDirectoryPath, string expectedId, string expectedGuid, string expectedProdcutCode, string expectedVariableName, string expectedCondition, string expectedResult)
{
string burnManifestXPath = string.Format(@"//burn:MsiComponentSearch[@Id='{0}']", expectedId);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.AreEqual(1, burnManifestNodes.Count, "No ComponentSearch with the Id: '{0}' was found in Burn_Manifest.xml.", expectedId);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "ComponentId", expectedGuid);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "ProductCode", expectedProdcutCode);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Variable", expectedVariableName);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Type", expectedResult);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Condition", expectedCondition);
}
/// <summary>
/// Verifies RegistrySearch information in Burn_Manifest.xml.
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="expectedId">Expected RegistrySearch @Id; this attribute is used to search for the element.</param>
/// <param name="expectedRoot">Expected RegistrySearch @Root value.</param>
/// <param name="expectedKey">Expected RegistrySearch @Key value.</param>
/// <param name="expectedVariableName">Expected RegistrySearch @Variable value.</param>
/// <param name="expectedCondition">Expected RegistrySearch @Condition value.</param>
/// <param name="expectedValue">Expected RegistrySearch @Value value.</param>
/// <param name="expectedResult">Expected RegistrySearch @Attribute value.</param>
/// <param name="expectedExpandEnvironmentVariables">Expected RegistrySearch @ExpandEnvironmentVariables value.</param>
/// <param name="expectedFormat">Expected RegistrySearch @Format value.</param>
/// TODO: Check for @Format value
public static void VerifyRegistrySearchInformation(string embededResourcesDirectoryPath, string expectedId, string expectedRoot, string expectedKey,
string expectedVariableName, string expectedCondition, string expectedValue, string expectedResult,
string expectedExpandEnvironmentVariables, string expectedFormat)
{
// verify the Burn_Manifest has the correct information
string burnManifestXPath = string.Format(@"//burn:RegistrySearch[@Id='{0}']", expectedId);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.AreEqual(1, burnManifestNodes.Count, "No RegistrySearch with the Id: '{0}' was found in Burn_Manifest.xml.", expectedId);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Root", expectedRoot);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Key", expectedKey);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Variable", expectedVariableName);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Type", expectedResult);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Condition", expectedCondition);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Value", expectedValue);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "ExpandEnvironment", expectedExpandEnvironmentVariables);
//BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Format", expectedFormat);
}
/// <summary>
/// Verifies Package information in Burn-Manifest.xml and Burn-UxManifest.xml.
/// </summary>
/// <param name="embededResourcesDirectoryPath">Output folder where all the embeded resources are.</param>
/// <param name="expectedPackageName">Package name; this is the attribute used to locate the package.</param>
/// <param name="expectedPackageType">Package type MSI, MSP, MSU or EXE.</param>
/// <param name="expectedId">Expected Package @Id value.</param>
/// <param name="expectedInstallCondition">Expected Package @InstallCondition value.</param>
/// <param name="expectedProductCode">Expected Package @ProductCode value.</param>
/// <param name="expecteVital">Package is viatal or not.</param>
/// <param name="expectedPermanent">Expected Package @Permanent value.</param>
/// <param name="expectedCacheId">Expected Package @CacheId value.</param>
/// <param name="expectedInstallCommmand">Expected @InstallCommand value.</param>
/// <param name="expectedUninstallCommmand">Expected @UninstallCommand value.</param>
/// <param name="expectedRepairCommand">Expected @RepairCommand value.</param>
/// <param name="expectedDownloadURL">Expected Package @DownloadURL value.</param>
/// <param name="acctualFilePath">Path to the acctual file for comparison.</param>
private static void VerifyPackageInformation(string embededResourcesDirectoryPath, string expectedPackageName, PackageType expectedPackageType, string expectedId,
string expectedInstallCondition, string expectedProductCode, bool expecteVital, bool expectedPermanent, string expectedCacheId,
string expectedInstallCommmand, string expectedUninstallCommmand, string expectedRepairCommand, string expectedDownloadURL,
string acctualFilePath)
{
string expectedFileSize = new FileInfo(acctualFilePath).Length.ToString();
string expectedHash = FileVerifier.ComputeFileSHA1Hash(acctualFilePath);
string expectedProductSize = expectedFileSize;
// verify the Burn_Manifest has the correct information
string burnManifestXPath = string.Format(@"//burn:{0}[@Id='{1}']", GetPackageElementName(expectedPackageType), expectedId);
XmlNodeList burnManifestNodes = BundleTests.QueryBurnManifest(embededResourcesDirectoryPath, burnManifestXPath);
Assert.AreEqual(1, burnManifestNodes.Count, "No MsiPackage with the Id: '{0}' was found in Burn_Manifest.xml.", expectedId);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "InstallCondition", expectedInstallCondition);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Permanent", expectedPermanent ? "yes" : "no");
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "Vital", expecteVital ? "yes" : "no");
if (expectedPackageType == PackageType.MSI)
{
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "ProductCode", expectedProductCode);
}
if (expectedPackageType == PackageType.EXE)
{
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "InstallArguments", expectedInstallCommmand);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "UninstallArguments", expectedUninstallCommmand);
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "RepairArguments", expectedRepairCommand);
}
if (!String.IsNullOrEmpty(expectedCacheId))
{
BundleTests.VerifyAttributeValue(burnManifestNodes[0], "CacheId", expectedCacheId);
}
// verify payload information
PackageTests.VerifyPackagePayloadInformation(embededResourcesDirectoryPath, expectedPackageType, expectedPackageName, expectedId, expectedPackageName, expectedDownloadURL, acctualFilePath);
// verify the Burn-UxManifest has the correct information
string expectedProductName = null;
string expectedDiscription = null;
if (expectedPackageType == PackageType.EXE)
{
FileVersionInfo fileInfo = FileVersionInfo.GetVersionInfo(acctualFilePath);
expectedProductName = string.IsNullOrEmpty(fileInfo.ProductName) ? null : fileInfo.ProductName;
expectedDiscription = string.IsNullOrEmpty(fileInfo.FileDescription) ? null : fileInfo.FileDescription;
}
else if (expectedPackageType == PackageType.MSI)
{
string subject = Verifier.GetMsiSummaryInformationProperty(acctualFilePath, Verifier.MsiSummaryInformationProperty.Subject);
expectedProductName = string.IsNullOrEmpty(subject) ? null : subject;
}
string burnUxManifestXPath = string.Format(@"//burnUx:WixPackageProperties[@Package='{0}']", expectedId);
XmlNodeList burnUxManifestNodes = BundleTests.QueryBurnUxManifest(embededResourcesDirectoryPath, burnUxManifestXPath);
Assert.AreEqual(1, burnUxManifestNodes.Count, "No WixPackageProperties for Package: '{0}' was found in Burn-UxManifest.xml.", expectedId);
BundleTests.VerifyAttributeValue(burnUxManifestNodes[0], "Vital", expecteVital ? "yes" : "no");
BundleTests.VerifyAttributeValue(burnUxManifestNodes[0], "DownloadSize", expectedFileSize);
BundleTests.VerifyAttributeValue(burnUxManifestNodes[0], "PackageSize", expectedFileSize);
BundleTests.VerifyAttributeValue(burnUxManifestNodes[0], "InstalledSize", expectedFileSize);
BundleTests.VerifyAttributeValue(burnUxManifestNodes[0], "DisplayName", expectedProductName);
BundleTests.VerifyAttributeValue(burnUxManifestNodes[0], "Description", expectedDiscription);
}