private void CheckFactory(IEnumerable source, FactoryKind factoryKind, int columnCount, bool hasMetadata)
{
FactoryDataSet dataSet = new FactoryDataSet(delegate { return(source); }, factoryKind, columnCount);
DataBinding[] bindings = new DataBinding[]
{
new DataBinding(0, null),
new DataBinding(1, null)
};
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(bindings, true));
Assert.Count(3, items);
Assert.AreEqual(1, items[0].GetValue(bindings[0]));
Assert.AreEqual(2, items[1].GetValue(bindings[0]));
Assert.AreEqual(3, items[2].GetValue(bindings[0]));
if (columnCount >= 2)
{
Assert.AreEqual("a", items[0].GetValue(bindings[1]));
Assert.AreEqual("b", items[1].GetValue(bindings[1]));
Assert.AreEqual("c", items[2].GetValue(bindings[1]));
}
if (hasMetadata)
{
Assert.AreEqual("1a", DataItemUtils.GetMetadata(items[0]).GetValue("Id"));
Assert.AreEqual("2b", DataItemUtils.GetMetadata(items[1]).GetValue("Id"));
Assert.AreEqual("3c", DataItemUtils.GetMetadata(items[2]).GetValue("Id"));
}
}
public void ProducesMetadata()
{
XmlDocument document = new XmlDocument();
document.LoadXml("<root><rows><row a=\"42\" b=\"x\"><metadata xmlns=\"http://www.gallio.org/\"><entry key=\"Metadata\" value=\"abc\"/></metadata></row><row a=\"53\" b=\"y\"><metadata xmlns=\"http://www.gallio.org/\"><entry key=\"Metadata\" value=\"def\"/></metadata></row></rows></root>");
XmlDataSet dataSet = new XmlDataSet(delegate { return(document); }, "//row", false);
dataSet.DataLocationName = "<inline>";
Assert.AreEqual("<inline>", dataSet.DataLocationName);
DataBinding binding = new DataBinding(null, "@a");
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(new DataBinding[] { binding }, true));
Assert.AreEqual("42", ((XPathNavigator)items[0].GetValue(binding)).Value);
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.AreEqual("<inline>", map.GetValue(MetadataKeys.DataLocation));
Assert.AreEqual("abc", map.GetValue("Metadata"));
Assert.AreEqual("53", ((XPathNavigator)items[1].GetValue(binding)).Value);
map = DataItemUtils.GetMetadata(items[1]);
Assert.AreEqual("<inline>", map.GetValue(MetadataKeys.DataLocation));
Assert.AreEqual("def", map.GetValue("Metadata"));
}
public void HasNoMetadataIfNullSpecifiedInConstructor()
{
ListDataItem <object> item = new ListDataItem <object>(EmptyArray <object> .Instance, null, false);
PropertyBag metadata = DataItemUtils.GetMetadata(item);
Assert.Count(0, metadata);
}
public void ProducesMetadata()
{
string document = "value,[Metadata]\n123,abc\n456,def";
Gallio.Common.GallioFunc <TextReader> documentReaderProvider = delegate { return(new StringReader(document)); };
CsvDataSet dataSet = new CsvDataSet(documentReaderProvider, false);
dataSet.HasHeader = true;
dataSet.DataLocationName = "<inline>";
Assert.AreEqual("<inline>", dataSet.DataLocationName);
DataBinding binding = new DataBinding(0, null);
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(new DataBinding[] { binding }, true));
Assert.AreEqual("123", items[0].GetValue(binding));
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.AreEqual("<inline>(2)", map.GetValue(MetadataKeys.DataLocation));
Assert.AreEqual("abc", map.GetValue("Metadata"));
Assert.AreEqual("456", items[1].GetValue(binding));
map = new PropertyBag();
items[1].PopulateMetadata(map);
Assert.AreEqual("<inline>(3)", map.GetValue(MetadataKeys.DataLocation));
Assert.AreEqual("def", map.GetValue("Metadata"));
}
public void GetItemsAppliesIndexAliasTranslation()
{
List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();
metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
IDataSet dataSet = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSet.ColumnCount).Return(3);
Expect.Call(dataSet.GetItems(null, true)).IgnoreArguments().Do((GetItemsDelegate) delegate(ICollection <DataBinding> bindings,
bool includeDynamicItems)
{
Assert.IsTrue(includeDynamicItems);
List <IDataItem> items = new List <IDataItem>();
items.Add(new ListDataItem <object>(new object[] { "abc", "def", "ghi" }, metadataPairs, true));
List <DataBinding> bindingList = new List <DataBinding>(bindings);
Assert.AreEqual("translatedPath", bindingList[0].Path);
Assert.AreEqual(2, bindingList[0].Index);
Assert.AreEqual("untranslatedPath", bindingList[1].Path);
Assert.AreEqual(1, bindingList[1].Index);
return(items);
});
}
using (Mocks.Playback())
{
DataSource source = new DataSource("theName");
source.AddIndexAlias("translatedPath", 2);
source.AddDataSet(dataSet);
DataBinding[] bindings = new DataBinding[] {
new DataBinding(5, "translatedPath"),
new DataBinding(1, "untranslatedPath")
};
List <IDataItem> items = new List <IDataItem>(source.GetItems(bindings, true));
Assert.Count(1, items);
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(1, map);
Assert.AreEqual("Bar", map.GetValue("Foo"));
Assert.Throws <ArgumentNullException>(delegate { items[0].GetValue(null); });
Assert.AreEqual("ghi", items[0].GetValue(bindings[0]));
Assert.AreEqual("def", items[0].GetValue(bindings[1]));
// Should throw ArgumentNullException when binding list is null.
Assert.Throws <ArgumentNullException>(delegate
{
items[0].GetValue(null);
});
}
}
public void HasNoMetadataIfNullSpecifiedInConstructor()
{
ScalarDataItem <object> item = new ScalarDataItem <object>(null, null, false);
PropertyBag metadata = DataItemUtils.GetMetadata(item);
Assert.Count(0, metadata);
}
public void GetMetadataReturnsAnEmptyArrayIfConstructorArgumentWasNull()
{
SimpleDataItem item = new StubDataItem(null, false);
PropertyBag map = DataItemUtils.GetMetadata(item);
Assert.Count(0, map);
}
public void ItemsContainEmptyMetadataWhenParameterWasNull()
{
ValueSequenceDataSet dataSet = new ValueSequenceDataSet(new object[] { "a" }, null, false);
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(EmptyArray <DataBinding> .Instance, true));
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(0, map);
}
public void GetMetadataReturnsSameEnumerationAsWasSpecifiedInConstructor()
{
List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();
metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
BaseDataItem item = new StubDataItem(metadataPairs, false);
PropertyBag map = DataItemUtils.GetMetadata(item);
Assert.Count(1, map);
Assert.AreEqual("Bar", map.GetValue("Foo"));
}
public void ContainSameMetadataAsSpecifiedInConstructor()
{
List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();
metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
ScalarDataItem <object> item = new ScalarDataItem <object>("abc", metadataPairs, false);
PropertyBag map = DataItemUtils.GetMetadata(item);
Assert.Count(1, map);
Assert.AreEqual("Bar", map.GetValue("Foo"));
}
public void ItemsContainSameMetadataAsSpecifiedInConstructor()
{
List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();
metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
ValueSequenceDataSet dataSet = new ValueSequenceDataSet(new object[] { "a" }, metadataPairs, false);
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(EmptyArray <DataBinding> .Instance, true));
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(1, map);
Assert.AreEqual("Bar", map.GetValue("Foo"));
}
public void IgnoresMissingMetadataColumns()
{
string document = "value,[Metadata]\n123";
Gallio.Common.GallioFunc <TextReader> documentReaderProvider = delegate { return(new StringReader(document)); };
CsvDataSet dataSet = new CsvDataSet(documentReaderProvider, false)
{
HasHeader = true
};
DataBinding binding = new DataBinding(0, null);
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(new DataBinding[] { binding }, true));
Assert.AreEqual("123", items[0].GetValue(binding));
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.IsFalse(map.ContainsKey("Metadata"));
}
public void ShouldProvideFluentInterfaceForBuildingMetadata()
{
PropertyBag extraMetadata = new PropertyBag();
extraMetadata.SetValue("Author", "Lewis Carroll");
extraMetadata.SetValue("Title", "The Jabberwocky");
DataRow row = new DataRow("abc")
.WithMetadata("Description", "Frumious")
.WithMetadata("Name", "Bandersnatch")
.WithMetadata(extraMetadata);
Assert.AreEqual("abc", row.GetValue(new DataBinding(0, null)));
PropertyBag map = DataItemUtils.GetMetadata(row);
Assert.Count(4, map);
Assert.AreEqual("Frumious", map.GetValue("Description"));
Assert.AreEqual("Bandersnatch", map.GetValue("Name"));
Assert.AreEqual("Lewis Carroll", map.GetValue("Author"));
Assert.AreEqual("The Jabberwocky", map.GetValue("Title"));
}
public void Run()
{
if (executor.progressMonitor.IsCanceled)
{
outcome = TestOutcome.Canceled;
return;
}
TestOutcome instanceOutcome;
try
{
PatternTestInstanceActions decoratedTestInstanceActions = testState.TestActions.TestInstanceActions.Copy();
instanceOutcome = primaryContext.Sandbox.Run(TestLog.Writer,
new DecorateTestInstanceAction(testState, decoratedTestInstanceActions).Run, "Decorate Child Test");
if (instanceOutcome.Status == TestStatus.Passed)
{
bool invisibleTestInstance = true;
PatternTestStep testStep;
if (reusePrimaryTestStep)
{
testStep = testState.PrimaryTestStep;
invisibleTestInstance = false;
PropertyBag map = DataItemUtils.GetMetadata(bindingItem);
foreach (KeyValuePair <string, string> entry in map.Pairs)
{
primaryContext.AddMetadata(entry.Key, entry.Value);
}
}
else
{
testStep = new PatternTestStep(testState.Test, testState.PrimaryTestStep,
testState.Test.Name, testState.Test.CodeElement, false);
testStep.Kind = testState.Test.Kind;
testStep.IsDynamic = bindingItem.IsDynamic;
bindingItem.PopulateMetadata(testStep.Metadata);
}
var bodyAction = new RunTestInstanceAction(executor, testCommand);
var testInstanceState = new PatternTestInstanceState(testStep, decoratedTestInstanceActions, testState, bindingItem, bodyAction.Run);
bodyAction.TestInstanceState = testInstanceState;
instanceOutcome = instanceOutcome.CombineWith(primaryContext.Sandbox.Run(
TestLog.Writer, new BeforeTestInstanceAction(testInstanceState).Run, "Before Test Instance"));
if (instanceOutcome.Status == TestStatus.Passed)
{
executor.progressMonitor.SetStatus(testStep.Name);
TestContext context = reusePrimaryTestStep
? primaryContext
: TestContext.PrepareContext(testCommand.StartStep(testStep), primaryContext.Sandbox.CreateChild());
testState.SetInContext(context);
testInstanceState.SetInContext(context);
invisibleTestInstance = false;
using (context.Enter())
{
if (RunTestInstanceBodyAction.CanOptimizeCallChainAndInvokeBodyActionDirectly(testInstanceState))
{
bodyAction.SkipProtect = true;
instanceOutcome = instanceOutcome.CombineWith(bodyAction.Run());
}
else
{
var runTestInstanceBodyAction = new RunTestInstanceBodyAction(testInstanceState);
TestOutcome sandboxOutcome = context.Sandbox.Run(TestLog.Writer, runTestInstanceBodyAction.Run, "Body");
instanceOutcome = instanceOutcome.CombineWith(runTestInstanceBodyAction.Outcome.CombineWith(sandboxOutcome));
}
}
if (!reusePrimaryTestStep)
{
context.FinishStep(instanceOutcome);
}
executor.progressMonitor.SetStatus("");
}
instanceOutcome = instanceOutcome.CombineWith(primaryContext.Sandbox.Run(
TestLog.Writer, new AfterTestInstanceAction(testInstanceState).Run, "After Test Instance"));
if (invisibleTestInstance)
{
instanceOutcome = PublishOutcomeFromInvisibleTest(testCommand, testStep, instanceOutcome).Outcome;
}
}
}
catch (Exception ex)
{
string message = String.Format("An exception occurred while preparing an instance of test '{0}'.", testState.Test.FullName);
if (reusePrimaryTestStep)
{
TestLog.Failures.WriteException(ex, message);
instanceOutcome = TestOutcome.Error;
}
else
{
instanceOutcome = ReportTestError(testCommand, testState.PrimaryTestStep, ex, message).Outcome;
}
}
outcome = instanceOutcome;
}
public void HasNoMetadata()
{
PropertyBag metadata = DataItemUtils.GetMetadata(NullDataItem.Instance);
Assert.Count(0, metadata);
}
public void GetItemsDelegatesToTheStrategy()
{
JoinedDataSet dataSet = new JoinedDataSet();
IList <KeyValuePair <string, string> > metadata1 = new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("abc", "123"),
new KeyValuePair <string, string>("def", "456")
};
IList <KeyValuePair <string, string> > metadata2 = new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("ghi", "789"),
};
DataSource dataSet1 = new DataSource("");
dataSet1.AddIndexAlias("path", 1);
dataSet1.AddDataSet(new ItemSequenceDataSet(new IDataItem[]
{
new ListDataItem <int>(new int[] { 1, 2, 3 }, metadata1, false),
new ListDataItem <int>(new int[] { -1, -2, -3 }, metadata2, false)
}, 3));
dataSet.AddDataSet(dataSet1);
IDataSet dataSet2 = new ItemSequenceDataSet(new IDataItem[]
{
new ListDataItem <int>(new int[] { 4, 5 }, metadata2, false),
new ListDataItem <int>(new int[] { -4, -5 }, null, true)
}, 2);
dataSet.AddDataSet(dataSet2);
List <IDataItem> dataSet1Items = new List <IDataItem>(dataSet1.GetItems(EmptyArray <DataBinding> .Instance, true));
List <IDataItem> dataSet2Items = new List <IDataItem>(dataSet2.GetItems(EmptyArray <DataBinding> .Instance, true));
List <IList <IDataItem> > results = new List <IList <IDataItem> >();
results.Add(new IDataItem[] { dataSet1Items[0], dataSet2Items[0] });
results.Add(new IDataItem[] { dataSet1Items[1], dataSet2Items[1] });
IJoinStrategy strategy = Mocks.StrictMock <IJoinStrategy>();
dataSet.Strategy = strategy;
DataBinding pathBinding = new DataBinding(null, "path");
DataBinding indexZeroBinding = new DataBinding(0, null);
DataBinding indexOneBinding = new DataBinding(1, null);
DataBinding indexThreeBinding = new DataBinding(3, null);
DataBinding[] bindings = new DataBinding[]
{
new DataBinding(null, null), // unresolvable binding because no data sets can claim it
pathBinding, // claimed by dataSet1
indexZeroBinding, // claimed by dataSet1
indexThreeBinding, // claimed by dataSet2
dataSet.TranslateBinding(dataSet1, pathBinding), // scoped by dataSet1
dataSet.TranslateBinding(dataSet2, indexOneBinding), // scoped by dataSet2
};
using (Mocks.Record())
{
Expect.Call(strategy.Join(null, null, true)).IgnoreArguments().Do((JoinDelegate) delegate(IList <IDataProvider> joinProviders, IList <ICollection <DataBinding> > joinBindingsPerProvider,
bool includeDynamicItems)
{
Assert.IsTrue(includeDynamicItems);
Assert.AreElementsEqual(new IDataProvider[] { dataSet1, dataSet2 }, joinProviders);
Assert.Count(2, joinBindingsPerProvider);
Assert.AreElementsEqual(new DataBinding[] { pathBinding, indexZeroBinding, pathBinding }, joinBindingsPerProvider[0]);
Assert.AreElementsEqual(new DataBinding[] { indexZeroBinding, indexOneBinding }, joinBindingsPerProvider[1]);
return(results);
});
}
using (Mocks.Playback())
{
List <IDataItem> items = new List <IDataItem>(dataSet.GetItems(bindings, true));
Assert.Count(2, items);
Assert.Throws <ArgumentNullException>(delegate { items[0].GetValue(null); });
Assert.Throws <DataBindingException>(delegate { items[0].GetValue(bindings[0]); });
Assert.AreEqual(2, items[0].GetValue(bindings[1]));
Assert.AreEqual(1, items[0].GetValue(bindings[2]));
Assert.AreEqual(4, items[0].GetValue(bindings[3]));
Assert.AreEqual(2, items[0].GetValue(bindings[4]));
Assert.AreEqual(5, items[0].GetValue(bindings[5]));
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(3, map);
Assert.AreEqual("123", map.GetValue("abc"));
Assert.AreEqual("456", map.GetValue("def"));
Assert.AreEqual("789", map.GetValue("ghi"));
Assert.IsFalse(items[0].IsDynamic);
Assert.Throws <DataBindingException>(delegate { items[1].GetValue(bindings[0]); });
Assert.AreEqual(-2, items[1].GetValue(bindings[1]));
Assert.AreEqual(-1, items[1].GetValue(bindings[2]));
Assert.AreEqual(-4, items[1].GetValue(bindings[3]));
Assert.AreEqual(-2, items[1].GetValue(bindings[4]));
Assert.AreEqual(-5, items[1].GetValue(bindings[5]));
map = DataItemUtils.GetMetadata(items[1]);
Assert.Count(1, map);
Assert.AreEqual("789", map.GetValue("ghi"));
Assert.IsTrue(items[1].IsDynamic);
}
}
