public void DapperReaderNode_can_perform_simple_select_and_emits_items(TestTable[] tests)
{
DapperExtensions.DapperExtensions.SqlDialect = new SqliteDialect();
using (var con = new SQLiteConnection("Data Source=:memory:;Version=3;New=True;"))
{
con.Open();
con.Execute("create table TestTable(Id int, Timestamp datetime, Name varchar(50));");
foreach (var test in tests)
{
con.Insert(test);
}
var context = new EtlPipelineContext();
var emitter = new TestEmitter <TestTable>();
var node = new DapperReaderNode <TestTable>(() => con, "select Id, Timestamp, Name from TestTable;");
node.SetEmitter(emitter);
node.Execute(context);
emitter.HasSignalledEnd.Should().BeTrue();
var results = emitter.EmittedItems;
results.Count.Should().Be(tests.Length);
results.Should().HaveSameCount(tests);
results.Should().BeEquivalentTo(tests, config => config.Excluding(x => x.IsFrozen));
}
}
public void Can_generate_fixed_number_of_items()
{
var node = new GenericDataGenerationNode <Row, object>(5, (ctx, i, gen) =>
{
var row = new Row
{
[i.ToString()] = "hello",
["number"] = i.ToString()
};
return(row);
});
var emitter = new TestEmitter <Row>();
node.SetEmitter(emitter);
node.Execute(TestHelpers.CreatePipelineContext());
emitter.EmittedItems.Should().HaveCount(5);
var items = emitter.EmittedItems;
for (var i = 1; i <= 5; i++)
{
items[i - 1].Columns.ContainsKey(i.ToString()).Should().BeTrue();
items[i - 1][i.ToString()].Should().Be("hello");
items[i - 1]["number"].Should().Be(i.ToString());
}
}
public void SimpleDbDataReaderNode_Handles_zero_results_gracefully()
{
DapperExtensions.DapperExtensions.SqlDialect = new SqliteDialect();
using (var con = new SQLiteConnection("Data Source=:memory:;Version=3;New=True;"))
{
con.Open();
con.Execute("create table TestTable(Id int, Timestamp datetime, Name varchar(50));");
// Mock calls to CreateNamedDbConnection, to make it return the same
// in memmory connenction every time
var mock = new Mock <EtlPipelineContext>();
mock.Setup(ctx => ctx.CreateNamedDbConnection("DB.Test")).Returns(con);
var context = mock.Object;
// register the connection name
context.DbConnections
.For <SQLiteConnection>(reg => reg
.Register("DB.Test", "foo"));
var emitter = new TestEmitter <Row>();
var node = new SimpleDbDataReaderNode("DB.Test", "select Id, Timestamp, Name from TestTable;");
node.SetEmitter(emitter);
node.Execute(context);
emitter.HasSignalledEnd.Should().BeTrue();
var results = emitter.EmittedItems;
results.Count.Should().Be(0);
}
}
private void ObserveOverallState(int timeMs)
{
EmitterCart.Observe(_master);
FocusCart.Observe(_master);
TestEmitter.Observe(_master);
TestFocus.Observe(_master, timeMs);
TestLaser.Observe(_master, timeMs);
TestFieldGenerator.Observe(_master, timeMs);
TestTemperature.ObserveUpperBound(_master, timeMs);
}
/// <summary>
/// Creates the test scenario
/// </summary>
public void Setup()
{
_master.Simulation.Chamber.EmitterCart.WarpToPosition(1f);
EmitterCart = new TestCart(_master.Simulation.Chamber.EmitterCart, "Emitter");
FocusCart = new TestCart(_master.Simulation.Chamber.FocusCart, "Focus");
TestEmitter = new TestEmitter();
TestFocus = new TestFocus();
TestLaser = new TestLaser();
TestFieldGenerator = new TestFieldGenerator();
TestTemperature = new TestTemperature();
}
public void ShouldParseExtendedMouseMove()
{
var test = new TestEmitter();
var data = ESC + "[<35;52;1m";
var buffer = CreateBufferFromString(data, 16);
var parser = new ExtendedMouseModeEncoding(test.Emitter);
var r = parser.Process(buffer);
Assert.AreEqual(data.Length, r);
Assert.AreEqual(1, test.MouseMoves.Count);
}
public void HandlesIoErrors()
{
var folder = GetAndCleanTestFolder(nameof(TestEmitterTests), nameof(HandlesIoErrors));
var testSuite = new TestSuite(
new TestClass("test1", A("x", "test1.dsc")));
var csFile1 = Path.Combine(folder, "test1.g.cs");
using (var fs = new FileStream(csFile1, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
var success = TestEmitter.WriteTestSuite(Logger, testSuite, folder, new string[0]);
Assert.False(success);
Logger.ValidateErrors(1, "Failed to write output file '", Path.DirectorySeparatorChar + "test1.g.cs' because it is being used by another process.");
}
}
public void ShouldOutputSingleEscape()
{
var test = new TestEmitter();
var data = $"{ESC}";
var buffer = CreateBufferFromString(data, 16);
var map = new InputMapper();
var keys = new KeysMap(test.Emitter);
keys.Register(map);
map.Process(buffer);
Assert.AreEqual(data.Length, test.Keys.Count);
Assert.IsTrue(test.Keys[0].Key == ConsoleKey.Escape);
}
public void TestClassEmit()
{
var stringWriter = new StringWriter();
var gen = new CodeGenerator(t => stringWriter.Write(t));
var testClass = new TestClass("testName", A("x", "test.dsc"),
new TestFunction("test1", "test1", default(LineAndColumn), A("x", "test.test1.lkg")),
new TestFunction("test2", "Ns2.test2", default(LineAndColumn), null));
TestEmitter.WriteTestClass(gen, testClass, new[] {
A("x", "Sdk1"),
A("x", "Sdk2")
});
var resultLines = stringWriter
.GetStringBuilder()
.ToString()
.Split('\r', '\n')
.Select(line => line.Trim())
.Where(line => !string.IsNullOrEmpty(line))
.ToArray();
Assert.Contains("// Copyright (c) Microsoft Corporation. All rights reserved.", resultLines);
Assert.Contains("using BuildXL.FrontEnd.Script.Testing.Helper;", resultLines);
Assert.Contains("using Xunit;", resultLines);
Assert.Contains("using Xunit.Abstractions;", resultLines);
Assert.Contains("public sealed class @testName : UnitTestBase", resultLines);
Assert.Contains("public @testName(ITestOutputHelper output)", resultLines);
if (OperatingSystemHelper.IsUnixOS)
{
Assert.Contains(String.Format(@"protected override string FileUnderTest => ""{0}"";", A("x", "test.dsc")), resultLines);
Assert.Contains("protected override string[] SdkFoldersUnderTest => new string[] {", resultLines);
Assert.Contains(String.Format(@"""{0}"",", A("x", "Sdk1")), resultLines);
Assert.Contains(String.Format(@"""{0}"",", A("x", "Sdk2")), resultLines);
Assert.Contains(String.Format(@"public void test1() => RunSpecTest(""test1"", ""test1"", ""{0}"");", A("x", "test.test1.lkg")), resultLines);
}
else
{
Assert.Contains(String.Format(@"protected override string FileUnderTest => @""{0}"";", A("x", "test.dsc")), resultLines);
Assert.Contains("protected override string[] SdkFoldersUnderTest => new string[] {", resultLines);
Assert.Contains(String.Format(@"@""{0}"",", A("x", "Sdk1")), resultLines);
Assert.Contains(String.Format(@"@""{0}"",", A("x", "Sdk2")), resultLines);
Assert.Contains(String.Format(@"public void test1() => RunSpecTest(""test1"", ""test1"", @""{0}"");", A("x", "test.test1.lkg")), resultLines);
}
Assert.Contains(@"public void test2() => RunSpecTest(""Ns2.test2"", ""test2"");", resultLines);
}
public void ShouldParseExtendedMouseClick()
{
var test = new TestEmitter();
var md = ESC + "[<0;52;1M";
var mu = ESC + "[<3;52;1m";
var parser = new ExtendedMouseModeEncoding(test.Emitter);
var rd = parser.Process(CreateBufferFromString(md, 16));
var ru = parser.Process(CreateBufferFromString(mu, 16));
Assert.AreEqual(md.Length, rd);
Assert.AreEqual(mu.Length, ru);
Assert.AreEqual(1, test.MouseMoves.Count); // same coords, should not move
Assert.AreEqual(1, test.MouseDowns.Count);
Assert.AreEqual(1, test.MouseUps.Count);
Assert.AreEqual(1, test.MouseClicks.Count);
}
public void DapperReaderNode_raises_error_and_signals_end_with_bad_query()
{
using (var con = new SQLiteConnection("Data Source=:memory:;Version=3;New=True;"))
{
con.Open();
var context = new EtlPipelineContext();
var emitter = new TestEmitter <TestTable>();
var errorHandler = new TestErrorHandler();
var node = new DapperReaderNode <TestTable>(() => con, "select Id, Timestamp, Name from TestTable;");
node.SetEmitter(emitter).SetErrorHandler(errorHandler);
node.Execute(context);
errorHandler.Errors.Should().HaveCount(1);
emitter.HasSignalledEnd.Should().BeTrue();
}
}
public void Can_classify_data_with_multiple_whens_and_a_default()
{
var input = new List <Row>
{
new Row {
["number"] = 1
},
new Row {
["number"] = 2
},
new Row {
["number"] = 3
},
new Row {
["number"] = 4
},
new Row {
["number"] = 5
},
new Row {
["number"] = 6
}
};
var node = new GenericClassificationNode <Row, string, object>(row => row["class"])
.When(x => x.GetAs <int>("number") % 3 == 0, "MOD_3")
.When(x => x.GetAs <int>("number") % 2 == 0, "MOD_2")
.Default("NOT_MOD_2_OR_3");
var emitter = new TestEmitter <Row>();
node.SetInput(input);
node.SetEmitter(emitter);
node.Execute(TestHelpers.CreatePipelineContext());
emitter.EmittedItems.Should().HaveCount(6);
emitter.EmittedItems[0]["class"].Should().Be("NOT_MOD_2_OR_3");
emitter.EmittedItems[1]["class"].Should().Be("MOD_2");
emitter.EmittedItems[2]["class"].Should().Be("MOD_3");
emitter.EmittedItems[3]["class"].Should().Be("MOD_2");
emitter.EmittedItems[4]["class"].Should().Be("NOT_MOD_2_OR_3");
emitter.EmittedItems[5]["class"].Should().Be("MOD_3");
}
public void Can_generate_items_based_on_predicate()
{
var node = new GenericDataGenerationNode <Row, DateTime>(
gen => gen.State <= DateTime.ParseExact("2018-01-31 00:00:00", "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture),
(ctx, i, gen) =>
{
if (i == 1)
{
gen.SetState(DateTime.ParseExact("2018-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture));
}
var row = new Row
{
["date"] = gen.State.ToString("yyyy-MM-dd")
};
gen.SetState(gen.State.AddDays(1));
return(row);
});
var emitter = new TestEmitter <Row>();
node.SetEmitter(emitter);
node.Execute(TestHelpers.CreatePipelineContext());
emitter.EmittedItems.Should().HaveCount(31);
var items = emitter.EmittedItems;
var assertDate = DateTime.ParseExact("2018-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
for (var i = 0; i < 31; i++)
{
if (i == 0)
{
items[i]["date"].Should().Be("2018-01-01");
}
items[i].Columns.ContainsKey("date").Should().BeTrue();
items[i]["date"].Should().Be(assertDate.ToString("yyyy-MM-dd"));
assertDate = assertDate.AddDays(1);
}
}
public void TestSuite()
{
var folder = GetAndCleanTestFolder(nameof(TestEmitterTests), nameof(TestSuite));
var testSuite = new TestSuite(
new TestClass("test1", A("x", "test1.dsc")),
new TestClass("test2", A("x", "test2.dsc")));
var success = TestEmitter.WriteTestSuite(Logger, testSuite, folder, new string[0]);
Assert.True(success);
var csFile1 = Path.Combine(folder, "test1.g.cs");
var csFile2 = Path.Combine(folder, "test2.g.cs");
Assert.True(File.Exists(csFile1));
Assert.True(File.Exists(csFile2));
Assert.Equal(0, Logger.ErrorCount);
}
public void SimpleDbDataReaderNode_can_perform_simple_select_and_emits_items(TestTable[] tests)
{
DapperExtensions.DapperExtensions.SqlDialect = new SqliteDialect();
using (var con = new SQLiteConnection("Data Source=:memory:;Version=3;New=True;"))
{
con.Open();
con.Execute("create table TestTable(Id int, Timestamp datetime, Name varchar(50));");
foreach (var test in tests)
{
con.Insert(test);
}
// Mock calls to CreateNamedDbConnection, to make it return the same
// in memmory connenction every time
var mock = new Mock <EtlPipelineContext>();
mock.Setup(ctx => ctx.CreateNamedDbConnection("DB.Test")).Returns(con);
var context = mock.Object;
// register the connection name
context.DbConnections
.For <SQLiteConnection>(reg => reg
.Register("DB.Test", "foo"));
var emitter = new TestEmitter <Row>();
var node = new SimpleDbDataReaderNode("DB.Test", "select Id, Timestamp, Name from TestTable;");
node.SetEmitter(emitter);
node.Execute(context);
emitter.HasSignalledEnd.Should().BeTrue();
var results = emitter.EmittedItems;
results.Count.Should().Be(tests.Length);
results.Should().HaveSameCount(tests);
for (var i = 0; i < tests.Length; i++)
{
results[i]["Id"].Should().Be(tests[i].Id);
results[i]["Timestamp"].Should().Be(tests[i].Timestamp);
results[i]["Name"].Should().Be(tests[i].Name);
}
}
}
public void ShouldParseClumpedClicks()
{
var test = new TestEmitter();
var md = ESC + "[<0;52;1M";
var mu = ESC + "[<3;52;1m";
var map = new InputMapper();
var c = new ExtendedMouseModeEncoding(test.Emitter);
c.Register(map);
// as long as the parser gets the entire sequence, additional chars shouldn't break anything
var clump = "123" + md + "456" + mu + "789";
map.Process(CreateBufferFromString(clump, 32));
Assert.AreEqual(1, test.MouseMoves.Count); // same coords, should not move
Assert.AreEqual(1, test.MouseDowns.Count);
Assert.AreEqual(1, test.MouseUps.Count);
Assert.AreEqual(1, test.MouseClicks.Count);
Assert.AreEqual(9, test.Keys.Count);
}
public void Can_filter_on_predicate()
{
var input = new List <Row>
{
new Row {
["number"] = 1
},
new Row {
["number"] = 2
},
new Row {
["number"] = 3
},
new Row {
["number"] = 4
},
new Row {
["number"] = 5
},
new Row {
["number"] = 6
}
};
var node = new GenericFilterNode <Row>(row => row.GetAs <int>("number") % 2 == 0);
var emitter = new TestEmitter <Row>();
node.SetInput(input);
node.SetEmitter(emitter);
node.Execute(TestHelpers.CreatePipelineContext());
emitter.EmittedItems.Should().HaveCount(3);
emitter.EmittedItems[0]["number"].Should().Be(2);
emitter.EmittedItems[1]["number"].Should().Be(4);
emitter.EmittedItems[2]["number"].Should().Be(6);
}
public void AbstractSourceNode_calls_SignalEnd_when_general_error()
{
var exception = new Exception("This is a test exception.");
var context = new EtlPipelineContext();
var errorHandler = new TestErrorHandler();
var emitter = new TestEmitter <Row>();
var node = new TestAbstractSourceNode <Row>((ctx, e) =>
{
e.Emit(new Row());
throw exception;
});
node.SetErrorHandler(errorHandler);
node.SetEmitter(emitter);
node.Execute(context);
errorHandler.Errors.Count.Should().Be(1);
errorHandler.Errors.First().Node.Should().Be(node);
errorHandler.Errors.First().Exception.Should().Be(exception);
emitter.HasSignalledEnd.Should().BeTrue();
}
