private bool HasExplicitTypeConvention(Member property)
        {
            // todo: clean this up!
            //        What it's doing is finding if there are any IUserType conventions
            //        that would be applied to this property, if there are then we should
            //        definitely automap it. The nasty part is that right now we don't have
            //        a model, so we're having to create a fake one so the convention will
            //        apply to it.
            var conventions = conventionFinder
                .Find<IPropertyConvention>()
                .Where(c =>
                {
                    if (!typeof(IUserTypeConvention).IsAssignableFrom(c.GetType()))
                        return false;

                    var criteria = new ConcreteAcceptanceCriteria<IPropertyInspector>();
                    var acceptance = c as IConventionAcceptance<IPropertyInspector>;
                    
                    if (acceptance != null)
                        acceptance.Accept(criteria);

                    var propertyMapping = new PropertyMapping
                    {
                        Member = property
                    };
                    propertyMapping.Set(x => x.Type, Layer.Defaults, new TypeReference(property.PropertyType));
                    return criteria.Matches(new PropertyInspector(propertyMapping));
                });

            return conventions.FirstOrDefault() != null;
        }

        public void CanAddProperty()
        {
            var property = new PropertyMapping { Name = "Property1" };
            compositeElementMapping.AddProperty(property);

            compositeElementMapping.Properties.ShouldContain(property);
        }

        public void CanAddProperty()
        {
            var property = new PropertyMapping { Name = "Property1" };
            _classMapping.AddProperty(property);

            _classMapping.Properties.ShouldContain(property);
        }

        public void Should_not_write_the_default_access_type()
        {
            var property = new PropertyMapping();

            _writer.VerifyXml(property)
                .DoesntHaveAttribute("access");
        }

        public void CanAddProperty()
        {
            var property = new PropertyMapping();
            property.Set(x => x.Name, Layer.Defaults, "Property1");
            mapping.AddProperty(property);

            mapping.Properties.ShouldContain(property);
        }

        public void Should_write_the_specified_access_type()
        {
            var property = new PropertyMapping();
            property.MemberAccess = MemberAccess.Create(AccessStrategy.Field, NamingStrategy.CamelCase);

            _writer.VerifyXml(property)
                .HasAttribute("access", "field.camelcase");
        }

        public PropertyInspector(PropertyMapping mapping)
            : base(mapping.Columns)
        {
            this.mapping = mapping;

            propertyMappings.Map(x => x.LazyLoad, x => x.Lazy);
            propertyMappings.Map(x => x.Nullable, "NotNull");
        }

        public void ShouldWriteColumns()
        {
            var mapping = new PropertyMapping();

            mapping.AddColumn(new ColumnMapping { Name = "Column1" });

            writer.VerifyXml(mapping)
                .Element("column").Exists();
        }

        public void ExpectOnPropertyShouldValidateToTrueIfGivenMatchingModel()
        {
            acceptance.Expect(x => x.Insert, Is.Set);

            var propertyMapping = new PropertyMapping();
            propertyMapping.Set(x => x.Insert, Layer.Defaults, true);
            acceptance
                .Matches(new PropertyInspector(propertyMapping))
                .ShouldBeTrue();
        }

        public void DefaultColumnShouldInheritColumnAttributes()
        {
            var mapping = new PropertyMapping();

            new PropertyBuilder(mapping, typeof(PropertyTarget), Prop(x => x.Name))
                .Not.Nullable();

            mapping.Columns.Defaults.First().NotNull.ShouldBeTrue();
            mapping.Columns.First().NotNull.ShouldBeTrue();
        }

        public void ShouldHaveDefaultColumnIfNoneSpecified()
        {
            var mapping = new PropertyMapping();                

            new PropertyBuilder(mapping, typeof(PropertyTarget), Prop(x => x.Name));

            mapping.Columns.Defaults.Count().ShouldEqual(1);
            mapping.Columns.UserDefined.Count().ShouldEqual(0);
            mapping.Columns.Count().ShouldEqual(1);
        }

        public void ExpectNotEqualShouldValidateToFalseIfNotGivenMatchingModel()
        {
            acceptance.Expect(x => x.Insert != true);

            var propertyMapping = new PropertyMapping();
            propertyMapping.Set(x => x.Insert, Layer.Defaults, true);
            acceptance
                .Matches(new PropertyInspector(propertyMapping))
                .ShouldBeFalse();
        }

        public void IsNotAnySucceedsIfNoValuesMatch()
        {
            acceptance.Expect(x => x.Access.IsNotAny(Access.Property, Access.Field));

            var propertyMapping = new PropertyMapping();
            propertyMapping.Set(x => x.Access, Layer.Defaults, Access.CamelCaseField().ToString());
            acceptance
                .Matches(new PropertyInspector(propertyMapping))
                .ShouldBeTrue();
        }

        public void ExpectNotEqualShouldValidateToFalseIfNotGivenMatchingModel()
        {
            acceptance.Expect(x => x.Access != Access.Field);

            var propertyMapping = new PropertyMapping();
            propertyMapping.Set(x => x.Access, Layer.Defaults, "field");
            acceptance
                .Matches(new PropertyInspector(propertyMapping))
                .ShouldBeFalse();
        }

        public void ShouldHaveNoDefaultsIfUserSpecifiedColumn()
        {
            var mapping = new PropertyMapping();

            new PropertyBuilder(mapping, typeof(PropertyTarget), Prop(x => x.Name))
                .Column("explicit");

            mapping.Columns.Defaults.Count().ShouldEqual(0);
            mapping.Columns.UserDefined.Count().ShouldEqual(1);
            mapping.Columns.Count().ShouldEqual(1);
        }

        public void MultipleExpectsShouldValidateToFalseIfOnlyOneMatches()
        {
            acceptance.Expect(x => x.Insert, Is.Set);
            acceptance.Expect(x => x.Update, Is.Set);

            var propertyMapping = new PropertyMapping();
            propertyMapping.Set(x => x.Insert, Layer.Defaults, true);
            acceptance
                .Matches(new PropertyInspector(propertyMapping))
                .ShouldBeFalse();
        }

        public void CollectionIsNotEmptyShouldBeTrueWithItemsWhenUsingExpression()
        {
            acceptance
                .Expect(x => x.Columns.IsNotEmpty());

            var mapping = new PropertyMapping();
            mapping.AddColumn(new ColumnMapping { Name = "Column1" });

            acceptance
                .Matches(new PropertyInspector(mapping))
                .ShouldBeTrue();
        }

        public void CollectionContainsWithStringShouldBeFalseWhenNoItemsMatching()
        {
            acceptance
                .Expect(x => x.Columns.Contains("boo"));

            var mapping = new PropertyMapping();
            mapping.AddColumn(new ColumnMapping { Name = "Column1" });

            acceptance
                .Matches(new PropertyInspector(mapping))
                .ShouldBeFalse();
        }

        public void CollectionContainsWithLambdaShouldBeTrueWhenItemsMatching()
        {
            acceptance
                .Expect(x => x.Columns.Contains(c => c.Name == "Column1"));

            var mapping = new PropertyMapping();
            mapping.AddColumn(new ColumnMapping { Name = "Column1" });

            acceptance
                .Matches(new PropertyInspector(mapping))
                .ShouldBeTrue();
        }

        public void CollectionIsEmptyShouldBeFalseWithItemsWhenUsingExpression()
        {
            acceptance
                .Expect(x => x.Columns.IsEmpty());

            var mapping = new PropertyMapping();
            mapping.AddColumn(Layer.Defaults, new ColumnMapping("Column1"));

            acceptance
                .Matches(new PropertyInspector(mapping))
                .ShouldBeFalse();
        }