public void MultipleExpectsShouldValidateToTrueIfGivenMatchingModel() { 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); propertyMapping.Set(x => x.Update, Layer.Defaults, true); acceptance .Matches(new PropertyInspector(propertyMapping)) .ShouldBeTrue(); }
public void AnyShouldValidateToTrueIfAllMatch() { acceptance .Any(c => c.Expect(x => x.Name, Is.Set), c => c.Expect(x => x.Type, Is.Set), c => c.Expect(x => x.Insert, Is.Set)); var propertyMapping = new PropertyMapping(); propertyMapping.Set(x => x.Name, Layer.Defaults, "Property1"); propertyMapping.Set(x => x.Type, Layer.Defaults, new TypeReference(typeof(string))); propertyMapping.Set(x => x.Insert, Layer.Defaults, true); acceptance .Matches(new PropertyInspector(propertyMapping)) .ShouldBeTrue(); }
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(); property.Set(x => x.Name, Layer.Defaults, "Property1"); mapping.AddProperty(property); mapping.Properties.ShouldContain(property); }
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.Insert != true); var propertyMapping = new PropertyMapping(); propertyMapping.Set(x => x.Insert, Layer.Defaults, true); acceptance .Matches(new PropertyInspector(propertyMapping)) .ShouldBeFalse(); }
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(); }
private PropertyMapping GetPropertyMapping(Type type, Member property) { var mapping = new PropertyMapping { ContainingEntityType = type, Member = property }; var columnMapping = new ColumnMapping(); columnMapping.Set(x => x.Name, Layer.Defaults, property.Name); mapping.AddColumn(Layer.Defaults, columnMapping); mapping.Set(x => x.Name, Layer.Defaults, mapping.Member.Name); mapping.Set(x => x.Type, Layer.Defaults, GetDefaultType(property)); SetDefaultAccess(property, mapping); return mapping; }
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 ExpectShouldEvaluateSubPropertyWithEvaluation() { acceptance.Expect(x => x.Type.Name == typeof(Record).Name); var propertyMapping = new PropertyMapping { Member = ReflectionHelper.GetMember<Record>(x => x.Age), }; propertyMapping.Set(x => x.Type, Layer.Defaults, new TypeReference(typeof(Record))); acceptance.Matches(new PropertyInspector(propertyMapping)) .ShouldBeTrue(); }
public void CanPassSubCriteriaToAny() { var subCriteria1 = new ConcreteAcceptanceCriteria<IPropertyInspector>(); subCriteria1.Expect(x => x.Name, Is.Set); var subCriteria2 = new ConcreteAcceptanceCriteria<IPropertyInspector>(); subCriteria2.Expect(x => x.Type, Is.Set); acceptance.Any(subCriteria1, subCriteria2); var propertyMapping = new PropertyMapping(); propertyMapping.Set(x => x.Name, Layer.Defaults, "Property1"); acceptance .Matches(new PropertyInspector(propertyMapping)) .ShouldBeTrue(); }
public void IsNotAnyFailsIfAnyOfTheSuppliedValuesMatch() { acceptance.Expect(x => x.Access.IsNotAny(Access.Property, Access.Field)); var propertyMapping = new PropertyMapping(); propertyMapping.Set(x => x.Access, Layer.Defaults, Access.Field.ToString()); var propertyMapping2 = new PropertyMapping(); propertyMapping2.Set(x => x.Access, Layer.Defaults, Access.Property.ToString()); acceptance .Matches(new PropertyInspector(propertyMapping)) .ShouldBeFalse(); acceptance .Matches(new PropertyInspector(propertyMapping2)) .ShouldBeFalse(); }
void SetDefaultAccess(Member member, PropertyMapping mapping) { var resolvedAccess = MemberAccessResolver.Resolve(member); if (resolvedAccess != Access.Property && resolvedAccess != Access.Unset) { // if it's a property or unset then we'll just let NH deal with it, otherwise // set the access to be whatever we determined it might be mapping.Set(x => x.Access, Layer.Defaults, resolvedAccess.ToString()); } if (member.IsProperty && !member.CanWrite) { mapping.Set(x => x.Access, Layer.Defaults, cfg.GetAccessStrategyForReadOnlyProperty(member).ToString()); } }
public void CombinationOfSetAndNotSetShouldValidateToFalseWhenNoneMatch() { acceptance .Expect(x => x.Insert, Is.Not.Set) .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 EitherIsAnyWithTwoParameters() { acceptance .Either(c => c.Expect(x => x.Name, Is.Set), c => c.Expect(x => x.Type, Is.Set)); var propertyMapping = new PropertyMapping(); propertyMapping.Set(x => x.Name, Layer.Defaults, "Property1"); acceptance .Matches(new PropertyInspector(propertyMapping)) .ShouldBeTrue(); }