org.sonar.api.config.Settings Java Examples

@Before
public void setUp() throws Exception {
    this.file = new DefaultInputFile("", "src/test/existing.ts").setLanguage(TypeScriptLanguage.LANGUAGE_KEY);
    this.file.setLines(5);
    
    this.settings = mock(Settings.class);
    when(this.settings.getString(TypeScriptPlugin.SETTING_LCOV_REPORT_PATH)).thenReturn("lcovpath");

    this.parser = mock(LCOVParser.class);

    this.sensor = spy(new TsCoverageSensorImpl());
    this.context = SensorContextTester.create(new File(""));

    this.context.fileSystem().add(this.file);
    this.context.setSettings(this.settings);
    
    this.lcovFile = mock(File.class);
    when(this.lcovFile.isFile()).thenReturn(true);
    doReturn(this.lcovFile).when(this.sensor).getIOFile(any(File.class), eq("lcovpath"));
    doReturn(this.parser).when(this.sensor).getParser(eq(this.context), any(File[].class));
}
 

@Override
public void execute(final org.sonar.api.batch.sensor.SensorContext context) {

	final Settings settings = context.settings();
	final boolean skipAnalysis = settings.getBoolean(Constants.PLUGIN_SKIP);

	if (skipAnalysis) {
		LOGGER.debug(String.format("Skipping plugin as skip flag is set: %s", Constants.PLUGIN_SKIP));
		return;
	}
	final boolean skipSensor = settings.getBoolean(sensorName);

	if (skipSensor) {
		LOGGER.debug(String.format("Skipping sensor as skip flag is set: %s", sensorName));
		return;
	}
	try {
		innerExecute(context);
	} catch (Throwable e) {
		e.printStackTrace();
	}
}
 

@Test
public void testGetFileSuffixes() {
  Settings settings = new Settings();
 Lua lua = new Lua(settings);

  assertThat(lua.getFileSuffixes()).isEqualTo(new String[] {"lua"});

  settings.setProperty(LuaPlugin.FILE_SUFFIXES_KEY, "");
  assertThat(lua.getFileSuffixes()).isEqualTo(new String[] {"lua"});

  settings.setProperty(LuaPlugin.FILE_SUFFIXES_KEY, "lua");
  assertThat(lua.getFileSuffixes()).isEqualTo(new String[] {"lua"});
}
 

public AbstractLanguageAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter,
                                      @Nullable CustomRulesDefinition[] customRulesDefinition) {

  this.fileSystem = fileSystem;
  this.settings = settings;
  this.noSonarFilter = noSonarFilter;
  this.checkFactory = checkFactory;
  this.customRulesDefinition = customRulesDefinition;
  this.parser = parser(fileSystem);
}
 

@Test
public void custom_file_suffixes() {
  Settings settings = new Settings();
  settings.setProperty("sonar.css.file.suffixes", "css,css3");

  CssLanguage language = new CssLanguage(settings);
  assertThat(language.getFileSuffixes()).containsOnly("css", "css3");
}
 

@Test
public void custom_file_suffixes() {
  Settings settings = new Settings();
  settings.setProperty("sonar.less.file.suffixes", "less,less3");

  LessLanguage language = new LessLanguage(settings);
  assertThat(language.getFileSuffixes()).containsOnly("less", "less3");
}
 

@Test
public void custom_file_suffixes() {
  Settings settings = new Settings();
  settings.setProperty("sonar.scss.file.suffixes", "scss,scss3");

  ScssLanguage language = new ScssLanguage(settings);
  assertThat(language.getFileSuffixes()).containsOnly("scss", "scss3");
}
 

@Test
public void testGetFileSuffixes_Default() {
    Ruby ruby = new Ruby(new Settings());

    String[] fileSuffixes = ruby.getFileSuffixes();

    assertThat(fileSuffixes).hasSize(8);
    assertThat(fileSuffixes).hasSameElementsAs(Lists.newArrayList("rb", "Gemfile", "gemspec", "rake", "spec", "Capfile", "ru", "Rakefile"));
}
 

@Test
public void testGetFileSuffixes_Override() {
    Settings settings = new Settings();
    settings.setProperty("sonar.ruby.file.suffixes", "rb");

    Ruby ruby = new Ruby(settings);

    String[] fileSuffixes = ruby.getFileSuffixes();

    assertThat(fileSuffixes).hasSize(1);
    assertThat(fileSuffixes).hasSameElementsAs(Lists.newArrayList("rb"));
}
 

