private static IAnalysisPropertyProvider CheckProcessingSucceeds(TestLogger logger, string[] input)
{
bool success = ArgumentProcessor.TryProcessArgs(input, logger, out IAnalysisPropertyProvider provider);
Assert.IsTrue(success, "Expecting processing to have succeeded");
Assert.IsNotNull(provider, "Returned provider should not be null");
logger.AssertErrorsLogged(0);
return(provider);
}
private static IAnalysisPropertyProvider CheckProcessingSucceeds(IEnumerable <ArgumentInstance> cmdLineArgs, string defaultPropertiesDirectory, TestLogger logger)
{
bool isValid = FilePropertyProvider.TryCreateProvider(cmdLineArgs, defaultPropertiesDirectory, logger, out IAnalysisPropertyProvider provider);
Assert.IsTrue(isValid, "Expecting the provider to be initialized successfully");
Assert.IsNotNull(provider, "Not expecting a null provider if the function returned true");
logger.AssertErrorsLogged(0);
return(provider);
}
private static IBootstrapperSettings CheckProcessingSucceeds(TestLogger logger, params string[] cmdLineArgs)
{
var success = ArgumentProcessor.TryProcessArgs(cmdLineArgs, logger, out IBootstrapperSettings settings);
success.Should().BeTrue("Expecting processing to succeed");
settings.Should().NotBeNull("Settings should not be null if processing succeeds");
logger.AssertErrorsLogged(0);
return(settings);
}
private static IAnalysisPropertyProvider CheckProcessingSucceeds(TestLogger logger, string[] input)
{
var success = ArgumentProcessor.TryProcessArgs(input, logger, out IAnalysisPropertyProvider provider);
success.Should().BeTrue("Expecting processing to have succeeded");
provider.Should().NotBeNull("Returned provider should not be null");
logger.AssertErrorsLogged(0);
return(provider);
}
private static IEnumerable <ArgumentInstance> CheckProcessingSucceeds(CommandLineParser parser, TestLogger logger, params string[] args)
{
IEnumerable <ArgumentInstance> instances;
bool success = parser.ParseArguments(args, logger, out instances);
Assert.IsTrue(success, "Expecting parsing to succeed");
Assert.IsNotNull(instances, "Instances should not be null if parsing succeeds");
logger.AssertErrorsLogged(0);
return(instances);
}
private static TestLogger CheckProcessingFails(params string[] commandLineArgs)
{
TestLogger logger = new TestLogger();
ProcessedArgs result = ArgumentProcessor.TryProcessArgs(commandLineArgs, logger);
Assert.IsNull(result, "Not expecting the arguments to be processed succesfully");
logger.AssertErrorsLogged();
return(logger);
}
private static IAnalysisPropertyProvider CheckProcessingSucceeds(IEnumerable <ArgumentInstance> args, TestLogger logger)
{
var success = CmdLineArgPropertyProvider.TryCreateProvider(args, logger, out var provider);
success.Should().BeTrue("Expected processing to succeed");
provider.Should().NotBeNull("Not expecting a null provider when processing succeeds");
logger.AssertErrorsLogged(0);
return(provider);
}
private static TestLogger CheckExecutionSucceeds(IBuildAgentUpdater updater, params string[] args)
{
TestLogger logger = new TestLogger();
int exitCode = Bootstrapper.Program.Execute(args, updater, logger);
Assert.AreEqual(0, exitCode, "Bootstrapper did not return the expected exit code");
logger.AssertErrorsLogged(0);
return(logger);
}
private static TestLogger CheckProcessingFails(params string[] cmdLineArgs)
{
var logger = new TestLogger();
var success = ArgumentProcessor.TryProcessArgs(cmdLineArgs, logger, out IBootstrapperSettings settings);
Assert.IsFalse(success, "Expecting processing to fail");
Assert.IsNull(settings, "Settings should be null if processing fails");
logger.AssertErrorsLogged();
return(logger);
}
private static void VerifyProcessRunOutcome(TestLogger testLogger, string expectedWorkingDir, bool actualOutcome, bool expectedOutcome)
{
Assert.AreEqual(actualOutcome, expectedOutcome, "Expecting execution to succeed");
testLogger.AssertInfoMessageExists(ExpectedConsoleMessagePrefix);
testLogger.AssertInfoMessageExists(expectedWorkingDir);
if (actualOutcome == false)
{
testLogger.AssertErrorsLogged();
}
}
private static IAnalysisPropertyProvider CheckProcessingSucceeds(IEnumerable <ArgumentInstance> args, TestLogger logger)
{
IAnalysisPropertyProvider provider;
bool success = CmdLineArgPropertyProvider.TryCreateProvider(args, logger, out provider);
Assert.IsTrue(success, "Expected processing to succeed");
Assert.IsNotNull(provider, "Not expecting a null provider when processing succeeds");
logger.AssertErrorsLogged(0);
return(provider);
}
public void ArgProc_SonarVerbose_IsBool()
{
var logger = new TestLogger();
var settings = CheckProcessingSucceeds(logger, "/d:sonar.host.url=foo", "begin", "/d:sonar.verbose=yes");
Assert.AreEqual(VerbosityCalculator.DefaultLoggingVerbosity, settings.LoggingVerbosity, "Only expecting true or false");
logger.AssertErrorsLogged(0);
logger.AssertSingleWarningExists("yes");
}
private static ProcessedArgs CheckProcessingSucceeds(params string[] commandLineArgs)
{
var logger = new TestLogger();
var result = ArgumentProcessor.TryProcessArgs(commandLineArgs, logger);
Assert.IsNotNull(result, "Expecting the arguments to be processed successfully");
logger.AssertErrorsLogged(0);
return(result);
}
private static IBootstrapperSettings CheckProcessingSucceeds(TestLogger logger, params string[] cmdLineArgs)
{
IBootstrapperSettings settings;
bool success = ArgumentProcessor.TryProcessArgs(cmdLineArgs, logger, out settings);
Assert.IsTrue(success, "Expecting processing to succeed");
Assert.IsNotNull(settings, "Settings should not be null if processing succeeds");
logger.AssertErrorsLogged(0);
return(settings);
}
private static TestLogger CheckProcessingFails(IEnumerable <ArgumentInstance> args)
{
var logger = new TestLogger();
var success = CmdLineArgPropertyProvider.TryCreateProvider(args, logger, out var provider);
success.Should().BeFalse("Not expecting the provider to be created");
provider.Should().BeNull("Expecting the provider to be null is processing fails");
logger.AssertErrorsLogged();
return(logger);
}
private void AssertPropertiesFilesCreated(ProjectInfoAnalysisResult result, TestLogger logger)
{
result.FullPropertiesFilePath.Should().NotBeNull("Expecting the sonar-scanner properties file to have been set");
var matches = result.GetProjectsByStatus(ProjectInfoValidity.Valid);
matches.Should().NotBeEmpty("Expecting at least one valid ProjectInfo file to exist");
TestContext.AddResultFile(result.FullPropertiesFilePath);
logger.AssertErrorsLogged(0);
}
private TestLogger CheckExecutionFails(AnalysisPhase phase, bool debug, params string[] args)
{
TestLogger logger = new TestLogger();
IBootstrapperSettings settings = MockBootstrapSettings(phase, debug, args);
BootstrapperClass bootstrapper = new BootstrapperClass(MockProcessorFactory.Object, settings, logger);
int exitCode = bootstrapper.Execute();
Assert.AreEqual(Bootstrapper.Program.ErrorCode, exitCode, "Bootstrapper did not return the expected exit code");
logger.AssertErrorsLogged();
return(logger);
}
private static TestLogger CheckProcessingFails(params string[] input)
{
var logger = new TestLogger();
var success = ArgumentProcessor.TryProcessArgs(input, logger, out IAnalysisPropertyProvider provider);
success.Should().BeFalse("Not expecting processing to have succeeded");
provider.Should().BeNull("Provider should be null if processing fails");
logger.AssertErrorsLogged(); // expecting errors if processing failed
return(logger);
}
private static ProcessedArgs CheckProcessingSucceeds(params string[] commandLineArgs)
{
var logger = new TestLogger();
var result = TryProcessArgsIsolatedFromEnvironment(commandLineArgs, logger);
result.Should().NotBeNull("Expecting the arguments to be processed successfully");
logger.AssertErrorsLogged(0);
return(result);
}
private TestLogger CheckExecutionSucceeds(AnalysisPhase phase, bool debug, params string[] args)
{
var logger = new TestLogger();
var settings = MockBootstrapSettings(phase, debug, args);
var bootstrapper = new BootstrapperClass(MockProcessorFactory.Object, settings, logger);
var exitCode = bootstrapper.Execute();
Assert.AreEqual(0, exitCode, "Bootstrapper did not return the expected exit code");
logger.AssertErrorsLogged(0);
return(logger);
}
public void AnalysisConfGen_FileProperties()
{
// File properties should not be copied to the file.
// Instead, a pointer to the file should be created.
// Arrange
var analysisDir = TestUtils.CreateTestSpecificFolderWithSubPaths(TestContext);
var logger = new TestLogger();
// The set of file properties to supply
var fileProperties = new AnalysisProperties
{
new Property()
{
Id = SonarProperties.HostUrl, Value = "http://myserver"
},
new Property()
{
Id = "file.only", Value = "file value"
}
};
var settingsFilePath = Path.Combine(analysisDir, "settings.txt");
fileProperties.Save(settingsFilePath);
var fileProvider = FilePropertyProvider.Load(settingsFilePath);
var args = new ProcessedArgs("key", "name", "version", "organization", false, EmptyPropertyProvider.Instance, fileProvider, EmptyPropertyProvider.Instance, logger);
var settings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Directory.CreateDirectory(settings.SonarConfigDirectory); // config directory needs to exist
// Act
var actualConfig = AnalysisConfigGenerator.GenerateFile(args, settings, new Dictionary <string, string>(), new List <AnalyzerSettings>(), new MockSonarQubeServer(), logger);
// Assert
AssertConfigFileExists(actualConfig);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
var actualSettingsFilePath = actualConfig.GetSettingsFilePath();
actualSettingsFilePath.Should().Be(settingsFilePath, "Unexpected settings file path");
// Check the file setting value do not appear in the config file
AssertFileDoesNotContainText(actualConfig.FileName, "file.only");
actualConfig.SourcesDirectory.Should().Be(settings.SourcesDirectory);
actualConfig.SonarScannerWorkingDirectory.Should().Be(settings.SonarScannerWorkingDirectory);
AssertExpectedLocalSetting(SonarProperties.Organization, "organization", actualConfig);
}
private static void CheckVerbosity(string errorMessage, LoggerVerbosity expectedVerbosity, string verbosity = null, string logLevel = null, int expectedNumberOfWarnings = 0)
{
var provider = CreatePropertiesProvider(verbosity, logLevel);
TestLogger logger = new TestLogger();
var actualVerbosity = VerbosityCalculator.ComputeVerbosity(provider, logger);
Assert.AreEqual(expectedVerbosity, actualVerbosity, errorMessage);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(expectedNumberOfWarnings);
}
private void AssertPropertiesFilesCreated(ProjectInfoAnalysisResult result, TestLogger logger)
{
Assert.IsNotNull(result.FullPropertiesFilePath, "Expecting the sonar-scanner properties file to have been set");
var matches = result.GetProjectsByStatus(ProjectInfoValidity.Valid);
Assert.AreNotEqual(0, matches.Count(), "Expecting at least one valid ProjectInfo file to exist");
TestContext.AddResultFile(result.FullPropertiesFilePath);
logger.AssertErrorsLogged(0);
}
private static TestLogger CheckProcessingFails(IEnumerable <ArgumentInstance> args)
{
var logger = new TestLogger();
var success = CmdLineArgPropertyProvider.TryCreateProvider(args, logger, out IAnalysisPropertyProvider provider);
Assert.IsFalse(success, "Not expecting the provider to be created");
Assert.IsNull(provider, "Expecting the provider to be null is processing fails");
logger.AssertErrorsLogged();
return(logger);
}
public void Exe_PostProc_Fails_On_Missing_TempFolder()
{
Directory.Delete(TempDir, true);
using (InitializeNonTeamBuildEnvironment(RootDir))
{
// Act
TestLogger logger = CheckExecutionFails(AnalysisPhase.PostProcessing, false);
// Assert
logger.AssertErrorsLogged(2);
}
}
private static TestLogger CheckProcessingFails(CommandLineParser parser, params string[] args)
{
var logger = new TestLogger();
var success = parser.ParseArguments(args, logger, out var instances);
success.Should().BeFalse("Expecting parsing to fail");
instances.Should().NotBeNull("Instances should not be null even if parsing fails");
AssertExpectedInstancesCount(0, instances);
logger.AssertErrorsLogged();
return(logger);
}
private static TestLogger CheckProcessingFails(CommandLineParser parser, params string[] args)
{
var logger = new TestLogger();
var success = parser.ParseArguments(args, logger, out IEnumerable <ArgumentInstance> instances);
Assert.IsFalse(success, "Expecting parsing to fail");
Assert.IsNotNull(instances, "Instances should not be null even if parsing fails");
AssertExpectedInstancesCount(0, instances);
logger.AssertErrorsLogged();
return(logger);
}
private static TestLogger CheckProcessingFails(params string[] input)
{
TestLogger logger = new TestLogger();
IAnalysisPropertyProvider provider;
bool success = ArgumentProcessor.TryProcessArgs(input, logger, out provider);
Assert.IsFalse(success, "Not expecting processing to have succeeded");
Assert.IsNull(provider, "Provider should be null if processing fails");
logger.AssertErrorsLogged(); // expecting errors if processing failed
return(logger);
}
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 Generate_LicenseAcceptanceNotRequired_Succeeds()
{
// Arrange
string outputDir = TestUtils.CreateTestDirectory(TestContext, ".out");
RemoteRepoBuilder remoteRepoBuilder = new RemoteRepoBuilder(TestContext);
// Multi-level dependencies: no package requires license acceptence
IPackage grandchild = CreatePackageWithAnalyzer(remoteRepoBuilder, "grandchild.id", "1.2", License.NotRequired /* no dependencies */);
IPackage child = CreatePackageWithAnalyzer(remoteRepoBuilder, "child.id", "1.1", License.NotRequired, grandchild);
CreatePackageWithAnalyzer(remoteRepoBuilder, "parent.id", "1.0", License.NotRequired, child);
TestLogger logger = new TestLogger();
AnalyzerPluginGenerator apg = CreateTestSubjectWithFakeRemoteRepo(remoteRepoBuilder, logger);
// 1. Acceptance not required -> succeeds if accept = false
ProcessedArgs args = CreateArgs("parent.id", "1.0", "cs", false /* accept licenses */,
false, outputDir);
bool result = apg.Generate(args);
result.Should().BeTrue("Generator should succeed if there are no licenses to accept");
logger.AssertErrorsLogged(0);
logger.AssertWarningNotLogged("parent.id"); // not expecting warnings about packages that don't require acceptance
logger.AssertWarningNotLogged("child.id");
logger.AssertWarningNotLogged("grandchild.id");
// 2. Acceptance not required -> succeeds if accept = true
args = CreateArgs("parent.id", "1.0", "cs", true /* accept licenses */, false, outputDir);
result = apg.Generate(args);
result.Should().BeTrue("Generator should succeed if there are no licenses to accept");
logger.AssertErrorsLogged(0);
logger.AssertWarningNotLogged("parent.id"); // not expecting warnings about packages that don't require acceptance
logger.AssertWarningNotLogged("child.id");
logger.AssertWarningNotLogged("grandchild.id");
AssertJarsGenerated(outputDir, 1);
}
