public void Matches_ResultSetService_CallToExecuteOnce()
{
var resultSet = new ResultSet();
resultSet.Load("a;b;1");
var serviceMock = new Mock <IResultSetService>();
serviceMock.Setup(s => s.Execute())
.Returns(resultSet);
var service = serviceMock.Object;
var alias = Mock.Of <IColumnAlias>(v => v.Column == 2 && v.Name == "Value");
var predicate = new Mock <ReferencePredicateArgs>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.Equal);
predicate.SetupGet(p => p.Reference).Returns(new LiteralScalarResolver <decimal>(1));
var predication = new Mock <PredicationArgs>();
predication.SetupGet(p => p.Identifier).Returns(new ColumnNameIdentifier("Value"));
predication.SetupGet(p => p.Predicate).Returns(predicate.Object);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate
(
predication.Object
, new Context(null, new List <IColumnAlias>()
{
alias
}, Array.Empty <IColumnExpression>())
);
var singleRowCtr = new SingleRowConstraint(filter);
//Method under test
singleRowCtr.Matches(service);
//Test conclusion
serviceMock.Verify(s => s.Execute(), Times.Once());
}
public void Matches_ResultSetService_CallToExecuteOnce()
{
var resultSet = new ResultSet();
resultSet.Load("a;b;1");
var serviceMock = new Mock <IResultSetService>();
serviceMock.Setup(s => s.Execute())
.Returns(resultSet);
var service = serviceMock.Object;
var alias = Mock.Of <IColumnAlias>(v => v.Column == 2 && v.Name == "Value");
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.Equal);
predicate.SetupGet(p => p.Operand).Returns(new ColumnNameIdentifier("Value"));
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)1);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate
(
new List <IColumnAlias>()
{
alias
}
, new List <IColumnExpression>()
{
}
, predicate.Object
);
var rowCount = new NoRowsConstraint(filter);
//Method under test
rowCount.Matches(service);
//Test conclusion
serviceMock.Verify(s => s.Execute(), Times.Once());
}
public void Apply_UnexistingColumnName_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
"(null)", 10, 100
},
new List <object>()
{
"(empty)", 2, 75
},
new List <object>()
{
"C", 5, 50
}
}));
var rs = service.Execute();
rs.Table.Columns[0].ColumnName = "first";
rs.Table.Columns[1].ColumnName = "second";
rs.Table.Columns[2].ColumnName = "third";
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Text);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.NullOrEmpty);
predicate.SetupGet(p => p.Operand).Returns(new ColumnNameIdentifier("Unexisting"));
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(new IColumnAlias[0], new IColumnExpression[0], predicate.Object);
var ex = Assert.Throws <ArgumentException>(() => filter.Apply(rs));
Assert.That(ex.Message, Is.StringContaining("first"));
Assert.That(ex.Message, Is.StringContaining("second"));
Assert.That(ex.Message, Is.StringContaining("third"));
}
public void Apply_Variable_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
"(null)", 10, 100
},
new List <object>()
{
"(empty)", 2, 75
},
new List <object>()
{
"C", 5, 50
}
}));
var rs = service.Execute();
var aliases = new[] { Mock.Of <IColumnAlias>(v => v.Column == 0 && v.Name == "a") };
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Text);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.NullOrEmpty);
predicate.SetupGet(p => p.Operand).Returns(new ColumnNameIdentifier("a"));
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(aliases, new IColumnExpression[0], predicate.Object);
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(2));
}
protected NBiConstraint InstantiateConstraint()
{
RowCountConstraint ctr;
var comparer = ConstraintXml.Comparer as ScalarReferencePredicateXml;
var childConstraint = BuildChildConstraint(comparer);
IResultSetFilter filter = null;
if (ConstraintXml.Filter != null)
{
var filterXml = ConstraintXml.Filter;
var expressions = new List <IColumnExpression>();
if (filterXml.Expression != null)
{
expressions.Add(filterXml.Expression);
}
var value = EvaluatePotentialVariable(comparer.Reference.ToString().Replace(" ", ""));
var context = new Context(Variables, filterXml.Aliases, expressions);
var factory = new ResultSetFilterFactory(ServiceLocator);
if (filterXml.Predication != null)
{
var helper = new PredicateArgsBuilder(ServiceLocator, context);
var args = helper.Execute(filterXml.Predication.ColumnType, filterXml.Predication.Predicate);
filter = factory.Instantiate
(
new PredicationArgs(filterXml.Predication.Operand, args)
, context
);
}
else if (filterXml.Combination != null)
{
var helper = new PredicateArgsBuilder(ServiceLocator, context);
var predicationArgs = new List <PredicationArgs>();
foreach (var predication in filterXml.Combination.Predications)
{
var args = helper.Execute(predication.ColumnType, predication.Predicate);
predicationArgs.Add(new PredicationArgs(predication.Operand, args));
}
filter = factory.Instantiate
(
filterXml.Combination.Operator
, predicationArgs
, context
);
}
if ((value is string& (value as string).EndsWith("%")))
{
ctr = new RowCountFilterPercentageConstraint(childConstraint, filter);
}
else
{
ctr = new RowCountFilterConstraint(childConstraint, filter);
}
}
else
{
ctr = new RowCountConstraint(childConstraint);
}
return(ctr);
}
public IEnumerable <Alter> InstantiateAlterations(ResultSetSystemXml resultSetXml)
{
if (resultSetXml.Alteration == null)
{
yield break;
}
if (resultSetXml.Alteration.Filters != null)
{
var factory = new ResultSetFilterFactory(variables);
foreach (var filterXml in resultSetXml.Alteration.Filters)
{
if (filterXml.Ranking == null)
{
var expressions = new List <IColumnExpression>();
if (filterXml.Expression != null)
{
expressions.Add(filterXml.Expression);
}
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);
}
}
else
{
yield return(factory.Instantiate(
filterXml.Ranking,
filterXml.Ranking?.GroupBy?.Columns
).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 identifierFactory = new ColumnIdentifierFactory();
var provider = new TransformationProvider();
foreach (var transformationXml in resultSetXml.Alteration.Transformations)
{
provider.Add(transformationXml.Identifier, transformationXml);
}
yield return(provider.Transform);
}
}
