public async Task When_SameNamespace_And_New_Name()
{
var transforms = new TypeTransform[] {
new TypeTransform {
TypeName = "MyNameSpace.MyNewType",
OriginalTypeName = "MyOriginalType"
}
};
await TransformValidation.Validate(transforms);
}
public async Task When_MethodTransform_FromVariable()
{
var transforms = new MethodTransform[] {
new MethodTransform {
MethodName = "Member02",
OwnerType = "MyType",
OriginalMethodName = "Member01"
}
};
await TransformValidation.Validate(transforms);
}
[InlineData(100000)] //should run in ~ 250ms
public async Task ValidationPerformanceValidationOff(int rows)
{
var data = Helpers.CreateLargeTable(rows);
var transform = new TransformValidation();
transform.SetInTransform(data);
var count = 0;
while (await transform.ReadAsync())
{
count++;
}
Assert.Equal(rows, count);
_output.WriteLine(transform.PerformanceSummary());
}
/// <summary>
/// Perfromance tests should run in around 1 minute.
/// </summary>
/// <param name="connection"></param>
public async Task PerformanceTransformWriter(Connection connection, string databaseName, long rows)
{
await connection.CreateDatabase(databaseName, CancellationToken.None);
//create a table that utilizes every available datatype.
var table = new Table("LargeTable" + (DataSets.counter++));
table.Columns.Add(
new TableColumn("SurrogateKey", ETypeCode.Int32, TableColumn.EDeltaType.SurrogateKey)
{
IsIncrementalUpdate = true
});
table.Columns.Add(new TableColumn("UpdateTest", ETypeCode.Int32));
foreach (ETypeCode typeCode in Enum.GetValues(typeof(ETypeCode)))
{
if (typeCode == ETypeCode.Binary && connection.CanUseBinary)
{
continue;
}
if (typeCode != ETypeCode.Binary)
{
continue;
}
table.Columns.Add(new TableColumn()
{
Name = "column" + typeCode,
DataType = typeCode,
MaxLength = 50,
DeltaType = TableColumn.EDeltaType.TrackingField
});
}
//create the table
await connection.CreateTable(table, true, CancellationToken.None);
//add rows.
var buffer = 0;
for (var i = 0; i < rows; i++)
{
var row = new object[table.Columns.Count];
row[0] = i;
row[1] = 0;
//load the rows with random values.
for (var j = 2; j < table.Columns.Count; j++)
{
var dataType = DataType.GetType(table.Columns[j].DataType);
if (i % 2 == 0)
{
row[j] = connection.GetConnectionMaxValue(table.Columns[j].DataType, 20);
}
else
{
row[j] = connection.GetConnectionMinValue(table.Columns[j].DataType);
}
}
table.Data.Add(row);
buffer++;
if (buffer >= 5000 || rows == i + 1)
{
//start a datawriter and insert the test data
await connection.DataWriterStart(table);
await connection.ExecuteInsertBulk(table, new ReaderMemory(table), CancellationToken.None);
table.Data.Clear();
buffer = 0;
}
}
var targetTable = table.Copy();
targetTable.AddAuditColumns();
targetTable.Name = "TargetTable";
await connection.CreateTable(targetTable, false, CancellationToken.None);
var targetTransform = connection.GetTransformReader(targetTable);
//count rows using reader
var transform = connection.GetTransformReader(table);
transform = new TransformMapping(transform, true, null, null);
transform = new TransformValidation(transform, null, false);
transform = new TransformDelta(transform, targetTransform, TransformDelta.EUpdateStrategy.Reload, 1, false);
var writer = new TransformWriter();
var writerResult = new TransformWriterResult();
await connection.InitializeAudit(writerResult, 0, "Datalink", 1, 2, "Test", 1, "Source", 2, "Target",
TransformWriterResult.ETriggerMethod.Manual, "Test", CancellationToken.None);
Assert.NotNull(writerResult);
var result = await writer.WriteAllRecords(writerResult, transform, targetTable, connection, null, null,
null, null, CancellationToken.None);
Assert.Equal(rows, writerResult.RowsCreated);
//check the audit table loaded correctly.
var auditTable = await connection.GetTransformWriterResults(0, null, "Datalink", writerResult.AuditKey, null, true,
false, false, null, 1, 2, false, CancellationToken.None);
Assert.Equal(writerResult.RowsCreated, auditTable[0].RowsCreated);
Assert.Equal(rows - 1, Convert.ToInt64(auditTable[0].MaxIncrementalValue));
}
public async Task Validations_unit()
{
var table = Helpers.CreateValidationTestData();
table.SetCacheMethod(Transform.ECacheMethod.PreLoadCache);
//set a validatoin that rejects all.
var validations = new List <TransformFunction>();
var transformFunction = Functions.GetFunction("dexih.functions.BuiltIn.ConditionFunctions", "IsEqual").GetTransformFunction();
transformFunction.Inputs = new[] {
new Parameter("StringColumn", ETypeCode.String, true, null, new TableColumn("StringColumn"), isArray: true),
new Parameter("Compare", ETypeCode.String, false, "junk", isArray: true)
};
validations.Add(transformFunction);
var transformValidation = new TransformValidation(table, validations, true);
Assert.Equal(8, transformValidation.FieldCount);
var count = 0;
while (await transformValidation.ReadAsync())
{
count = count + 1;
Assert.Equal('R', transformValidation["Operation"]);
}
Assert.Equal(10, count);
table.SetRowNumber(0);
//set a validation that rejects and cleans
validations = new List <TransformFunction>();
//create a simple clean function that set's the max value.
transformFunction = Functions.GetFunction("dexih.functions.BuiltIn.ValidationFunctions", "MaxLength").GetTransformFunction();
transformFunction.Inputs = new[] {
new Parameter("value", ETypeCode.String, true, null, new TableColumn("StringColumn")),
new Parameter("maxLength", ETypeCode.Int32, false, 5)
};
transformFunction.Outputs = new[] {
new Parameter("cleanedValue", ETypeCode.String, true, null, new TableColumn("StringColumn"))
};
transformFunction.InvalidAction = TransformFunction.EInvalidAction.Clean;
validations.Clear();
validations.Add(transformFunction);
transformValidation = new TransformValidation(table, validations, true);
Assert.Equal(8, transformValidation.FieldCount);
var passCount = 0;
var rejectCount = 0;
while (await transformValidation.ReadAsync())
{
Assert.Equal('C', transformValidation["Operation"]);
Assert.True((string)transformValidation["StringColumn"] == "value");
passCount++;
}
Assert.Equal(10, passCount);
//Run the same valuidation with RejectClean set.
transformFunction = Functions.GetFunction("dexih.functions.BuiltIn.ValidationFunctions", "MaxValue").GetTransformFunction();
transformFunction.Inputs = new[] {
new Parameter("value", ETypeCode.Decimal, true, null, new TableColumn("IntColumn")),
new Parameter("maxLength", ETypeCode.Decimal, false, 5)
};
transformFunction.Outputs = new[] {
new Parameter("cleanedValue", ETypeCode.Decimal, true, null, new TableColumn("IntColumn"))
};
transformFunction.InvalidAction = TransformFunction.EInvalidAction.RejectClean;
validations.Clear();
validations.Add(transformFunction);
transformValidation = new TransformValidation(table, validations, true);
Assert.Equal(8, transformValidation.FieldCount);
passCount = 0;
rejectCount = 0;
while (await transformValidation.ReadAsync())
{
if ((char)transformValidation["Operation"] == 'C')
{
Assert.True((int)transformValidation["IntColumn"] <= 5);
passCount++;
}
else
{
rejectCount++;
}
}
Assert.Equal(10, passCount);
Assert.Equal(5, rejectCount);
}