Support dual-purpose packages in Burn.bob/ConfigurableScopeBundles

Fixes https://github.com/wixtoolset/issues/issues/8958

5 files changed, 642 insertions, 4 deletions

diff --git a/src/test/burn/WixToolsetTest.BurnE2E/BundlePackageTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/BundlePackageTests.cs
index dc793cf0..b066899b 100644
--- a/src/test/burn/WixToolsetTest.BurnE2E/BundlePackageTests.cs
+++ b/src/test/burn/WixToolsetTest.BurnE2E/BundlePackageTests.cs
@@ -92,7 +92,7 @@ namespace WixToolsetTest.BurnE2E
 
             Assert.True(LogVerifier.MessageInLogFile(logPath, "Applied execute package: v3bundle.exe, result: 0x0, restart: None"));
 
-            Assert.True(BundleRegistration.TryGetPerMachineBundleRegistrationById(v3BundleId, false, out var v3Registration));
+            Assert.True(BundleRegistration.TryGetPerMachineBundleRegistrationById(v3BundleId, false, this.TestContext.TestOutputHelper, out var v3Registration));
             Assert.Null(v3Registration.SystemComponent);
         }
 
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/ConfigurableScopeTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/ConfigurableScopeTests.cs
new file mode 100644
index 00000000..1b7d6d75
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/ConfigurableScopeTests.cs
@@ -0,0 +1,631 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using WixTestTools;
+    using WixToolset.BootstrapperApplicationApi;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class ConfigurableScopeTests : BurnE2ETests
+    {
+        public ConfigurableScopeTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [RuntimeFact]
+        public void CommandLineScopeTestNoopBecauseNonDefaultPlan()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("AllPmouBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install(arguments: "/peruser");
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Scope command-line switch ignored because the bootstrapper application already specified a scope."));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void CommandLineScopeTestNoopBecauseNoConfigurablePackages()
+        {
+            var bundle = this.CreateBundleInstaller("PerMachineBundle");
+            var log = bundle.Install(arguments: "/peruser");
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Scope command-line switch ignored because the bundle doesn't have any packages with configurable scope."));
+        }
+
+        [RuntimeFact]
+        public void CommandLineScopeTestPerUser()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("AllPmouBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install(arguments: "/peruser");
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall(arguments: "/peruser");
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void CommandLineScopeTestPerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("AllPuomBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install(arguments: "/permachine");
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+
+            bundle.Uninstall(arguments: "/permachine");
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PMOU_Bundle_Default_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("AllPmouBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PUOM_Bundle_Default_Plan_Installs_PerUser()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("AllPuomBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PMOU_Bundle_PM_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("AllPmouBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PUOM_Bundle_PM_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("AllPuomBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PMOU_Bundle_PU_Plan_Installs_PerUser()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerUser);
+
+            var bundle = this.CreateBundleInstaller("AllPmouBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PUOM_Bundle_PU_Plan_Installs_PerUser()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerUser);
+
+            var bundle = this.CreateBundleInstaller("AllPuomBundleTestBA");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 3 packages, action: Install, planned scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PMOU_Bundle_Default_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("PmPmouBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 4 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PMOU_Bundle_PM_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("PmPmouBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 4 packages, action: Install, planned scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PMOU_Bundle_PU_Plan_Installs_PerUserMostly()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerUser);
+
+            var bundle = this.CreateBundleInstaller("PmPmouBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 4 packages, action: Install, planned scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PUOM_Bundle_Default_Plan_Installs_PerUser()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("PmPuomBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 4 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PUOM_Bundle_PM_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("PmPuomBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 4 packages, action: Install, planned scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PUOM_Bundle_PU_Plan_Installs_PerUserMostly()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerUser);
+
+            var bundle = this.CreateBundleInstaller("PmPuomBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 4 packages, action: Install, planned scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned configurable scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PU_PMOU_Bundle_Default_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("PmPuPmouBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 5 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerUserPkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PU_PMOU_Bundle_PM_Plan_Installs_PerMachine()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("PmPuPmouBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var perUserPkg = this.CreatePackageInstaller("PerUserPkg");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled();
+            perUserPkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 5 packages, action: Install, planned scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerUserPkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled(false);
+            perUserPkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PU_PMOU_Bundle_PU_Plan_Installs_PerUserMostly()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerUser);
+
+            var bundle = this.CreateBundleInstaller("PmPuPmouBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var perUserPkg = this.CreatePackageInstaller("PerUserPkg");
+            var pkg1 = this.CreatePackageInstaller("PmouPkg1");
+            var pkg2 = this.CreatePackageInstaller("PmouPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled();
+            perUserPkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 5 packages, action: Install, planned scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerUserPkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser,"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PmouPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser,"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled(false);
+            perUserPkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PU_PUOM_Bundle_Default_Plan_Installs_PerUser()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.Default);
+
+            var bundle = this.CreateBundleInstaller("PmPuPuomBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var perUserPkg = this.CreatePackageInstaller("PerUserPkg");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled();
+            perUserPkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 5 packages, action: Install, planned scope: Default"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerUserPkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled(false);
+            perUserPkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PU_PUOM_Bundle_PM_Plan_Installs_PerMachineMostly()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerMachine);
+
+            var bundle = this.CreateBundleInstaller("PmPuPuomBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var perUserPkg = this.CreatePackageInstaller("PerUserPkg");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled();
+            perUserPkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 5 packages, action: Install, planned scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerUserPkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: true);
+            perMachinePkg.VerifyInstalled(false);
+            perUserPkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+        [RuntimeFact]
+        public void PM_PU_PUOM_Bundle_PU_Plan_Installs_PerUserMostly()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetBundleScope(BundleScope.PerUser);
+
+            var bundle = this.CreateBundleInstaller("PmPuPuomBundleTestBA");
+            var perMachinePkg = this.CreatePackageInstaller("PerMachinePkg");
+            var perUserPkg = this.CreatePackageInstaller("PerUserPkg");
+            var pkg1 = this.CreatePackageInstaller("PuomPkg1");
+            var pkg2 = this.CreatePackageInstaller("PuomPkg2");
+            var log = bundle.Install();
+
+            bundle.VerifyRegisteredAndInPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled();
+            perUserPkg.VerifyInstalled();
+            pkg1.VerifyInstalled();
+            pkg2.VerifyInstalled();
+
+            Assert.True(LogVerifier.MessageInLogFile(log, "Plan begin, 5 packages, action: Install, planned scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerMachinePkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PerUserPkg.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg1.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+            Assert.True(LogVerifier.MessageInLogFile(log, "Planned package: PuomPkg2.msi, state: Absent, default requested: Present, ba requested: Present, execute: Install, rollback: Uninstall, scope: PerUser"));
+
+            bundle.Uninstall();
+            bundle.VerifyUnregisteredAndRemovedFromPackageCache(plannedPerMachine: false);
+            perMachinePkg.VerifyInstalled(false);
+            perUserPkg.VerifyInstalled(false);
+            pkg1.VerifyInstalled(false);
+            pkg2.VerifyInstalled(false);
+        }
+
+
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/OptionalUpdateRegistrationTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/OptionalUpdateRegistrationTests.cs
index 3731b0cc..3e848fbd 100644
--- a/src/test/burn/WixToolsetTest.BurnE2E/OptionalUpdateRegistrationTests.cs
+++ b/src/test/burn/WixToolsetTest.BurnE2E/OptionalUpdateRegistrationTests.cs
@@ -20,11 +20,11 @@ namespace WixToolsetTest.BurnE2E
 
             bundleAv1.Install();
             bundleAv1.VerifyRegisteredAndInPackageCache();
-            var gotV1Registration = bundleAv1.TryGetUpdateRegistration(out var v1Registration);
+            var gotV1Registration = bundleAv1.TryGetUpdateRegistration(plannedPerMachine: null, out var v1Registration);
 
             bundleAv2.Install();
             bundleAv2.VerifyRegisteredAndInPackageCache();
-            var gotV2Registration = bundleAv2.TryGetUpdateRegistration(out var v2Registration);
+            var gotV2Registration = bundleAv2.TryGetUpdateRegistration(plannedPerMachine: null, out var v2Registration);
 
             bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
 
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/Utilities/TestBAController.cs b/src/test/burn/WixToolsetTest.BurnE2E/Utilities/TestBAController.cs
index c344ebce..872e6954 100644
--- a/src/test/burn/WixToolsetTest.BurnE2E/Utilities/TestBAController.cs
+++ b/src/test/burn/WixToolsetTest.BurnE2E/Utilities/TestBAController.cs
@@ -72,6 +72,11 @@ namespace WixToolsetTest.BurnE2E
             this.SetBurnTestValue("ForceUpdateSource", url);
         }
 
+        public void SetBundleScope(BundleScope scope)
+        {
+            this.SetBurnTestValue("BundleScope", scope.ToString());
+        }
+
         /// <summary>
         /// Slows the cache progress of a package.
         /// </summary>
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd b/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd
index ecea18a0..f6950fb0 100644
--- a/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd
+++ b/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd
@@ -1,2 +1,4 @@
 SET RuntimeTestsEnabled=true
-dotnet test WixToolsetTest.BurnE2E.dll -v normal --logger trx
+dotnet test WixToolsetTest.BurnE2E.dll -v normal --logger trx;LogFileName=%TMP%\SandboxTests.trx
+
+ROBOCOPY /NFL /NDL /S /PURGE %TMP% C:\Build\SandboxLogs *.log *.trx