public void GetSegments_Expected_LastSegmentIsCorrect() { PocoPath path = new PocoPath("EnumerableData().NestedData.NestedData.Name", "EnumerableData.NestedData.NestedData.Name"); string expected = "Name"; string actual = path.GetSegements().Last().ToString(); Assert.AreEqual(expected, actual); }
public void GetSegments_Expected_CorrectSegmentCount() { PocoPath path = new PocoPath("EnumerableData().NestedData.Name", "EnumerableData.NestedData.Name"); int expected = 3; int actual = path.GetSegements().Count(); Assert.AreEqual(expected, actual); }
public void ToStringOnEnumerableSegment_WhereEnumerablesAreConsidered_Expected_ScalarFormat() { PocoPath path = new PocoPath(); IPathSegment segment = path.CreatePathSegment("Collection()"); const string expected = "Collection()"; string actual = segment.ToString(true); Assert.AreEqual(expected, actual); }
public void ToStringOnScalarSegment_Expected_ScalarFormat() { PocoPath path = new PocoPath(); IPathSegment segment = path.CreatePathSegment("Name"); const string expected = "Name"; string actual = segment.ToString(); Assert.AreEqual(expected, actual); }
public void CreateScalarPathSegmentFromPropertyInfo_Expected_ScalarPocoPathSegment() { PropertyInfo propertyInfo = typeof(PocoTestData).GetProperty("Name"); PocoPath path = new PocoPath(); IPathSegment segment = path.CreatePathSegment(propertyInfo); bool expected = false; bool actual = segment.IsEnumarable; Assert.AreEqual(expected, actual); }
public void CreateEnumerablePathSegmentFromPropertyInfo_Expected_EnumerablePocoPathSegment() { PropertyInfo propertyInfo = typeof(PocoTestData).GetProperty("EnumerableData"); PocoPath path = new PocoPath(); IPathSegment segment = path.CreatePathSegment(propertyInfo); const bool expected = true; bool actual = segment.IsEnumarable; Assert.AreEqual(expected, actual); }
private IPath BuildPath(Stack <Tuple <PropertyInfo, bool, object> > propertyStack, PropertyInfo property, object root) { var path = new PocoPath(); path.ActualPath = string.Join(PocoPath.SeperatorSymbol, propertyStack.Reverse().Select(p => path.CreatePathSegment(p.Item1).ToString(p.Item2))); List <Tuple <IPathSegment, bool> > displayPathSegments = propertyStack.Reverse() .Select(p => new Tuple <IPathSegment, bool>(path.CreatePathSegment(p.Item1), p.Item2)) .ToList(); bool recordsetEncountered = false; for (int i = displayPathSegments.Count - 1; i >= 0; i--) { Tuple <IPathSegment, bool> pathSegment = displayPathSegments[i]; if (recordsetEncountered) { pathSegment.Item1.IsEnumarable = false; } if (pathSegment.Item1.IsEnumarable && pathSegment.Item2) { recordsetEncountered = true; } } path.DisplayPath = string.Join(PocoPath.SeperatorSymbol, displayPathSegments.Select(p => p.Item1.ToString(p.Item2))); if (path.ActualPath != string.Empty) { path.ActualPath += PocoPath.SeperatorSymbol; } if (path.DisplayPath != string.Empty) { path.DisplayPath += PocoPath.SeperatorSymbol; } path.ActualPath += path.CreatePathSegment(property).ToString(); path.DisplayPath += path.CreatePathSegment(property).ToString(); path.SampleData = GetSampleData(root, path); return(path); }
IPath BuildPath(Stack <Tuple <string, bool, bool, object> > propertyStack, string name, bool isEnumerable) { var path = new PocoPath(); path.ActualPath = string.Join(PocoPath.SeperatorSymbol, propertyStack.Reverse().Select(p => path.CreatePathSegment(p.Item1, p.Item2).ToString(p.Item3))); var displayPathSegments = propertyStack.Reverse() .Select(p => new Tuple <IPathSegment, bool>(path.CreatePathSegment(p.Item1, p.Item2), p.Item3)) .ToList(); var recordsetEncountered = false; for (int i = displayPathSegments.Count - 1; i >= 0; i--) { var pathSegment = displayPathSegments[i]; if (recordsetEncountered) { pathSegment.Item1.IsEnumarable = false; } if (pathSegment.Item1.IsEnumarable && pathSegment.Item2) { recordsetEncountered = true; } } path.DisplayPath = string.Join(PocoPath.SeperatorSymbol, displayPathSegments.Select(p => p.Item1.ToString(p.Item2))); if (path.ActualPath != string.Empty) { path.ActualPath += PocoPath.SeperatorSymbol; } if (path.DisplayPath != string.Empty) { path.DisplayPath += PocoPath.SeperatorSymbol; } path.ActualPath += path.CreatePathSegment(name, isEnumerable); path.DisplayPath += path.CreatePathSegment(name, isEnumerable); return(path); }
public IEnumerable <object> SelectEnumerable(IPath path) { if (path == null) { throw new ArgumentNullException("path"); } PocoPath pocoPath = path as PocoPath; if (pocoPath == null) { throw new Exception(string.Format("Path of type '{0}' expected, path of type '{1}' received.", typeof(PocoPath), path.GetType())); } List <object> returnData; if (path.ActualPath == PocoPath.SeperatorSymbol) { returnData = new List <object> { Data }; } else if (path.ActualPath == PocoPath.EnumerableSymbol + PocoPath.SeperatorSymbol) { IEnumerable enumerableData = Data as IEnumerable; returnData = new List <object>(); if (enumerableData != null) { IEnumerator enumerator = enumerableData.GetEnumerator(); enumerator.Reset(); while (enumerator.MoveNext()) { returnData.Add(enumerator.Current); } } } else { returnData = SelectEnumberable(pocoPath.GetSegements().ToList(), Data).ToList(); } return(returnData); }
private IPath BuildPath(Stack<Tuple<PropertyInfo, bool, object>> propertyStack, PropertyInfo property, object root) { var path = new PocoPath(); path.ActualPath = string.Join(PocoPath.SeperatorSymbol, propertyStack.Reverse().Select(p => path.CreatePathSegment(p.Item1).ToString(p.Item2))); List<Tuple<IPathSegment, bool>> displayPathSegments = propertyStack.Reverse() .Select(p => new Tuple<IPathSegment, bool>(path.CreatePathSegment(p.Item1), p.Item2)) .ToList(); bool recordsetEncountered = false; for (int i = displayPathSegments.Count - 1; i >= 0; i--) { Tuple<IPathSegment, bool> pathSegment = displayPathSegments[i]; if (recordsetEncountered) { pathSegment.Item1.IsEnumarable = false; } if (pathSegment.Item1.IsEnumarable && pathSegment.Item2) recordsetEncountered = true; } path.DisplayPath = string.Join(PocoPath.SeperatorSymbol, displayPathSegments.Select(p => p.Item1.ToString(p.Item2))); if (path.ActualPath != string.Empty) { path.ActualPath += PocoPath.SeperatorSymbol; } if (path.DisplayPath != string.Empty) { path.DisplayPath += PocoPath.SeperatorSymbol; } path.ActualPath += path.CreatePathSegment(property).ToString(); path.DisplayPath += path.CreatePathSegment(property).ToString(); path.SampleData = GetSampleData(root, path); return path; }
public void SelectEnumerableValueUsingPocoEnumerablePathFromReferenceType_Expected_ValuesFromEachItemInEnumeration() { PocoTestData testData = GivenPoco(); IPath namePath = new PocoPath("EnumerableData().Name", "EnumerableData.Name"); IDataBrowser dataBrowser = DataBrowserFactory.CreateDataBrowser(); IEnumerable<object> data = dataBrowser.SelectEnumerable(namePath, testData); string expected = string.Join("|", testData.EnumerableData.Select(e => e.Name)); string actual = string.Join("|", data.Select(o => o.ToString())); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesAsRelatedFromReferenceType_Where_PathsContainUnrelatedEnumerablePaths_Expected_FlattenedDataWithValuesFromUnrelatedEnumerablePathsAtMatchingIndexes() { PocoTestData testData = GivenWithParallelAndNestedEnumerables(); PocoPath enumerableNamePath = new PocoPath("EnumerableData().Name", "EnumerableData.Name"); PocoPath parallelEnumerableNamePath = new PocoPath("EnumerableData1().Name", "EnumerableData1.Name"); //PocoPath nestedEnumerableNamePath = new PocoPath("EnumerableData().EnumerableData().Name", "EnumerableData.EnumerableData.Name"); List<IPath> paths = new List<IPath> { enumerableNamePath, parallelEnumerableNamePath }; PocoNavigator pocoNavigator = new PocoNavigator(testData); Dictionary<IPath, IList<object>> data = pocoNavigator.SelectEnumerablesAsRelated(paths); int maxCount = Math.Max(testData.EnumerableData.Count, testData.EnumerableData1.Count); #region Complex Setup for Expected // // The code in this region is used to setup the exprected value. // It can't be reused for other tests and can't be made generic // without replicating the funcationality being tested. // string tmpExpected = ""; string tmpExpected1 = ""; string separator = "|"; for (int i = 0; i < maxCount; i++) { if (i == maxCount - 1) separator = ""; if (i < testData.EnumerableData.Count) { tmpExpected += testData.EnumerableData[i].Name + separator; } else { tmpExpected += separator; } if (i < testData.EnumerableData1.Count) { tmpExpected1 += testData.EnumerableData1[i].Name + separator; } else { tmpExpected1 += separator; } } #endregion Complex Setup for Expected string expected = tmpExpected + "^" + tmpExpected1; string actual = string.Join("|", data[enumerableNamePath]); actual += "^" + string.Join("|", data[parallelEnumerableNamePath]); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesUsingEnumerablePathFromReferenceType_Where_EnumerableDataIsNull_Expected_Null() { PocoTestData testData = GivenWithNoEnumerableData(); IPath namePath = new PocoPath("EnumerableData().Name", "EnumerableData.Name"); PocoNavigator pocoNavigator = new PocoNavigator(testData); object data = pocoNavigator.SelectScalar(namePath); Assert.AreEqual(data, null); }
public void SelectScalarValueUsingEnumerablePathFromReferenceType_Expected_ScalarValueFromLastItemInEnumerableCollection() { PocoTestData testData = Given(); IPath namePath = new PocoPath("EnumerableData().NestedData.Name", "EnumerableData.NestedData.Name"); PocoNavigator pocoNavigator = new PocoNavigator(testData); object data = pocoNavigator.SelectScalar(namePath); Assert.AreEqual(data, testData.EnumerableData.ElementAt(testData.EnumerableData.Count - 1).NestedData.Name); }
public void CreateScalarPathSegmentFromSegmentText_Expected_ScalarPocoPathSegment() { PocoPath path = new PocoPath(); IPathSegment segment = path.CreatePathSegment("Name"); bool expected = false; bool actual = segment.IsEnumarable; Assert.AreEqual(expected, actual); }
public void SelectScalarValueUsingScalarPathFromEnumerable_Expected_ScalarValue() { PocoTestData testData = Given(); IPath path = new PocoPath("EnumerableData.Count", "EnumerableData.Count"); PocoNavigator pocoNavigator = new PocoNavigator(testData); object data = pocoNavigator.SelectScalar(path); Assert.AreEqual(data, testData.EnumerableData.Count); }
public void SelectScalarValueUsingScalarPathFromReferenceType_Expected_ScalarValue() { PocoTestData testData = Given(); IPath namePath = new PocoPath("Name", "Name"); PocoNavigator pocoNavigator = new PocoNavigator(testData); object data = pocoNavigator.SelectScalar(namePath); Assert.AreEqual(data, testData.Name); }
public void CreateEnumerablePathSegmentFromSegmentText_Expected_EnumerablePocoPathSegment() { PocoPath path = new PocoPath(); IPathSegment segment = path.CreatePathSegment("EnumerableData()"); bool expected = true; bool actual = segment.IsEnumarable; Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesUsingEnumerablePathFromReferenceType_Expected_ValuesFromEachItemInEnumeration() { PocoTestData testData = Given(); IPath namePath = new PocoPath("EnumerableData().Name", "EnumerableData.Name"); PocoNavigator pocoNavigator = new PocoNavigator(testData); IEnumerable<object> data = pocoNavigator.SelectEnumerable(namePath); string expected = string.Join("|", testData.EnumerableData.Select(e => e.Name)); string actual = string.Join("|", data.Select(o => o.ToString())); Assert.AreEqual(expected, actual); }
public void SelectScalarValueUsingRootPathFromPrimitive_Expected_ScalarValue() { Given(); IPath path = new PocoPath(PocoPath.SeperatorSymbol, PocoPath.SeperatorSymbol); PocoNavigator pocoNavigator = new PocoNavigator(1); object data = pocoNavigator.SelectScalar(path); Assert.AreEqual(data, "1"); }
public void SelectEnumerableValuesUsingScalarPathFromReferenceType_Expected_SingleValueInEnumeration() { PocoTestData testData = Given(); IPath namePath = new PocoPath("NestedData.Name", "NestedData.Name"); PocoNavigator pocoNavigator = new PocoNavigator(testData); IEnumerable<object> data = pocoNavigator.SelectEnumerable(namePath); string expected = testData.NestedData.Name; string actual = string.Join("", data.Select(o => o.ToString())); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesUsingRootPathFromPrimitive_Expected_SingleValueInEnumeration() { Given(); IPath path = new PocoPath(PocoPath.SeperatorSymbol, PocoPath.SeperatorSymbol); PocoNavigator pocoNavigator = new PocoNavigator(1); IEnumerable<object> data = pocoNavigator.SelectEnumerable(path); const string expected = "1"; string actual = string.Join("", data.Select(o => o.ToString())); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesAsRelatedFromReferenceType_Where_PathsContainASinglePathWhichIsScalar_Expected_FlattenedDataWithValueFromScalarPath() { PocoTestData testData = GivenWithParallelAndNestedEnumerables(); PocoPath namePath = new PocoPath("Name", "Name"); List<IPath> paths = new List<IPath> { namePath }; PocoNavigator pocoNavigator = new PocoNavigator(testData); Dictionary<IPath, IList<object>> data = pocoNavigator.SelectEnumerablesAsRelated(paths); string expected = testData.Name; string actual = string.Join("|", data[namePath]); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesAsRelatedUsingRootPathFromPrimitive_Expected_SingleValueInEnumeration() { Given(); IPath path = new PocoPath(PocoPath.SeperatorSymbol, PocoPath.SeperatorSymbol); List<IPath> paths = new List<IPath> { path }; PocoNavigator pocoNavigator = new PocoNavigator(1); Dictionary<IPath, IList<object>> data = pocoNavigator.SelectEnumerablesAsRelated(paths); const string expected = "1"; string actual = string.Join("|", data[path]); Assert.AreEqual(expected, actual); }
public object SelectScalar(IPath path) { if (path == null) { throw new ArgumentNullException("path"); } PocoPath pocoPath = path as PocoPath; if (pocoPath == null) { throw new Exception(string.Format("Path of type '{0}' expected, path of type '{1}' received.", typeof(PocoPath), path.GetType())); } object currentData = Data; if (path.ActualPath == PocoPath.SeperatorSymbol) { currentData = Data.ToString(); } else if (path.ActualPath == PocoPath.EnumerableSymbol + PocoPath.SeperatorSymbol) { IEnumerable enumerableData = currentData as IEnumerable; if (enumerableData == null) { currentData = null; } else { IEnumerator enumerator = enumerableData.GetEnumerator(); enumerator.Reset(); while (enumerator.MoveNext()) { currentData = enumerator.Current; } } } else { List <IPathSegment> pathSegments = pocoPath.GetSegements().ToList(); int segmentIndex = 0; while (currentData != null && segmentIndex < pathSegments.Count) { if (pathSegments[segmentIndex].IsEnumarable) { IEnumerable enumerableData = GetEnumerableValueForPathSegment(pathSegments[segmentIndex], currentData); if (enumerableData == null) { currentData = null; } else { IEnumerator enumerator = enumerableData.GetEnumerator(); enumerator.Reset(); while (enumerator.MoveNext()) { currentData = enumerator.Current; } } } else { currentData = GetScalarValueForPathSegement(pathSegments[segmentIndex], currentData); } segmentIndex++; } } return(currentData); }
public void SelectScalarValueUsingRootPathFromEnumerableContainingOnlyPrimitives_Expected_LastScalarValueInEnumeration() { List<int> testData = new List<int> { 1, 2, 3 }; IPath namePath = new PocoPath("().", "()."); PocoNavigator pocoNavigator = new PocoNavigator(testData); const string expected = "3"; string actual = pocoNavigator.SelectScalar(namePath).ToString(); Assert.AreEqual(expected, actual); }
public void SelectScalarValueUsingPocoScalarPathFromReferenceType_Expected_ScalarValue() { PocoTestData testData = GivenPoco(); IPath namePath = new PocoPath("Name", "Name"); IDataBrowser dataBrowser = DataBrowserFactory.CreateDataBrowser(); object data = dataBrowser.SelectScalar(namePath, testData); Assert.AreEqual(data, testData.Name); }
public void SelectEnumerableValuesUsingRootPathFromEnumerableContainingOnlyPrimitives_Expected_ValuesForEachValueInEnumeration() { List<int> testData = new List<int> { 1, 2, 3 }; IPath path = new PocoPath("().", "()."); List<IPath> paths = new List<IPath> { path }; PocoNavigator pocoNavigator = new PocoNavigator(testData); Dictionary<IPath, IList<object>> data = pocoNavigator.SelectEnumerablesAsRelated(paths); string expected = string.Join("|", testData.Select(e => e)); string actual = string.Join("|", data[path]); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesAsRelatedUsingPocoEnumerablePathsFromReferenceType_Where_PathsContainNestedEnumerablePaths_Expected_FlattenedDataWithValuesFromOuterEnumerablePathRepeatingForEveryValueFromNestedEnumerablePath() { PocoTestData testData = GivenPocoWithParallelAndNestedEnumerables(); PocoPath enumerableNamePath = new PocoPath("EnumerableData().Name", "EnumerableData.Name"); PocoPath nestedEnumerableNamePath = new PocoPath("EnumerableData().EnumerableData().Name", "EnumerableData.EnumerableData.Name"); List<IPath> paths = new List<IPath> { enumerableNamePath, nestedEnumerableNamePath }; IDataBrowser dataBrowser = DataBrowserFactory.CreateDataBrowser(); Dictionary<IPath, IList<object>> data = dataBrowser.SelectEnumerablesAsRelated(paths, testData); #region Complex Setup for Expected // // The code in this region is used to setup the exprected value. // It can't be reused for other tests and can't be made generic // without replicating the funcationality being tested. // string tmpExpected = ""; string tmpExpected1 = ""; string separator = "|"; for (int outerCount = 0; outerCount < testData.EnumerableData.Count; outerCount++) { for (int innerCount = 0; innerCount < testData.EnumerableData[outerCount].EnumerableData.Count; innerCount++) { if (outerCount == testData.EnumerableData.Count - 1 && innerCount == testData.EnumerableData[outerCount].EnumerableData.Count - 1) separator = ""; if (outerCount < testData.EnumerableData.Count) { tmpExpected += testData.EnumerableData[outerCount].Name + separator; } else { tmpExpected += separator; } if (innerCount < testData.EnumerableData[outerCount].EnumerableData.Count) { tmpExpected1 += testData.EnumerableData[outerCount].EnumerableData[innerCount].Name + separator; } else { tmpExpected1 += separator; } } } #endregion Complex Setup for Expected string expected = tmpExpected + "^" + tmpExpected1; string actual = string.Join("|", data[enumerableNamePath]); actual += "^" + string.Join("|", data[nestedEnumerableNamePath]); Assert.AreEqual(expected, actual); }
public void SelectEnumerableValuesAsRelatedUsingRootPathFromEnumerableContainingOnlyPrimitives_Expected_ValuesForEachValueInEnumeration() { List<int> testData = new List<int> { 1, 2, 3 }; IPath path = new PocoPath("().", "()."); PocoNavigator pocoNavigator = new PocoNavigator(testData); IEnumerable<object> data = pocoNavigator.SelectEnumerable(path); string expected = string.Join("|", testData.Select(e => e)); string actual = string.Join("|", data.Select(o => o.ToString())); Assert.AreEqual(expected, actual); }