Ensure user and group integration tests always clean up after themselves.

Fixes 8940
author: Rob Mensching <rob@firegiant.com> 2025-02-12 11:01:19 -0800
committer: Rob Mensching <rob@firegiant.com> 2025-02-12 11:55:25 -0800
commit: bbe23165a86e71661b725bc2155a79685f7a7ea7 (patch)
tree: 7aa8044ed720b7f1eeadb5ae4a39418dfa9d777e /src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs
parent: bc433149fa086422a7d0fc2713aa9758b1d65883 (diff)
download: wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.tar.gz
wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.tar.bz2
wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.zip
1 files changed, 179 insertions, 131 deletions
diff --git a/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs b/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs
index 08b7cee1..40538eef 100644
--- a/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs
+++ b/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs
@@ -15,130 +15,148 @@ namespace WixToolsetTest.MsiE2E
        [RuntimeFact]
        public void CanInstallAndUninstallUsers()
        {
-            UserVerifier.CreateLocalUser("testName3", "test123!@#");
+            try
-            var productA = this.CreatePackageInstaller("ProductA");
+            {
+                UserVerifier.CreateLocalUser("testName3", "test123!@#");
-            productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
+                var productA = this.CreatePackageInstaller("ProductA");
-            // Validate New User Information.
+                productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
-            UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
-            UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
-            UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);
+                // Validate New User Information.
-            UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");
+                UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
+                UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
-            UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");
+                UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);
+                UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");
-            productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
+                UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");
-            // Verify Users marked as RemoveOnUninstall were removed.
+                productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
-            Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
-            Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
-            // Verify that user added to power users group is removed on uninstall.
+                // Verify Users marked as RemoveOnUninstall were removed.
-            UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
+                Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
+                Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
-            // clean up
+                // Verify that user added to power users group is removed on uninstall.
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
-            UserVerifier.DeleteLocalUser("testName2");
+            }
-            UserVerifier.DeleteLocalUser("testName3");
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.DeleteLocalUser("testName2");
+                UserVerifier.DeleteLocalUser("testName3");
+            }
        }
        // Verify the rollback action reverts all Users changes.
        [RuntimeFact]
        public void CanRollbackUsers()
        {
-            UserVerifier.CreateLocalUser("testName3", "test123!@#", "User3 comment");
+            try
-            UserVerifier.AddUserToGroup("testName3", "Backup Operators");
+            {
-            var productFail = this.CreatePackageInstaller("ProductFail");
+                UserVerifier.CreateLocalUser("testName3", "test123!@#", "User3 comment");
+                UserVerifier.AddUserToGroup("testName3", "Backup Operators");
-            // make sure the user accounts are deleted before we start
+                var productFail = this.CreatePackageInstaller("ProductFail");
-            UserVerifier.DeleteLocalUser("testName1");
-            UserVerifier.DeleteLocalUser("testName2");
+                // make sure the user accounts are deleted before we start
+                UserVerifier.DeleteLocalUser("testName1");
-            productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
+                UserVerifier.DeleteLocalUser("testName2");
-            // Verify added Users were removed on rollback.
+                productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
-            Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Rollback", "testName1"));
-            Assert.False(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was not removed on Rollback", "testName2"));
+                // Verify added Users were removed on rollback.
+                Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Rollback", "testName1"));
-            // Verify that user added to power users group is removed from power users group on rollback.
+                Assert.False(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was not removed on Rollback", "testName2"));
-            UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
-            // but is not removed from Backup Operators
+                // Verify that user added to power users group is removed from power users group on rollback.
-            UserVerifier.VerifyUserIsMemberOf(string.Empty, "testName3", "Backup Operators");
+                UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
-            // and has their original comment set back
+                // but is not removed from Backup Operators
-            UserVerifier.VerifyUserComment(string.Empty, "testName3", "User3 comment");
+                UserVerifier.VerifyUserIsMemberOf(string.Empty, "testName3", "Backup Operators");
+                // and has their original comment set back
-            // clean up
+                UserVerifier.VerifyUserComment(string.Empty, "testName3", "User3 comment");
-            UserVerifier.DeleteLocalUser("testName1");
+            }
-            UserVerifier.DeleteLocalUser("testName2");
+            finally
-            UserVerifier.DeleteLocalUser("testName3");
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.DeleteLocalUser("testName2");
+                UserVerifier.DeleteLocalUser("testName3");
+            }
        }
        // Verify that command-line parameters are not blocked by repair switches.
        // Original code signalled repair mode by using "-f ", which silently
        // terminated the command-line parsing, ignoring any parameters that followed.
        [RuntimeFact()]
        public void CanRepairUsersWithCommandLineParameters()
        {
-            var arguments = new string[]
+            try
            {
-                "TESTPARAMETER1=testName1",
+                var arguments = new string[]
-            };
+                {
-            var productWithCommandLineParameters = this.CreatePackageInstaller("ProductWithCommandLineParameters");
+                    "TESTPARAMETER1=testName1",
+                };
-            // Make sure that the user doesn't exist when we start the test.
+                var productWithCommandLineParameters = this.CreatePackageInstaller("ProductWithCommandLineParameters");
-            UserVerifier.DeleteLocalUser("testName1");
-            // Install
+                // Make sure that the user doesn't exist when we start the test.
-            productWithCommandLineParameters.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
+                UserVerifier.DeleteLocalUser("testName1");
-            // Repair
+                // Install
-            productWithCommandLineParameters.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
+                productWithCommandLineParameters.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
-            // Clean up
+                // Repair
-            UserVerifier.DeleteLocalUser("testName1");
+                productWithCommandLineParameters.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
+            }
+            finally
+            {
+                // Clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
        // Verify that the users specified in the authoring are created as expected on repair.
        [RuntimeFact()]
        public void CanRepairUsers()
        {
-            UserVerifier.CreateLocalUser("testName3", "test123!@#");
+            try
-            var productA = this.CreatePackageInstaller("ProductA");
+            {
+                UserVerifier.CreateLocalUser("testName3", "test123!@#");
-            productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
+                var productA = this.CreatePackageInstaller("ProductA");
-            // Validate New User Information.
+                productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
-            UserVerifier.DeleteLocalUser("testName1");
-            UserVerifier.SetUserInformation(String.Empty, "testName2", true, false, false);
-            productA.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS);
+                // Validate New User Information.
+                UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.SetUserInformation(String.Empty, "testName2", true, false, false);
-            // Validate New User Information.
+                productA.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS);
-            UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
-            UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
-            UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);
+                // Validate New User Information.
-            UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");
+                UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
+                UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
-            UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");
+                UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);
+                UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");
-            productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
+                UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");
-            // Verify Users marked as RemoveOnUninstall were removed.
+                productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
-            Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
-            Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
-            // Verify that user added to power users group is removed on uninstall.
+                // Verify Users marked as RemoveOnUninstall were removed.
-            UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
+                Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
+                Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
-            // clean up
+                // Verify that user added to power users group is removed on uninstall.
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
-            UserVerifier.DeleteLocalUser("testName2");
+            }
-            UserVerifier.DeleteLocalUser("testName3");
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.DeleteLocalUser("testName2");
+                UserVerifier.DeleteLocalUser("testName3");
+            }
        }
        // Verify that Installation fails if FailIfExists is set.
