public void Config_Key_Config()
{
SL.Config(TestCommandKey, configSet => ScenarioTestHelper.SetCommandConfigFrom(configSet, CustomConfigSet));
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(CustomConfigSet, CommandComponents.ConfigSet));
}
public void Config_Key_Group()
{
SL.Config(TestCommandKey, TestGroupKey);
Assert.AreEqual(TestCommandKey, CommandComponents.CommandInfo.Key, true);
Assert.AreEqual(TestGroupKey, CommandComponents.CommandInfo.GroupKey, true);
Assert.AreEqual(CommandDomains.Default, CommandComponents.CommandInfo.Domain, true);
Assert.IsTrue(ScenarioTestHelper.AreEqual(DefaultConfigSet, CommandComponents.ConfigSet));
}
public void Config_Key_Group_Domain_Config_Custom()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain, configSet => ScenarioTestHelper.SetCommandConfigFrom(configSet, CustomConfigSet));
Assert.AreEqual(TestCommandKey, CommandComponents.CommandInfo.Key, true);
Assert.AreEqual(TestGroupKey, CommandComponents.CommandInfo.GroupKey, true);
Assert.AreEqual(TestDomain, CommandComponents.CommandInfo.Domain, true);
Assert.IsTrue(ScenarioTestHelper.AreEqual(CustomConfigSet, CommandComponents.ConfigSet));
}
public void Config_Key_Group_Domain_Config_Default()
{
SL.Config(TestCommandKey, null, null, 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 Config_Key_Group_Domain_MaxConcurrentCount()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain, CustomConfigSet.CommandMaxConcurrentCount);
Assert.AreEqual(TestCommandKey, CommandComponents.CommandInfo.Key, true);
Assert.AreEqual(TestGroupKey, CommandComponents.CommandInfo.GroupKey, true);
Assert.AreEqual(TestDomain, CommandComponents.CommandInfo.Domain, true);
Assert.AreEqual(CustomConfigSet.CommandMaxConcurrentCount, CommandComponents.ConfigSet.CommandMaxConcurrentCount);
}
public void Execution_ShortCircuited_ByFailureAndTimeout()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain);
CommandComponents.ConfigSet.InitTestHealthSnapshotInterval();
CommandComponents.ConfigSet.CommandTimeoutInMilliseconds = TimeoutInMilliseconds;
for (int i = 0; i < DefaultConfigSet.CircuitBreakerRequestCountThreshold; i++)
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
using (SL instance = new SL(TestCommandKey))
{
ScenarioTestHelper.SleepHealthSnapshotInverval();
instance.StartExecution();
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount - 1, TestSemaphore.CurrentCount);
if (i % 2 == 0)
{
if (i % 4 == 0)
{
instance.MarkFailure();
continue;
}
Thread.Sleep(TimeoutInMilliseconds + 2);
}
instance.MarkSuccess();
}
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
}
try
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
using (SL instance = new SL(TestCommandKey))
{
ScenarioTestHelper.SleepHealthSnapshotInverval();
try
{
instance.StartExecution();
Assert.Fail("Short circuited exception should be thrown before.");
}
finally
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
}
}
}
catch (HystrixException ex)
{
Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType);
}
}
public void Config_EmptyKey()
{
foreach (string key in EmptyStrings)
{
try
{
SL.Config(key, null, null, config => { });
Assert.Fail("Empty key should cause ArgumentNullException");
}
catch (ArgumentNullException)
{
}
}
}
public void Config_Key_Group_Domain_MaxConcurrentCount_Timeout_RequestCountThreshold_ErrorThresholdPercentage_FallbackMaxConcurrentCount()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain,
CustomConfigSet.CommandMaxConcurrentCount, CustomConfigSet.CommandTimeoutInMilliseconds,
CustomConfigSet.CircuitBreakerRequestCountThreshold, CustomConfigSet.CircuitBreakerErrorThresholdPercentage,
CustomConfigSet.FallbackMaxConcurrentCount);
Assert.AreEqual(TestGroupKey, CommandComponents.CommandInfo.GroupKey, true);
Assert.AreEqual(TestDomain, CommandComponents.CommandInfo.Domain, true);
Assert.IsFalse(ScenarioTestHelper.AreEqual(CustomConfigSet, CommandComponents.ConfigSet));
Assert.AreEqual(CustomConfigSet.CommandMaxConcurrentCount, CommandComponents.ConfigSet.CommandMaxConcurrentCount);
Assert.AreEqual(CustomConfigSet.CommandTimeoutInMilliseconds, CommandComponents.ConfigSet.CommandTimeoutInMilliseconds);
Assert.AreEqual(CustomConfigSet.CircuitBreakerRequestCountThreshold, CommandComponents.ConfigSet.CircuitBreakerRequestCountThreshold);
Assert.AreEqual(CustomConfigSet.CircuitBreakerErrorThresholdPercentage, CommandComponents.ConfigSet.CircuitBreakerErrorThresholdPercentage);
Assert.AreEqual(CustomConfigSet.FallbackMaxConcurrentCount, CommandComponents.ConfigSet.FallbackMaxConcurrentCount);
}
public void MarkBadRequest_RunOnce()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain);
CommandComponents.ConfigSet.InitTestHealthSnapshotInterval();
for (int i = 1; i <= DefaultConfigSet.CircuitBreakerRequestCountThreshold; i++)
{
using (SL instance = new SL(TestCommandKey))
{
instance.StartExecution();
instance.MarkBadRequest();
ScenarioTestHelper.SleepHealthSnapshotInverval();
Dictionary <CommandExecutionEventEnum, int> counts = CommandComponents.Metrics.ToConcrete().GetExecutionEventDistribution();
Assert.AreEqual(i, counts[CommandExecutionEventEnum.BadRequest]);
}
}
}
public void MarkBadRequest_WithInstance()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain);
CommandComponents.ConfigSet.InitTestHealthSnapshotInterval();
object instance = SL.CreateInstance(TestCommandKey);
Assert.AreEqual(CommandComponents.ConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
SL.StartExecution(instance);
Assert.AreEqual(CommandComponents.ConfigSet.CommandMaxConcurrentCount - 1, TestSemaphore.CurrentCount);
SL.MarkBadRequest(instance);
Assert.AreEqual(CommandComponents.ConfigSet.CommandMaxConcurrentCount - 1, TestSemaphore.CurrentCount);
ScenarioTestHelper.SleepHealthSnapshotInverval();
Dictionary <CommandExecutionEventEnum, int> counts = CommandComponents.Metrics.ToConcrete().GetExecutionEventDistribution();
Assert.AreEqual(1, counts[CommandExecutionEventEnum.BadRequest]);
SL.EndExecution(instance);
Assert.AreEqual(CommandComponents.ConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
}
public void Execution_ShortCircuited_AutoRecover_WithInstance()
{
SL.Config(TestCommandKey, TestGroupKey, TestDomain);
CommandComponents.ConfigSet.InitTestHealthSnapshotInterval();
for (int i = 0; i < DefaultConfigSet.CircuitBreakerRequestCountThreshold; i++)
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
object instance = SL.CreateInstance(TestCommandKey);
ScenarioTestHelper.SleepHealthSnapshotInverval();
SL.StartExecution(instance);
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount - 1, TestSemaphore.CurrentCount);
SL.MarkFailure(instance);
SL.EndExecution(instance);
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
}
for (int i = 0; i < 10; i++)
{
try
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
object instance = SL.CreateInstance(TestCommandKey);
ScenarioTestHelper.SleepHealthSnapshotInverval();
try
{
SL.StartExecution(instance);
Assert.Fail("Short circuited exception should be thrown before.");
}
catch (HystrixException)
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
throw;
}
}
catch (HystrixException ex)
{
Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType);
}
}
Thread.Sleep(DefaultConfigSet.CircuitBreakerSleepWindowInMilliseconds + 10);
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
object instance = SL.CreateInstance(TestCommandKey);
ScenarioTestHelper.SleepHealthSnapshotInverval();
SL.StartExecution(instance);
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount - 1, TestSemaphore.CurrentCount);
SL.MarkFailure(instance);
SL.EndExecution(instance);
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
}
for (int i = 0; i < 10; i++)
{
try
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
object instance = SL.CreateInstance(TestCommandKey);
ScenarioTestHelper.SleepHealthSnapshotInverval();
try
{
SL.StartExecution(instance);
Assert.Fail("Short circuited exception should be thrown before.");
}
catch (HystrixException)
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
throw;
}
}
catch (HystrixException ex)
{
Assert.AreEqual(FailureTypeEnum.ShortCircuited, ex.FailureType);
}
}
Thread.Sleep(DefaultConfigSet.CircuitBreakerSleepWindowInMilliseconds + 10);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
object instance = SL.CreateInstance(TestCommandKey);
SL.StartExecution(instance);
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount - 1, TestSemaphore.CurrentCount);
SL.MarkSuccess(instance);
SL.EndExecution(instance);
Assert.AreEqual(DefaultConfigSet.CommandMaxConcurrentCount, TestSemaphore.CurrentCount);
}
}
