public void WrongSpec_Fail()
            {
                var harvester = new ProjectionHarvester();
                var ex        = Assert.Throws <ArgumentException>(() => harvester.Exclude <A>(x => Math.Min(3, 3)));

                Assert.AreEqual("Field specification must refer to a field", ex.Message);

                ex = Assert.Throws <ArgumentException>(() => harvester.Exclude <A>(x => 1));
                Assert.AreEqual("Field specification must refer to a field", ex.Message);
            }
            public void Include_OnAlreadyInclude_Fail()
            {
                var harvester = new ProjectionHarvester();

                harvester.Exclude <A>(x => x.X);
                harvester.Include <A>(x => x.X);
            }
            public void Exclude_OnAlreadyFilter_Fail()
            {
                var harvester = new ProjectionHarvester();

                harvester.AddFilter <A>(x => null);
                harvester.Exclude <A>(x => x.X);
            }
            public void AddExclude_FieldOnDifferentType_Fail()
            {
                var harvester = new ProjectionHarvester();
                var ex        = Assert.Throws <ArgumentException>(() => harvester.Exclude <A>(x => x.X.Year));

                Assert.AreEqual("Field 'Year' is declared on type 'DateTime' not on argument: 'A'", ex.Message);
            }
            public void Fields_params_WorksForTypesAndSubtypes()
            {
                var harvester = new ProjectionHarvester();

                harvester.Exclude <A>(x => x.X, x => x.Y);

                Asserts(harvester);
            }
            public void Include_OnAlreadyInclude_Fail()
            {
                var harvester = new ProjectionHarvester();

                harvester.Exclude <A>(x => x.X);
                var ex = Assert.Throws <ArgumentException>(() => harvester.Include <A>(x => x.X));

                Assert.AreEqual("Type A has already been configured as an excluder.", ex.Message);
            }
            public void Exclude_FieldInSuperclass_WorksForTypesAndSubtypes()
            {
                var harvester = new ProjectionHarvester();

                harvester.Exclude <B>(x => x.Name);

                IFieldHarvester fh = (IFieldHarvester)harvester;

                Assert.IsFalse(fh.CanHandleType(typeof(A)));

                Assert.IsTrue(fh.CanHandleType(typeof(B)));
                var fields = fh.GetFields(typeof(B)).Select(x => x.SanitizedName);

                CollectionAssert.AreEquivalent(new[] { "X", "Y", "Age" }, fields);

                Assert.IsFalse(fh.CanHandleType(typeof(C)));
            }
            public void AddExclude_FieldOnDifferentType_Fail()
            {
                var harvester = new ProjectionHarvester();

                harvester.Exclude <A>(x => x.X.Year);
            }
 public void Include_OnAlreadyInclude_Fail()
 {
     var harvester = new ProjectionHarvester();
     harvester.Exclude<A>(x => x.X);
     harvester.Include<A>(x => x.X);
 }
            public void WrongSpec_Fail()
            {
                var harvester = new ProjectionHarvester();
                var ex = Assert.Throws<ArgumentException>(() => harvester.Exclude<A>(x => Math.Min(3, 3)));
                Assert.AreEqual("Field specification must refer to a field", ex.Message);

                ex = Assert.Throws<ArgumentException>(() => harvester.Exclude<A>(x => 1));
                Assert.AreEqual("Field specification must refer to a field", ex.Message);
            }
            public void Fields_WorksForTypesAndSubtypes()
            {
                var harvester = new ProjectionHarvester();
                harvester
                    .Exclude<A>(x => x.X)
                    .Exclude<A>(x => x.Y);

                Asserts(harvester);
            }
 public void Exclude_OnAlreadyFilter_Fail()
 {
     var harvester = new ProjectionHarvester();
     harvester.AddFilter<A>(x => null);
     harvester.Exclude<A>(x => x.X);
 }
            public void Exclude_FieldInSuperclass_WorksForTypesAndSubtypes()
            {
                var harvester = new ProjectionHarvester();
                harvester.Exclude<B>(x => x.Name);

                IFieldHarvester fh = (IFieldHarvester)harvester;
                Assert.IsFalse(fh.CanHandleType(typeof(A)));

                Assert.IsTrue(fh.CanHandleType(typeof(B)));
                var fields = fh.GetFields(typeof(B)).Select(x => x.SanitizedName);
                CollectionAssert.AreEquivalent(new[] { "X", "Y", "Age" }, fields);

                Assert.IsFalse(fh.CanHandleType(typeof(C)));
            }
 public void AddExclude_FieldOnDifferentType_Fail()
 {
     var harvester = new ProjectionHarvester();
     harvester.Exclude<A>(x => x.X.Year);
 }