public DatabaseReleaseTool(
string databaseScriptPath,
IFileStructurePolicy createDatabasePolicy,
IFileStructurePolicy fileStructurePolicy,
IOutputLogger outputLogger,
IConnectionStringFactory connectionStringFactory,
IDatabaseConnectionFactory databaseConnectionFactory)
{
if (outputLogger == null)
{
throw new ArgumentNullException("outputLogger");
}
if (string.IsNullOrEmpty(databaseScriptPath))
{
throw new ArgumentException(@"Cannot be null or empty.", "databaseScriptPath");
}
if (!Directory.Exists(databaseScriptPath))
{
throw new DirectoryNotFoundException(string.Format("Path: {0} does not exist.", databaseScriptPath));
}
_createDatabasePolicy = createDatabasePolicy;
_fileStructurePolicy = fileStructurePolicy;
_outputLogger = outputLogger;
_connectionStringFactory = connectionStringFactory;
_databaseConnectionFactory = databaseConnectionFactory;
_databaseScriptsDirInfo = new DirectoryInfo(databaseScriptPath);
}
public FileBoardConfigurationProvider(
string fileLocation,
IOutputLogger outputLogger)
{
_fileLocation = fileLocation;
_outputLogger = outputLogger;
}
public int ExecuteAll(string binaryPath, IProgressRecorder progressRecorder,
IOutputLogger logger, ICrossDomainLogger crossDomainLogger)
{
var executionOperation = new BinaryExecutionOperation(binaryPath,
progressRecorder, crossDomainLogger);
return(RunOperationRemotely("all", executionOperation, binaryPath, logger));
}
public void Execute(
IBinaryTestExecutor binaryTestExecutor,
IProgressRecorder progressRecorder,
IOutputLogger outputLogger, ICrossDomainLogger crossDomainLogger)
{
// TODO pass canceler to binaryTestExecutor.Execute
binaryTestExecutor.ExecuteAll(BinaryPath, progressRecorder, outputLogger, crossDomainLogger);
}
public void Execute(
IBinaryTestExecutor binaryTestExecutor,
IProgressRecorder progressRecorder,
IOutputLogger outputLogger, ICrossDomainLogger crossDomainLogger)
{
var testCaseFullNames = testCaseGroup.Select(tc => tc.FullyQualifiedName);
// TODO pass canceler to binaryTestExecutor.Execute
binaryTestExecutor.ExecuteSelected(BinaryPath, testCaseFullNames, progressRecorder, outputLogger, crossDomainLogger);
}
public int ExecuteSelected(string binaryPath, IEnumerable <string> testCaseFullNames,
IProgressRecorder progressRecorder,
IOutputLogger logger, ICrossDomainLogger crossDomainLogger)
{
string[] exampleFullNames = testCaseFullNames.ToArray();
var executionOperation = new SelectionExecutionOperation(binaryPath, exampleFullNames,
progressRecorder, crossDomainLogger);
return(RunOperationRemotely("selected", executionOperation, binaryPath, logger));
}
public virtual void before_each()
{
autoSubstitute = new AutoSubstitute();
testCases = new List <TestCase>();
discoverySink = autoSubstitute.Resolve <ITestCaseDiscoverySink>();
discoverySink.When(sink => sink.SendTestCase(Arg.Any <TestCase>())).Do(callInfo =>
{
var discoveredTestCase = callInfo.Arg <TestCase>();
testCases.Add(discoveredTestCase);
});
binaryTestDiscoverer = autoSubstitute.Resolve <IBinaryTestDiscoverer>();
binaryTestDiscoverer.Discover(null, null, null).ReturnsForAnyArgs(callInfo =>
{
string binaryPath = callInfo.Arg <string>();
if (sources.Contains(binaryPath))
{
return(discoveredExamplesBySource[binaryPath]);
}
else
{
return(new DiscoveredExample[0]);
}
});
var testCaseMapper = autoSubstitute.Resolve <ITestCaseMapper>();
testCaseMapper.FromDiscoveredExample(null).ReturnsForAnyArgs(callInfo =>
{
var discoveredExample = callInfo.Arg <DiscoveredExample>();
var testCase = new TestCase(discoveredExample.FullName, Constants.ExecutorUri, discoveredExample.SourceFilePath);
return(testCase);
});
var settingsRepository = autoSubstitute.Resolve <ISettingsRepository>();
var messageLogger = autoSubstitute.Resolve <IMessageLogger>();
outputLogger = autoSubstitute.Resolve <IOutputLogger>();
var loggerFactory = autoSubstitute.Resolve <ILoggerFactory>();
loggerFactory.CreateOutput(messageLogger, Arg.Any <IAdapterSettings>()).Returns(outputLogger);
discoverer = new MultiSourceTestDiscoverer(sources, binaryTestDiscoverer, testCaseMapper, settingsRepository, loggerFactory);
discoverer.DiscoverTests(discoverySink, messageLogger, autoSubstitute.Resolve <IDiscoveryContext>());
}
public GameEngine(
IBoardConfigurationProvider boardConfigurationProvider,
IMovesConfigurationProvider movesConfigurationProvider,
IOutputLogger outputLogger,
ICollection <IBoardValidator> boardValidators,
ICollection <IMoveValidator> moveValidators)
{
_boardConfigurationProvider = boardConfigurationProvider;
_movesConfigurationProvider = movesConfigurationProvider;
_outputLogger = outputLogger;
_boardValidators = boardValidators;
_moveValidators = moveValidators;
}
public virtual void before_each()
{
autoSubstitute = new AutoSubstitute();
proxyableExecutor = Substitute.For <IProxyableTestExecutor>();
remoteRunner = autoSubstitute.SubstituteFor <ICrossDomainRunner <IProxyableTestExecutor, int> >();
progressRecorder = autoSubstitute.Resolve <IProgressRecorder>();
logger = autoSubstitute.Resolve <IOutputLogger>();
crossDomainLogger = autoSubstitute.Resolve <ICrossDomainLogger>();
executor = autoSubstitute.Resolve <BinaryTestExecutor>();
}
public TransactionalSqlFileExecutor(IDbConnection connection, IOutputLogger outputLogger)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (outputLogger == null)
{
throw new ArgumentNullException("outputLogger");
}
_connection = connection;
_outputLogger = outputLogger;
}
public void TransactionalSqlFileExecutorShouldCallOutputLoggerWriteLineMethod()
{
// Arrange
IDbConnection conn = MockRepository.GenerateStub <IDbConnection>();
IOutputLogger outputLogger = MockRepository.GenerateMock <IOutputLogger>();
outputLogger.Expect(method => method.WriteInfoLine("Dummy", 1)).Repeat.Never();
TransactionalSqlFileExecutor executor = new TransactionalSqlFileExecutor(conn, outputLogger);
List <string> fileList = new List <string>();
// Act
executor.ExecuteTransactional(fileList, null);
// Assert
outputLogger.VerifyAllExpectations();
}
public IEnumerable <DiscoveredExample> Discover(string binaryPath,
IOutputLogger logger, ICrossDomainLogger crossDomainLogger)
{
if (!NSpecLibraryFound(binaryPath))
{
logger.Debug(String.Format("Skipping binary '{0}' because it does not reference nspec library", binaryPath));
return(new DiscoveredExample[0]);
}
else
{
var discoveryOperation = new BinaryDiscoveryOperation(binaryPath, crossDomainLogger);
return(RunOperationRemotely(discoveryOperation, binaryPath, logger));
}
}
public virtual void before_each()
{
autoSubstitute = new AutoSubstitute();
proxyableDiscoverer = Substitute.For <IProxyableTestDiscoverer>();
remoteRunner = autoSubstitute.SubstituteFor <
ICrossDomainRunner <IProxyableTestDiscoverer, DiscoveredExample[]> >();
fileService = autoSubstitute.Resolve <IFileService>();
logger = autoSubstitute.Resolve <IOutputLogger>();
crossDomainLogger = autoSubstitute.Resolve <ICrossDomainLogger>();
discoverer = autoSubstitute.Resolve <BinaryTestDiscoverer>();
}
IEnumerable <DiscoveredExample> RunOperationRemotely(
IDiscoveryOperation discoveryOperation, string binaryPath, IOutputLogger logger)
{
logger.Info(String.Format("Discovering tests in binary '{0}'", binaryPath));
IEnumerable <DiscoveredExample> discoveredExamples = remoteRunner.Run(binaryPath, discoveryOperation.Run,
(ex, path) =>
{
// report problem and return for the next assembly, without crashing the test discovery process
var message = String.Format("Exception thrown while discovering tests in binary '{0}'", binaryPath);
logger.Error(ex, message);
return(new DiscoveredExample[0]);
});
logger.Info(String.Format("Found {0} tests in binary '{1}'", discoveredExamples.Count(), binaryPath));
return(discoveredExamples);
}
public virtual void before_each()
{
autoSubstitute = new AutoSubstitute();
frameworkHandle = autoSubstitute.Resolve <IFrameworkHandle>();
binaryTestExecutor = autoSubstitute.Resolve <IBinaryTestExecutor>();
progressRecorder = autoSubstitute.Resolve <IProgressRecorder>();
progressRecorderFactory = autoSubstitute.Resolve <IProgressRecorderFactory>();
progressRecorderFactory.Create(frameworkHandle).Returns(progressRecorder);
settingsRepository = autoSubstitute.Resolve <ISettingsRepository>();
outputLogger = autoSubstitute.Resolve <IOutputLogger>();
loggerFactory = autoSubstitute.Resolve <ILoggerFactory>();
loggerFactory.CreateOutput(null, null).ReturnsForAnyArgs(outputLogger);
actualSources = new List <string>();
progressRecorder.BinaryPath = Arg.Do <string>(path => actualSources.Add(path));
}
public void TransactionalSqlFileExecutorShouldReadFilesWithGivenEncoding(string inputFile, bool useUtf8)
{
// Arrange
IDbConnection conn = MockRepository.GenerateStub <IDbConnection>();
IOutputLogger outputLogger = MockRepository.GenerateMock <IOutputLogger>();
IDbCommand command = MockRepository.GenerateStub <IDbCommand>();
IDbTransaction transaction = MockRepository.GenerateStub <IDbTransaction>();
conn.Expect(method => method.BeginTransaction()).Return(transaction);
conn.Expect(method => method.CreateCommand()).Return(command);
List <string> fileList = new List <string> {
inputFile
};
Encoding encoding = useUtf8 ? Encoding.UTF8 : Encoding.Default;
TransactionalSqlFileExecutor executor = new TransactionalSqlFileExecutor(conn, outputLogger);
// Act
executor.ExecuteTransactional(fileList, encoding);
// Assert
Assert.That(command.CommandText, Is.EqualTo(File.ReadAllText(inputFile, encoding)));
}
/// <summary>
/// Initializes a new instance of the <see cref="GitSquashWrapper" /> class.
/// </summary>
/// <param name="repoDirectory">The directory where the repository is located</param>
/// <param name="logger">The output logger to output GIT transactions.</param>
/// <param name="gitProcess">The GIT process to use.</param>
public GitSquashWrapper(string repoDirectory, IOutputLogger logger, IGitProcessManager gitProcess = null)
{
this.repoDirectory = repoDirectory;
this.gitProcess = gitProcess ?? new GitProcessManager(repoDirectory, logger);
this.branchManager = new BranchManager(this.repoDirectory, null);
}
public LoggableTest(IOutputLogger outputLogger)
{
this.OutputLogger = outputLogger;
}
public CityClinicsTest(IOutputLogger outputLogger) : base(outputLogger)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GitProcessManager"/> class.
/// </summary>
/// <param name="repoDirectory">The location of the GIT repository.</param>
/// <param name="newOutputLogger">The output logger where to send output.</param>
public GitProcessManager(string repoDirectory, IOutputLogger newOutputLogger)
{
this.repoDirectory = repoDirectory;
this.outputLogger = newOutputLogger;
}
public CrossDomainLogger(IOutputLogger outputLogger)
{
this.outputLogger = outputLogger;
}
/// <summary>
/// Initializes a new instance of the <see cref="BranchManager"/> class.
/// </summary>
/// <param name="repoPath">The directory to the repo.</param>
/// <param name="logger">The logger to use.</param>
public BranchManager(string repoPath, IOutputLogger logger)
{
this.gitProcessManager = new GitProcessManager(repoPath, logger);
}
public PangramTest(IOutputLogger outputLogger) : base(outputLogger)
{
}
public TopmostStepTest(IOutputLogger outputLogger) : base(outputLogger)
{
}
private bool InitialiseInternal(GameLoader loader)
{
if (m_state != GameState.NotStarted)
{
throw new Exception("Game already initialised");
}
loader.FilenameUpdated += loader_FilenameUpdated;
loader.LoadStatus += loader_LoadStatus;
m_state = GameState.Loading;
bool success;
if (m_data != null)
{
success = loader.Load(data: m_data);
}
else
{
success = m_filename == null || loader.Load(m_filename);
}
DebugEnabled = !loader.IsCompiledFile;
m_state = success ? GameState.Running : GameState.Finished;
m_errors = loader.Errors;
m_saver = new GameSaver(this);
if (Version <= WorldModelVersion.v530)
{
m_legacyOutputLogger = new LegacyOutputLogger(this);
m_outputLogger = m_legacyOutputLogger;
}
else
{
m_outputLogger = new OutputLogger(this);
}
return success;
}
public MergeArraysTask(IOutputLogger outputLogger) : base(outputLogger)
{
}
// TODO pass canceler to proxyableExecutor
int RunOperationRemotely(string description,
IExecutionOperation executionOperation, string binaryPath, IOutputLogger logger)
{
logger.Info(String.Format("Executing {0} tests in binary '{1}'", description, binaryPath));
int count = remoteRunner.Run(binaryPath, executionOperation.Run, (ex, path) =>
{
// report problem and return for the next assembly, without crashing the test execution process
var message = String.Format("Exception thrown while executing tests in binary '{0}'", path);
logger.Error(ex, message);
return(0);
});
logger.Info(String.Format("Executed {0} tests in binary '{1}'", count, binaryPath));
return(count);
}
