public override async Task AssertQueryScalar <TItem1, TItem2, TItem3, TResult>(
Func <IQueryable <TItem1>, IQueryable <TItem2>, IQueryable <TItem3>, IQueryable <TResult> > actualQuery,
Func <IQueryable <TItem1>, IQueryable <TItem2>, IQueryable <TItem3>, IQueryable <TResult> > expectedQuery,
bool assertOrder = false,
bool isAsync = false)
{
using (var context = _contextCreator())
{
var actual = isAsync
? await actualQuery(
SetExtractor.Set <TItem1>(context),
SetExtractor.Set <TItem2>(context),
SetExtractor.Set <TItem3>(context)).ToArrayAsync()
: actualQuery(
SetExtractor.Set <TItem1>(context),
SetExtractor.Set <TItem2>(context),
SetExtractor.Set <TItem3>(context)).ToArray();
var expected = expectedQuery(
ExpectedData.Set <TItem1>(),
ExpectedData.Set <TItem2>(),
ExpectedData.Set <TItem3>()).ToArray();
TestHelpers.AssertResults(
expected,
actual,
e => e,
Assert.Equal,
assertOrder);
}
}
public IHttpActionResult PutExpectedData(int id, ExpectedData expectedData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != expectedData.Id)
{
return(BadRequest());
}
ExpectedData e = _unitOfWork.ExpectedDatas.Get(id);
if (e == null)
{
return(NotFound());
}
e.Consumption = expectedData.Consumption;
e.Production = expectedData.Production;
e.StartTime = expectedData.StartTime;
e.EndTime = expectedData.EndTime;
_unitOfWork.Complete();
return(StatusCode(HttpStatusCode.NoContent));
}
public override void AssertSingleResult <TItem1, TItem2>(
Func <IQueryable <TItem1>, IQueryable <TItem2>, object> actualQuery,
Func <IQueryable <TItem1>, IQueryable <TItem2>, object> expectedQuery,
Action <object, object> asserter = null,
int entryCount = 0)
{
using (var context = _contextCreator())
{
var actual = actualQuery(
SetExtractor.Set <TItem1>(context),
SetExtractor.Set <TItem2>(context));
var expected = expectedQuery(
ExpectedData.Set <TItem1>(),
ExpectedData.Set <TItem2>());
if (asserter == null &&
expected != null)
{
_entityAsserters.TryGetValue(expected.GetType(), out asserter);
}
if (asserter != null)
{
asserter(expected, actual);
}
else
{
Assert.Equal(expected, actual);
}
Assert.Equal(entryCount, context.ChangeTracker.Entries().Count());
}
}
private static void CheckExpectedResults(Interpreter ip, string fileContent, Script script, ScriptResult result)
{
// Load the expected results from filecontent... if they are there.
LoadExpectedResults(fileContent, script, result);
// Check that each expected result is correct.
for (int z = 0; z < script.ExceptedValues.Count; z++)
{
var resultData = new ExpectedData();
var exceptedValue = script.ExceptedValues[z];
// Result after executing a script
object actualValue = ip.Memory.Get <object>(exceptedValue.Name);
actualValue = ((LObject)actualValue).GetValue();
// Check if the expected value matched
resultData.Actual = actualValue.ToString();
resultData.Expected = exceptedValue.Value;
resultData.Name = exceptedValue.Name;
resultData.IsMatched = FluentHelper.IsMatchingValue(actualValue, exceptedValue.DataType, exceptedValue.Value);
// The script result is a failure if at least 1 of the expected results fails.
if (resultData.IsMatched)
{
//Console.WriteLine(exceptedValue.Name + " matched : " + actualValue.ToString() + " with : " + exceptedValue.Value);
}
else
{
result.Succeed = false;
//Console.WriteLine(exceptedValue.Name + " did not match");
}
result.ExpectedResults.Add(resultData);
}
}
public override async Task <List <object> > AssertIncludeQuery <TItem1>(
Func <IQueryable <TItem1>, IQueryable <object> > actualQuery,
Func <IQueryable <TItem1>, IQueryable <object> > expectedQuery,
List <IExpectedInclude> expectedIncludes,
Func <dynamic, object> elementSorter = null,
List <Func <dynamic, object> > clientProjections = null,
bool assertOrder = false,
int entryCount = 0,
bool isAsync = false)
{
using (var context = _contextCreator())
{
var actual = isAsync
? await actualQuery(
SetExtractor.Set <TItem1>(context)).ToListAsync()
: actualQuery(
SetExtractor.Set <TItem1>(context)).ToList();
var expected = expectedQuery(ExpectedData.Set <TItem1>()).ToList();
if (!assertOrder)
{
if (elementSorter == null)
{
var firstNonNullableElement = expected.FirstOrDefault(e => e != null);
if (firstNonNullableElement != null)
{
_entitySorters.TryGetValue(firstNonNullableElement.GetType(), out elementSorter);
}
}
if (elementSorter != null)
{
actual = actual.OrderBy(elementSorter).ToList();
expected = expected.OrderBy(elementSorter).ToList();
}
}
if (clientProjections != null)
{
foreach (var clientProjection in clientProjections)
{
var projectedActual = actual.Select(clientProjection).ToList();
var projectedExpected = expected.Select(clientProjection).ToList();
_includeResultAsserter.AssertResult(projectedExpected, projectedActual, expectedIncludes);
}
}
else
{
_includeResultAsserter.AssertResult(expected, actual, expectedIncludes);
}
Assert.Equal(entryCount, context.ChangeTracker.Entries().Count());
return(actual);
}
}
public IHttpActionResult GetExpectedData(int id)
{
ExpectedData expectedData = _unitOfWork.ExpectedDatas.Get(id);
if (expectedData == null)
{
return(NotFound());
}
return(Ok(expectedData));
}
public ExpectedDataControl(TestEditorControl testEditorControl, ExpectedData data = null)
{
InitializeComponent();
_testEditorControl = testEditorControl;
if (null != data)
{
textName.Text = data.name;
textValue.Text = data.value;
expectedData = data;
}
}
public IHttpActionResult PostExpectedData(ExpectedData expectedData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_unitOfWork.ExpectedDatas.Add(expectedData);
_unitOfWork.Complete();
return(CreatedAtRoute("DefaultApi", new { id = expectedData.Id }, expectedData));
}
public override async Task AssertQuery <TItem1, TItem2, TItem3>(
Func <IQueryable <TItem1>, IQueryable <TItem2>, IQueryable <TItem3>, IQueryable <object> > actualQuery,
Func <IQueryable <TItem1>, IQueryable <TItem2>, IQueryable <TItem3>, IQueryable <object> > expectedQuery,
Func <dynamic, object> elementSorter = null,
Action <dynamic, dynamic> elementAsserter = null,
bool assertOrder = false,
int entryCount = 0,
bool isAsync = false)
{
using (var context = _contextCreator())
{
var actual = isAsync
? await actualQuery(
SetExtractor.Set <TItem1>(context),
SetExtractor.Set <TItem2>(context),
SetExtractor.Set <TItem3>(context)).ToArrayAsync()
: actualQuery(
SetExtractor.Set <TItem1>(context),
SetExtractor.Set <TItem2>(context),
SetExtractor.Set <TItem3>(context)).ToArray();
var expected = expectedQuery(
ExpectedData.Set <TItem1>(),
ExpectedData.Set <TItem2>(),
ExpectedData.Set <TItem3>()).ToArray();
if (!assertOrder &&
elementSorter == null &&
expected.Length > 0 &&
expected[0] != null)
{
_entitySorters.TryGetValue(expected[0].GetType(), out elementSorter);
}
if (elementAsserter == null &&
expected.Length > 0 &&
expected[0] != null)
{
_entityAsserters.TryGetValue(expected[0].GetType(), out elementAsserter);
}
TestHelpers.AssertResults(
expected,
actual,
elementSorter,
elementAsserter,
assertOrder);
Assert.Equal(entryCount, context.ChangeTracker.Entries().Count());
}
}
public IHttpActionResult DeleteExpectedData(int id)
{
ExpectedData expectedData = _unitOfWork.ExpectedDatas.Get(id);
if (expectedData == null)
{
return(NotFound());
}
_unitOfWork.ExpectedDatas.Remove(expectedData);
_unitOfWork.Complete();
return(Ok(expectedData));
}
public override void AssertQueryScalar <TItem1, TResult>(
Func <IQueryable <TItem1>, IQueryable <TResult?> > actualQuery,
Func <IQueryable <TItem1>, IQueryable <TResult?> > expectedQuery,
bool assertOrder = false)
{
using (var context = _contextCreator())
{
var actual = actualQuery(SetExtractor.Set <TItem1>(context)).ToArray();
var expected = expectedQuery(ExpectedData.Set <TItem1>()).ToArray();
TestHelpers.AssertResultsNullable(
expected,
actual,
e => e,
Assert.Equal,
assertOrder);
}
}
private void timer_Tick(object sender, System.EventArgs e)
{
var valid = true;
var errorMsg = new StringBuilder();
for (var idx = scrollableControlShellCommand.Controls.Count - 1; idx >= 0; --idx)
{
ShellCommandControl shellCommandControl = scrollableControlShellCommand.Controls[idx] as ShellCommandControl;
shellCommandControl.BackColor = Color.Transparent;
if (string.IsNullOrEmpty(shellCommandControl.command))
{
errorMsg = errorMsg.Append("Please input your command. ");
valid = false;
this._testEditorControl.AllowToRun(false);
shellCommandControl.BackColor = Color.Pink;
EditorForm.ShowMessage(errorMsg.ToString(), true);
}
if (_test.IsShellCommandExist(shellCommandControl.command))
{
valid = false;
shellCommandControl.BackColor = Color.Pink;
errorMsg.Append(string.Format("The command [{0}] already exists, please resolve the duplicate. ", shellCommandControl.command));
}
else if (!string.IsNullOrEmpty(shellCommandControl.command.Trim()))
{
valid &= true;
this.DoDataExchange();
}
}
for (var idx = scrollableControlExpectedData.Controls.Count - 1; idx >= 0; --idx)
{
ExpectedDataControl expectedDataControl = scrollableControlExpectedData.Controls[idx] as ExpectedDataControl;
expectedDataControl.BackColor = Color.Transparent;
ExpectedData data = expectedDataControl.expectedData;
if (string.IsNullOrEmpty(data.name) || string.IsNullOrEmpty(data.value))
{
errorMsg.Append("Please input your expected data. ");
valid &= false;
expectedDataControl.BackColor = Color.Pink;
}
if (_test.IsExpectedDataExist(data.name))
{
valid &= false;
errorMsg.Append(string.Format("The expected data [{0}] already exists, please resolve the duplicate. ", data.name));
expectedDataControl.BackColor = Color.Pink;
}
else if (!string.IsNullOrEmpty(data.value.Trim()))
{
valid &= true;
this.DoDataExchange();
}
}
if (!valid)
{
EditorForm.ShowMessage(errorMsg.ToString(), true);
this._testEditorControl.AllowToRun(false);
}
else
{
timer.Enabled = false;
}
if (null != EditorForm)
{
EditorForm.ShowMessage(errorMsg.ToString(), !valid);
this._testEditorControl.AllowToRun(valid);
}
}
private void IsPointer_VariousTypeNames_ReturnsExpectedValue(string input, ExpectedData data)
{
var sut = TypeIdentifier.Parse(input);
Assert.Equal(data.IsPointer, sut.IsPointer);
}
private void FullName_VariousTypeNames_ReturnsExpectedValue(string input, ExpectedData data)
{
var sut = TypeIdentifier.Parse(input);
Assert.Equal(data.FullName, sut.FullName);
}
private void GenericArguments_VariousTypeNames_ReturnsExpectedValue(string input, ExpectedData data)
{
var sut = TypeIdentifier.Parse(input);
Assert.NotNull(sut.GenericArguments);
Assert.Equal(data.GenericArguments, sut.GenericArguments.Select(arg => new ExpectedData(arg)));
}
private void TypeSpecifiers_VariousTypeNames_ReturnsExpectedValue(string input, ExpectedData data)
{
var sut = TypeIdentifier.Parse(input);
Assert.Equal(data.TypeSpecifiers, sut.TypeSpecifiers);
}
