/// <summary>
/// Configures the specified configuration for the Azure Service Bus.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="channelId">The channel identifier.</param>
/// <param name="boundaryLoggingActive">Sets boundary logging as active.</param>
public override void Configure(IEnvironmentConfiguration configuration
, string channelId
, bool boundaryLoggingActive = true)
{
base.Configure(configuration, channelId, boundaryLoggingActive);
Service.AzureServiceBusPropertiesSet(configuration);
}
public static IPipelineAspNetCore AddXigadee(this IServiceCollection services, string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policy = null
, IEnumerable <Tuple <string, string> > properties = null
, IEnvironmentConfiguration config = null
, Action <IMicroservice> assign = null
, Action <IEnvironmentConfiguration> configAssign = null
, bool addDefaultJsonPayloadSerializer = true
, bool addDefaultPayloadCompressors = true
, string serviceVersionId = null
, Type serviceReference = null)
{
XigadeeHostedService service = services.GetXigadeeService();
if (service != null)
{
return(service.Pipeline);
}
var ms = services.XigadeeCreate(name, serviceId, description, policy
, properties, config, assign
, configAssign, addDefaultJsonPayloadSerializer, addDefaultPayloadCompressors
, serviceVersionId, serviceReference);
return(ms.Pipeline);
}
/// <summary>
/// This is the default constructor for the pipeline.
/// </summary>
/// <param name="name">The Microservice name.</param>
/// <param name="serviceId">The service id.</param>
/// <param name="description">An optional description of the Microservice.</param>
/// <param name="policy">The policy settings collection.</param>
/// <param name="properties">Any additional property key/value pairs.</param>
/// <param name="config">The environment config object</param>
/// <param name="assign">The action can be used to assign items to the microservice.</param>
/// <param name="configAssign">This action can be used to adjust the config settings.</param>
/// <param name="addDefaultJsonPayloadSerializer">This property specifies that the default Json
/// payload serializer should be added to the Microservice, set this to false to disable this.</param>
/// <param name="addDefaultPayloadCompressors">This method ensures the Gzip and Deflate compressors are added to the Microservice.</param>
/// <param name="serviceVersionId">This is the version id of the calling assembly as a string.</param>
/// <param name="serviceReference">This is a reference type used to identify the version id of the root assembly.</param>
public MicroservicePipeline(string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policy = null
, IEnumerable <Tuple <string, string> > properties = null
, IEnvironmentConfiguration config = null
, Action <IMicroservice> assign = null
, Action <IEnvironmentConfiguration> configAssign = null
, bool addDefaultJsonPayloadSerializer = true
, bool addDefaultPayloadCompressors = true
, string serviceVersionId = null
, Type serviceReference = null
)
{
Configuration = config ?? new ConfigBase();
configAssign?.Invoke(Configuration);
serviceVersionId = serviceVersionId ?? serviceReference?.Assembly.GetName().Version.ToString();
Service = new Microservice(name, serviceId, description, policy, properties, serviceVersionId);
assign?.Invoke(Service);
if (addDefaultJsonPayloadSerializer)
{
this.AddPayloadSerializerDefaultJson();
}
if (addDefaultPayloadCompressors)
{
this.AddPayloadCompressorsDefault();
}
}
/// <summary>
///
/// </summary>
/// <param name="environmentalConfiguration"></param>
/// <param name="adxeCertificateValidationHandler"></param>
public SwaggerExamplePort(IEnvironmentConfiguration environmentalConfiguration, SwaggerExampleCertificateValidationHandler adxeCertificateValidationHandler)
{
_environmentalConfiguration = environmentalConfiguration;
_adxeCertificateValidationHandler = adxeCertificateValidationHandler;
_httpClient = new HttpClient(_adxeCertificateValidationHandler);
_httpClient.Timeout = TimeSpan.FromSeconds(300);
}
/// <summary>
/// This is the default constructor for the pipeline.
/// </summary>
/// <param name="name">The Microservice name.</param>
/// <param name="serviceId">The service id.</param>
/// <param name="description">This is an optional Microservice description.</param>
/// <param name="policy">The policy settings collection.</param>
/// <param name="properties">Any additional property key/value pairs.</param>
/// <param name="config">The environment config object</param>
/// <param name="assign">The action can be used to assign items to the microservice.</param>
/// <param name="configAssign">This action can be used to adjust the config settings.</param>
/// <param name="addDefaultJsonPayloadSerializer">This property specifies that the default Json
/// payload serializer should be added to the Microservice, set this to false to disable this.</param>
/// <param name="addDefaultPayloadCompressors">This method ensures the Gzip and Deflate compressors are added to the Microservice.</param>
/// <param name="httpConfig">The http configuration.</param>
/// <param name="registerConfig">The boolean property registers the Microservice configuration with Unity.</param>
/// <param name="serviceVersionId">This is the version id of the calling assembly as a string.</param>
/// <param name="serviceReference">This is a reference type used to identify the version id of the root assembly.</param>
public UnityWebApiMicroservicePipeline(string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policy = null
, IEnumerable <Tuple <string, string> > properties = null
, IEnvironmentConfiguration config = null
, Action <IMicroservice> assign = null
, Action <IEnvironmentConfiguration> configAssign = null
, bool addDefaultJsonPayloadSerializer = true
, bool addDefaultPayloadCompressors = true
, HttpConfiguration httpConfig = null
, bool registerConfig = true
, string serviceVersionId = null
, Type serviceReference = null
) : base(name, serviceId, description, policy, properties, config, assign, configAssign, addDefaultJsonPayloadSerializer, addDefaultPayloadCompressors, httpConfig, serviceVersionId, serviceReference)
{
//ApiConfig.
Unity = new UnityContainer();
HttpConfig.DependencyResolver = new UnityDependencyResolver(Unity);
if (registerConfig)
{
Unity.RegisterInstance <IEnvironmentConfiguration>(this.Configuration);
}
}
/// <summary>
/// When the environment is configured it removes the configuration. Defaults are not removed.
/// </summary>
public static void Deconfigure()
{
_instance = null;
_defaults.Clear();
InitDefaults();
}
/// <summary>
/// Adds a trace to the current value. Useful for tracing the surces and source types
/// </summary>
/// <param name="configuration"></param>
/// <param name="value">the trace value</param>
/// <param name="sourceType">the optional source type (will ne displayed in brackets before the value)</param>
/// <returns></returns>
public static IEnvironmentConfiguration WithTrace(this IEnvironmentConfiguration configuration, string value, string sourceType = null)
{
return(configuration.SetValue(Constants.SourceTraceValueKey,
string.IsNullOrEmpty(sourceType?.Trim())
? value
: $"[{sourceType}]{value}"));
}
/// <summary>
/// Configures the specified configuration for the Azure Service Bus.
/// </summary>
/// <param name="configuration">The configuration parameters.</param>
/// <param name="channelId">The channel identifier.</param>
/// <param name="mappingChannelId">The actual channel id for the fabric queue.</param>
public virtual void Configure(IEnvironmentConfiguration configuration
, string channelId
, string mappingChannelId = null
, bool boundaryLoggingActive = true)
{
base.Configure(configuration, channelId, boundaryLoggingActive);
Service.MappingChannelId = mappingChannelId;
}
public static StorageCredentials StorageCredentials(this IEnvironmentConfiguration config)
{
if (string.IsNullOrEmpty(config.StorageAccountName()) || string.IsNullOrEmpty(config.StorageAccountAccessKey()))
{
return(null);
}
return(new StorageCredentials(config.StorageAccountName(), config.StorageAccountAccessKey()));
}
public HomeController(
IHttpClientFactory httpFactory,
ILoggerFactory loggerFactory,
IEnvironmentConfiguration environmentConfiguration)
{
_factory = httpFactory;
_logger = loggerFactory.CreateLogger <HomeController>();
_envConfig = environmentConfiguration;
}
/// <summary>
///
/// </summary>
/// <param name="Configuration"></param>
/// <param name="key"></param>
/// <param name="errorMessage"></param>
public static void ConfigAssertKeyPresent(this IEnvironmentConfiguration Configuration, string key, string errorMessage = null)
{
if (Configuration.CanResolve(key))
{
return;
}
throw new ConfigAssertKeyNotPresentException(key, errorMessage);
}
public static ClientCredential KeyVaultClientCredential(this IEnvironmentConfiguration config)
{
if (string.IsNullOrEmpty(config.KeyVaultClientId()) || string.IsNullOrEmpty(config.KeyVaultClientSecret()))
{
return(null);
}
return(new ClientCredential(config.KeyVaultClientId(), config.KeyVaultClientSecret()));
}
public static StorageCredentials AzureStorageCredentials(this IEnvironmentConfiguration config, bool throwExceptionIfNotFound = true)
{
if (string.IsNullOrEmpty(config.AzureStorageAccountName(throwExceptionIfNotFound)) ||
string.IsNullOrEmpty(config.AzureStorageAccountAccessKey(throwExceptionIfNotFound)))
{
return(null);
}
return(new StorageCredentials(config.AzureStorageAccountName(), config.AzureStorageAccountAccessKey()));
}
/// <summary>
/// This method validates that the Event Hub connection is set.
/// </summary>
/// <param name="Configuration">The configuration.</param>
/// <param name="eventHubsConnection">The alternate connection.</param>
/// <returns>Returns the connection from either the parameter or from the settings.</returns>
private static string EventHubsConnectionValidate(this IEnvironmentConfiguration Configuration, string eventHubsConnection)
{
var conn = eventHubsConnection ?? Configuration.EventHubsConnection();
if (string.IsNullOrEmpty(conn))
{
throw new AzureConnectionException();//"Service bus connection string cannot be resolved. Please check the config settings has been set.");
}
return(conn);
}
/// <summary>
/// This method validates that the Event Hub connection is set.
/// </summary>
/// <param name="Configuration">The configuration.</param>
/// <param name="eventHubsConnection">The alternate connection.</param>
/// <returns>Returns the connection from either the parameter or from the settings.</returns>
private static string EventHubsConnectionValidate(this IEnvironmentConfiguration Configuration, string eventHubsConnection)
{
var conn = eventHubsConnection ?? Configuration.EventHubsConnection();
if (string.IsNullOrEmpty(conn))
{
throw new AzureConnectionException(AzureExtensionMethods.KeyEventHubsConnection);
}
return(conn);
}
/// <summary>
/// Configures the Ncqrs environment.
/// </summary>
/// <param name="source">The source that contains the configuration for the current environment.</param>
public static void Configure(IEnvironmentConfiguration source)
{
Contract.Requires <ArgumentNullException>(source != null, "The source cannot be null.");
Contract.Requires <InvalidOperationException>(!IsConfigured, "Cannot configure the environment when it is already configured.");
Contract.Ensures(_instance == source, "The given source should initialize the _instance member.");
Contract.Ensures(IsConfigured, "The given source should configure this environment.");
_instance = source;
Log.InfoFormat("Ncqrs environment configured with {0} configuration source.", source.GetType().FullName);
}
public static void Initialize(IEnvironmentConfiguration environmentConfiguration)
{
BluetoothConstants.ServiceUUID = environmentConfiguration.GetValue("BluetoothTracing_ServiceUUID");
BluetoothConstants.CharacteristicUUID = environmentConfiguration.GetValue("BluetoothTracing_CharacteristicUUID");
BluetoothConstants.DataExpirationTime = TimeSpan.FromDays(int.Parse(environmentConfiguration.GetValue("BluetoothTracing_DataExpirationTimeDays")));
BluetoothConstants.DeviceThrottleTime = TimeSpan.FromMinutes(int.Parse(environmentConfiguration.GetValue("BluetoothTracing_DeviceThrottleTimeMinutes")));
PushNotificationsConstants.SubscriptionTags = new string[] { environmentConfiguration.GetValue("PushNotifications_SubscriptionTags") };
PushNotificationsConstants.FCMTemplateBody = environmentConfiguration.GetValue("PushNotifications_FCMTemplateBody");
PushNotificationsConstants.APNTemplateBody = environmentConfiguration.GetValue("PushNotifications_APNTemplateBody");
}
/// <summary>
/// Adds a logger to the pipeline
/// </summary>
/// <param name="configuration"></param>
/// <param name="loggerFacade">the logger to use</param>
/// <param name="level">the logging level to use</param>
/// <returns></returns>
public static IEnvironmentConfiguration WithLogger(this IEnvironmentConfiguration configuration,
ILoggerFacade loggerFacade, LogLevel level)
{
if (loggerFacade == null)
{
throw new ArgumentException("Cannot set a null logger facade", nameof(loggerFacade));
}
loggerFacade.LogLevel = level;
return(configuration.SetValue(typeof(ILoggerFacade).FullName, (ILoggerFacade)loggerFacade));
}
/// <summary>
/// This method validates that the service bus connection is set.
/// </summary>
/// <param name="Configuration">The configuration.</param>
/// <param name="serviceBusConnection">The alternate connection.</param>
/// <returns>Returns the connection from either the parameter or from the settings.</returns>
private static string ServiceBusConnectionValidate(this IEnvironmentConfiguration Configuration, string serviceBusConnection)
{
var conn = serviceBusConnection ?? Configuration.ServiceBusConnection();
if (string.IsNullOrEmpty(conn))
{
throw new AzureServiceBusConnectionException(KeyServiceBusConnection);
}
return(conn);
}
/// <summary>
/// Sets the Azure Service Bus connection properties.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="config">The configuration.</param>
/// <param name="channelId">The channel identifier.</param>
public static void AzureServiceBusPropertiesSet(this IAzureServiceBusMessagingService service
, IEnvironmentConfiguration config)
{
config.ServiceBusConnectionValidate(null);
var connection = config.ServiceBusConnection();
service.Connection = new AzureServiceBusConnection(
new ServiceBusConnectionStringBuilder(connection)
, ReceiveMode.PeekLock
, null);
}
public static LoggingLevel ApplicationInsightsLoggingLevel(this IEnvironmentConfiguration config, bool throwException = false)
{
LoggingLevel loggingLevel;
var configLevel = config.PlatformOrConfigCache(KeyApplicationInsightsLoggingLevel);
if (!string.IsNullOrEmpty(configLevel) && Enum.TryParse(configLevel, out loggingLevel))
{
return(loggingLevel);
}
return(LoggingLevel.Warning);
}
/// <summary>
/// Sets the current active log level for the configured logger
/// </summary>
/// <param name="configuration"></param>
/// <param name="level">the log level to set</param>
/// <returns></returns>
public static IEnvironmentConfiguration WithLogLevel(this IEnvironmentConfiguration configuration,
LogLevel level)
{
if (configuration.HasValue(typeof(ILoggerFacade).FullName))
{
if (configuration.GetValue <ILoggerFacade>(typeof(ILoggerFacade).FullName) is ILoggerFacade facade)
{
facade.LogLevel = level;
}
}
return(configuration);
}
/// <summary>
/// This is the default pipeline.
/// </summary>
/// <param name="service">The microservice.</param>
/// <param name="config">The microservice configuration.</param>
public MicroservicePipeline(IMicroservice service, IEnvironmentConfiguration config)
{
if (service == null)
{
throw new ArgumentNullException("service cannot be null");
}
if (config == null)
{
throw new ArgumentNullException("config cannot be null");
}
Service = service;
Configuration = config;
}
/// <summary>
/// This is the default constructor for the pipeline.
/// </summary>
/// <param name="name">The Microservice name.</param>
/// <param name="serviceId">The service id.</param>
/// <param name="description">This is an optional Microservice description.</param>
/// <param name="policy">The policy settings collection.</param>
/// <param name="properties">Any additional property key/value pairs.</param>
/// <param name="config">The environment config object</param>
/// <param name="assign">The action can be used to assign items to the microservice.</param>
/// <param name="configAssign">This action can be used to adjust the config settings.</param>
/// <param name="addDefaultJsonPayloadSerializer">This property specifies that the default Json
/// payload serializer should be added to the Microservice, set this to false to disable this.</param>
/// <param name="httpConfig">The http configuration.</param>
public WebApiMicroservicePipeline(string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policy = null
, IEnumerable <Tuple <string, string> > properties = null
, IEnvironmentConfiguration config = null
, Action <IMicroservice> assign = null
, Action <IEnvironmentConfiguration> configAssign = null
, bool addDefaultJsonPayloadSerializer = true
, HttpConfiguration httpConfig = null
) : base(name, serviceId, description, policy, properties, config, assign, configAssign, addDefaultJsonPayloadSerializer)
{
HttpConfig = httpConfig ?? new HttpConfiguration();
}
public void EnvironmentRequirements(IEnvironmentConfiguration cfg)
{
cfg
.WithOutQueue()
.WithInQueue();
//.WithResource("inQueue")
//.WithResource("inQueue", serializer => (ISerializer)null, deserializer => (IDeserializer)null )
//.WithResource("outQueue")
//.WithResource("inQueue", env => CreateInQueue(env))
//.WithResource("outQueue", (IResource) null);
//PresiceEnvironmentConfiguration.Configure(cfg)
// .WithQueueBroker();
}
/// <summary>
/// This is the default pipeline.
/// </summary>
/// <param name="service">The microservice.</param>
/// <param name="config">The microservice configuration.</param>
/// <param name="httpConfig">The http configuration.</param>
/// <param name="registerConfig">The boolean property registers the Microservice configuration with Unity.</param>
public UnityWebApiMicroservicePipeline(IMicroservice service
, IEnvironmentConfiguration config
, HttpConfiguration httpConfig = null
, bool registerConfig = true
) : base(service, config, httpConfig)
{
//ApiConfig.
Unity = new UnityContainer();
HttpConfig.DependencyResolver = new UnityDependencyResolver(Unity);
if (registerConfig)
{
Unity.RegisterInstance <IEnvironmentConfiguration>(this.Configuration);
}
}
/// <summary>
/// Adds the xml file to the configuration. Multiple different files can be added.
/// </summary>
/// <param name="configuration"></param>
/// <param name="file">the file to use</param>
/// <param name="namespaces">The xml namespaces to load</param>
/// <param name="eagerLoad">if the file should be eagerly loaded rather than lazily loaded</param>
/// <returns></returns>
public static IEnvironmentConfiguration WithXmlFile(this IEnvironmentConfiguration configuration, string file,
IDictionary <string, string> namespaces = null, bool eagerLoad = false)
{
XmlFileParser parser = null;
if (configuration.HasValue(typeof(XmlFileParser).FullName))
{
parser = configuration.GetValue <XmlFileParser>(typeof(XmlFileParser).FullName);
}
else
{
configuration.SetValue(typeof(XmlFileParser).FullName, parser = new XmlFileParser());
}
if (parser.Files.Keys.Any(x => String.Equals(x, file, StringComparison.OrdinalIgnoreCase)))
{
return(configuration);
}
else
{
var data = new XmlFileParser.FileDataHolder();
if (eagerLoad)
{
try
{
data.ParsedFile = XDocument.Parse(File.ReadAllText(file));
}
catch
{
data.ParsingFailed = true;
}
}
data.Path = file;
if (namespaces != null && namespaces.Any())
{
foreach (var keyValuePair in namespaces)
{
data.NamespaceManager.AddNamespace(keyValuePair.Key, keyValuePair.Value);
}
}
parser.Files.Add(file, data);
}
return(configuration);
}
/// <summary>
/// Initializes a new instance of the <see cref="XigadeeHostedService"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="serviceId">The service identifier.</param>
/// <param name="description">The description.</param>
/// <param name="policy">The policy.</param>
/// <param name="properties">The properties.</param>
/// <param name="config">The configuration.</param>
/// <param name="assign">The assign.</param>
/// <param name="configAssign">The configuration assign.</param>
/// <param name="addDefaultJsonPayloadSerializer">if set to <c>true</c> [add default json payload serializer].</param>
/// <param name="addDefaultPayloadCompressors">if set to <c>true</c> [add default payload compressors].</param>
/// <param name="serviceVersionId">The service version identifier.</param>
/// <param name="serviceReference">The service reference.</param>
public XigadeeHostedService(string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policy = null
, IEnumerable <Tuple <string, string> > properties = null
, IEnvironmentConfiguration config = null
, Action <IMicroservice> assign = null
, Action <IEnvironmentConfiguration> configAssign = null
, bool addDefaultJsonPayloadSerializer = true
, bool addDefaultPayloadCompressors = true
, string serviceVersionId = null
, Type serviceReference = null)
{
Pipeline = new AspNetCoreMicroservicePipeline(name, serviceId, description, policy
, properties, config, assign, configAssign
, addDefaultJsonPayloadSerializer, addDefaultPayloadCompressors
, serviceVersionId, serviceReference);
}
private void IsolateRepository()
{
ObjectFactory.EjectAllInstancesOf <IConnectionCache>();
_envConfig = Isolate.Fake.Instance <IEnvironmentConfiguration>();
Isolate.WhenCalled(() => _confMan.GetConfiguration("Test")).WillReturn(_envConfig);
_connection = Isolate.Fake.Instance <IDbConnection>();
Isolate.WhenCalled(() => _envConfig.GetConnection()).WillReturn(_connection);
_factory = Isolate.Fake.Instance <ISessionFactory>();
Isolate.WhenCalled(() => _envConfig.GetSessionFactory()).WillReturn(_factory);
_session = Isolate.Fake.Instance <ISession>();
Isolate.WhenCalled(() => _factory.OpenSession(_connection)).WillReturn(_session);
Isolate.WhenCalled(() => _envConfig.BuildSchema(_session)).IgnoreCall();
Isolate.WhenCalled(() => CurrentSessionContext.Bind(_session)).IgnoreCall();
}
/// <summary>
/// This is the default constructor for the pipeline.
/// </summary>
/// <param name="name">The Microservice name.</param>
/// <param name="serviceId">The service id.</param>
/// <param name="description">An optional description of the Microservice.</param>
/// <param name="policy">The policy settings collection.</param>
/// <param name="properties">Any additional property key/value pairs.</param>
/// <param name="config">The environment config object</param>
/// <param name="assign">The action can be used to assign items to the microservice.</param>
/// <param name="configAssign">This action can be used to adjust the config settings.</param>
/// <param name="addDefaultJsonPayloadSerializer">This property specifies that the default Json
/// payload serializer should be added to the Microservice, set this to false to disable this.</param>
public MicroservicePipeline(string name = null
, string serviceId = null
, string description = null
, IEnumerable <PolicyBase> policy = null
, IEnumerable <Tuple <string, string> > properties = null
, IEnvironmentConfiguration config = null
, Action <IMicroservice> assign = null
, Action <IEnvironmentConfiguration> configAssign = null
, bool addDefaultJsonPayloadSerializer = true
)
{
Configuration = config ?? new ConfigBase();
configAssign?.Invoke(Configuration);
Service = new Microservice(name, serviceId, description, policy, properties);
assign?.Invoke(Service);
if (addDefaultJsonPayloadSerializer)
{
this.AddPayloadSerializerDefaultJson();
}
}
/// <summary>
/// Adds the json file to the configuration. Multiple different files can be added.
/// Use root expression syntax for file selection <example>$(filename).some.path</example>
/// </summary>
/// <param name="configuration"></param>
/// <param name="file">the file to use</param>
/// <param name="eagerLoad">load the file eagerly instead of lazily</param>
/// <returns></returns>
public static IEnvironmentConfiguration WithJsonFile(this IEnvironmentConfiguration configuration, string file, bool eagerLoad = false)
{
JsonFileParser parser = null;
if (configuration.HasValue(typeof(JsonFileParser).FullName))
{
parser = configuration.GetValue <JsonFileParser>(typeof(JsonFileParser).FullName);
}
else
{
configuration.SetValue(typeof(JsonFileParser).FullName, parser = new JsonFileParser());
}
if (parser.Files.Keys.Any(x => String.Equals(x, file, StringComparison.OrdinalIgnoreCase)))
{
return(configuration);
}
else
{
var data = new JsonFileParser.FileDataHolder();
if (eagerLoad)
{
try
{
data.ParsedFile = JsonManager.Parse(File.ReadAllText(file));
}
catch
{
data.ParsingFailed = true;
}
}
data.Path = file;
parser.Files.Add(file, data);
}
return(configuration);
}
public Backuperer(IFileSystem files, IEnvironmentConfiguration config)
{
this.files = files;
this.config = config;
}
private void IsolateRepository()
{
ObjectFactory.EjectAllInstancesOf<IConnectionCache>();
_envConfig = Isolate.Fake.Instance<IEnvironmentConfiguration>();
Isolate.WhenCalled(() => _confMan.GetConfiguration("Test")).WillReturn(_envConfig);
_connection = Isolate.Fake.Instance<IDbConnection>();
Isolate.WhenCalled(() => _envConfig.GetConnection()).WillReturn(_connection);
_factory = Isolate.Fake.Instance<ISessionFactory>();
Isolate.WhenCalled(() => _envConfig.GetSessionFactory()).WillReturn(_factory);
_session = Isolate.Fake.Instance<ISession>();
Isolate.WhenCalled(() => _factory.OpenSession(_connection)).WillReturn(_session);
Isolate.WhenCalled(() => _envConfig.BuildSchema(_session)).IgnoreCall();
Isolate.WhenCalled(() => CurrentSessionContext.Bind(_session)).IgnoreCall();
}