@@ -191,93 +209,123 @@ namespace WixToolsetTest.MsiE2E
        [RuntimeFact]
        public void CanCreateNewUserWithComment()
        {
-            var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
+            try
+            {
-            productNewUserWithComment.InstallProduct();
+                var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
-            UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
-            // clean up
+                productNewUserWithComment.InstallProduct();
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
+            }
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
        // Verify that a comment can be added to an existing user
        [RuntimeFact]
        public void CanAddCommentToExistingUser()
        {
-            UserVerifier.CreateLocalUser("testName1", "test123!@#");
+            try
-            var productAddCommentToExistingUser = this.CreatePackageInstaller("ProductAddCommentToExistingUser");
+            {
+                UserVerifier.CreateLocalUser("testName1", "test123!@#");
-            productAddCommentToExistingUser.InstallProduct();
+                var productAddCommentToExistingUser = this.CreatePackageInstaller("ProductAddCommentToExistingUser");
-            UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
+                productAddCommentToExistingUser.InstallProduct();
-            // clean up
+                UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
-            UserVerifier.DeleteLocalUser("testName1");
+            }
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
        // Verify that a comment can be repaired for a new user
        [RuntimeFact]
        public void CanRepairCommentOfNewUser()
        {
-            var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
+            try
+            {
-            productNewUserWithComment.InstallProduct();
+                var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
-            UserVerifier.SetUserComment(String.Empty, "testName1", "");
-            productNewUserWithComment.RepairProduct();
+                productNewUserWithComment.InstallProduct();
-            UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
+                UserVerifier.SetUserComment(String.Empty, "testName1", "");
-            // clean up
+                productNewUserWithComment.RepairProduct();
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
+            }
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
        // Verify that a comment can be changed for an existing user
        [RuntimeFact]
        public void CanChangeCommentOfExistingUser()
        {
-            UserVerifier.CreateLocalUser("testName1", "test123!@#");
+            try
-            UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");
+            {
-            var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
+                UserVerifier.CreateLocalUser("testName1", "test123!@#");
+                UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");
-            productNewUserWithComment.InstallProduct();
+                var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
-            UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
-            // clean up
+                productNewUserWithComment.InstallProduct();
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
+            }
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
        // Verify that a comment can be rolled back for an existing user
        [RuntimeFact]
        public void CanRollbackCommentOfExistingUser()
        {
-            UserVerifier.CreateLocalUser("testName1", "test123!@#");
+            try
-            UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");
+            {
-            var productCommentFail = this.CreatePackageInstaller("ProductCommentFail");
+                UserVerifier.CreateLocalUser("testName1", "test123!@#");
+                UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");
-            productCommentFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
+                var productCommentFail = this.CreatePackageInstaller("ProductCommentFail");
-            // Verify that comment change was rolled back.
+                productCommentFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
-            UserVerifier.VerifyUserComment(String.Empty, "testName1", "initialTestComment1");
-            // clean up
+                // Verify that comment change was rolled back.
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserComment(String.Empty, "testName1", "initialTestComment1");
+            }
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
        // Verify that a comment can be deleted for an existing user
        [RuntimeFact]
        public void CanDeleteCommentOfExistingUser()
        {
-            UserVerifier.CreateLocalUser("testName1", "test123!@#");
+            try
-            UserVerifier.SetUserComment(String.Empty, "testName1", "testComment1");
+            {
-            var productCommentDelete = this.CreatePackageInstaller("ProductCommentDelete");
+                UserVerifier.CreateLocalUser("testName1", "test123!@#");
+                UserVerifier.SetUserComment(String.Empty, "testName1", "testComment1");
-            productCommentDelete.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
+                var productCommentDelete = this.CreatePackageInstaller("ProductCommentDelete");
-            // Verify that comment was removed.
+                productCommentDelete.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
-            UserVerifier.VerifyUserComment(String.Empty, "testName1", "");
-            // clean up
+                // Verify that comment was removed.
-            UserVerifier.DeleteLocalUser("testName1");
+                UserVerifier.VerifyUserComment(String.Empty, "testName1", "");
+            }
+            finally
+            {
+                // clean up
+                UserVerifier.DeleteLocalUser("testName1");
+            }
        }
    }
 }
author	Rob Mensching <rob@firegiant.com>	2025-02-12 11:01:19 -0800
committer	Rob Mensching <rob@firegiant.com>	2025-02-12 11:55:25 -0800
commit	bbe23165a86e71661b725bc2155a79685f7a7ea7 (patch)
tree	7aa8044ed720b7f1eeadb5ae4a39418dfa9d777e /src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs
parent	bc433149fa086422a7d0fc2713aa9758b1d65883 (diff)
download	wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.tar.gz wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.tar.bz2 wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.zip

diff --git a/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs b/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs index 08b7cee1..40538eef 100644 --- a/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs +++ b/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs
@@ -15,130 +15,148 @@ namespace WixToolsetTest.MsiE2E
15	[RuntimeFact]	15	[RuntimeFact]
16	public void CanInstallAndUninstallUsers()	16	public void CanInstallAndUninstallUsers()
17	{	17	{
18	UserVerifier.CreateLocalUser("testName3", "test123!@#");	18	try
19	var productA = this.CreatePackageInstaller("ProductA");	19	{
20		20	UserVerifier.CreateLocalUser("testName3", "test123!@#");
21	productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);	21	var productA = this.CreatePackageInstaller("ProductA");
22		22
23	// Validate New User Information.	23	productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
24	UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
25	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
26		24
27	UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);	25	// Validate New User Information.
28	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");	26	UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
		27	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
29		28
30	UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");	29	UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);
		30	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");
31		31
32	productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);	32	UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");
33		33
34	// Verify Users marked as RemoveOnUninstall were removed.	34	productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
35	Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
36	Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
37		35
38	// Verify that user added to power users group is removed on uninstall.	36	// Verify Users marked as RemoveOnUninstall were removed.
39	UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");	37	Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
		38	Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
40		39
41	// clean up	40	// Verify that user added to power users group is removed on uninstall.
42	UserVerifier.DeleteLocalUser("testName1");	41	UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
43	UserVerifier.DeleteLocalUser("testName2");	42	}
44	UserVerifier.DeleteLocalUser("testName3");	43	finally
		44	{
		45	// clean up
		46	UserVerifier.DeleteLocalUser("testName1");
		47	UserVerifier.DeleteLocalUser("testName2");
		48	UserVerifier.DeleteLocalUser("testName3");
		49	}
45	}	50	}
46		51
47	// Verify the rollback action reverts all Users changes.	52	// Verify the rollback action reverts all Users changes.
48	[RuntimeFact]	53	[RuntimeFact]
49	public void CanRollbackUsers()	54	public void CanRollbackUsers()
50	{	55	{
51	UserVerifier.CreateLocalUser("testName3", "test123!@#", "User3 comment");	56	try
52	UserVerifier.AddUserToGroup("testName3", "Backup Operators");	57	{
53	var productFail = this.CreatePackageInstaller("ProductFail");	58	UserVerifier.CreateLocalUser("testName3", "test123!@#", "User3 comment");
54		59	UserVerifier.AddUserToGroup("testName3", "Backup Operators");
55	// make sure the user accounts are deleted before we start	60	var productFail = this.CreatePackageInstaller("ProductFail");
56	UserVerifier.DeleteLocalUser("testName1");	61
57	UserVerifier.DeleteLocalUser("testName2");	62	// make sure the user accounts are deleted before we start
58		63	UserVerifier.DeleteLocalUser("testName1");
59	productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);	64	UserVerifier.DeleteLocalUser("testName2");
60		65
61	// Verify added Users were removed on rollback.	66	productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
62	Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Rollback", "testName1"));	67
63	Assert.False(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was not removed on Rollback", "testName2"));	68	// Verify added Users were removed on rollback.
64		69	Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Rollback", "testName1"));
65	// Verify that user added to power users group is removed from power users group on rollback.	70	Assert.False(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was not removed on Rollback", "testName2"));
66	UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");	71
67	// but is not removed from Backup Operators	72	// Verify that user added to power users group is removed from power users group on rollback.
68	UserVerifier.VerifyUserIsMemberOf(string.Empty, "testName3", "Backup Operators");	73	UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
69	// and has their original comment set back	74	// but is not removed from Backup Operators
70	UserVerifier.VerifyUserComment(string.Empty, "testName3", "User3 comment");	75	UserVerifier.VerifyUserIsMemberOf(string.Empty, "testName3", "Backup Operators");
71		76	// and has their original comment set back
72	// clean up	77	UserVerifier.VerifyUserComment(string.Empty, "testName3", "User3 comment");
73	UserVerifier.DeleteLocalUser("testName1");	78	}
74	UserVerifier.DeleteLocalUser("testName2");	79	finally
75	UserVerifier.DeleteLocalUser("testName3");	80	{
		81	// clean up
		82	UserVerifier.DeleteLocalUser("testName1");
		83	UserVerifier.DeleteLocalUser("testName2");
		84	UserVerifier.DeleteLocalUser("testName3");
		85	}
76	}	86	}
77		87
78
79	// Verify that command-line parameters are not blocked by repair switches.	88	// Verify that command-line parameters are not blocked by repair switches.
80	// Original code signalled repair mode by using "-f ", which silently	89	// Original code signalled repair mode by using "-f ", which silently
81	// terminated the command-line parsing, ignoring any parameters that followed.	90	// terminated the command-line parsing, ignoring any parameters that followed.
82	[RuntimeFact()]	91	[RuntimeFact()]
83	public void CanRepairUsersWithCommandLineParameters()	92	public void CanRepairUsersWithCommandLineParameters()
84	{	93	{
85	var arguments = new string[]	94	try
86	{	95	{
87	"TESTPARAMETER1=testName1",	96	var arguments = new string[]
88	};	97	{
89	var productWithCommandLineParameters = this.CreatePackageInstaller("ProductWithCommandLineParameters");	98	"TESTPARAMETER1=testName1",
90		99	};
91	// Make sure that the user doesn't exist when we start the test.	100	var productWithCommandLineParameters = this.CreatePackageInstaller("ProductWithCommandLineParameters");
92	UserVerifier.DeleteLocalUser("testName1");
93		101
94	// Install	102	// Make sure that the user doesn't exist when we start the test.
95	productWithCommandLineParameters.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);	103	UserVerifier.DeleteLocalUser("testName1");
96		104
97	// Repair	105	// Install
98	productWithCommandLineParameters.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);	106	productWithCommandLineParameters.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
99		107
100	// Clean up	108	// Repair
101	UserVerifier.DeleteLocalUser("testName1");	109	productWithCommandLineParameters.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
		110	}
		111	finally
		112	{
		113	// Clean up
		114	UserVerifier.DeleteLocalUser("testName1");
		115	}
