public void GetSystemUnderTest_ResultSetSystemXml_IResultSetService()
{
var sutXmlStub = new Mock <Systems.ResultSetSystemXml>();
sutXmlStub.Setup(s => s.File).Returns("myFile.csv");
var sutXml = sutXmlStub.Object;
var ctrXml = new AllRowsXml()
{
Predication = new PredicationXml()
{
Predicate = new MoreThanXml()
{
Value = "10"
},
Operand = "#0"
}
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, null, new ServiceLocator());
builder.Build();
var sut = builder.GetSystemUnderTest();
Assert.That(sut, Is.Not.Null);
Assert.That(sut, Is.InstanceOf <IResultSetService>());
}
public void Serialize_AllRowsXml_AnyOfXml()
{
var allRowsXml = new AllRowsXml
{
Predication = new PredicationXml()
{
Predicate = new AnyOfXml()
{
Values = new List <string>()
{
"first", "second"
}
}
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var stream = new MemoryStream();
var writer = new StreamWriter(stream, Encoding.UTF8);
serializer.Serialize(writer, allRowsXml);
var content = Encoding.UTF8.GetString(stream.ToArray());
writer.Close();
stream.Close();
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("any-of"));
Assert.That(content, Is.StringContaining("item"));
Assert.That(content, Is.StringContaining("first"));
Assert.That(content, Is.StringContaining("second"));
}
public void GetSystemUnderTest_ExecutionXml_IResultSetService()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryableXml>();
itemXmlStubFactory.Setup(i => i.GetQuery()).Returns("query");
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml()
{
Predication = new PredicationXml()
{
Predicate = new MoreThanXml()
{
Value = "10"
},
Operand = "#0"
}
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, null, new ServiceLocator());
builder.Build();
var sut = builder.GetSystemUnderTest();
Assert.That(sut, Is.Not.Null);
Assert.That(sut, Is.InstanceOf <IResultSetService>());
}
public void Serialize_ModuloXml_AllPredicateInfoCorrectlySerialized()
{
var allRowsXml = new AllRowsXml
{
Predication = new PredicationXml()
{
Operand = new ColumnOrdinalIdentifier(1),
Predicate = new ModuloXml()
{
SecondOperand = "10", Value = "5"
}
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var stream = new MemoryStream();
var writer = new StreamWriter(stream, Encoding.UTF8);
serializer.Serialize(writer, allRowsXml);
var content = Encoding.UTF8.GetString(stream.ToArray());
writer.Close();
stream.Close();
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("<modulo"));
Assert.That(content, Is.StringContaining("second-operand=\"10\""));
Assert.That(content, Is.StringContaining(">5<"));
}
public void Serialize_AllRowsXml_OnlyAliasNoVariable()
{
var allRowsXml = new AllRowsXml();
allRowsXml.InternalAliasesOld = new List <AliasXml>()
{
new AliasXml()
{
Column = 1, Name = "Col1"
},
new AliasXml()
{
Column = 0, Name = "Col2"
}
};
allRowsXml.Predication = new PredicationXml();
var serializer = new XmlSerializer(typeof(AllRowsXml));
var stream = new MemoryStream();
var writer = new StreamWriter(stream, Encoding.UTF8);
serializer.Serialize(writer, allRowsXml);
var content = Encoding.UTF8.GetString(stream.ToArray());
writer.Close();
stream.Close();
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("alias"));
Assert.That(content, Is.Not.StringContaining("variable"));
}
public void Serialize_PredicateXml_OnlyOperandNoName()
{
var allRowsXml = new AllRowsXml
{
Predication = new PredicationXml()
{
Operand = new ColumnOrdinalIdentifier(1),
Predicate = new FalseXml()
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var stream = new MemoryStream();
var writer = new StreamWriter(stream, Encoding.UTF8);
serializer.Serialize(writer, allRowsXml);
var content = Encoding.UTF8.GetString(stream.ToArray());
writer.Close();
stream.Close();
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("operand"));
Assert.That(content, Is.Not.StringContaining("name"));
}
public void GetSystemUnderTest_ExecutionXml_IResultSetService()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryXml>();
itemXmlStubFactory.Setup(i => i.InlineQuery).Returns("query");
itemXmlStubFactory.Setup(i => i.Settings).Returns(SettingsXml.Empty);
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml()
{
Predication = new SinglePredicationXml()
{
Predicate = new MoreThanXml()
{
Reference = "10"
},
Operand = new ColumnOrdinalIdentifier(0)
}
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, null, new ServiceLocator());
builder.Build();
var sut = builder.GetSystemUnderTest();
Assert.That(sut, Is.Not.Null);
Assert.That(sut, Is.InstanceOf <IResultSetService>());
}
public void GetConstraint_BuildWithResultSet_CorrectConstraint()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryXml>();
itemXmlStubFactory.Setup(i => i.InlineQuery).Returns("query");
itemXmlStubFactory.Setup(i => i.Settings).Returns(SettingsXml.Empty);
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml
{
Predication = new SinglePredicationXml()
{
Predicate = new MoreThanXml()
{
Reference = "100"
},
Operand = new ColumnOrdinalIdentifier(0)
}
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, null, new ServiceLocator());
builder.Build();
var ctr = builder.GetConstraint();
Assert.That(ctr, Is.InstanceOf <AllRowsConstraint>());
var allRows = ctr as AllRowsConstraint;
Assert.That(allRows.Differed, Is.Null);
}
public void Serialize_ExecutionXml_NoColumnOrdinal()
{
var allRowsXml = new AllRowsXml
{
Expressions = new List <ExpressionXml>()
{
new ExpressionXml()
{
Value = "a + b = c",
Type = ColumnType.Boolean,
Name = "calculate"
}
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var content = string.Empty;
using (var stream = new MemoryStream())
{
using (var writer = new StreamWriter(stream, Encoding.UTF8))
serializer.Serialize(writer, allRowsXml);
content = Encoding.UTF8.GetString(stream.ToArray());
}
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("expression"));
Assert.That(content, Is.StringContaining("type"));
Assert.That(content, Is.StringContaining("name"));
Assert.That(content, Is.StringContaining(">a + b = c<"));
Assert.That(content, Is.Not.StringContaining("column-type"));
Assert.That(content, Is.Not.StringContaining("column-index"));
Assert.That(content, Is.Not.StringContaining("tolerance"));
}
public void GetConstraint_Build_HandleVariable()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryableXml>();
itemXmlStubFactory.Setup(i => i.GetQuery()).Returns("query");
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml();
ctrXml.Predicate = new PredicateXml();
ctrXml.Predicate.MoreThan = new MoreThanXml();
ctrXml.Predicate.MoreThan.Value = "@year";
var variables = new Dictionary <string, ITestVariable>()
{
{ "year", new CSharpTestVariable("DateTime.Now.Year") }
};
var builder = new ExecutionAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, variables);
builder.Build();
Assert.That(variables["year"].IsEvaluated, Is.True);
}
public void GetConstraint_BuildWithResultSet_CorrectConstraint()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryableXml>();
itemXmlStubFactory.Setup(i => i.GetQuery()).Returns("query");
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml
{
Predication = new PredicationXml()
{
Predicate = new MoreThanXml()
{
Value = "100"
},
Operand = "#0"
}
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, null, new ServiceLocator());
builder.Build();
var ctr = builder.GetConstraint();
Assert.That(ctr, Is.InstanceOf <AllRowsConstraint>());
var allRows = ctr as AllRowsConstraint;
Assert.That(allRows.Differed, Is.Null);
}
protected override void SpecificSetup(AbstractSystemUnderTestXml sutXml, AbstractConstraintXml ctrXml)
{
if (!(ctrXml is AllRowsXml))
{
throw new ArgumentException("Constraint must be a 'RowCountXml'");
}
ConstraintXml = (AllRowsXml)ctrXml;
}
public void Serialize_NativeExpression_ScriptIsAvailable()
{
var allRowsXml = new AllRowsXml
{
Expressions = new List <ExpressionXml>()
{
new ExpressionXml()
{
Type = ColumnType.Numeric,
Name = "calculate",
Script = new ScriptXml()
{
Code = "a | numeric-to-integer", Language = LanguageType.Native
}
}
},
Predication = new SinglePredicationXml()
{
Operand = new ColumnNameIdentifier("calculate"),
ColumnType = ColumnType.Numeric,
Predicate = new EqualXml()
{
Reference = "100"
}
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var content = string.Empty;
using (var stream = new MemoryStream())
{
using (var writer = new StreamWriter(stream, Encoding.UTF8))
serializer.Serialize(writer, allRowsXml);
content = Encoding.UTF8.GetString(stream.ToArray());
}
Debug.WriteLine(content);
Assert.That(content, Does.Contain("<expression"));
Assert.That(content, Does.Contain("<script"));
Assert.That(content, Does.Contain("native"));
Assert.That(content, Does.Contain("a | numeric-to-integer"));
Assert.That(content.IndexOf("a | numeric-to-integer"), Is.EqualTo(content.LastIndexOf("a | numeric-to-integer")));
}
public void GetConstraint_BuildWithVariables_DontEvaluateThem()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryXml>();
itemXmlStubFactory.Setup(i => i.InlineQuery).Returns("query");
itemXmlStubFactory.Setup(i => i.Settings).Returns(SettingsXml.Empty);
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml
{
Predication = new SinglePredicationXml()
{
Predicate = new MoreThanXml()
{
Reference = "@year"
},
Operand = new ColumnOrdinalIdentifier(0)
}
};
var yearResolverMock = new Mock <ITestVariable>();
yearResolverMock.Setup(x => x.GetValue()).Returns(2017);
var notUsedResolverMock = new Mock <ITestVariable>();
notUsedResolverMock.Setup(x => x.GetValue());
var variables = new Dictionary <string, ITestVariable>()
{
{ "year", yearResolverMock.Object },
{ "NotUsed", notUsedResolverMock.Object }
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, variables, new ServiceLocator());
builder.Build();
notUsedResolverMock.Verify(x => x.GetValue(), Times.Never);
}
public void Serialize_NCalcExpression_NoScript()
{
var allRowsXml = new AllRowsXml
{
Expressions = new List <ExpressionXml>()
{
new ExpressionXml()
{
Type = ColumnType.Numeric,
Name = "calculate",
Script = new ScriptXml()
{
Code = "a + b - c", Language = LanguageType.NCalc
}
}
},
Predication = new PredicationXml()
{
Operand = new ColumnNameIdentifier("calculate"),
ColumnType = ColumnType.Numeric,
Predicate = new EqualXml()
{
Value = "100"
}
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var content = string.Empty;
using (var stream = new MemoryStream())
{
using (var writer = new StreamWriter(stream, Encoding.UTF8))
serializer.Serialize(writer, allRowsXml);
content = Encoding.UTF8.GetString(stream.ToArray());
}
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("<expression"));
Assert.That(content, Is.StringContaining("a + b - c"));
Assert.That(content.IndexOf("a + b - c"), Is.EqualTo(content.LastIndexOf("a + b - c")));
}
public void GetConstraint_BuildWithVariables_DontEvaluateThem()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryableXml>();
itemXmlStubFactory.Setup(i => i.GetQuery()).Returns("query");
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml
{
Predication = new PredicationXml()
{
Predicate = new MoreThanXml()
{
Value = "@year"
},
Operand = "#0"
}
};
var yearResolverMock = new Mock <ITestVariable>();
yearResolverMock.Setup(x => x.GetValue()).Returns(2017);
var notUsedResolverMock = new Mock <ITestVariable>();
notUsedResolverMock.Setup(x => x.GetValue());
var variables = new Dictionary <string, ITestVariable>()
{
{ "year", yearResolverMock.Object },
{ "NotUsed", notUsedResolverMock.Object }
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, variables);
builder.Build();
notUsedResolverMock.Verify(x => x.GetValue(), Times.Never);
}
public void GetConstraint_Build_DontEvaluateVariable()
{
var sutXmlStubFactory = new Mock <Systems.ExecutionXml>();
var itemXmlStubFactory = new Mock <QueryableXml>();
itemXmlStubFactory.Setup(i => i.GetQuery()).Returns("query");
sutXmlStubFactory.Setup(s => s.Item).Returns(itemXmlStubFactory.Object);
var sutXml = sutXmlStubFactory.Object;
sutXml.Item = itemXmlStubFactory.Object;
var ctrXml = new AllRowsXml
{
Predication = new PredicationXml()
{
Predicate = new MoreThanXml {
Value = "@year"
},
Operand = new ColumnOrdinalIdentifier(0)
}
};
var yearResolverMock = new Mock <ITestVariable>();
yearResolverMock.Setup(x => x.GetValue()).Returns(2017);
yearResolverMock.Setup(x => x.IsEvaluated()).Returns(false);
var variables = new Dictionary <string, ITestVariable>()
{
{ "year", yearResolverMock.Object }
};
var builder = new ResultSetAllRowsBuilder();
builder.Setup(sutXml, ctrXml, null, variables, new ServiceLocator());
builder.Build();
//The variable is not evaluated during the build of constraint (introduced in 1.19)
yearResolverMock.Verify(x => x.GetValue(), Times.Never);
}
public void Serialize_ExecutionAndAliasesXml_AliasesBeforeExecution()
{
var allRowsXml = new AllRowsXml
{
Expressions = new List <ExpressionXml>()
{
new ExpressionXml()
{
Value = "a + b - c",
Type = ColumnType.Numeric,
Name = "calculate"
}
},
InternalAliases = new List <AliasXml>()
{
new AliasXml()
{
Column = 0,
Name = "a"
},
new AliasXml()
{
Column = 1,
Name = "b"
},
new AliasXml()
{
Column = 2,
Name = "c"
}
},
Predication = new PredicationXml()
{
Operand = new ColumnNameIdentifier("calculate"),
ColumnType = ColumnType.Numeric,
Predicate = new EqualXml()
{
Value = "100"
}
}
};
var serializer = new XmlSerializer(typeof(AllRowsXml));
var content = string.Empty;
using (var stream = new MemoryStream())
{
using (var writer = new StreamWriter(stream, Encoding.UTF8))
serializer.Serialize(writer, allRowsXml);
content = Encoding.UTF8.GetString(stream.ToArray());
}
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("<alias"));
Assert.That(content, Is.StringContaining("<expression"));
Assert.That(content, Is.StringContaining("<predicate"));
Assert.That(content.LastIndexOf("<alias"), Is.LessThan(content.IndexOf("<expression")));
Assert.That(content.LastIndexOf("<expression"), Is.LessThan(content.IndexOf("<predicate")));
}
