public void BuildsResourcesPerSection()
                {
                    MethodToTest(() => service.BuildMembershipRuleSectionResources(A <string> .Ignored,
                                                                                   A <IEnumerable <MembershipRuleSection> > .Ignored,
                                                                                   A <IEnumerable <MembershipRuleTermDefinition> > .Ignored, A <Auth0User> .Ignored));

                    var sectionPrefix = "pre";
                    var user          = new Auth0User();
                    var org           = new ShurahBasedOrganisation
                    {
                        MembershipRuleSections = new List <MembershipRuleSection>(),
                        Terms = new List <MembershipRuleTermDefinition>()
                    };
                    var exampleIndex   = 3;
                    var exampleSection = new MembershipRuleSection();
                    var exampleMembershipRuleSectionResource = new MembershipRuleSectionResource();

                    A.CallTo(() => service.BuildMembershipRuleSectionResource(sectionPrefix, exampleSection, user, exampleIndex, org.Terms))
                    .Returns(exampleMembershipRuleSectionResource);
                    var orderedSections = A.Fake <IOrderedEnumerable <MembershipRuleSection> >();

                    A.CallTo(() => dependencies.LinqService.OrderBy(org.MembershipRuleSections,
                                                                    A <Func <MembershipRuleSection, int> > .That.Matches(x =>
                                                                                                                         x.Invoke(new MembershipRuleSection {
                        Sequence = 4
                    }) == 4
                                                                                                                         ))).Returns(orderedSections);
                    var resources = new List <MembershipRuleSectionResource>();

                    A.CallTo(() => dependencies.LinqService.SelectIndexedEnumerable(orderedSections,
                                                                                    A <Func <MembershipRuleSection, int, MembershipRuleSectionResource> > .That.Matches(x =>
                                                                                                                                                                        x.Invoke(exampleSection, exampleIndex) == exampleMembershipRuleSectionResource
                                                                                                                                                                        ))).Returns(resources);
                    var resourcesList = new List <MembershipRuleSectionResource>();

                    A.CallTo(() => dependencies.LinqService.EnumerableToList(resources)).Returns(resourcesList);



                    var result = service.BuildMembershipRuleSectionResources(sectionPrefix, org.MembershipRuleSections, org.Terms, user);

                    Assert.AreSame(resourcesList, result);
                }
        public virtual MembershipRuleSectionResource BuildMembershipRuleSectionResource(string sectionPrefix,
                                                                                        MembershipRuleSection ruleSection, Auth0User user, int sectionIndex, IEnumerable <MembershipRuleTermDefinition> terms)
        {
            var resource = new MembershipRuleSectionResource();

            resource.Title          = ruleSection.Title;
            resource.Id             = ruleSection.Id;
            resource.OrganisationId = ruleSection.ShurahBasedOrganisationId;
            resource.SectionNumber  = sectionPrefix + (sectionIndex + 1);
            resource.UniqueName     = ruleSection.UniqueInOrganisationName;
            var orderedRules = _dependencies.LinqService.OrderBy(ruleSection.MembershipRules, r => r.Sequence);
            var prefix       = sectionPrefix + (sectionIndex + 1).ToString() + ".";

            resource.Rules =
                _dependencies.LinqService.EnumerableToList(
                    _dependencies.LinqService.SelectIndexedEnumerable(orderedRules,
                                                                      (r, i) => BuildMembershipRuleResource(prefix, user, r, i, terms)));
            resource.SubSections = BuildMembershipRuleSectionResources(
                prefix,
                _dependencies.LinqService.SelectEnumerable(ruleSection.ChildMembershipRuleSections,
                                                           x => x.MembershipRuleSection), terms, user);
            return(resource);
        }