public async Task <RunTestResponse> RunTest(RunTestRequest request)
{
var listRequest = new ListTestsDataRequest(request.FilteringOrders, new Vectors.IntInterval(0, 1000), true, false);
var listResponse = await TestsStorage.ListTestsDataAsync(listRequest);
var testsQuery = Db.TestRuns
.IncludeGroup(RunnerService.Db.EntityGroups.ALL, Db)
.Filter(Logger, request.FilteringOrders);
var tests = await testsQuery.ToArrayAsync();
foreach (var testFromStorge in listResponse.Tests)
{
var exists = tests.Any(r => r.TestName == testFromStorge.TestName);
if (!exists)
{
tests.Add(new RunnerService.Db.TestRunInfo()
{
TestId = testFromStorge.TestId,
Results = new List <Result>(),
RunPlan = new ManualRunPlan(),
TestName = testFromStorge.TestName,
});
await Db.TestRuns.AddAsync(tests.LastElement());
}
}
var messages = new List <Func <BeginTestMessage> >();
foreach (var test in tests)
{
var result = new Result()
{
ResultBase = new PendingCompletionResult()
{
StartTime = DateTime.UtcNow,
StartedByUser = request.StartedByUser,
TestId = test.TestId,
TestName = test.TestName,
State = new StateInfo("", null, false)
}
};
test.Results.Add(result);
var data = listResponse.Tests.First(t => t.TestName == test.TestName).Data;
messages.Add(() => new BeginTestMessage(test.TestId, result.Id, data.Type, data.Data));
}
await Db.SaveChangesAsync();
foreach (var message in messages)
{
MessageProducer.FireBeginTest(message());
}
return(new RunTestResponse());
}
public async Task <ListTestsResponse> ListTests(ListTestsRequest request)
{
var lstRequest = new ListTestsDataRequest(request.FilteringOrders, request.Range, false, request.ReturnNotSaved);
var tests = await TestsStorage.ListTestsDataAsync(lstRequest);
var testsIds = tests.Tests.Select(c => c.TestId).ToArray();
var getInfosR = new RunnerService.API.Models.GetTestsInfoRequest(testsIds);
RunnerService.API.Models.GetTestsInfoResponse getInfosResp = request.ReturnNotSaved
? (RunnerService.API.Models.GetTestsInfoResponse)null
: (RunnerService.API.Models.GetTestsInfoResponse) await RunnerService.GetTestsInfoAsync(getInfosR);
var fullInfos = tests.Tests.Select(c => (Case: c, RunInfo: getInfosResp == null ? (RunnerService.API.Models.TestRunInfo)null : getInfosResp.RunInfos.FirstOrDefault(r => r.TestId == c.TestId)));
//var fullInfos = tests.Tests.Zip(getInfosResp?.RunInfos ?? ((RunnerService.API.Models.TestRunInfo)null).Repeat(tests.Tests.Length).ToArray() , (Case, RunInfo) => (Case, RunInfo));
var response = new ListTestsResponse(ddd().ToArray(), tests.TotalCount);
return(response);
IEnumerable <TestInfo> ddd()
{
foreach (var info in fullInfos)
{
yield return(new TestInfo()
{
TestId = info.Case.TestId,
TestName = info.Case.TestName,
Author = info.Case.AuthorName == null
? null
: new GetUserInfoResponse(info.Case.AuthorName, null, null),
Target = new TestCaseInfo()
{
DisplayName = info.Case.TestDescription,
TargetType = info.Case?.Data?.Type,
Parameters = info.Case?.Data?.Parameters,
CreateDate = info.Case?.CreationDate ?? default,
KeyParameters = info.Case?.Data?.KeyParameters.Select(p => p.Key + "###" + p.Value).Aggregate(Environment.NewLine) // Someone, pls, rewrite :D
},
public async Task <ListTestsDataResponse> ListTestsData(ListTestsDataRequest request)
{
IQueryable <TestCase> cases = Db.Cases
.AsNoTracking()
.IncludeGroup(EntityGroups.ALL, Db)
.Where(c => request.ReturnNotSaved
? c.State == TestCaseState.RecordedButNotSaved
: c.State == TestCaseState.Saved)
.OrderByDescending(c => c.CreationDate);
cases = filterCases(cases, request.FilteringOrders);
var totalCount = cases is Microsoft.EntityFrameworkCore.Query.Internal.IAsyncQueryProvider
? await cases.CountAsync()
: cases.Count();
if (request.Range != null)
{
var count = (request.Range.To - request.Range.From).NegativeToZero();
cases = cases.Take(count);
}
var result = cases is Microsoft.EntityFrameworkCore.Query.Internal.IAsyncQueryProvider
? await cases.ToArrayAsync()
: cases.ToArray();
if (!request.IncludeData)
{
foreach (var r in result)
{
r.Data.Data = null;
}
}
return(new ListTestsDataResponse(result, totalCount));
}
public async Task <GetTestsInfoResponse> GetTestsInfo(GetTestsInfoRequest request)
{
var infos = await ensureDbPopulated(request.TestIds);
return(new GetTestsInfoResponse(ges().ToArray()));
IEnumerable <API.Models.TestRunInfo> ges()
{
foreach (var i in infos)
{
var lastResult = i.Results
.OrderByDescending(r => r.ResultBase.StartTime)
.FirstOrDefault()
?.ResultBase;
StateBase state = new JustCreatedState();
if (i.Results.Any(r => r.ResultBase.Result == RunResult.Running))
{
state = new RunningState();
}
else
{
state = lastResult?.Result switch
{
RunResult.Aborted => new ReadyState(),
RunResult.Passed => new ReadyState(),
RunResult.Error => new ReadyState(),
RunResult.FatalError => new ReadyState(),
RunResult.Running => new RunningState(),
null => new JustCreatedState(),
_ => throw new NotSupportedException()
};
}
yield return(new API.Models.TestRunInfo(
i.TestId,
i.TestName,
lastResult,
state,
i.RunPlan));
}
}
}
async Task <Db.TestRunInfo[]> ensureDbPopulated(int[] testIds)
{
var infos = await Db.TestRuns
.IncludeGroup(RunnerService.Db.EntityGroups.ALL, Db)
.Where(r => testIds.Contains(r.TestId))
.ToArrayAsync();
var missingIds = testIds
.Where(id => infos.NotContains(i => i.TestId == id))
.ToArray();
if (missingIds.Length > 0)
{
var lstReq = ListTestsDataRequest.ByIds(missingIds, new Vectors.IntInterval(0, missingIds.Length), false, false);
ListTestsDataResponse lstResp = await TestsStorage.ListTestsDataAsync(lstReq);
var missingRunInfos = lstResp.Tests
.Select(ti => new Db.TestRunInfo()
{
TestId = ti.TestId,
TestName = ti.TestName,
RunPlan = new ManualRunPlan(),
}).ToArray();
if (missingRunInfos.Length > 0)
{
await Db.TestRuns.AddRangeAsync(missingRunInfos);
await Db.SaveChangesAsync();
infos = infos.Concat(missingRunInfos).ToArray();
}
}
return(infos);
}
public Task <ListTestsDataResponse> ListTestsDataAsync(ListTestsDataRequest request)
{
return(MakeRequestAsync <ListTestsDataRequest, ListTestsDataResponse>(HttpMethod.Post, "list", request));
}