102	}	116	}
103		117
104
105	// Verify that the users specified in the authoring are created as expected on repair.	118	// Verify that the users specified in the authoring are created as expected on repair.
106	[RuntimeFact()]	119	[RuntimeFact()]
107	public void CanRepairUsers()	120	public void CanRepairUsers()
108	{	121	{
109	UserVerifier.CreateLocalUser("testName3", "test123!@#");	122	try
110	var productA = this.CreatePackageInstaller("ProductA");	123	{
111		124	UserVerifier.CreateLocalUser("testName3", "test123!@#");
112	productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);	125	var productA = this.CreatePackageInstaller("ProductA");
113		126
114	// Validate New User Information.	127	productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
115	UserVerifier.DeleteLocalUser("testName1");
116	UserVerifier.SetUserInformation(String.Empty, "testName2", true, false, false);
117		128
118	productA.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS);	129	// Validate New User Information.
		130	UserVerifier.DeleteLocalUser("testName1");
		131	UserVerifier.SetUserInformation(String.Empty, "testName2", true, false, false);
119		132
120	// Validate New User Information.	133	productA.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS);
121	UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
122	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
123		134
124	UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);	135	// Validate New User Information.
125	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");	136	UserVerifier.VerifyUserInformation(String.Empty, "testName1", true, false, false);
		137	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName1", "Administrators", "Power Users");
