private void UserAccountOptionsBuilder(IFakeOptions <ei_infrastructure.Data.POCOs.UserAccount> fakeOptions) { fakeOptions.ConfigureFake(userAccount => { userAccount.Username = RandomString(10); userAccount.Password = RandomString(6); }); }
/// <summary> /// Makes the fake default to calling base methods, so long as they aren't abstract. /// </summary> /// <param name="options">Options used to create the fake object.</param> /// <returns>An options object.</returns> public static IFakeOptions CallsBaseMethods(this IFakeOptions options) { Guard.AgainstNull(options, nameof(options)); return(options.ConfigureFake(fake => A.CallTo(fake) .Where(call => !call.Method.IsAbstract) .CallsBaseMethod())); }
public void BuildOptions(Type typeOfFake, IFakeOptions options) { if (options == null) { return; } options.ConfigureFake(fake => ((TypeWithOptionsBuilders)fake).WasConfigured = true); }
protected override void BuildOptions(IFakeOptions <SomeClass> options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } options.ConfigureFake(fake => fake.IsConfigured = true); }
public void BuildOptions(Type typeOfFake, IFakeOptions options) { if (options == null) { return; } options.ConfigureFake(fake => A.CallTo(() => ((TypeWithDummyFactory)fake).WasConfigured).Returns(true)); }
/// <summary> /// Makes the fake strict. This means that any call to the fake /// that has not been explicitly configured will throw an exception. /// </summary> /// <param name="options">Options used to create the fake object.</param> /// <returns>An options object.</returns> public static IFakeOptions Strict(this IFakeOptions options) { Guard.AgainstNull(options, nameof(options)); return(options.ConfigureFake(fake => { var manager = Fake.GetFakeManager(fake); manager.AddRuleFirst(new StrictFakeRule()); })); }
/// <summary> /// Makes the fake strict. This means that any call to the fake /// that has not been explicitly configured will throw an exception, /// except calls to the <see cref="object"/> methods specified /// in <paramref name="strictOptions"/>. /// </summary> /// <typeparam name="T">The type of fake object.</typeparam> /// <param name="options">Options used to create the fake object.</param> /// <param name="strictOptions">Strict fake options.</param> /// <returns>An options object.</returns> public static IFakeOptions <T> Strict <T>(this IFakeOptions <T> options, StrictFakeOptions strictOptions) where T : class { Guard.AgainstNull(options, nameof(options)); return(options.ConfigureFake(fake => { var manager = Fake.GetFakeManager(fake); manager.AddRuleFirst(new StrictFakeRule(strictOptions)); })); }
/// <summary> /// Makes the fake strict. This means that any call to the fake /// that has not been explicitly configured will throw an exception. /// </summary> /// <param name="options">Options used to create the fake object.</param> /// <returns>An options object.</returns> public static IFakeOptions Strict(this IFakeOptions options) { Guard.AgainstNull(options, nameof(options)); Action <IFakeObjectCall> thrower = call => { throw new ExpectationException(ExceptionMessages.CallToUnconfiguredMethodOfStrictFake(call)); }; return(options.ConfigureFake(fake => A.CallTo(fake).Invokes(thrower))); }
/// <summary> /// Makes the fake strict. This means that any call to the fake /// that has not been explicitly configured will throw an exception. /// </summary> /// <param name="optionsBuilder">Action that builds options used to create the fake object.</param> /// <returns>A configuration object.</returns> public static IFakeOptions Strict(this IFakeOptions optionsBuilder) { Guard.AgainstNull(optionsBuilder, "optionsBuilder"); Action <IFakeObjectCall> thrower = call => { throw new ExpectationException("Call to non configured method \"{0}\" of strict fake.".FormatInvariant(call.Method.Name)); }; return(optionsBuilder.ConfigureFake(fake => A.CallTo(fake).Invokes(thrower))); }
private void ApplyOptions <T>(IFakeOptions <T> options) { if (this._strict) { options.Strict(); } if (this._configureFake != null) { options.ConfigureFake(x => this._configureFake(x)); } }
private void ApplyOptions <T>(IFakeOptions <T> options)//IFakeOptionsBuilder<T> [to] IFakeOptions<T> { if (this._strict) { options.Strict(); } if (this._onFakeCreated != null) { options.ConfigureFake(x => this._onFakeCreated(x));//OnFakeCreated(x=>) [to] ConfigureFake(x=>) } }
protected override void BuildOptions(IFakeOptions <RobotRunsAmokEvent> options) { if (options == null) { return; } options.ConfigureFake(fake => { var robotRunsAmokEvent = fake; A.CallTo(() => robotRunsAmokEvent.CalculateTimestamp()) .Returns(ConfiguredTimestamp); robotRunsAmokEvent.ID = -99; }); }
private void ApplyOptions(IFakeOptions options) { if (this._strict) { options = options.Strict(); } if (this._configureFake != null) { options = options.ConfigureFake(x => this._configureFake(x)); } if (this._callsBaseMethods) { options.CallsBaseMethods(); } }
public void BuildOptions(Type typeOfFake, IFakeOptions options) { if (options == null) { return; } options.ConfigureFake(fake => { var domainEvent = (DomainEvent)fake; domainEvent.ID = this.nextID++; domainEvent.Name = typeOfFake.Name; }) .WithAttributes(() => new ForTestAttribute()) .Implements(typeof(IDisposable)) .Implements <IComparable>(); }
public void BuildOptions(Type typeOfFake, IFakeOptions options) { if (options == null) { return; } options.ConfigureFake(fake => { var domainEvent = (DomainEvent)fake; domainEvent.ID = this.nextID++; domainEvent.Name = typeOfFake.Name; }) .WithAdditionalAttributes(new[] { CreateCustomAttributeBuilder() }) .Implements(typeof(IDisposable)) .Implements <ICloneable>(); }