aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionGroupTests.cs350
-rw-r--r--src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs310
2 files changed, 383 insertions, 277 deletions
diff --git a/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionGroupTests.cs b/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionGroupTests.cs
index e379047d..abed83c6 100644
--- a/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionGroupTests.cs
+++ b/src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionGroupTests.cs
@@ -16,110 +16,128 @@ namespace WixToolsetTest.MsiE2E
16 [RuntimeFact] 16 [RuntimeFact]
17 public void CanInstallAndUninstallNonDomainGroups() 17 public void CanInstallAndUninstallNonDomainGroups()
18 { 18 {
19 UserGroupVerifier.CreateLocalGroup("testName3"); 19 try
20 var productA = this.CreatePackageInstaller("ProductA"); 20 {
21 21 UserGroupVerifier.CreateLocalGroup("testName3");
22 productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 22 var productA = this.CreatePackageInstaller("ProductA");
23 23
24 // Validate New User Information. 24 productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
25 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not created on Install", "testName1"));
26 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was not created on Install", "testName2"));
27 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName3"), String.Format("Group '{0}' was not created on Install", "testName3"));
28 25
29 productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 26 // Validate New User Information.
27 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not created on Install", "testName1"));
28 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was not created on Install", "testName2"));
29 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName3"), String.Format("Group '{0}' was not created on Install", "testName3"));
30 30
31 // Verify Users marked as RemoveOnUninstall were removed. 31 productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
32 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not removed on Uninstall", "testName1"));
33 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was removed on Uninstall", "testName2"));
34 32
35 // clean up 33 // Verify Users marked as RemoveOnUninstall were removed.
36 UserGroupVerifier.DeleteLocalGroup("testName1"); 34 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not removed on Uninstall", "testName1"));
37 UserGroupVerifier.DeleteLocalGroup("testName2"); 35 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was removed on Uninstall", "testName2"));
38 UserGroupVerifier.DeleteLocalGroup("testName3"); 36 }
37 finally
38 {
39 // clean up
40 UserGroupVerifier.DeleteLocalGroup("testName1");
41 UserGroupVerifier.DeleteLocalGroup("testName2");
42 UserGroupVerifier.DeleteLocalGroup("testName3");
43 }
39 } 44 }
40 45
41 // Verify the rollback action reverts all Users changes. 46 // Verify the rollback action reverts all Users changes.
42 [RuntimeFact] 47 [RuntimeFact]
43 public void CanRollbackNonDomainGroups() 48 public void CanRollbackNonDomainGroups()
44 { 49 {
45 UserGroupVerifier.CreateLocalGroup("testName3"); 50 try
46 var productFail = this.CreatePackageInstaller("ProductFail"); 51 {
47 52 UserGroupVerifier.CreateLocalGroup("testName3");
48 // make sure the user accounts are deleted before we start 53 var productFail = this.CreatePackageInstaller("ProductFail");
49 UserGroupVerifier.DeleteLocalGroup("testName1");
50 UserGroupVerifier.DeleteLocalGroup("testName2");
51 54
52 productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE); 55 // make sure the user accounts are deleted before we start
56 UserGroupVerifier.DeleteLocalGroup("testName1");
57 UserGroupVerifier.DeleteLocalGroup("testName2");
53 58
54 // Verify added Users were removed on rollback. 59 productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
55 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not removed on Rollback", "testName1"));
56 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was not removed on Rollback", "testName2"));
57 60
58 // clean up 61 // Verify added Users were removed on rollback.
59 UserGroupVerifier.DeleteLocalGroup("testName1"); 62 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not removed on Rollback", "testName1"));
60 UserGroupVerifier.DeleteLocalGroup("testName2"); 63 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was not removed on Rollback", "testName2"));
61 UserGroupVerifier.DeleteLocalGroup("testName3"); 64 }
65 finally
66 {
67 // clean up
68 UserGroupVerifier.DeleteLocalGroup("testName1");
69 UserGroupVerifier.DeleteLocalGroup("testName2");
70 UserGroupVerifier.DeleteLocalGroup("testName3");
71 }
62 } 72 }
63 73
64
65 // Verify that command-line parameters aer not blocked by repair switches. 74 // Verify that command-line parameters aer not blocked by repair switches.
66 // Original code signalled repair mode by using "-f ", which silently 75 // Original code signalled repair mode by using "-f ", which silently
67 // terminated the command-line parsing, ignoring any parameters that followed. 76 // terminated the command-line parsing, ignoring any parameters that followed.
68 [RuntimeFact()] 77 [RuntimeFact()]
69 public void CanRepairNonDomainGroupsWithCommandLineParameters() 78 public void CanRepairNonDomainGroupsWithCommandLineParameters()
70 { 79 {
71 var arguments = new string[] 80 try
72 { 81 {
73 "TESTPARAMETER1=testName1", 82 var arguments = new string[]
74 }; 83 {
75 var productWithCommandLineParameters = this.CreatePackageInstaller("ProductWithCommandLineParameters"); 84 "TESTPARAMETER1=testName1",
85 };
86 var productWithCommandLineParameters = this.CreatePackageInstaller("ProductWithCommandLineParameters");
76 87
77 // Make sure that the user doesn't exist when we start the test. 88 // Make sure that the user doesn't exist when we start the test.
78 UserGroupVerifier.DeleteLocalGroup("testName1"); 89 UserGroupVerifier.DeleteLocalGroup("testName1");
79 90
80 // Install 91 // Install
81 productWithCommandLineParameters.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments); 92 productWithCommandLineParameters.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
82 93
83 // Repair 94 // Repair
84 productWithCommandLineParameters.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments); 95 productWithCommandLineParameters.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
85 96
86 97
87 // Install 98 // Install
88 productWithCommandLineParameters.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments); 99 productWithCommandLineParameters.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, arguments);
89 100 }
90 // Clean up 101 finally
91 UserGroupVerifier.DeleteLocalGroup("testName1"); 102 {
103 // Clean up
104 UserGroupVerifier.DeleteLocalGroup("testName1");
105 }
92 } 106 }
93 107
94
95 // Verify that the groups specified in the authoring are created as expected on repair. 108 // Verify that the groups specified in the authoring are created as expected on repair.
96 [RuntimeFact()] 109 [RuntimeFact()]
97 public void CanRepairNonDomainGroups() 110 public void CanRepairNonDomainGroups()
98 { 111 {
99 UserGroupVerifier.CreateLocalGroup("testName3"); 112 try
100 var productA = this.CreatePackageInstaller("ProductA"); 113 {
101 114 UserGroupVerifier.CreateLocalGroup("testName3");
102 productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 115 var productA = this.CreatePackageInstaller("ProductA");
103 116
104 // Validate New User Information. 117 productA.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
105 UserGroupVerifier.DeleteLocalGroup("testName1");
106 118
107 productA.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS); 119 // Validate New User Information.
120 UserGroupVerifier.DeleteLocalGroup("testName1");
108 121
109 // Validate New User Information. 122 productA.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS);
110 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("User '{0}' was not installed on Repair", "testName1"));
111 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("User '{0}' was not installed after Repair", "testName2"));
112 123
113 productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 124 // Validate New User Information.
125 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("User '{0}' was not installed on Repair", "testName1"));
126 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("User '{0}' was not installed after Repair", "testName2"));
114 127
115 // Verify Users marked as RemoveOnUninstall were removed. 128 productA.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
116 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
117 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
118 129
119 // clean up 130 // Verify Users marked as RemoveOnUninstall were removed.
120 UserGroupVerifier.DeleteLocalGroup("testName1"); 131 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("User '{0}' was not removed on Uninstall", "testName1"));
121 UserGroupVerifier.DeleteLocalGroup("testName2"); 132 Assert.True(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("User '{0}' was removed on Uninstall", "testName2"));
122 UserGroupVerifier.DeleteLocalGroup("testName3"); 133 }
134 finally
135 {
136 // clean up
137 UserGroupVerifier.DeleteLocalGroup("testName1");
138 UserGroupVerifier.DeleteLocalGroup("testName2");
139 UserGroupVerifier.DeleteLocalGroup("testName3");
140 }
123 } 141 }
124 142
125 // Verify that Installation fails if FailIfExists is set. 143 // Verify that Installation fails if FailIfExists is set.
@@ -165,101 +183,131 @@ namespace WixToolsetTest.MsiE2E
165 [RuntimeFact] 183 [RuntimeFact]
166 public void CanCreateNewNonDomainGroupWithComment() 184 public void CanCreateNewNonDomainGroupWithComment()
167 { 185 {
168 var productNewUserWithComment = this.CreatePackageInstaller("ProductNewGroupWithComment"); 186 try
169 187 {
170 productNewUserWithComment.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 188 var productNewUserWithComment = this.CreatePackageInstaller("ProductNewGroupWithComment");
171 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1");
172 productNewUserWithComment.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
173 189
174 // clean up 190 productNewUserWithComment.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
175 UserGroupVerifier.DeleteLocalGroup("testName1"); 191 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1");
192 productNewUserWithComment.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
193 }
194 finally
195 {
196 // clean up
197 UserGroupVerifier.DeleteLocalGroup("testName1");
198 }
176 } 199 }
177 200
178 // Verify that a comment can be added to an existing group 201 // Verify that a comment can be added to an existing group
179 [RuntimeFact] 202 [RuntimeFact]
180 public void CanAddCommentToExistingNonDomainGroup() 203 public void CanAddCommentToExistingNonDomainGroup()
181 { 204 {
182 UserGroupVerifier.CreateLocalGroup("testName1"); 205 try
183 var productAddCommentToExistingUser = this.CreatePackageInstaller("ProductAddCommentToExistingGroup"); 206 {
184 207 UserGroupVerifier.CreateLocalGroup("testName1");
185 productAddCommentToExistingUser.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 208 var productAddCommentToExistingUser = this.CreatePackageInstaller("ProductAddCommentToExistingGroup");
186 209
187 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1"); 210 productAddCommentToExistingUser.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
188 211
189 productAddCommentToExistingUser.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 212 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1");
190 213
191 // clean up 214 productAddCommentToExistingUser.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
192 UserGroupVerifier.DeleteLocalGroup("testName1"); 215 }
216 finally
217 {
218 // clean up
219 UserGroupVerifier.DeleteLocalGroup("testName1");
220 }
193 } 221 }
194 222
195 // Verify that a comment can be repaired for a new group 223 // Verify that a comment can be repaired for a new group
196 [RuntimeFact] 224 [RuntimeFact]
197 public void CanRepairCommentOfNewNonDomainGroup() 225 public void CanRepairCommentOfNewNonDomainGroup()
198 { 226 {
199 var productNewUserWithComment = this.CreatePackageInstaller("ProductNewGroupWithComment"); 227 try
200 228 {
201 productNewUserWithComment.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 229 var productNewUserWithComment = this.CreatePackageInstaller("ProductNewGroupWithComment");
202 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "");
203 230
204 productNewUserWithComment.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS); 231 productNewUserWithComment.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
205 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1"); 232 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "");
206 productNewUserWithComment.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
207 233
208 // clean up 234 productNewUserWithComment.RepairProduct(MSIExec.MSIExecReturnCode.SUCCESS);
209 UserGroupVerifier.DeleteLocalGroup("testName1"); 235 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1");
236 productNewUserWithComment.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
237 }
238 finally
239 {
240 // clean up
241 UserGroupVerifier.DeleteLocalGroup("testName1");
242 }
210 } 243 }
211 244
212 // Verify that a comment can be changed for an existing group 245 // Verify that a comment can be changed for an existing group
213 [RuntimeFact] 246 [RuntimeFact]
214 public void CanChangeCommentOfExistingNonDomainGroup() 247 public void CanChangeCommentOfExistingNonDomainGroup()
215 { 248 {
216 UserGroupVerifier.CreateLocalGroup("testName1"); 249 try
217 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "initialTestComment1"); 250 {
218 var productNewUserWithComment = this.CreatePackageInstaller("ProductNewGroupWithComment"); 251 UserGroupVerifier.CreateLocalGroup("testName1");
219 252 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "initialTestComment1");
220 productNewUserWithComment.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 253 var productNewUserWithComment = this.CreatePackageInstaller("ProductNewGroupWithComment");
221 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1");
222 productNewUserWithComment.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
223 254
224 // clean up 255 productNewUserWithComment.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
225 UserGroupVerifier.DeleteLocalGroup("testName1"); 256 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "testComment1");
257 productNewUserWithComment.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
258 }
259 finally
260 {
261 // clean up
262 UserGroupVerifier.DeleteLocalGroup("testName1");
263 }
226 } 264 }
227 265
228 // Verify that a comment can be rolled back for an existing group 266 // Verify that a comment can be rolled back for an existing group
229 [RuntimeFact] 267 [RuntimeFact]
230 public void CanRollbackCommentOfExistingNonDomainGroup() 268 public void CanRollbackCommentOfExistingNonDomainGroup()
231 { 269 {
232 UserGroupVerifier.CreateLocalGroup("testName1"); 270 try
233 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "initialTestComment1"); 271 {
234 var productCommentFail = this.CreatePackageInstaller("ProductCommentFail"); 272 UserGroupVerifier.CreateLocalGroup("testName1");
235 273 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "initialTestComment1");
236 productCommentFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE); 274 var productCommentFail = this.CreatePackageInstaller("ProductCommentFail");
237 275
238 // Verify that comment change was rolled back. 276 productCommentFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
239 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "initialTestComment1");
240 277
241 // clean up 278 // Verify that comment change was rolled back.
242 UserGroupVerifier.DeleteLocalGroup("testName1"); 279 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "initialTestComment1");
280 }
281 finally
282 {
283 // clean up
284 UserGroupVerifier.DeleteLocalGroup("testName1");
285 }
243 } 286 }
244 287
245 // Verify that a comment can be deleted for an existing group 288 // Verify that a comment can be deleted for an existing group
246 [RuntimeFact] 289 [RuntimeFact]
247 public void CanDeleteCommentOfExistingNonDomainGroup() 290 public void CanDeleteCommentOfExistingNonDomainGroup()
248 { 291 {
249 UserGroupVerifier.CreateLocalGroup("testName1"); 292 try
250 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "testComment1"); 293 {
251 var productCommentDelete = this.CreatePackageInstaller("ProductCommentDelete"); 294 UserGroupVerifier.CreateLocalGroup("testName1");
252 295 UserGroupVerifier.SetGroupComment(String.Empty, "testName1", "testComment1");
253 productCommentDelete.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS); 296 var productCommentDelete = this.CreatePackageInstaller("ProductCommentDelete");
254 297
255 // Verify that comment was removed. 298 productCommentDelete.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
256 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "");
257 299
300 // Verify that comment was removed.
301 UserGroupVerifier.VerifyGroupComment(String.Empty, "testName1", "");
258 302
259 productCommentDelete.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
260 303
261 // clean up 304 productCommentDelete.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS);
262 UserGroupVerifier.DeleteLocalGroup("testName1"); 305 }
306 finally
307 {
308 // clean up
309 UserGroupVerifier.DeleteLocalGroup("testName1");
310 }
263 } 311 }
264 312
265 #endregion 313 #endregion
@@ -269,48 +317,58 @@ namespace WixToolsetTest.MsiE2E
269 [RuntimeFact(DomainRequired = true)] 317 [RuntimeFact(DomainRequired = true)]
270 public void CanNestDomainGroups() 318 public void CanNestDomainGroups()
271 { 319 {
272 var testDomain = System.Environment.UserDomainName; 320 try
273 var productNestedGroups = this.CreatePackageInstaller("ProductNestedGroups"); 321 {
274 322 var testDomain = System.Environment.UserDomainName;
275 productNestedGroups.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, $"TESTDOMAIN={testDomain}"); 323 var productNestedGroups = this.CreatePackageInstaller("ProductNestedGroups");
276 324
277 // Verify group nested membership 325 productNestedGroups.InstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, $"TESTDOMAIN={testDomain}");
278 UserGroupVerifier.VerifyIsMemberOf(testDomain, "Domain Users", new string[] { "testName1", "testName2" });
279 //UserGroupVerifier.VerifyIsMemberOf(String.Empty, "Everyone", new string[] { "testName1" });
280 326
281 UserGroupVerifier.VerifyIsNotMemberOf(testDomain, "Domain Users", new string[] { "testName3" }); 327 // Verify group nested membership
282 //UserGroupVerifier.VerifyIsNotMemberOf(String.Empty, "Everyone", new string[] { "testName2", "testName3" }); 328 UserGroupVerifier.VerifyIsMemberOf(testDomain, "Domain Users", new string[] { "testName1", "testName2" });
329 //UserGroupVerifier.VerifyIsMemberOf(String.Empty, "Everyone", new string[] { "testName1" });
283 330
284 productNestedGroups.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, $"TESTDOMAIN={testDomain}"); 331 UserGroupVerifier.VerifyIsNotMemberOf(testDomain, "Domain Users", new string[] { "testName3" });
332 //UserGroupVerifier.VerifyIsNotMemberOf(String.Empty, "Everyone", new string[] { "testName2", "testName3" });
285 333
286 // clean up 334 productNestedGroups.UninstallProduct(MSIExec.MSIExecReturnCode.SUCCESS, $"TESTDOMAIN={testDomain}");
287 UserGroupVerifier.DeleteLocalGroup("testName1"); 335 }
288 UserGroupVerifier.DeleteLocalGroup("testName2"); 336 finally
289 UserGroupVerifier.DeleteLocalGroup("testName3"); 337 {
338 // clean up
339 UserGroupVerifier.DeleteLocalGroup("testName1");
340 UserGroupVerifier.DeleteLocalGroup("testName2");
341 UserGroupVerifier.DeleteLocalGroup("testName3");
342 }
290 } 343 }
291 344
292 // Verify the rollback action reverts all Users changes. 345 // Verify the rollback action reverts all Users changes.
293 [RuntimeFact(DomainRequired = true)] 346 [RuntimeFact(DomainRequired = true)]
294 public void CanRollbackDomainGroups() 347 public void CanRollbackDomainGroups()
295 { 348 {
296 var testDomain = System.Environment.UserDomainName; 349 try
297 UserGroupVerifier.CreateLocalGroup("testName3"); 350 {
298 var productFail = this.CreatePackageInstaller("ProductFail"); 351 var testDomain = System.Environment.UserDomainName;
299 352 UserGroupVerifier.CreateLocalGroup("testName3");
300 // make sure the user accounts are deleted before we start 353 var productFail = this.CreatePackageInstaller("ProductFail");
301 UserGroupVerifier.DeleteLocalGroup("testName1");
302 UserGroupVerifier.DeleteLocalGroup("testName2");
303 354
304 productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE, $"TESTDOMAIN={testDomain}"); 355 // make sure the user accounts are deleted before we start
356 UserGroupVerifier.DeleteLocalGroup("testName1");
357 UserGroupVerifier.DeleteLocalGroup("testName2");
305 358
306 // Verify added Users were removed on rollback. 359 productFail.InstallProduct(MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE, $"TESTDOMAIN={testDomain}");
307 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not removed on Rollback", "testName1"));
308 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was not removed on Rollback", "testName2"));
309 360
310 // clean up 361 // Verify added Users were removed on rollback.
311 UserGroupVerifier.DeleteLocalGroup("testName1"); 362 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName1"), String.Format("Group '{0}' was not removed on Rollback", "testName1"));
312 UserGroupVerifier.DeleteLocalGroup("testName2"); 363 Assert.False(UserGroupVerifier.GroupExists(String.Empty, "testName2"), String.Format("Group '{0}' was not removed on Rollback", "testName2"));
313 UserGroupVerifier.DeleteLocalGroup("testName3"); 364 }
365 finally
366 {
367 // clean up
368 UserGroupVerifier.DeleteLocalGroup("testName1");
369 UserGroupVerifier.DeleteLocalGroup("testName2");
370 UserGroupVerifier.DeleteLocalGroup("testName3");
371 }
314 } 372 }
315 373
316 #endregion 374 #endregion
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}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-12-04 06:59:37 +0000