protected bool doMatch(ResultSet actual)
{
actualResultSet = actual;
//This is needed if we don't use //ism
if (expectedResultSet == null)
{
expectedResultSet = GetResultSet(expect);
}
if (TransformationProvider != null)
{
TransformationProvider.Transform(expectedResultSet);
}
result = Engine.Compare(actualResultSet, expectedResultSet);
// Math.Min for result.Difference limits the value to 1 if we've two non matching resultsets
if ((int)persistanceChoice + Math.Min(1, (int)result.Difference) > 1)
{
if ((persistanceItems & PersistanceItems.expected) == PersistanceItems.expected)
{
doPersist(expectedResultSet, GetPersistancePath("Expect"));
}
if ((persistanceItems & PersistanceItems.actual) == PersistanceItems.actual)
{
doPersist(actualResultSet, GetPersistancePath("Actual"));
}
}
return(result.Difference == ResultSetDifferenceType.None);
}
/// <summary>
/// Searchs the fol configuration files and nest them.
///From Radim: http://stackoverflow.com/questions/19427333/how-to-find-a-projectitem-by-the-file-name
/// </summary>
/// <param name="projectItems">The project items.</param>
private static void SearchFolConfigFilesAndNestThem(ProjectItems projectItems)
{
foreach (ProjectItem projectItem in projectItems)
{
string transFileName;
if (projectItem.TryGetPropertyValue(ProjectItemExt.FullPathProperty, out transFileName))
{
transFileName = Path.GetFileName(transFileName);
string configFileName;
if (TransformationProvider.CheckTransformationFileAndGetSourceFileFromIt(transFileName,
Options.Options.TransfomationFileNameRegexp, Options.Options.SourceFileRegexpMatchIndex,
out configFileName))
{
var configItem = DteHelper.FindItemByName(projectItems, configFileName, true);
var itemToBeNested = DteHelper.FindItemByName(projectItems, transFileName, true);
if (configItem == null || itemToBeNested == null)
{
continue;
}
// ReSharper disable once UnusedVariable
var pitn = configItem.ProjectItems.AddFromFile(itemToBeNested.GetFullPath());
string itemType;
if (itemToBeNested.TryGetPropertyValue(ProjectItemExt.ItemTypeProperty, out itemType))
{
pitn.TrySetPropertyValue(ProjectItemExt.ItemTypeProperty, itemType);
}
}
}
}
}
public FVirtualFile(string virtualpath, FVirtualPathProvider virtualpathpprovider)
: base(virtualpath)
{
_provider = virtualpathpprovider;
_layoutProvider = new LayoutProvider();
_transformationProvider = new TransformationProvider();
_articleProvider = new ArticleProvider();
}
public void CanConvertObjectWithNullFieldToArrays()
{
var obj = new { x = 1254, y = (object)null, z = (string)null };
var arrays = TransformationProvider.ConvertObjectToArrays(obj);
Assert.AreEqual(new[] { "x", "y", "z" }, arrays.Item1);
Assert.AreEqual(new[] { "1254", null, null }, arrays.Item2);
}
/// <summary>
/// Projects the supports transforms.
/// </summary>
/// <param name="project">The project.</param>
/// <returns>
/// [True] if project suppors transformation, otherwise [False]
/// </returns>
public static bool ProjectSupportsTransforms(IVsProject project)
{
string projectFullPath;
if (ErrorHandler.Failed(project.GetMkDocument(VSConstants.VSITEMID_ROOT, out projectFullPath)))
{
return(false);
}
return(TransformationProvider.IsProjectSupported(projectFullPath));
}
/// <summary>
/// Commands the callback.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
public override void CommandCallback(object sender, EventArgs e)
{
string fileName;
var result = SolutionHelper.IsCorrectItemForTransformationOperationsSelected(out fileName);
if (!result)
{
return;
}
TransformationProvider.Transform(fileName,
Options.Options.TransfomationFileNameRegexp, Options.Options.SourceFileRegexpMatchIndex);
}
public void CanConvertObjectWithIndexedFieldToArrays()
{
var obj = new Gwelkghlw {
Id = 1254
};
obj[12] = "qewgfwgewrgh";
obj[13] = "eljpowwdoihgvwoihio";
var arrays = TransformationProvider.ConvertObjectToArrays(obj);
Assert.AreEqual(new[] { "Id" }, arrays.Item1);
Assert.AreEqual(new[] { "1254" }, arrays.Item2);
}
public void Transform_NativeTranformationUnknown_Exception()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
resultSet.Load("\t;10");
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.Native &&
t.OriginalType == NBi.Core.ResultSet.ColumnType.Text &&
t.Code == "unknown"
);
var provider = new TransformationProvider();
Assert.Throws <NotImplementedTransformationException>(() => provider.Add(new ColumnOrdinalIdentifier(0), transformation));
}
public void Transform_NativeTranformationBlankToNull_Correct()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
resultSet.Load("\t;10");
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.Native &&
t.OriginalType == NBi.Core.ResultSet.ColumnType.Text &&
t.Code == "blank-to-null"
);
var provider = new TransformationProvider();
provider.Add(new ColumnOrdinalIdentifier(0), transformation);
provider.Transform(resultSet);
Assert.That(resultSet.Rows[0][0], Is.EqualTo("(null)"));
}
public void Transform_NativeTranformationTrim_Correct()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
resultSet.Load(" aaaa ;10");
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.Native &&
t.OriginalType == NBi.Core.ResultSet.ColumnType.Text &&
t.Code == "text-to-trim"
);
var provider = new TransformationProvider();
provider.Add(0, transformation);
provider.Transform(resultSet);
Assert.That(resultSet.Rows[0][0], Is.EqualTo("aaaa"));
}
public void Transform_SimpleTranformation_Correct()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
resultSet.Load("aaaa;10");
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.CSharp &&
t.OriginalType == NBi.Core.ResultSet.ColumnType.Text &&
t.Code == "value.Substring(0,1)"
);
var provider = new TransformationProvider();
provider.Add(new ColumnOrdinalIdentifier(0), transformation);
provider.Transform(resultSet);
Assert.That(resultSet.Rows[0][0], Is.EqualTo("a"));
}
public void Transform_NativeTranformationFirstCharWithContext_Correct()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
resultSet.Load(new[] { new object[] { "123456789", 6 }, new object[] { "abcdefgh", 2 } });
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.Native &&
t.OriginalType == ColumnType.Text &&
t.Code == "text-to-first-chars(#1)"
);
var provider = new TransformationProvider(new ServiceLocator(), Context.None);
provider.Add(new ColumnOrdinalIdentifier(0), transformation);
provider.Transform(resultSet);
Assert.That(resultSet.Rows[0][0], Is.EqualTo("123456"));
Assert.That(resultSet.Rows[1][0], Is.EqualTo("ab"));
}
public void Transform_TypeSwitch_Correct()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
var obj = new object[] { new DateTime(2016, 10, 1) };
resultSet.Load(Enumerable.Repeat(obj, 1));
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.CSharp &&
t.OriginalType == NBi.Core.ResultSet.ColumnType.DateTime &&
t.Code == "value.Month + (value.Year-2000)*12"
);
var provider = new TransformationProvider();
provider.Add(new ColumnOrdinalIdentifier(0), transformation);
provider.Transform(resultSet);
Assert.That(resultSet.Rows[0][0], Is.EqualTo(202));
}
/// <summary>
/// Commands the callback.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
/// <exception cref="System.NotImplementedException"></exception>
public override void CommandCallback(object sender, EventArgs e)
{
string fileName;
var result = SolutionHelper.IsCorrectItemForTransformationOperationsSelected(out fileName);
if (!result)
{
return;
}
var files = TransformationProvider.TransformToTemporaryFile(fileName,
Options.Options.TransfomationFileNameRegexp, Options.Options.SourceFileRegexpMatchIndex);
if (files == null)
{
return;
}
this.CompareFiles(files.Item1, files.Item2);
}
public void Transform_SimpleTranformation_CorrectHandlingOfColumnNames()
{
var resultSet = new NBi.Core.ResultSet.ResultSet();
resultSet.Load("aaaa;10");
resultSet.Columns[0].ColumnName = "MyCol0";
resultSet.Columns[1].ColumnName = "MyCol1";
var transformation = Mock.Of <ITransformationInfo>
(
t => t.Language == LanguageType.CSharp &&
t.OriginalType == ColumnType.Text &&
t.Code == "value.Substring(0,1)"
);
var provider = new TransformationProvider(new ServiceLocator(), Context.None);
provider.Add(new ColumnOrdinalIdentifier(0), transformation);
provider.Transform(resultSet);
Assert.That(resultSet.Columns[0].ColumnName, Is.EqualTo("MyCol0"));
Assert.That(resultSet.Columns[1].ColumnName, Is.EqualTo("MyCol1"));
Assert.That(resultSet.Columns.Count, Is.EqualTo(2));
}
public void CanConvertNullObjectToArrays()
{
var arrays = TransformationProvider.ConvertObjectToArrays(null);
Assert.IsNull(arrays);
}
protected override BaseResultSetComparisonConstraint InstantiateConstraint(object obj, SettingsXml settings, TransformationProvider transformation)
{
var argsBuilder = new ResultSetResolverArgsBuilder(ServiceLocator);
argsBuilder.Setup(obj);
argsBuilder.Setup(settings);
argsBuilder.Build();
var factory = ServiceLocator.GetResultSetResolverFactory();
var resolver = factory.Instantiate(argsBuilder.GetArgs());
var builder = new ResultSetServiceBuilder();
builder.Setup(resolver);
if (transformation != null)
{
builder.Setup(transformation.Transform);
}
var service = builder.GetService();
return(new SubsetOfConstraint(service));
}
protected override void Init()
{
base.Init();
if (_contentTypeProvider == null)
_contentTypeProvider = new ContentTypeProvider();
if (_transformationProvider == null)
_transformationProvider = new TransformationProvider();
}
public EqualToConstraint Using(TransformationProvider transformationProvider)
{
this.TransformationProvider = transformationProvider;
return(this);
}
public IEnumerable <Alter> InstantiateAlterations(ResultSetSystemXml resultSetXml)
{
if (resultSetXml.Alteration == null)
{
yield break;
}
if (resultSetXml.Alteration.Filters != null)
{
foreach (var filterXml in resultSetXml.Alteration.Filters)
{
var expressions = new List <IColumnExpression>();
if (filterXml.Expression != null)
{
expressions.Add(filterXml.Expression);
}
var factory = new PredicateFilterFactory();
if (filterXml.Predication != null)
{
yield return(factory.Instantiate
(
filterXml.Aliases
, expressions
, filterXml.Predication
).Apply);
}
if (filterXml.Combination != null)
{
yield return(factory.Instantiate
(
filterXml.Aliases
, expressions
, filterXml.Combination.Operator
, filterXml.Combination.Predicates
).Apply);
}
}
}
if (resultSetXml.Alteration.Conversions != null)
{
foreach (var conversionXml in resultSetXml.Alteration.Conversions)
{
var factory = new ConverterFactory();
var converter = factory.Instantiate(conversionXml.Converter.From, conversionXml.Converter.To, conversionXml.Converter.DefaultValue, conversionXml.Converter.Culture);
var engine = new ConverterEngine(conversionXml.Column, converter);
yield return(engine.Execute);
}
}
if (resultSetXml.Alteration.Transformations != null)
{
var provider = new TransformationProvider();
foreach (var transformationXml in resultSetXml.Alteration.Transformations)
{
provider.Add(transformationXml.ColumnIndex, transformationXml);
}
yield return(provider.Transform);
}
}
protected virtual BaseResultSetComparisonConstraint InstantiateConstraint(object obj, SettingsXml settings, TransformationProvider transformation)
{
var argsBuilder = new ResultSetResolverArgsBuilder();
argsBuilder.Setup(obj);
argsBuilder.Setup(settings);
argsBuilder.Build();
var factory = new ResultSetResolverFactory();
var resolver = factory.Instantiate(argsBuilder.GetArgs());
var serviceBuilder = new ResultSetServiceBuilder();
serviceBuilder.Setup(resolver);
if (transformation != null)
{
serviceBuilder.Setup(transformation.Transform);
}
var service = serviceBuilder.GetService();
return(new EqualToConstraint(service));
}
/// <summary>
/// Determines whether [is transformation file] [the specified file name].
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <returns>[True] if file is transformation file, otherwise [False]</returns>
private bool IsTransformationFile(string fileName)
{
return(TransformationProvider.IsTransformationFile(fileName,
Options.Options.TransfomationFileNameRegexp,
Options.Options.SourceFileRegexpMatchIndex));
}
public BaseResultSetComparisonConstraint Using(TransformationProvider transformationProvider)
{
this.TransformationProvider = transformationProvider;
return(this);
}
protected NBiConstraint InstantiateConstraint()
{
EqualToConstraint ctr = null;
if (ConstraintXml.GetCommand() != null)
{
var commandText = ConstraintXml.GetCommand().CommandText;
var connectionString = ConstraintXml.GetCommand().Connection.ConnectionString;
var timeout = ((QueryXml)(ConstraintXml.BaseItem)).Timeout;
IEnumerable <IQueryParameter> parameters = null;
IEnumerable <IQueryTemplateVariable> variables = null;
if (ConstraintXml.Query != null)
{
parameters = ConstraintXml.Query.GetParameters();
variables = ConstraintXml.Query.GetVariables();
}
var commandBuilder = new CommandBuilder();
var cmd = commandBuilder.Build(connectionString, commandText, parameters, variables, timeout);
ctr = new EqualToConstraint(cmd);
}
else if (ConstraintXml.ResultSet != null)
{
if (!string.IsNullOrEmpty(ConstraintXml.ResultSet.File))
{
Trace.WriteLineIf(NBiTraceSwitch.TraceVerbose, "ResultSet defined in external file!");
ctr = new EqualToConstraint(ConstraintXml.ResultSet.GetFile());
if (ConstraintXml.Settings.CsvProfile != null)
{
ctr = ctr.CsvProfile(ConstraintXml.Settings.CsvProfile);
}
}
else if (ConstraintXml.ResultSet.Rows != null)
{
Trace.WriteLineIf(NBiTraceSwitch.TraceVerbose, "ResultSet defined in embedded resultSet!");
ctr = new EqualToConstraint(ConstraintXml.ResultSet.Rows);
}
}
else if (ConstraintXml.XmlSource != null)
{
var selects = new List <AbstractSelect>();
var factory = new SelectFactory();
foreach (var select in ConstraintXml.XmlSource.XPath.Selects)
{
selects.Add(factory.Instantiate(select.Value, select.Attribute, select.Evaluate));
}
XPathEngine engine = null;
if (ConstraintXml.XmlSource.File != null)
{
Trace.WriteLineIf(NBiTraceSwitch.TraceVerbose, string.Format("Xml file at '{0}'", ConstraintXml.XmlSource.GetFile()));
engine = new XPathFileEngine(ConstraintXml.XmlSource.GetFile(), ConstraintXml.XmlSource.XPath.From.Value, selects);
}
else if (ConstraintXml.XmlSource.Url != null)
{
Trace.WriteLineIf(NBiTraceSwitch.TraceVerbose, string.Format("Xml file at '{0}'", ConstraintXml.XmlSource.Url.Value));
engine = new XPathUrlEngine(ConstraintXml.XmlSource.Url.Value, ConstraintXml.XmlSource.XPath.From.Value, selects);
}
else
{
throw new ArgumentException("File or Url can't be both empty when declaring an xml-source.");
}
ctr = new EqualToConstraint(engine);
}
if (ctr == null)
{
throw new ArgumentException();
}
//Manage settings for comparaison
ResultSetComparisonSettings settings = null;
if (ConstraintXml.Behavior == EqualToXml.ComparisonBehavior.SingleRow)
{
ctr = ctr.Using(new SingleRowComparer());
settings = new SingleRowComparisonSettings(
ConstraintXml.ValuesDefaultType,
new NumericToleranceFactory().Instantiate(ConstraintXml.Tolerance),
ConstraintXml.ColumnsDef
);
}
else
{
settings = new ResultSetComparisonSettings(
ConstraintXml.KeysDef,
ConstraintXml.ValuesDef,
ConstraintXml.ValuesDefaultType,
new NumericToleranceFactory().Instantiate(ConstraintXml.Tolerance),
ConstraintXml.ColumnsDef
);
}
ctr.Using(settings);
//Manage transformations
var transformationProvider = new TransformationProvider();
foreach (var columnDef in ConstraintXml.ColumnsDef)
{
if (columnDef.Transformation != null)
{
transformationProvider.Add(columnDef.Index, columnDef.Transformation);
}
}
ctr = ctr.Using(transformationProvider);
//Manage parallelism
if (ConstraintXml.ParallelizeQueries)
{
ctr = ctr.Parallel();
}
else
{
ctr = ctr.Sequential();
}
//Manage persistance
//EqualToConstraint.PersistanceItems persi = 0;
//if (ConstraintXml.GetCommand() != null)
// persi += (int)EqualToConstraint.PersistanceItems.actual;
//if (SystemUnderTestXml is QueryXml)
// persi += (int)EqualToConstraint.PersistanceItems.expected;
//if (!(persi==0 || ConstraintXml.Query==null || string.IsNullOrEmpty(ConstraintXml.Test.Name)))
// ctr.Persist(ConstraintXml.Persistance, persi, ConstraintXml.Test.Name);
return(ctr);
}
protected NBiConstraint InstantiateConstraint()
{
BaseResultSetComparisonConstraint ctr = null;
//Manage transformations
var transformationProvider = new TransformationProvider();
foreach (var columnDef in ConstraintXml.ColumnsDef)
{
if (columnDef.Transformation != null)
{
transformationProvider.Add(columnDef.Index, columnDef.Transformation);
}
}
if (ConstraintXml.GetCommand() != null)
{
ctr = InstantiateConstraint(((QueryXml)(ConstraintXml.BaseItem)), ConstraintXml.Settings, transformationProvider);
}
else if (ConstraintXml.ResultSet != null)
{
ctr = InstantiateConstraint(ConstraintXml.ResultSet, ConstraintXml.Settings, transformationProvider);
}
else if (ConstraintXml.XmlSource != null)
{
ctr = InstantiateConstraint(ConstraintXml.XmlSource, ConstraintXml.Settings, transformationProvider);
}
if (ctr == null)
{
throw new ArgumentException();
}
//Manage settings for comparaison
var builder = new SettingsEquivalerBuilder();
if (ConstraintXml.Behavior == EqualToXml.ComparisonBehavior.SingleRow)
{
builder.Setup(false);
builder.Setup(ConstraintXml.ValuesDefaultType, ConstraintXml.Tolerance);
builder.Setup(ConstraintXml.ColumnsDef);
}
else
{
builder.Setup(ConstraintXml.KeysDef, ConstraintXml.ValuesDef);
builder.Setup(
ConstraintXml.KeyName?.Replace(" ", "").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Distinct(),
ConstraintXml.ValueName?.Replace(" ", "").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Distinct());
builder.Setup(ConstraintXml.ValuesDefaultType, ConstraintXml.Tolerance);
builder.Setup(ConstraintXml.ColumnsDef);
}
builder.Build();
var settings = builder.GetSettings();
var factory = new EquivalerFactory();
var comparer = factory.Instantiate(settings, EquivalenceKind);
ctr = ctr.Using(comparer);
ctr = ctr.Using(settings);
//Manage parallelism
if (ConstraintXml.ParallelizeQueries)
{
ctr = ctr.Parallel();
}
else
{
ctr = ctr.Sequential();
}
return(ctr);
}
