public void Execute(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_key);
testCaseContext.DescriptionWriter.AddNote("AssertItem", $"{effectiveItemKey}");
testCaseContext.AssertContent(testCaseContext.GetRequiredItem(effectiveItemKey), _path);
}
public async Task ExecuteAsync(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_itemKey);
testCaseContext.DescriptionWriter.AddNote("AssertContent", $"{effectiveItemKey} => file:{_fileName}");
var token = testCaseContext.GetRequiredItemAsJToken(_itemKey);
if (!string.IsNullOrEmpty(_jsonPath))
{
var jsonPath = testCaseContext.Resolve(_jsonPath);
token = new JArray(token.SelectTokens(jsonPath));
}
if (_replaceGroups != null)
{
token = token.DeepClone();
var groups = await testCaseContext.TestCase.GetObjectFromJsonAsync <Dictionary <string, IReadOnlyCollection <string> > >(_replaceGroups);
testCaseContext.ReplaceTokens(token, groups);
}
await testCaseContext.AssertContentAsync(token, _fileName);
}
public void Get_Error()
{
// Arrange
var context = new TestCaseContext();
var sut = new LocaleController(
context.Logger,
context.SessionManager);
Mock.Get(context.Session.LocaleManager).Setup(
m => m.GetLocale())
.Throws(new Exception("message"));
// Act
var actionResult = sut.Get(context.Session.Id);
// Assert
Assert.NotNull(actionResult);
var objectResult = actionResult.Result as ObjectResult;
Assert.NotNull(objectResult);
Assert.Equal(500, objectResult.StatusCode);
var result = objectResult.Value as ApiResponse <GetLocaleResponse>;
Assert.NotNull(result);
Assert.False(result.Success);
Assert.NotNull(result.Error);
Assert.Null(result.Payload);
}
public void Get_Success()
{
// Arrange
var context = new TestCaseContext();
var sut = new LocaleController(
context.Logger,
context.SessionManager);
var locale = "ru-ru";
Mock.Get(context.Session.LocaleManager).Setup(
m => m.GetLocale())
.Returns(locale);
// Act
var actionResult = sut.Get(context.Session.Id);
// Assert
Assert.NotNull(actionResult);
var objectResult = actionResult.Result as ObjectResult;
Assert.NotNull(objectResult);
Assert.Equal(200, objectResult.StatusCode);
var result = objectResult.Value as ApiResponse <GetLocaleResponse>;
Assert.NotNull(result);
Assert.True(result.Success);
Assert.Null(result.Error);
var payload = result.Payload;
Assert.NotNull(payload);
Assert.Equal(locale, payload.Locale);
}
public async Task Get_Error()
{
// Arrange
var context = new TestCaseContext();
var sut = new VarsController(
context.Logger,
context.SessionManager);
Mock.Get(context.Session.VarsManager).Setup(
m => m.GetAllVars(true))
.Throws(new Exception("message"));
// Act
var actionResult = await sut.Get(
context.Session.Id,
CancellationToken.None);
// Assert
Assert.NotNull(actionResult);
var objectResult = actionResult.Result as ObjectResult;
Assert.NotNull(objectResult);
Assert.Equal(500, objectResult.StatusCode);
var result = objectResult.Value as ApiResponse <GetVarsResponse>;
Assert.NotNull(result);
Assert.False(result.Success);
Assert.NotNull(result.Error);
Assert.Null(result.Payload);
}
public void Execute(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_key);
testCaseContext.DescriptionWriter.AddNote("UseItemKey", $"{effectiveItemKey}");
testCaseContext.SetItemKey(effectiveItemKey);
}
public async Task Image_Success()
{
// Arrange
var context = new TestCaseContext(AssetType.Image, Result.Success);
var sut = new AssetsController(
context.Logger,
context.SessionManager);
// Act
var actionResult = await sut.Image(
context.Session.Id,
ApiRequest <GetAssetRequest> .Make(new GetAssetRequest {
Key = context.AssetKey
}),
CancellationToken.None);
// Assert
Assert.NotNull(actionResult);
var objectResult = actionResult.Result as ObjectResult;
Assert.NotNull(objectResult);
Assert.Equal(200, objectResult.StatusCode);
var result = objectResult.Value as ApiResponse <ImageAssetResponse>;
Assert.NotNull(result);
Assert.True(result.Success);
Assert.Null(result.Error);
var payload = result.Payload;
Assert.NotNull(payload);
Assert.Equal(context.AssetKey, payload.Key);
Assert.Equal(context.Asset.Descriptor.MediaType, payload.MediaType);
Assert.Equal(context.Asset.Descriptor.SourceUrl, payload.SourceUrl);
}
public void Execute(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_key);
testCaseContext.DescriptionWriter.AddNote("SaveItem", $"{effectiveItemKey} => file: {_path}");
testCaseContext.TestCase.PutContent(_path, testCaseContext.GetRequiredItem(effectiveItemKey));
}
public void GetAllVars()
{
// Arrange
var context = new TestCaseContext();
var sut = new VarsManager(
context.OptionsService,
context.Logger);
var random = new Random();
int varsCount = 5;
var vars = new List <IVar>();
for (int i = 0; i < varsCount; ++i)
{
vars.Add(new IntVar(
$"key{i}",
$"var-name{i}",
random.Next(-100, 100)));
}
// Act
foreach (var v in vars)
{
sut.AddVar(v);
}
var actual = sut.GetAllVars();
// Assert
Assert.Equal(vars, actual);
}
public async Task ApplyTransition_NextStateKeyOverride()
{
// Arrange
var context = new TestCaseContext();
var sut = new StateMachineManager(
context.OptionsService,
context.Logger,
context.DataService);
Mock.Get(context.DataService).Setup(
m => m.RunOnTransitionScript(context.InitialState, context.Transition, It.IsAny <CancellationToken>()))
.ReturnsAsync(new OnTransitionOutput {
NextStateKeyOverride = context.State2Key
});
// Act
await sut.SetInitialState();
await sut.ApplyTransition(context.TransitionKey);
var currentState = sut.GetCurrentState();
// Assert
Assert.Same(context.State2, currentState);
Mock.Get(context.DataService).Verify(
m => m.RunOnTransitionScript(context.InitialState, context.Transition, It.IsAny <CancellationToken>()),
Times.Once);
Mock.Get(context.DataService).Verify(
m => m.RunOnLeaveStateScript(context.InitialState, It.IsAny <CancellationToken>()),
Times.Once);
Mock.Get(context.DataService).Verify(
m => m.RunOnEnterStateScript(context.State2, It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task SetCurrentState(bool leaveCurrentState)
{
// Arrange
var context = new TestCaseContext();
var sut = new StateMachineManager(
context.OptionsService,
context.Logger,
context.DataService);
// Act
await sut.SetInitialState();
await sut.SetCurrentState(context.State1Key, leaveCurrentState);
var currentState = sut.GetCurrentState();
// Assert
Assert.Same(context.State1, currentState);
var times = leaveCurrentState ? Times.Once() : Times.Never();
Mock.Get(context.DataService).Verify(
m => m.RunOnLeaveStateScript(context.InitialState, It.IsAny <CancellationToken>()),
times);
Mock.Get(context.DataService).Verify(
m => m.RunOnEnterStateScript(context.State1, It.IsAny <CancellationToken>()),
Times.Once);
}
public void Post_Success()
{
// Arrange
var context = new TestCaseContext();
var sut = new PingController(
context.Logger,
context.SessionManager);
// Act
var actionResult = sut.Post(context.Session.Id);
// Assert
Assert.NotNull(actionResult);
var objectResult = actionResult.Result as ObjectResult;
Assert.NotNull(objectResult);
Assert.Equal(200, objectResult.StatusCode);
var result = objectResult.Value as ApiResponse <EmptyPayload>;
Assert.NotNull(result);
Assert.True(result.Success);
Assert.Null(result.Error);
var payload = result.Payload;
Assert.Null(payload);
Mock.Get(context.SessionManager).Verify(
m => m.PingSession(context.Session.Id),
Times.Once);
}
public void Init()
{
// Arrange
var context = new TestCaseContext();
var sut = new VarsManager(
context.OptionsService,
context.Logger);
var userName = "******";
var vars = new List <IVar>
{
new IntVar("v1", "v1-name", 0),
new IntVar("v2", "v2-name", 1),
new IntVar("v3", "v3-name", 2),
};
// Act
sut.Init(userName, vars);
var allVars = sut.GetAllVars();
var userNameVar = sut.GetVar <StringVar>(context.Options.UserNameVarKey);
// Assert
Assert.Equal(vars.Count + 1, allVars.Count());
Assert.Equal(userName, userNameVar.Value);
}
public override void Execute(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_key);
var item = testCaseContext.GetRequiredItem(effectiveItemKey);
testCaseContext.Logger.LogInformation(item);
}
public async Task Image_Exception_ApiError()
{
// Arrange
var context = new TestCaseContext(AssetType.Image, Result.ApiError);
var sut = new AssetsController(
context.Logger,
context.SessionManager);
// Act
var actionResult = await sut.Image(
context.Session.Id,
ApiRequest <GetAssetRequest> .Make(new GetAssetRequest {
Key = context.AssetKey
}),
CancellationToken.None);
// Assert
Assert.NotNull(actionResult);
var objectResult = actionResult.Result as ObjectResult;
Assert.NotNull(objectResult);
Assert.Equal(500, objectResult.StatusCode);
var result = objectResult.Value as ApiResponse <ImageAssetResponse>;
Assert.NotNull(result);
Assert.False(result.Success);
Assert.NotNull(result.Error);
Assert.Null(result.Payload);
}
public async Task ExecuteAsync(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_itemKey);
testCaseContext.DescriptionWriter.AddNote("AssertContentDiff", $"{effectiveItemKey} => file: {_diffName}, base: {_baseFile}");
var actual = testCaseContext.GetRequiredItemAsJToken(effectiveItemKey);
if (!string.IsNullOrEmpty(_jsonPath))
{
actual = new JArray(actual.SelectTokens(_jsonPath));
}
var testCase = testCaseContext.TestCase;
var expectedBase = await testCase.GetObjectFromJsonAsync <JToken>(_baseFile);
var diffs = JsonPatchCreator.Compare(expectedBase, actual, _tokenSelectorProvider);
(var mismatches, var expected) = await testCase.CompareAndRebaseAsync(actual, expectedBase, diffs, _diffName, _tokenSelectorProvider, testCaseContext.Options.IsRebaseline());
if (mismatches.Count > 0)
{
var matchedDiffCategories = testCaseContext.GetDiffCategories(actual, expected, _categoriesFile);
throw new AssertException("Unexpected token changes:" + string.Join("\n", mismatches.Select(d => d.JsonPath)), matchedDiffCategories);
}
}
public async Task ExecuteAsync(TestCaseContext testCaseContext)
{
var actionUrls = await testCaseContext.TestCase.GetObjectFromJsonAsync <string[]>(_path);
var actionDefs = actionUrls.Select(DataStoreBasedTestStorage.ParseUrl).ToList();
await testCaseContext.ExecuteActionsAsync(_pipelineActionFactory, actionDefs, testCaseContext.Options.GetDeferExceptions(), testCaseContext.Logger);
}
public void Execute(TestCaseContext testCaseContext)
{
testCaseContext.DescriptionWriter.AddNote("HttpPostMany", _url);
var httpClient = testCaseContext.GetRequiredItem <HttpClient>(_httpClientKey);
var responses = _bodyFunc(testCaseContext.TestCase, testCaseContext).Select(body => httpClient.PostEnsureSuccess(_url, body, testCaseContext.Logger)).ToList();
testCaseContext.SetItem(_targetKey, responses);
}
public void Execute(TestCaseContext testCaseContext)
{
var url = testCaseContext.Resolve(_url);
testCaseContext.DescriptionWriter.AddNote("HttpDelete", url);
var httpClient = testCaseContext.GetRequiredItem <HttpClient>(_httpClientKey);
httpClient.DeleteEnsureSuccess(url, testCaseContext.Logger);
}
public void Execute(TestCaseContext testCaseContext)
{
var effectiveSourceKey = testCaseContext.GetEffectiveItemKey(_sourceKey);
var effectiveTargetKey = testCaseContext.GetEffectiveItemKey(_targetKey);
testCaseContext.DescriptionWriter.AddNote("ToJToken", $"{effectiveSourceKey} => {effectiveTargetKey}");
string content = testCaseContext.GetRequiredItem <string>(effectiveSourceKey);
testCaseContext.SetItem(effectiveTargetKey, JToken.Parse(content));
}
public void Execute(TestCaseContext testCaseContext)
{
var url = testCaseContext.Resolve(_url);
testCaseContext.DescriptionWriter.AddNote("HttpPut", url);
var body = _bodyFunc(testCaseContext.TestCase, testCaseContext);
var httpClient = testCaseContext.GetRequiredItem <HttpClient>(_httpClientKey);
testCaseContext.SetItem(_targetKey, httpClient.PutEnsureSuccess(url, body, testCaseContext.Logger));
}
public void RemoveVar_NotFound_Throws()
{
// Arrange
var context = new TestCaseContext();
var sut = new VarsManager(
context.OptionsService,
context.Logger);
// Act + Assert
Assert.Throws <VarNotFoundException>(() => sut.RemoveVar("key"));
}
public void Execute(TestCaseContext testCaseContext)
{
var effectiveSourceKey = testCaseContext.GetEffectiveItemKey(_sourceKey);
var effectiveTargetKey = testCaseContext.GetEffectiveItemKey(_targetKey);
var jsonPath = testCaseContext.Resolve(_jsonPath);
testCaseContext.DescriptionWriter.AddNote("JsonPathSelect", $"{effectiveSourceKey} [{jsonPath}] => {effectiveTargetKey}");
var itemToken = testCaseContext.GetRequiredItemAsJToken(effectiveSourceKey);
var result = itemToken.SelectToken(jsonPath);
testCaseContext.SetItem(effectiveTargetKey, result);
}
public void Execute(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_key);
var value = _resolve
? testCaseContext.Resolve(_value)
: _value;
testCaseContext.DescriptionWriter.AddNote("SetItem", $"{effectiveItemKey} = {value}");
testCaseContext.SetItem(effectiveItemKey, value);
}
public async Task ApplyTransition_NoState_Throws()
{
// Arrange
var context = new TestCaseContext();
var sut = new StateMachineManager(
context.OptionsService,
context.Logger,
context.DataService);
// Act + Assert
await Assert.ThrowsAsync <InvalidOperationException>(
() => sut.ApplyTransition(context.TransitionKey));
}
public void Execute(TestCaseContext testCaseContext)
{
var effectiveItemKey = testCaseContext.GetEffectiveItemKey(_key);
testCaseContext.DescriptionWriter.AddNote("LoadItem", $"file:{_path} => {effectiveItemKey}");
var content = testCaseContext.TestCase.GetContent(_path);
if (_resolve)
{
content = testCaseContext.Resolve(content);
}
testCaseContext.SetItem(effectiveItemKey, content);
}
public void StartingLocale()
{
// Arrange
var context = new TestCaseContext();
var sut = new LocaleManager(
context.OptionsService,
context.Logger);
// Act
var actual = sut.GetLocale();
// Assert
Assert.Equal(context.Options.StartingLocale, actual);
}
public void AddVar_SameVar_Throws()
{
// Arrange
var context = new TestCaseContext();
var sut = new VarsManager(
context.OptionsService,
context.Logger);
var key = "var";
var aVar = new IntVar(key, "var-name", 15);
// Act + Assert
sut.AddVar(aVar);
Assert.Throws <VarAlreadyExistsException>(() => sut.AddVar(aVar));
}
public void JsonEditAction_ResolvesToken()
{
var context = new TestCaseContext(null, null, null, new XDocumentDescriptionWriter(null), new ItemsHolder(null));
context.SetItem("v", "a value");
var key = context.GetItemKey();
context.SetItem(key, "{'abc':1}");
var action1 = new JsonEditAction("$.abc", "'some text ${v}.'");
action1.Execute(context);
Assert.That(context.GetItem <JToken>(key), Is.EqualTo(JValue.Parse("{'abc':'some text a value.'}")));
}
public void EncodeToString(byte[] data, string expected)
{
// Arrange
var context = new TestCaseContext();
var sut = new StringEncoder(
context.Options,
context.Logger);
// Act
var result = sut.EncodeToString(data);
// Assert
Assert.Equal(expected, result);
}
