public void Matches_AllValidatePredicate_True()
{
var rs = new ResultSet();
rs.Load(new[] { new object[] { "a", -1 }, new object[] { "b", -2 }, new object[] { "c", -3 } });
var predicate = new Mock <ReferencePredicateArgs>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.LessThan);
predicate.SetupGet(p => p.Reference).Returns(new LiteralScalarResolver <decimal>(0));
var predication = new Mock <PredicationArgs>();
predication.SetupGet(p => p.Identifier).Returns(new ColumnOrdinalIdentifier(1));
predication.SetupGet(p => p.Predicate).Returns(predicate.Object);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate
(
predication.Object
, Context.None
);
var singleRowCtr = new AllRowsConstraint(filter);
Assert.That(singleRowCtr.Matches(rs), Is.True);
}
public void Apply_ColumnName_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";
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("first"));
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(new IColumnAlias[0], new IColumnExpression[0], predicate.Object);
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(2));
}
public void Apply_ColumnOrdinal_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 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 ColumnOrdinalIdentifier(0));
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(new IColumnAlias[0], new IColumnExpression[0], predicate.Object);
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(2));
Assert.That(filter.Describe(), Is.StringContaining("null").And.StringContaining("or empty"));
}
public void Matches_FewValidatePredicate_True()
{
var rs = new ResultSet();
rs.Load(new[] { new object[] { "a", -1 }, new object[] { "b", -2 }, new object[] { "c", 3 } });
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.LessThan);
predicate.SetupGet(p => p.Operand).Returns(new ColumnOrdinalIdentifier(1));
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)0);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate
(
new List <IColumnAlias>()
, new List <IColumnExpression>()
, predicate.Object
);
var someRowCtr = new SomeRowsConstraint(filter);
Assert.That(someRowCtr.Matches(rs));
}
public void Apply_AndWillNotEvaluateAll_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
null
},
new List <object>()
{
5
},
new List <object>()
{
10
},
new List <object>()
{
null
},
new List <object>()
{
20
},
}));
var rs = service.Execute();
var aliases = new[] { Mock.Of <IColumnAlias>(v => v.Column == 0 && v.Name == "a") };
var predicate1 = new Mock <PredicateArgs>();
predicate1.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate1.SetupGet(p => p.ComparerType).Returns(ComparerType.Null);
predicate1.SetupGet(p => p.Not).Returns(true);
var predication1 = new Mock <PredicationArgs>();
predication1.SetupGet(p => p.Identifier).Returns(new ColumnOrdinalIdentifier(0));
predication1.SetupGet(p => p.Predicate).Returns(predicate1.Object);
var predicate2 = new Mock <ReferencePredicateArgs>();
predicate2.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate2.SetupGet(p => p.ComparerType).Returns(ComparerType.LessThan);
predicate2.SetupGet(p => p.Reference).Returns(new LiteralScalarResolver <decimal>(10));
var predication2 = new Mock <PredicationArgs>();
predication2.SetupGet(p => p.Identifier).Returns(new ColumnOrdinalIdentifier(0));
predication2.SetupGet(p => p.Predicate).Returns(predicate2.Object);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(CombinationOperator.And, new[] { predication1.Object, predication2.Object }, new Context(null, aliases, Array.Empty <IColumnExpression>()));
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(1));
}
protected NBiConstraint InstantiateConstraint()
{
RowCountConstraint ctr;
var childConstraint = BuildChildConstraint(ConstraintXml.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(ConstraintXml.Comparer.Value.Replace(" ", ""));
var factory = new ResultSetFilterFactory(Variables);
if (filterXml.Predication != null)
{
filter = factory.Instantiate
(
filterXml.Aliases
, expressions
, filterXml.Predication
);
}
else if (filterXml.Combination != null)
{
filter = factory.Instantiate
(
filterXml.Aliases
, expressions
, filterXml.Combination.Operator
, filterXml.Combination.Predicates
);
}
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 void Apply_XOr_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
"(null)", 10, 100
},
new List <object>()
{
"(empty)", 2, 75
},
new List <object>()
{
"(empty)", 20, 75
},
new List <object>()
{
"C", 5, 50
},
new List <object>()
{
"C", 15, 50
}
}));
var rs = service.Execute();
var aliases = new[] { Mock.Of <IColumnAlias>(v => v.Column == 0 && v.Name == "a") };
var predicate1 = new Mock <IPredicateInfo>();
predicate1.SetupGet(p => p.ColumnType).Returns(ColumnType.Text);
predicate1.SetupGet(p => p.ComparerType).Returns(ComparerType.NullOrEmpty);
predicate1.SetupGet(p => p.Operand).Returns(new ColumnNameIdentifier("a"));
var predicate2 = new Mock <IPredicateInfo>();
predicate2.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate2.SetupGet(p => p.ComparerType).Returns(ComparerType.LessThan);
predicate2.SetupGet(p => p.Operand).Returns(new ColumnOrdinalIdentifier(1));
predicate2.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)10);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(aliases, new IColumnExpression[0], CombinationOperator.XOr, new[] { predicate1.Object, predicate2.Object });
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(3));
}
public void Apply_OrWillNotEvaluateAll_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
null
},
new List <object>()
{
5
},
new List <object>()
{
10
},
new List <object>()
{
null
},
new List <object>()
{
20
},
}));
var rs = service.Execute();
var aliases = new[] { Mock.Of <IColumnAlias>(v => v.Column == 0 && v.Name == "a") };
var predicate1 = new Mock <IPredicateInfo>();
predicate1.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate1.SetupGet(p => p.ComparerType).Returns(ComparerType.Null);
predicate1.SetupGet(p => p.Operand).Returns(new ColumnOrdinalIdentifier(0));
var predicate2 = new Mock <IPredicateInfo>();
predicate2.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate2.SetupGet(p => p.ComparerType).Returns(ComparerType.LessThan);
predicate2.SetupGet(p => p.Operand).Returns(new ColumnOrdinalIdentifier(0));
predicate2.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns(10);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(aliases, new IColumnExpression[0], CombinationOperator.Or, new[] { predicate1.Object, predicate2.Object });
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(3));
}
public void Apply_NativeExpression_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
new DateTime(2019, 10, 01, 8, 0, 0), 10, 100
},
new List <object>()
{
new DateTime(2019, 10, 01, 23, 0, 0), 2, 75
},
new List <object>()
{
new DateTime(2019, 10, 02, 05, 0, 0), 5, 50
}
}));
var rs = service.Execute();
rs.Table.Columns[0].ColumnName = "a";
var aliases = new List <IColumnAlias>()
{
Mock.Of <IColumnAlias>(v => v.Column == 0 && v.Name == "x"),
};
var expressions = new List <IColumnExpression>()
{
Mock.Of <IColumnExpression>(
e => e.Value == "a | utc-to-local(Brussels) | dateTime-to-date" &&
e.Name == "d" &&
e.Language == LanguageType.Native &&
e.Type == ColumnType.DateTime),
};
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.DateTime);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.MoreThanOrEqual);
predicate.SetupGet(p => p.Operand).Returns(new ColumnNameIdentifier("d"));
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)new DateTime(2019, 10, 2));
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(aliases, expressions, predicate.Object);
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(2));
}
public void Apply_MixedExpression_CorrectResult()
{
var service = new ObjectsResultSetResolver(
new ObjectsResultSetResolverArgs(
new object[]
{
new List <object>()
{
1, 10, 100
},
new List <object>()
{
2, 2, 75
},
new List <object>()
{
3, 5, 50
}
}));
var rs = service.Execute();
rs.Table.Columns[2].ColumnName = "c1";
var aliases = new List <IColumnAlias>()
{
Mock.Of <IColumnAlias>(v => v.Column == 0 && v.Name == "a"),
};
var expressions = new List <IColumnExpression>()
{
Mock.Of <IColumnExpression>(e => e.Value == "Abs([a])+[e]" && e.Name == "d" && e.Language == LanguageType.NCalc),
Mock.Of <IColumnExpression>(e => e.Value == "[#1]*[c1]" && e.Name == "e" && e.Language == LanguageType.NCalc)
};
var predicate = new Mock <IPredicateInfo>();
predicate.SetupGet(p => p.ColumnType).Returns(ColumnType.Numeric);
predicate.SetupGet(p => p.ComparerType).Returns(ComparerType.MoreThanOrEqual);
predicate.SetupGet(p => p.Operand).Returns(new ColumnNameIdentifier("d"));
predicate.As <IReferencePredicateInfo>().SetupGet(p => p.Reference).Returns((object)200);
var factory = new ResultSetFilterFactory(null);
var filter = factory.Instantiate(aliases, expressions, predicate.Object);
var result = filter.Apply(rs);
Assert.That(result.Rows, Has.Count.EqualTo(2));
}
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());
}
protected IResultSetFilter InstantiateFilter()
{
var expressions = new List <IColumnExpression>();
if (ConstraintXml.Expressions != null)
{
expressions.AddRange(ConstraintXml.Expressions);
}
var factory = new ResultSetFilterFactory(Variables);
if (ConstraintXml.Predication != null)
{
return(factory.Instantiate
(
ConstraintXml.Aliases
, expressions
, ConstraintXml.Predication
));
}
else if (ConstraintXml.Combination != null)
{
var predicateInfos = new List <IPredicateInfo>();
foreach (var predicateXml in ConstraintXml.Combination.Predicates)
{
predicateInfos.Add(predicateXml);
}
return(factory.Instantiate
(
ConstraintXml.Aliases
, expressions
, ConstraintXml.Combination.Operator
, predicateInfos
));
}
else
{
throw new ArgumentException("You must specify a predicate or a combination of predicates. None of them is specified");
}
}
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"));
}
protected IResultSetFilter InstantiateFilter()
{
var context = new Context(Variables, ConstraintXml.Aliases, ConstraintXml.Expressions);
var factory = new ResultSetFilterFactory(ServiceLocator);
if (ConstraintXml.Predication != null)
{
var helper = new PredicateArgsBuilder(ServiceLocator, context);
var args = helper.Execute(ConstraintXml.Predication.ColumnType, ConstraintXml.Predication.Predicate);
return(factory.Instantiate
(
new PredicationArgs(ConstraintXml.Predication.Operand, args)
, context
));
}
else if (ConstraintXml.Combination != null)
{
var helper = new PredicateArgsBuilder(ServiceLocator, context);
var predicationArgs = new List <PredicationArgs>();
foreach (var predicationXml in ConstraintXml.Combination.Predications)
{
var args = helper.Execute(predicationXml.ColumnType, predicationXml.Predicate);
predicationArgs.Add(new PredicationArgs(predicationXml.Operand, args));
}
return(factory.Instantiate
(
ConstraintXml.Combination.Operator
, predicationArgs
, context
));
}
else
{
throw new ArgumentException("You must specify a predicate or a combination of predicates. None of them is specified");
}
}
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);
}
}
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);
}
