/Tests/Projections/DynamicProjetionsTests.cs

using System.Collections.Generic;

using System.Linq;

using System.Linq.Dynamic;

using AutoMapper;

using ExampleWebApplication;

using ExampleWebApplication.Entities;

using ExampleWebApplication.Infraestruture;

using ExampleWebApplication.Models;

using FizzWare.NBuilder;

using FluentAssertions;

using NUnit.Framework;

using TelerikMvcGridCustomBindingHelper.Mapper;

using TelerikMvcGridCustomBindingHelper.Projections;

using Tests.Entity;

using Tests.ViewModel;



namespace Tests.Projections

{

    public class DynamicProjetionsTests

    {

        private ProjectionsEngine _engine;



        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            _engine = new ProjectionsEngine();

        }



        [Test]

        public void projections_to()

        {

            Mapper.CreateMap<Product, ProductModel>();

            Mapper.CreateMap<Category, CategoryModel>();



            var data = Builder<Product>.CreateListOfSize(50).All()

                .With(p => p.Category = Builder<Category>.CreateNew().Build())

                .Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Product, ProductModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var products = _engine.GetData<Product, ProductModel>(queryable);

            var productModels = Mapper.Map<List<ProductModel>>(products);



            productModels.Should().HaveCount(50);

        }



        [Test]

        public void projections_to_2()

        {

            GridModelMapper.CreateMap<Order, OrderModel>()

                .MapProperty(order => order.Freight, model => model.Freight, options => options.SetValueResolver<DecimalValueResolver>());



            var data = Builder<Order>.CreateListOfSize(50).All()

                .Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Order, OrderModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var products = _engine.GetData<Order, OrderModel>(queryable);

            var productModels = Mapper.Map<List<OrderModel>>(products);



            productModels.Should().HaveCount(50);

        }



        [Test]

        public void projections_to_3()

        {

            MvcApplication.CreateMaps(false);



            var engine = new ProjectionsEngine();



            var properties = engine.PropertiesIntersection<Order, OrderModel>().ToList();



            properties.Should().HaveCount(14);

            properties.Where(x => x.Contains('.')).Should().HaveCount(8);

            properties.Where(x => !x.Contains('.')).Should().HaveCount(6);



            var dynamicLinqSelector = engine.BuildSelector<Order, OrderModel>(null);



            var orders = new List<Order>().AsQueryable();



            orders.Select(dynamicLinqSelector.Expression);

        }



        [Test]

        public void projections_to_with_custom_mappins()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var data = Builder<Foo>.CreateListOfSize(50)

