public virtual Adorner LoadContent(UIElement adornedElement) { var parameters = ConstructorParameters.ToList(); parameters.Insert(0, adornedElement); return(Activator.CreateInstance(Type, parameters.ToArray()) as Adorner); }
public SupportVectorMachine(ConstructorParameters parameters) { this.maximumNumberOfIterations = parameters.maximumNumberOfIterations; this.learnRate = parameters.learnRate; this.kernel = parameters.kernel; this.mu = parameters.mu; this.withBias = parameters.withBias; }
/// <summary> /// Writes the object to an XElement instance using the specified root element name. /// </summary> /// <param name="rootElement">Root element name</param> /// <returns>XElement representation of the object</returns> public override XElement WriteToXml(XName rootElement) { return(new XElement(rootElement, new XAttribute(INSTANCE_PREFIX, InstancePrefix ?? String.Empty), new XAttribute(INSTANCE_NAME, InstanceName ?? String.Empty), // ReSharper disable AssignNullToNotNullAttribute new XAttribute(PROVIDER, Provider == null ? String.Empty : Provider.AssemblyQualifiedName), // ReSharper restore AssignNullToNotNullAttribute ConstructorParameters.WriteToXml(CONSTRUCT), Properties.WriteToXml(PROPERTIES))); }
/// <summary> /// Parse the specified configuration settings /// </summary> /// <param name="element">Element holding configuration settings</param> protected override void ParseFromXml(XElement element) { InstancePrefix = element.OptionalStringAttribute(INSTANCE_PREFIX); InstanceName = element.OptionalStringAttribute(INSTANCE_NAME); var providerValue = element.OptionalStringAttribute(PROVIDER); Provider = String.IsNullOrWhiteSpace(providerValue) ? typeof(AppConfigProvider) : Type.GetType(providerValue); element.ProcessOptionalElement(CONSTRUCT, item => ConstructorParameters.ReadFromXml(item)); element.ProcessOptionalElement(PROPERTIES, item => Properties.ReadFromXml(item)); }
/// <summary> /// Returns a new instance of <typeparamref name="TModule"/> with the given context and using the given services. /// </summary> /// <param name="context">The command context to be used in this module.</param> /// <param name="provider">The objects to pass to this module's constructor.</param> /// <param name="beforeExecute">Whether to run <see cref="ModuleBase{T}.BeforeExecute(CommandInfo)"/>.</param> public static TModule Create(TContext context, IServiceProvider provider, bool beforeExecute = true) { var parameters = ConstructorParameters.Select(x => provider.GetService(x.ParameterType)).ToArray(); var module = (TModule)Constructor.Invoke(parameters); Context.SetValue(module, context, BindingFlags.NonPublic | BindingFlags.Instance, null, null, null); if (beforeExecute) { BeforeExecute.Invoke(module, new object[] { null }); } return(module); }
public IConstructorParameters GenerateParameters(params object[] parameters) { ConstructorParameters constructor = new ConstructorParameters(); foreach (object p in parameters) { constructor.Add(new ConstructorParameter() { Type = TypeGetter.GetType(p), Value = p }); } return(constructor); }
IEnumerable <Type> exec(params object[] instances) { IConstructorParameters parameters = new ConstructorParameters(); foreach (object instance in instances) { parameters.Parameters.Add(new ConstructorParameter() { Type = instance.GetType(), Value = instance }); } return(new ConstructorParametersTypeListGenerator().GenerateList(parameters)); }
IConstructorParameter exec <T>(params object[] instances) { ConstructorParameters constructorParameters = new ConstructorParameters(); foreach (object instance in instances) { constructorParameters.Add(new ConstructorParameter() { Type = instance.GetType(), Value = instance }); } IConstructorParameter result = new ConstructorParameterByTypeFinder().FindByType(constructorParameters, typeof(T)); return(result); }
public override void Validate() { if (ConstructorParameters != null && ConstructorParameters.Count > 10) { throw new NotSupportedException("Too many parameters added. Maximum 10 constructor parameters"); } if (ConstructorParameters.Any(x => x == null)) { throw new NotSupportedException("Constructor parameters cannot be null"); } if (Type == null) { throw new NullReferenceException("No Type defined"); } }
IParameter[] exec(int parameters, params object[] instances) { ConstructorInfo ctor = typeof(Test1).GetConstructors().SingleOrDefault(x => x.GetParameters().Length == parameters); ConstructorParameters constructorParameters = new ConstructorParameters(); foreach (object instance in instances) { constructorParameters.Add(new ConstructorParameter() { Type = instance.GetType(), Value = instance }); } IEnumerable <IParameter> generateParameters(ConstructorInfo info) { foreach (ParameterInfo parameterInfo in info.GetParameters()) { yield return(new ParameterBuilder() .AddType(parameterInfo.ParameterType) .AddDefaultValue(parameterInfo.DefaultValue) .HasDefaultValue(parameterInfo.HasDefaultValue) .Build()); } } TypedMemberValueProvider typedMemberValueProvider = new TypedMemberValueProvider(); ConstructorParametersGenerator generator = new ConstructorParametersGenerator(typedMemberValueProvider, new ConstructorParameterByTypeFinder(), new ServiceHasConstructorParametersChecker()); IEnumerable <IParameter> generatedParameters = generateParameters(ctor); foreach (IParameter parameter in generatedParameters) { Console.WriteLine($"{parameter.Type.FullName}:: {parameter.Value}"); } IParameter[] result = generator.GenerateParameters(new Constructor() { Instance = ctor, Parameters = generatedParameters }, constructorParameters).ToArray(); return(result); }
public override void Validate() { if (ConstructorParameters != null && ConstructorParameters.Count > 10) { throw new NotSupportedException("Too many parameters added. Maximum 10 constructor parameters"); } if (ConstructorParameters.Any(x => x == null)) { throw new NotSupportedException("Constructor parameters cannot be null"); } if (Type == null) { throw new NullReferenceException("No Type defined"); } if (Cache.IsEnabled() && Lazy != LazyLoading.Disabled) { throw new NotSupportedException("Both Cache and IsLazy cannot be true. Cached models cannot lazy load."); } }
ConstructorInfo exec <T>(params object[] instances) { ConstructorParameters parameters = new ConstructorParameters(); foreach (object instance in instances) { parameters.Add(new ConstructorParameter() { Type = instance.GetType(), Value = instance }); } ConstructorFinder finder = new ConstructorFinder(); ConstructorInfo[] allCtors = typeof(T).GetConstructors(); ConstructorListGenerator generator = new ConstructorListGenerator(new ConstructorGenerator(new ParametersGenerator(new ParameterGenerator()))); IEnumerable <IConstructor> ctors = generator.GenerateList(allCtors); IConstructor ctor = finder.FindBy(ctors, parameters); return(ctor.Instance); }
private ConstructorInfo GetBestMatchingConstructor() { var constructors = (from ctor in ProviderType.GetConstructors() let parameters = ctor.GetParameters() where parameters.Length == ConstructorParameters.Count where parameters.All(p => ConstructorParameters.ContainsKey(p.Name)) select ctor).ToArray(); if (!constructors.Any()) { throw new ConfigurationErrorsException( String.Format( "Type {0} doesn't contain a public constructor with {1} parameters", ProviderType, ConstructorParameters.Count)); } if (constructors.Length == 1) { return(constructors.Single()); } throw new ConfigurationErrorsException(String.Format("Multiple constructors matched on type {0}", ProviderType)); }
protected virtual void HandleAttribute(string name, string value) { ConstructorParameters.Add(name, value); }
public override string ToString() => "{ " + string.Join(", ", ConstructorParameters.Select(p => p.Key + ": " + p.Value)) + " }";
public string GetConstructorString() { var args = string.Join(", ", ConstructorParameters.Select(x => "__" + x.Name + "__")); return($"{FullName}({args})"); }
public override TDbContext Create() { var dbContextMock = new Mock <TDbContext>(ConstructorParameters.ToArray()); dbContextMock.DefaultValueProvider = new NoSetUpDefaultValueProvider <TDbContext>(DbContext); dbContextMock.Setup(m => m.Add(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Add(providedEntity)); dbContextMock.Setup(m => m.AddAsync(It.IsAny <object>(), It.IsAny <CancellationToken>())) .Returns((object providedEntity, CancellationToken providedCancellationToken) => DbContext.AddAsync(providedEntity, providedCancellationToken)); dbContextMock.Setup(m => m.AddRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.AddRange(providedEntities)); dbContextMock.Setup(m => m.AddRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.AddRange(providedEntities)); dbContextMock.Setup(m => m.AddRangeAsync(It.IsAny <object[]>(), It.IsAny <CancellationToken>())) .Returns((object[] providedEntities, CancellationToken providedCancellationToken) => DbContext.AddRangeAsync(providedEntities, providedCancellationToken)); dbContextMock.Setup(m => m.AddRangeAsync(It.IsAny <IEnumerable <object> >(), It.IsAny <CancellationToken>())) .Returns((IEnumerable <object> providedEntities, CancellationToken providedCancellationToken) => DbContext.AddRangeAsync(providedEntities, providedCancellationToken)); dbContextMock.Setup(m => m.Attach(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Attach(providedEntity)); dbContextMock.Setup(m => m.AttachRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.AttachRange(providedEntities)); dbContextMock.Setup(m => m.AttachRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.AttachRange(providedEntities)); dbContextMock.As <IDbContextDependencies>().Setup(m => m.ChangeDetector).Returns(((IDbContextDependencies)DbContext).ChangeDetector); dbContextMock.Setup(m => m.ChangeTracker).Returns(() => DbContext.ChangeTracker); dbContextMock.Setup(m => m.ContextId).Returns(() => DbContext.ContextId); dbContextMock.Setup(m => m.Database).Returns(() => DbContext.Database); dbContextMock.Setup(m => m.Dispose()).Callback(() => DbContext.Dispose()); dbContextMock.Setup(m => m.DisposeAsync()).Callback(() => DbContext.DisposeAsync()); dbContextMock.As <IDbContextDependencies>().Setup(m => m.EntityFinderFactory).Returns(((IDbContextDependencies)DbContext).EntityFinderFactory); dbContextMock.As <IDbContextDependencies>().Setup(m => m.EntityGraphAttacher).Returns(((IDbContextDependencies)DbContext).EntityGraphAttacher); dbContextMock.Setup(m => m.Entry(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Entry(providedEntity)); dbContextMock.Setup(m => m.Find(It.IsAny <Type>(), It.IsAny <object[]>())) .Returns((Type providedEntityType, object[] providedKeyValues) => DbContext.Find(providedEntityType, providedKeyValues)); dbContextMock.Setup(m => m.FindAsync(It.IsAny <Type>(), It.IsAny <object[]>())) .Returns((Type providedEntityType, object[] providedKeyValues) => DbContext.FindAsync(providedEntityType, providedKeyValues)); dbContextMock.Setup(m => m.FindAsync(It.IsAny <Type>(), It.IsAny <object[]>(), It.IsAny <CancellationToken>())) .Returns((Type providedEntityType, object[] providedKeyValues, CancellationToken providedCancellationToken) => DbContext.FindAsync(providedEntityType, providedKeyValues, providedCancellationToken)); dbContextMock.As <IDbSetCache>() .Setup(m => m.GetOrAddSet(It.IsAny <IDbSetSource>(), It.IsAny <Type>())) .Returns((IDbSetSource providedSource, Type providedType) => ((IDbSetCache)DbContext).GetOrAddSet(providedSource, providedType)); dbContextMock.As <IDbContextDependencies>().Setup(m => m.InfrastructureLogger).Returns(((IDbContextDependencies)DbContext).InfrastructureLogger); dbContextMock.As <IInfrastructure <IServiceProvider> >().Setup(m => m.Instance).Returns(((IInfrastructure <IServiceProvider>)DbContext).Instance); //dbContextMock.As<IDbContextDependencies>().Setup(m => m.Model).Returns(((IDbContextDependencies) DbContext).Model); dbContextMock.As <IDbContextDependencies>().Setup(m => m.QueryProvider).Returns(((IDbContextDependencies)DbContext).QueryProvider); dbContextMock.Setup(m => m.Remove(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Remove(providedEntity)); dbContextMock.Setup(m => m.RemoveRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.RemoveRange(providedEntities)); dbContextMock.Setup(m => m.RemoveRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.RemoveRange(providedEntities)); dbContextMock.As <IDbContextPoolable>().Setup(m => m.ResetState()).Callback(((IDbContextPoolable)DbContext).ResetState); dbContextMock.As <IDbContextPoolable>() .Setup(m => m.ResetStateAsync(It.IsAny <CancellationToken>())) .Callback((CancellationToken providedCancellationToken) => ((IDbContextPoolable)DbContext).ResetStateAsync(providedCancellationToken)); // dbContextMock.As<IDbContextPoolable>() // .Setup(m => m.Resurrect(It.IsAny<DbContextPoolConfigurationSnapshot>())) // .Callback((DbContextPoolConfigurationSnapshot providedConfigurationSnapshot) => ((IDbContextPoolable) DbContext).Resurrect(providedConfigurationSnapshot)); dbContextMock.Setup(m => m.SaveChanges()).Returns(() => DbContext.SaveChanges()); dbContextMock.Setup(m => m.SaveChanges(It.IsAny <bool>())).Returns((bool providedAcceptAllChangesOnSuccess) => DbContext.SaveChanges(providedAcceptAllChangesOnSuccess)); dbContextMock.Setup(m => m.SaveChangesAsync(It.IsAny <CancellationToken>())) .Returns((CancellationToken providedCancellationToken) => DbContext.SaveChangesAsync(providedCancellationToken)); dbContextMock.Setup(m => m.SaveChangesAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Returns((bool providedAcceptAllChangesOnSuccess, CancellationToken providedCancellationToken) => DbContext.SaveChangesAsync(providedAcceptAllChangesOnSuccess, providedCancellationToken)); // dbContextMock.As<IDbContextPoolable>() // .Setup(m => m.SetPool(It.IsAny<IDbContextPool>())) // .Callback((IDbContextPool providedContextPool) => ((IDbContextPoolable) DbContext).SetPool(providedContextPool)); dbContextMock.As <IDbContextDependencies>().Setup(m => m.SetSource).Returns(((IDbContextDependencies)DbContext).SetSource); // dbContextMock.As<IDbContextPoolable>().Setup(m => m.SnapshotConfiguration()).Returns(((IDbContextPoolable) DbContext).SnapshotConfiguration()); dbContextMock.As <IDbContextDependencies>().Setup(m => m.StateManager).Returns(((IDbContextDependencies)DbContext).StateManager); dbContextMock.Setup(m => m.Update(It.IsAny <object>())).Returns((object providedEntity) => DbContext.Update(providedEntity)); dbContextMock.As <IDbContextDependencies>().Setup(m => m.UpdateLogger).Returns(((IDbContextDependencies)DbContext).UpdateLogger); dbContextMock.Setup(m => m.UpdateRange(It.IsAny <IEnumerable <object> >())).Callback((IEnumerable <object> providedEntities) => DbContext.UpdateRange(providedEntities)); dbContextMock.Setup(m => m.UpdateRange(It.IsAny <object[]>())).Callback((object[] providedEntities) => DbContext.UpdateRange(providedEntities)); //Relational set up var rawSqlCommandBuilderMock = new Mock <IRawSqlCommandBuilder>(); rawSqlCommandBuilderMock.Setup(m => m.Build(It.IsAny <string>(), It.IsAny <IEnumerable <object> >())) .Callback((string providedSql, IEnumerable <object> providedParameters) => Logger.LogDebug("Catch all exception invoked")) .Throws <InvalidOperationException>(); var rawSqlCommandBuilder = rawSqlCommandBuilderMock.Object; // var concurrencyDetectorMock = new Mock<IConcurrencyDetector>(); // concurrencyDetectorMock.Setup(x => x.EnterCriticalSection()).Returns(() => new ConcurrencyDetectorCriticalSectionDisposer(Mock.Of<IConcurrencyDetector>())); // var concurrencyDetector = concurrencyDetectorMock.Object; var relationalConnectionMock = new Mock <IRelationalConnection>(); relationalConnectionMock.Setup(x => x.CommandTimeout).Returns(() => 0); var relationalConnection = relationalConnectionMock.Object; var dependenciesMock = new Mock <IRelationalDatabaseFacadeDependencies>(); //dependenciesMock.Setup(m => m.ConcurrencyDetector).Returns(() => concurrencyDetector); dependenciesMock.Setup(m => m.CommandLogger).Returns(() => Mock.Of <IRelationalCommandDiagnosticsLogger>()); dependenciesMock.Setup(m => m.RawSqlCommandBuilder).Returns(() => rawSqlCommandBuilder); dependenciesMock.Setup(m => m.RelationalConnection).Returns(() => relationalConnection); //dependenciesMock.Setup(m => m.CoreOptions.IsConcurrencyDetectionEnabled).Returns(() => true); dependenciesMock.Setup(m => m.CoreOptions.AreThreadSafetyChecksEnabled).Returns(() => false); var dependencies = dependenciesMock.Object; var serviceProviderMock = new Mock <IServiceProvider>(); serviceProviderMock.Setup(m => m.GetService(It.Is <Type>(t => t == typeof(IDatabaseFacadeDependencies)))).Returns((Type providedType) => dependencies); var serviceProvider = serviceProviderMock.Object; dbContextMock.As <IInfrastructure <IServiceProvider> >().Setup(m => m.Instance).Returns(() => serviceProvider); var mockedDbContext = dbContextMock.Object; var databaseFacadeMock = new Mock <DatabaseFacade>(mockedDbContext); databaseFacadeMock.As <IDatabaseFacadeDependenciesAccessor>().Setup(x => x.Dependencies).Returns(() => dependencies); databaseFacadeMock.Setup(x => x.BeginTransaction()).Returns(() => Mock.Of <IDbContextTransaction>()); var databaseFacade = databaseFacadeMock.Object; dbContextMock.Setup(m => m.Database).Returns(() => databaseFacade); return(mockedDbContext); }
public override TDbContext Create() { var mockedDbContext = (TDbContext)Substitute.For(new[] { typeof(TDbContext), typeof(IDbContextDependencies), typeof(IDbSetCache), typeof(IInfrastructure <IServiceProvider>), typeof(IDbContextPoolable) }, ConstructorParameters.ToArray()); var router = SubstitutionContext.Current.GetCallRouterFor(mockedDbContext); router.RegisterCustomCallHandlerFactory(state => new NoSetUpHandler()); mockedDbContext.Add(Arg.Any <object>()).Returns(callInfo => DbContext.Add(callInfo.Arg <object>())); mockedDbContext.AddAsync(Arg.Any <object>(), Arg.Any <CancellationToken>()) .Returns(callInfo => DbContext.AddAsync(callInfo.Arg <object>(), callInfo.Arg <CancellationToken>())); mockedDbContext.When(x => x.AddRange(Arg.Any <object[]>())).Do(callInfo => DbContext.AddRange(callInfo.Arg <object[]>())); mockedDbContext.When(x => x.AddRange(Arg.Any <IEnumerable <object> >())).Do(callInfo => DbContext.AddRange(callInfo.Arg <IEnumerable <object> >())); mockedDbContext.AddRangeAsync(Arg.Any <object[]>(), Arg.Any <CancellationToken>()) .Returns(callInfo => DbContext.AddRangeAsync(callInfo.Arg <object[]>(), callInfo.Arg <CancellationToken>())); mockedDbContext.AddRangeAsync(Arg.Any <IEnumerable <object> >(), Arg.Any <CancellationToken>()) .Returns(callInfo => DbContext.AddRangeAsync(callInfo.Arg <object>(), callInfo.Arg <CancellationToken>())); mockedDbContext.Attach(Arg.Any <object>()).Returns(callInfo => DbContext.Attach(callInfo.Arg <object>())); mockedDbContext.When(x => x.AttachRange(Arg.Any <object[]>())).Do(callInfo => DbContext.AttachRange(callInfo.Arg <object[]>())); mockedDbContext.When(x => x.AttachRange(Arg.Any <IEnumerable <object> >())).Do(callInfo => DbContext.AttachRange(callInfo.Arg <IEnumerable <object> >())); ((IDbContextDependencies)mockedDbContext).ChangeDetector.Returns(callInfo => ((IDbContextDependencies)DbContext).ChangeDetector); mockedDbContext.ChangeTracker.Returns(callInfo => DbContext.ChangeTracker); mockedDbContext.ContextId.Returns(callInfo => DbContext.ContextId); mockedDbContext.Database.Returns(callInfo => DbContext.Database); mockedDbContext.When(x => x.Dispose()).Do(callInfo => DbContext.Dispose()); mockedDbContext.DisposeAsync().Returns(callInfo => DbContext.DisposeAsync()); ((IDbContextDependencies)mockedDbContext).EntityFinderFactory.Returns(callInfo => ((IDbContextDependencies)DbContext).EntityFinderFactory); ((IDbContextDependencies)mockedDbContext).EntityGraphAttacher.Returns(callInfo => ((IDbContextDependencies)DbContext).EntityGraphAttacher); mockedDbContext.Entry(Arg.Any <object>()).Returns(callInfo => DbContext.Entry(callInfo.Arg <object>())); mockedDbContext.Find(Arg.Any <Type>(), Arg.Any <object[]>()).Returns(callInfo => DbContext.Find(callInfo.Arg <Type>(), callInfo.Arg <object[]>())); mockedDbContext.FindAsync(Arg.Any <Type>(), Arg.Any <object[]>()).Returns(callInfo => DbContext.FindAsync(callInfo.Arg <Type>(), callInfo.Arg <object[]>())); mockedDbContext.FindAsync(Arg.Any <Type>(), Arg.Any <object[]>(), Arg.Any <CancellationToken>()) .Returns(callInfo => DbContext.FindAsync(callInfo.Arg <Type>(), callInfo.Arg <object[]>(), callInfo.Arg <CancellationToken>())); ((IDbSetCache)mockedDbContext).GetOrAddSet(Arg.Any <IDbSetSource>(), Arg.Any <Type>()) .Returns(callInfo => ((IDbSetCache)DbContext).GetOrAddSet(callInfo.Arg <IDbSetSource>(), callInfo.Arg <Type>())); ((IDbContextDependencies)mockedDbContext).InfrastructureLogger.Returns(callInfo => ((IDbContextDependencies)DbContext).InfrastructureLogger); ((IInfrastructure <IServiceProvider>)mockedDbContext).Instance.Returns(callInfo => ((IInfrastructure <IServiceProvider>)DbContext).Instance); ((IDbContextDependencies)mockedDbContext).Model.Returns(callInfo => ((IDbContextDependencies)DbContext).Model); ((IDbContextDependencies)mockedDbContext).QueryProvider.Returns(callInfo => ((IDbContextDependencies)DbContext).QueryProvider); mockedDbContext.Remove(Arg.Any <object>()).Returns(callInfo => DbContext.Remove(callInfo.Arg <object>())); mockedDbContext.When(x => x.RemoveRange(Arg.Any <object[]>())).Do(callInfo => DbContext.RemoveRange(callInfo.Arg <object[]>())); mockedDbContext.When(x => x.RemoveRange(Arg.Any <IEnumerable <object> >())).Do(callInfo => DbContext.RemoveRange(callInfo.Arg <IEnumerable <object> >())); ((IDbContextPoolable)mockedDbContext).When(x => x.ResetState()).Do(callInfo => ((IDbContextPoolable)DbContext).ResetState()); ((IDbContextPoolable)mockedDbContext).When(x => x.ResetStateAsync(Arg.Any <CancellationToken>())) .Do(callInfo => ((IDbContextPoolable)DbContext).ResetStateAsync(callInfo.Arg <CancellationToken>())); // ((IDbContextPoolable) mockedDbContext).When(x => x.Resurrect(Arg.Any<DbContextPoolConfigurationSnapshot>())) // .Do(callInfo => ((IDbContextPoolable) DbContext).Resurrect(callInfo.Arg<DbContextPoolConfigurationSnapshot>())); mockedDbContext.SaveChanges().Returns(callInfo => DbContext.SaveChanges()); mockedDbContext.SaveChanges(Arg.Any <bool>()).Returns(callInfo => DbContext.SaveChanges(callInfo.Arg <bool>())); mockedDbContext.SaveChangesAsync(Arg.Any <CancellationToken>()).Returns(callInfo => DbContext.SaveChangesAsync(callInfo.Arg <CancellationToken>())); mockedDbContext.SaveChangesAsync(Arg.Any <bool>(), Arg.Any <CancellationToken>()) .Returns(callInfo => DbContext.SaveChangesAsync(callInfo.Arg <bool>(), callInfo.Arg <CancellationToken>())); // ((IDbContextPoolable) mockedDbContext).When(x => x.SetPool(Arg.Any<IDbContextPool>())) // .Do(callInfo => ((IDbContextPoolable) DbContext).SetPool(callInfo.Arg<IDbContextPool>())); ((IDbContextDependencies)mockedDbContext).SetSource.Returns(callInfo => ((IDbContextDependencies)DbContext).SetSource); // ((IDbContextPoolable) mockedDbContext).SnapshotConfiguration().Returns(callInfo => ((IDbContextPoolable) DbContext).SnapshotConfiguration()); ((IDbContextDependencies)mockedDbContext).StateManager.Returns(callInfo => ((IDbContextDependencies)DbContext).StateManager); mockedDbContext.Update(Arg.Any <object>()).Returns(callInfo => DbContext.Update(callInfo.Arg <object>())); ((IDbContextDependencies)mockedDbContext).UpdateLogger.Returns(callInfo => ((IDbContextDependencies)DbContext).UpdateLogger); mockedDbContext.When(x => x.UpdateRange(Arg.Any <object[]>())).Do(callInfo => DbContext.UpdateRange(callInfo.Arg <object[]>())); mockedDbContext.When(x => x.UpdateRange(Arg.Any <IEnumerable <object> >())).Do(callInfo => DbContext.UpdateRange(callInfo.Arg <IEnumerable <object> >())); foreach (var entity in DbContext.Model.GetEntityTypes().Where(x => x.FindPrimaryKey() != null)) { typeof(MockedDbContextFactory <TDbContext>).GetMethod(nameof(SetUpModelEntity), BindingFlags.Instance | BindingFlags.NonPublic) .MakeGenericMethod(entity.ClrType) .Invoke(this, new object[] { mockedDbContext }); } foreach (var entity in DbContext.Model.GetEntityTypes().Where(x => x.FindPrimaryKey() == null)) { typeof(MockedDbContextFactory <TDbContext>).GetMethod(nameof(SetUpReadOnlyModelEntity), BindingFlags.Instance | BindingFlags.NonPublic) .MakeGenericMethod(entity.ClrType) .Invoke(this, new object[] { mockedDbContext }); } //Relational set up var rawSqlCommandBuilder = Substitute.For <IRawSqlCommandBuilder>(); rawSqlCommandBuilder.Build(Arg.Any <string>(), Arg.Any <IEnumerable <object> >()) .Throws(callInfo => { Logger.LogDebug("Catch all exception invoked"); return(new InvalidOperationException()); }); var concurrencyDetector = Substitute.For <IConcurrencyDetector>(); concurrencyDetector.EnterCriticalSection().Returns(callInfo => new ConcurrencyDetectorCriticalSectionDisposer(Substitute.For <IConcurrencyDetector>())); var relationalConnection = Substitute.For <IRelationalConnection>(); relationalConnection.CommandTimeout.Returns(callInfo => 0); var dependencies = Substitute.For <IRelationalDatabaseFacadeDependencies>(); dependencies.ConcurrencyDetector.Returns(callInfo => concurrencyDetector); dependencies.CommandLogger.Returns(callInfo => Substitute.For <IDiagnosticsLogger <DbLoggerCategory.Database.Command> >()); dependencies.RawSqlCommandBuilder.Returns(callInfo => rawSqlCommandBuilder); dependencies.RelationalConnection.Returns(callInfo => relationalConnection); var serviceProvider = Substitute.For <IServiceProvider>(); serviceProvider.GetService(Arg.Is <Type>(t => t == typeof(IDatabaseFacadeDependencies))).Returns(callInfo => dependencies); ((IInfrastructure <IServiceProvider>)mockedDbContext).Instance.Returns(callInfo => serviceProvider); var databaseFacade = Substitute.For(new[] { typeof(DatabaseFacade), typeof(IDatabaseFacadeDependenciesAccessor) }, new[] { mockedDbContext }); ((IDatabaseFacadeDependenciesAccessor)databaseFacade).Dependencies.Returns(callInfo => dependencies); mockedDbContext.Database.Returns(callInfo => databaseFacade); return(mockedDbContext); }