+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * SonarQube is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.batch.bootstrap;
-
-public class AbstractServerLoader {
- protected Boolean loadedFromCache = null;
-
- public boolean loadedFromCache() {
- if (loadedFromCache == null) {
- throw new IllegalStateException("Didn't load");
- }
- return loadedFromCache;
- }
-}
issues = CoreProperties.ANALYSIS_MODE_ISSUES.equals(mode);
if (preview) {
- LOG.info("Preview global mode");
+ LOG.debug("Preview global mode");
} else if (issues) {
- LOG.info("Issues global mode");
+ LOG.debug("Issues global mode");
} else {
- LOG.info("Publish global mode");
+ LOG.debug("Publish global mode");
}
}
*/
package org.sonar.batch.cache;
-import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.apache.commons.lang.StringUtils;
import org.sonar.api.utils.log.Loggers;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
public void load(boolean force) {
- Profiler profiler = Profiler.create(Loggers.get(ProjectCacheSynchronizer.class));
Date lastSync = cacheStatus.getSyncStatus(project.getKeyWithBranch());
if (lastSync != null) {
LOG.info("Found project [{}] cache [{}]", project.getKeyWithBranch(), lastSync);
return;
} else {
- LOG.info("Found project [{}] cache [{}], refreshing data..", project.getKeyWithBranch(), lastSync);
+ LOG.info("-- Found project [{}] cache [{}], synchronizing data..", project.getKeyWithBranch(), lastSync);
}
cacheStatus.delete(project.getKeyWithBranch());
} else {
- LOG.info("Cache for project [{}] not found, fetching data..", project.getKeyWithBranch());
+ LOG.info("-- Cache for project [{}] not found, synchronizing data..", project.getKeyWithBranch());
}
+ loadData();
+ saveStatus();
+ }
+
+ private void saveStatus() {
+ cacheStatus.save(project.getKeyWithBranch());
+ LOG.info("-- Succesfully synchronized project cache");
+ }
+
+ private static String getComponentKey(String moduleKey, String filePath) {
+ return moduleKey + ":" + filePath;
+ }
+
+ private void loadData() {
+ Profiler profiler = Profiler.create(Loggers.get(ProjectCacheSynchronizer.class));
profiler.startInfo("Load project repository");
- ProjectRepositories projectRepo = projectRepositoryLoader.load(project, properties);
- profiler.stopInfo(projectRepositoryLoader.loadedFromCache());
+ MutableBoolean fromCache = new MutableBoolean();
+ ProjectRepositories projectRepo = projectRepositoryLoader.load(project, properties, fromCache);
+ profiler.stopInfo(fromCache.booleanValue());
if (projectRepo.lastAnalysisDate() == null) {
LOG.debug("No previous analysis found");
- LOG.info("Succesfully synchronized project cache");
return;
}
profiler.startInfo("Load server issues");
UserLoginAccumulator consumer = new UserLoginAccumulator();
- boolean fromCache = issuesLoader.load(project.getKeyWithBranch(), consumer);
- profiler.stopInfo(fromCache);
+ boolean isFromCache = issuesLoader.load(project.getKeyWithBranch(), consumer);
+ profiler.stopInfo(isFromCache);
profiler.startInfo("Load user information (" + consumer.loginSet.size() + " users)");
for (String login : consumer.loginSet) {
- userRepository.load(login);
+ userRepository.load(login, null);
}
- stopInfo(profiler, "Load user information", fromCache);
+ stopInfo(profiler, "Load user information", isFromCache);
loadLineHashes(projectRepo.fileDataByModuleAndPath(), profiler);
-
- cacheStatus.save(project.getKeyWithBranch());
-
- LOG.info("Succesfully synchronized project cache");
- }
-
- private String getComponentKey(String moduleKey, String filePath) {
- return moduleKey + ":" + filePath;
}
private void loadLineHashes(Map<String, Map<String, FileData>> fileDataByModuleAndPath, Profiler profiler) {
for (Entry<String, FileData> e2 : e1.getValue().entrySet()) {
String filePath = e2.getKey();
- lineHashesLoader.getLineHashes(getComponentKey(moduleKey, filePath));
+ lineHashesLoader.getLineHashes(getComponentKey(moduleKey, filePath), null);
}
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+@ParametersAreNonnullByDefault
+package org.sonar.batch.cache;
+
+import javax.annotation.ParametersAreNonnullByDefault;
\ No newline at end of file
*/
package org.sonar.batch.issue.tracking;
-import org.sonar.batch.bootstrap.WSLoaderResult;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
+import javax.annotation.Nullable;
+import org.sonar.batch.bootstrap.WSLoaderResult;
import org.sonar.batch.util.BatchUtils;
import org.sonar.batch.bootstrap.WSLoader;
import com.google.common.base.Splitter;
}
@Override
- public String[] getLineHashes(String fileKey) {
- String hashesFromWs = loadHashesFromWs(fileKey);
+ public String[] getLineHashes(String fileKey, @Nullable MutableBoolean fromCache) {
+ String hashesFromWs = loadHashesFromWs(fileKey, fromCache);
return Iterators.toArray(Splitter.on('\n').split(hashesFromWs).iterator(), String.class);
}
- private String loadHashesFromWs(String fileKey) {
+ private String loadHashesFromWs(String fileKey, @Nullable MutableBoolean fromCache) {
Profiler profiler = Profiler.createIfDebug(Loggers.get(getClass()))
.addContext("file", fileKey)
.startDebug("Load line hashes");
WSLoaderResult<String> result = wsLoader.loadString("/api/sources/hash?key=" + BatchUtils.encodeForUrl(fileKey));
try {
+ if (fromCache != null) {
+ fromCache.setValue(result.isFromCache());
+ }
return result.get();
} finally {
if (result.isFromCache()) {
*/
package org.sonar.batch.issue.tracking;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
+import javax.annotation.Nullable;
+
import org.sonar.api.batch.BatchSide;
@BatchSide
public interface ServerLineHashesLoader {
- String[] getLineHashes(String fileKey);
+ String[] getLineHashes(String fileKey, @Nullable MutableBoolean fromCache);
}
} else if (status == Status.SAME) {
hashedReference = hashedSource;
} else {
- String[] lineHashes = lastSnapshots.getLineHashes(inputFile.key());
+ String[] lineHashes = lastSnapshots.getLineHashes(inputFile.key(), null);
hashedReference = lineHashes != null ? FileHashes.create(lineHashes) : null;
}
}
*/
package org.sonar.batch.repository;
-import org.sonar.batch.bootstrap.AbstractServerLoader;
+import javax.annotation.Nullable;
+import org.apache.commons.lang.mutable.MutableBoolean;
import org.sonar.batch.bootstrap.WSLoaderResult;
import org.sonar.batch.bootstrap.WSLoader;
import org.sonar.batch.protocol.input.GlobalRepositories;
-public class DefaultGlobalRepositoriesLoader extends AbstractServerLoader implements GlobalRepositoriesLoader {
+public class DefaultGlobalRepositoriesLoader implements GlobalRepositoriesLoader {
private static final String BATCH_GLOBAL_URL = "/batch/global";
}
@Override
- public GlobalRepositories load() {
+ public GlobalRepositories load(@Nullable MutableBoolean fromCache) {
WSLoaderResult<String> result = wsLoader.loadString(BATCH_GLOBAL_URL);
- super.loadedFromCache = result.isFromCache();
+ if (fromCache != null) {
+ fromCache.setValue(result.isFromCache());
+ }
return GlobalRepositories.fromJson(result.get());
}
-
}
*/
package org.sonar.batch.repository;
-import org.sonar.batch.scan.ProjectAnalysisMode;
+import javax.annotation.Nullable;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.sonar.batch.scan.ProjectAnalysisMode;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
-import org.sonar.batch.bootstrap.AbstractServerLoader;
import org.sonar.batch.bootstrap.WSLoaderResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.batch.rule.ModuleQProfiles;
import org.sonar.batch.util.BatchUtils;
-public class DefaultProjectRepositoriesLoader extends AbstractServerLoader implements ProjectRepositoriesLoader {
+public class DefaultProjectRepositoriesLoader implements ProjectRepositoriesLoader {
private static final Logger LOG = LoggerFactory.getLogger(DefaultProjectRepositoriesLoader.class);
private static final String BATCH_PROJECT_URL = "/batch/project";
}
@Override
- public ProjectRepositories load(ProjectDefinition projectDefinition, AnalysisProperties taskProperties) {
+ public ProjectRepositories load(ProjectDefinition projectDefinition, AnalysisProperties taskProperties, @Nullable MutableBoolean fromCache) {
String projectKey = projectDefinition.getKeyWithBranch();
String url = BATCH_PROJECT_URL + "?key=" + BatchUtils.encodeForUrl(projectKey);
if (taskProperties.properties().containsKey(ModuleQProfiles.SONAR_PROFILE_PROP)) {
url += "&profile=" + BatchUtils.encodeForUrl(taskProperties.properties().get(ModuleQProfiles.SONAR_PROFILE_PROP));
}
url += "&preview=" + analysisMode.isIssues();
- ProjectRepositories projectRepositories = ProjectRepositories.fromJson(load(url));
+
+ ProjectRepositories projectRepositories = load(url, fromCache);
validateProjectRepositories(projectRepositories);
return projectRepositories;
}
- private String load(String resource) {
+ private ProjectRepositories load(String resource, @Nullable MutableBoolean fromCache) {
WSLoaderResult<String> result = wsLoader.loadString(resource);
- super.loadedFromCache = result.isFromCache();
- return result.get();
+ if(fromCache != null) {
+ fromCache.setValue(result.isFromCache());
+ }
+ return ProjectRepositories.fromJson(result.get());
}
private static void validateProjectRepositories(ProjectRepositories projectRepositories) {
*/
package org.sonar.batch.repository;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
+import javax.annotation.Nullable;
+
import org.sonar.batch.protocol.input.GlobalRepositories;
public interface GlobalRepositoriesLoader {
- GlobalRepositories load();
-
- boolean loadedFromCache();
+ GlobalRepositories load(@Nullable MutableBoolean fromCache);
}
*/
package org.sonar.batch.repository;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
import org.picocontainer.injectors.ProviderAdapter;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
public GlobalRepositories provide(GlobalRepositoriesLoader loader) {
if (globalReferentials == null) {
Profiler profiler = Profiler.create(LOG).startInfo(LOG_MSG);
- globalReferentials = loader.load();
- profiler.stopInfo(loader.loadedFromCache());
+ MutableBoolean fromCache = new MutableBoolean();
+ globalReferentials = loader.load(fromCache);
+ profiler.stopInfo(fromCache.booleanValue());
}
return globalReferentials;
}
*/
package org.sonar.batch.repository;
-import org.sonar.api.batch.bootstrap.ProjectDefinition;
+import javax.annotation.Nullable;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.batch.bootstrap.AnalysisProperties;
import org.sonar.batch.protocol.input.ProjectRepositories;
public interface ProjectRepositoriesLoader {
- ProjectRepositories load(ProjectDefinition projectDefinition, AnalysisProperties taskProperties);
-
- boolean loadedFromCache();
+ ProjectRepositories load(ProjectDefinition projectDefinition, AnalysisProperties taskProperties, @Nullable MutableBoolean fromCache);
}
*/
package org.sonar.batch.repository;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
import org.picocontainer.injectors.ProviderAdapter;
import org.sonar.api.batch.AnalysisMode;
import org.sonar.api.batch.bootstrap.ProjectReactor;
public ProjectRepositories provide(ProjectRepositoriesLoader loader, ProjectReactor reactor, AnalysisProperties taskProps, AnalysisMode analysisMode) {
if (projectReferentials == null) {
Profiler profiler = Profiler.create(LOG).startInfo(LOG_MSG);
- projectReferentials = loader.load(reactor.getRoot(), taskProps);
- profiler.stopInfo(loader.loadedFromCache());
+ MutableBoolean fromCache = new MutableBoolean();
+ projectReferentials = loader.load(reactor.getRoot(), taskProps, fromCache);
+ profiler.stopInfo(fromCache.booleanValue());
if (analysisMode.isIssues() && projectReferentials.lastAnalysisDate() == null) {
LOG.warn("No analysis has been found on the server for this project. All issues will be marked as 'new'.");
*/
package org.sonar.batch.repository.user;
-import com.google.common.collect.Lists;
+import javax.annotation.Nullable;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import com.google.common.collect.Lists;
import com.google.common.base.Joiner;
-import org.sonar.batch.bootstrap.AbstractServerLoader;
import org.sonar.batch.bootstrap.WSLoaderResult;
import org.sonar.batch.util.BatchUtils;
import org.sonar.batch.bootstrap.WSLoader;
import java.util.Collections;
import java.util.List;
-public class UserRepositoryLoader extends AbstractServerLoader {
+public class UserRepositoryLoader {
private final WSLoader wsLoader;
public UserRepositoryLoader(WSLoader wsLoader) {
}
public BatchInput.User load(String userLogin) {
- ByteSource byteSource = loadQuery(new UserEncodingFunction().apply(userLogin));
+ return load(userLogin, null);
+ }
+
+ public BatchInput.User load(String userLogin, @Nullable MutableBoolean fromCache) {
+ ByteSource byteSource = loadQuery(new UserEncodingFunction().apply(userLogin), fromCache);
return parseUser(byteSource);
}
+ public Collection<BatchInput.User> load(List<String> userLogins) {
+ return load(userLogins, null);
+ }
+
/**
* Not cache friendly. Should not be used if a cache hit is expected.
*/
- public Collection<BatchInput.User> load(List<String> userLogins) {
+ public Collection<BatchInput.User> load(List<String> userLogins, @Nullable MutableBoolean fromCache) {
if (userLogins.isEmpty()) {
return Collections.emptyList();
}
- ByteSource byteSource = loadQuery(Joiner.on(',').join(Lists.transform(userLogins, new UserEncodingFunction())));
+ ByteSource byteSource = loadQuery(Joiner.on(',').join(Lists.transform(userLogins, new UserEncodingFunction())), fromCache);
return parseUsers(byteSource);
}
- private ByteSource loadQuery(String loginsQuery) {
+ private ByteSource loadQuery(String loginsQuery, @Nullable MutableBoolean fromCache) {
WSLoaderResult<ByteSource> result = wsLoader.loadSource("/batch/users?logins=" + loginsQuery);
- super.loadedFromCache = result.isFromCache();
+ if (fromCache != null) {
+ fromCache.setValue(result.isFromCache());
+ }
return result.get();
}
*/
package org.sonar.batch.rule;
-import org.sonar.batch.bootstrap.AbstractServerLoader;
+import javax.annotation.Nullable;
+import org.apache.commons.lang.mutable.MutableBoolean;
import org.sonar.batch.bootstrap.WSLoaderResult;
import org.sonarqube.ws.Rules.ListResponse.Rule;
import com.google.common.io.ByteSource;
import org.sonar.batch.bootstrap.WSLoader;
-public class DefaultRulesLoader extends AbstractServerLoader implements RulesLoader {
+public class DefaultRulesLoader implements RulesLoader {
private static final String RULES_SEARCH_URL = "/api/rules/list";
private final WSLoader wsLoader;
}
@Override
- public List<Rule> load() {
+ public List<Rule> load(@Nullable MutableBoolean fromCache) {
WSLoaderResult<ByteSource> result = wsLoader.loadSource(RULES_SEARCH_URL);
ListResponse list = loadFromSource(result.get());
- super.loadedFromCache = result.isFromCache();
+ if (fromCache != null) {
+ fromCache.setValue(result.isFromCache());
+ }
return list.getRulesList();
}
*/
package org.sonar.batch.rule;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
import java.util.List;
import org.sonarqube.ws.Rules.ListResponse.Rule;
public interface RulesLoader {
- List<Rule> load();
-
- boolean loadedFromCache();
+ List<Rule> load(MutableBoolean fromCache);
}
*/
package org.sonar.batch.rule;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
-
import org.sonar.api.utils.log.Profiler;
import java.util.List;
private static Rules load(RulesLoader ref) {
Profiler profiler = Profiler.create(LOG).startInfo(LOG_MSG);
- List<Rule> loadedRules = ref.load();
+ MutableBoolean fromCache = new MutableBoolean();
+ List<Rule> loadedRules = ref.load(fromCache);
RulesBuilder builder = new RulesBuilder();
for (Rule r : loadedRules) {
newRule.setInternalKey(r.getInternalKey());
}
- profiler.stopInfo(ref.loadedFromCache());
+ profiler.stopInfo(fromCache.booleanValue());
return builder.build();
}
preview = CoreProperties.ANALYSIS_MODE_PREVIEW.equals(mode);
issues = CoreProperties.ANALYSIS_MODE_ISSUES.equals(mode);
mediumTestMode = "true".equals(getPropertyWithFallback(analysisProps, globalProps, FakePluginInstaller.MEDIUM_TEST_ENABLED));
-
+ }
+
+ public void printMode() {
if (preview) {
LOG.info("Preview mode");
} else if (issues) {
*/
package org.sonar.batch.scan;
-import org.sonar.batch.cache.ProjectSyncContainer;
-
import org.sonar.batch.repository.user.UserRepositoryLoader;
import org.sonar.batch.issue.tracking.DefaultServerLineHashesLoader;
import org.sonar.batch.issue.tracking.ServerLineHashesLoader;
return env != null && "SonarRunner".equals(env.getKey());
}
- private void doProjectSync() {
- ProjectAnalysisMode mode = getComponentByType(ProjectAnalysisMode.class);
- if (mode.isIssues()) {
- new ProjectSyncContainer(getParent(), props, false).execute();
- }
- }
-
private void addBatchComponents() {
add(
props,
@Override
protected void doAfterStart() {
+ ProjectAnalysisMode analysisMode = getComponentByType(ProjectAnalysisMode.class);
+ analysisMode.printMode();
LOG.debug("Start recursive analysis of project modules");
DefaultProjectTree tree = getComponentByType(DefaultProjectTree.class);
scanRecursively(tree.getRootProject());
- if (getComponentByType(ProjectAnalysisMode.class).isMediumTest()) {
+ if (analysisMode.isMediumTest()) {
getComponentByType(ScanTaskObservers.class).notifyEndOfScanTask();
}
}
package org.sonar.batch.cache;
import static org.mockito.Mockito.when;
+
+import org.sonar.batch.protocol.input.ProjectRepositories;
+
+import org.apache.commons.lang.mutable.MutableBoolean;
import org.sonar.batch.issue.tracking.DefaultServerLineHashesLoader;
import org.sonar.batch.repository.DefaultServerIssuesLoader;
import org.sonar.batch.scan.ProjectAnalysisMode;
import java.util.Date;
import java.util.HashMap;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
import static org.mockito.Matchers.anyString;
-
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import com.google.common.io.Resources;
private ServerLineHashesLoader lineHashesLoader;
private UserRepositoryLoader userRepositoryLoader;
+ private ProjectCacheSynchronizer sync;
+
@Before
public void setUp() throws IOException {
MockitoAnnotations.initMocks(this);
issuesLoader = new DefaultServerIssuesLoader(ws);
lineHashesLoader = new DefaultServerLineHashesLoader(ws);
userRepositoryLoader = new UserRepositoryLoader(ws);
+
+ sync = new ProjectCacheSynchronizer(projectReactor, projectRepositoryLoader, properties, issuesLoader, lineHashesLoader, userRepositoryLoader,
+ cacheStatus);
}
@Test
public void testSync() {
- ProjectCacheSynchronizer sync = new ProjectCacheSynchronizer(projectReactor, projectRepositoryLoader, properties, issuesLoader, lineHashesLoader, userRepositoryLoader,
- cacheStatus);
sync.load(false);
verify(ws).loadString(BATCH_PROJECT);
verify(cacheStatus).save(anyString());
}
+ @Test
+ public void testSyncNoLastAnalysis() {
+ projectRepositoryLoader = mock(DefaultProjectRepositoriesLoader.class);
+ ProjectRepositories mockedProjectRepositories = mock(ProjectRepositories.class);
+ when(mockedProjectRepositories.lastAnalysisDate()).thenReturn(null);
+ when(projectRepositoryLoader.load(any(ProjectDefinition.class), any(AnalysisProperties.class), any(MutableBoolean.class))).thenReturn(mockedProjectRepositories);
+
+ sync = new ProjectCacheSynchronizer(projectReactor, projectRepositoryLoader, properties, issuesLoader, lineHashesLoader, userRepositoryLoader,
+ cacheStatus);
+ sync.load(true);
+
+ verify(cacheStatus).save("org.codehaus.sonar-plugins:sonar-scm-git-plugin");
+ }
+
@Test
public void testDontSyncIfNotForce() {
when(cacheStatus.getSyncStatus("org.codehaus.sonar-plugins:sonar-scm-git-plugin")).thenReturn(new Date());
*/
package org.sonar.batch.issue.tracking;
-import org.sonar.batch.bootstrap.WSLoaderResult;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.sonar.batch.bootstrap.WSLoaderResult;
import org.sonar.batch.bootstrap.WSLoader;
import org.junit.Before;
import org.junit.Rule;
ServerLineHashesLoader lastSnapshots = new DefaultServerLineHashesLoader(wsLoader);
- String[] hashes = lastSnapshots.getLineHashes("myproject:org/foo/Bar.c");
+ String[] hashes = lastSnapshots.getLineHashes("myproject:org/foo/Bar.c", null);
assertThat(hashes).containsOnly("ae12", "", "43fb");
verify(wsLoader).loadString("/api/sources/hash?key=myproject%3Aorg%2Ffoo%2FBar.c");
}
ServerLineHashesLoader lastSnapshots = new DefaultServerLineHashesLoader(server);
- String[] hashes = lastSnapshots.getLineHashes("myproject:org/foo/Foo Bar.c");
+ MutableBoolean fromCache = new MutableBoolean();
+ String[] hashes = lastSnapshots.getLineHashes("myproject:org/foo/Foo Bar.c", fromCache);
+ assertThat(fromCache.booleanValue()).isTrue();
assertThat(hashes).containsOnly("ae12", "", "43fb");
verify(server).loadString("/api/sources/hash?key=myproject%3Aorg%2Ffoo%2FFoo+Bar.c");
}
ServerLineHashesLoader lastSnapshots = new DefaultServerLineHashesLoader(server);
thrown.expect(HttpDownloader.HttpException.class);
- lastSnapshots.getLineHashes("foo");
+ lastSnapshots.getLineHashes("foo", null);
}
}
FileUtils.write(ioFile, source, StandardCharsets.UTF_8);
when(file.key()).thenReturn(key);
when(file.status()).thenReturn(InputFile.Status.CHANGED);
- when(lastSnapshots.getLineHashes(key)).thenReturn(new String[] {md5Hex(source)});
+ when(lastSnapshots.getLineHashes(key, null)).thenReturn(new String[] {md5Hex(source)});
assertThat(sourceHashHolder.getHashedReference().getHash(1)).isEqualTo(md5Hex(source));
- verify(lastSnapshots).getLineHashes(key);
+ verify(lastSnapshots).getLineHashes(key, null);
assertThat(sourceHashHolder.getHashedReference().getHash(1)).isEqualTo(md5Hex(source));
Mockito.verifyNoMoreInteractions(lastSnapshots);
*/
package org.sonar.batch.mediumtest;
+import org.apache.commons.lang.mutable.MutableBoolean;
+
+import javax.annotation.Nullable;
+
import org.sonar.batch.cache.ProjectCacheStatus;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonarqube.ws.Rules.ListResponse.Rule;
}
@Override
- public List<Rule> load() {
+ public List<Rule> load(@Nullable MutableBoolean fromCache) {
return rules;
}
-
- @Override
- public boolean loadedFromCache() {
- return false;
- }
}
private static class FakeGlobalRepositoriesLoader implements GlobalRepositoriesLoader {
private GlobalRepositories ref = new GlobalRepositories();
@Override
- public GlobalRepositories load() {
+ public GlobalRepositories load(@Nullable MutableBoolean fromCache) {
return ref;
}
return this;
}
- @Override
- public boolean loadedFromCache() {
- return false;
- }
}
private static class FakeProjectRepositoriesLoader implements ProjectRepositoriesLoader {
private ProjectRepositories ref = new ProjectRepositories();
@Override
- public ProjectRepositories load(ProjectDefinition projDefinition, AnalysisProperties taskProperties) {
+ public ProjectRepositories load(ProjectDefinition projDefinition, AnalysisProperties taskProperties, @Nullable MutableBoolean fromCache) {
return ref;
}
return this;
}
- @Override
- public boolean loadedFromCache() {
- return true;
- }
}
private static class FakeServerIssuesLoader implements ServerIssuesLoader {
private Map<String, String[]> byKey = new HashMap<>();
@Override
- public String[] getLineHashes(String fileKey) {
+ public String[] getLineHashes(String fileKey, @Nullable MutableBoolean fromCache) {
if (byKey.containsKey(fileKey)) {
return byKey.get(fileKey);
} else {
*/
package org.sonar.batch.repository;
-import org.sonar.batch.scan.ProjectAnalysisMode;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.sonar.batch.scan.ProjectAnalysisMode;
import org.apache.commons.io.IOUtils;
import org.sonar.batch.bootstrap.WSLoaderResult;
import com.google.common.collect.Maps;
addQualityProfile();
project = ProjectDefinition.create().setKey("foo");
when(analysisMode.isIssues()).thenReturn(false);
- loader.load(project, taskProperties);
+ loader.load(project, taskProperties, null);
verify(wsLoader).loadString("/batch/project?key=foo&preview=false");
when(analysisMode.isIssues()).thenReturn(true);
- loader.load(project, taskProperties);
+ loader.load(project, taskProperties, null);
verify(wsLoader).loadString("/batch/project?key=foo&preview=true");
}
public void deserializeResponse() throws IOException {
String resourceName = this.getClass().getSimpleName() + "/sample_response.json";
String response = IOUtils.toString(this.getClass().getResourceAsStream(resourceName));
- when(wsLoader.loadString(anyString())).thenReturn(new WSLoaderResult<>(response, false));
+ when(wsLoader.loadString(anyString())).thenReturn(new WSLoaderResult<>(response, true));
project = ProjectDefinition.create().setKey("foo");
- ProjectRepositories projectRepo = loader.load(project, taskProperties);
+ MutableBoolean fromCache = new MutableBoolean();
+ ProjectRepositories projectRepo = loader.load(project, taskProperties, fromCache);
+ assertThat(fromCache.booleanValue()).isTrue();
assertThat(projectRepo.activeRules().size()).isEqualTo(221);
assertThat(projectRepo.fileDataByPath("my:project").size()).isEqualTo(11);
public void passAndEncodeProjectKeyParameter() {
addQualityProfile();
project = ProjectDefinition.create().setKey("foo bàr");
- loader.load(project, taskProperties);
+ loader.load(project, taskProperties, null);
verify(wsLoader).loadString("/batch/project?key=foo+b%C3%A0r&preview=false");
}
addQualityProfile();
project = ProjectDefinition.create().setKey("foo");
taskProperties.properties().put(ModuleQProfiles.SONAR_PROFILE_PROP, "my-profile#2");
- loader.load(project, taskProperties);
+ loader.load(project, taskProperties, null);
verify(wsLoader).loadString("/batch/project?key=foo&profile=my-profile%232&preview=false");
}
project = ProjectDefinition.create().setKey("foo");
when(wsLoader.loadString(anyString())).thenReturn(new WSLoaderResult<>(new ProjectRepositories().toJson(), true));
- loader.load(project, taskProperties);
+ loader.load(project, taskProperties, null);
}
private void addQualityProfile() {
*/
package org.sonar.batch.repository.user;
-import com.google.common.collect.ImmutableMap;
+import org.junit.Before;
+import com.google.common.collect.ImmutableList;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import com.google.common.collect.ImmutableMap;
import org.junit.rules.ExpectedException;
import org.junit.Rule;
import org.mockito.Mockito;
import java.util.Arrays;
import java.util.Map;
+import static org.mockito.Matchers.anyString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.Mockito.mock;
@Rule
public final ExpectedException exception = ExpectedException.none();
+ private WSLoader wsLoader;
+ private UserRepositoryLoader userRepo;
+
+ @Before
+ public void setUp() {
+ wsLoader = mock(WSLoader.class);
+ userRepo = new UserRepositoryLoader(wsLoader);
+ }
+
@Test
public void testLoad() throws IOException {
- WSLoader wsLoader = mock(WSLoader.class);
- UserRepositoryLoader userRepo = new UserRepositoryLoader(wsLoader);
-
Map<String, String> userMap = ImmutableMap.of("fmallet", "Freddy Mallet", "sbrandhof", "Simon");
WSLoaderResult<ByteSource> res = new WSLoaderResult<>(createUsersMock(userMap), true);
when(wsLoader.loadSource("/batch/users?logins=fmallet,sbrandhof")).thenReturn(res);
}
@Test
- public void testLoadSingleUser() throws IOException {
- WSLoader wsLoader = mock(WSLoader.class);
- UserRepositoryLoader userRepo = new UserRepositoryLoader(wsLoader);
+ public void testFromCache() throws IOException {
+ WSLoaderResult<ByteSource> res = new WSLoaderResult<>(createUsersMock(ImmutableMap.of("fmallet", "Freddy Mallet")), true);
+ when(wsLoader.loadSource(anyString())).thenReturn(res);
+ MutableBoolean fromCache = new MutableBoolean();
+ userRepo.load("", fromCache);
+ assertThat(fromCache.booleanValue()).isTrue();
+
+ fromCache.setValue(false);
+ userRepo.load(ImmutableList.of("user"), fromCache);
+ assertThat(fromCache.booleanValue()).isTrue();
+ }
+ @Test
+ public void testLoadSingleUser() throws IOException {
WSLoaderResult<ByteSource> res = new WSLoaderResult<>(createUsersMock(ImmutableMap.of("fmallet", "Freddy Mallet")), true);
when(wsLoader.loadSource("/batch/users?logins=fmallet")).thenReturn(res);
@Test
public void testInputStreamError() throws IOException {
- WSLoader wsLoader = mock(WSLoader.class);
- UserRepositoryLoader userRepo = new UserRepositoryLoader(wsLoader);
ByteSource source = mock(ByteSource.class);
WSLoaderResult<ByteSource> res = new WSLoaderResult<>(source, true);
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import org.sonar.batch.bootstrap.WSLoaderResult;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import org.sonar.batch.bootstrap.WSLoaderResult;
import org.sonarqube.ws.Rules.ListResponse.Rule;
import com.google.common.io.ByteSource;
import com.google.common.io.Resources;
ByteSource source = Resources.asByteSource(this.getClass().getResource("DefaultRulesLoader/response.protobuf"));
when(wsLoader.loadSource(anyString())).thenReturn(new WSLoaderResult<>(source, true));
DefaultRulesLoader loader = new DefaultRulesLoader(wsLoader);
- List<Rule> ruleList = loader.load();
+ List<Rule> ruleList = loader.load(null);
assertThat(ruleList).hasSize(318);
}
ByteSource source = Resources.asByteSource(this.getClass().getResource("DefaultRulesLoader/response.protobuf"));
when(wsLoader.loadSource(anyString())).thenReturn(new WSLoaderResult<>(source, true));
DefaultRulesLoader loader = new DefaultRulesLoader(wsLoader);
- loader.load();
+ MutableBoolean fromCache = new MutableBoolean();
+ loader.load(fromCache);
- assertThat(loader.loadedFromCache()).isTrue();
+ assertThat(fromCache.booleanValue()).isTrue();
}
- @Test(expected = IllegalStateException.class)
- public void testGetLoadedFromCacheBefore() {
- DefaultRulesLoader loader = new DefaultRulesLoader(mock(WSLoader.class));
- loader.loadedFromCache();
- }
}
*/
package org.sonar.batch.rule;
-import com.google.common.collect.Lists;
+import static org.mockito.Matchers.any;
-import org.sonar.api.batch.rule.Rules;
+import org.apache.commons.lang.mutable.MutableBoolean;
+import com.google.common.collect.Lists;
+import org.sonar.api.batch.rule.Rules;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.mock;
@Test
public void testRuleTranslation() {
RulesLoader loader = mock(RulesLoader.class);
- when(loader.load()).thenReturn(Lists.newArrayList(getTestRule()));
+ when(loader.load(any(MutableBoolean.class))).thenReturn(Lists.newArrayList(getTestRule()));
RulesProvider provider = new RulesProvider();
projects / sonarqube.git / commitdiff