                .All().With(x => x.Name = "FooName").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);

            var fooModels = Mapper.Map<List<FooModel>>(foos);



            fooModels.Should().HaveCount(50);

            fooModels.ForEach(model => model.BarName.Should().Be("FooName"));

        }



        [Test]

        public void projections_to_with_custom_mappins_1()

        {

            GridModelMapper.CreateMap<Category, CategoryModel>();

            //GridModelMapper.CreateMap<CategoryModel, Category>();

            GridModelMapper.CreateMap<Product, ProductModel>()

                .MapProperty(product => product.Units_On_Order, productModel => productModel.Units_OnOrder)

                .MapProperty(product => product.ProductName, productModel => productModel.ViewModelProp);

            Mapper.CreateMap<Product, ProductModel>().ForMember(trg => trg.ViewModelProp, opt => opt.MapFrom(src => "[Agreggates] " + src.ProductName));



            var data = Builder<Product>.CreateListOfSize(50).All().With(product => product.Category = new Category()).Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Product, ProductModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var products = _engine.GetData<Product, ProductModel>(queryable);

            var productModels = Mapper.Map<List<ProductModel>>(products);



            productModels.Should().HaveCount(50);

        }



        [Test]

        public void projections_to_with_custom_mappins_2()

        {

            GridModelMapper.CreateMap<Category, CategoryModel>();

            //GridModelMapper.CreateMap<CategoryModel, Category>();

            GridModelMapper.CreateMap<Product, ProductModel>()

                .MapProperty(product => product.Units_On_Order, productModel => productModel.Units_OnOrder)

                .MapProperty(product => product.ProductName, productModel => productModel.ViewModelProp);

            Mapper.CreateMap<Product, ProductModel>().ForMember(trg => trg.ViewModelProp, opt => opt.MapFrom(src => "[Agreggates] " + src.ProductName));



            var data = Builder<Product>.CreateListOfSize(50).All()

                .With(product => product.Category = new Category { CategoryName = "CategoryNameValue" })

                .And(product => product.ProductName = "ProductNameValue").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Product, ProductModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var products = _engine.GetData<Product, ProductModel>(queryable);

            var productModels = Mapper.Map<List<ProductModel>>(products);



            productModels.Should().HaveCount(50);

            productModels.Should().OnlyContain(productModel => productModel.ProductName == "ProductNameValue");

            productModels.Should().OnlyContain(productModel => productModel.Category != null);

            productModels.Should().OnlyContain(productModel => productModel.Category.CategoryName == "CategoryNameValue");

        }



        [Test]

        public void projections_to_assert_all_object_graph()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.ImInAViewModel, opt => opt.MapFrom(src => src.ImInAnEntity));

            Mapper.CreateMap<Bar, BarModel>()

                .ForMember(trg => trg.ImInAViewModel, opt => opt.MapFrom(src => src.ImInAnEntity));

            Mapper.CreateMap<Bee, BeeModel>();



            var bar = Builder<Bar>.CreateNew()

                    .With(y => y.ImInAnEntity = "BarImInAnEntity")

                    .With(y => y.Name = "BarName")

                    .With(y => y.Bee = Builder<Bee>.CreateNew()

                        .With(z => z.Name = "BeeName")

                        .With(z => z.UnitPrice = 33.33M)

                        .Build())

                    .Build();



            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.ImInAnEntity = "FooImInAnEntity")

                .With(x => x.Name = "FooName")

                .With(x => x.UnitPrice = 11.11M)

                .With(x => x.UnitsInStock = 22.22M)

                .With(x => x.Bar = bar)

                .With(x => x.Bars = Builder<Bar>.CreateListOfSize(10).All()

                    .With(g => g.Bee = bar.Bee)

                    .With(g => g.ImInAnEntity = bar.ImInAnEntity)

                    .With(g => g.Name = bar.Name)

                    .Build())

                .Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);

            var fooModels = Mapper.Map<IList<FooModel>>(foos).ToList();



            fooModels.Should().HaveCount(50);

            fooModels.ForEach(foo => foo.ImInAViewModel.Should().Be("FooImInAnEntity"));

            fooModels.ForEach(foo => foo.BarName.Should().Be("BarName"));

            fooModels.ForEach(foo => foo.Bar.ImInAViewModel.Should().Be("BarImInAnEntity"));

            fooModels.ForEach(foo => foo.Bar.Name.Should().Be("BarName"));

            fooModels.ForEach(foo => foo.Bar.Bee.Should().NotBeNull());

            fooModels.ForEach(foo => foo.Bar.Bee.Name.Should().Be("BeeName"));

            fooModels.ForEach(foo => foo.Bar.Bee.UnitPrice.Should().Be(33.33M));

            fooModels.ForEach(foo => foo.Bars.Should().HaveCount(10));

            fooModels.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Name.Should().Be("BarName")));

            fooModels.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.ImInAViewModel.Should().Be("BarImInAnEntity")));

            fooModels.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Bee.Should().NotBeNull()));

            fooModels.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Bee.Name.Should().Be("BeeName")));

            fooModels.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Bee.UnitPrice.Should().Be(33.33M)));

        }



        [Test]

        public void projections_cache()

        {

            Mapper.CreateMap<Product, ProductModel>();

            Mapper.CreateMap<Category, CategoryModel>();



            var selector1 = _engine.BuildSelector<Product, ProductModel>(null);

            var selector2 = _engine.BuildSelector<Category, CategoryModel>(null);



            var selector3 = _engine.BuildSelector<Product, ProductModel>(null);

            var selector4 = _engine.BuildSelector<Category, CategoryModel>(null);



            selector1.Should().NotBe(selector2);

            selector1.Should().Be(selector3);

            selector2.Should().Be(selector4);

        }



        [Test]

        public void projections_from()

        {

            Mapper.CreateMap<Product, ProductModel>();

            Mapper.CreateMap<Category, CategoryModel>();



            var data = Builder<Product>.CreateListOfSize(50).All()

                .With(p => p.Category = Builder<Category>.CreateNew().Build())

                .Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Product, ProductModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var products = _engine.GetData<Product, ProductModel>(queryable);



            products.Should().HaveCount(50);

        }



        [Test]

        public void projections_from_assert_all_object_graph()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.ImInAViewModel, opt => opt.MapFrom(src => src.ImInAnEntity));

            Mapper.CreateMap<Bar, BarModel>()

                .ForMember(trg => trg.ImInAViewModel, opt => opt.MapFrom(src => src.ImInAnEntity));

            Mapper.CreateMap<Bee, BeeModel>();



            var bar = Builder<Bar>.CreateNew()

                    .With(y => y.ImInAnEntity = "BarImInAnEntity")

                    .With(y => y.Name = "BarName")

                    .With(y => y.Bee = Builder<Bee>.CreateNew()

                        .With(z => z.Name = "BeeName")

                        .With(z => z.UnitPrice = 33.33M)

                        .Build())

                    .Build();



            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.ImInAnEntity = "FooImInAnEntity")

                .With(x => x.Name = "FooName")

                .With(x => x.UnitPrice = 11.11M)

                .With(x => x.UnitsInStock = 22.22M)

                .With(x => x.Bar = bar)

                .With(x => x.Bars = Builder<Bar>.CreateListOfSize(10).All()

                    .With(g => g.Bee = bar.Bee)

                    .With(g => g.ImInAnEntity = bar.ImInAnEntity)

                    .With(g => g.Name = bar.Name)

                    .Build())

                .Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);



            foos.Should().HaveCount(50);

            foos.ForEach(foo => foo.ImInAnEntity.Should().Be("FooImInAnEntity"));

            foos.ForEach(foo => foo.Bar.ImInAnEntity.Should().Be("BarImInAnEntity"));

            foos.ForEach(foo => foo.Bar.Name.Should().Be("BarName"));

            foos.ForEach(foo => foo.Bar.Bee.Should().NotBeNull());

            foos.ForEach(foo => foo.Bar.Bee.Name.Should().Be("BeeName"));

            foos.ForEach(foo => foo.Bar.Bee.UnitPrice.Should().Be(33.33M));

            foos.ForEach(foo => foo.Bars.Should().HaveCount(10));

            foos.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Name.Should().Be("BarName")));

            foos.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.ImInAnEntity.Should().Be("BarImInAnEntity")));

            foos.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Bee.Should().NotBeNull()));

            foos.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Bee.Name.Should().Be("BeeName")));

            foos.ForEach(foo => foo.Bars.ToList().ForEach(barModel => barModel.Bee.UnitPrice.Should().Be(33.33M)));

        }



        [Test]

        public void projections_from_with_custom_mappins()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.Bar = Builder<Bar>.CreateNew().Build())

                .With(x => x.Bar.Name = "FooBarName").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);



            foos.Should().HaveCount(50);

            foos.ForEach(foo => foo.Bar.Name.Should().Be("FooBarName"));

        }



        #region Dynamic Linq selector builder



        [Test]

        public void build_selector()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Use(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Use(foo => new

            {

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);



            dynamicLinqSelector.Expression.Should().Be(

                "new(Name, Bar.Name as Bar_Name, Bar.Bee.Name as Bar_Bee_Name, Bar.Bee.UnitPrice as Bar_Bee_UnitPrice, Bars)");

        }



        #endregion



        #region Dynamic Linq selector builder - With options



        [Test]

        public void build_selector_with_options_use()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Use(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Use(foo => new

            {

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(options);



            dynamicLinqSelector.Expression.Should().Be(

                "new(Name, ImInAnEntity, Bars, UnitPrice, UnitsInStock, Bar.Bee.Name as Bar_Bee_Name, Bar.ImInAnEntity as Bar_ImInAnEntity, Bar.Bee.UnitPrice as Bar_Bee_UnitPrice)");

        }



        [Test]

        public void build_selector_with_options_use_2()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Use(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Use(foo => new

            {

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                //foo.Bar.Bee.UnitPrice

            });



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(options);



            dynamicLinqSelector.Expression.Should().Be(

                "new(Name, ImInAnEntity, Bars, UnitPrice, UnitsInStock, Bar.Bee.Name as Bar_Bee_Name, Bar.ImInAnEntity as Bar_ImInAnEntity)");

        }



        [Test]

        public void build_selector_with_options_ignore()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Ignore(foo => new

            {

                //foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Ignore(foo => new

            {

                //foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(options);



            dynamicLinqSelector.Expression.Should().Be("new(Name, Bar.Name as Bar_Name, Bar.Bee.Name as Bar_Bee_Name)");

        }



        [Test]

        public void build_selector_with_options_include()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Include(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Include(foo => new

            {

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(options);



            dynamicLinqSelector.Expression.Should().Be(

                "new(Name, Bar.Name as Bar_Name, Bar.Bee.Name as Bar_Bee_Name, Bar.Bee.UnitPrice as Bar_Bee_UnitPrice, Bars, ImInAnEntity, UnitPrice, UnitsInStock, Bar.ImInAnEntity as Bar_ImInAnEntity)");

        }



        [Test]

        public void build_selector_with_options_include_and_ignore()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Ignore(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                //foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock,

                //foo.Bar.Name,

            })

            .Include(foo => new

            {

                foo.Bars,

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(options);



            dynamicLinqSelector.Expression.Should().Be(

                "new(Bar.Name as Bar_Name, Bar.Bee.Name as Bar_Bee_Name, Bar.Bee.UnitPrice as Bar_Bee_UnitPrice, Bars, Bar.ImInAnEntity as Bar_ImInAnEntity)");

        }



        #endregion



        #region Dynamic Linq selector builder - With options and GetData

        

        [Test]

        public void build_selector_with_options_use_and_getData()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Use(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Use(foo => new

            {

                foo.Bar.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });

            

            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.Bar = Builder<Bar>.CreateNew().Build())

                .With(x => x.Bar.Name = "FooBarName").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);



            foos.Should().HaveCount(50);

            foos.ForEach(foo => foo.Bar.Name.Should().Be("FooBarName"));

        }



        [Test]

        public void build_selector_with_options_ignore_and_getData()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Ignore(foo => new

            {

                //foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Ignore(foo => new

            {

                //foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.Bar = Builder<Bar>.CreateNew().Build())

                .With(x => x.Bar.Name = "FooBarName").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);



            foos.Should().HaveCount(50);

            foos.ForEach(foo => foo.Bar.Name.Should().Be("FooBarName"));

        }



        [Test]

        public void build_selector_with_options_include_and_getData()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Include(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock

            })

            .Include(foo => new

            {

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.Bar = Builder<Bar>.CreateNew().Build())

                .With(x => x.Bar.Name = "FooBarName").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);



            foos.Should().HaveCount(50);

            foos.ForEach(foo => foo.Bar.Name.Should().Be("FooBarName"));

        }



        [Test]

        public void build_selector_with_options_include_and_ignore_and_getData()

        {

            Mapper.CreateMap<Foo, FooModel>()

                .ForMember(trg => trg.BarName, opt => opt.MapFrom(src => src.Name));

            Mapper.CreateMap<Bar, BarModel>();

            Mapper.CreateMap<Bee, BeeModel>();



            var options = new ProjectionsOptionsImpl<Foo>();

            options.Ignore(foo => new

            {

                foo.Name,

                foo.ImInAnEntity,

                //foo.Bars,

                foo.UnitPrice,

                foo.UnitsInStock,

                //foo.Bar.Name,

            })

            .Include(foo => new

            {

                foo.Bars,

                foo.Bar.Bee.Name,

                foo.Bar.ImInAnEntity,

                foo.Bar.Bee.UnitPrice

            });



            var data = Builder<Foo>.CreateListOfSize(50).All()

                .With(x => x.Bar = Builder<Bar>.CreateNew().Build())

                .With(x => x.Bar.Name = "FooBarName").Build().AsQueryable();



            var dynamicLinqSelector = _engine.BuildSelector<Foo, FooModel>(null);

            var queryable = data.Select(dynamicLinqSelector.Expression);

            var foos = _engine.GetData<Foo, FooModel>(queryable);



            foos.Should().HaveCount(50);

            foos.ForEach(foo => foo.Bar.Name.Should().Be("FooBarName"));

        }



        #endregion

    }

}