public void GetOrAddFilePathChangeToken_DoesNotAddsPollingChangeTokenWhenCallbackIsDisabled()
{
using (var root = new DisposableFileSystem())
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
var changeToken = physicalFilesWatcher.GetOrAddFilePathChangeToken("some-path");
Assert.IsType <CancellationChangeToken>(changeToken);
Assert.Empty(physicalFilesWatcher.PollingChangeTokens);
}
}
public void FilesAreEnumerated()
{
using (var scenario = new DisposableFileSystem()
.CreateFile("alpha.txt"))
{
var contents = new DirectoryInfoWrapper(scenario.DirectoryInfo).EnumerateFileSystemInfos();
var alphaTxt = contents.OfType <FileInfoBase>().Single();
Assert.Single(contents);
Assert.Equal("alpha.txt", alphaTxt.Name);
}
}
public void CanBuildWixiplUsingExtensionLibrary()
{
var folder = TestData.Get(@"TestData\Wixipl");
var extensionPath = Path.GetFullPath(new Uri(typeof(ExampleExtensionFactory).Assembly.CodeBase).LocalPath);
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var result = WixRunner.Execute(new[]
{
"build",
"-ext", extensionPath,
Path.Combine(folder, "Package.wxs"),
Path.Combine(folder, "PackageComponents.wxs"),
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(intermediateFolder, @"test.wixipl"),
});
result.AssertSuccess();
result = WixRunner.Execute(new[]
{
"build",
Path.Combine(intermediateFolder, @"test.wixipl"),
"-ext", extensionPath,
"-loc", Path.Combine(folder, "Package.en-us.wxl"),
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(baseFolder, @"bin\test.msi"),
});
result.AssertSuccess();
var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wixpdb"));
var section = intermediate.Sections.Single();
{
var fileSymbol = section.Symbols.OfType <FileSymbol>().Single();
Assert.Equal(Path.Combine(folder, @"data\test.txt"), fileSymbol[FileSymbolFields.Source].AsPath().Path);
Assert.Equal(@"test.txt", fileSymbol[FileSymbolFields.Source].PreviousValue.AsPath().Path);
}
{
var binary = section.Symbols.OfType <BinarySymbol>().Single();
var path = binary[BinarySymbolFields.Data].AsPath().Path;
Assert.StartsWith(Path.Combine(baseFolder, @"obj\test"), path);
Assert.EndsWith(@"wix-ir\example.txt", path);
Assert.Equal(@"BinFromWir", binary.Id.Id);
}
}
}
public void PopulatesManifestWithBundleExtensionSearches()
{
var extensionPath = Path.GetFullPath(new Uri(typeof(ExampleExtensionFactory).Assembly.CodeBase).LocalPath);
var folder = TestData.Get(@"TestData");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var bundlePath = Path.Combine(baseFolder, @"bin\test.exe");
var baFolderPath = Path.Combine(baseFolder, "ba");
var extractFolderPath = Path.Combine(baseFolder, "extract");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "BundleExtension", "BundleExtensionSearches.wxs"),
Path.Combine(folder, "BundleExtension", "BundleWithSearches.wxs"),
Path.Combine(folder, "BundleWithPackageGroupRef", "MinimalPackageGroup.wxs"),
Path.Combine(folder, "BundleWithPackageGroupRef", "Bundle.wxs"),
"-ext", extensionPath,
"-bindpath", Path.Combine(folder, "SimpleBundle", "data"),
"-intermediateFolder", intermediateFolder,
"-o", bundlePath
});
result.AssertSuccess();
Assert.True(File.Exists(bundlePath));
var extractResult = BundleExtractor.ExtractBAContainer(null, bundlePath, baFolderPath, extractFolderPath);
extractResult.AssertSuccess();
var bundleExtensions = extractResult.SelectManifestNodes("/burn:BurnManifest/burn:BundleExtension");
Assert.Equal(1, bundleExtensions.Count);
Assert.Equal("<BundleExtension Id='ExampleBundleExtension' EntryPayloadId='ExampleBundleExtension' />", bundleExtensions[0].GetTestXml());
var extensionSearches = extractResult.SelectManifestNodes("/burn:BurnManifest/burn:ExtensionSearch");
Assert.Equal(2, extensionSearches.Count);
Assert.Equal("<ExtensionSearch Id='ExampleSearchBar' Variable='SearchBar' Condition='WixBundleInstalled' ExtensionId='ExampleBundleExtension' />", extensionSearches[0].GetTestXml());
Assert.Equal("<ExtensionSearch Id='ExampleSearchFoo' Variable='SearchFoo' ExtensionId='ExampleBundleExtension' />", extensionSearches[1].GetTestXml());
var bundleExtensionDatas = extractResult.SelectBundleExtensionDataNodes("/be:BundleExtensionData/be:BundleExtension[@Id='ExampleBundleExtension']");
Assert.Equal(1, bundleExtensionDatas.Count);
Assert.Equal("<BundleExtension Id='ExampleBundleExtension'>" +
"<ExampleSearch Id='ExampleSearchBar' SearchFor='Bar' />" +
"<ExampleSearch Id='ExampleSearchFoo' SearchFor='Foo' />" +
"</BundleExtension>", bundleExtensionDatas[0].GetTestXml());
var exampleSearches = extractResult.SelectBundleExtensionDataNodes("/be:BundleExtensionData/be:BundleExtension[@Id='ExampleBundleExtension']/be:ExampleSearch");
Assert.Equal(2, exampleSearches.Count);
}
}
public void PayloadIsNotPutInMultipleContainers()
{
var folder = TestData.Get(@"TestData");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var binFolder = Path.Combine(baseFolder, "bin");
var bundlePath = Path.Combine(binFolder, "test.exe");
var baFolderPath = Path.Combine(baseFolder, "ba");
var extractFolderPath = Path.Combine(baseFolder, "extract");
this.BuildMsis(folder, intermediateFolder, binFolder);
var result = WixRunner.Execute(false, new[]
{
"build",
Path.Combine(folder, "Container", "PayloadInMultipleContainers.wxs"),
Path.Combine(folder, "BundleWithPackageGroupRef", "Bundle.wxs"),
"-bindpath", Path.Combine(folder, "SimpleBundle", "data"),
"-bindpath", binFolder,
"-intermediateFolder", intermediateFolder,
"-o", bundlePath
});
WixAssert.CompareLineByLine(new string[]
{
"The Payload 'SharedPayload' can't be added to Container 'FirstX64' because it was already added to Container 'FirstX86'.",
}, result.Messages.Select(m => m.ToString()).ToArray());
result.AssertSuccess();
Assert.True(File.Exists(bundlePath));
var extractResult = BundleExtractor.ExtractBAContainer(null, bundlePath, baFolderPath, extractFolderPath);
extractResult.AssertSuccess();
var ignoreAttributes = new Dictionary <string, List <string> > {
{ "Payload", new List <string> {
"FileSize", "Hash"
} }
};
var payloads = extractResult.SelectManifestNodes("/burn:BurnManifest/burn:Payload[@Id='SharedPayload']")
.Cast <XmlElement>()
.Select(e => e.GetTestXml(ignoreAttributes))
.ToArray();
WixAssert.CompareLineByLine(new string[]
{
"<Payload Id='SharedPayload' FilePath='PayloadInMultipleContainers.wxs' FileSize='*' Hash='*' Packaging='embedded' SourcePath='a2' Container='FirstX86' />",
}, payloads);
}
}
public void CanBuildSingleFile()
{
var folder = TestData.Get(@"TestData\SingleFile");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var wixiplPath = Path.Combine(intermediateFolder, @"test.wixipl");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Package.wxs"),
Path.Combine(folder, "PackageComponents.wxs"),
"-intermediateFolder", intermediateFolder,
"-o", wixiplPath,
});
result.AssertSuccess();
var intermediate = Intermediate.Load(wixiplPath);
Assert.False(intermediate.HasLevel(IntermediateLevels.Compiled));
Assert.True(intermediate.HasLevel(IntermediateLevels.Linked));
Assert.False(intermediate.HasLevel(IntermediateLevels.Resolved));
result = WixRunner.Execute(new[]
{
"build",
Path.Combine(intermediateFolder, @"test.wixipl"),
"-loc", Path.Combine(folder, "Package.en-us.wxl"),
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(baseFolder, @"bin\test.msi")
});
result.AssertSuccess();
intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wixpdb"));
Assert.False(intermediate.HasLevel(IntermediateLevels.Compiled));
Assert.True(intermediate.HasLevel(IntermediateLevels.Linked));
Assert.True(intermediate.HasLevel(IntermediateLevels.Resolved));
var section = intermediate.Sections.Single();
var fileSymbol = section.Symbols.OfType <FileSymbol>().First();
Assert.Equal(Path.Combine(folder, @"data\test.txt"), fileSymbol[FileSymbolFields.Source].AsPath().Path);
Assert.Equal(@"test.txt", fileSymbol[FileSymbolFields.Source].PreviousValue.AsPath().Path);
}
}
public void PopulatesInstallExecuteSequenceTable()
{
var folder = TestData.Get(@"TestData");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var msiPath = Path.Combine(baseFolder, @"bin\test.msi");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Upgrade", "DetectOnly.wxs"),
Path.Combine(folder, "ProductWithComponentGroupRef", "MinimalComponentGroup.wxs"),
Path.Combine(folder, "ProductWithComponentGroupRef", "Product.wxs"),
"-bindpath", Path.Combine(folder, "SingleFile", "data"),
"-intermediateFolder", intermediateFolder,
"-o", msiPath
});
result.AssertSuccess();
Assert.True(File.Exists(msiPath));
var results = Query.QueryDatabase(msiPath, new[] { "InstallExecuteSequence" });
WixAssert.CompareLineByLine(new[]
{
"InstallExecuteSequence:CostFinalize\t\t1000",
"InstallExecuteSequence:CostInitialize\t\t800",
"InstallExecuteSequence:CreateFolders\t\t3700",
"InstallExecuteSequence:FileCost\t\t900",
"InstallExecuteSequence:FindRelatedProducts\t\t25",
"InstallExecuteSequence:InstallFiles\t\t4000",
"InstallExecuteSequence:InstallFinalize\t\t6600",
"InstallExecuteSequence:InstallInitialize\t\t1500",
"InstallExecuteSequence:InstallValidate\t\t1400",
"InstallExecuteSequence:LaunchConditions\t\t100",
"InstallExecuteSequence:MigrateFeatureStates\t\t1200",
"InstallExecuteSequence:ProcessComponents\t\t1600",
"InstallExecuteSequence:PublishFeatures\t\t6300",
"InstallExecuteSequence:PublishProduct\t\t6400",
"InstallExecuteSequence:RegisterProduct\t\t6100",
"InstallExecuteSequence:RegisterUser\t\t6000",
"InstallExecuteSequence:RemoveExistingProducts\t\t1401",
"InstallExecuteSequence:RemoveFiles\t\t3500",
"InstallExecuteSequence:RemoveFolders\t\t3600",
"InstallExecuteSequence:UnpublishFeatures\t\t1800",
"InstallExecuteSequence:ValidateProductID\t\t700",
}, results);
}
}
public void CanBuildAndCleanSimpleMsiPackage()
{
var projectPath = TestData.Get(@"TestData\SimpleMsiPackage\MsiPackage\MsiPackage.wixproj");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var binFolder = Path.Combine(baseFolder, @"bin\");
var intermediateFolder = Path.Combine(baseFolder, @"obj\");
// Build
var result = MsbuildRunner.Execute(projectPath, new[]
{
$"-p:WixTargetsPath={WixTargetsPath}",
$"-p:IntermediateOutputPath={intermediateFolder}",
$"-p:OutputPath={binFolder}",
"-v:diag"
});
result.AssertSuccess();
var buildOutput = String.Join("\r\n", result.Output);
var createdPaths = Directory.EnumerateFiles(baseFolder, @"*.*", SearchOption.AllDirectories)
.Select(s => s.Substring(baseFolder.Length + 1))
.OrderBy(s => s)
.ToArray();
Assert.NotEmpty(createdPaths);
// Clean
result = MsbuildRunner.Execute(projectPath, new[]
{
$"-p:WixTargetsPath={WixTargetsPath}",
$"-p:IntermediateOutputPath={intermediateFolder}",
$"-p:OutputPath={binFolder}",
"-t:Clean",
"-v:diag"
});
result.AssertSuccess();
var cleanOutput = String.Join("\r\n", result.Output);
// Clean is only expected to delete the files listed in {Project}.FileListAbsolute.txt,
// so this is not quite right but close enough.
var remainingPaths = Directory.EnumerateFiles(baseFolder, @"*.*", SearchOption.AllDirectories)
.Select(s => s.Substring(baseFolder.Length + 1))
.Where(s => s != "obj\\MsiPackage.wixproj.FileListAbsolute.txt")
.OrderBy(s => s)
.ToArray();
Assert.Empty(remainingPaths);
}
}
public void CanBuildWithDefaultProductLanguage()
{
var folder = TestData.Get(@"TestData", "Language");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Package.wxs"),
"-loc", Path.Combine(folder, "Package.wxl"),
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", Path.Combine(baseFolder, "obj"),
"-o", Path.Combine(baseFolder, @"bin\test.msi")
});
result.AssertSuccess();
var intermediate = Intermediate.Load(Path.Combine(baseFolder, @"bin\test.wixpdb"));
var section = intermediate.Sections.Single();
var directorySymbols = section.Symbols.OfType <DirectorySymbol>();
WixAssert.CompareLineByLine(new[]
{
"INSTALLFOLDER:Example Corporation\\MsiPackage",
"ProgramFilesFolder:PFiles",
"TARGETDIR:SourceDir"
}, directorySymbols.OrderBy(s => s.Id.Id).Select(s => s.Id.Id + ":" + s.Name).ToArray());
var propertySymbol = section.Symbols.OfType <PropertySymbol>().Single(p => p.Id.Id == "ProductLanguage");
Assert.Equal("0", propertySymbol.Value);
var summaryPlatform = section.Symbols.OfType <SummaryInformationSymbol>().Single(s => s.PropertyId == SummaryInformationType.PlatformAndLanguage);
Assert.Equal("Intel;0", summaryPlatform.Value);
var summaryCodepage = section.Symbols.OfType <SummaryInformationSymbol>().Single(s => s.PropertyId == SummaryInformationType.Codepage);
Assert.Equal("1252", summaryCodepage.Value);
var data = WindowsInstallerData.Load(Path.Combine(baseFolder, @"bin\test.wixpdb"));
var directoryRows = data.Tables["Directory"].Rows;
WixAssert.CompareLineByLine(new[]
{
"d4EceYatXTyy8HXPt5B6DT9Rj.wE:u7-b4gch|Example Corporation",
"INSTALLFOLDER:oekcr5lq|MsiPackage",
"ProgramFilesFolder:PFiles",
"TARGETDIR:SourceDir"
}, directoryRows.Select(r => r.FieldAsString(0) + ":" + r.FieldAsString(2)).ToArray());
}
}
public void CanBuildBundleWithLargePayload()
{
var folder = TestData.Get(@"TestData\LargePayload");
// Overwrite the payload with a 2.5 GiB file. We do this dynamically to avoid committing such
// a large file to source control.
var largeFile = Path.Combine(folder, "data", "large_file.dat");
const long TwoAndAHalfGigabytes = 2_684_354_560;
using (var stream = File.Create(largeFile))
{
stream.Seek(TwoAndAHalfGigabytes - 1, SeekOrigin.Begin);
stream.WriteByte(1);
}
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var exePath = Path.Combine(baseFolder, @"bin\test.exe");
var pdbPath = Path.Combine(baseFolder, @"bin\test.wixpdb");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Bundle.wxs"),
"-loc", Path.Combine(folder, "Bundle.en-us.wxl"),
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", intermediateFolder,
"-o", exePath,
});
result.AssertSuccess();
Assert.Empty(result.Messages.Where(m => m.Level == MessageLevel.Warning));
Assert.True(File.Exists(exePath));
Assert.True(File.Exists(pdbPath));
Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\large_file.dat")));
using (var wixOutput = WixOutput.Read(pdbPath))
{
var intermediate = Intermediate.Load(wixOutput);
var section = intermediate.Sections.Single();
var payloadSymbol = section.Symbols.OfType <WixBundlePayloadSymbol>().Where(x => x.Name == "large_file.dat").Single();
Assert.Equal(TwoAndAHalfGigabytes, payloadSymbol.FileSize);
}
}
File.Delete(largeFile);
}
public void ReadProjectWithPatchTest()
{
string projectFile = "MyProject.csproj";
using (var fs = new DisposableFileSystem())
{
fs.CreateFile(projectFile, ProjectHelper.SetVersion("1.3.5"));
var store = new ProjectStore();
var project = store.Read(CreateFileInfo(fs, projectFile));
Assert.Equal("1.3.5", project.Version);
}
}
public void ReadNoVersionTest()
{
string projectFile = "project2.csproj";
using (var fs = new DisposableFileSystem())
{
fs.CreateFile(projectFile, ProjectHelper.SetVersion(string.Empty));
var store = new ProjectStore();
var project = store.Read(CreateFileInfo(fs, projectFile));
Assert.Equal("0.1.0", project.Version);
}
}
public void FoldersAreEnumerated()
{
using (var scenario = new DisposableFileSystem()
.CreateFolder("beta"))
{
var contents1 = new DirectoryInfoWrapper(scenario.DirectoryInfo).EnumerateFileSystemInfos();
var beta = contents1.OfType <DirectoryInfoBase>().Single();
var contents2 = beta.EnumerateFileSystemInfos();
Assert.Equal(1, contents1.Count());
Assert.Equal("beta", beta.Name);
Assert.Equal(0, contents2.Count());
}
}
public void FindWithProjectFiles()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFile("project1.csproj")
.CreateFile("project2.csproj");
var finder = new ProjectFinder(fs.RootPath);
var projects = finder.FindProjects().OrderBy(p => p.Name).ToArray();
Assert.Equal("project1.csproj", projects[0].Name);
Assert.Equal("project2.csproj", projects[1].Name);
}
}
public void UpdateProjectWithBadVersionTest()
{
string projectFile = "MyProject.csproj";
using (var fs = new DisposableFileSystem())
{
fs.CreateFile(projectFile, ProjectHelper.SetVersion("1.4.0"));
var store = new ProjectStore();
var project = store.Read(CreateFileInfo(fs, projectFile));
project.Version = "${BuildVersion}";
Assert.Throws <ArgumentException>("version", () => store.Save(project));
}
}
public void CanBuildSimpleMsiPackage()
{
var folder = TestData.Get(@"TestData\SimpleMsiPackage\MsiPackage");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var pdbPath = Path.Combine(baseFolder, @"bin\testpackage.wixpdb");
var engine = new FakeBuildEngine();
var task = new WixBuild
{
BuildEngine = engine,
SourceFiles = new[]
{
new TaskItem(Path.Combine(folder, "Package.wxs")),
new TaskItem(Path.Combine(folder, "PackageComponents.wxs")),
},
LocalizationFiles = new[]
{
new TaskItem(Path.Combine(folder, "Package.en-us.wxl")),
},
BindInputPaths = new[]
{
new TaskItem(Path.Combine(folder, "data")),
},
IntermediateDirectory = new TaskItem(intermediateFolder),
OutputFile = new TaskItem(Path.Combine(baseFolder, @"bin\test.msi")),
PdbType = "Full",
PdbFile = new TaskItem(pdbPath),
DefaultCompressionLevel = "nOnE",
};
var result = task.Execute();
Assert.True(result, $"MSBuild task failed unexpectedly. Output:\r\n{engine.Output}");
Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\test.msi")));
Assert.True(File.Exists(pdbPath));
Assert.True(File.Exists(Path.Combine(baseFolder, @"bin\cab1.cab")));
var intermediate = Intermediate.Load(pdbPath);
var section = intermediate.Sections.Single();
var fileSymbol = section.Symbols.OfType <FileSymbol>().Single();
Assert.Equal(Path.Combine(folder, @"data\test.txt"), fileSymbol[FileSymbolFields.Source].AsPath().Path);
Assert.Equal(@"test.txt", fileSymbol[FileSymbolFields.Source].PreviousValue.AsPath().Path);
}
}
public void PopulatesControlTables()
{
var folder = TestData.Get(@"TestData");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var msiPath = Path.Combine(baseFolder, @"bin\test.msi");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "DialogsInInstallUISequence", "PackageComponents.wxs"),
Path.Combine(folder, "ProductWithComponentGroupRef", "MinimalComponentGroup.wxs"),
Path.Combine(folder, "ProductWithComponentGroupRef", "Product.wxs"),
"-bindpath", Path.Combine(folder, "SingleFile", "data"),
"-intermediateFolder", intermediateFolder,
"-o", msiPath,
});
result.AssertSuccess();
Assert.True(File.Exists(msiPath));
var results = Query.QueryDatabase(msiPath, new[] { "CheckBox", "Control", "ControlCondition", "InstallUISequence" });
WixAssert.CompareLineByLine(new[]
{
"CheckBox:WIXUI_EXITDIALOGOPTIONALCHECKBOX\t1",
"Control:FirstDialog\tHeader\tText\t0\t13\t90\t13\t3\t\tFirstDialogHeader\tTitle\t",
"Control:FirstDialog\tTitle\tText\t0\t0\t90\t13\t3\t\tFirstDialogTitle\tHeader\t",
"Control:SecondDialog\tOptionalCheckBox\tCheckBox\t0\t13\t100\t40\t2\tWIXUI_EXITDIALOGOPTIONALCHECKBOX\t[WIXUI_EXITDIALOGOPTIONALCHECKBOXTEXT]\tTitle\tOptional checkbox|Check this box for fun",
"Control:SecondDialog\tTitle\tText\t0\t0\t90\t13\t3\t\tSecondDialogTitle\tOptionalCheckBox\t",
"ControlCondition:FirstDialog\tHeader\tDisable\tInstalled",
"ControlCondition:FirstDialog\tHeader\tHide\tInstalled",
"ControlCondition:SecondDialog\tOptionalCheckBox\tShow\tWIXUI_EXITDIALOGOPTIONALCHECKBOXTEXT AND NOT Installed",
"InstallUISequence:CostFinalize\t\t1000",
"InstallUISequence:CostInitialize\t\t800",
"InstallUISequence:ExecuteAction\t\t1300",
"InstallUISequence:FileCost\t\t900",
"InstallUISequence:FindRelatedProducts\t\t25",
"InstallUISequence:FirstDialog\tInstalled AND PATCH\t1298",
"InstallUISequence:LaunchConditions\t\t100",
"InstallUISequence:MigrateFeatureStates\t\t1200",
"InstallUISequence:SecondDialog\tNOT Installed\t1299",
"InstallUISequence:ValidateProductID\t\t700",
}, results);
}
}
public async Task ChangePreWithBadFormatTest()
{
using (var fs = new DisposableFileSystem())
{
fs.CreateFile("MySolution.sln");
fs.CreateFolder("src/Services");
fs.CreateFile("src/Services/project1.csproj", ProjectHelper.SetVersion("5.0.8-beta"));
var store = new ProjectStore();
var command = new PreCommand(GitHelper.CreateDefaultGitMock().Object);
var context = new CommandContext(_console, Verbosity.Info);
context.Directory = fs.RootPath;
await Assert.ThrowsAsync <FormatException>(() => command.ExecuteAsync(context));
}
}
public void CanCreateSingleFileCabinet()
{
using (var fs = new DisposableFileSystem())
{
var intermediateFolder = fs.GetFolder(true);
var cabPath = Path.Combine(intermediateFolder, "testout.cab");
var files = new[] { new CabinetCompressFile(TestData.Get(@"TestData\test.txt"), "test.txt") };
var cabinet = new Cabinet(cabPath);
cabinet.Compress(files, CabinetCompressionLevel.Low);
Assert.True(File.Exists(cabPath));
}
}
public void CanBuildInstanceTransform()
{
var folder = TestData.Get(@"TestData\InstanceTransform");
using (var fs = new DisposableFileSystem())
{
var intermediateFolder = fs.GetFolder();
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Package.wxs"),
Path.Combine(folder, "PackageComponents.wxs"),
"-loc", Path.Combine(folder, "Package.en-us.wxl"),
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(intermediateFolder, @"bin\test.msi")
});
result.AssertSuccess();
var output = WindowsInstallerData.Load(Path.Combine(intermediateFolder, @"bin\test.wixpdb"), false);
var substorage = output.SubStorages.Single();
Assert.Equal("I1", substorage.Name);
var data = substorage.Data;
Assert.Equal(new[]
{
"_SummaryInformation",
"Property",
"Upgrade"
}, data.Tables.Select(t => t.Name).ToArray());
Assert.Equal(new[]
{
"INSTANCEPROPERTY\tI1",
"ProductName\tMsiPackage (Instance 1)",
}, JoinRows(data.Tables["Property"]));
Assert.Equal(new[]
{
"{047730A5-30FE-4A62-A520-DA9381B8226A}\t\t1.0.0.0\t1033\t1\t\tWIX_UPGRADE_DETECTED",
"{047730A5-30FE-4A62-A520-DA9381B8226A}\t\t1.0.0.0\t1033\t1\t0\t0",
"{047730A5-30FE-4A62-A520-DA9381B8226A}\t1.0.0.0\t\t1033\t2\t\tWIX_DOWNGRADE_DETECTED",
"{047730A5-30FE-4A62-A520-DA9381B8226A}\t1.0.0.0\t\t1033\t2\t0\t0"
}, JoinRows(data.Tables["Upgrade"]));
}
}
public void CanBuildWithExtensionUsingWixlib()
{
var folder = TestData.Get(@"TestData\ExampleExtension");
var extensionPath = Path.GetFullPath(new Uri(typeof(ExampleExtensionFactory).Assembly.CodeBase).LocalPath);
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "PackageComponents.wxs"),
"-ext", extensionPath,
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(intermediateFolder, @"test.wixlib")
});
result.AssertSuccess();
result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Package.wxs"),
"-loc", Path.Combine(folder, "Package.en-us.wxl"),
"-lib", Path.Combine(intermediateFolder, @"test.wixlib"),
"-ext", extensionPath,
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(intermediateFolder, @"bin\test.msi")
});
result.AssertSuccess();
var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"test.wir"));
var section = intermediate.Sections.Single();
var wixFile = section.Tuples.OfType <WixFileTuple>().Single();
Assert.Equal(Path.Combine(folder, @"data\example.txt"), wixFile[WixFileTupleFields.Source].AsPath().Path);
Assert.Equal(@"example.txt", wixFile[WixFileTupleFields.Source].PreviousValue.AsPath().Path);
var example = section.Tuples.Where(t => t.Definition.Type == TupleDefinitionType.MustBeFromAnExtension).Single();
Assert.Equal("Foo", example.Id.Id);
Assert.Equal("Foo", example[0].AsString());
Assert.Equal("Bar", example[1].AsString());
}
}
public void CanBuildSimpleModule()
{
var folder = TestData.Get(@"TestData\SimpleModule");
using (var fs = new DisposableFileSystem())
{
var intermediateFolder = fs.GetFolder();
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "Module.wxs"),
"-loc", Path.Combine(folder, "Module.en-us.wxl"),
"-bindpath", Path.Combine(folder, "data"),
"-intermediateFolder", intermediateFolder,
"-o", Path.Combine(intermediateFolder, @"bin\test.msm")
});
result.AssertSuccess();
var msmPath = Path.Combine(intermediateFolder, @"bin\test.msm");
Assert.True(File.Exists(msmPath));
Assert.True(File.Exists(Path.Combine(intermediateFolder, @"bin\test.wixpdb")));
var intermediate = Intermediate.Load(Path.Combine(intermediateFolder, @"bin\test.wixpdb"));
var section = intermediate.Sections.Single();
var fileSymbol = section.Symbols.OfType <FileSymbol>().Single();
Assert.Equal("filyIq8rqcxxf903Hsn5K9L0SWV73g", fileSymbol.Id.Id);
Assert.Equal(Path.Combine(folder, @"data\test.txt"), fileSymbol[FileSymbolFields.Source].AsPath().Path);
Assert.Equal(@"test.txt", fileSymbol[FileSymbolFields.Source].PreviousValue.AsPath().Path);
var data = WindowsInstallerData.Load(Path.Combine(intermediateFolder, @"bin\test.wixpdb"));
var fileRows = data.Tables["File"].Rows;
Assert.Equal(new[]
{
"filyIq8rqcxxf903Hsn5K9L0SWV73g.243FB739_4D05_472F_9CFB_EF6B1017B6DE"
}, fileRows.Select(r => r.FieldAsString(0)).ToArray());
var cabPath = Path.Combine(intermediateFolder, "msm-test.cab");
Query.ExtractStream(msmPath, "MergeModule.CABinet", cabPath);
var files = Query.GetCabinetFiles(cabPath);
Assert.Equal(new[]
{
"filyIq8rqcxxf903Hsn5K9L0SWV73g.243FB739_4D05_472F_9CFB_EF6B1017B6DE"
}, files.Select(f => Path.Combine(f.Path, f.Name)).ToArray());
}
}
public void CanLoadFDDLatestCoreMBA()
{
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var bundleFile = TestData.Get(bundleBasePath, "LatestCoreBundleFDD.exe");
var testEngine = new TestEngine();
var result = testEngine.RunShutdownEngine(bundleFile, baseFolder);
var logMessages = result.Output;
Assert.Equal("Loading .NET Core FDD bootstrapper application.", logMessages[0]);
Assert.Equal("Creating BA thread to run asynchronously.", logMessages[1]);
Assert.Equal("LatestCoreBA", logMessages[2]);
Assert.Equal("Shutdown,ReloadBootstrapper,0", logMessages[3]);
}
}
public void CreateFileChangeToken_DoesNotAllowPathsAboveRoot()
{
using (var root = new DisposableFileSystem())
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
var token = physicalFilesWatcher.CreateFileChangeToken(Path.GetFullPath(Path.Combine(root.RootPath, "..")));
Assert.IsType <NullChangeToken>(token);
token = physicalFilesWatcher.CreateFileChangeToken(Path.GetFullPath(Path.Combine(root.RootPath, "../")));
Assert.IsType <NullChangeToken>(token);
token = physicalFilesWatcher.CreateFileChangeToken("..");
Assert.IsType <NullChangeToken>(token);
}
}
public void CanDownloadPayloadsFromMissingAttachedContainer()
{
var packageA = this.CreatePackageInstaller("PackageA");
var packageB = this.CreatePackageInstaller("PackageB");
var bundleA = this.CreateBundleInstaller("BundleA");
var testBAController = this.CreateTestBAController();
var webServer = this.CreateWebServer();
webServer.AddFiles(new Dictionary <string, string>
{
{ "/BundleA/PackageA.msi", Path.Combine(this.TestContext.TestDataFolder, "PackageA.msi") },
{ "/BundleA/PackageB.msi", Path.Combine(this.TestContext.TestDataFolder, "PackageB.msi") },
});
webServer.Start();
// Don't install PackageB initially so it will be installed when run from the package cache.
testBAController.SetPackageRequestedState("PackageB", RequestState.Absent);
packageA.VerifyInstalled(false);
packageB.VerifyInstalled(false);
// Manually copy bundle to separate directory, install from there, and then delete it
// so that when run from the package cache, it can't find the attached container.
using (var dfs = new DisposableFileSystem())
{
var tempDirectory = dfs.GetFolder(true);
var bundleAFileInfo = new FileInfo(bundleA.Bundle);
var bundleACopiedPath = Path.Combine(tempDirectory, bundleAFileInfo.Name);
bundleAFileInfo.CopyTo(bundleACopiedPath);
bundleA.Install(bundleACopiedPath);
}
var bundlePackageCachePath = bundleA.VerifyRegisteredAndInPackageCache();
packageA.VerifyInstalled(true);
packageB.VerifyInstalled(false);
testBAController.SetPackageRequestedState("PackageB", RequestState.Present);
bundleA.Modify(bundlePackageCachePath);
bundleA.VerifyRegisteredAndInPackageCache();
packageA.VerifyInstalled(true);
packageB.VerifyInstalled(true);
}
public void PopulatesDirectoryTableWithValidDefaultDir()
{
var folder = TestData.Get(@"TestData");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var msiPath = Path.Combine(baseFolder, @"bin\test.msi");
var result = WixRunner.Execute(new[]
{
"build",
"-sw1031", // this is expected for this test
Path.Combine(folder, "DefaultDir", "DefaultDir.wxs"),
Path.Combine(folder, "ProductWithComponentGroupRef", "Product.wxs"),
"-bindpath", Path.Combine(folder, "SingleFile", "data"),
"-intermediateFolder", intermediateFolder,
"-o", msiPath
});
result.AssertSuccess();
Assert.True(File.Exists(msiPath));
var results = Query.QueryDatabase(msiPath, new[] { "Directory" });
WixAssert.CompareLineByLine(new[]
{
"Directory:DUPLICATENAMEANDSHORTNAME\tINSTALLFOLDER\tduplicat",
"Directory:Folder1\tINSTALLFOLDER\tFolder.1",
"Directory:Folder12\tINSTALLFOLDER\tFolder.12",
"Directory:Folder123\tINSTALLFOLDER\tFolder.123",
"Directory:Folder1234\tINSTALLFOLDER\tyakwclwy|Folder.1234",
"Directory:INSTALLFOLDER\tProgramFiles6432Folder\t1egc1laj|MsiPackage",
"Directory:NAMEANDSHORTNAME\tINSTALLFOLDER\tSHORTNAM|NameAndShortName",
"Directory:NAMEANDSHORTSOURCENAME\tINSTALLFOLDER\tNAMEASSN|NameAndShortSourceName",
"Directory:NAMEWITHSHORTVALUE\tINSTALLFOLDER\tSHORTVAL",
"Directory:ProgramFiles6432Folder\tProgramFilesFolder\t.",
"Directory:ProgramFilesFolder\tTARGETDIR\tPFiles",
"Directory:SHORTNAMEANDLONGSOURCENAME\tINSTALLFOLDER\tSHNALSNM:6ukthv5q|ShortNameAndLongSourceName",
"Directory:SHORTNAMEONLY\tINSTALLFOLDER\tSHORTONL",
"Directory:SOURCENAME\tINSTALLFOLDER\ts2s5bq-i|NameAndSourceName:dhnqygng|SourceNameWithName",
"Directory:SOURCENAMESONLY\tINSTALLFOLDER\t.:SRCNAMON|SourceNameOnly",
"Directory:SOURCENAMEWITHSHORTVALUE\tINSTALLFOLDER\t.:SRTSRCVL",
"Directory:TARGETDIR\t\tSourceDir",
}, results);
}
}
public void SubFoldersAreEnumerated()
{
using (var scenario = new DisposableFileSystem()
.CreateFolder("beta")
.CreateFile(Path.Combine("beta", "alpha.txt")))
{
var contents1 = new DirectoryInfoWrapper(scenario.DirectoryInfo).EnumerateFileSystemInfos();
var beta = contents1.OfType <DirectoryInfoBase>().Single();
var contents2 = beta.EnumerateFileSystemInfos();
var alphaTxt = contents2.OfType <FileInfoBase>().Single();
Assert.Equal(1, contents1.Count());
Assert.Equal("beta", beta.Name);
Assert.Equal(1, contents2.Count());
Assert.Equal("alpha.txt", alphaTxt.Name);
}
}
public void DetectUnconvertableQtExecCmdTimeout()
{
const string beforeFileName = "v3.wxs";
const string afterFileName = "v4_expected.wxs";
var folder = TestData.Get(@"TestData\QtExec.bad");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder(true);
var targetFile = Path.Combine(baseFolder, beforeFileName);
File.Copy(Path.Combine(folder, beforeFileName), Path.Combine(baseFolder, beforeFileName));
var runner = new WixCopRunner
{
FixErrors = true,
SearchPatterns =
{
targetFile,
},
};
var result = runner.Execute();
Assert.Equal(2, result.ExitCode);
Assert.Single(result.Messages.Where(message => message.ToString().EndsWith("(QtExecCmdTimeoutAmbiguous)")));
var expected = File.ReadAllText(Path.Combine(folder, afterFileName)).Replace("\r\n", "\n");
var actual = File.ReadAllText(targetFile).Replace("\r\n", "\n");
Assert.Equal(expected, actual);
// still fails because QtExecCmdTimeoutAmbiguous is unfixable
var runner2 = new WixCopRunner
{
FixErrors = true,
SearchPatterns =
{
targetFile,
},
};
var result2 = runner2.Execute();
Assert.Equal(2, result2.ExitCode);
}
}
public void PopulatesManifestWithBundleExtension()
{
var folder = TestData.Get(@"TestData");
using (var fs = new DisposableFileSystem())
{
var baseFolder = fs.GetFolder();
var intermediateFolder = Path.Combine(baseFolder, "obj");
var bundlePath = Path.Combine(baseFolder, @"bin\test.exe");
var baFolderPath = Path.Combine(baseFolder, "ba");
var extractFolderPath = Path.Combine(baseFolder, "extract");
var result = WixRunner.Execute(new[]
{
"build",
Path.Combine(folder, "BundleExtension", "BundleExtension.wxs"),
Path.Combine(folder, "BundleExtension", "SimpleBundleExtension.wxs"),
Path.Combine(folder, "BundleWithPackageGroupRef", "MinimalPackageGroup.wxs"),
Path.Combine(folder, "BundleWithPackageGroupRef", "Bundle.wxs"),
"-bindpath", Path.Combine(folder, "SimpleBundle", "data"),
"-intermediateFolder", intermediateFolder,
"-o", bundlePath
});
result.AssertSuccess();
Assert.True(File.Exists(bundlePath));
var extractResult = BundleExtractor.ExtractBAContainer(null, bundlePath, baFolderPath, extractFolderPath);
extractResult.AssertSuccess();
var bundleExtensions = extractResult.SelectManifestNodes("/burn:BurnManifest/burn:BundleExtension");
Assert.Equal(1, bundleExtensions.Count);
Assert.Equal("<BundleExtension Id='ExampleBext' EntryPayloadId='ExampleBext' />", bundleExtensions[0].GetTestXml());
var bundleExtensionPayloads = extractResult.SelectManifestNodes("/burn:BurnManifest/burn:UX/burn:Payload[@Id='ExampleBext']");
Assert.Equal(1, bundleExtensionPayloads.Count);
var ignored = new Dictionary <string, List <string> >
{
{ "Payload", new List <string> {
"FileSize", "Hash", "SourcePath"
} },
};
Assert.Equal("<Payload Id='ExampleBext' FilePath='fakebext.dll' FileSize='*' Hash='*' Packaging='embedded' SourcePath='*' />", bundleExtensionPayloads[0].GetTestXml(ignored));
}
}
public void UpdateProjectTest()
{
string projectFile = "MyProject.csproj";
using (var fs = new DisposableFileSystem())
{
fs.CreateFile(projectFile, ProjectHelper.SetVersion("1.4.0"));
var store = new ProjectStore();
var project = store.Read(CreateFileInfo(fs, projectFile));
project.Version = "2.0";
store.Save(project);
var newProject = store.Read(CreateFileInfo(fs, projectFile));
Assert.Equal("2.0", project.Version);
}
}