@Test
public void testGetFileSuffixes_WithSpaces() {
    Settings settings = new Settings();
    settings.setProperty("sonar.ruby.file.suffixes", "rb, , gemspec");

    Ruby ruby = new Ruby(settings);

    String[] fileSuffixes = ruby.getFileSuffixes();

    assertThat(fileSuffixes).hasSize(2);
    assertThat(fileSuffixes).hasSameElementsAs(Lists.newArrayList("rb", "gemspec"));
}
 

@Test
public void testCustomFileSuffixes() {
    Map<String, String> props = Maps.newHashMap();
    props.put(Apex.FILE_SUFFIXES_KEY, "cls,apex");

    Settings settings = new Settings();
    settings.addProperties(props);

    assertThat(apexLanguage.getFileSuffixes(), is(new String[]{"cls", "trigger"}));
}
 

public static TsLintExecutorConfig fromSettings(Settings settings, SensorContext ctx, PathResolver resolver) {
    TsLintExecutorConfig toReturn = new TsLintExecutorConfig();

    toReturn.setPathToTsLint(resolver.getPath(ctx, TypeScriptPlugin.SETTING_TS_LINT_PATH, TSLINT_FALLBACK_PATH));
    toReturn.setConfigFile(resolver.getPath(ctx, TypeScriptPlugin.SETTING_TS_LINT_CONFIG_PATH, CONFIG_FILENAME));
    toReturn.setRulesDir(resolver.getPath(ctx, TypeScriptPlugin.SETTING_TS_LINT_RULES_DIR, null));
    toReturn.setPathToTsConfig(resolver.getPath(ctx, TypeScriptPlugin.SETTING_TS_LINT_PROJECT_PATH, null));
    toReturn.setPathToTsLintOutput(resolver.getPath(ctx, TypeScriptPlugin.SETTING_TS_LINT_OUTPUT_PATH, null));
    toReturn.setPathToNode(resolver.getPath(ctx, TypeScriptPlugin.SETTING_TS_LINT_NODE_PATH, NODE_FALLBACK_PATH));

    toReturn.setTimeoutMs(Math.max(5000, settings.getInt(TypeScriptPlugin.SETTING_TS_LINT_TIMEOUT)));
    toReturn.setShouldPerformTypeCheck(settings.getBoolean(TypeScriptPlugin.SETTING_TS_LINT_TYPECHECK));

    return toReturn;
}
 

@Test
public void CheckCustomRulesConfigNotProvided() {

    Settings settings = mock(Settings.class);
    when(settings.getKeysStartingWith(TypeScriptPlugin.SETTING_TS_RULE_CONFIGS)).thenReturn(new ArrayList<String>());

    TsRulesDefinition rulesDef = new TsRulesDefinition(settings);
    List<TsLintRule> rules = rulesDef.getRules();
    assertNotNull(rules);
    assertEquals(0, rules.size());
}
 

@Test
public void CheckCustomRulesInhibited() {

    Settings settings = mock(Settings.class);
    when(settings.getBoolean(TypeScriptPlugin.SETTING_TS_LINT_DISALLOW_CUSTOM_RULES)).thenReturn(true);

    TsRulesDefinition rulesDef = new TsRulesDefinition(settings);
    List<TsLintRule> rules = rulesDef.getRules();
    assertNotNull(rules);
    assertEquals(0, rules.size());
}
 

@Test
public void fromSettings_setsTimeoutTo5000msMinimum_ifSetToLess() {
    Settings settings = new Settings();
    settings.setProperty(TypeScriptPlugin.SETTING_TS_LINT_TIMEOUT, 1000);

    PathResolver resolver = mock(PathResolver.class);

    TsLintExecutorConfig config = TsLintExecutorConfig.fromSettings(settings, SensorContextTester.create(new File("")), resolver);

    assertEquals((Integer) 5000, config.getTimeoutMs());
}
 

public GerritPostJob(Settings settings, GerritConfiguration gerritConfiguration,
                     GerritFacadeFactory gerritFacadeFactory) {
    LOG.debug("[GERRIT PLUGIN] Instanciating GerritPostJob");
    this.settings = settings;
    this.gerritFacade = gerritFacadeFactory.getFacade();
    this.gerritConfiguration = gerritConfiguration;
}
 

