public void Configuration_WithInitializeSchemaTrueButInvalidConnectionString_ThrowsException()
{
// Arrange
const bool InitializeSchema = true;
string badConnectionString =
"server=.;Initial Catalog=" + TestConfiguration.DatabaseName + ";User Id=bad;Password=bad;";
IConfigurationWriter configuration =
BuildValidConfiguration(InitializeSchema, badConnectionString);
using (var manager = new IntegrationTestLoggingAppDomainManager(configuration))
{
try
{
// Act
manager.DomainUnderTest.InitializeLoggingSystem();
}
catch (ConfigurationErrorsException ex)
{
bool messageIsValid =
ex.Message.Contains("Initialization of database schema") &&
ex.Message.Contains("failed");
Assert.IsTrue(messageIsValid, "Exception message should describe the failure. " +
"Actual message: " + ex.Message);
}
}
}
public SchedulingController(IScheduler scheduler,
IConfigurationWriter configurationWriter,
IExecutionHistoryManager historyManager)
{
_scheduler = scheduler;
_configurationWriter = configurationWriter;
_historyManager = historyManager;
}
public ConfigurationController(IConfiguration configuration,
ITypeResolver typeResolver,
IIndex <string, ISerializer> serializerDictionary,
IConfigurationWriter configurationWriter)
{
this.configuration = configuration;
this.typeResolver = typeResolver;
this.serializer = serializerDictionary[CubesConstants.Serializer_JSON];
this.configurationWriter = configurationWriter;
}
protected override LocalSandbox <UnitTestRemoteSandbox> CreateLocalSandbox(string name,
IConfigurationWriter configuration)
{
var localSandbox = base.CreateLocalSandbox(name, configuration);
string currentAssemblyName = MethodBase.GetCurrentMethod().DeclaringType.Assembly.GetName().Name;
localSandbox.DependentFiles.Add(currentAssemblyName + ".dll");
return(localSandbox);
}
public ConfigurationUpdater(
ILogger <ConfigurationUpdater> logger,
AppState appState,
IMachineLocator machineLocator,
IConfigurationWriter configurationWriter
)
{
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.appState = appState ?? throw new ArgumentNullException(nameof(appState));
this.machineLocator = machineLocator ?? throw new ArgumentNullException(nameof(machineLocator));
this.configurationWriter = configurationWriter ?? throw new ArgumentNullException(nameof(configurationWriter));
}
public void Initialize_WithInitializeSchemaTrue_CreatesSchemaSuccesfully()
{
// Arrange
bool initializeSchema = true;
IConfigurationWriter configuration = BuildValidConfiguration(initializeSchema);
using (var manager = new IntegrationTestLoggingAppDomainManager(configuration))
{
// Act
manager.DomainUnderTest.InitializeLoggingSystem();
}
}
protected LoggingAppDomainManager(IConfigurationWriter configuration)
{
string name = "sandbox" + GetNextId();
this.sandbox = this.CreateLocalSandbox(name, configuration);
this.sandboxManager = new SandboxManager();
this.sandboxManager.Sandboxes.Add(this.sandbox);
this.sandboxManager.SetupAllSandboxes();
}
public DataController(IConnectionManager connectionManager,
IQueryManager queryManager,
IConfigurationWriter configurationWriter,
IOptionsSnapshot <DataAccessSettings> options,
ILocalStorage localStorage)
{
this.queryManager = queryManager;
this.configurationWriter = configurationWriter;
this.connectionManager = connectionManager;
this.settings = options.Value;
this.localStorage = localStorage;
}
// Constructors
public DefaultAudioSwitch(IDisplayManager displayManager,
IAudioDeviceManager audioDeviceManager,
IConfigurationReader configurationReader,
IConfigurationWriter configurationWriter)
{
_displayManager = displayManager;
_audioDeviceManager = audioDeviceManager;
_configurationReader = configurationReader;
_configurationWriter = configurationWriter;
_configuration = CreateDefaultConfigurationIfNecessary(displayManager);
_lastDisplayNode = _displayManager.GetCurrentDisplayMode();
_displayManager.DisplayModeChanged += DisplayModeChanged;
_displayManager.StartPolling(1000);
}
public void Configuration_WithInitializeSchemaTrue_CreatesSchemaSuccesfully()
{
// Arrange
const bool InitializeSchema = true;
string validConnectionString = TestConfiguration.ConnectionString;
IConfigurationWriter configuration =
BuildValidConfiguration(InitializeSchema, validConnectionString);
using (var manager = new IntegrationTestLoggingAppDomainManager(configuration))
{
// Act
manager.DomainUnderTest.InitializeLoggingSystem();
}
}
protected virtual LocalSandbox <TRemoteSandbox> CreateLocalSandbox(string name,
IConfigurationWriter configuration)
{
LocalSandbox <TRemoteSandbox> localSandbox =
new LocalSandbox <TRemoteSandbox>(name, configuration);
string currentAssemblyName = MethodBase.GetCurrentMethod().DeclaringType.Assembly.GetName().Name;
localSandbox.DependentFiles.Add("CuttingEdge.Logging.dll");
localSandbox.DependentFiles.Add(currentAssemblyName + ".dll");
localSandbox.DependentFiles.Add("NSandbox.dll");
return(localSandbox);
}
public MusicFileCop(IFileSystemLoader fileSystemLoader, IConfigurationLoader configurationLoader,
IMetadataLoader metadataLoader, IConsistencyChecker consistencyChecker,
IDefaultConfigurationNode defaultConfiguration, IConfigurationWriter configWriter, ITextOutputWriter outputWriter, IRuleSet ruleSet)
{
if (fileSystemLoader == null)
{
throw new ArgumentNullException(nameof(fileSystemLoader));
}
if (configurationLoader == null)
{
throw new ArgumentNullException(nameof(configurationLoader));
}
if (metadataLoader == null)
{
throw new ArgumentNullException(nameof(metadataLoader));
}
if (consistencyChecker == null)
{
throw new ArgumentNullException(nameof(consistencyChecker));
}
if (defaultConfiguration == null)
{
throw new ArgumentNullException(nameof(defaultConfiguration));
}
if (configWriter == null)
{
throw new ArgumentNullException(nameof(configWriter));
}
if (outputWriter == null)
{
throw new ArgumentNullException(nameof(outputWriter));
}
if (ruleSet == null)
{
throw new ArgumentNullException(nameof(ruleSet));
}
this.m_FileSystemLoader = fileSystemLoader;
this.m_ConfigLoader = configurationLoader;
this.m_MetadataLoader = metadataLoader;
this.m_ConsistencyChecker = consistencyChecker;
this.m_DefaultConfiguration = defaultConfiguration;
m_ConfigWriter = configWriter;
m_OutputWriter = outputWriter;
m_RuleSet = ruleSet;
}
public void Log_WithValidLogEntryWithoutException_Succeeds()
{
// Arrange
bool initializeSchema = true;
IConfigurationWriter configuration = BuildValidConfiguration(initializeSchema);
LogEntry entry =
new LogEntry(LoggingEventType.Critical, "my message", "my source", null);
using (var manager = new IntegrationTestLoggingAppDomainManager(configuration))
{
manager.DomainUnderTest.InitializeLoggingSystem();
// Act
manager.DomainUnderTest.Log(entry);
}
}
public static string Serialise <T>(this IConfigurationWriter <T> writer, T configuration)
{
using (var enumerator = writer.GenerateParts(configuration).GetEnumerator())
{
if (!enumerator.MoveNext())
{
return("");
}
var builder = new StringBuilder();
WriteQuotedPart(builder, enumerator.Current);
while (enumerator.MoveNext())
{
builder.Append(" ");
WriteQuotedPart(builder, enumerator.Current);
}
return(builder.ToString());
}
}
public void Configuration_LoggingAValidLogEntryWithoutAnException_Succeeds()
{
// Arrange
const bool InitializeSchema = true;
string validConnectionString = TestConfiguration.ConnectionString;
IConfigurationWriter configuration =
BuildValidConfiguration(InitializeSchema, validConnectionString);
LogEntry entry = new LogEntry(LoggingEventType.Critical, "my message", "my source", null);
using (var manager = new IntegrationTestLoggingAppDomainManager(configuration))
{
manager.DomainUnderTest.InitializeLoggingSystem();
// Act
manager.DomainUnderTest.Log(entry);
}
}
public LocationsController(IFileOptions options, IConfigurationWriter configurationWriter)
{
_helper = new LocationsHelper(options, configurationWriter);
}
public LocationsHelper(IFileOptions options, IConfigurationWriter configurationWriter)
{
_options = options;
_writer = configurationWriter;
}
public CommonLoggingTestLoggingAppDomainManager(IConfigurationWriter configuration)
: base(configuration)
{
}
public AddCommand(IConfigurationWriter writer)
{
_config = writer;
}
// Constructors
public DefaultConfigurationManager(IConfigurationReader configurationReader, IConfigurationWriter configurationWriter)
{
}
public UnitTestAppDomainManager(IConfigurationWriter configuration) : base(configuration)
{
}
public IntegrationTestLoggingAppDomainManager(IConfigurationWriter configuration) : base(configuration)
{
this.DomainUnderTest.BeginTransactionScope();
}
public static void Save <T>(this IConfigurationWriter writer, T configInstance) => writer.Save(typeof(T), configInstance);
public GenericConfigurationDialogProvider(IConfigurationWriter configurationWriter,
IConfigurationReader configurationReader,
IEndpointCommandSender endpointCommandSender)
=> _configurationDialog = new GenericConfigurationDialog <PlantConfiguration>();
