ConfigurationProcessorGroupTests.cs (34558B)
1 // ----------------------------------------------------------------------------- 2 // <copyright file="ConfigurationProcessorGroupTests.cs" company="Microsoft Corporation"> 3 // Copyright (c) Microsoft Corporation. Licensed under the MIT License. 4 // </copyright> 5 // ----------------------------------------------------------------------------- 6 7 namespace Microsoft.Management.Configuration.UnitTests.Tests 8 { 9 using System; 10 using System.Collections.Generic; 11 using System.Linq; 12 using System.Threading; 13 using Microsoft.Management.Configuration.UnitTests.Fixtures; 14 using Microsoft.Management.Configuration.UnitTests.Helpers; 15 using Xunit; 16 using Xunit.Abstractions; 17 18 /// <summary> 19 /// Unit tests for running group processing. 20 /// </summary> 21 [Collection("UnitTestCollection")] 22 [InProc] 23 public class ConfigurationProcessorGroupTests : ConfigurationProcessorTestBase 24 { 25 /// <summary> 26 /// Initializes a new instance of the <see cref="ConfigurationProcessorGroupTests"/> class. 27 /// </summary> 28 /// <param name="fixture">Unit test fixture.</param> 29 /// <param name="log">Log helper.</param> 30 public ConfigurationProcessorGroupTests(UnitTestFixture fixture, ITestOutputHelper log) 31 : base(fixture, log) 32 { 33 } 34 35 /// <summary> 36 /// Test a set that was parsed with schema 0.3. 37 /// </summary> 38 [Fact] 39 public void TestSet_Parsed_0_3() 40 { 41 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 42 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 43 44 OpenConfigurationSetResult openResult = processor.OpenConfigurationSet(this.CreateStream(@" 45 $schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/08/config/document.json 46 resources: 47 - name: Name 48 type: Module/Resource 49 properties: 50 c: 3 51 d: '4' 52 - name: Name2 53 type: Module/Resource2 54 properties: 55 l: '10' 56 ")); 57 58 Assert.Null(openResult.ResultCode); 59 Assert.NotNull(openResult.Set); 60 Assert.Equal(string.Empty, openResult.Field); 61 Assert.Equal(string.Empty, openResult.Value); 62 Assert.Equal(0U, openResult.Line); 63 Assert.Equal(0U, openResult.Column); 64 65 ConfigurationSet configurationSet = openResult.Set; 66 int unitCount = configurationSet.Units.Count; 67 68 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 69 70 TestConfigurationUnitProcessor[] unitProcessors = new TestConfigurationUnitProcessor[unitCount]; 71 for (int i = 0; i < unitCount; ++i) 72 { 73 unitProcessors[i] = setProcessor.CreateTestProcessor(configurationSet.Units[i]); 74 if (i == 0) 75 { 76 unitProcessors[i].TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => new TestSettingsResultInstance(unit) { TestResult = ConfigurationTestResult.Negative }; 77 } 78 else 79 { 80 unitProcessors[i].TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => new TestSettingsResultInstance(unit) { TestResult = ConfigurationTestResult.Positive }; 81 } 82 } 83 84 TestConfigurationSetResult result = processor.TestSet(configurationSet); 85 Assert.NotNull(result); 86 Assert.Equal(ConfigurationTestResult.Negative, result.TestResult); 87 Assert.Equal(unitCount, result.UnitResults.Count); 88 89 for (int i = 0; i < unitCount; ++i) 90 { 91 var unitResult = result.UnitResults[i]; 92 Assert.NotNull(unitResult); 93 94 if (i == 0) 95 { 96 Assert.Equal(ConfigurationTestResult.Negative, unitResult.TestResult); 97 } 98 else 99 { 100 Assert.Equal(ConfigurationTestResult.Positive, unitResult.TestResult); 101 } 102 103 Assert.NotNull(unitResult.ResultInformation); 104 Assert.Null(unitResult.ResultInformation.ResultCode); 105 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 106 } 107 108 this.VerifySummaryEvent(configurationSet, result, 0, ConfigurationUnitResultSource.None); 109 } 110 111 /// <summary> 112 /// Test when the set processor is a group processor. 113 /// </summary> 114 [Fact] 115 public void TestSet_SetGroupProcessor() 116 { 117 ConfigurationSet configurationSet = this.ConfigurationSet(); 118 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 119 ConfigurationUnit configurationUnitNegative = this.ConfigurationUnit(); 120 configurationUnitNegative.Settings[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 121 ConfigurationUnit configurationUnitPositive = this.ConfigurationUnit(); 122 configurationUnitPositive.Settings[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Positive.ToString(); 123 configurationSet.Units = new ConfigurationUnit[] { configurationUnitNegative, configurationUnitPositive }; 124 125 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 126 TestConfigurationSetGroupProcessor setProcessor = factory.CreateTestGroupProcessor(configurationSet); 127 setProcessor.ShouldWaitOnAsyncEvent = true; 128 129 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 130 List<TestConfigurationUnitResult> progressValues = new List<TestConfigurationUnitResult>(); 131 132 var operation = processor.TestSetAsync(configurationSet); 133 operation.Progress = (Windows.Foundation.IAsyncOperationWithProgress<TestConfigurationSetResult, TestConfigurationUnitResult> op, TestConfigurationUnitResult unitResult) => { progressValues.Add(unitResult); }; 134 setProcessor.SignalAsyncEvent(); 135 136 operation.AsTask().Wait(); 137 TestConfigurationSetResult result = operation.GetResults(); 138 139 Assert.NotNull(result); 140 Assert.Equal(ConfigurationTestResult.Negative, result.TestResult); 141 Assert.NotNull(result.UnitResults); 142 Assert.Equal(2, result.UnitResults.Count); 143 Assert.Equal(2, progressValues.Count); 144 145 TestConfigurationUnitResult negativeResult = result.UnitResults.First(x => x.Unit == configurationUnitNegative); 146 TestConfigurationUnitResult negativeProgress = progressValues.First(x => x.Unit == configurationUnitNegative); 147 148 foreach (TestConfigurationUnitResult unitResult in new TestConfigurationUnitResult[] { negativeResult, negativeProgress }) 149 { 150 Assert.NotNull(unitResult); 151 Assert.Equal(ConfigurationTestResult.Negative, unitResult.TestResult); 152 Assert.NotNull(unitResult.ResultInformation); 153 Assert.Null(unitResult.ResultInformation.ResultCode); 154 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 155 } 156 157 TestConfigurationUnitResult positiveResult = result.UnitResults.First(x => x.Unit == configurationUnitPositive); 158 TestConfigurationUnitResult positiveProgress = progressValues.First(x => x.Unit == configurationUnitPositive); 159 160 foreach (TestConfigurationUnitResult unitResult in new TestConfigurationUnitResult[] { positiveResult, positiveProgress }) 161 { 162 Assert.NotNull(unitResult); 163 Assert.Equal(ConfigurationTestResult.Positive, unitResult.TestResult); 164 Assert.NotNull(unitResult.ResultInformation); 165 Assert.Null(unitResult.ResultInformation.ResultCode); 166 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 167 } 168 169 this.VerifySummaryEvent(configurationSet, result, 0, ConfigurationUnitResultSource.None); 170 } 171 172 /// <summary> 173 /// Test when the set processor is a group processor and contains a unit that is also a group. 174 /// </summary> 175 [Fact] 176 public void TestSet_SetGroupProcessor_WithGroupUnit() 177 { 178 ConfigurationSet configurationSet = this.ConfigurationSet(); 179 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 180 181 ConfigurationUnit configurationUnit = this.ConfigurationUnit(); 182 ConfigurationUnit configurationUnitGroup = this.ConfigurationUnit(); 183 184 configurationSet.Units = new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }; 185 186 ConfigurationUnit configurationUnitGroupMember = this.ConfigurationUnit(); 187 configurationUnitGroup.IsGroup = true; 188 configurationUnitGroup.Units = new ConfigurationUnit[] { configurationUnitGroupMember }; 189 190 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 191 TestConfigurationSetGroupProcessor setProcessor = factory.CreateTestGroupProcessor(configurationSet); 192 setProcessor.ShouldWaitOnAsyncEvent = true; 193 194 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 195 List<TestConfigurationUnitResult> progressValues = new List<TestConfigurationUnitResult>(); 196 197 var operation = processor.TestSetAsync(configurationSet); 198 operation.Progress = (Windows.Foundation.IAsyncOperationWithProgress<TestConfigurationSetResult, TestConfigurationUnitResult> op, TestConfigurationUnitResult unitResult) => { progressValues.Add(unitResult); }; 199 setProcessor.SignalAsyncEvent(); 200 201 operation.AsTask().Wait(); 202 TestConfigurationSetResult result = operation.GetResults(); 203 204 Assert.NotNull(result); 205 Assert.Equal(ConfigurationTestResult.Positive, result.TestResult); 206 Assert.NotNull(result.UnitResults); 207 Assert.Equal(3, result.UnitResults.Count); 208 Assert.Equal(3, progressValues.Count); 209 210 foreach (ConfigurationUnit unit in new ConfigurationUnit[] { configurationUnit, configurationUnitGroup, configurationUnitGroupMember }) 211 { 212 foreach (IReadOnlyList<TestConfigurationUnitResult> unitResults in new IReadOnlyList<TestConfigurationUnitResult>[] { result.UnitResults, progressValues }) 213 { 214 TestConfigurationUnitResult unitResult = unitResults.First(x => x.Unit == unit); 215 216 Assert.NotNull(unitResult); 217 Assert.Equal(ConfigurationTestResult.Positive, unitResult.TestResult); 218 Assert.NotNull(unitResult.ResultInformation); 219 Assert.Null(unitResult.ResultInformation.ResultCode); 220 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 221 } 222 } 223 224 this.VerifySummaryEvent(configurationSet, result, 0, ConfigurationUnitResultSource.None); 225 } 226 227 /// <summary> 228 /// Test when the standard set processor is used and there is a group unit. 229 /// </summary> 230 [Fact] 231 public void TestSet_UnitGroupProcessor_WithGroupUnit() 232 { 233 ConfigurationSet configurationSet = this.ConfigurationSet(); 234 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 235 236 ConfigurationUnit configurationUnit = this.ConfigurationUnit(); 237 ConfigurationUnit configurationUnitGroup = this.ConfigurationUnit(); 238 239 configurationSet.Units = new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }; 240 241 ConfigurationUnit configurationUnitGroupMember = this.ConfigurationUnit(); 242 configurationUnitGroup.IsGroup = true; 243 configurationUnitGroup.Units = new ConfigurationUnit[] { configurationUnitGroupMember }; 244 245 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 246 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 247 setProcessor.CreateTestProcessor(configurationUnit); 248 setProcessor.CreateTestGroupProcessor(configurationUnitGroup); 249 250 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 251 252 TestConfigurationSetResult result = processor.TestSet(configurationSet); 253 254 Assert.NotNull(result); 255 Assert.Equal(ConfigurationTestResult.Positive, result.TestResult); 256 Assert.NotNull(result.UnitResults); 257 Assert.Equal(3, result.UnitResults.Count); 258 259 foreach (ConfigurationUnit unit in new ConfigurationUnit[] { configurationUnit, configurationUnitGroup, configurationUnitGroupMember }) 260 { 261 TestConfigurationUnitResult unitResult = result.UnitResults.First(x => x.Unit == unit); 262 263 Assert.NotNull(unitResult); 264 Assert.Equal(ConfigurationTestResult.Positive, unitResult.TestResult); 265 Assert.NotNull(unitResult.ResultInformation); 266 Assert.Null(unitResult.ResultInformation.ResultCode); 267 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 268 } 269 270 this.VerifySummaryEvent(configurationSet, result, 0, ConfigurationUnitResultSource.None); 271 } 272 273 /// <summary> 274 /// Test when the standard set processor is used and there is a non-group unit that still exposes a group processor. 275 /// </summary> 276 [Fact] 277 public void TestSet_UnitGroupProcessor_WithNonGroupUnit() 278 { 279 ConfigurationSet configurationSet = this.ConfigurationSet(); 280 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 281 282 ConfigurationUnit configurationUnit = this.ConfigurationUnit(); 283 ConfigurationUnit configurationUnitGroup = this.ConfigurationUnit(); 284 285 configurationSet.Units = new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }; 286 287 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 288 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 289 setProcessor.CreateTestProcessor(configurationUnit); 290 setProcessor.CreateTestGroupProcessor(configurationUnitGroup); 291 292 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 293 294 TestConfigurationSetResult result = processor.TestSet(configurationSet); 295 296 Assert.NotNull(result); 297 Assert.Equal(ConfigurationTestResult.Positive, result.TestResult); 298 Assert.NotNull(result.UnitResults); 299 Assert.Equal(2, result.UnitResults.Count); 300 301 foreach (ConfigurationUnit unit in new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }) 302 { 303 TestConfigurationUnitResult unitResult = result.UnitResults.First(x => x.Unit == unit); 304 305 Assert.NotNull(unitResult); 306 Assert.Equal(ConfigurationTestResult.Positive, unitResult.TestResult); 307 Assert.NotNull(unitResult.ResultInformation); 308 Assert.Null(unitResult.ResultInformation.ResultCode); 309 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 310 } 311 312 this.VerifySummaryEvent(configurationSet, result, 0, ConfigurationUnitResultSource.None); 313 } 314 315 /// <summary> 316 /// Apply a set that was parsed with schema 0.3. 317 /// </summary> 318 [Fact] 319 public void ApplySet_Parsed_0_3() 320 { 321 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 322 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 323 324 OpenConfigurationSetResult openResult = processor.OpenConfigurationSet(this.CreateStream(@" 325 $schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/08/config/document.json 326 resources: 327 - name: Name 328 type: Module/Resource 329 properties: 330 c: 3 331 d: '4' 332 - name: Name2 333 type: Module/Resource2 334 properties: 335 l: '10' 336 ")); 337 338 Assert.Null(openResult.ResultCode); 339 Assert.NotNull(openResult.Set); 340 Assert.Equal(string.Empty, openResult.Field); 341 Assert.Equal(string.Empty, openResult.Value); 342 Assert.Equal(0U, openResult.Line); 343 Assert.Equal(0U, openResult.Column); 344 345 ConfigurationSet configurationSet = openResult.Set; 346 int unitCount = configurationSet.Units.Count; 347 348 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 349 350 TestConfigurationUnitProcessor[] unitProcessors = new TestConfigurationUnitProcessor[unitCount]; 351 for (int i = 0; i < unitCount; ++i) 352 { 353 unitProcessors[i] = setProcessor.CreateTestProcessor(configurationSet.Units[i]); 354 if (i == 0) 355 { 356 unitProcessors[i].TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => new TestSettingsResultInstance(unit) { TestResult = ConfigurationTestResult.Negative }; 357 } 358 else 359 { 360 unitProcessors[i].TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => new TestSettingsResultInstance(unit) { TestResult = ConfigurationTestResult.Positive }; 361 } 362 } 363 364 ApplyConfigurationSetResult result = processor.ApplySet(configurationSet, ApplyConfigurationSetFlags.None); 365 Assert.NotNull(result); 366 Assert.Null(result.ResultCode); 367 Assert.Equal(unitCount, result.UnitResults.Count); 368 369 for (int i = 0; i < unitCount; ++i) 370 { 371 var unitResult = result.UnitResults[i]; 372 Assert.NotNull(unitResult); 373 374 if (i == 0) 375 { 376 Assert.False(unitResult.PreviouslyInDesiredState); 377 } 378 else 379 { 380 Assert.True(unitResult.PreviouslyInDesiredState); 381 } 382 383 Assert.False(unitResult.RebootRequired); 384 Assert.NotNull(unitResult.ResultInformation); 385 Assert.Null(unitResult.ResultInformation.ResultCode); 386 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 387 } 388 389 for (int i = 0; i < unitCount; ++i) 390 { 391 Assert.Equal(1, unitProcessors[i].TestSettingsCalls); 392 Assert.Equal(0, unitProcessors[i].GetSettingsCalls); 393 if (i == 0) 394 { 395 Assert.Equal(1, unitProcessors[i].ApplySettingsCalls); 396 } 397 else 398 { 399 Assert.Equal(0, unitProcessors[i].ApplySettingsCalls); 400 } 401 } 402 403 this.VerifySummaryEvent(configurationSet, result, ConfigurationUnitResultSource.None); 404 } 405 406 /// <summary> 407 /// Test when the set processor is a group processor. 408 /// </summary> 409 [Fact] 410 public void ApplySet_SetGroupProcessor() 411 { 412 ConfigurationSet configurationSet = this.ConfigurationSet(); 413 414 ConfigurationUnit configurationUnitNegative = this.ConfigurationUnit(); 415 configurationUnitNegative.Settings[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 416 ConfigurationUnit configurationUnitPositive = this.ConfigurationUnit(); 417 configurationUnitPositive.Settings[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Positive.ToString(); 418 configurationSet.Units = new ConfigurationUnit[] { configurationUnitNegative, configurationUnitPositive }; 419 420 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 421 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 422 ManualResetEvent startProcessing = new ManualResetEvent(false); 423 factory.CreateSetProcessorDelegate = (f, c) => 424 { 425 startProcessing.WaitOne(); 426 return f.CreateTestGroupProcessor(c); 427 }; 428 429 var operation = processor.ApplySetAsync(configurationSet, ApplyConfigurationSetFlags.None); 430 431 List<ConfigurationSetChangeData> progressValues = new List<ConfigurationSetChangeData>(); 432 operation.Progress = (Windows.Foundation.IAsyncOperationWithProgress<ApplyConfigurationSetResult, ConfigurationSetChangeData> op, ConfigurationSetChangeData unitResult) => { progressValues.Add(unitResult); }; 433 startProcessing.Set(); 434 operation.AsTask().Wait(); 435 ApplyConfigurationSetResult result = operation.GetResults(); 436 437 Assert.NotNull(result); 438 Assert.Null(result.ResultCode); 439 Assert.NotNull(result.UnitResults); 440 Assert.Equal(configurationSet.Units.Count, result.UnitResults.Count); 441 Assert.Equal((configurationSet.Units.Count * 2) + 2, progressValues.Count); 442 443 ApplyConfigurationUnitResult negativeResult = result.UnitResults.First(x => x.Unit == configurationUnitNegative); 444 445 Assert.NotNull(negativeResult); 446 Assert.NotNull(negativeResult.ResultInformation); 447 Assert.Null(negativeResult.ResultInformation.ResultCode); 448 Assert.Equal(ConfigurationUnitResultSource.None, negativeResult.ResultInformation.ResultSource); 449 Assert.Equal(ConfigurationUnitState.Completed, negativeResult.State); 450 Assert.False(negativeResult.PreviouslyInDesiredState); 451 452 IEnumerable<ConfigurationSetChangeData> negativeProgress = progressValues.Where(x => x.Unit == configurationUnitNegative); 453 Assert.Equal(2, negativeProgress.Count()); 454 455 foreach (ConfigurationSetChangeData change in negativeProgress) 456 { 457 Assert.Equal(ConfigurationSetChangeEventType.UnitStateChanged, change.Change); 458 Assert.Equal(ConfigurationSetState.InProgress, change.SetState); 459 Assert.NotNull(change.ResultInformation); 460 Assert.Null(change.ResultInformation.ResultCode); 461 Assert.Equal(ConfigurationUnitResultSource.None, change.ResultInformation.ResultSource); 462 } 463 464 Assert.Single(negativeProgress.Where(x => x.UnitState == ConfigurationUnitState.InProgress)); 465 Assert.Single(negativeProgress.Where(x => x.UnitState == ConfigurationUnitState.Completed)); 466 467 ApplyConfigurationUnitResult positiveResult = result.UnitResults.First(x => x.Unit == configurationUnitPositive); 468 469 Assert.NotNull(positiveResult); 470 Assert.NotNull(positiveResult.ResultInformation); 471 Assert.Null(positiveResult.ResultInformation.ResultCode); 472 Assert.Equal(ConfigurationUnitResultSource.None, positiveResult.ResultInformation.ResultSource); 473 Assert.Equal(ConfigurationUnitState.Completed, positiveResult.State); 474 Assert.True(positiveResult.PreviouslyInDesiredState); 475 476 IEnumerable<ConfigurationSetChangeData> positiveProgress = progressValues.Where(x => x.Unit == configurationUnitPositive); 477 Assert.Equal(2, positiveProgress.Count()); 478 479 foreach (ConfigurationSetChangeData change in positiveProgress) 480 { 481 Assert.Equal(ConfigurationSetChangeEventType.UnitStateChanged, change.Change); 482 Assert.Equal(ConfigurationSetState.InProgress, change.SetState); 483 Assert.NotNull(change.ResultInformation); 484 Assert.Null(change.ResultInformation.ResultCode); 485 Assert.Equal(ConfigurationUnitResultSource.None, change.ResultInformation.ResultSource); 486 } 487 488 Assert.Single(positiveProgress.Where(x => x.UnitState == ConfigurationUnitState.InProgress)); 489 Assert.Single(positiveProgress.Where(x => x.UnitState == ConfigurationUnitState.Completed)); 490 491 this.VerifySummaryEvent(configurationSet, result, ConfigurationUnitResultSource.None); 492 } 493 494 /// <summary> 495 /// Test when the set processor is a group processor and contains a unit that is also a group. 496 /// </summary> 497 [Fact] 498 public void ApplySet_SetGroupProcessor_WithGroupUnit() 499 { 500 ConfigurationSet configurationSet = this.ConfigurationSet(); 501 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 502 503 ConfigurationUnit configurationUnit = this.ConfigurationUnit(); 504 ConfigurationUnit configurationUnitGroup = this.ConfigurationUnit(); 505 506 configurationSet.Units = new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }; 507 508 ConfigurationUnit configurationUnitGroupMember = this.ConfigurationUnit(); 509 configurationUnitGroup.IsGroup = true; 510 configurationUnitGroup.Units = new ConfigurationUnit[] { configurationUnitGroupMember }; 511 512 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 513 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 514 ManualResetEvent startProcessing = new ManualResetEvent(false); 515 factory.CreateSetProcessorDelegate = (f, c) => 516 { 517 startProcessing.WaitOne(); 518 return f.CreateTestGroupProcessor(c); 519 }; 520 521 var operation = processor.ApplySetAsync(configurationSet, ApplyConfigurationSetFlags.None); 522 523 List<ConfigurationSetChangeData> progressValues = new List<ConfigurationSetChangeData>(); 524 operation.Progress = (Windows.Foundation.IAsyncOperationWithProgress<ApplyConfigurationSetResult, ConfigurationSetChangeData> op, ConfigurationSetChangeData unitResult) => { progressValues.Add(unitResult); }; 525 startProcessing.Set(); 526 operation.AsTask().Wait(); 527 ApplyConfigurationSetResult result = operation.GetResults(); 528 529 Assert.NotNull(result); 530 Assert.Null(result.ResultCode); 531 Assert.NotNull(result.UnitResults); 532 Assert.Equal(3, result.UnitResults.Count); 533 Assert.Equal(2 + (3 * 2), progressValues.Count); 534 535 foreach (ConfigurationUnit unit in new ConfigurationUnit[] { configurationUnit, configurationUnitGroup, configurationUnitGroupMember }) 536 { 537 ApplyConfigurationUnitResult unitResult = result.UnitResults.First(x => x.Unit == unit); 538 539 Assert.NotNull(unitResult); 540 Assert.NotNull(unitResult.ResultInformation); 541 Assert.Null(unitResult.ResultInformation.ResultCode); 542 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 543 Assert.Equal(ConfigurationUnitState.Completed, unitResult.State); 544 Assert.True(unitResult.PreviouslyInDesiredState); 545 546 IEnumerable<ConfigurationSetChangeData> unitProgress = progressValues.Where(x => x.Unit == unit); 547 Assert.Equal(2, unitProgress.Count()); 548 549 foreach (ConfigurationSetChangeData change in unitProgress) 550 { 551 Assert.Equal(ConfigurationSetChangeEventType.UnitStateChanged, change.Change); 552 Assert.Equal(ConfigurationSetState.InProgress, change.SetState); 553 Assert.NotNull(change.ResultInformation); 554 Assert.Null(change.ResultInformation.ResultCode); 555 Assert.Equal(ConfigurationUnitResultSource.None, change.ResultInformation.ResultSource); 556 } 557 558 Assert.True(unitProgress.Where(x => x.UnitState == ConfigurationUnitState.InProgress).Count() <= 1); 559 Assert.True(unitProgress.Where(x => x.UnitState == ConfigurationUnitState.Completed).Count() <= 1); 560 } 561 562 this.VerifySummaryEvent(configurationSet, result, ConfigurationUnitResultSource.None); 563 } 564 565 /// <summary> 566 /// Test when the standard set processor is used and there is a group unit. 567 /// </summary> 568 [Fact] 569 public void ApplySet_UnitGroupProcessor_WithGroupUnit() 570 { 571 ConfigurationSet configurationSet = this.ConfigurationSet(); 572 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 573 574 ConfigurationUnit configurationUnit = this.ConfigurationUnit(); 575 ConfigurationUnit configurationUnitGroup = this.ConfigurationUnit(); 576 577 configurationSet.Units = new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }; 578 579 ConfigurationUnit configurationUnitGroupMember = this.ConfigurationUnit(); 580 configurationUnitGroup.IsGroup = true; 581 configurationUnitGroup.Units = new ConfigurationUnit[] { configurationUnitGroupMember }; 582 583 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 584 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 585 setProcessor.CreateTestProcessor(configurationUnit); 586 setProcessor.CreateTestGroupProcessor(configurationUnitGroup); 587 588 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 589 590 ApplyConfigurationSetResult result = processor.ApplySet(configurationSet, ApplyConfigurationSetFlags.None); 591 592 Assert.NotNull(result); 593 Assert.Null(result.ResultCode); 594 Assert.NotNull(result.UnitResults); 595 Assert.Equal(3, result.UnitResults.Count); 596 597 foreach (ConfigurationUnit unit in new ConfigurationUnit[] { configurationUnit, configurationUnitGroup, configurationUnitGroupMember }) 598 { 599 ApplyConfigurationUnitResult unitResult = result.UnitResults.First(x => x.Unit == unit); 600 601 Assert.NotNull(unitResult); 602 Assert.NotNull(unitResult.ResultInformation); 603 Assert.Null(unitResult.ResultInformation.ResultCode); 604 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 605 Assert.Equal(ConfigurationUnitState.Completed, unitResult.State); 606 Assert.True(unitResult.PreviouslyInDesiredState); 607 } 608 609 this.VerifySummaryEvent(configurationSet, result, ConfigurationUnitResultSource.None); 610 } 611 612 /// <summary> 613 /// Test when the standard set processor is used and there is a non-group unit that still exposes a group processor. 614 /// </summary> 615 [Fact] 616 public void ApplySet_UnitGroupProcessor_WithNonGroupUnit() 617 { 618 ConfigurationSet configurationSet = this.ConfigurationSet(); 619 configurationSet.Metadata[TestConfigurationUnitGroupProcessor.TestResultSetting] = ConfigurationTestResult.Negative.ToString(); 620 621 ConfigurationUnit configurationUnit = this.ConfigurationUnit(); 622 ConfigurationUnit configurationUnitGroup = this.ConfigurationUnit(); 623 624 configurationSet.Units = new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }; 625 626 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 627 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 628 setProcessor.CreateTestProcessor(configurationUnit); 629 setProcessor.CreateTestGroupProcessor(configurationUnitGroup); 630 631 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 632 633 ApplyConfigurationSetResult result = processor.ApplySet(configurationSet, ApplyConfigurationSetFlags.None); 634 635 Assert.NotNull(result); 636 Assert.Null(result.ResultCode); 637 Assert.NotNull(result.UnitResults); 638 Assert.Equal(2, result.UnitResults.Count); 639 640 foreach (ConfigurationUnit unit in new ConfigurationUnit[] { configurationUnit, configurationUnitGroup }) 641 { 642 ApplyConfigurationUnitResult unitResult = result.UnitResults.First(x => x.Unit == unit); 643 644 Assert.NotNull(unitResult); 645 Assert.NotNull(unitResult.ResultInformation); 646 Assert.Null(unitResult.ResultInformation.ResultCode); 647 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 648 Assert.Equal(ConfigurationUnitState.Completed, unitResult.State); 649 Assert.True(unitResult.PreviouslyInDesiredState); 650 } 651 652 this.VerifySummaryEvent(configurationSet, result, ConfigurationUnitResultSource.None); 653 } 654 } 655 }