/Tests/Aggregates/InLineCustomAggregatesTests.cs

using System.Collections.Generic;

using System.Linq;

using AutoMapper;

using ExampleWebApplication.Entities;

using ExampleWebApplication.Models;

using FizzWare.NBuilder;

using FluentAssertions;

using NHibernate;

using NHibernate.Criterion;

using NSubstitute;

using NUnit.Framework;

using Telerik.Web.Mvc;

using TelerikMvcGridCustomBindingHelper;

using TelerikMvcGridCustomBindingHelper.Mapper;

using TelerikMvcGridCustomBindingHelper.NHibernate;

using Tests.Stubs;



namespace Tests.Aggregates

{

    public class InLineCustomAggregatesTests

    {

        [TestFixtureSetUp]

        public void TestFixtureSetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();



            Mapper.CreateMap<Product, ProductModel>();

        }



        [Test]

        public void inline_expression_for_queryover_and_its_queryable_groups()

        {

            var dataSource = new QueryOverStub<Product, Product>(Substitute.For<ICriteria>());

            dataSource.RootCriteria.FutureValue<object>().Returns(new FutureValueStub<object>(385M));



            var helper = new NHibernateGridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder,

                    queryOver => queryOver.Sum(product => product.UnitPrice * product.Units_On_Order),

                    groups => groups.Sum(product => product.UnitPrice * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            dataSource.RootCriteria.Received(1).SetProjection(Arg.Any<IProjection>());

            const string sqlString = "sum({UnitPrice} * {Units_On_Order})";

            dataSource.RootCriteria.Received(1).SetProjection(Arg.Is<IProjection>(projections => projections.ToString() == sqlString));

            dataSource.RootCriteria.Received(2).FutureValue<object>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(385M);

        }



        #region QueryOver with auto convertible expressions



        [Test]

        public void inline_sum_aggregate_expression_with_queryover()

        {

            var dataSource = new QueryOverStub<Product, Product>(Substitute.For<ICriteria>());

            dataSource.RootCriteria.FutureValue<object>().Returns(new FutureValueStub<object>(385M));



            var helper = new NHibernateGridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Sum(product => product.UnitPrice * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            dataSource.RootCriteria.Received(1).SetProjection(Arg.Any<IProjection>());

            const string sqlString = "sum({UnitPrice} * {Units_On_Order})";

            dataSource.RootCriteria.Received(1).SetProjection(Arg.Is<IProjection>(projections => projections.ToString() == sqlString));

            dataSource.RootCriteria.Received(2).FutureValue<object>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(385M);

        }



        [Test]

        public void inline_count_aggregate_expression_with_queryover()

        {

            var dataSource = new QueryOverStub<Product, Product>(Substitute.For<ICriteria>());

            dataSource.RootCriteria.FutureValue<object>().Returns(new FutureValueStub<object>(385M));



            var helper = new NHibernateGridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Count(product => product.Units_On_Order > 7));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            dataSource.RootCriteria.Received(1).SetProjection(Arg.Any<IProjection>());

            const string sqlString = "count(*) as expressionProjectionHelperResult";

            dataSource.RootCriteria.Received(1).SetProjection(Arg.Is<IProjection>(projections => projections.ToString() == sqlString));



            dataSource.RootCriteria.Received(1).Add(Arg.Any<ICriterion>());

            const string criterion = "{Units_On_Order} > 7";

            dataSource.RootCriteria.Received(1).Add(Arg.Is<ICriterion>(projections => projections.ToString() == criterion));



            dataSource.RootCriteria.Received(2).FutureValue<object>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(385M);

        }



        [Test]

        public void inline_average_aggregate_expression_with_queryover()

        {

            var dataSource = new QueryOverStub<Product, Product>(Substitute.For<ICriteria>());

            dataSource.RootCriteria.FutureValue<object>().Returns(new FutureValueStub<object>(38.5));



            var helper = new NHibernateGridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Average(product => product.UnitPrice * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            dataSource.RootCriteria.Received(1).SetProjection(Arg.Any<IProjection>());

            const string sqlString = "average({UnitPrice} * {Units_On_Order})";

            dataSource.RootCriteria.Received(1).SetProjection(Arg.Is<IProjection>(projections => projections.ToString() == sqlString));

            dataSource.RootCriteria.Received(2).FutureValue<object>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(38.5);

        }



        [Test]

        public void inline_min_aggregate_expression_with_queryover()

        {

            var dataSource = new QueryOverStub<Product, Product>(Substitute.For<ICriteria>());

            dataSource.RootCriteria.FutureValue<object>().Returns(new FutureValueStub<object>(38.5));



            var helper = new NHibernateGridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Min(product => product.UnitPrice * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            dataSource.RootCriteria.Received(1).SetProjection(Arg.Any<IProjection>());

            const string sqlString = "min({UnitPrice} * {Units_On_Order})";

            dataSource.RootCriteria.Received(1).SetProjection(Arg.Is<IProjection>(projections => projections.ToString() == sqlString));

            dataSource.RootCriteria.Received(2).FutureValue<object>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(38.5);

        }



        [Test]

        public void inline_max_aggregate_expression_with_queryover()

        {

            var dataSource = new QueryOverStub<Product, Product>(Substitute.For<ICriteria>());

            dataSource.RootCriteria.FutureValue<object>().Returns(new FutureValueStub<object>(38.5));



            var helper = new NHibernateGridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Max(product => product.UnitPrice * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            dataSource.RootCriteria.Received(1).SetProjection(Arg.Any<IProjection>());

            const string sqlString = "max({UnitPrice} * {Units_On_Order})";

            dataSource.RootCriteria.Received(1).SetProjection(Arg.Is<IProjection>(projections => projections.ToString() == sqlString));

            dataSource.RootCriteria.Received(2).FutureValue<object>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(38.5);

        }



        #endregion



        #region Queryable



        [Test]

        public void inline_sum_aggregate_expression_with_queryable()

        {

            var dataSource = Builder<Product>.CreateListOfSize(10).Build().AsQueryable();



            var helper = new GridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Sum(product => product.UnitPrice * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(385M);

        }



        [Test]

        public void inline_count_aggregate_expression_with_queryable()

        {

            var dataSource = Builder<Product>.CreateListOfSize(10).Build().AsQueryable();



            var helper = new GridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Count(product => product.Units_On_Order > 7));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(3);

        }



        [Test]

        public void inline_average_aggregate_expression_with_queryable()

        {

            var dataSource = Builder<Product>.CreateListOfSize(10).Build().AsQueryable();



            var helper = new GridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Average(product => product.Units_On_Order * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(38.5);

        }



        [Test]

        public void inline_min_aggregate_expression_with_queryable()

        {

            var dataSource = Builder<Product>.CreateListOfSize(10).Build().AsQueryable();



            var helper = new GridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Min(product => product.Units_On_Order * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(1);

        }



        [Test]

        public void inline_max_aggregate_expression_with_queryable()

        {

            var dataSource = Builder<Product>.CreateListOfSize(10).Build().AsQueryable();



            var helper = new GridCustomBindingHelper<Product, ProductModel>(new GridCommand(), dataSource)

                .AddAggregateFunction(model => model.Units_OnOrder, query => query.Max(product => product.Units_On_Order * product.Units_On_Order));



            var aggregates = helper.BuildGridModel().Aggregates.As<Dictionary<string, object>>();



            aggregates.Should().HaveCount(1);

            aggregates.Single().Key.Should().Be("Units_OnOrder");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Key.Should().Be("Custom");

            aggregates.Single().Value.As<Dictionary<string, object>>().First().Value.Should().Be(100);

        }



        #endregion

    }

}