126		138
127	UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");	139	UserVerifier.VerifyUserInformation(String.Empty, "testName2", true, true, true);
		140	UserVerifier.VerifyUserIsMemberOf(String.Empty, "testName2", "Power Users");
128		141
129	productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);	142	UserVerifier.VerifyUserIsMemberOf("", "testName3", "Power Users");
130		143
131	// Verify Users marked as RemoveOnUninstall were removed.	144	productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
132	Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
133	Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
134		145
135	// Verify that user added to power users group is removed on uninstall.	146	// Verify Users marked as RemoveOnUninstall were removed.
136	UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");	147	Assert.False(UserVerifier.UserExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
		148	Assert.True(UserVerifier.UserExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
137		149
138	// clean up	150	// Verify that user added to power users group is removed on uninstall.
139	UserVerifier.DeleteLocalUser("testName1");	151	UserVerifier.VerifyUserIsNotMemberOf("", "testName3", "Power Users");
140	UserVerifier.DeleteLocalUser("testName2");	152	}
141	UserVerifier.DeleteLocalUser("testName3");	153	finally
		154	{
		155	// clean up
		156	UserVerifier.DeleteLocalUser("testName1");
		157	UserVerifier.DeleteLocalUser("testName2");
		158	UserVerifier.DeleteLocalUser("testName3");
		159	}
