/Tests/Aggregates/BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests.cs

using System;

using System.Linq.Expressions;

using FluentAssertions;

using NHibernate;

using NHibernate.Cfg;

using NHibernate.Criterion;

using NHibernate.Dialect;

using NHibernate.Driver;

using NHibernate.Engine;

using NHibernate.Impl;

using NHibernate.Loader.Criteria;

using NHibernate.Mapping.ByCode;

using NHibernate.Mapping.ByCode.Conformist;

using NSubstitute;

using NUnit.Framework;

using TelerikMvcGridCustomBindingHelper.NHibernate;

using TelerikMvcGridCustomBindingHelper.NHibernate.Aggregates;

using TelerikMvcGridCustomBindingHelper.NHibernate.Projections;

using Tests.Stubs;



namespace Tests.Aggregates

{

    public class BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests

    {

        #region Test models



        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        private class Foo

        {

            public virtual string Name { get; set; }

            public virtual short UnitPrice { get; set; }

            public virtual short UnitsInStock { get; set; }

            public virtual short UnitsOnOrder { get; set; }

            public virtual Bar Bar { get; set; }

        }



        private class Bar

        {

            public virtual short UnitPrice { get; set; }

            public virtual Foo Foo { get; set; }

        }

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global



        private class FooMap : ClassMapping<Foo>

        {

            public FooMap()

            {

                Table("FooTable");

                Property(x => x.Name, map => map.Column("FooName"));

                Property(x => x.UnitPrice, map => map.Column("FooUnitPrice"));

                Property(x => x.UnitsInStock, map => map.Column("FooUnitsInStock"));

                Property(x => x.UnitsOnOrder, map => map.Column("FooUnitsOnOrder"));

                OneToOne(x => x.Bar, map => map.ForeignKey("FooBarKey"));

            }

        }



        private class BarMap : ClassMapping<Bar>

        {

            public BarMap()

            {

                Table("BarTable");

                Property(x => x.UnitPrice, map => map.Column("BarUnitPrice"));

                OneToOne(x => x.Foo, map => map.ForeignKey("BarFooKey"));

            }

        }



        #endregion



        private ISessionFactory _factory;



        [SetUp]

        public void SetUp()

        {

            var nhCfg = new Configuration();

            nhCfg.DataBaseIntegration(db =>

            {

                db.ConnectionString = "Data Source=:memory:;Version=3;New=True;Pooling=True;Max Pool Size=1;";

                db.ConnectionReleaseMode = ConnectionReleaseMode.OnClose;

                db.Driver<SQLite20Driver>();

                db.Dialect<SQLiteDialect>();

                // Debuging

                //db.LogSqlInConsole = true;

                //db.LogFormattedSql = true;

                //db.AutoCommentSql = true;

            });//.SessionFactory().GenerateStatistics();



            var mapper = new ModelMapper();

            mapper.AddMapping(new FooMap());

            mapper.AddMapping(new BarMap());

            nhCfg.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());



            _factory = nhCfg.BuildSessionFactory();

        }



        public class BetterCountAndAvgProjectionsTests : BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests

        {

            [Test]

            public void betterCountProjection_should_return_a_int64()

            {

                using (var session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterCountProjection("UnitsOnOrder");



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be("count(sql_alias.FooUnitsOnOrder) as y0_");



                    crit.GetTypes(null, null)[0].Should().Be(NHibernateUtil.Int64);

                }

            }



            [Test]

            public void betterAvgProjection_should_return_a_decimal()

            {

                using (var session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterAvgProjection("UnitsOnOrder");



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be("avg(cast(sql_alias.FooUnitsOnOrder as DOUBLE)) as y0_");



                    crit.GetTypes(null, null)[0].Should().Be(NHibernateUtil.Decimal);

                }

            }

        }



        public class BetterSqlCriterionTests : BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests

        {

            [Test]

            public void replaces_propertynames_with_columnnames()

            {

                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion("({UnitsOnOrder} + 3) > {UnitsInStock}");



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();

                    Assert.That(where, Is.EqualTo("(sql_alias.FooUnitsOnOrder + 3) > sql_alias.FooUnitsInStock"));

                }

            }



            [Test]

            public void replaces_aliased_propertynames_with_columnnames()

