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);
}