142	}	160	}
143		161
144	// Verify that Installation fails if FailIfExists is set.	162	// Verify that Installation fails if FailIfExists is set.
@@ -191,93 +209,123 @@ namespace WixToolsetTest.MsiE2E
191	[RuntimeFact]	209	[RuntimeFact]
192	public void CanCreateNewUserWithComment()	210	public void CanCreateNewUserWithComment()
193	{	211	{
194	var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");	212	try
195		213	{
196	productNewUserWithComment.InstallProduct();	214	var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
197	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
198		215
199	// clean up	216	productNewUserWithComment.InstallProduct();
200	UserVerifier.DeleteLocalUser("testName1");	217	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
		218	}
		219	finally
		220	{
		221	// clean up
		222	UserVerifier.DeleteLocalUser("testName1");
		223	}
201	}	224	}
202		225
203	// Verify that a comment can be added to an existing user	226	// Verify that a comment can be added to an existing user
204	[RuntimeFact]	227	[RuntimeFact]
205	public void CanAddCommentToExistingUser()	228	public void CanAddCommentToExistingUser()
206	{	229	{
207	UserVerifier.CreateLocalUser("testName1", "test123!@#");	230	try
208	var productAddCommentToExistingUser = this.CreatePackageInstaller("ProductAddCommentToExistingUser");	231	{
209		232	UserVerifier.CreateLocalUser("testName1", "test123!@#");
210	productAddCommentToExistingUser.InstallProduct();	233	var productAddCommentToExistingUser = this.CreatePackageInstaller("ProductAddCommentToExistingUser");
211		234
212	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");	235	productAddCommentToExistingUser.InstallProduct();
213		236
214	// clean up	237	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
215	UserVerifier.DeleteLocalUser("testName1");	238	}
		239	finally
		240	{
		241	// clean up
		242	UserVerifier.DeleteLocalUser("testName1");
		243	}
216	}	244	}
217		245
218	// Verify that a comment can be repaired for a new user	246	// Verify that a comment can be repaired for a new user
219	[RuntimeFact]	247	[RuntimeFact]
220	public void CanRepairCommentOfNewUser()	248	public void CanRepairCommentOfNewUser()
221	{	249	{
222	var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");	250	try
223		251	{
224	productNewUserWithComment.InstallProduct();	252	var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
225	UserVerifier.SetUserComment(String.Empty, "testName1", "");
226		253
227	productNewUserWithComment.RepairProduct();	254	productNewUserWithComment.InstallProduct();
228	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");	255	UserVerifier.SetUserComment(String.Empty, "testName1", "");
229		256
230	// clean up	257	productNewUserWithComment.RepairProduct();
231	UserVerifier.DeleteLocalUser("testName1");	258	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
		259	}
		260	finally
		261	{
		262	// clean up
		263	UserVerifier.DeleteLocalUser("testName1");
		264	}
232	}	265	}
233		266
234	// Verify that a comment can be changed for an existing user	267	// Verify that a comment can be changed for an existing user
235	[RuntimeFact]	268	[RuntimeFact]
236	public void CanChangeCommentOfExistingUser()	269	public void CanChangeCommentOfExistingUser()
237	{	270	{
238	UserVerifier.CreateLocalUser("testName1", "test123!@#");	271	try
239	UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");	272	{
240	var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");	273	UserVerifier.CreateLocalUser("testName1", "test123!@#");
241		274	UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");
242	productNewUserWithComment.InstallProduct();	275	var productNewUserWithComment = this.CreatePackageInstaller("ProductNewUserWithComment");
243	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
244		276
245	// clean up	277	productNewUserWithComment.InstallProduct();
246	UserVerifier.DeleteLocalUser("testName1");	278	UserVerifier.VerifyUserComment(String.Empty, "testName1", "testComment1");
		279	}
		280	finally
		281	{
		282	// clean up
		283	UserVerifier.DeleteLocalUser("testName1");
		284	}
247	}	285	}
248		286
249	// Verify that a comment can be rolled back for an existing user	287	// Verify that a comment can be rolled back for an existing user
250	[RuntimeFact]	288	[RuntimeFact]
251	public void CanRollbackCommentOfExistingUser()	289	public void CanRollbackCommentOfExistingUser()
252	{	290	{
253	UserVerifier.CreateLocalUser("testName1", "test123!@#");	291	try
254	UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");	292	{
255	var productCommentFail = this.CreatePackageInstaller("ProductCommentFail");	293	UserVerifier.CreateLocalUser("testName1", "test123!@#");
256		294	UserVerifier.SetUserComment(String.Empty, "testName1", "initialTestComment1");
257	productCommentFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);	295	var productCommentFail = this.CreatePackageInstaller("ProductCommentFail");
258		296
259	// Verify that comment change was rolled back.	297	productCommentFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
260	UserVerifier.VerifyUserComment(String.Empty, "testName1", "initialTestComment1");
261		298
262	// clean up	299	// Verify that comment change was rolled back.
263	UserVerifier.DeleteLocalUser("testName1");	300	UserVerifier.VerifyUserComment(String.Empty, "testName1", "initialTestComment1");
		301	}
		302	finally
		303	{
		304	// clean up
		305	UserVerifier.DeleteLocalUser("testName1");
		306	}
