public Rules provide(RulesLoader ref) { if (singleton == null) { singleton = load(ref); } return singleton; }
public void execute() { execute(LOG); }
public QProfile build() { return new QProfile(key, name, language, rulesUpdatedAt); } }
public ScannerMediumTester addActiveRule(String repositoryKey, String ruleKey, @Nullable String templateRuleKey, String name, @Nullable String severity, @Nullable String internalKey, @Nullable String language) { LoadedActiveRule r = new LoadedActiveRule(); r.setInternalKey(internalKey); r.setRuleKey(RuleKey.of(repositoryKey, ruleKey)); r.setName(name); r.setTemplateRuleKey(templateRuleKey); r.setLanguage(language); r.setSeverity(severity); activeRules.addActiveRule(r); return this; }
private void activateTODORule() { LoadedActiveRule r = new LoadedActiveRule(); r.setRuleKey(RuleKey.of("xoo", HasTagSensor.RULE_KEY)); r.setName("TODO"); r.setLanguage("xoo"); r.setSeverity("MAJOR"); r.setParams(ImmutableMap.of("tag", "TODO")); tester.activateRule(r); }
private static ActiveRules load(ActiveRulesLoader loader, QualityProfiles qProfiles) { Collection<String> qProfileKeys = getKeys(qProfiles); Set<RuleKey> loadedRulesKey = new HashSet<>(); ActiveRulesBuilder builder = new ActiveRulesBuilder(); for (String qProfileKey : qProfileKeys) { Collection<LoadedActiveRule> qProfileRules = load(loader, qProfileKey); for (LoadedActiveRule r : qProfileRules) { if (!loadedRulesKey.contains(r.getRuleKey())) { loadedRulesKey.add(r.getRuleKey()); builder.addRule(transform(r, qProfileKey)); } } } return builder.build(); }
private static LoadedActiveRule mockRule(String name) { LoadedActiveRule r = new LoadedActiveRule(); r.setName(name); r.setRuleKey(RuleKey.of(name, name)); return r; } }
@Test public void testRuleTranslation() { RulesLoader loader = mock(RulesLoader.class); when(loader.load()).thenReturn(Lists.newArrayList(getTestRule())); RulesProvider provider = new RulesProvider(); Rules rules = provider.provide(loader); assertThat(rules.findAll()).hasSize(1); assertRule(rules.findAll().iterator().next()); }
@Test public void testParamsAreTransformed() { LoadedActiveRule r1 = mockRule("rule1"); LoadedActiveRule r2 = mockRule("rule2"); r2.setParams(ImmutableMap.of("foo1", "bar1", "foo2", "bar2")); List<LoadedActiveRule> qpRules = ImmutableList.of(r1, r2); when(loader.load(eq("qp"))).thenReturn(qpRules); QualityProfiles profiles = mockProfiles("qp"); ActiveRules activeRules = provider.provide(loader, profiles); assertThat(activeRules.findAll()).hasSize(2); assertThat(activeRules.findAll()).extracting("ruleKey", "params").containsOnly( Tuple.tuple(RuleKey.of("rule1", "rule1"), ImmutableMap.of()), Tuple.tuple(RuleKey.of("rule2", "rule2"), ImmutableMap.of("foo1", "bar1", "foo2", "bar2"))); verify(loader).load(eq("qp")); verifyNoMoreInteractions(loader); }
@Before public void before() throws Exception { store = new InputComponentStore(mock(BranchConfiguration.class)); profiles = mock(QualityProfiles.class); QProfile javaProfile = new QProfile("p1", "My Java profile", "java", null); when(profiles.findByLanguage("java")).thenReturn(javaProfile); QProfile cobolProfile = new QProfile("p2", "My Cobol profile", "cobol", null); when(profiles.findByLanguage("cobol")).thenReturn(cobolProfile); }
@Test public void feed_real_response_encode_qp() throws IOException { int total = PAGE_SIZE_1 + PAGE_SIZE_2; WsTestUtil.mockStream(wsClient, urlOfPage(1, false), responseOfSize(PAGE_SIZE_1, total)); WsTestUtil.mockStream(wsClient, urlOfPage(2, false), responseOfSize(PAGE_SIZE_2, total)); Collection<LoadedActiveRule> activeRules = loader.load("c+-test_c+-values-17445"); assertThat(activeRules).hasSize(total); assertThat(activeRules) .filteredOn(r -> r.getRuleKey().equals(EXAMPLE_KEY)) .extracting(LoadedActiveRule::getParams) .extracting(p -> p.get(FORMAT_KEY)) .containsExactly(FORMAT_VALUE); assertThat(activeRules) .filteredOn(r -> r.getRuleKey().equals(EXAMPLE_KEY)) .extracting(LoadedActiveRule::getSeverity) .containsExactly(SEVERITY_VALUE); WsTestUtil.verifyCall(wsClient, urlOfPage(1, false)); WsTestUtil.verifyCall(wsClient, urlOfPage(2, false)); verifyNoMoreInteractions(wsClient); }
@Test public void should_not_fail_if_no_language_on_project() { settings.setProperty("sonar.profile", "Unknown"); QProfileVerifier profileLogger = new QProfileVerifier(settings.asConfig(), store, profiles); profileLogger.execute(); }
@Before public void setUp() { MockitoAnnotations.initMocks(this); provider = new ActiveRulesProvider(); }
private void assertResponse(QualityProfiles qps) { assertThat(qps.findAll()).extracting("key").containsExactly("profile"); } }
private static List<LoadedActiveRule> load(ActiveRulesLoader loader, String qProfileKey) { return loader.load(qProfileKey); }
public ActiveRules provide(ActiveRulesLoader loader, QualityProfiles qProfiles) { if (singleton == null) { Profiler profiler = Profiler.create(LOG).startInfo(LOG_MSG); singleton = load(loader, qProfiles); profiler.stopInfo(); } return singleton; }
@Override public List<Rule> load() { GetRequest getRequest = new GetRequest(RULES_SEARCH_URL); ListResponse list = loadFromStream(wsClient.call(getRequest).contentStream()); return list.getRulesList(); }
@Before public void setUp() { wsClient = mock(ScannerWsClient.class); branchConfig = mock(BranchConfiguration.class); when(branchConfig.isShortOrPullRequest()).thenReturn(false); loader = new DefaultActiveRulesLoader(wsClient, branchConfig); }
@Test public void should_not_fail_if_default_profile_used_at_least_once() { store.put("foo", new TestInputFileBuilder("foo", "src/Bar.java").setLanguage("java").build()); settings.setProperty("sonar.profile", "My Java profile"); QProfileVerifier profileLogger = new QProfileVerifier(settings.asConfig(), store, profiles); profileLogger.execute(); } }