public GerritConfiguration(Settings settings) {
    LOG.debug("[GERRIT PLUGIN] Instanciating GerritConfiguration");

    this.enable(settings.getBoolean(PropertyKey.GERRIT_ENABLED));
    this.commentNewIssuesOnly(settings.getBoolean(PropertyKey.GERRIT_COMMENT_NEW_ISSUES_ONLY));
    this.strictlyCheckHostkey(settings.getBoolean(PropertyKey.GERRIT_STRICT_HOSTKEY));

    this.setScheme(settings.getString(PropertyKey.GERRIT_SCHEME));
    this.setHost(settings.getString(PropertyKey.GERRIT_HOST));
    this.setPort(settings.getInt(PropertyKey.GERRIT_PORT));

    this.setUsername(settings.getString(PropertyKey.GERRIT_USERNAME));
    this.setPassword(settings.getString(PropertyKey.GERRIT_PASSWORD));
    this.setHttpAuthScheme(settings.getString(PropertyKey.GERRIT_HTTP_AUTH_SCHEME));
    this.setBasePath(settings.getString(PropertyKey.GERRIT_BASE_PATH));

    this.setSshKeyPath(settings.getString(PropertyKey.GERRIT_SSH_KEY_PATH));

    this.setLabel(settings.getString(PropertyKey.GERRIT_LABEL));
    this.setMessage(settings.getString(PropertyKey.GERRIT_MESSAGE));
    this.setIssueComment(settings.getString(PropertyKey.GERRIT_ISSUE_COMMENT));
    this.setThreshold(settings.getString(PropertyKey.GERRIT_THRESHOLD));
    this.setVoteNoIssue(settings.getInt(PropertyKey.GERRIT_VOTE_NO_ISSUE));
    this.setVoteBelowThreshold(settings.getInt(PropertyKey.GERRIT_VOTE_ISSUE_BELOW_THRESHOLD));
    this.setVoteAboveThreshold(settings.getInt(PropertyKey.GERRIT_VOTE_ISSUE_ABOVE_THRESHOLD));

    this.setProjectName(settings.getString(PropertyKey.GERRIT_PROJECT));
    this.setBranchName(settings.getString(PropertyKey.GERRIT_BRANCH));
    this.setChangeId(settings.getString(PropertyKey.GERRIT_CHANGE_ID));
    this.setRevisionId(settings.getString(PropertyKey.GERRIT_REVISION_ID));

    this.assertGerritConfiguration();
}
 

@Test
public void testDefinedSuffixes() {
	final Settings settings = new org.sonar.api.config.internal.MapSettings();
	settings.setProperty(Constants.PLUGIN_SUFFIXES, ".sql,.test");
	final TSQLLanguage language = new TSQLLanguage(settings);
	Assert.assertArrayEquals(new String[] { ".sql", ".test" }, language.getFileSuffixes());
}
 

public PmdExecutor(FileSystem fileSystem, RulesProfile rulesProfile, PmdProfileExporter pmdProfileExporter,
                   PmdConfiguration pmdConfiguration, JavaResourceLocator javaResourceLocator, Settings settings) {
  this.fs = fileSystem;
  this.rulesProfile = rulesProfile;
  this.pmdProfileExporter = pmdProfileExporter;
  this.pmdConfiguration = pmdConfiguration;
  this.javaResourceLocator = javaResourceLocator;
  this.settings = settings;
}
 

public AbstractLanguageAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter) {
  this(fileSystem, checkFactory, settings, noSonarFilter, null);
}
 

public EmbeddedCssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter) {
  super(fileSystem, checkFactory, settings, noSonarFilter);
}
 

public TsLintSensor(Settings settings, PathResolver resolver, TsLintExecutor executor, TsLintParser parser) {
    this.settings = settings;
    this.resolver = resolver;
    this.executor = executor;
    this.parser = parser;
}
 

public EmbeddedCssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter,
                                 @Nullable CustomCssRulesDefinition[] customRulesDefinition) {
  super(fileSystem, checkFactory, settings, noSonarFilter, customRulesDefinition);
}
 

@Test
public void testDefaultSuffixes() {
	final Settings settings = new org.sonar.api.config.internal.MapSettings();
	final TSQLLanguage language = new TSQLLanguage(settings);
	Assert.assertArrayEquals(new String[] { ".sql" }, language.getFileSuffixes());
}
 

public CoverageSensor(final FileSystem fs, final Settings settings) {
	this(new SqlCoverCoverageProvider(settings, fs));
}
 

@Test
public void default_file_suffix() {
  CssLanguage language = new CssLanguage(mock(Settings.class));
  assertThat(language.getFileSuffixes()).containsOnly("css");
}
 

public LessAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter) {
  super(fileSystem, checkFactory, settings, noSonarFilter);
}
 

public CodeGuardIssuesLoaderSensor(final Settings settings, final TempFolder tempFolder) {
	super(new CodeGuardIssuesProvider(settings, tempFolder), Constants.PLUGIN_SKIP_CG, Constants.CG_REPO_KEY);
}
 

public SqlCoverCoverageProvider(final Settings settings, final FileSystem fileSystem) {
	this.settings = settings;
	this.fileSystem = fileSystem;

}
 

public CssLanguage(Settings settings) {
  super(KEY, NAME);
  this.settings = settings;
}