public void MakeParseOperation_LineParseIsSuccessful_EndsLineParse(string[][] configData)
{
var testContext = new TestContext()
{
Config = BuildConfig(configData)
};
foreach (var handlerIndex in Enumerable.Repeat(0, 3))
{
testContext.AddFakeConfigParseHandler(ParseResult.Success);
}
testContext.Uut.MakeParseOperation()
.ShouldRunToCompletion(testContext.MockBackgroundWorker);
foreach (var configLineData in configData)
{
foreach (var mockConfigParseHandler in testContext.MockConfigParseHandlers)
{
mockConfigParseHandler.ShouldHaveReceived(x => x.OnStarting(), 1);
mockConfigParseHandler.ShouldHaveReceived(x => x.OnCompleted(), 1);
}
testContext.MockConfigParseHandlers[0]
.ShouldHaveReceivedOnParsing(new ConfigLine(configLineData));
foreach (var mockConfigParseHandler in testContext.MockConfigParseHandlers.Skip(1))
{
mockConfigParseHandler.ShouldNotHaveReceived(x => x.OnParsing(It.IsAny <ConfigLine>()));
}
}
testContext.MockLogger.ShouldNotHaveReceived(x => x.AddLine(It.IsAny <string>()));
}
public void MakeParseOperation_LineIsIgnored_LogsError(string[][] configData)
{
var testContext = new TestContext()
{
Config = BuildConfig(configData)
};
foreach (var _ in Enumerable.Repeat(0, 3))
{
testContext.AddFakeConfigParseHandler(ParseResult.Ignored);
}
testContext.Uut.MakeParseOperation()
.ShouldRunToCompletion(testContext.MockBackgroundWorker);
foreach (var configLineData in configData)
{
foreach (var mockConfigParseHandler in testContext.MockConfigParseHandlers)
{
mockConfigParseHandler.ShouldHaveReceived(x => x.OnStarting(), 1);
mockConfigParseHandler.ShouldHaveReceivedOnParsing(new ConfigLine(configLineData));
mockConfigParseHandler.ShouldHaveReceived(x => x.OnCompleted(), 1);
}
testContext.MockLogger.ShouldHaveReceived(x => x.AddLine(It.Is <string>(y => y.Contains(BuildConfigLine(configLineData)))));
}
}
public void MakeParseOperation_Always_SplitsLinesAndParamsCorrectly(string[][] configData)
{
var testContext = new TestContext()
{
Config = BuildConfig(configData)
};
var mockConfigParseHandler = testContext.AddFakeConfigParseHandler(ParseResult.Success);
var configLines = new List <ConfigLine>();
mockConfigParseHandler
.Setup(x => x.OnParsing(It.IsAny <ConfigLine>()))
.Callback <ConfigLine>(x => configLines.Add(x))
.Returns(ParseResult.Success);
testContext.Uut.MakeParseOperation()
.ShouldRunToCompletion(testContext.MockBackgroundWorker);
configLines.Count.ShouldBe(configData.Length);
foreach (var i in Enumerable.Range(0, configLines.Count))
{
var expectedConfigLine = new ConfigLine(configData[i]);
configLines[i].Option.ShouldBe(expectedConfigLine.Option);
configLines[i].ParamCount.ShouldBe(expectedConfigLine.ParamCount);
foreach (var index in Enumerable.Range(0, configLines[i].ParamCount))
{
configLines[i].GetParam(index).ShouldBe(expectedConfigLine.GetParam(index));
}
}
}
public void MakeParseOperation_LineParseIsError_LogsErrorAndEndsLineParse(string[][] configData)
{
var testContext = new TestContext()
{
Config = BuildConfig(configData)
};
var errorText = "errorText";
foreach (var handlerIndex in Enumerable.Repeat(0, 3))
{
testContext.AddFakeConfigParseHandler(ParseResult.FromError($"{errorText}{handlerIndex}"));
}
testContext.Uut.MakeParseOperation()
.ShouldRunToCompletion(testContext.MockBackgroundWorker);
foreach (var configLineData in configData)
{
foreach (var mockConfigParseHandler in testContext.MockConfigParseHandlers)
{
mockConfigParseHandler.ShouldHaveReceived(x => x.OnStarting(), 1);
mockConfigParseHandler.ShouldHaveReceived(x => x.OnCompleted(), 1);
}
testContext.MockConfigParseHandlers[0]
.ShouldHaveReceivedOnParsing(new ConfigLine(configLineData));
foreach (var mockConfigParseHandler in testContext.MockConfigParseHandlers.Skip(1))
{
mockConfigParseHandler.ShouldNotHaveReceived(x => x.OnParsing(It.IsAny <ConfigLine>()));
}
testContext.MockLogger.ShouldHaveReceived(x => x.AddLine(It.Is <string>(y =>
y.Contains(BuildConfigLine(configLineData)) &&
y.Contains($"{errorText}0"))));
foreach (var i in Enumerable.Range(0, testContext.MockConfigParseHandlers.Count).Skip(1))
{
testContext.MockLogger.ShouldNotHaveReceived(x => x.AddLine(It.Is <string>(y =>
y.Contains(BuildConfigLine(configLineData)) &&
y.Contains($"{errorText}{i}"))));
}
}
}
public void MakeParseOperation_ConfigIsEmptyOrWhitespace_CompletesAfterStarting(string config)
{
var testContext = new TestContext()
{
Config = config
};
testContext.AddFakeConfigParseHandler(ParseResult.Ignored);
testContext.Uut.MakeParseOperation()
.ShouldRunToCompletion(testContext.MockBackgroundWorker);
foreach (var mockConfigParseHandler in testContext.MockConfigParseHandlers)
{
mockConfigParseHandler.ShouldHaveReceived(x => x.OnStarting(), 1);
mockConfigParseHandler.ShouldNotHaveReceived(x => x.OnParsing(It.IsAny <ConfigLine>()));
mockConfigParseHandler.ShouldHaveReceived(x => x.OnCompleted(), 1);
}
testContext.MockLogger.ShouldNotHaveReceived(x => x.AddLine(It.IsAny <string>()));
}
public void MakeParseOperation_OperationIsDisposed_OperationIsRecycled(string[][] configData)
{
var testContext = new TestContext()
{
Config = BuildConfig(configData)
};
testContext.AddFakeConfigParseHandler(ParseResult.Success);
var result = testContext.Uut.MakeParseOperation();
result.ShouldRunToCompletion(testContext.MockBackgroundWorker);
var mockConfigParseHandlersInvocations = testContext.MockConfigParseHandlers
.Select(x => x.Invocations.ToArray())
.ToArray();
result.ShouldBeAssignableTo <IDisposable>();
(result as IDisposable).Dispose();
testContext.MockConfigParseHandlers
.ForEach(x => x.Invocations.Clear());
testContext.Uut.MakeParseOperation()
.ShouldBeSameAs(result);
result.ShouldRunToCompletion(testContext.MockBackgroundWorker);
foreach (var i in Enumerable.Range(0, testContext.MockConfigParseHandlers.Count))
{
testContext.MockConfigParseHandlers[i].Invocations.Count.ShouldBe(mockConfigParseHandlersInvocations[i].Length);
foreach (var j in Enumerable.Range(0, mockConfigParseHandlersInvocations.Length))
{
testContext.MockConfigParseHandlers[i].Invocations[j].ShouldBe(mockConfigParseHandlersInvocations[i][j]);
}
}
}