264	}	307	}
265		308
266	// Verify that a comment can be deleted for an existing user	309	// Verify that a comment can be deleted for an existing user
267	[RuntimeFact]	310	[RuntimeFact]
268	public void CanDeleteCommentOfExistingUser()	311	public void CanDeleteCommentOfExistingUser()
269	{	312	{
270	UserVerifier.CreateLocalUser("testName1", "test123!@#");	313	try
271	UserVerifier.SetUserComment(String.Empty, "testName1", "testComment1");	314	{
272	var productCommentDelete = this.CreatePackageInstaller("ProductCommentDelete");	315	UserVerifier.CreateLocalUser("testName1", "test123!@#");
273		316	UserVerifier.SetUserComment(String.Empty, "testName1", "testComment1");
274	productCommentDelete.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);	317	var productCommentDelete = this.CreatePackageInstaller("ProductCommentDelete");
275		318
276	// Verify that comment was removed.	319	productCommentDelete.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
277	UserVerifier.VerifyUserComment(String.Empty, "testName1", "");
278		320
279	// clean up	321	// Verify that comment was removed.
280	UserVerifier.DeleteLocalUser("testName1");	322	UserVerifier.VerifyUserComment(String.Empty, "testName1", "");
		323	}
		324	finally
		325	{
		326	// clean up
		327	UserVerifier.DeleteLocalUser("testName1");
		328	}
281	}	329	}
282	}	330	}
283	}	331	}