public void Serialize_FileWithIfMissing_NoAttributeTwoElements()
{
var root = new ResultSetSystemXml()
{
File = new FileXml
{
Path = "c:\\myFile.txt",
IfMissing = new IfMissingXml()
{
File = new FileXml()
{
Path = "C:\\myOtherFile.txt"
}
},
}
};
var overrides = new WriteOnlyAttributes();
overrides.Build();
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root, overrides);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<file>"));
Assert.That(xml, Does.Contain("<path>c:\\myFile.txt</path>"));
Assert.That(xml, Does.Contain("<if-missing"));
Assert.That(xml, Does.Contain(">C:\\myOtherFile.txt<"));
Assert.That(xml, Does.Contain("</file>"));
}
public void Serialize_EmptyWithoutColumnCount_Correct()
{
var root = new ResultSetSystemXml()
{
Empty = new EmptyResultSetXml()
{
Columns = new List <ColumnDefinitionLightXml>
{
new ColumnDefinitionLightXml {
Identifier = new ColumnNameIdentifier("myFirstColumn")
},
new ColumnDefinitionLightXml {
Identifier = new ColumnNameIdentifier("mySecondColumn")
}
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<empty>"));
Assert.That(xml, Does.Contain("<column identifier=\"[myFirstColumn]\" />"));
Assert.That(xml, Does.Contain("<column identifier=\"[mySecondColumn]\" />"));
Assert.That(xml, Does.Not.Contain("column-count"));
}
public void Serialize_FileWithParser_NoAttributeTwoElements()
{
var root = new ResultSetSystemXml()
{
File = new FileXml
{
Path = "c:\\myFile.txt",
Parser = new ParserXml()
{
Name = "myName"
}
}
};
var overrides = new WriteOnlyAttributes();
overrides.Build();
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root, overrides);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<file>"));
Assert.That(xml, Does.Contain("<path>c:\\myFile.txt</path>"));
Assert.That(xml, Does.Contain("<parser name=\"myName\" />"));
Assert.That(xml, Does.Contain("</file>"));
}
public void Serialize_Renaming_Correct()
{
var root = new ResultSetSystemXml()
{
File = new FileXml()
{
Path = @"C:\Temp\foo.txt"
},
Alterations = new List <AlterationXml>()
{
new RenamingXml()
{
Identifier = new ColumnOrdinalIdentifier(5), NewName = "myNewName"
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<rename"));
Assert.That(xml, Does.Contain("#5"));
Assert.That(xml, Does.Contain("myNewName"));
}
public void Serialize_ProjectAway_Correct()
{
var root = new ResultSetSystemXml()
{
Alterations = new List <AlterationXml>()
{
new ProjectAwayXml()
{
Columns = new List <ColumnDefinitionLightXml>()
{
new ColumnDefinitionLightXml()
{
Identifier = new ColumnOrdinalIdentifier(2)
},
new ColumnDefinitionLightXml()
{
Identifier = new ColumnNameIdentifier("foo")
},
}
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<project-away>"));
Assert.That(xml, Does.Contain("<column identifier=\"#2\" />"));
Assert.That(xml, Does.Contain("<column identifier=\"[foo]\" />"));
}
protected virtual object InstantiateSystemUnderTest(ResultSetSystemXml resultSetXml)
{
var builder = new ResultSetServiceBuilder();
builder.Setup(InstantiateResolver(resultSetXml));
builder.Setup(InstantiateAlterations(resultSetXml));
return(builder.GetService());
}
protected virtual object InstantiateSystemUnderTest(ResultSetSystemXml resultSetXml)
{
var builder = new ResultSetServiceBuilder();
var helper = new ResultSetSystemHelper(ServiceLocator, SettingsXml.DefaultScope.SystemUnderTest, Variables);
builder.Setup(helper.InstantiateResolver(resultSetXml));
builder.Setup(helper.InstantiateAlterations(resultSetXml));
return(builder.GetService());
}
public void IsHandling_ResultSetReferenceExists_True()
{
var sutXml = new ResultSetSystemXml();
var ctrXml = new LookupExistsXml();
var testCaseFactory = new TestCaseFactory();
var actual = testCaseFactory.IsHandling(sutXml.GetType(), ctrXml.GetType());
Assert.That(actual, Is.True);
}
public void Serialize_Unstack_Correct()
{
var root = new ResultSetSystemXml()
{
Alterations = new List <AlterationXml>()
{
new UnstackXml()
{
Header = new HeaderXml()
{
Column = new ColumnDefinitionLightXml()
{
Identifier = new ColumnOrdinalIdentifier(2), Type = ColumnType.Text
},
EnforcedValues = new List <string>()
{
"Alpha", "Beta"
}
},
GroupBy = new GroupByXml()
{
Columns = new List <ColumnDefinitionLightXml>()
{
new ColumnDefinitionLightXml()
{
Identifier = new ColumnOrdinalIdentifier(0), Type = ColumnType.Numeric
},
new ColumnDefinitionLightXml()
{
Identifier = new ColumnOrdinalIdentifier(1), Type = ColumnType.DateTime
}
}
},
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<unstack>"));
Assert.That(xml, Does.Contain("<header>"));
Assert.That(xml, Does.Contain("<column identifier=\"#2\" />"));
Assert.That(xml, Does.Contain("<group-by>"));
Assert.That(xml, Does.Contain("<column identifier=\"#0\" type=\"numeric\" />"));
Assert.That(xml, Does.Contain("<column identifier=\"#1\" type=\"dateTime\" />"));
Assert.That(xml, Does.Contain("<enforced-value>"));
Assert.That(xml, Does.Contain(">Alpha<"));
Assert.That(xml, Does.Contain(">Beta<"));
}
protected virtual IResultSetResolver InstantiateResolver(ResultSetSystemXml resultSetXml)
{
var argsBuilder = new ResultSetResolverArgsBuilder();
argsBuilder.Setup(resultSetXml);
argsBuilder.Setup(resultSetXml.Settings);
argsBuilder.Setup(base.Variables);
argsBuilder.Build();
var factory = new ResultSetResolverFactory();
var resolver = factory.Instantiate(argsBuilder.GetArgs());
return(resolver);
}
public IResultSetResolver InstantiateResolver(ResultSetSystemXml resultSetXml)
{
var argsBuilder = new ResultSetResolverArgsBuilder(serviceLocator);
argsBuilder.Setup(resultSetXml);
argsBuilder.Setup(resultSetXml.Settings);
argsBuilder.Setup(variables);
argsBuilder.Build();
var factory = serviceLocator.GetResultSetResolverFactory();
var resolver = factory.Instantiate(argsBuilder.GetArgs());
return(resolver);
}
protected virtual object InstantiateSystemUnderTest(ResultSetSystemXml resultSetXml)
{
if (!string.IsNullOrEmpty(resultSetXml.File))
{
Trace.WriteLineIf(NBiTraceSwitch.TraceVerbose, "ResultSet defined in external file!");
return(resultSetXml.GetFile());
//if (resultSetXml.Settings.CsvProfile != null)
//ctr = ctr.CsvProfile(resultSetXml.Settings.CsvProfile);
}
else if (resultSetXml.Rows != null)
{
Trace.WriteLineIf(NBiTraceSwitch.TraceVerbose, "ResultSet defined in embedded resultSet!");
return(resultSetXml.Content);
}
throw new ArgumentException();
}
public void Serialize_EmptyWithoutColumns_Correct()
{
var root = new ResultSetSystemXml()
{
Empty = new EmptyResultSetXml {
ColumnCount = "4"
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<empty"));
Assert.That(xml, Does.Contain("column-count=\"4\""));
Assert.That(xml, Does.Not.Contain("<column"));
}
public void Serialize_InlineFileAndParser_Correct()
{
var root = new ResultSetSystemXml()
{
#pragma warning disable 0618
FilePath = "myFile.csv!myParser",
#pragma warning restore 0618
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Is.StringContaining("<file>"));
Assert.That(xml, Is.StringContaining("<path>myFile.csv</path>"));
Assert.That(xml, Is.StringContaining("<parser name=\"myParser\" />"));
Assert.That(xml, Is.StringContaining("</file>"));
}
public void Serialize_InlineFileWithoutParser_Correct()
{
var root = new ResultSetSystemXml()
{
#pragma warning disable 0618
FilePath = "myFile.csv",
#pragma warning restore 0618
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<file>"));
Assert.That(xml, Does.Contain("<path>myFile.csv</path>"));
Assert.That(xml, Does.Not.Contain("<parser"));
Assert.That(xml, Does.Contain("</file>"));
}
public void Serialize_LookupReplace_Correct()
{
var root = new ResultSetSystemXml()
{
Alterations = new List <AlterationXml>()
{
new LookupReplaceXml()
{
Missing = new NBi.Xml.Items.Alteration.Lookup.MissingXml()
{
Behavior = Behavior.DefaultValue, DefaultValue = "(null)"
},
Join = new JoinXml()
{
Usings = new List <ColumnUsingXml>()
{
new ColumnUsingXml()
{
Column = "#1"
}
}
},
ResultSet = new ResultSetSystemXml(),
Replacement = new ColumnDefinitionLightXml()
{
Identifier = new ColumnNameIdentifier("foo")
}
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<lookup-replace>"));
Assert.That(xml, Does.Contain("<missing behavior=\"default-value\">(null)</missing>"));
Assert.That(xml, Does.Contain("<join>"));
Assert.That(xml, Does.Contain("<result-set"));
Assert.That(xml, Does.Contain("<replacement identifier=\"[foo]\" />"));
}
public void Serialize_Sequence_Correct()
{
var root = new ResultSetSystemXml()
{
Sequence = new SequenceXml()
{
Items = new List <string>()
{
"A", "B"
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<sequence"));
Assert.That(xml, Does.Contain("<item>A</item>"));
Assert.That(xml, Does.Contain("<item>B</item>"));
}
private 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);
}
}
}
}
public void Serialize_AlterTransform_IdentifierCorrect()
{
var root = new ResultSetSystemXml()
{
Alterations = new List <AlterationXml>()
{
new TransformXml()
{
Identifier = new ColumnIdentifierFactory().Instantiate("[MyName]"),
Language = LanguageType.Native,
Code = "empty-to-null"
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<transform "));
Assert.That(xml, Does.Contain("column=\"[MyName]\""));
}
public void Instantiate_ResultSetReferenceExists_TestCase()
{
var sutXml = new ResultSetSystemXml();
var ctrXml = new LookupExistsXml();
var builderMockFactory = new Mock <ITestCaseBuilder>();
builderMockFactory.Setup(b => b.Setup(sutXml, ctrXml, NBi.Core.Configuration.Configuration.Default, It.IsAny <Dictionary <string, ITestVariable> >(), It.IsAny <ServiceLocator>()));
builderMockFactory.Setup(b => b.Build());
builderMockFactory.Setup(b => b.GetSystemUnderTest()).Returns(new RelationalCommand(new SqlCommand(), null, null));
builderMockFactory.Setup(b => b.GetConstraint()).Returns(new IsConstraint("x"));
var builder = builderMockFactory.Object;
var testCaseFactory = new TestCaseFactory();
testCaseFactory.Register(typeof(ResultSetSystemXml), typeof(LookupExistsXml), builder);
var tc = testCaseFactory.Instantiate(sutXml, ctrXml);
Assert.That(tc, Is.Not.Null);
builderMockFactory.VerifyAll();
}
public void Serialize_IfUnavailable_Correct()
{
var root = new ResultSetSystemXml()
{
IfUnavailable = new IfUnavailableXml
{
ResultSet = new ResultSetSystemXml {
Empty = new EmptyResultSetXml {
ColumnCount = "2"
}
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<if-unavailable"));
Assert.That(xml, Does.Contain("<result-set"));
Assert.That(xml, Does.Contain("<empty"));
}
public void Serialize_FileAndParser_Correct()
{
var root = new ResultSetSystemXml()
{
File = new FileXml()
{
Path = "myFile.csv",
Parser = new ParserXml()
{
Name = "myParser",
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<file>"));
Assert.That(xml, Does.Contain("<path>myFile.csv</path>"));
Assert.That(xml, Does.Contain("<parser name=\"myParser\" />"));
Assert.That(xml, Does.Contain("</file>"));
}
public void Serialize_LookupReplaceDefaultMissing_Correct()
{
var root = new ResultSetSystemXml()
{
Alterations = new List <AlterationXml>()
{
new LookupReplaceXml()
{
Missing = new MissingXml()
{
Behavior = Behavior.Failure
},
}
}
};
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<lookup-replace"));
Assert.That(xml, Does.Not.Contain("<missing"));
}
public void Serialize_JustFileName_NoElementForParser()
{
var root = new ResultSetSystemXml()
{
File = new FileXml
{
Path = "c:\\myFile.txt",
}
};
var overrides = new WriteOnlyAttributes();
overrides.Build();
var manager = new XmlManager();
var xml = manager.XmlSerializeFrom(root, overrides);
Console.WriteLine(xml);
Assert.That(xml, Does.Contain("<file>"));
Assert.That(xml, Does.Contain("<path>c:\\myFile.txt</path>"));
Assert.That(xml, Does.Contain("</file>"));
Assert.That(xml, Does.Not.Contain("<parser"));
Assert.That(xml, Does.Not.Contain("<if-missing"));
}
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);
}
}
