ConfigurationProcessorTestTests.cs (17656B)
1 // ----------------------------------------------------------------------------- 2 // <copyright file="ConfigurationProcessorTestTests.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.IO; 11 using System.Linq; 12 using Microsoft.Management.Configuration.UnitTests.Fixtures; 13 using Microsoft.Management.Configuration.UnitTests.Helpers; 14 using Microsoft.VisualBasic; 15 using Xunit; 16 using Xunit.Abstractions; 17 18 /// <summary> 19 /// Unit tests for running test on the processor. 20 /// </summary> 21 [Collection("UnitTestCollection")] 22 [InProc] 23 [OutOfProc] 24 public class ConfigurationProcessorTestTests : ConfigurationProcessorTestBase 25 { 26 /// <summary> 27 /// Initializes a new instance of the <see cref="ConfigurationProcessorTestTests"/> class. 28 /// </summary> 29 /// <param name="fixture">Unit test fixture.</param> 30 /// <param name="log">Log helper.</param> 31 public ConfigurationProcessorTestTests(UnitTestFixture fixture, ITestOutputHelper log) 32 : base(fixture, log) 33 { 34 } 35 36 /// <summary> 37 /// An error creating the set processor results in an error for the function. 38 /// </summary> 39 [Fact] 40 public void TestSet_SetProcessorError() 41 { 42 ConfigurationSet configurationSet = this.ConfigurationSet(); 43 44 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 45 factory.Exceptions.Add(configurationSet, new FileNotFoundException()); 46 47 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 48 49 Assert.Throws<FileNotFoundException>(() => processor.TestSet(configurationSet)); 50 51 Assert.Empty(this.EventSink.Events); 52 } 53 54 /// <summary> 55 /// An error creating a unit processor results in an error for that unit. 56 /// </summary> 57 [Fact] 58 public void TestSet_UnitProcessorCreationError() 59 { 60 ConfigurationSet configurationSet = this.ConfigurationSet(); 61 ConfigurationUnit configurationUnitThrows = this.ConfigurationUnit(); 62 ConfigurationUnit configurationUnitWorks = this.ConfigurationUnit(); 63 configurationSet.Units = new ConfigurationUnit[] { configurationUnitThrows, configurationUnitWorks }; 64 65 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 66 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 67 setProcessor.Exceptions.Add(configurationUnitThrows, new NullReferenceException()); 68 69 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 70 71 TestConfigurationSetResult result = processor.TestSet(configurationSet); 72 73 Assert.NotNull(result); 74 Assert.Equal(ConfigurationTestResult.Failed, result.TestResult); 75 Assert.NotNull(result.UnitResults); 76 Assert.Equal(2, result.UnitResults.Count); 77 78 TestConfigurationUnitResult throwsResult = result.UnitResults.First(x => x.Unit == configurationUnitThrows); 79 Assert.NotNull(throwsResult); 80 Assert.Equal(ConfigurationTestResult.Failed, throwsResult.TestResult); 81 Assert.NotNull(throwsResult.ResultInformation); 82 Assert.NotNull(throwsResult.ResultInformation.ResultCode); 83 Assert.IsType<NullReferenceException>(throwsResult.ResultInformation.ResultCode); 84 Assert.Equal(ConfigurationUnitResultSource.Internal, throwsResult.ResultInformation.ResultSource); 85 86 TestConfigurationUnitResult worksResult = result.UnitResults.First(x => x.Unit == configurationUnitWorks); 87 Assert.NotNull(worksResult); 88 Assert.Equal(ConfigurationTestResult.Positive, worksResult.TestResult); 89 Assert.NotNull(worksResult.ResultInformation); 90 Assert.Null(worksResult.ResultInformation.ResultCode); 91 Assert.Equal(ConfigurationUnitResultSource.None, worksResult.ResultInformation.ResultSource); 92 93 this.VerifySummaryEvent(configurationSet, result, throwsResult.ResultInformation.ResultCode.HResult, ConfigurationUnitResultSource.Internal); 94 } 95 96 /// <summary> 97 /// An error running a unit processor results in an error for that unit. 98 /// </summary> 99 [Fact] 100 public void TestSet_UnitProcessorExecutionError() 101 { 102 ConfigurationSet configurationSet = this.ConfigurationSet(); 103 ConfigurationUnit configurationUnitThrows = this.ConfigurationUnit(); 104 ConfigurationUnit configurationUnitWorks = this.ConfigurationUnit(); 105 configurationSet.Units = new ConfigurationUnit[] { configurationUnitWorks, configurationUnitThrows }; 106 107 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 108 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 109 TestConfigurationUnitProcessor unitProcessor = setProcessor.CreateTestProcessor(configurationUnitThrows); 110 unitProcessor.TestSettingsDelegate = () => throw new NullReferenceException(); 111 112 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 113 114 TestConfigurationSetResult result = processor.TestSet(configurationSet); 115 116 Assert.NotNull(result); 117 Assert.Equal(ConfigurationTestResult.Failed, result.TestResult); 118 Assert.NotNull(result.UnitResults); 119 Assert.Equal(2, result.UnitResults.Count); 120 121 TestConfigurationUnitResult throwsResult = result.UnitResults.First(x => x.Unit == configurationUnitThrows); 122 Assert.NotNull(throwsResult); 123 Assert.Equal(ConfigurationTestResult.Failed, throwsResult.TestResult); 124 Assert.NotNull(throwsResult.ResultInformation); 125 Assert.NotNull(throwsResult.ResultInformation.ResultCode); 126 Assert.IsType<NullReferenceException>(throwsResult.ResultInformation.ResultCode); 127 Assert.Equal(ConfigurationUnitResultSource.Internal, throwsResult.ResultInformation.ResultSource); 128 129 TestConfigurationUnitResult worksResult = result.UnitResults.First(x => x.Unit == configurationUnitWorks); 130 Assert.NotNull(worksResult); 131 Assert.Equal(ConfigurationTestResult.Positive, worksResult.TestResult); 132 Assert.NotNull(worksResult.ResultInformation); 133 Assert.Null(worksResult.ResultInformation.ResultCode); 134 Assert.Equal(ConfigurationUnitResultSource.None, worksResult.ResultInformation.ResultSource); 135 136 this.VerifySummaryEvent(configurationSet, result, throwsResult.ResultInformation.ResultCode.HResult, ConfigurationUnitResultSource.Internal); 137 } 138 139 /// <summary> 140 /// An error running a unit processor results in an error for that unit. 141 /// </summary> 142 [Fact] 143 public void TestSet_UnitProcessorResultError() 144 { 145 ConfigurationSet configurationSet = this.ConfigurationSet(); 146 ConfigurationUnit configurationUnitThrows = this.ConfigurationUnit(); 147 ConfigurationUnit configurationUnitWorks = this.ConfigurationUnit(); 148 configurationSet.Units = new ConfigurationUnit[] { configurationUnitWorks, configurationUnitThrows }; 149 150 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 151 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 152 TestConfigurationUnitProcessor unitProcessor = setProcessor.CreateTestProcessor(configurationUnitThrows); 153 TestSettingsResultInstance testResult = new TestSettingsResultInstance(configurationUnitThrows); 154 testResult.TestResult = ConfigurationTestResult.Failed; 155 testResult.InternalResult.ResultCode = new NullReferenceException(); 156 testResult.InternalResult.Description = "Failed again"; 157 testResult.InternalResult.ResultSource = ConfigurationUnitResultSource.UnitProcessing; 158 unitProcessor.TestSettingsDelegate = () => testResult; 159 160 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 161 162 TestConfigurationSetResult result = processor.TestSet(configurationSet); 163 164 Assert.NotNull(result); 165 Assert.Equal(ConfigurationTestResult.Failed, result.TestResult); 166 Assert.NotNull(result.UnitResults); 167 Assert.Equal(2, result.UnitResults.Count); 168 169 TestConfigurationUnitResult throwsResult = result.UnitResults.First(x => x.Unit == configurationUnitThrows); 170 Assert.NotNull(throwsResult); 171 Assert.Equal(ConfigurationTestResult.Failed, throwsResult.TestResult); 172 Assert.NotNull(throwsResult.ResultInformation); 173 Assert.NotNull(throwsResult.ResultInformation.ResultCode); 174 Assert.IsType<NullReferenceException>(throwsResult.ResultInformation.ResultCode); 175 Assert.Equal(testResult.ResultInformation.Description, throwsResult.ResultInformation.Description); 176 Assert.Equal(testResult.ResultInformation.ResultSource, throwsResult.ResultInformation.ResultSource); 177 178 TestConfigurationUnitResult worksResult = result.UnitResults.First(x => x.Unit == configurationUnitWorks); 179 Assert.NotNull(worksResult); 180 Assert.Equal(ConfigurationTestResult.Positive, worksResult.TestResult); 181 Assert.NotNull(worksResult.ResultInformation); 182 Assert.Null(worksResult.ResultInformation.ResultCode); 183 Assert.Equal(ConfigurationUnitResultSource.None, worksResult.ResultInformation.ResultSource); 184 185 this.VerifySummaryEvent(configurationSet, result, testResult.ResultInformation.ResultCode.HResult, testResult.ResultInformation.ResultSource); 186 } 187 188 /// <summary> 189 /// Ensures that the expected TestResult comes back for all types. 190 /// </summary> 191 [Fact] 192 public void TestSet_ResultTypes() 193 { 194 this.RunTestSetTestForResultTypes(new ConfigurationTestResult[] { ConfigurationTestResult.Positive, ConfigurationTestResult.Negative, ConfigurationTestResult.Failed, ConfigurationTestResult.NotRun }, ConfigurationTestResult.Failed); 195 } 196 197 /// <summary> 198 /// Ensures that a single negative makes the overall result negative. 199 /// </summary> 200 [Fact] 201 public void TestSet_Negative() 202 { 203 this.RunTestSetTestForResultTypes(new ConfigurationTestResult[] { ConfigurationTestResult.Positive, ConfigurationTestResult.Negative, ConfigurationTestResult.Positive, ConfigurationTestResult.NotRun }, ConfigurationTestResult.Negative); 204 } 205 206 /// <summary> 207 /// Ensures that a single not run test does not impact the positive result. 208 /// </summary> 209 [Fact] 210 public void TestSet_Positive() 211 { 212 this.RunTestSetTestForResultTypes(new ConfigurationTestResult[] { ConfigurationTestResult.Positive, ConfigurationTestResult.Positive, ConfigurationTestResult.Positive, ConfigurationTestResult.NotRun }, ConfigurationTestResult.Positive); 213 } 214 215 private TestSettingsResultInstance PositiveResult(ConfigurationUnit unit) 216 { 217 TestSettingsResultInstance positiveResult = new TestSettingsResultInstance(unit); 218 positiveResult.TestResult = ConfigurationTestResult.Positive; 219 return positiveResult; 220 } 221 222 private TestSettingsResultInstance NegativeResult(ConfigurationUnit unit) 223 { 224 TestSettingsResultInstance negativeResult = new TestSettingsResultInstance(unit); 225 negativeResult.TestResult = ConfigurationTestResult.Negative; 226 return negativeResult; 227 } 228 229 private TestSettingsResultInstance FailedResult(ConfigurationUnit unit, string description, ConfigurationUnitResultSource resultSource) 230 { 231 TestSettingsResultInstance failedResult = new TestSettingsResultInstance(unit); 232 failedResult.TestResult = ConfigurationTestResult.Failed; 233 failedResult.InternalResult.ResultCode = new NullReferenceException(); 234 failedResult.InternalResult.Description = description; 235 failedResult.InternalResult.ResultSource = resultSource; 236 return failedResult; 237 } 238 239 /// <summary> 240 /// Creates a test scenario where the units produce the given test results. 241 /// </summary> 242 /// <param name="resultTypes">The result types for each unit.</param> 243 /// <param name="overallResult">The expected overall test result.</param> 244 private void RunTestSetTestForResultTypes(ConfigurationTestResult[] resultTypes, ConfigurationTestResult overallResult) 245 { 246 ConfigurationSet configurationSet = this.ConfigurationSet(); 247 ConfigurationUnit[] configurationUnits = new ConfigurationUnit[resultTypes.Length]; 248 249 TestConfigurationProcessorFactory factory = new TestConfigurationProcessorFactory(); 250 TestConfigurationSetProcessor setProcessor = factory.CreateTestProcessor(configurationSet); 251 252 string failedDescription = "Failed again"; 253 ConfigurationUnitResultSource failedResultSource = ConfigurationUnitResultSource.UnitProcessing; 254 255 for (int i = 0; i < resultTypes.Length; ++i) 256 { 257 configurationUnits[i] = this.ConfigurationUnit(); 258 configurationUnits[i].Type = $"Unit {i}"; 259 TestConfigurationUnitProcessor unitProcessor = setProcessor.CreateTestProcessor(configurationUnits[i]); 260 261 switch (resultTypes[i]) 262 { 263 case ConfigurationTestResult.Positive: 264 unitProcessor.TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => this.PositiveResult(unit); 265 break; 266 case ConfigurationTestResult.Negative: 267 unitProcessor.TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => this.NegativeResult(unit); 268 break; 269 case ConfigurationTestResult.NotRun: 270 configurationUnits[i].Intent = ConfigurationUnitIntent.Inform; 271 break; 272 case ConfigurationTestResult.Failed: 273 unitProcessor.TestSettingsDelegateWithUnit = (ConfigurationUnit unit) => this.FailedResult(unit, failedDescription, failedResultSource); 274 break; 275 } 276 } 277 278 configurationSet.Units = configurationUnits; 279 280 ConfigurationProcessor processor = this.CreateConfigurationProcessorWithDiagnostics(factory); 281 282 TestConfigurationSetResult result = processor.TestSet(configurationSet); 283 284 Assert.NotNull(result); 285 Assert.Equal(overallResult, result.TestResult); 286 Assert.NotNull(result.UnitResults); 287 Assert.Equal(resultTypes.Length, result.UnitResults.Count); 288 289 int summaryEventResult = 0; 290 ConfigurationUnitResultSource resultSource = ConfigurationUnitResultSource.None; 291 292 for (int i = 0; i < resultTypes.Length; ++i) 293 { 294 TestConfigurationUnitResult unitResult = result.UnitResults.First(x => x.Unit == configurationUnits[i]); 295 296 Assert.NotNull(unitResult); 297 Assert.Equal(resultTypes[i], unitResult.TestResult); 298 Assert.NotNull(unitResult.ResultInformation); 299 300 switch (resultTypes[i]) 301 { 302 case ConfigurationTestResult.Positive: 303 case ConfigurationTestResult.Negative: 304 case ConfigurationTestResult.NotRun: 305 Assert.Null(unitResult.ResultInformation.ResultCode); 306 Assert.Empty(unitResult.ResultInformation.Description); 307 Assert.Equal(ConfigurationUnitResultSource.None, unitResult.ResultInformation.ResultSource); 308 break; 309 case ConfigurationTestResult.Failed: 310 Assert.NotNull(unitResult.ResultInformation.ResultCode); 311 Assert.IsType<NullReferenceException>(unitResult.ResultInformation.ResultCode); 312 Assert.Equal(failedDescription, unitResult.ResultInformation.Description); 313 Assert.Equal(failedResultSource, unitResult.ResultInformation.ResultSource); 314 summaryEventResult = unitResult.ResultInformation.ResultCode.HResult; 315 resultSource = unitResult.ResultInformation.ResultSource; 316 break; 317 } 318 } 319 320 this.VerifySummaryEvent(configurationSet, result, summaryEventResult, resultSource); 321 } 322 } 323 }