/// <summary> /// Creates a new instance of the generator /// </summary> /// <param name="singleValueDef">The property definition that indicates which property the values are being generated for</param> /// <param name="regExPhrase">The regular expression against which generated values must match</param> public ValidValueGeneratorRegEx(ISingleValueDef singleValueDef, string regExPhrase) : base(singleValueDef) { if (regExPhrase == null) throw new ArgumentNullException("regExPhrase"); if (regExPhrase == "") throw new ArgumentException("Must supply a non-empty regular expression", "regExPhrase"); RegExPhrase = regExPhrase; }
/// <summary> /// Resolves the registered <see cref="ValidValueGenerator"/> for the PropDef if one is registered. /// Else tries to find a <see cref="ValidValueGenerator"/> for the specified PropDefs Property Type /// using the <see cref="ValidValueGeneratorRegistry"/> /// </summary> /// <returns></returns> public virtual ValidValueGenerator Resolve(ISingleValueDef propDef) { if (propDef == null) { throw new ArgumentNullException("propDef"); } lock (_lockProp) { var keyName = GetKeyName(propDef); if (_validValueGenTypesPerPropDef.ContainsKey(keyName)) { var validValueGen = this._validValueGenTypesPerPropDef[keyName]; var validValueGenType = validValueGen.GeneratorType; var parameter = validValueGen.Parameter; if (parameter != null) { if (!GeneratorHasConstructorWithExtraParameter(validValueGenType)) { throw new ArgumentException( "An extra parameter was provided for a valid value generator type (" + validValueGenType.Name + "), but no suitable constructor was found with a second parameter."); } return((ValidValueGenerator)Activator.CreateInstance(validValueGenType, propDef, parameter)); } return((ValidValueGenerator)Activator.CreateInstance(validValueGenType, propDef)); } return(ValidValueGeneratorRegistry.Instance.Resolve(propDef)); } }
protected ValidValueGenerator(ISingleValueDef singleValueDef) { if (singleValueDef == null) { throw new ArgumentNullException("singleValueDef"); } this.SingleValueDef = singleValueDef; }
/// <summary> /// Returns True if a value Gen is registered with the singleValueDef <paramref name="propDef"/> /// </summary> /// <param name="propDef"></param> /// <returns></returns> public bool IsRegistered(ISingleValueDef propDef) { lock (_lockProp) { var keyName = GetKeyName(propDef); return(this._validValueGenTypesPerPropDef.ContainsKey(keyName)); } }
/// <summary> /// Constructs a new instance of the generator /// </summary> /// <param name="propDef">The definition of the property for which random values will be generated</param> /// <param name="fileName">The filename that contains the available values, including the path. If the path is relative, /// it will relate to the execution directory. If no filename is specified, the filename used will be the /// property name (e.g. FirstName) with a ".txt" extension.</param> public ValidValueGeneratorTextFile(ISingleValueDef propDef, string fileName = null) : base(propDef) { if (string.IsNullOrEmpty(fileName)) { fileName = propDef.PropertyName + ".txt"; } FileName = fileName; }
private void ClearPreviousInstances(ISingleValueDef propDef) { var keyName = GetKeyName(propDef); if (this._validValueGenTypesPerPropDef.ContainsKey(keyName)) { this._validValueGenTypesPerPropDef.Remove(keyName); } }
private static void ValidateProp(Type type, ISingleValueDef def, string propName) { if (def == null) { throw new HabaneroDeveloperException( string.Format("The property '{0}' for the ClassDef for '{1}' is not defined", propName, type), DEVELOPER_MESSAGE); } }
/// <summary> /// Constructs a new instance of the generator /// </summary> /// <param name="propDef">The definition of the property for which random values will be generated</param> /// <param name="fileName">The filename that contains the available values, including the path. If the path is relative, /// it will relate to the execution directory. If no filename is specified, the filename used will be the /// property name (e.g. FirstName) with a ".txt" extension.</param> public ValidValueGeneratorTextFile(ISingleValueDef propDef, string fileName = null) : base(propDef) { if (string.IsNullOrEmpty(fileName)) { fileName = propDef.PropertyName + ".txt"; } FileName = fileName; }
private void ClearPreviousInstances(ISingleValueDef propDef) { var keyName = GetKeyName(propDef); if (this._validValueGenTypesPerPropDef.ContainsKey(keyName)) { this._validValueGenTypesPerPropDef.Remove(keyName); } }
protected static ISingleValueDef GetPropDef(IClassDef classDef, string propName, bool raiseErrIfNotExists) { ISingleValueDef def = classDef.GetPropDef(propName, false); if (raiseErrIfNotExists) { ValidateProp(classDef.ClassType, def, propName); } return(def); }
/// <summary> /// Register a Valid Value Generator to be used for generating values for a specified PropDef. /// </summary> /// <param name="propDef">The property definition for which this generator type is being assigned</param> /// <param name="validValuGenType">The type of generator which will be instantiated when a valid value is needed</param> /// <param name="parameter">An additional parameter to pass to the constructor of the generator</param> public virtual void Register(ISingleValueDef propDef, Type validValuGenType, object parameter = null) { _logger.Log("Register valid value gen for PropDef : " + propDef.PropertyName, LogCategory.Debug); string boTypeName = GetClassType(propDef); ValidateGeneratorType(validValuGenType, boTypeName); lock (_lockProp) { this.ClearPreviousInstances(propDef); _validValueGenTypesPerPropDef.Add(GetKeyName(propDef), new ValidValueGeneratorInfo(validValuGenType, parameter)); } }
/// <summary> /// Returns a valid prop value for <paramref name="propDef"/> /// using any <see cref="IPropRule"/>s for the Prop. /// Note_ this value does not take into consideration any /// <see cref="InterPropRule"/>s /// </summary> public virtual object GetValidPropValue(ISingleValueDef propDef) { if (_defaultValueRegistry.IsRegistered(propDef.PropertyName)) { return(_defaultValueRegistry.Resolve(propDef.PropertyName)); } var valueGenerator = GetValidValueGenerator(propDef); return((valueGenerator == null) ? null : valueGenerator.GenerateValidValue()); }
protected void CheckPropertyTypeIsCorrect(ISingleValueDef valueDef) { if (!typeof(T).IsAssignableFrom(valueDef.PropertyType)) { var message = string.Format( Messages.You_cannot_use_a_ValidValueGeneratorFromList_for_generating_values_of_typeT, typeof(T), valueDef.PropertyType); throw new HabaneroArgumentException(message + valueDef.ClassName + "_" + valueDef.PropertyName + "'"); } }
/// <summary> /// Register a Valid Value Generator to be used for generating values for a specified PropDef. /// </summary> /// <param name="propDef">The property definition for which this generator type is being assigned</param> /// <param name="validValuGenType">The type of generator which will be instantiated when a valid value is needed</param> /// <param name="parameter">An additional parameter to pass to the constructor of the generator</param> public virtual void Register(ISingleValueDef propDef, Type validValuGenType, object parameter = null) { _logger.Log("Register valid value gen for PropDef : " + propDef.PropertyName, LogCategory.Debug); string boTypeName = GetClassType(propDef); ValidateGeneratorType(validValuGenType, boTypeName); lock (_lockProp) { this.ClearPreviousInstances(propDef); _validValueGenTypesPerPropDef.Add(GetKeyName(propDef), new ValidValueGeneratorInfo(validValuGenType, parameter)); } }
/// <summary> /// returns a valid value generator for of the specified type based on the /// <see cref="ISingleValueDef"/>.<see cref="ISingleValueDef.PropertyType"/> /// </summary> /// <param name="propDef"></param> /// <returns></returns> public ValidValueGenerator GetValidValueGenerator(ISingleValueDef propDef) { if (propDef.IsLookupList()) { return(new ValidValueGeneratorLookupList(propDef)); } if (propDef.PropertyType.IsEnum) { return(new ValidValueGeneratorEnum(propDef)); } return(_validValueGenRegistry.Resolve(propDef)); }
/// <summary> /// Creates a new instance of the generator /// </summary> /// <param name="singleValueDef">The property definition that indicates which property the values are being generated for</param> /// <param name="regExPhrase">The regular expression against which generated values must match</param> public ValidValueGeneratorRegEx(ISingleValueDef singleValueDef, string regExPhrase) : base(singleValueDef) { if (regExPhrase == null) { throw new ArgumentNullException("regExPhrase"); } if (regExPhrase == "") { throw new ArgumentException("Must supply a non-empty regular expression", "regExPhrase"); } RegExPhrase = regExPhrase; }
/// <summary> /// Resolves the registered <see cref="ValidValueGenerator"/> if one is registered. /// Else returns null./> /// </summary> /// <returns></returns> public virtual ValidValueGenerator Resolve(ISingleValueDef propDef) { if (propDef == null) { throw new ArgumentNullException("propDef"); } var valueType = propDef.PropertyType; if (this._validValueGenTypes.ContainsKey(valueType)) { Type validValueGenType = this._validValueGenTypes[valueType]; return((ValidValueGenerator)Activator.CreateInstance(validValueGenType, propDef)); } return(null); }
protected virtual int GetNextNameReference(ISingleValueDef propDef) { if (!_nextItemDictionaryRef.ContainsKey(propDef)) { _nextItemDictionaryRef.Add(propDef, 0); } var nextNameReference = _nextItemDictionaryRef[propDef]; nextNameReference++; if (nextNameReference >= AvailableItemsList.Count) { nextNameReference = 0; } _nextItemDictionaryRef[propDef] = nextNameReference; return(nextNameReference); }
/// <summary> /// Returns a valid Value for either a single relationship or a property for the <see cref="BusinessObject"/>'s /// relationship or prop is identified by the <paramref name="name"/> /// </summary> /// <param name="type"></param> /// <param name="name"></param> /// <returns></returns> private object GetValidValue(Type type, string name) { ISingleValueDef relationshipDef = GetRelationshipDef(type, name, false) as ISingleValueDef; if (relationshipDef != null) { return(this.GetValidRelationshipValue(relationshipDef)); } ISingleValueDef def = GetPropDef(type, name, false); if (def != null) { return(this.GetValidPropValue(def)); } ThrowPropDoesNotExist(type, name); return(null); }
public void Test_Construct_WithValueDefNull_ShouldRaiseError() { //---------------Set up test pack------------------- ISingleValueDef relDefIsNull = null; //---------------Assert Precondition---------------- Assert.IsNull(relDefIsNull); //---------------Execute Test ---------------------- try { new ValidValueGeneratorFromBOList <FakeBO2>(relDefIsNull, GetEmptyList <FakeBO2>()); Assert.Fail("expected ArgumentNullException"); } //---------------Test Result ----------------------- catch (ArgumentNullException ex) { StringAssert.Contains("Value cannot be null", ex.Message); StringAssert.Contains("singleValueDef", ex.ParamName); } }
/// <summary> /// Returns a Valid Relationship Value for the relationship <paramref name="relationshipDef"/> /// </summary> /// <param name="relationshipDef"></param> /// <returns></returns> public virtual IBusinessObject GetValidRelationshipValue(ISingleValueDef relationshipDef) { string relationshipName = relationshipDef.PropertyName; if (_defaultValueRegistry.IsRegistered(relationshipName)) { return(_defaultValueRegistry.Resolve(relationshipName) as IBusinessObject); } if (_validValueGenRegistry.IsRegistered(relationshipDef)) { var validValueGenerator = _validValueGenRegistry.Resolve(relationshipDef); if (validValueGenerator != null) { return(validValueGenerator.GenerateValidValue() as IBusinessObject); } } var classType = relationshipDef.PropertyType; var boTestFactory = BOTestFactoryRegistry.Instance.Resolve(classType); return(boTestFactory.CreateValidBusinessObject()); }
public ValidValueGeneratorEnum(ISingleValueDef propDef) : base(propDef) { }
public ValidValueGeneratorLookupList(ISingleValueDef propDef) : base(propDef) { }
private static bool IsCompulsory(ISingleValueDef singleValueDef) { return(singleValueDef != null && singleValueDef.Compulsory); }
internal static bool IsLookupList(this ISingleValueDef propDef) { return(!(propDef.LookupList is NullLookupList)); }
private static bool IsNotWriteNotNew(ISingleValueDef propDef) { return(propDef.ReadWriteRule != PropReadWriteRule.WriteNotNew); }
/// <summary> /// returns a valid value generator for of the specified type based on the /// <see cref="ISingleValueDef"/>.<see cref="ISingleValueDef.PropertyType"/> /// </summary> /// <param name="propDef"></param> /// <returns></returns> public ValidValueGenerator GetValidValueGenerator(ISingleValueDef propDef) { if (propDef.IsLookupList()) { return new ValidValueGeneratorLookupList(propDef); } if (propDef.PropertyType.IsEnum) { return new ValidValueGeneratorEnum(propDef); } return _validValueGenRegistry.Resolve(propDef); }
/// <summary> /// Returns a valid prop value for <paramref name="propDef"/> /// using any <see cref="IPropRule"/>s for the Prop. /// Note_ this value does not take into consideration any /// <see cref="InterPropRule"/>s /// </summary> public virtual object GetValidPropValue(ISingleValueDef propDef) { if (_defaultValueRegistry.IsRegistered(propDef.PropertyName)) { return _defaultValueRegistry.Resolve(propDef.PropertyName); } var valueGenerator = GetValidValueGenerator(propDef); return ((valueGenerator == null) ? null : valueGenerator.GenerateValidValue()); }
/// <summary> /// Returns a Valid Relationship Value for the relationship <paramref name="relationshipDef"/> /// </summary> /// <param name="relationshipDef"></param> /// <returns></returns> public virtual IBusinessObject GetValidRelationshipValue(ISingleValueDef relationshipDef) { string relationshipName = relationshipDef.PropertyName; if (_defaultValueRegistry.IsRegistered(relationshipName)) { return _defaultValueRegistry.Resolve(relationshipName) as IBusinessObject; } if (_validValueGenRegistry.IsRegistered(relationshipDef)) { var validValueGenerator = _validValueGenRegistry.Resolve(relationshipDef); if (validValueGenerator != null) { return validValueGenerator.GenerateValidValue() as IBusinessObject; } } var classType = relationshipDef.PropertyType; var boTestFactory = BOTestFactoryRegistry.Instance.Resolve(classType); return boTestFactory.CreateValidBusinessObject(); }
private static ValidValueGeneratorRegEx CreateValueGenerator(string regExPhrase, ISingleValueDef singleValueDef = null) { if (singleValueDef == null) { singleValueDef = new PropDefFake { PropertyType = typeof(string) }; } return new ValidValueGeneratorRegEx(singleValueDef, regExPhrase); }
public ValidValueGeneratorFromBOList(ISingleValueDef singleValueDef, IList <T> availableItems) : base(singleValueDef, availableItems) { }
private static bool IsInteger(ISingleValueDef propDef) { return(typeof(int) == propDef.PropertyType || typeof(long) == propDef.PropertyType); }
public ValidValueGeneratorEnum(ISingleValueDef propDef) : base(propDef) { }
private static string GetKeyName(ISingleValueDef propDef) { return GetClassType(propDef) + propDef.PropertyName; }
private static string GetClassType(ISingleValueDef propDef) { return propDef.ClassDef == null ? "" : propDef.ClassDef.ClassNameFull; }
private static bool IsNotWriteNotNew(ISingleValueDef propDef) { return propDef.ReadWriteRule != PropReadWriteRule.WriteNotNew; }
/// <summary> /// Returns True if a value Gen is registered with the singleValueDef <paramref name="propDef"/> /// </summary> /// <param name="propDef"></param> /// <returns></returns> public bool IsRegistered(ISingleValueDef propDef) { lock (_lockProp) { var keyName = GetKeyName(propDef); return this._validValueGenTypesPerPropDef.ContainsKey(keyName); } }
private static void ValidateProp(Type type, ISingleValueDef def, string propName) { if (def == null) { throw new HabaneroDeveloperException( string.Format("The property '{0}' for the ClassDef for '{1}' is not defined", propName, type), DEVELOPER_MESSAGE); } }
public SingleValueTesterTestDouble(ISingleValueDef singleValueDef) { _singleValueDef = singleValueDef; }
/// <summary> /// Resolves the registered <see cref="ValidValueGenerator"/> for the PropDef if one is registered. /// Else tries to find a <see cref="ValidValueGenerator"/> for the specified PropDefs Property Type /// using the <see cref="ValidValueGeneratorRegistry"/> /// </summary> /// <returns></returns> public virtual ValidValueGenerator Resolve(ISingleValueDef propDef) { if (propDef == null) { throw new ArgumentNullException("propDef"); } lock (_lockProp) { var keyName = GetKeyName(propDef); if (_validValueGenTypesPerPropDef.ContainsKey(keyName)) { var validValueGen = this._validValueGenTypesPerPropDef[keyName]; var validValueGenType = validValueGen.GeneratorType; var parameter = validValueGen.Parameter; if (parameter != null) { if (!GeneratorHasConstructorWithExtraParameter(validValueGenType)) { throw new ArgumentException( "An extra parameter was provided for a valid value generator type (" + validValueGenType.Name + "), but no suitable constructor was found with a second parameter."); } return (ValidValueGenerator) Activator.CreateInstance(validValueGenType, propDef, parameter); } return (ValidValueGenerator) Activator.CreateInstance(validValueGenType, propDef); } return ValidValueGeneratorRegistry.Instance.Resolve(propDef); } }
private static string GetClassType(ISingleValueDef propDef) { return(propDef.ClassDef == null ? "" : propDef.ClassDef.ClassNameFull); }
/// <summary> /// Returns a valid prop value for <paramref name="propName"/> /// for the Business object of type <paramref name="classDef"/> /// using any <see cref="IPropRule"/>s for the Prop. /// Note_ this value does nto atake into consideration any /// <see cref="InterPropRule"/>s /// </summary> protected virtual object GetValidPropValue(IClassDef classDef, string propName) { ISingleValueDef def = GetPropDef(classDef, propName, true); return(this.GetValidPropValue(def)); }
private static string GetKeyName(ISingleValueDef propDef) { return(GetClassType(propDef) + propDef.PropertyName); }
/// <summary> /// Returns a valid prop value for <paramref name="propName"/> /// for the Business object of type <paramref name="type"/> /// using any <see cref="IPropRule"/>s for the Prop. /// Note_ this value does nto atake into consideration any /// <see cref="InterPropRule"/>s /// </summary> public virtual object GetValidPropValue(Type type, string propName) { ISingleValueDef def = GetPropDef(type, propName, true); return(this.GetValidPropValue(def)); }
public ValidValueGeneratorFromBOList(ISingleValueDef singleValueDef) : base(singleValueDef) { }
private static ValidValueGeneratorRegEx CreateValueGenerator(string regExPhrase, ISingleValueDef singleValueDef = null) { if (singleValueDef == null) { singleValueDef = new PropDefFake { PropertyType = typeof(string) }; } return(new ValidValueGeneratorRegEx(singleValueDef, regExPhrase)); }