            {

                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    criteria.CreateAlias("Bar", "b");

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion("{UnitPrice} > ({b.UnitPrice} + 1)");



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();

                    Assert.That(where, Is.EqualTo("sql_alias.FooUnitPrice > (b1_.BarUnitPrice + 1)"));

                }

            }



            [Test]

            public void non_existing_property_throws_exception()

            {

                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion("{NonExisting} > 1");



                    Assert.Throws<QueryException>(() => crit.ToSqlString(criteria, criteriaQuery, null));

                }

            }

        }



        public class BetterSqlCriterionAndLinqExpressionsToSqlStringsConverterIntegrationTests : BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests

        {

            [Test]

            public void equality_with_a_string()

            {

                Expression<Func<Foo, object>> exp = p => p.Name == "Caneta";

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{Name} = 'Caneta'");

                    where.Should().Be("sql_alias.FooName = 'Caneta'");

                }

            }



            [Test]

            public void equality_with_a_number()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice == 5;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} = 5");

                    where.Should().Be("sql_alias.FooUnitPrice = 5");

                }

            }



            [Test]

            public void equality_with_another_property()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitsOnOrder == p.UnitsInStock;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitsOnOrder} = {UnitsInStock}");

                    where.Should().Be("sql_alias.FooUnitsOnOrder = sql_alias.FooUnitsInStock");

                }

            }



            [Test]

            public void equality_with_a_string_and_a_number_at_same_time()

            {

                Expression<Func<Foo, object>> exp = p => p.Name == "Caneta" && p.UnitPrice == 3;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{Name} = 'Caneta' and {UnitPrice} = 3");

                    where.Should().Be("sql_alias.FooName = 'Caneta' and sql_alias.FooUnitPrice = 3");

                }

            }



            [Test]

            public void greater_than()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice > 5;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} > 5");

                    where.Should().Be("sql_alias.FooUnitPrice > 5");

                }

            }



            [Test]

            public void greater_than_a_property()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice > p.UnitsInStock;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} > {UnitsInStock}");

                    where.Should().Be("sql_alias.FooUnitPrice > sql_alias.FooUnitsInStock");

                }

            }



            [Test]

            public void greater_than_or_equal()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice >= 5;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} >= 5");

                    where.Should().Be("sql_alias.FooUnitPrice >= 5");

                }

            }



            [Test]

            public void greater_than_or_equal_a_property()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice >= p.UnitsInStock;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} >= {UnitsInStock}");

                    where.Should().Be("sql_alias.FooUnitPrice >= sql_alias.FooUnitsInStock");

                }

            }



            [Test]

            public void less_than()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice < 5;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} < 5");

                    where.Should().Be("sql_alias.FooUnitPrice < 5");

                }

            }



            [Test]

            public void less_than_a_property()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice < p.UnitsInStock;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} < {UnitsInStock}");

                    where.Should().Be("sql_alias.FooUnitPrice < sql_alias.FooUnitsInStock");

                }

            }



            [Test]

            public void less_than_or_equal()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice <= 5;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} <= 5");

                    where.Should().Be("sql_alias.FooUnitPrice <= 5");

                }

            }



            [Test]

            public void less_than_or_equal_a_property()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice <= p.UnitsInStock;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} <= {UnitsInStock}");

                    where.Should().Be("sql_alias.FooUnitPrice <= sql_alias.FooUnitsInStock");

                }

            }



            [Test]

            public void replaces_aliased_propertynames_with_columnnames_from_expression()

            {

                Expression<Func<Foo, object>> exp = p => p.UnitPrice > p.Bar.UnitPrice;

                var sqlString = exp.ToSqlString();



                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    criteria.CreateAlias("Bar", "Bar");

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlCriterion(sqlString);



                    var where = crit.ToSqlString(criteria, criteriaQuery, null).ToString();



                    sqlString.Should().Be("{UnitPrice} > {Bar.UnitPrice}");

                    where.Should().Be("sql_alias.FooUnitPrice > bar1_.BarUnitPrice");

                }

            }

        }



        public class BetterSqlProjectionTests : BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests

        {

            [Test]

            public void replaces_propertynames_with_columnnames()

            {

                using (var session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlProjection("({UnitsOnOrder} + 3) > {UnitsInStock}");



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be(("cast((cast(sql_alias.FooUnitsOnOrder as NUMERIC) + 3) > cast(sql_alias.FooUnitsInStock as NUMERIC) as NUMERIC) as betterSqlProjectionResult"));

                }

            }



            [Test]

            public void replaces_propertynames_with_columnnames_ignoring_cast()

            {

                using (var session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlProjection("({UnitsOnOrder} + 3) > {UnitsInStock}", ignoreCast: true);



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be(("((sql_alias.FooUnitsOnOrder + 3) > sql_alias.FooUnitsInStock) as betterSqlProjectionResult"));

                }

            }



            [Test]

            public void replaces_aliased_propertynames_with_columnnames()

            {

                using (ISession session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    criteria.CreateAlias("Bar", "Bar");

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlProjection("{UnitPrice} > ({Bar.UnitPrice} + 1)");



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be(("cast(cast(sql_alias.FooUnitPrice as NUMERIC) > (cast(bar1_.BarUnitPrice as NUMERIC) + 1) as NUMERIC) as betterSqlProjectionResult"));

                }

            }



            [Test]

            public void replaces_aliased_propertynames_with_columnnames_ignoring_cast()

            {

                using (var session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    criteria.CreateAlias("Bar", "Bar");

                    //criteria.CreateCriteria("Bar", "Bar");

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlProjection("{UnitPrice} > ({Bar.UnitPrice} + 1)", ignoreCast: true);



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be(("(sql_alias.FooUnitPrice > (bar1_.BarUnitPrice + 1)) as betterSqlProjectionResult"));

                }

            }



            [Test]

            public void replaces_aliased_propertynames_with_columnnames_ignoring_cast_2()

            {

                using (var session = _factory.OpenSession())

                {

                    var queryOver = session.QueryOver<Foo>();

                    var criteria = (CriteriaImpl)queryOver.RootCriteria;

                    criteria.CreateAlias("Bar.Foo", "BarFoo");

                    //criteria.CreateCriteria("Bar.Foo", "BarFoo");

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlProjection("{UnitPrice} + ({BarFoo.Name} + 1)", ignoreCast: true);



                    var where = crit.ToSqlString(criteria, 0, criteriaQuery, null).ToString();

                    where.Should().Be(("(sql_alias.FooUnitPrice + (barfoo1_.FooName + 1)) as betterSqlProjectionResult"));

                }

            }



            [Test]

            public void non_existing_property_throws_exception()

            {

                using (var session = _factory.OpenSession())

                {

                    var criteria = (CriteriaImpl)session.CreateCriteria<Foo>();

                    var criteriaQuery = new CriteriaQueryTranslator(

                        (ISessionFactoryImplementor)_factory,

                        criteria, criteria.EntityOrClassName, "sql_alias");



                    var crit = new BetterSqlProjection("{NonExisting} > 1");



                    Assert.Throws<QueryException>(() => crit.ToSqlString(criteria, 0, criteriaQuery, null));

                }

            }

        }



        public class ExpressionProjectionHelperTests : BetterNHibernateImplementationsForSqlCriterionAndSqlProjectionsTests

        {

            [Test]

            public void count_expression()

            {

                var queryOver = new QueryOverStub<Foo, Foo>(Substitute.For<ICriteria>());



                Expression<Func<Foo, bool?>> expression = foo => foo.UnitPrice + 3 > foo.UnitsOnOrder;

                var expressionProjectionHelper = new ExpressionProjectionHelper(queryOver, expression, NHibernateUtil.Decimal);

                expressionProjectionHelper.Count();



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

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

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



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

                const string criterion = "{UnitPrice} + 3 > {UnitsOnOrder}";

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



                queryOver.RootCriteria.Received(1).FutureValue<object>();

            }



            [Test]

            public void sum_expression()

            {

                var queryOver = new QueryOverStub<Foo, Foo>(Substitute.For<ICriteria>());



                Expression<Func<Foo, decimal?>> expression = foo => foo.UnitPrice * foo.UnitsOnOrder;

                var expressionProjectionHelper = new ExpressionProjectionHelper(queryOver, expression, NHibernateUtil.Decimal);

                expressionProjectionHelper.Sum();



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

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

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



                queryOver.RootCriteria.Received(1).FutureValue<object>();

            }

        }

    }

}