public void Burn_CancelVeryLate() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundle. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Cancel package B at the last moment possible.. this.SetPackageCancelExecuteAtProgress("PackageB", 100); // Install the bundle and hopefully it fails. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(expectedExitCode: ErrorCodes.ERROR_INSTALL_USEREXIT); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); this.CleanTestArtifacts = true; }
static void QuickPack() { if (EditorUtility.DisplayDialog("确认打包AB", "确认打包AB ,确认不可撤回", "yes")) { BundleBuilder.BuildByLastSet(); } }
public void Burn_InstallUninstall() { string v2Version = "2.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageC = new PackageBuilder(this, "C") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageC", packageC); // Add the bindpath for the cab for C to enable to add it as a payload for BundleA bindPaths.Add("packageCcab", Path.Combine(Path.GetDirectoryName(packageC), "cab1.cab")); // Build the embedded bundle. string bundleBv2 = new BundleBuilder(this, "BundleBv2") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", v2Version } } }.Build().Output; // Build the parent bundle. bindPaths.Add("bundleBv2", bundleBv2); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the parent bundle that will install the embedded bundle. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageC)); // Attempt to uninstall bundleA, which will uninstall bundleB since it is a patch related bundle. installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageC)); this.Complete(); }
public void Burn_RedirectPackageCache() { const string PolicyName = "PackageCache"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; RegistryKey policy = Registry.LocalMachine.CreateSubKey(@"Software\Policies\WiX\Burn"); string currentPackageCache = null; try { currentPackageCache = policy.GetValue(PolicyName) as string; // Install the first bundle using the default package cache. policy.DeleteValue(PolicyName); BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); // Install the second bundle which has a shared package using the redirected package cache. string path = Path.Combine(Path.GetTempPath(), "Package Cache"); policy.SetValue(PolicyName, path); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // The first bundle should leave package A behind. installerA.Uninstall(); // Now make sure that the second bundle removes packages from either cache directory. installerB.Uninstall(); this.Complete(); } finally { if (!string.IsNullOrEmpty(currentPackageCache)) { policy.SetValue(PolicyName, currentPackageCache); } else { policy.DeleteValue(PolicyName); } policy.Dispose(); } }
public Compiler(Log log, Backend backend, SourcePackage package, CompilerOptions options) : base(log) { // This is a block of dependency injection to initialize the Compiler var il = new Namespace(); var extensions = new ExtensionRoot(); Backend = backend; var disk = Disk = new Disk(log, true); Shell = new Shell(log); var essentials = Essentials = new Essentials(); var resolver = NameResolver = new NameResolver(this); var ilf = ILFactory = new ILFactory(backend, il, essentials, resolver, this); var data = Data = new BuildData(il, extensions, ilf); var environment = Environment = new BuildEnvironment(backend, package, options, extensions, ilf, this); var input = Input = new SourceReader(log, package, environment); var blockBuilder = BlockBuilder = new BlockBuilder(backend, il, ilf, resolver, this); var typeBuilder = TypeBuilder = new TypeBuilder(environment, ilf, resolver, this); var bundle = BundleBuilder = new BundleBuilder(backend, environment, ilf, this); AstProcessor = new AstProcessor(il, blockBuilder, typeBuilder, resolver, environment); UxlProcessor = new UxlProcessor(disk, backend.Name, il, extensions, environment, ilf); Plugins = new PluginCache(log, bundle, ilf, environment); var pass = Pass = new CompilerPass(disk, data, environment, ilf, backend, input.Package, typeBuilder, resolver); Utilities = new Utilities(il, pass); ILVerifier = new ILVerifier(pass); ConstantFolder = new ConstantFolder(pass); ILStripper = new ILStripper(pass); }
public void Burn_PermanentInstallUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install Bundle A. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall bundleA. installerA.Uninstall(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); this.Complete(); }
public void Burn_PermanentInstallForceUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install Bundle A. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Force Uninstall Bundle A. this.SetPackageRequestedState("PackageA", Microsoft.Tools.WindowsInstallerXml.Bootstrapper.RequestState.ForceAbsent); this.SetPackageRequestedState("PackageB", Microsoft.Tools.WindowsInstallerXml.Bootstrapper.RequestState.ForceAbsent); installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); this.Complete(); }
public void Burn_InstallUninstallBundleWithEmbeddedBundle() { // Build the packages. string packageA1 = new PackageBuilder(this, "A").Build().Output; string packageB1 = new PackageBuilder(this, "B").Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA1); bindPaths.Add("packageB", packageB1); // Build the embedded bundle. string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Build the parent bundle bindPaths.Add("bundleB", bundleB); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); // Test package is installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.True(MsiVerifier.IsPackageInstalled(packageB1)); // Attempt to uninstall bundleA. installerA.Uninstall(); // Test package is uninstalled. Assert.False(MsiVerifier.IsPackageInstalled(packageA1)); Assert.False(MsiVerifier.IsPackageInstalled(packageB1)); this.Complete(); }
public void Burn_ComponentSearchResults() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // PackageB will be installed if all ComponentSearches worked. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall the main bundle and add-on. installerA.Uninstall(); this.Complete(); }
public void Burn_CancelExecuteWhileCaching() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundle. string bundleA = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Slow the caching of package B to ensure that package A starts installing and cancels. this.SetPackageCancelExecuteAtProgress("PackageA", 50); this.SetPackageSlowCache("PackageB", 1000); // Install the bundle and hopefully it fails. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(expectedExitCode: ErrorCodes.ERROR_INSTALL_USEREXIT); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); this.CleanTestArtifacts = true; }
public void Draw(Rect r) { GUILayout.BeginHorizontal(TableStyles.Toolbar); { isPull = GUILayout.Toggle(isPull, "PACK RULE"); //new GUIStyle{alignment = TextAnchor.MiddleCenter , normal = new GUIStyleState{textColor = new Color(1 , 1 , 1)}}); } GUILayout.Space(3f); GUILayout.EndHorizontal(); if (isPull) { for (int i = 0; i < config.rules.Count; i++) { OnGUIRule(config.rules[i], index == i); if (Event.current.type == EventType.MouseUp && GUILayoutUtility.GetLastRect().Contains(Event.current.mousePosition)) { index = i; Event.current.Use(); } } GUILayout.BeginHorizontal(TableStyles.Toolbar); { if (GUILayout.Button("AddRule", TableStyles.ToolbarButton)) { config.rules.Add(new ABPackRuleConfig.Rule()); EditorUtility.SetDirty(config); } if (GUILayout.Button("Apply", TableStyles.ToolbarButton)) { BundleBuilder.ClearBundleName(); AutoABNamePostprocessor.PackAll(); } } GUILayout.EndHorizontal(); } }
public void Burn_RollbackUpgradeBundle() { const string expectedVersion1 = "1.0.0.0"; const string expectedVersion2 = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleD = new BundleBuilder(this, "BundleD") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the base bundle and make sure it's installed. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion1, actualVersion); } // Install the upgrade bundle that will fail and rollback. Make sure packageA is still present. // SFBUG:3405221 - pkg dependecy not removed in rollback if pkg already present BundleInstaller installerD = new BundleInstaller(this, bundleD).Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion1, actualVersion); } // Uninstall the first bundle and make sure packageA is uninstalled. installerA.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_MissingAttributesForAddditionalRegistration() { // Build the bundle. string bundleD = new BundleBuilder(this, "BundleD") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; this.CleanTestArtifacts = true; }
public void Burn_InstallUninstallAddonPatchRelatedBundle() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; string packageC1 = new PackageBuilder(this, "C").Build().Output; string packageC2 = new PackageBuilder(this, "C") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", "1.0.1.0" } } }.Build().Output; string packageD = new PackageBuilder(this, "D").Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageC", packageC1); bindPaths.Add("packageD", packageD); // Build the base and addon bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Update path to C2 and build the addon patch bundle. bindPaths["packageC"] = packageC2; string bundleE = new BundleBuilder(this, "BundleE") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", "1.0.1.0" } } }.Build().Output; // Install the base and addon bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); // Test that packages A and C1 but not D are installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageC1)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC2)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD)); // Install the patch to the addon. BundleInstaller installerE = new BundleInstaller(this, bundleE).Install(); // Test that packages A and C2 but not D are installed, and that C1 was upgraded. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC1)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageC2)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD)); // Attempt to uninstall bundleA. installerA.Uninstall(); // Test that uninstalling bundle A detected and removed bundle C, which removed bundle E (can't easily reference log). Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerA.LastLogFile, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Addon, scope: PerMachine, version: 1\.0\.0\.0, operation: Remove")); // Test that all packages are uninstalled. Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC1)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC2)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD)); this.CleanTestArtifacts = true; }
public void Burn_InstallBundles() { const string expectedVersion = "1.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // Make sure the MSIs are installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("A") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Uninstall in reverse order. installerB.Uninstall(); installerA.Uninstall(); // Make sure the MSIs are not installed. Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_InstallUninstall() { string v2Version = "2.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageC = new PackageBuilder(this, "C") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageC", packageC); // Add the bindpath for the cab for C to enable to add it as a payload for BundleA bindPaths.Add("packageCcab", Path.Combine(Path.GetDirectoryName(packageC), "cab1.cab")); // Build the embedded bundle. string bundleBv2 = new BundleBuilder(this, "BundleBv2") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", v2Version } } }.Build().Output; // Build the parent bundle. bindPaths.Add("bundleBv2", bundleBv2); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the parent bundle that will install the embedded bundle. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageC)); // Attempt to uninstall bundleA, which will uninstall bundleB since it is a patch related bundle. installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageC)); this.Complete(); }
public ModuleBuilder(ProductCfg.ModuleCfg cfg, string version, CreateAssetBundlesContext ctx) { Cfg = cfg; foreach (var b in Cfg.Bundles) { var bb = new BundleBuilder(b, ctx); bundleBuilders.Add(bb); } this.version = version; }
public void Burn_InstallUpdatedBundleOptionalUpdateRegistration() { string v2Version = "2.0.0.0"; // Build the packages. string packageAv1 = new PackageBuilder(this, "A").Build().Output; string packageAv2 = new PackageBuilder(this, "A") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", v2Version } } }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPathsv1 = new Dictionary<string, string>() { { "packageA", packageAv1 } }; Dictionary<string, string> bindPathsv2 = new Dictionary<string, string>() { { "packageA", packageAv2 } }; // Build the bundles. string bundleAv1 = new BundleBuilder(this, "BundleA") { BindPaths = bindPathsv1, Extensions = Extensions }.Build().Output; string bundleAv2 = new BundleBuilder(this, "BundleA") { BindPaths = bindPathsv2, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", v2Version } } }.Build().Output; // Initialize with first bundle. BundleInstaller installerAv1 = new BundleInstaller(this, bundleAv1).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageAv1)); // Make sure the OptionalUpdateRegistration exists. // SOFTWARE\[Manufacturer]\Updates\[ProductFamily]\[Name] using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_InstallUpdatedBundleOptionalUpdateRegistration - Bundle A")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("1.0.0.0", key.GetValue("PackageVersion")); } // Install second bundle which will major upgrade away v1. BundleInstaller installerAv2 = new BundleInstaller(this, bundleAv2).Install(); Assert.False(MsiVerifier.IsPackageInstalled(packageAv1)); Assert.True(MsiVerifier.IsPackageInstalled(packageAv2)); // Make sure the OptionalUpdateRegistration exists. // SOFTWARE\[Manufacturer]\Updates\[ProductFamily]\[Name] using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_InstallUpdatedBundleOptionalUpdateRegistration - Bundle A")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("2.0.0.0", key.GetValue("PackageVersion")); } // Uninstall the second bundle and everything should be gone. installerAv2.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageAv1)); Assert.False(MsiVerifier.IsPackageInstalled(packageAv2)); // Make sure the key is removed. using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_InstallUpdatedBundleOptionalUpdateRegistration - Bundle A")) { Assert.Null(key); } }
public void Burn_FailNonVitalPackage() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageC = new PackageBuilder(this, "C") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageC); // Build the bundle. string bundleE = new BundleBuilder(this, "BundleE") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundle and make sure packageA is installed. // SFBUG:3435047 - Make sure during install we don't fail for non-vital packages. BundleInstaller installerE = new BundleInstaller(this, bundleE).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC)); using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.IsNull(root.GetValue("Version")); } // Repair the bundle. // SFBUG:3435047 - Make sure during repair we don't fail for the same reason in a different code path. installerE.Repair(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC)); using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.IsNull(root.GetValue("Version")); } // Uninstall the bundle and make sure packageA is uninstalled. installerE.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_MissingAttributesForAddditionalRegistration() { Assert.Throws <TestException>(() => { // Build the bundle. string bundleD = new BundleBuilder(this, "BundleD") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; }); this.Complete(); }
public void Burn_FeatureRepair() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundle with the optional feature present this.SetPackageFeatureState("PackageA", "Test", FeatureState.Local); BundleInstaller install = new BundleInstaller(this, bundleA).Install(); this.ResetPackageStates("PackageA"); string packageSourceCodeInstalled = this.GetTestInstallFolder(@"A\A.wxs"); string packageNotKeyPathFile = this.GetTestInstallFolder(@"A\notkeypath.file"); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A keyfile installed at: ", packageSourceCodeInstalled)); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A non-keyfile installed at: ", packageSourceCodeInstalled)); // Delete the non-keypath source file. File.Delete(packageNotKeyPathFile); // Now repair without repairing the feature to verify the non-keyfile doesn't come back. install.Repair(); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A keyfile installed at: ", packageSourceCodeInstalled)); Assert.False(File.Exists(packageNotKeyPathFile), String.Concat("Should have not found Package A non-keyfile installed at: ", packageNotKeyPathFile)); // Now repair and include the feature this time. this.SetPackageFeatureState("PackageA", "Test", FeatureState.Local); install.Repair(); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A keyfile installed at: ", packageSourceCodeInstalled)); Assert.True(File.Exists(packageNotKeyPathFile), String.Concat("Should have repaired Package A non-keyfile installed at: ", packageNotKeyPathFile)); this.ResetPackageStates("PackageA"); // Uninstall everything. install.Uninstall(); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageSourceCodeInstalled)); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
private BundleBuilder GetBundleA(Dictionary<string, string> bindPaths = null) { if (null == bindPaths) { string packageAPath = this.GetPackageA().Output; bindPaths = new Dictionary<string, string>() { { "packageA", packageAPath } }; } if (null == this.bundleA) { this.bundleA = this.CreateBundle("BundleA", bindPaths); } return this.bundleA; }
public void Burn_FeatureInstallUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; BundleInstaller install = new BundleInstaller(this, bundleA).Install(); // Source file should *not* be installed, main registry key should be present. string packageSourceCodeInstalled = this.GetTestInstallFolder(@"A\A.wxs"); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Should not have found Package A payload installed at: ", packageSourceCodeInstalled)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("A") as string; Assert.Equal("1.0.0.0", actualVersion); } // Now turn on the feature. this.SetPackageRequestedState("PackageA", RequestState.Present); this.SetPackageFeatureState("PackageA", "Test", FeatureState.Local); install.Modify(); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageSourceCodeInstalled)); this.ResetPackageStates("PackageA"); // Turn the feature back off. this.SetPackageRequestedState("PackageA", RequestState.Present); this.SetPackageFeatureState("PackageA", "Test", FeatureState.Absent); install.Modify(); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Should have removed Package A payload from: ", packageSourceCodeInstalled)); this.ResetPackageStates("PackageA"); // Uninstall everything. install.Uninstall(); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageSourceCodeInstalled)); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
private BundleBuilder GetBundleA(Dictionary <string, string> bindPaths = null) { if (null == bindPaths) { string packageAPath = this.GetPackageA().Output; bindPaths = new Dictionary <string, string>() { { "packageA", packageAPath } }; } return((null != this.bundleA) ? this.bundleA : this.bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build()); }
public void Burn_PatchInstallUninstall() { string originalVersion = "1.0.0.0"; string patchedVersion = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = WixTests.Extensions }.Build().Output; string packageAUpdate = new PackageBuilder(this, "A") { Extensions = WixTests.Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { Extensions = WixTests.Extensions, TargetPath = packageA, UpgradePath = packageAUpdate }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("patchA", patchA); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = WixTests.Extensions }.Build().Output; string bundleAPatch = new BundleBuilder(this, "PatchBundleA") { BindPaths = bindPaths, Extensions = WixTests.Extensions }.Build().Output; // Install the unpatched bundle. BundleInstaller installA = new BundleInstaller(this, bundleA).Install(); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("A") as string; Assert.Equal(originalVersion, actualVersion); } // Install the patch bundle. BundleInstaller installAPatch = new BundleInstaller(this, bundleAPatch).Install(); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("A") as string; Assert.Equal(patchedVersion, actualVersion); } // Uninstall the patch bundle. installAPatch.Uninstall(); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("A") as string; Assert.Equal(originalVersion, actualVersion); } installA.Uninstall(); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
public void Burn_InstallUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; string packageB = new PackageBuilder(this, "B").Build().Output; string packageC = new PackageBuilder(this, "C").Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", Path.GetDirectoryName(packageA)); bindPaths.Add("packageB", Path.GetDirectoryName(packageB)); bindPaths.Add("packageC", Path.GetDirectoryName(packageC)); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string packageASourceCodeInstalled = this.GetTestInstallFolder(@"A\A.wxs"); string packageBSourceCodeInstalled = this.GetTestInstallFolder(@"B\B.wxs"); string packageCSourceCodeInstalled = this.GetTestInstallFolder(@"C\C.wxs"); // Source file should *not* be installed Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A payload should not be there on test start: ", packageASourceCodeInstalled)); Assert.False(File.Exists(packageBSourceCodeInstalled), String.Concat("Package B payload should not be there on test start: ", packageBSourceCodeInstalled)); Assert.False(File.Exists(packageCSourceCodeInstalled), String.Concat("Package C payload should not be there on test start: ", packageCSourceCodeInstalled)); BundleInstaller install = new BundleInstaller(this, bundleA).Install(); // Source file should be installed Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled)); Assert.True(File.Exists(packageBSourceCodeInstalled), String.Concat("Should have found Package B payload installed at: ", packageBSourceCodeInstalled)); Assert.True(File.Exists(packageCSourceCodeInstalled), String.Concat("Should have found Package C payload installed at: ", packageCSourceCodeInstalled)); // Uninstall everything. install.Uninstall(); // Source file should *not* be installed Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageASourceCodeInstalled)); Assert.False(File.Exists(packageBSourceCodeInstalled), String.Concat("Package B payload should have been removed by uninstall from: ", packageBSourceCodeInstalled)); Assert.False(File.Exists(packageCSourceCodeInstalled), String.Concat("Package C payload should have been removed by uninstall from: ", packageCSourceCodeInstalled)); this.Complete(); }
public void Burn_InstallUninstallAddonRelatedBundle() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; string packageC = new PackageBuilder(this, "C").Build().Output; string packageD = new PackageBuilder(this, "D").Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageC", packageC); bindPaths.Add("packageD", packageD); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); // Test that packages A and C but not D are installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageC)); Assert.False(MsiVerifier.IsPackageInstalled(packageD)); // Attempt to uninstall bundleA. installerA.Uninstall(); // Test that uninstalling bundle A detected and would remove bundle C. Assert.True(LogVerifier.MessageInLogFileRegex(installerA.LastLogFile, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Addon, scope: PerMachine, version: 1\.0\.0\.0, operation: Remove")); // Test that all packages are uninstalled. Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageC)); Assert.False(MsiVerifier.IsPackageInstalled(packageD)); this.Complete(); }
public void Burn_PermanentInstallUninstallForceUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install Bundle A. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall Bundle A. installerA.Uninstall(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); // Force Uninstall Bundle A. this.SetPackageRequestedState("PackageA", WixToolset.Bootstrapper.RequestState.ForceAbsent); this.SetPackageRequestedState("PackageB", WixToolset.Bootstrapper.RequestState.ForceAbsent); installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); this.Complete(); }
public void Burn_AutomaticSlipstreamInstallUninstall() { const string originalVersion = "1.0.0.0"; const string patchedVersion = "1.0.1.0"; // Build the packages. string packageA = this.GetPackageA().Output; string packageAUpdate = this.GetPackageAv101().Output; string packageB = this.GetPackageB().Output; string packageBUpdate = new PackageBuilder(this, "B") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion} }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } }, TargetPaths = new string[] { packageA, packageB }, UpgradePaths = new string[] { packageAUpdate, packageBUpdate } }.Build().Output; string patchB = new PatchBuilder(this, "PatchB") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } }, TargetPaths = new string[] { packageA, packageB }, UpgradePaths = new string[] { packageAUpdate, packageBUpdate } }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); bindPaths.Add("patchA", patchA); bindPaths.Add("patchB", patchB); string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; BundleInstaller install = new BundleInstaller(this, bundleC).Install(); using (RegistryKey root = this.GetTestRegistryRoot()) { // Product A should've slipstreamed both patches. string actualVersion = root.GetValue("A") as string; Assert.Equal(patchedVersion, actualVersion); actualVersion = root.GetValue("A2") as string; Assert.Equal(patchedVersion, actualVersion); // Product B should've only slipstreamed patch B. actualVersion = root.GetValue("B") as string; Assert.Equal(originalVersion, actualVersion); actualVersion = root.GetValue("B2") as string; Assert.Equal(patchedVersion, actualVersion); } install.Uninstall(); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
private BundleBuilder GetBundleA(Dictionary <string, string> bindPaths = null) { if (null == bindPaths) { string packageAPath = this.GetPackageA().Output; bindPaths = new Dictionary <string, string>() { { "packageA", packageAPath } }; } if (null == this.bundleA) { this.bundleA = this.CreateBundle("BundleA", bindPaths); } return(this.bundleA); }
private BundleBuilder GetBundleOnlyPatchA() { if (null == this.bundleOnlyPatchA) { string patchAPath = this.GetPatchA().Output; Dictionary <string, string> bindPaths = new Dictionary <string, string>() { { "patchA", patchAPath } }; this.bundleOnlyPatchA = new BundleBuilder(this, "BundleOnlyPatchA") { BindPaths = bindPaths, Extensions = Extensions }.Build(); } return(this.bundleOnlyPatchA); }
void DrawButtonFunction() { EditorGUILayout.BeginHorizontal(); if (GUILayout.Button("Build Bundle")) { BundleBuilder.BuildBundle(target as BundleObject); } if (GUILayout.Button("Save as")) { if (!string.IsNullOrEmpty(SaveName)) { MyScriptObject.CreateScriptObject <BundleObject>(SaveName); } } SaveName = EditorGUILayout.TextField(SaveName); EditorGUILayout.EndHorizontal(); EditorGUILayout.Space(); }
public void Burn_MimimalAdditionalRegistration() { // Build the bundle. string bundleA = new BundleBuilder(this, "BundleA") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; // Install the bundle. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); // Make sure the registry exists. using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_MimimalAdditionalRegistration - Bundle A")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("Microsoft Corporation", key.GetValue("Publisher")); Assert.Equal("Update", key.GetValue("ReleaseType")); } this.Complete(); }
public void Burn_FeatureRepair() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundle with the optional feature present this.SetPackageFeatureState("PackageA", "Test", FeatureState.Local); BundleInstaller install = new BundleInstaller(this, bundleA).Install(); this.ResetPackageStates("PackageA"); string packageSourceCodeInstalled = this.GetTestInstallFolder(@"A\A.wxs"); string packageNotKeyPathFile = this.GetTestInstallFolder(@"A\notkeypath.file"); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A keyfile installed at: ", packageSourceCodeInstalled)); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A non-keyfile installed at: ", packageSourceCodeInstalled)); // Delete the non-keypath source file. File.Delete(packageNotKeyPathFile); // Now repair without repairing the feature to verify the non-keyfile doesn't come back. install.Repair(); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A keyfile installed at: ", packageSourceCodeInstalled)); Assert.False(File.Exists(packageNotKeyPathFile), String.Concat("Should have not found Package A non-keyfile installed at: ", packageNotKeyPathFile)); // Now repair and include the feature this time. this.SetPackageFeatureState("PackageA", "Test", FeatureState.Local); install.Repair(); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A keyfile installed at: ", packageSourceCodeInstalled)); Assert.True(File.Exists(packageNotKeyPathFile), String.Concat("Should have repaired Package A non-keyfile installed at: ", packageNotKeyPathFile)); this.ResetPackageStates("PackageA"); // Uninstall everything. install.Uninstall(); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageSourceCodeInstalled)); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
private BundleBuilder GetBundleAReverse() { if (null == this.bundleAReverse) { string packageAPath = this.GetPackageA().Output; string patchAPath = this.GetPatchA().Output; Dictionary <string, string> bindPaths = new Dictionary <string, string>() { { "packageA", packageAPath }, { "patchA", patchAPath } }; this.bundleAReverse = new BundleBuilder(this, "BundleAReverse") { BindPaths = bindPaths, Extensions = Extensions }.Build(); } return(this.bundleAReverse); }
/// <summary> /// Creates an instance of a <see cref="BundleBuilder"/>. /// </summary> /// <param name="name">The name of the bundle to create.</param> /// <param name="bindPaths">Additional bind paths for building the bundle.</param> /// <param name="preprocessorVariables">Preprocessor variables for building the bundle.</param> /// <param name="extensions">Extensions for building the bundle.</param> /// <returns>A new <see cref="BundleBuilder"/> initialized with the given data.</returns> protected BundleBuilder CreateBundle(string name, Dictionary <string, string> bindPaths = null, Dictionary <string, string> preprocessorVariables = null, string[] extensions = null) { string testDataDirectory = Path.Combine(this.TestContext.TestDataDirectory, @"Integration\BurnIntegrationTests\BasicTests"); BundleBuilder builder = new BundleBuilder(this.TestContext.TestName, name, testDataDirectory, this.TestArtifacts); if (null != bindPaths) { builder.BindPaths = bindPaths; } if (null != preprocessorVariables) { builder.PreprocessorVariables = preprocessorVariables; } builder.Extensions = extensions ?? WixTestBase.Extensions; return(builder.Build()); }
public void Burn_MaximumAdditionalRegistration() { // Build the bundle. string bundleC = new BundleBuilder(this, "BundleC") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; // Install the bundle. BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); // Make sure the registry exists. using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Updates\Visual Studio 11\KB1234567")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("Microsoft Corporation", key.GetValue("Publisher")); Assert.Equal("Developer Division", key.GetValue("PublishingGroup")); Assert.Equal("Service Pack", key.GetValue("ReleaseType")); } this.Complete(); }
/// <summary> /// Creates an instance of a <see cref="BundleBuilder"/>. /// </summary> /// <param name="name">The name of the bundle to create.</param> /// <param name="bindPaths">Additional bind paths for building the bundle.</param> /// <param name="preprocessorVariables">Preprocessor variables for building the bundle.</param> /// <param name="extensions">Extensions for building the bundle.</param> /// <returns>A new <see cref="BundleBuilder"/> initialized with the given data.</returns> protected BundleBuilder CreateBundle(string name, Dictionary<string, string> bindPaths = null, Dictionary<string, string> preprocessorVariables = null, string[] extensions = null) { string testDataDirectory = Path.Combine(this.TestContext.TestDataDirectory, @"Integration\BurnIntegrationTests\BasicTests"); BundleBuilder builder = new BundleBuilder(this.TestContext.TestName, name, testDataDirectory, this.TestArtifacts); if (null != bindPaths) { builder.BindPaths = bindPaths; } if (null != preprocessorVariables) { builder.PreprocessorVariables = preprocessorVariables; } builder.Extensions = extensions ?? WixTestBase.Extensions; return builder.Build(); }
private BundleBuilder GetBundleAv2(Dictionary <string, string> bindPaths = null) { if (null == bindPaths) { string packageAPath = this.GetPackageAv2().Output; bindPaths = new Dictionary <string, string>() { { "packageA", packageAPath } }; } return((null != this.bundleAv2) ? this.bundleAv2 : this.bundleAv2 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", V2 } } }.Build()); }
public void Burn_FeatureInstallUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; BundleInstaller install = new BundleInstaller(this, bundleA).Install(); // Source file should *not* be installed, main registry key should be present. string packageSourceCodeInstalled = this.GetTestInstallFolder(@"A\A.wxs"); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Should not have found Package A payload installed at: ", packageSourceCodeInstalled)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("A") as string; Assert.Equal("1.0.0.0", actualVersion); } // Now turn on the feature. this.SetPackageRequestedState("PackageA", RequestState.Present); this.SetPackageFeatureState("PackageA", "Test", FeatureState.Local); install.Modify(); Assert.True(File.Exists(packageSourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageSourceCodeInstalled)); this.ResetPackageStates("PackageA"); // Turn the feature back off. this.SetPackageRequestedState("PackageA", RequestState.Present); this.SetPackageFeatureState("PackageA", "Test", FeatureState.Absent); install.Modify(); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Should have removed Package A payload from: ", packageSourceCodeInstalled)); this.ResetPackageStates("PackageA"); // Uninstall everything. install.Uninstall(); Assert.False(File.Exists(packageSourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageSourceCodeInstalled)); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
public void Burn_InstallUninstallBundleWithEmbeddedBundle() { // Build the packages. string packageA1 = new PackageBuilder(this, "A").Build().Output; string packageB1 = new PackageBuilder(this, "B").Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA1); bindPaths.Add("packageB", packageB1); // Build the embedded bundle. string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Build the parent bundle bindPaths.Add("bundleB", bundleB); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); // Test package is installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.True(MsiVerifier.IsPackageInstalled(packageB1)); // Attempt to uninstall bundleA. installerA.Uninstall(); // Test package is uninstalled. Assert.False(MsiVerifier.IsPackageInstalled(packageA1)); Assert.False(MsiVerifier.IsPackageInstalled(packageB1)); this.Complete(); }
public void Burn_MissingNonVitalPackage() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundle. string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Delete the non-vital package to force the ignorable failure. File.Delete(Path.Combine(Path.GetDirectoryName(bundleC), "~Burn_MissingNonVitalPackage_PackageA.msi")); // Install the bundle. BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerC.LastLogFile, "Skipping apply of package: PackageA due to cache error: 0x80070002. Continuing...")); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall bundle. installerC.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); this.CleanTestArtifacts = true; }
private BundleBuilder GetBundleC(Dictionary <string, string> bindPaths = null) { if (null == bindPaths) { string packageCPath = this.GetPackageC().Output; bindPaths = new Dictionary <string, string>() { { "packageC", packageCPath } }; } if (null == this.bundleC) { this.bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build(); } return(this.bundleC); }
public void Burn_MimimalAdditionalRegistration() { // Build the bundle. string bundleA = new BundleBuilder(this, "BundleA") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; // Install the bundle. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); // Make sure the registry exists. using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_MimimalAdditionalRegistration - Bundle A")) { Assert.AreEqual("Y", key.GetValue("ThisVersionInstalled")); Assert.AreEqual("Microsoft Corporation", key.GetValue("Publisher")); Assert.AreEqual("Update", key.GetValue("ReleaseType")); } this.CleanTestArtifacts = true; }
public void Burn_MinimalAdditionalRegistrationWithProductFamily() { // Build the bundle. string bundleB = new BundleBuilder(this, "BundleB") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; // Install the bundle. BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // Make sure the registry exists. using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\Visual Studio 11\~Burn_MinimalAdditionalRegistrationWithProductFamily - Bundle B")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("Microsoft Corporation", key.GetValue("Publisher")); Assert.Equal("Update", key.GetValue("ReleaseType")); } this.Complete(); }
public void Burn_ComponentSearchResults() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // PackageB will be installed if all ComponentSearches worked. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall the main bundle and add-on. installerA.Uninstall(); this.CleanTestArtifacts = true; }
public void Burn_BuildNonSpecificPatches() { string patchedVersion = "1.0.1.0"; string[] extensions = new string[] { "WixBalExtension", "WixTagExtension", }; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = extensions }.Build().Output; string packageAUpdate = new PackageBuilder(this, "A") { Extensions = extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { Extensions = extensions, TargetPath = packageA, UpgradePath = packageAUpdate }.Build().Output; string patchB = new PatchBuilder(this, "PatchB") { Extensions = extensions, TargetPath = packageA, UpgradePath = packageAUpdate }.Build().Output; string patchC = new PatchBuilder(this, "PatchC") { Extensions = extensions, TargetPath = packageA, UpgradePath = packageAUpdate }.Build().Output; // Build the bundles. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("patchA", patchA); bindPaths.Add("patchB", patchB); bindPaths.Add("patchC", patchC); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = extensions }.Build().Output; WixTest.BundleBuilder bundleAPatch = new BundleBuilder(this, "PatchBundleA") { BindPaths = bindPaths, Extensions = extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } } }.Build(); WixTest.BundleBuilder bundleBPatch = new BundleBuilder(this, "PatchBundleB") { BindPaths = bindPaths, Extensions = extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } } }.Build(); WixTest.BundleBuilder bundleCPatch = new BundleBuilder(this, "PatchBundleC") { BindPaths = bindPaths, Extensions = extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", patchedVersion } } }.Build(); // Disassemble the patch bundles and check for PatchTargetCode elements. XmlNodeList nodes = PatchTests.GetPatchTargetCodes(bundleAPatch); Assert.Equal(1, nodes.Count); Assert.True(nodes.OfType<XmlElement>().Any(elem => elem.HasAttribute("Product") && "yes".Equals(elem.Attributes["Product"].Value))); nodes = PatchTests.GetPatchTargetCodes(bundleBPatch); Assert.Equal(2, nodes.Count); Assert.True(nodes.OfType<XmlElement>().Any(elem => elem.HasAttribute("Product") && "yes".Equals(elem.Attributes["Product"].Value))); Assert.True(nodes.OfType<XmlElement>().Any(elem => elem.HasAttribute("Product") && "no".Equals(elem.Attributes["Product"].Value))); nodes = PatchTests.GetPatchTargetCodes(bundleCPatch); Assert.Equal(0, nodes.Count); this.Complete(); }
public void Burn_CancelVeryEarly() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundle. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Cancel package B right away. this.SetPackageCancelExecuteAtProgress("PackageB", 1); // Install the bundle and hopefully it fails. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(expectedExitCode: ErrorCodes.ERROR_INSTALL_USEREXIT); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); this.Complete(); }
public void Burn_MissingNonVitalPackage() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundle. string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Delete the non-vital package to force the ignorable failure. File.Delete(Path.Combine(Path.GetDirectoryName(bundleC), "~Burn_MissingNonVitalPackage_PackageA.msi")); // Install the bundle. BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerC.LastLogFile, "Skipping apply of package: PackageA due to cache error: 0x80070002. Continuing...")); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall bundle. installerC.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); this.CleanTestArtifacts = true; }
public void Burn_UninstallUpgradedBundle() { const string expectedVersion1 = "1.0.0.0"; const string expectedVersion2 = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; string packageA1 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Override the path for A to A1. bindPaths["packageA"] = packageA1; string bundleA1 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // Make sure the MSIs and EXE are installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion1, actualVersion); } // Attempt to upgrade bundleA. BundleInstaller installerA1 = new BundleInstaller(this, bundleA1).Install(); // Verify packageA1 was installed and packageA was uninstalled. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA1)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion2, actualVersion); } // Uninstall bundleA1 and verify that packageA1 is still installed. installerA1.Uninstall(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA1)); // Uninstall bundleB now. installerB.Uninstall(); // BUG: BundleB does not know about PackageA1 (A,v2), so remove it explicitly (SFBUG:3307315). MSIExec.UninstallProduct(packageA1, MSIExec.MSIExecReturnCode.SUCCESS); // Make sure the MSIs are not installed. Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA1)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_UninstallBundleWithDependent() { const string expectedVersion = "1.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // Make sure the MSIs and EXE are installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Attempt to uninstall bundleA. installerA.Uninstall(); // Verify packageA and ExeA are still installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Uninstall bundleB now. installerB.Uninstall(); // Make sure the MSIs are installed. Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_UninstallAddonBundle() { const string expectedVersion = "1.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA1 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleA2 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleF = new BundleBuilder(this, "BundleF") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the base bundle and make sure all packages are installed. BundleInstaller installerF = new BundleInstaller(this, bundleF).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); // Install an addon bundle and make sure all packages are installed. BundleInstaller installerA1 = new BundleInstaller(this, bundleA1).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Install a second addon bundle and make sure all packages are installed. BundleInstaller installerA2 = new BundleInstaller(this, bundleA2).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Uninstall the base bundle and make sure all packages are uninstalled. installerF.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_RollbackUpgradeBundle() { const string expectedVersion1 = "1.0.0.0"; const string expectedVersion2 = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleD = new BundleBuilder(this, "BundleD") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the base bundle and make sure it's installed. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion1, actualVersion); } // Install the upgrade bundle that will fail and rollback. Make sure packageA is still present. // SFBUG:3405221 - pkg dependecy not removed in rollback if pkg already present BundleInstaller installerD = new BundleInstaller(this, bundleD).Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion1, actualVersion); } // Uninstall the first bundle and make sure packageA is uninstalled. installerA.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_MixedScopeUpgradedBundle() { const string upgradeVersion = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageD1 = new PackageBuilder(this, "D") { Extensions = Extensions }.Build().Output; string packageD2 = new PackageBuilder(this, "D") { Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", upgradeVersion } } }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageD", packageD1); // Build the base bundle. string bundleH1 = new BundleBuilder(this, "BundleH") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Override the path for D1 to D2 and build the upgrade bundle. bindPaths["packageD"] = packageD2; string bundleH2 = new BundleBuilder(this, "BundleH") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", upgradeVersion } } }.Build().Output; // Install the base bundle. BundleInstaller installerH1 = new BundleInstaller(this, bundleH1).Install(); // Make sure the MSIs are installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageD1)); Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerH1.LastLogFile, @"Skipping cross-scope dependency registration on package: PackageA, bundle scope: PerUser, package scope: PerMachine")); // Install the upgrade bundle. Verify the base bundle was removed. BundleInstaller installerH2 = new BundleInstaller(this, bundleH2).Install(); // Verify packageD2 was installed and packageD1 was uninstalled. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD1)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageD2)); Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerH2.LastLogFile, @"Skipping cross-scope dependency registration on package: PackageA, bundle scope: PerUser, package scope: PerMachine")); Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerH2.LastLogFile, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Upgrade, scope: PerUser, version: 1\.0\.0\.0, operation: MajorUpgrade")); // Uninstall the upgrade bundle now. installerH2.Uninstall(); // Verify that permanent packageA is still installed and then remove. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); MSIExec.UninstallProduct(packageA, MSIExec.MSIExecReturnCode.SUCCESS); // Make sure the MSIs were uninstalled. Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD2)); this.CleanTestArtifacts = true; }
public void Burn_InstallUpgradeSlipstreamBundle() { const string expectedVersion1 = "1.0.0.0"; const string expectedVersion2 = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageA1 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion2 } }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion2 } }, TargetPath = packageA, UpgradePath = packageA1 }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("patchA", patchA); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the base bundle and make sure it's installed. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion1, actualVersion); } // Install the upgrade bundle with a slipstreamed patch and make sure the patch is installed. // SFBUG:3387046 - Uninstalling bundle registers a dependency on a package BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); Assert.IsTrue(MsiUtils.IsPatchInstalled(patchA)); // BundleC doesn't carry the EXE, so make sure it's removed. using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.IsNull(root.GetValue("Version")); } // Repair the upgrade bundle to make sure it does not prompt for source. // SFBUG:3386927 - MSIs get removed from cache during upgrade installerC.Repair(); // Uninstall the slipstream bundle and make sure both packages are uninstalled. installerC.Uninstall(); Assert.IsFalse(MsiUtils.IsPatchInstalled(patchA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); this.CleanTestArtifacts = true; }
public void Burn_InstallPatchBundle() { const string expectedVersion = "1.0.1.0"; // Build the packages. string packageA1 = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageA2 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion } }, NeverGetsInstalled = true }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", expectedVersion } }, TargetPath = packageA1, UpgradePath = packageA2 }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA1); bindPaths.Add("packageB", packageB); bindPaths.Add("patchA", patchA); // Build the bundles. string bundleF = new BundleBuilder(this, "BundleF") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleG = new BundleBuilder(this, "BundleG") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the base bundle and make sure all packages are installed. BundleInstaller installerF = new BundleInstaller(this, bundleF).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA1)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); // Install patch bundle and make sure all packages are installed. BundleInstaller installerG = new BundleInstaller(this, bundleG).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA1)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageB)); Assert.IsTrue(MsiUtils.IsPatchInstalled(patchA)); // Uninstall the base bundle and make sure all packages are uninstalled. installerF.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA1)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); Assert.IsFalse(MsiUtils.IsPatchInstalled(patchA)); this.CleanTestArtifacts = true; }
public void Burn_FailNonVitalPackage() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageC = new PackageBuilder(this, "C") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageC); // Build the bundle. string bundleE = new BundleBuilder(this, "BundleE") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundle and make sure packageA is installed. // SFBUG:3435047 - Make sure during install we don't fail for non-vital packages. BundleInstaller installerE = new BundleInstaller(this, bundleE).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC)); using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.IsNull(root.GetValue("Version")); } // Repair the bundle. // SFBUG:3435047 - Make sure during repair we don't fail for the same reason in a different code path. installerE.Repair(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC)); using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.IsNull(root.GetValue("Version")); } // Uninstall the bundle and make sure packageA is uninstalled. installerE.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsNull(this.GetTestRegistryRoot()); this.CleanTestArtifacts = true; }
public void Burn_DifferentPackageRequestStates() { const string expectedVersion = "1.0.0.0"; // Build the package. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the base bundle and make sure it's installed. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // SFBUG:3469206 - install a bundle without installing the shared package, which should not be ref-counted. this.SetPackageRequestedState("PackageA", RequestState.None); // Also don't install packageB since it has an authored dependency on packageA and would fail this test case. this.SetPackageRequestedState("PackageB", RequestState.None); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Uninstall the first bundle and make sure packageA is uninstalled. this.ResetPackageStates("PackageA"); installerA.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.AreEqual(expectedVersion, actualVersion); } // Uninstall the second bundle and make sure all packages are uninstalled. installerB.Uninstall(); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.IsNull(root.GetValue("Version")); } this.CleanTestArtifacts = true; }
public void Burn_MissingAttributesForAddditionalRegistration() { Assert.Throws<TestException>(() => { // Build the bundle. string bundleD = new BundleBuilder(this, "BundleD") { Extensions = Extensions, AdditionalSourceFiles = this.AdditionalSourceFiles }.Build().Output; }); this.Complete(); }