public void FileProvider_InvalidDefaultPropertiesFile()
{
// Arrange
TestLogger logger = new TestLogger();
string defaultPropertiesDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string invalidFile = CreateFile(defaultPropertiesDir, FilePropertyProvider.DefaultFileName, "not a valid XML properties file");
IList<ArgumentInstance> args = new List<ArgumentInstance>();
// Act
CheckProcessingFails(args, defaultPropertiesDir, logger);
// Assert
logger.AssertErrorsLogged(1);
logger.AssertSingleErrorExists(invalidFile);
}
public void V0_9Upgrade_CalledFromV0_9()
{
// Arrange
TestLogger logger = new TestLogger();
ProcessRunnerArguments runnerArgs = new ProcessRunnerArguments(typeof(V0_9UpgradeMessageExe.Program).Assembly.Location, logger)
{
WorkingDirectory = this.TestContext.DeploymentDirectory
};
// Act
ProcessRunner runner = new ProcessRunner();
bool success = runner.Execute(runnerArgs);
// Assert
Assert.IsFalse(success);
logger.AssertSingleErrorExists(SonarQube.V0_9UpgradeMessageExe.Resources.UpgradeMessage);
logger.AssertErrorsLogged(1);
}
[WorkItem(72)] // Regression test for bug #72: fail the conversion if the output file is not created
public void Conv_FailsIfFileNotFound()
{
// Arrange
TestLogger logger = new TestLogger();
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string outputFilePath = Path.Combine(testDir, "output.txt");
string inputFilePath = Path.Combine(testDir, "input.txt");
File.WriteAllText(inputFilePath, "dummy input file");
string converterFilePath = Path.Combine(testDir, "converter.bat");
File.WriteAllText(converterFilePath, @"REM Do nothing - don't create a file");
// Act
bool success = CoverageReportConverter.ConvertBinaryToXml(converterFilePath, inputFilePath, outputFilePath, logger);
// Assert
Assert.IsFalse(success, "Expecting the process to fail");
logger.AssertErrorsLogged();
logger.AssertSingleErrorExists(outputFilePath); // error message should refer to the output file
Assert.IsFalse(File.Exists(outputFilePath), "Not expecting the output file to exist");
}
public void ArgProc_EndVerb()
{
// Arrange
TestLogger logger = new TestLogger();
string validUrl = "/d:sonar.host.url=http://foo";
// 1. Minimal parameters -> valid
IBootstrapperSettings settings = CheckProcessingSucceeds(logger, "end");
AssertExpectedPhase(AnalysisPhase.PostProcessing, settings);
AssertExpectedChildArguments(settings);
// 2. With additional parameters -> valid
logger = new TestLogger();
settings = CheckProcessingSucceeds(logger, "end", "ignored", "/d:key=value");
AssertExpectedPhase(AnalysisPhase.PostProcessing, settings);
logger.AssertWarningsLogged(0);
AssertExpectedChildArguments(settings, "ignored", "/d:key=value");
// 3. Multiple occurrences -> invalid
logger = CheckProcessingFails(validUrl, "end", "end");
logger.AssertSingleErrorExists(ArgumentProcessor.EndVerb);
// 4. Missing, no other arguments -> valid with warning
logger = new TestLogger();
settings = CheckProcessingSucceeds(logger);
AssertExpectedPhase(AnalysisPhase.PostProcessing, settings);
logger.AssertWarningsLogged(1);
AssertExpectedChildArguments(settings);
// 5. Incorrect case -> unrecognised -> treated as preprocessing -> fails (URL not supplied)
logger = CheckProcessingFails("END");
logger.AssertErrorsLogged();
// 6. Partial match -> unrecognised -> treated as preprocessing -> fails (URL not supplied)
logger = CheckProcessingFails("endX");
logger.AssertErrorsLogged();
}
public void ArgProc_BeginVerb()
{
// Arrange
TestLogger logger = new TestLogger();
string validUrl = "/d:sonar.host.url=http://foo";
// 1. Minimal parameters -> valid
IBootstrapperSettings settings = CheckProcessingSucceeds(logger, validUrl, "begin");
AssertExpectedPhase(AnalysisPhase.PreProcessing, settings);
logger.AssertWarningsLogged(0);
AssertExpectedChildArguments(settings, validUrl);
// 2. With additional parameters -> valid
settings = CheckProcessingSucceeds(logger, validUrl, "begin", "ignored", "k=2");
AssertExpectedPhase(AnalysisPhase.PreProcessing, settings);
logger.AssertWarningsLogged(0);
AssertExpectedChildArguments(settings, validUrl, "ignored", "k=2");
// 3. Multiple occurrences -> error
logger = CheckProcessingFails(validUrl, "begin", "begin");
logger.AssertSingleErrorExists(ArgumentProcessor.BeginVerb);
// 4. Missing -> valid with warning
logger = new TestLogger();
settings = CheckProcessingSucceeds(logger, validUrl);
logger.AssertSingleWarningExists(ArgumentProcessor.BeginVerb);
AssertExpectedChildArguments(settings, validUrl);
// 5. Incorrect case -> treated as unrecognised argument
// -> valid with 1 warning (no begin / end specified warning)
logger = new TestLogger();
settings = CheckProcessingSucceeds(logger, validUrl, "BEGIN"); // wrong case
logger.AssertWarningsLogged(1);
logger.AssertSingleWarningExists(ArgumentProcessor.BeginVerb);
AssertExpectedChildArguments(settings, validUrl, "BEGIN");
}
private void CheckInvalidUrlFails(string url)
{
// Arrange
TestLogger logger = new TestLogger();
BuildAgentUpdater updater = new BuildAgentUpdater();
string downloadDir = this.TestContext.DeploymentDirectory;
string nonExistentUrl = url;
string expectedUrl = nonExistentUrl + BootstrapperSettings.IntegrationUrlSuffix;
string expectedDownloadPath = Path.Combine(downloadDir, BootstrapperSettings.SonarQubeIntegrationFilename);
// Act
bool success = updater.TryUpdate(nonExistentUrl, downloadDir, logger);
// Assert
Assert.IsFalse(success, "Not expecting the update to succeed");
logger.AssertSingleDebugMessageExists(expectedUrl, expectedDownloadPath);
logger.AssertSingleErrorExists(nonExistentUrl);
logger.AssertErrorsLogged(1);
}
public void ProcRunner_MissingExe()
{
// Tests attempting to launch a non-existent exe
// Arrange
TestLogger logger = new TestLogger();
ProcessRunnerArguments args = new ProcessRunnerArguments("missingExe.foo", logger);
ProcessRunner runner = new ProcessRunner();
// Act
bool success = runner.Execute(args);
// Assert
Assert.IsFalse(success, "Expecting the process to have failed");
Assert.AreEqual(ProcessRunner.ErrorCode, runner.ExitCode, "Unexpected exit code");
logger.AssertSingleErrorExists("missingExe.foo");
}
public void Parser_Verbs_Multiples()
{
CommandLineParser parser;
IEnumerable<ArgumentInstance> instances;
TestLogger logger;
ArgumentDescriptor verb1 = new ArgumentDescriptor("v1", new string[] { "noMult" }, false /* required */, "noMult desc", false /* no multiples */, true);
ArgumentDescriptor verb2 = new ArgumentDescriptor("v2", new string[] { "multOk" }, false /* required */, "multOk desc", true /* allow multiples */, true);
parser = new CommandLineParser(new ArgumentDescriptor[] { verb1, verb2 }, true /* allow unrecognised */ );
// 1. Allowed multiples
logger = new TestLogger();
instances = CheckProcessingSucceeds(parser, logger, "multOk", "multOk");
AssertExpectedInstancesCount(2, instances);
// 2. Disallowed multiples
logger = CheckProcessingFails(parser, new string[] { "noMult", "noMult" });
logger.AssertSingleErrorExists("noMult");
logger.AssertErrorsLogged(1);
}
public void PreArgProc_Duplicates()
{
// 0. Setup
TestLogger logger = new TestLogger();
// 1. Duplicate key using alias
logger = CheckProcessingFails("/key:my.key", "/name:my name", "/version:1.2", "/k:key2");
logger.AssertErrorsLogged(1);
logger.AssertSingleErrorExists("/k:key2", "my.key"); // we expect the error to include the first value and the duplicate argument
// 2. Duplicate name, not using alias
logger = CheckProcessingFails("/key:my.key", "/name:my name", "/version:1.2", "/name:dupName");
logger.AssertErrorsLogged(1);
logger.AssertSingleErrorExists("/name:dupName", "my name");
// 3. Duplicate version, not using alias
logger = CheckProcessingFails("/key:my.key", "/name:my name", "/version:1.2", "/v:version2.0");
logger.AssertErrorsLogged(1);
logger.AssertSingleErrorExists("/v:version2.0", "1.2");
// Duplicate key (specified three times)
logger = CheckProcessingFails("/key:my.key", "/k:k2", "/k:key3");
logger.AssertSingleErrorExists("/k:k2", "my.key"); // Warning about key appears twice
logger.AssertSingleErrorExists("/k:key3", "my.key");
// ... and there should be warnings about other missing args too
logger.AssertSingleErrorExists("/version:");
logger.AssertSingleErrorExists("/name:");
logger.AssertErrorsLogged(4);
}
public void FileProvider_MissingPropertiesFile()
{
// Arrange
TestLogger logger = new TestLogger();
string defaultPropertiesDir = this.TestContext.DeploymentDirectory;
IList<ArgumentInstance> args = new List<ArgumentInstance>();
args.Add(new ArgumentInstance(FilePropertyProvider.Descriptor, "missingFile.txt"));
// Act
CheckProcessingFails(args, defaultPropertiesDir, logger);
// Assert
logger.AssertErrorsLogged(1);
logger.AssertSingleErrorExists("missingFile.txt");
}