public void ConfigCommand_Key_Group_Domain_MaxConcurrentCount() { HystrixCommandBase.ConfigCommand <string>(TestCommandKey, TestGroupKey, TestDomain, CustomConfigSet.CommandMaxConcurrentCount); Assert.AreEqual(TestGroupKey, CommandComponents.CommandInfo.GroupKey, true); Assert.AreEqual(TestDomain, CommandComponents.CommandInfo.Domain, true); Assert.AreEqual(CustomConfigSet.CommandMaxConcurrentCount, CommandComponents.ConfigSet.CommandMaxConcurrentCount); }
public void CircuitBreakerForceClosedIsFalseWithoutFallback() { CommandComponents.ConfigSet.ToConcrete().CircuitBreakerForceClosed = false; string expected = string.Empty; for (int i = 0; i < CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold; i++) { try { ScenarioTestHelper.SleepHealthSnapshotInverval(); HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (ScenarioTestException) { } } try { ScenarioTestHelper.SleepHealthSnapshotInverval(); HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (HystrixException ex) { Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } }
public void ConfigAllCommandSettings() { Assert.IsFalse(ScenarioTestHelper.AreEqual(DefaultConfigSet, CustomConfigSet)); HystrixCommandBase.ConfigCommand <string>(TestCommandKey, configSet => ScenarioTestHelper.SetCommandConfigFrom(configSet, CustomConfigSet)); Assert.IsTrue(ScenarioTestHelper.AreEqual(CustomConfigSet, CommandComponents.ConfigSet)); }
private void RunToTimeoutNormally() { ScenarioTestHelper.SleepHealthSnapshotInverval(); string actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, ExecuteTimeout); Assert.AreEqual(Expected, actual); }
public void ConfigCommand_Key_Domain_Config() { HystrixCommandBase.ConfigCommand <string>(TestCommandKey, TestDomain, config => ScenarioTestHelper.SetCommandConfigFrom(config, CustomConfigSet)); Assert.AreEqual(TestDomain, CommandComponents.CommandInfo.Domain, true); Assert.IsTrue(ScenarioTestHelper.AreEqual(CustomConfigSet, CommandComponents.ConfigSet)); }
public void IsBadRequestException_NonCustomBadRequestException() { HystrixCommandBase.RegisterCustomBadRequestExceptionChecker("custom", ex => ex is IndexOutOfRangeException); Exception ex2 = new Exception(); Assert.IsFalse(ex2.IsBadRequestException()); }
public void RunCommandFailAndFallbackSuccess() { string fallback = string.Empty; string actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new Exception(); }, () => fallback); Assert.AreEqual(fallback, actual); }
public void ExecuteAsync_ShouldExecute_MethodWithOutParametersRetuningVoid() { // Arrange var mockService = new MockService(); var primaryArgs = new Type[] { }; MethodInfo methodInfo = typeof(MockService).GetMethod(nameof(MockService.MethodReturnsTask), primaryArgs); var primaryFuncArgs = primaryArgs.Concat(new Type[] { methodInfo.ReturnType }).ToArray(); var primaryDelegate = methodInfo.CreateDelegate(Expression.GetDelegateType(primaryFuncArgs), mockService); var fallbackArgs = new Type[] { typeof(HystrixFallback) }; methodInfo = typeof(MockService).GetMethod(nameof(MockService.MethodRetunsVoid), fallbackArgs); var fallbackDelegate = methodInfo.CreateDelegate(Expression.GetActionType(fallbackArgs), mockService); var options = MockService.GetCommandOptions(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()); //Act var command = new HystrixCommandBase(options, primaryDelegate, fallbackDelegate, new object[] { }, _loggerFactory); command.Execute(); }
private void TestRequestCountThresholdSetting(int?setting = null) { if (setting.HasValue) { CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold = setting.Value; } else { setting = CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold; } for (int i = 0; i < setting.Value; i++) { ScenarioTestHelper.SleepHealthSnapshotInverval(); try { HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (ScenarioTestException) { } } ScenarioTestHelper.SleepHealthSnapshotInverval(); try { HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (HystrixException) { } }
public SemaphoreIsolation(string instanceKey, string commandKey, string groupKey, string domain, Action <ICommandConfigSet> config) { Func <string, CommandComponents> valueFactory = null; Func <string, IsolationSemaphore> func2 = null; if (string.IsNullOrWhiteSpace(commandKey)) { string message = "HystrixCommand Key cannot be null."; CommonUtils.Log.Log(LogLevelEnum.Fatal, message, new Dictionary <string, string>().AddLogTagData("FXD303002")); throw new ArgumentNullException(message); } this.Key = CommonUtils.GenerateKey(instanceKey, commandKey); instanceKey = string.IsNullOrWhiteSpace(instanceKey) ? null : instanceKey.Trim(); commandKey = commandKey.Trim(); groupKey = groupKey ?? "DefaultGroup"; domain = domain ?? "Ant"; if (valueFactory == null) { valueFactory = key => HystrixCommandBase.CreateCommandComponents(this.Key, instanceKey, commandKey, groupKey, domain, IsolationModeEnum.SemaphoreIsolation, config, typeof(SemaphoreIsolation)); } this.Components = HystrixCommandBase.CommandComponentsCollection.GetOrAdd(this.Key, valueFactory); if (func2 == null) { func2 = key => new IsolationSemaphore(this.Components.ConfigSet.CommandMaxConcurrentCount); } this.ExecutionSemaphore = HystrixCommandBase.ExecutionSemaphores.GetOrAdd(this.Key, func2); this._stopwatch = new Stopwatch(); }
public void CircuitBreakerForceClosedIsTrueWithoutFallback() { CommandComponents.ConfigSet.ToConcrete().CircuitBreakerForceClosed = true; for (int i = 0; i < CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold; i++) { try { ScenarioTestHelper.SleepHealthSnapshotInverval(); HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (ScenarioTestException) { } } try { ScenarioTestHelper.SleepHealthSnapshotInverval(); HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (ScenarioTestException) { } }
public void ExecuteAsync_ShouldExecute_PrimaryWhenNoTimeoutOnIt() { // Arrange var executationResult = string.Empty; var mockService = new MockService(); var methodInfo = default(MethodInfo); var primaryArgs = new Type[] { typeof(int) }; methodInfo = typeof(MockService).GetMethod(nameof(MockService.MethodWithTimeoutTest), primaryArgs); var primaryFuncArgs = primaryArgs.Concat(new Type[] { methodInfo.ReturnType }).ToArray(); var primaryDelegate = methodInfo.CreateDelegate(Expression.GetDelegateType(primaryFuncArgs), mockService); var fallbackArgs = new Type[] { typeof(HystrixFallback), typeof(int) }; methodInfo = typeof(MockService).GetMethod(nameof(MockService.MethodWithTimeoutTest), fallbackArgs); var fallbackFuncArgs = fallbackArgs.Concat(new Type[] { methodInfo.ReturnType }).ToArray(); var fallbackDelegate = methodInfo.CreateDelegate(Expression.GetFuncType(fallbackFuncArgs), mockService); var options = MockService.GetCommandOptions(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()); //Act var command = new HystrixCommandBase <IEnumerable <Type> >(options, primaryDelegate, fallbackDelegate, new object[] { 10 }, _loggerFactory); var result = command.Execute(); // Assert result.Should().BeEquivalentTo(primaryArgs); }
public void CircuitBreakerForceOpenIsFalseWithFallback() { CommandComponents.ConfigSet.ToConcrete().CircuitBreakerForceOpen = false; string result = HystrixCommandBase.RunCommand <string>(TestCommandKey, () => string.Empty, () => null); Assert.AreEqual(string.Empty, result); }
private void TestErrorPercentageThresholdSetting100() { CommandComponents.ConfigSet.CircuitBreakerErrorThresholdPercentage = 100; for (int i = 0; i < 100; i++) { ScenarioTestHelper.SleepHealthSnapshotInverval(); try { HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (ScenarioTestException) { if (i >= CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold) { Assert.Fail("Execution should throw HystrixException."); } } catch (HystrixException ex) { if (i < CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold) { Assert.Fail("Execution should throw ScenarioTestException."); } Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } } }
public void CustomBadRequestNotCauseCircuitBreakerOpen_CheckerThrowException() { HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(WithExceptionCheckerName, IsBadRequestExceptionWithException); CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold = 2; int circuitBreakerCount = 0; for (int i = 0; i < 100; i++) { SampleIsolationCommand command = new SampleIsolationCommand( TestCommandKey, execute: () => { throw new ArgumentOutOfRangeException(); }); try { command.Run(); } catch (ArgumentOutOfRangeException) { } catch (HystrixException) { } ScenarioTestHelper.SleepHealthSnapshotInverval(); Dictionary <CommandExecutionEventEnum, int> counts = CommandComponents.Metrics.ToConcrete().GetExecutionEventDistribution(); circuitBreakerCount += counts[CommandExecutionEventEnum.ShortCircuited]; } Assert.AreNotEqual(0, circuitBreakerCount); }
private void RunToSuccessNormally() { ScenarioTestHelper.SleepHealthSnapshotInverval(); string actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, () => Expected); Assert.AreEqual(Expected, actual); }
public void RunCommandSuccessAndFallbackFail() { string expected = string.Empty; string actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, () => expected, () => { throw new ScenarioTestException(); }); Assert.AreEqual(expected, actual); }
public void ConfigCommandWithDefaultConfig() { HystrixCommandBase.ConfigCommand <string>(TestCommandKey, config => {}); Assert.AreEqual(TestCommandKey, CommandComponents.CommandInfo.Key, true); Assert.AreEqual(HystrixCommandBase.DefaultGroupKey, CommandComponents.CommandInfo.GroupKey, true); Assert.AreEqual(CommandDomains.Default, CommandComponents.CommandInfo.Domain, true); Assert.IsTrue(ScenarioTestHelper.AreEqual(DefaultConfigSet, CommandComponents.ConfigSet)); }
public void RegisterCustomBadRequestExceptionChecker_MultiAddWithSameNameOnlyUseTheFirstAddAndIngoreTheLatters() { HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(NormalCheckerName, IsBadRequestException); HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(NormalCheckerName, IsBadRequestExceptionWithException); Assert.AreNotEqual(IsBadRequestException, IsBadRequestExceptionWithException); Assert.AreEqual(IsBadRequestException, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName]); Assert.AreNotEqual(IsBadRequestExceptionWithException, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName]); }
public void RunCommandSuccessAndFallbackSuccess() { string expected = string.Empty; string fallback = null; string actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, () => expected, () => fallback); Assert.AreEqual(expected, actual); }
public void RegisterCustomBadRequestExceptionChecker_IgnoreNameCase() { HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(NormalCheckerName, IsBadRequestException); Assert.AreEqual(1, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers.Count); Assert.AreEqual(IsBadRequestException, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName]); Assert.AreEqual(CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName], CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName.ToUpper()]); Assert.AreEqual(CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName], CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName.ToLower()]); }
public void CircuitBreakerOpenCausedByTimeout() { int timeoutInMilliseconds = 10; CommandComponents.ConfigSet.CommandTimeoutInMilliseconds = timeoutInMilliseconds; string expected = string.Empty; string actual; Func <string> execute = () => { Thread.Sleep(timeoutInMilliseconds + 2); return(expected); }; for (int i = 0; i < CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold; i++) { ScenarioTestHelper.SleepHealthSnapshotInverval(); actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, execute); Assert.AreEqual(expected, actual); } for (int i = 0; i < 10; i++) { try { ScenarioTestHelper.SleepHealthSnapshotInverval(); HystrixCommandBase.RunCommand <string>(TestCommandKey, execute); var snapshot = CommandComponents.Metrics.GetExecutionEventDistribution(); Assert.Fail("Execution should throw exception."); } catch (HystrixException ex) { Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } } Thread.Sleep(CommandComponents.ConfigSet.CircuitBreakerSleepWindowInMilliseconds + 1); actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, execute); Assert.AreEqual(expected, actual); try { ScenarioTestHelper.SleepHealthSnapshotInverval(); HystrixCommandBase.RunCommand <string>(TestCommandKey, execute); Assert.Fail("Execution should throw exception."); } catch (HystrixException ex) { Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } Thread.Sleep(CommandComponents.ConfigSet.CircuitBreakerSleepWindowInMilliseconds + 1); actual = HystrixCommandBase.RunCommand <string>(TestCommandKey, () => expected); Assert.AreEqual(expected, actual); }
public void CustomBadRequestExecuteFallback() { HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(NormalCheckerName, IsBadRequestException); SampleHasFallbackIsolationCommand command = new SampleHasFallbackIsolationCommand( TestCommandKey, execute: () => { throw new ArgumentOutOfRangeException(); }, fallback: () => string.Empty); command.Run(); }
public void RegisterCustomBadRequestExceptionChecker_AddCustomCheckerSuccess() { Assert.AreEqual(0, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers.Count); HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(NormalCheckerName, IsBadRequestException); Assert.AreEqual(1, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers.Count); Assert.AreEqual(IsBadRequestException, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName]); HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(WithExceptionCheckerName, IsBadRequestExceptionWithException); Assert.AreEqual(2, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers.Count); Assert.AreEqual(IsBadRequestException, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[NormalCheckerName]); Assert.AreEqual(IsBadRequestExceptionWithException, CustomBadRequestExceptionChecker.BadRequestExceptionCheckers[WithExceptionCheckerName]); }
public void CustomBadRequestNotExecuteFallback_CheckerThrowException() { HystrixCommandBase.RegisterCustomBadRequestExceptionChecker(WithExceptionCheckerName, IsBadRequestExceptionWithException); SampleHasFallbackIsolationCommand command = new SampleHasFallbackIsolationCommand( TestCommandKey, execute: () => { throw new ArgumentOutOfRangeException(); }, fallback: () => string.Empty); string result = command.Run(); Assert.AreEqual(string.Empty, result); }
private void RunToExceptionNormally() { ScenarioTestHelper.SleepHealthSnapshotInverval(); try { HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (ScenarioTestException) { } }
private void RunToTimeoutShortCircuited() { ScenarioTestHelper.SleepHealthSnapshotInverval(); try { HystrixCommandBase.RunCommand <string>(TestCommandKey, ExecuteTimeout); } catch (HystrixException ex) { Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } }
public void CircuitBreakerForceOpenIsTrueWithoutFallback() { CommandComponents.ConfigSet.ToConcrete().CircuitBreakerForceOpen = true; try { HystrixCommandBase.RunCommand <string>(TestCommandKey, () => string.Empty); Assert.Fail("Execution should throw exception."); } catch (HystrixException ex) { Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } }
public void TestAsyncCommandSuccessful() { Console.WriteLine(13 % 2); var result = HystrixCommandBase.RunCommandAsync <bool>("testasync", () => { return(true); }, () => { return(false); }); Assert.AreEqual(true, result.Result); }
private void RunToExceptionShortCircuited() { ScenarioTestHelper.SleepHealthSnapshotInverval(); try { HystrixCommandBase.RunCommand <string>(TestCommandKey, () => { throw new ScenarioTestException(); }); Assert.Fail("Execution should throw exception."); } catch (HystrixException ex) { Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType); } }