public void Test_VisitNodes(Entity node, IEnumerable <Tuple <Entity, IEnumerable <Entity> > > expectedResults)
        {
            List <Tuple <Entity, IEnumerable <Entity> > > actualResults;

            actualResults = new List <Tuple <Entity, IEnumerable <Entity> > >();
            StructuredQueryHelper.VisitNodes(node,
                                             (entity, descendants) => actualResults.Add(new Tuple <Entity, IEnumerable <Entity> >(entity, descendants)));

            Assert.That(actualResults, Is.EquivalentTo(expectedResults).Using(this));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Get the relationship types referenced in the query.
        /// </summary>
        /// <param name="structuredQuery">
        /// The <see cref="StructuredQuery"/> to check. This cannot be null.
        /// </param>
        /// <returns>
        /// A list of relationship types or empty, if the query references no relationships.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="structuredQuery"/> cannot be null.
        /// </exception>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="structuredQuery"/>'s RootEntity property cannot be null.
        /// </exception>
        public static IList <EntityRef> GetReferencedRelationshipTypes(StructuredQuery structuredQuery)
        {
            if (structuredQuery == null)
            {
                throw new ArgumentNullException("structuredQuery");
            }
            if (structuredQuery.RootEntity == null)
            {
                throw new ArgumentNullException("structuredQuery", "RootEntity cannot be null");
            }

            HashSet <EntityRef> result;

            result = new HashSet <EntityRef>();
            IEnumerable <ResourceDataColumn> resourceDataColumns;
            RelatedResource relatedResource;

            resourceDataColumns = structuredQuery.Conditions
                                  .SelectMany(cond => StructuredQueryHelper.WalkExpressions(cond.Expression))
                                  .Where(se => se is ResourceDataColumn)
                                  .Cast <ResourceDataColumn>();
            foreach (ResourceDataColumn resourceDataColumn in resourceDataColumns)
            {
                StructuredQueryHelper.VisitNodes(structuredQuery.RootEntity, (node, ancestors) =>
                {
                    if (node.NodeId == resourceDataColumn.NodeId)
                    {
                        relatedResource = node as RelatedResource;
                        if (relatedResource != null)
                        {
                            result.Add(relatedResource.RelationshipTypeId);
                            result.UnionWith(
                                ancestors.Where(n => n is RelatedResource)
                                .Cast <RelatedResource>()
                                .Select(rr => rr.RelationshipTypeId));
                        }
                    }
                });
            }

            return(result.ToList());
        }
 public void Test_VisitNodes_NullVisitor()
 {
     Assert.That(() => StructuredQueryHelper.VisitNodes(new ResourceEntity(), null),
                 Throws.TypeOf <ArgumentNullException>().And.Property("ParamName").EqualTo("visitor"));
 }
 public void Test_VisitNodes_NullNode()
 {
     Assert.That(() => StructuredQueryHelper.VisitNodes(null, (entity, descendants) => { }),
                 Throws.TypeOf <ArgumentNullException>().And.Property("ParamName").EqualTo("node"));
 }