public void Create_WithValidSetting_ReturnsProcessor()
{
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Loose);
HashSet <string> steps = new HashSet <string> {
"A"
};
string setting = "{ type : 'RequestProcessor', value : { errorSize : 100, latency : 42, steps : [ 'A' ], successSize : 20 }}";
var logger = new Mock <ILogger <NestedConfigFactory <IProcessor, IProcessor> > >(MockBehavior.Loose);
var factory = new NestedConfigFactory <IProcessor, IProcessor>(logger.Object, loggerFactory.Object);
IProcessor processor = factory.Create(setting);
Assert.IsNotNull(processor);
IRequestProcessor reqProcessor = processor as IRequestProcessor;
Assert.IsNotNull(reqProcessor, "Processor should not be null");
Assert.AreEqual(100, reqProcessor.ErrorPayloadSize, "Error size should be set correctly");
Assert.AreEqual(42, reqProcessor.IngressLatencyMilliseconds, "Latency should be set correctly");
Assert.AreEqual(steps.Count, reqProcessor.Steps.Count, "Steps should have the correct number of entries");
Assert.IsTrue(steps.SetEquals(reqProcessor.Steps), "Steps should be set correctly");
Assert.AreEqual(20, reqProcessor.SuccessPayloadSize, "Success size should be set correctly");
Assert.AreEqual(50, reqProcessor.ErrorPayload.Error.Length, "Error payload should be the correct size");
var resultList = reqProcessor.SuccessPayload.Result as List <string>;
Assert.IsNotNull(resultList);
Assert.AreEqual(1, resultList.Count, "Success result should be the correct length");
Assert.AreEqual(10, resultList[0].Length, "Success payload should be the correct size");
}
public void Create_WithNullName_ThrowsException()
{
var logger = new Mock <ILogger <NestedConfigFactory <IStep, IStep> > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IStep, IStep>(logger.Object, loggerFactory.Object);
Assert.ThrowsException <ArgumentException>(
() => factory.Create(null), "Create should throw.");
}
public void Create_WithNullName_ThrowsException()
{
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Loose);
var logger = new Mock <ILogger <NestedConfigFactory <IProcessor, IProcessor> > >(MockBehavior.Loose);
var factory = new NestedConfigFactory <IProcessor, IProcessor>(logger.Object, loggerFactory.Object);
Assert.ThrowsException <ArgumentException>(
() => factory.Create(null));
}
public void Create_WithNullName_ThrowsException()
{
var logger = new Mock <ILogger <NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> > > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> >(
logger.Object, loggerFactory.Object);
Assert.ThrowsException <ArgumentException>(
() => factory.Create(null), "Create should throw.");
}
public void Create_WithMissingStepValue_Throws()
{
string setting = "{ type : 'LoadStep' }";
var logger = new Mock <ILogger <NestedConfigFactory <IStep, IStep> > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IStep, IStep>(logger.Object, loggerFactory.Object);
Assert.ThrowsException <InvalidOperationException>(
() => factory.Create(setting), "Create should throw");
}
public void Create_WithUnknownType_ThrowsException()
{
string setting = "{ type : 'FrontStep', value : { time : 10, percent : 20 } }";
var logger = new Mock <ILogger <NestedConfigFactory <IStep, IStep> > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IStep, IStep>(logger.Object, loggerFactory.Object);
Assert.ThrowsException <InvalidOperationException>(
() => factory.Create(setting), "Create should throw");
}
public void Create_WithMissingValueJson_Throws()
{
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Loose);
string setting = "{ type : 'RequestProcessor' }";
var logger = new Mock <ILogger <NestedConfigFactory <IProcessor, IProcessor> > >(MockBehavior.Loose);
var factory = new NestedConfigFactory <IProcessor, IProcessor>(logger.Object, loggerFactory.Object);
Assert.ThrowsException <InvalidOperationException>(
() => factory.Create(setting));
}
public void Create_WithMissingPolicyValue_Throws()
{
string setting = "{ type : 'RetryConfig' }";
var logger = new Mock <ILogger <NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> > > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> >(
logger.Object, loggerFactory.Object);
Assert.ThrowsException <InvalidOperationException>(
() => factory.Create(setting), "Create should throw");
}
public void Create_WithInvalidStep_ReturnsNull()
{
string setting = "{ type : 'LoadStep', value : { } }";
var logger = new Mock <ILogger <NestedConfigFactory <IStep, IStep> > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IStep, IStep>(logger.Object, loggerFactory.Object);
IStep step = factory.Create(setting);
Assert.IsNull(step, "Step should be null");
}
public void Create_WithNonJsonData_ReturnsNull()
{
string setting = "???";
var logger = new Mock <ILogger <NestedConfigFactory <IStep, IStep> > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IStep, IStep>(logger.Object, loggerFactory.Object);
IStep step = factory.Create(setting);
Assert.IsNull(step, "Step should be null");
}
public void Create_WithEmptyValueJson_ReturnsNull()
{
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Loose);
string setting = "{ type : 'RequestProcessor', value : {} }";
var logger = new Mock <ILogger <NestedConfigFactory <IProcessor, IProcessor> > >(MockBehavior.Loose);
var factory = new NestedConfigFactory <IProcessor, IProcessor>(logger.Object, loggerFactory.Object);
IProcessor processor = factory.Create(setting);
Assert.IsNull(processor);
}
public void Create_WithNonJsonData_ReturnsNull()
{
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Loose);
string setting = "???";
var logger = new Mock <ILogger <NestedConfigFactory <IProcessor, IProcessor> > >(MockBehavior.Loose);
var factory = new NestedConfigFactory <IProcessor, IProcessor>(logger.Object, loggerFactory.Object);
IProcessor processor = factory.Create(setting);
Assert.IsNull(processor, "Processor should be null");
}
public void Create_WithErronousSetting_ReturnsNull()
{
string setting = "{ }";
var logger = new Mock <ILogger <NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> > > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
var factory = new NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> >(
logger.Object, loggerFactory.Object);
IAsyncPolicy <HttpResponseMessage> policy = factory.Create(setting);
Assert.IsNull(policy, "IAsyncPolicy<HttpResponseMessage> should be null");
}
public void Create_WithValidSetting_ReturnsPolicy()
{
string setting = "{ type : 'RetryConfig', value : { retries : 1, delays : [ 2 ] } }";
var logger = new Mock <ILogger <NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> > > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
// Mock string implementation, called by extenstion method that takes Type
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(new Mock <ILogger>().Object);
var factory = new NestedConfigFactory <IPolicyConfiguration, IAsyncPolicy <HttpResponseMessage> >(
logger.Object, loggerFactory.Object);
IAsyncPolicy <HttpResponseMessage> policy = factory.Create(setting);
Assert.IsNotNull(policy, "IAsyncPolicy<HttpResponseMessage> should not be null");
Assert.IsInstanceOfType(policy, typeof(AsyncRetryPolicy <HttpResponseMessage>),
"IAsyncPolicy<HttpResponseMessage> should be a RetryPolicy instance");
}
public void Create_WithValidSetting_ReturnsStep()
{
string setting = "{ type : 'LoadStep', value : { bytes : 2, time : 10, percent : 20 } }";
var logger = new Mock <ILogger <NestedConfigFactory <IStep, IStep> > >(MockBehavior.Loose);
var loggerFactory = new Mock <ILoggerFactory>(MockBehavior.Strict);
// Mock string implementation, called by extenstion method that takes Type
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(new Mock <ILogger>().Object);
var factory = new NestedConfigFactory <IStep, IStep>(logger.Object, loggerFactory.Object);
IStep step = factory.Create(setting);
Assert.IsNotNull(step, "Step should not be null");
Assert.IsInstanceOfType(step, typeof(LoadStep), "Step should be a LoadStep instance");
LoadStep loadStep = step as LoadStep;
Assert.AreEqual(10, loadStep.TimeInSeconds, "Time should be set correctly");
Assert.AreEqual(20, loadStep.CpuPercentage, "Percentage should be set correctly");
}
