/// <summary> /// Creates a factory method for the given type. /// </summary> /// <param name="setup">The setup which is used for the type.</param> /// <returns>A function with which the given type can be instantiated.</returns> internal static Func <T> CreateFactoryMethod(FillerSetup setup) { Type targetType = typeof(T); if (!Setup.TypeToRandomFunc.ContainsKey(targetType)) { if (targetType.IsClass()) { var fillerType = typeof(Filler <>).MakeGenericType(typeof(T)); var objectFiller = Activator.CreateInstance(fillerType); if (setup != null) { var setupMethod = objectFiller.GetType().GetMethods() .Where(x => x.Name == "Setup" && x.GetParameters().Length == 1) .Single(x => x.GetParameters().First().ParameterType == typeof(FillerSetup)); setupMethod.Invoke(objectFiller, new[] { setup }); } var createMethod = objectFiller.GetType().GetMethods().Single(x => !x.GetParameters().Any() && x.Name == "Create"); return(() => (T)createMethod.Invoke(objectFiller, null)); } return(() => default(T)); } return(() => (T)Setup.TypeToRandomFunc[typeof(T)]()); }
/// <summary> /// Creates a setup based uppon another setup /// </summary> /// <typeparam name="TTarget">The type which is configured.</typeparam> /// <param name="baseSetup">The setup which is used as basis of the new one.</param> /// <returns>Setup you can use for Filler and Randomizer.</returns> public static FluentFillerApi <TTarget> Create <TTarget>(FillerSetup baseSetup) where TTarget : class { var setupManager = new SetupManager(); setupManager.FillerSetup = baseSetup ?? new FillerSetup(); return(new FluentFillerApi <TTarget>(setupManager)); }
/// <summary> /// With this method you can use a previously defined setup for specific types. /// </summary> /// <param name="setup">The setup for the type.</param> /// <returns>Main FluentFiller API</returns> public FluentFillerApi <TTargetObject> Use(FillerSetup setup) { var factoryMethod = Randomizer <TTargetType> .CreateFactoryMethod(setup); this.setupManager.GetFor <TTargetObject>().TypeToRandomFunc[typeof(TTargetType)] = () => factoryMethod(); return(this.callback); }
/// <summary> /// Call this to start the setup for the <see cref="Filler{T}"/> and use a setup which you created /// before with the <see cref="IFluentApi{TTargetObject,TTargetType}"/> /// </summary> /// <param name="fillerSetupToUse"> /// FillerSetup to use /// </param> /// <returns> /// Fluent API Setup /// </returns> public FluentFillerApi <T> Setup(FillerSetup fillerSetupToUse) { if (fillerSetupToUse != null) { this.setupManager.FillerSetup = fillerSetupToUse; } return(new FluentFillerApi <T>(this.setupManager)); }
/// <summary> /// Call this to start the setup for the <see cref="Filler{T}"/> and use a setup which you created /// before with the <see cref="IFluentApi{TTargetObject,TTargetType}"/> /// </summary> /// <param name="fillerSetupToUse"> /// FillerSetup to use /// </param> /// <param name="explicitSetup">True if just properties shall get filled which configured in filler setup.</param> /// <returns> /// Fluent API Setup /// </returns> public FluentFillerApi <T> Setup(FillerSetup fillerSetupToUse, bool explicitSetup) { if (fillerSetupToUse != null) { this.setupManager.FillerSetup = fillerSetupToUse; } this.justConfiguredProperties = explicitSetup; return(new FluentFillerApi <T>(this.setupManager)); }
/// <summary> /// Defines which <see cref="FillerSetup"/> is used to generate a value for the given <see cref="TTargetType"/> /// </summary> /// <param name="setup">The setup which is used for configuration.</param> public FluentFillerApi <TTargetObject> Use(FillerSetup setup) { foreach (PropertyInfo propertyInfo in this.affectedProperties) { var factoryMethod = Randomizer <TTargetType> .CreateFactoryMethod(setup); this.setupManager.GetFor <TTargetObject>().PropertyToRandomFunc[propertyInfo] = () => factoryMethod(); } return(this.callback); }
public void GetFillerSetup() { Filler<Person> filler = new Filler<Person>(); _fillerSetup = filler.Setup() .OnType<IAddress>().CreateInstanceOf<Address>() .OnProperty(x => x.Age).Use(new IntRange(18, 35)) .OnProperty(x => x.FirstName).Use(new RealNames(NameStyle.FirstName)) .OnProperty(x => x.LastName).Use(new RealNames(NameStyle.LastName)) .SetupFor<Address>() .OnProperty(x => x.HouseNumber).Use(new IntRange(1, 100)) .Result; }
/// <summary> /// Creates a value base on a filler setup /// </summary> /// <param name="setup">Setup for the objectfiller</param> /// <returns>Created value</returns> public static T Create(FillerSetup setup) { var creationMethod = CreateFactoryMethod(setup); T result; try { result = creationMethod(); } catch (Exception ex) { throw new InvalidOperationException( "The type " + typeof(T).FullName + " needs additional information to get created. " + "Please use the Filler class and call \"Setup\" to create a setup for that type. See Innerexception for more details.", ex); } return(result); }
/// <summary> /// Creates a set of random items of the given type and will use a <see cref="FillerSetup"/> for that. /// </summary> /// <param name="setup">Setup to use.</param> /// <param name="amount">Amount of items created.</param> /// <returns>Set of random items of the given type.</returns> public static IEnumerable <T> Create(FillerSetup setup, int amount) { return(Create(amount, () => Create(setup))); }
/// <summary> /// Call this to start the setup for the <see cref="Filler{T}"/> and use a setup which you created /// before with the <see cref="IFluentApi{TTargetObject,TTargetType}"/> /// </summary> /// <param name="fillerSetupToUse"> /// FillerSetup to use /// </param> /// <returns> /// Fluent API Setup /// </returns> public FluentFillerApi <T> Setup(FillerSetup fillerSetupToUse) { return(this.Setup(fillerSetupToUse, false)); }
/// <summary> /// Initializes a new instance of the <see cref="SetupManager"/> class. /// </summary> internal SetupManager() { FillerSetup = new FillerSetup(); }