diff options
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 | |
parent | bc433149fa086422a7d0fc2713aa9758b1d65883 (diff) | |
download | wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.tar.gz wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.tar.bz2 wix-bbe23165a86e71661b725bc2155a79685f7a7ea7.zip |
Ensure user and group integration tests always clean up after themselves.
Fixes 8940
-rw-r--r-- | src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionGroupTests.cs | 350 | ||||
-rw-r--r-- | src/test/msi/WixToolsetTest.MsiE2E/UtilExtensionUserTests.cs | 310 |
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 | } |