/**
* Checks whether there is any document in any mentioned type.
*/
- public boolean isEmpty(IndexTypeId... indexType) {
+ public boolean isEmpty(IndexTypeId indexType) {
return count(indexType) <= 0;
}
- private long count(IndexTypeId... indexType) {
+ private long count(IndexTypeId indexType) {
return prepareSearch(indexType).setSize(0).get().getHits().getTotalHits();
}
long now = system2.now();
List<DefaultIssue> toBeUpdated = batchInsertAndReturnIssuesToUpdate(session, issues, now);
update(toBeUpdated, now);
- doAfterSave();
+ doAfterSave(issues);
}
- protected void doAfterSave() {
+ protected void doAfterSave(Iterable<DefaultIssue> issues) {
// overridden on server-side to index ES
}
}
@Override
- protected void doAfterSave() {
- indexer.index();
+ protected void doAfterSave(Iterable<DefaultIssue> issues) {
+ indexer.index(issues);
}
protected ComponentDto component(DbSession session, DefaultIssue issue) {
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.sonar.api.resources.Qualifiers;
-import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.server.es.BaseIndexer;
import org.sonar.server.es.BulkIndexer;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.EsUtils;
import static org.elasticsearch.index.query.QueryBuilders.boolQuery;
import static org.elasticsearch.index.query.QueryBuilders.termQuery;
import static org.sonar.server.issue.index.IssueIndexDefinition.FIELD_ISSUE_PROJECT_UUID;
-import static org.sonar.server.issue.index.IssueIndexDefinition.FIELD_ISSUE_TECHNICAL_UPDATED_AT;
import static org.sonar.server.issue.index.IssueIndexDefinition.INDEX_TYPE_ISSUE;
-public class IssueIndexer extends BaseIndexer implements ProjectIndexer, NeedAuthorizationIndexer, StartupIndexer {
+public class IssueIndexer implements ProjectIndexer, NeedAuthorizationIndexer, StartupIndexer {
private static final String DELETE_ERROR_MESSAGE = "Fail to delete some issues of project [%s]";
private static final int MAX_BATCH_SIZE = 1000;
private static final AuthorizationScope AUTHORIZATION_SCOPE = new AuthorizationScope(INDEX_TYPE_ISSUE, project -> Qualifiers.PROJECT.equals(project.getQualifier()));
private final DbClient dbClient;
+ private final EsClient esClient;
- public IssueIndexer(System2 system2, DbClient dbClient, EsClient esClient) {
- super(system2, esClient, 300, INDEX_TYPE_ISSUE, FIELD_ISSUE_TECHNICAL_UPDATED_AT);
+ public IssueIndexer(DbClient dbClient, EsClient esClient) {
this.dbClient = dbClient;
+ this.esClient = esClient;
}
@Override
return AUTHORIZATION_SCOPE;
}
- @Override
- protected long doIndex(long lastUpdatedAt) {
- return doIndex(createBulkIndexer(false), lastUpdatedAt, null);
- }
-
@Override
public Set<IndexTypeId> getIndexTypes() {
return ImmutableSet.of(INDEX_TYPE_ISSUE);
@Override
public void indexOnStartup() {
- index();
+ doIndex(createBulkIndexer(true), (String) null);
}
public void indexAll() {
- doIndex(createBulkIndexer(true), 0L, null);
+ doIndex(createBulkIndexer(false), (String) null);
}
@Override
// nothing to do, project key is not used in this index
break;
case NEW_ANALYSIS:
- super.index(lastUpdatedAt -> doIndex(createBulkIndexer(false), lastUpdatedAt, projectUuid));
+ doIndex(createBulkIndexer(false), projectUuid);
break;
default:
// defensive case
doIndex(createBulkIndexer(false), issues);
}
- private long doIndex(BulkIndexer bulk, long lastUpdatedAt, @Nullable String projectUuid) {
+ private void doIndex(BulkIndexer bulk, @Nullable String projectUuid) {
try (DbSession dbSession = dbClient.openSession(false)) {
- IssueResultSetIterator rowIt = IssueResultSetIterator.create(dbClient, dbSession, lastUpdatedAt, projectUuid);
- long maxDate = doIndex(bulk, rowIt);
+ IssueResultSetIterator rowIt = IssueResultSetIterator.create(dbClient, dbSession, projectUuid);
+ doIndex(bulk, rowIt);
rowIt.close();
- return maxDate;
}
}
- private static long doIndex(BulkIndexer bulk, Iterator<IssueDoc> issues) {
+ private static void doIndex(BulkIndexer bulk, Iterator<IssueDoc> issues) {
bulk.start();
- long maxDate = 0L;
while (issues.hasNext()) {
IssueDoc issue = issues.next();
bulk.add(newIndexRequest(issue));
-
- // it's more efficient to sort programmatically than in SQL on some databases (MySQL for instance)
- maxDate = Math.max(maxDate, issue.getTechnicalUpdateDate().getTime());
}
bulk.stop();
- return maxDate;
}
@Override
"inner join projects p on p.uuid=i.component_uuid " +
"inner join projects root on root.uuid=i.project_uuid";
- private static final String SQL_AFTER_DATE = SQL_ALL + " where i.updated_at>?";
-
private static final String PROJECT_FILTER = " AND root.uuid=?";
private static final Splitter TAGS_SPLITTER = Splitter.on(',').trimResults().omitEmptyStrings();
super(stmt);
}
- static IssueResultSetIterator create(DbClient dbClient, DbSession session, long afterDate, @Nullable String projectUuid) {
+ static IssueResultSetIterator create(DbClient dbClient, DbSession session, @Nullable String projectUuid) {
try {
- String sql = afterDate > 0L ? SQL_AFTER_DATE : SQL_ALL;
+ String sql = SQL_ALL;
sql += projectUuid == null ? "" : PROJECT_FILTER;
PreparedStatement stmt = dbClient.getMyBatis().newScrollingSelectStatement(session, sql);
- int index = 1;
- if (afterDate > 0L) {
- stmt.setLong(index, afterDate);
- index++;
- }
if (projectUuid != null) {
- stmt.setString(index, projectUuid);
+ stmt.setString(1, projectUuid);
}
return new IssueResultSetIterator(stmt);
} catch (SQLException e) {
import javax.annotation.Nullable;
import org.elasticsearch.action.index.IndexRequest;
import org.sonar.api.resources.Qualifiers;
-import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.measure.ProjectMeasuresIndexerIterator;
import org.sonar.db.measure.ProjectMeasuresIndexerIterator.ProjectMeasures;
-import org.sonar.server.es.BaseIndexer;
import org.sonar.server.es.BulkIndexer;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.IndexTypeId;
import org.sonar.server.permission.index.AuthorizationScope;
import org.sonar.server.permission.index.NeedAuthorizationIndexer;
-import static org.sonar.server.measure.index.ProjectMeasuresIndexDefinition.FIELD_ANALYSED_AT;
import static org.sonar.server.measure.index.ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES;
-public class ProjectMeasuresIndexer extends BaseIndexer implements ProjectIndexer, NeedAuthorizationIndexer, StartupIndexer {
+public class ProjectMeasuresIndexer implements ProjectIndexer, NeedAuthorizationIndexer, StartupIndexer {
private static final AuthorizationScope AUTHORIZATION_SCOPE = new AuthorizationScope(INDEX_TYPE_PROJECT_MEASURES, project -> Qualifiers.PROJECT.equals(project.getQualifier()));
private final DbClient dbClient;
+ private final EsClient esClient;
- public ProjectMeasuresIndexer(System2 system2, DbClient dbClient, EsClient esClient) {
- super(system2, esClient, 300, INDEX_TYPE_PROJECT_MEASURES, FIELD_ANALYSED_AT);
+ public ProjectMeasuresIndexer(DbClient dbClient, EsClient esClient) {
this.dbClient = dbClient;
+ this.esClient = esClient;
}
@Override
@Override
public void indexOnStartup() {
- index();
+ doIndex(createBulkIndexer(false), (String) null);
}
@Override
return AUTHORIZATION_SCOPE;
}
- @Override
- protected long doIndex(long lastUpdatedAt) {
- return doIndex(createBulkIndexer(false), lastUpdatedAt, null);
- }
-
@Override
public void indexProject(String projectUuid, Cause cause) {
switch (cause) {
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.index.IndexRequest;
-import org.elasticsearch.action.search.SearchResponse;
import org.picocontainer.Startable;
import org.sonar.api.utils.DateUtils;
import org.sonar.core.util.stream.Collectors;
import org.sonar.server.es.EsUtils;
import org.sonar.server.es.IndexTypeId;
import org.sonar.server.es.ProjectIndexer;
+import org.sonar.server.es.StartupIndexer;
import static com.google.common.base.Preconditions.checkArgument;
import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;
+import static org.sonar.core.util.stream.Collectors.toSet;
/**
* Manages the synchronization of indexes with authorization settings defined in database:
* <li>delete project orphans from index</li>
* </ul>
*/
-public class PermissionIndexer implements ProjectIndexer, Startable {
+public class PermissionIndexer implements ProjectIndexer, Startable, StartupIndexer {
@VisibleForTesting
static final int MAX_BATCH_SIZE = 1000;
this.authorizationScopes = authorizationScopes;
}
- public void initializeOnStartup() {
- LOG.info("Index authorization");
- indexAllIfEmpty();
+ @Override
+ public Set<IndexTypeId> getIndexTypes() {
+ return authorizationScopes.stream()
+ .map(AuthorizationScope::getIndexType)
+ .collect(toSet(authorizationScopes.size()));
}
- public void indexAllIfEmpty() {
- boolean isEmpty = false;
- for (AuthorizationScope scope : authorizationScopes) {
- isEmpty |= isAuthorizationTypeEmpty(scope.getIndexType());
- }
-
- if (isEmpty) {
- Future<?> submit = executor.submit(() -> {
- authorizationScopes.stream()
- .map(AuthorizationScope::getIndexType)
- .forEach(this::truncateAuthorizationType);
-
- try (DbSession dbSession = dbClient.openSession(false)) {
- index(new PermissionIndexerDao().selectAll(dbClient, dbSession));
- }
- });
- try {
- Uninterruptibles.getUninterruptibly(submit);
- } catch (ExecutionException e) {
- Throwables.propagate(e);
+ @Override
+ public void indexOnStartup() {
+ Future<?> submit = executor.submit(() -> {
+ authorizationScopes.stream()
+ .map(AuthorizationScope::getIndexType)
+ .forEach(this::truncateAuthorizationType);
+
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ index(new PermissionIndexerDao().selectAll(dbClient, dbSession));
}
+ });
+ try {
+ Uninterruptibles.getUninterruptibly(submit);
+ } catch (ExecutionException e) {
+ Throwables.propagate(e);
}
}
.get());
}
- private boolean isAuthorizationTypeEmpty(IndexTypeId indexType) {
- SearchResponse response = esClient.prepareSearch(indexType).setSize(0).get();
- return response.getHits().getTotalHits() == 0;
- }
-
private void truncateAuthorizationType(IndexTypeId indexType) {
BulkIndexer.delete(esClient, indexType.getIndex(), esClient.prepareSearch(indexType).setQuery(matchAllQuery()));
}
package org.sonar.server.source.index;
import com.google.common.base.Joiner;
-
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
public class FileSourcesUpdaterHelper {
private static final String SQL_ALL = "SELECT %s FROM file_sources WHERE data_type='%s' ";
- private static final String AFTER_DATE_FILTER = " AND updated_at>?";
private static final String PROJECT_FILTER = " AND project_uuid=?";
private static final String[] FIELDS = {
// only static stuff
}
- public static PreparedStatement preparedStatementToSelectFileSources(DbClient dbClient, DbSession session, String dataType, long afterDate, @Nullable String projectUuid)
+ public static PreparedStatement preparedStatementToSelectFileSources(DbClient dbClient, DbSession session, String dataType, @Nullable String projectUuid)
throws SQLException {
- String sql = createSQL(dataType, afterDate, projectUuid);
+ String sql = createSQL(dataType, projectUuid);
// rows are big, so they are scrolled once at a time (one row in memory at a time)
PreparedStatement stmt = dbClient.getMyBatis().newScrollingSingleRowSelectStatement(session, sql);
- int index = 1;
- if (afterDate > 0L) {
- stmt.setLong(index, afterDate);
- index++;
- }
if (projectUuid != null) {
- stmt.setString(index, projectUuid);
+ stmt.setString(1, projectUuid);
}
return stmt;
}
- private static String createSQL(String dataType, long afterDate, @Nullable String projectUuid) {
+ private static String createSQL(String dataType, @Nullable String projectUuid) {
StringBuilder sql = new StringBuilder(String.format(SQL_ALL, FIELDS_ONE_LINE, dataType));
- if (afterDate > 0L || projectUuid != null) {
- if (afterDate > 0L) {
- sql.append(AFTER_DATE_FILTER);
- }
- if (projectUuid != null) {
- sql.append(PROJECT_FILTER);
- }
+ if (projectUuid != null) {
+ sql.append(PROJECT_FILTER);
}
return sql.toString();
}
import javax.annotation.Nullable;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.index.query.QueryBuilders;
-import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.server.es.BaseIndexer;
import org.sonar.server.es.BulkIndexer;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.IndexTypeId;
import org.sonar.server.source.index.FileSourcesUpdaterHelper;
import static org.sonar.server.test.index.TestIndexDefinition.FIELD_FILE_UUID;
-import static org.sonar.server.test.index.TestIndexDefinition.FIELD_UPDATED_AT;
import static org.sonar.server.test.index.TestIndexDefinition.INDEX_TYPE_TEST;
/**
* Add to Elasticsearch index {@link TestIndexDefinition} the rows of
* db table FILE_SOURCES of type TEST that are not indexed yet
*/
-public class TestIndexer extends BaseIndexer implements ProjectIndexer, StartupIndexer {
+public class TestIndexer implements ProjectIndexer, StartupIndexer {
private final DbClient dbClient;
+ private final EsClient esClient;
- public TestIndexer(System2 system2, DbClient dbClient, EsClient esClient) {
- super(system2, esClient, 0L, INDEX_TYPE_TEST, FIELD_UPDATED_AT);
+ public TestIndexer(DbClient dbClient, EsClient esClient) {
this.dbClient = dbClient;
+ this.esClient = esClient;
}
@Override
break;
case NEW_ANALYSIS:
deleteProject(projectUuid);
- super.index(lastUpdatedAt -> doIndex(lastUpdatedAt, projectUuid));
+ doIndex(projectUuid, cause);
break;
default:
// defensive case
@Override
public void indexOnStartup() {
- index();
+ doIndex(null, Cause.NEW_ANALYSIS);
}
public long index(Iterator<FileSourcesUpdaterHelper.Row> dbRows) {
return doIndex(bulk, dbRows);
}
- @Override
- protected long doIndex(long lastUpdatedAt) {
- return doIndex(lastUpdatedAt, null);
- }
-
- private long doIndex(long lastUpdatedAt, @Nullable String projectUuid) {
+ private long doIndex(@Nullable String projectUuid, Cause cause) {
final BulkIndexer bulk = new BulkIndexer(esClient, INDEX_TYPE_TEST.getIndex());
- bulk.setLarge(lastUpdatedAt == 0L);
+ bulk.setLarge(cause == Cause.NEW_ANALYSIS);
DbSession dbSession = dbClient.openSession(false);
try {
- TestResultSetIterator rowIt = TestResultSetIterator.create(dbClient, dbSession, lastUpdatedAt, projectUuid);
+ TestResultSetIterator rowIt = TestResultSetIterator.create(dbClient, dbSession, projectUuid);
long maxUpdatedAt = doIndex(bulk, rowIt);
rowIt.close();
return maxUpdatedAt;
super(stmt);
}
- public static TestResultSetIterator create(DbClient dbClient, DbSession session, long afterDate, @Nullable String projectUuid) {
+ public static TestResultSetIterator create(DbClient dbClient, DbSession session, @Nullable String projectUuid) {
try {
- return new TestResultSetIterator(FileSourcesUpdaterHelper.preparedStatementToSelectFileSources(dbClient, session, FileSourceDto.Type.TEST, afterDate, projectUuid));
+ return new TestResultSetIterator(FileSourcesUpdaterHelper.preparedStatementToSelectFileSources(dbClient, session, FileSourceDto.Type.TEST, projectUuid));
} catch (SQLException e) {
throw new IllegalStateException("Fail to prepare SQL request to select all tests", e);
}
import java.util.Iterator;
import java.util.Set;
import org.elasticsearch.action.index.IndexRequest;
-import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.server.es.BaseIndexer;
import org.sonar.server.es.BulkIndexer;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.IndexTypeId;
import static org.sonar.server.user.index.UserIndexDefinition.INDEX_TYPE_USER;
-public class UserIndexer extends BaseIndexer implements StartupIndexer {
+public class UserIndexer implements StartupIndexer {
private final DbClient dbClient;
+ private final EsClient esClient;
- public UserIndexer(System2 system2, DbClient dbClient, EsClient esClient) {
- super(system2, esClient, 300, UserIndexDefinition.INDEX_TYPE_USER, UserIndexDefinition.FIELD_UPDATED_AT);
+ public UserIndexer(DbClient dbClient, EsClient esClient) {
this.dbClient = dbClient;
+ this.esClient = esClient;
}
@Override
index();
}
- @Override
- protected long doIndex(long lastUpdatedAt) {
+ public void index() {
final BulkIndexer bulk = new BulkIndexer(esClient, UserIndexDefinition.INDEX_TYPE_USER.getIndex());
- bulk.setLarge(lastUpdatedAt == 0L);
+ bulk.setLarge(true);
DbSession dbSession = dbClient.openSession(false);
try {
- UserResultSetIterator rowIt = UserResultSetIterator.create(dbClient, dbSession, lastUpdatedAt);
- long maxUpdatedAt = doIndex(bulk, rowIt);
+ UserResultSetIterator rowIt = UserResultSetIterator.create(dbClient, dbSession);
+ doIndex(bulk, rowIt);
rowIt.close();
- return maxUpdatedAt;
} finally {
dbSession.close();
}
private static final String SQL_ALL = "select " + StringUtils.join(FIELDS, ",") + " from users u ";
- private static final String SQL_AFTER_DATE = SQL_ALL + " where u.updated_at>?";
-
private UserResultSetIterator(PreparedStatement stmt) throws SQLException {
super(stmt);
}
- static UserResultSetIterator create(DbClient dbClient, DbSession session, long afterDate) {
+ static UserResultSetIterator create(DbClient dbClient, DbSession session) {
try {
- String sql = afterDate > 0L ? SQL_AFTER_DATE : SQL_ALL;
- PreparedStatement stmt = dbClient.getMyBatis().newScrollingSelectStatement(session, sql);
- if (afterDate > 0L) {
- stmt.setLong(1, afterDate);
- }
+ PreparedStatement stmt = dbClient.getMyBatis().newScrollingSelectStatement(session, SQL_ALL);
return new UserResultSetIterator(stmt);
} catch (SQLException e) {
throw new IllegalStateException("Fail to prepare SQL request to select all users", e);
import java.util.Map;
import java.util.Set;
import org.elasticsearch.action.index.IndexRequest;
-import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.UuidWithProjectUuidDto;
-import org.sonar.server.es.BaseIndexer;
import org.sonar.server.es.BulkIndexer;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.IndexTypeId;
import static com.google.common.collect.Maps.newHashMap;
import static org.sonar.server.view.index.ViewIndexDefinition.INDEX_TYPE_VIEW;
-public class ViewIndexer extends BaseIndexer implements StartupIndexer {
+public class ViewIndexer implements StartupIndexer {
private final DbClient dbClient;
+ private final EsClient esClient;
- public ViewIndexer(System2 system2, DbClient dbClient, EsClient esClient) {
- super(system2, esClient, 300, ViewIndexDefinition.INDEX_TYPE_VIEW, "updatedAt");
+ public ViewIndexer(DbClient dbClient, EsClient esClient) {
this.dbClient = dbClient;
+ this.esClient = esClient;
}
@Override
}
@Override
- public void indexOnStartup() {
- index();
- }
-
- /**
- * Index all views if the index is empty (Only used on startup).
- * It's currently not possible to index only data from db that are not existing in the index because we have no way to last when the structure of a view is changed :
- * - Either the definition has changed -> No updated at column in the projects table,
- * - Either the view is defined by a regex -> A new analysed project automatically steps into the view.
- * <p/>
- * The views lookup cache will not be cleared
- */
- @Override
- protected long doIndex(long lastUpdatedAt) {
- long count = esClient.prepareCount(ViewIndexDefinition.INDEX_TYPE_VIEW.getIndex()).setTypes(ViewIndexDefinition.INDEX_TYPE_VIEW.getType()).get().getCount();
- if (count == 0) {
- DbSession dbSession = dbClient.openSession(false);
- try {
- Map<String, String> viewAndProjectViewUuidMap = newHashMap();
- for (UuidWithProjectUuidDto uuidWithProjectUuidDto : dbClient.componentDao().selectAllViewsAndSubViews(dbSession)) {
- viewAndProjectViewUuidMap.put(uuidWithProjectUuidDto.getUuid(), uuidWithProjectUuidDto.getProjectUuid());
- }
- index(dbSession, viewAndProjectViewUuidMap, false);
- } finally {
- dbSession.close();
+ public void indexOnStartup(Set<IndexType> emptyIndexTypes) {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ Map<String, String> viewAndProjectViewUuidMap = newHashMap();
+ for (UuidWithProjectUuidDto uuidWithProjectUuidDto : dbClient.componentDao().selectAllViewsAndSubViews(dbSession)) {
+ viewAndProjectViewUuidMap.put(uuidWithProjectUuidDto.getUuid(), uuidWithProjectUuidDto.getProjectUuid());
}
+ index(dbSession, viewAndProjectViewUuidMap, false);
}
- return 0L;
}
/**
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
- private IssueIndexer issueIndexer = new IssueIndexer(system2, db.getDbClient(), es.client());
+ private IssueIndexer issueIndexer = new IssueIndexer(db.getDbClient(), es.client());
private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(es, issueIndexer);
private ServerFileSystem fs = mock(ServerFileSystem.class);
private WsTester tester;
private DbClient dbClient = db.getDbClient();
private DbSession dbSession = db.getSession();
- private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(es, new ProjectMeasuresIndexer(System2.INSTANCE, dbClient, es.client()));
+ private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(es, new ProjectMeasuresIndexer(dbClient, es.client()));
private ProjectMeasuresIndex index = new ProjectMeasuresIndex(es.client(), new AuthorizationTypeSupport(userSession));
private ProjectMeasuresQueryValidator queryValidator = new ProjectMeasuresQueryValidator(dbClient);
private ArgumentCaptor<IssueChangeNotification> notificationArgumentCaptor = ArgumentCaptor.forClass(IssueChangeNotification.class);
private IssueUpdater underTest = new IssueUpdater(dbClient,
- new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(system2, dbClient, esTester.client())),
+ new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(dbClient, esTester.client())),
notificationManager);
@Test
private System2 system2 = System2.INSTANCE;
private IssueIndex index;
- private IssueIndexer issueIndexer = new IssueIndexer(system2, null, tester.client());
+ private IssueIndexer issueIndexer = new IssueIndexer(null, tester.client());
private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(tester, issueIndexer);
@Before
public ExpectedException expectedException = ExpectedException.none();
private IssueIndex underTest;
- private IssueIndexer issueIndexer = new IssueIndexer(system2, null, tester.client());
- private ViewIndexer viewIndexer = new ViewIndexer(system2, null, tester.client());
+ private IssueIndexer issueIndexer = new IssueIndexer(tester.client(), new IssueIteratorFactory(null));
+ private ViewIndexer viewIndexer = new ViewIndexer(null, tester.client());
private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(tester, issueIndexer);
@Before
@Rule
public DbTester dbTester = DbTester.create(system2);
- private IssueIndexer underTest = new IssueIndexer(system2, dbTester.getDbClient(), esTester.client());
+ private IssueIndexer underTest = new IssueIndexer(dbTester.getDbClient(), esTester.client());
@Test
public void index_on_startup() {
IssueIndexer indexer = spy(underTest);
- doNothing().when(indexer).index();
+ doNothing().when(indexer).indexOnStartup();
indexer.indexOnStartup();
verify(indexer).indexOnStartup();
}
public void index_all_issues() {
dbTester.prepareDbUnit(getClass(), "index.xml");
- underTest.index();
+ underTest.indexOnStartup();
List<IssueDoc> docs = esTester.getDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDoc.class);
assertThat(docs).hasSize(1);
public void deleteProject_deletes_issues_of_a_specific_project() {
dbTester.prepareDbUnit(getClass(), "index.xml");
- underTest.index();
+ underTest.indexOnStartup();
assertThat(esTester.countDocuments("issues", "issue")).isEqualTo(1);
issueDoc.setKey("key");
issueDoc.setTechnicalUpdateDate(new Date());
issueDoc.setProjectUuid("non-exitsing-parent");
- new IssueIndexer(system2, dbTester.getDbClient(), esTester.client())
+ new IssueIndexer(dbTester.getDbClient(), esTester.client())
.index(Arrays.asList(issueDoc).iterator());
assertThat(esTester.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(1L);
@Test
public void iterator_over_one_issue() {
dbTester.prepareDbUnit(getClass(), "one_issue.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
Map<String, IssueDoc> issuesByKey = issuesByKey(it);
it.close();
@Test
public void iterator_over_issues() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
Map<String, IssueDoc> issuesByKey = issuesByKey(it);
it.close();
@Test
public void iterator_over_issue_from_project() {
dbTester.prepareDbUnit(getClass(), "many_projects.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, "THE_PROJECT_1");
+ IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), "THE_PROJECT_1");
Map<String, IssueDoc> issuesByKey = issuesByKey(it);
it.close();
assertThat(issuesByKey).hasSize(2);
}
- @Test
- public void iterator_over_issue_from_project_and_date() {
- dbTester.prepareDbUnit(getClass(), "many_projects.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 1_600_000_000_000L, "THE_PROJECT_1");
- Map<String, IssueDoc> issuesByKey = issuesByKey(it);
- it.close();
-
- assertThat(issuesByKey).hasSize(1);
- }
-
@Test
public void extract_directory_path() {
dbTester.prepareDbUnit(getClass(), "extract_directory_path.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
Map<String, IssueDoc> issuesByKey = issuesByKey(it);
it.close();
@Test
public void extract_file_path() {
dbTester.prepareDbUnit(getClass(), "extract_file_path.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
Map<String, IssueDoc> issuesByKey = issuesByKey(it);
it.close();
assertThat(issuesByKey.get("FGH").filePath()).isNull();
}
- @Test
- public void select_after_date() {
- dbTester.prepareDbUnit(getClass(), "shared.xml");
- IssueResultSetIterator it = IssueResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 1_420_000_000_000L, null);
-
- assertThat(it.hasNext()).isTrue();
- IssueDoc issue = it.next();
- assertThat(issue.key()).isEqualTo("DEF");
-
- assertThat(it.hasNext()).isFalse();
- it.close();
- }
-
private static Map<String, IssueDoc> issuesByKey(IssueResultSetIterator it) {
return Maps.uniqueIndex(it, new Function<IssueDoc, String>() {
@Override
private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
private IssueUpdater issueUpdater = new IssueUpdater(dbClient,
- new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(system2, dbClient, esTester.client())), mock(NotificationManager.class));
+ new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(dbClient, esTester.client())), mock(NotificationManager.class));
private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
private WsActionTester tester = new WsActionTester(
private IssueFieldsSetter issueFieldsSetter = new IssueFieldsSetter();
private IssueWorkflow issueWorkflow = new IssueWorkflow(new FunctionExecutor(issueFieldsSetter), issueFieldsSetter);
- private IssueStorage issueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(system2, dbClient, es.client()));
+ private IssueStorage issueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(dbClient, es.client()));
private NotificationManager notificationManager = mock(NotificationManager.class);
private List<Action> actions = new ArrayList<>();
private TransitionService transitionService = new TransitionService(userSession, workflow);
private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
private IssueUpdater issueUpdater = new IssueUpdater(dbClient,
- new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(system2, dbClient, esTester.client())), mock(NotificationManager.class));
+ new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(dbClient, esTester.client())), mock(NotificationManager.class));
private WsAction underTest = new DoTransitionAction(dbClient, userSession, new IssueFinder(dbClient, userSession), issueUpdater, transitionService, responseWriter);
private WsActionTester tester = new WsActionTester(underTest);
private WsActionTester tester = new WsActionTester(new SetSeverityAction(userSession, dbClient, new IssueFinder(dbClient, userSession), new IssueFieldsSetter(),
new IssueUpdater(dbClient,
- new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(system2, dbClient, esTester.client())), mock(NotificationManager.class)),
+ new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(dbClient, esTester.client())), mock(NotificationManager.class)),
responseWriter));
@Test
private WsActionTester tester = new WsActionTester(new SetTypeAction(userSession, dbClient, new IssueFinder(dbClient, userSession), new IssueFieldsSetter(),
new IssueUpdater(dbClient,
- new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(system2, dbClient, esTester.client())), mock(NotificationManager.class)),
+ new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient), dbClient, new IssueIndexer(dbClient, esTester.client())), mock(NotificationManager.class)),
responseWriter));
@Test
import org.junit.Test;
import org.sonar.api.config.MapSettings;
import org.sonar.api.resources.Qualifiers;
-import org.sonar.api.utils.System2;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.organization.OrganizationTesting;
import org.sonar.db.user.GroupDto;
import org.sonar.db.user.UserDto;
+import org.sonar.server.component.ws.FilterParser.Operator;
import org.sonar.server.es.EsTester;
import org.sonar.server.es.Facets;
import org.sonar.server.es.SearchIdResult;
import static org.sonar.db.component.ComponentTesting.newProjectDto;
import static org.sonar.db.user.GroupTesting.newGroupDto;
import static org.sonar.db.user.UserTesting.newUserDto;
-import static org.sonar.server.component.ws.FilterParser.Operator;
import static org.sonar.server.measure.index.ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES;
public class ProjectMeasuresIndexTest {
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
- private ProjectMeasuresIndexer projectMeasureIndexer = new ProjectMeasuresIndexer(System2.INSTANCE, null, es.client());
+ private ProjectMeasuresIndexer projectMeasureIndexer = new ProjectMeasuresIndexer(null, es.client());
private PermissionIndexerTester authorizationIndexerTester = new PermissionIndexerTester(es, projectMeasureIndexer);
private ProjectMeasuresIndex underTest = new ProjectMeasuresIndex(es.client(), new AuthorizationTypeSupport(userSession));
public DbTester dbTester = DbTester.create(system2);
private ComponentDbTester componentDbTester = new ComponentDbTester(dbTester);
- private ProjectMeasuresIndexer underTest = new ProjectMeasuresIndexer(system2, dbTester.getDbClient(), esTester.client());
+ private ProjectMeasuresIndexer underTest = new ProjectMeasuresIndexer(dbTester.getDbClient(), esTester.client());
@Test
public void index_on_startup() {
ProjectMeasuresIndexer indexer = spy(underTest);
- doNothing().when(indexer).index();
+ doNothing().when(indexer).indexOnStartup();
indexer.indexOnStartup();
verify(indexer).indexOnStartup();
}
@Test
public void index_nothing() {
- underTest.index();
+ underTest.indexOnStartup();
assertThat(esTester.countDocuments(INDEX_TYPE_PROJECT_MEASURES)).isZero();
}
componentDbTester.insertProjectAndSnapshot(newProjectDto(organizationDto));
componentDbTester.insertProjectAndSnapshot(newProjectDto(organizationDto));
- underTest.index();
+ underTest.indexOnStartup();
assertThat(esTester.countDocuments(INDEX_TYPE_PROJECT_MEASURES)).isEqualTo(3);
}
public void index_provisioned_projects() {
ComponentDto project = componentDbTester.insertProject();
- underTest.index();
+ underTest.indexOnStartup();
assertThat(esTester.getIds(INDEX_TYPE_PROJECT_MEASURES)).containsOnly(project.uuid());
}
componentDbTester.insertProjectAndSnapshot(project2);
ComponentDto project3 = newProjectDto(organizationDto);
componentDbTester.insertProjectAndSnapshot(project3);
- underTest.index();
+ underTest.indexOnStartup();
underTest.deleteProject(project1.uuid());
public void does_nothing_when_deleting_unknown_project() throws Exception {
ComponentDto project = newProjectDto(dbTester.organizations().insert());
componentDbTester.insertProjectAndSnapshot(project);
- underTest.index();
+ underTest.indexOnStartup();
underTest.deleteProject("UNKNOWN");
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.api.web.UserRole.ADMIN;
import static org.sonar.api.web.UserRole.USER;
-import static org.sonar.server.permission.index.FooIndexDefinition.FOO_INDEX;
public class PermissionIndexerTest {
}
@Test
- public void indexAllIfEmpty_does_nothing_if_no_data() {
- underTest.indexAllIfEmpty();
-
- assertThat(esTester.countDocuments(FOO_INDEX, "authorization")).isZero();
- assertThat(fooIndex.hasAccessToProject("a_project")).isFalse();
- }
-
- @Test
- public void indexAllIfEmpty_grants_access_to_user() {
+ public void initializeOnStartup_grants_access_to_user() {
ComponentDto project = createAndIndexProject();
UserDto user1 = userDbTester.insertUser();
UserDto user2 = userDbTester.insertUser();
userDbTester.insertProjectPermissionOnUser(user1, USER, project);
userDbTester.insertProjectPermissionOnUser(user2, ADMIN, project);
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
// anonymous
verifyAnyoneNotAuthorized(project);
}
@Test
- public void indexAllIfEmpty_grants_access_to_group() {
+ public void initializeOnStartup_grants_access_to_group() {
ComponentDto project = createAndIndexProject();
UserDto user1 = userDbTester.insertUser();
UserDto user2 = userDbTester.insertUser();
userDbTester.insertProjectPermissionOnGroup(group1, USER, project);
userDbTester.insertProjectPermissionOnGroup(group2, ADMIN, project);
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
// anonymous
verifyAnyoneNotAuthorized(project);
}
@Test
- public void indexAllIfEmpty_grants_access_to_user_and_group() {
+ public void initializeOnStartup_grants_access_to_user_and_group() {
ComponentDto project = createAndIndexProject();
UserDto user1 = userDbTester.insertUser();
UserDto user2 = userDbTester.insertUser();
userDbTester.insertProjectPermissionOnUser(user1, USER, project);
userDbTester.insertProjectPermissionOnGroup(group, USER, project);
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
// anonymous
verifyAnyoneNotAuthorized(project);
}
@Test
- public void indexAllIfEmpty_does_not_grant_access_to_anybody() {
+ public void initializeOnStartup_does_not_grant_access_to_anybody() {
ComponentDto project = createAndIndexProject();
UserDto user = userDbTester.insertUser();
GroupDto group = userDbTester.insertGroup();
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
verifyAnyoneNotAuthorized(project);
verifyNotAuthorized(project, user);
}
@Test
- public void indexAllIfEmpty_grants_access_to_anyone() {
+ public void initializeOnStartup_grants_access_to_anyone() {
ComponentDto project = createAndIndexProject();
UserDto user = userDbTester.insertUser();
GroupDto group = userDbTester.insertGroup();
userDbTester.insertProjectPermissionOnAnyone(USER, project);
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
verifyAnyoneAuthorized(project);
verifyAuthorized(project, user);
}
@Test
- public void indexAllIfEmpty_grants_access_on_many_projects() {
+ public void initializeOnStartup_grants_access_on_many_projects() {
UserDto user1 = userDbTester.insertUser();
UserDto user2 = userDbTester.insertUser();
ComponentDto project = null;
userDbTester.insertProjectPermissionOnUser(user1, USER, project);
}
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
verifyAnyoneNotAuthorized(project);
verifyAuthorized(project, user1);
ComponentDto project2 = createAndIndexProject();
userDbTester.insertProjectPermissionOnAnyone(USER, project1);
userDbTester.insertProjectPermissionOnAnyone(USER, project2);
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
assertThat(esTester.countDocuments(INDEX_TYPE_FOO_AUTH)).isEqualTo(2);
underTest.deleteProject(project1.uuid());
ComponentDto project = createAndIndexProject();
UserDto user1 = userDbTester.insertUser();
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
verifyAnyoneNotAuthorized(project);
verifyNotAuthorized(project, user1);
userDbTester.insertProjectPermissionOnAnyone(USER, projectOnOrg1);
userDbTester.insertProjectPermissionOnUser(user, USER, projectOnOrg2);
- underTest.indexAllIfEmpty();
+ underTest.indexOnStartup();
verifyAnyoneAuthorized(projectOnOrg1);
verifyAnyoneNotAuthorized(projectOnOrg2);
import org.sonar.server.ws.WsActionTester;
import org.sonar.test.JsonAssert;
import org.sonarqube.ws.MediaTypes;
+import org.sonarqube.ws.QualityProfiles.CreateWsResponse;
+import org.sonarqube.ws.QualityProfiles.CreateWsResponse.QualityProfile;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
-import static org.sonar.server.language.LanguageTesting.newLanguages;
import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_PROFILES;
-import static org.sonarqube.ws.QualityProfiles.CreateWsResponse;
-import static org.sonarqube.ws.QualityProfiles.CreateWsResponse.QualityProfile;
+import static org.sonar.server.language.LanguageTesting.newLanguages;
import static org.sonarqube.ws.QualityProfiles.CreateWsResponse.parseFrom;
public class CreateActionTest {
assertThat(rule.updatedAt()).isEqualTo(1600000000000L);
}
- @Test
- public void select_after_date() {
- dbClient.ruleDao().insert(dbSession, templateRule);
- dbClient.ruleDao().insert(dbSession, customRule);
- dbSession.commit();
-
- RuleResultSetIterator it = RuleResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 1_900_000_000_000L);
-
- assertThat(it.hasNext()).isTrue();
- RuleDoc issue = it.next();
- assertThat(issue.key()).isEqualTo(RuleKey.of("xoo", "S002"));
-
- assertThat(it.hasNext()).isFalse();
- it.close();
- }
-
@Test
public void iterator_over_rules() {
dbClient.ruleDao().insert(dbSession, templateRule);
@Rule
public DbTester db = DbTester.create(system2);
- private TestIndexer underTest = new TestIndexer(system2, db.getDbClient(), es.client());
+ private TestIndexer underTest = new TestIndexer(db.getDbClient(), es.client());
@Test
public void index_on_startup() {
TestIndexer indexer = spy(underTest);
- doNothing().when(indexer).index();
+ doNothing().when(indexer).indexOnStartup();
indexer.indexOnStartup();
verify(indexer).indexOnStartup();
}
db.prepareDbUnit(getClass(), "db.xml");
TestTesting.updateDataColumn(db.getSession(), "FILE_UUID", TestTesting.newRandomTests(3));
- underTest.index();
+ underTest.indexOnStartup();
assertThat(countDocuments()).isEqualTo(3);
}
public void traverse_db() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
TestTesting.updateDataColumn(dbTester.getSession(), "F1", newFakeTests(3));
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
FileSourcesUpdaterHelper.Row row = underTest.next();
assertThat(row.getProjectUuid()).isEqualTo("P1");
.setName("N1")
.build());
TestTesting.updateDataColumn(dbTester.getSession(), "F1", tests);
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
FileSourcesUpdaterHelper.Row row = underTest.next();
FIELD_COVERED_FILES);
}
- @Test
- public void filter_by_date() {
- dbTester.prepareDbUnit(getClass(), "shared.xml");
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 2000000000000L, null);
-
- assertThat(underTest.hasNext()).isFalse();
- }
-
@Test
public void filter_by_project() throws Exception {
dbTester.prepareDbUnit(getClass(), "filter_by_project.xml");
TestTesting.updateDataColumn(dbTester.getSession(), "F1", newFakeTests(1));
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, "P1");
+ underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), "P1");
FileSourcesUpdaterHelper.Row row = underTest.next();
assertThat(row.getProjectUuid()).isEqualTo("P1");
assertThat(underTest.hasNext()).isFalse();
}
- @Test
- public void filter_by_project_and_date() throws Exception {
- dbTester.prepareDbUnit(getClass(), "filter_by_project_and_date.xml");
- TestTesting.updateDataColumn(dbTester.getSession(), "F1", newFakeTests(1));
-
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 1400000000000L, "P1");
-
- FileSourcesUpdaterHelper.Row row = underTest.next();
- assertThat(row.getProjectUuid()).isEqualTo("P1");
- assertThat(row.getFileUuid()).isEqualTo("F1");
-
- // File F2 is not returned
- assertThat(underTest.hasNext()).isFalse();
- }
-
@Test
public void read_does_not_fail_if_corrupted_data() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
TestTesting.updateDataColumn(dbTester.getSession(), "F1", "THIS_IS_NOT_PROTOBUF".getBytes());
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
FileSourcesUpdaterHelper.Row row = underTest.next();
assertThat(row.getFileUuid()).isEqualTo("F1");
assertThat(row.getUpdateRequests()).isEmpty();
dbTester.prepareDbUnit(getClass(), "shared.xml");
TestTesting.updateDataColumn(dbTester.getSession(), "F1", (byte[])null);
- underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L, null);
+ underTest = TestResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), null);
FileSourcesUpdaterHelper.Row row = underTest.next();
assertThat(row.getFileUuid()).isEqualTo("F1");
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.config.MapSettings;
-import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
private DbClient dbClient = db.getDbClient();
private TestIndex testIndex = new TestIndex(es.client());
- private TestIndexer testIndexer = new TestIndexer(System2.INSTANCE, db.getDbClient(), es.client());
+ private TestIndexer testIndexer = new TestIndexer(db.getDbClient(), es.client());
private ComponentDto project;
private ComponentDto mainFile;
.setFileUuid(testFile.uuid())
.setTestData(asList(tests)));
db.commit();
- testIndexer.index();
+ testIndexer.indexOnStartup();
}
private static ListResponse call(TestRequest request) {
private ArgumentCaptor<NewUserHandler.Context> newUserHandler = ArgumentCaptor.forClass(NewUserHandler.Context.class);
private Settings settings = new MapSettings();
private DbSession session = db.getSession();
- private UserIndexer userIndexer = new UserIndexer(system2, dbClient, es.client());
+ private UserIndexer userIndexer = new UserIndexer(dbClient, es.client());
private OrganizationCreation organizationCreation = mock(OrganizationCreation.class);
private UserUpdater underTest = new UserUpdater(newUserNotifier, settings, dbClient, userIndexer, system2, TestDefaultOrganizationProvider.from(db), organizationCreation);
}
private UserIndexer createIndexer() {
- return new UserIndexer(system2, dbTester.getDbClient(), esTester.client());
+ return new UserIndexer(dbTester.getDbClient(), esTester.client());
}
}
@Test
public void iterator_over_users() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- UserResultSetIterator it = UserResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 0L);
+ UserResultSetIterator it = UserResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession());
Map<String, UserDoc> usersByLogin = Maps.uniqueIndex(it, new Function<UserDoc, String>() {
@Override
public String apply(UserDoc user) {
assertThat(user3.createdAt()).isEqualTo(1500000000000L);
assertThat(user3.updatedAt()).isEqualTo(1550000000000L);
}
-
- @Test
- public void select_after_date() {
- dbTester.prepareDbUnit(getClass(), "shared.xml");
- UserResultSetIterator it = UserResultSetIterator.create(dbTester.getDbClient(), dbTester.getSession(), 1520000000000L);
-
- assertThat(it.hasNext()).isTrue();
- UserDoc user = it.next();
- assertThat(user.login()).isEqualTo("user3");
-
- assertThat(it.hasNext()).isFalse();
- it.close();
- }
}
public UserSessionRule userSessionRule = UserSessionRule.standalone().logIn();
private UserUpdater userUpdater = new UserUpdater(mock(NewUserNotifier.class), new MapSettings(), db.getDbClient(),
- new UserIndexer(System2.INSTANCE, db.getDbClient(), esTester.client()),
+ new UserIndexer(db.getDbClient(), esTester.client()),
System2.INSTANCE,
TestDefaultOrganizationProvider.from(db),
mock(OrganizationCreation.class));
public ExpectedException expectedException = ExpectedException.none();
private UserIndex index = new UserIndex(esTester.client());
- private UserIndexer userIndexer = new UserIndexer(system2, db.getDbClient(), esTester.client());
+ private UserIndexer userIndexer = new UserIndexer(db.getDbClient(), esTester.client());
private GroupDto defaultGroupInDefaultOrg;
private OrganizationCreation organizationCreation = mock(OrganizationCreation.class);
@Before
public void setUp() {
- userIndexer = new UserIndexer(system2, dbClient, esTester.client());
+ userIndexer = new UserIndexer(dbClient, esTester.client());
index = new UserIndex(esTester.client());
- userIndexer = new UserIndexer(system2, dbClient, esTester.client());
+ userIndexer = new UserIndexer(dbClient, esTester.client());
ws = new WsActionTester(new DeactivateAction(
dbClient, userIndexer, userSession, new UserJsonWriter(userSession), defaultOrganizationProvider));
}
private DbClient dbClient = db.getDbClient();
private DbSession dbSession = db.getSession();
private UserIndex index = new UserIndex(esTester.client());
- private UserIndexer userIndexer = new UserIndexer(system2, dbClient, esTester.client());
+ private UserIndexer userIndexer = new UserIndexer(dbClient, esTester.client());
private WsTester ws = new WsTester(new UsersWs(new SearchAction(index, dbClient, new UserJsonWriter(userSession))));
@Test
dbClient.groupDao().insert(session, newGroupDto().setName("sonar-users"));
session.commit();
- userIndexer = new UserIndexer(system2, dbClient, esTester.client());
+ userIndexer = new UserIndexer(dbClient, esTester.client());
tester = new WsTester(new UsersWs(new UpdateAction(
new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2, defaultOrganizationProvider, ORGANIZATION_CREATION_NOT_USED_FOR_UPDATE),
userSessionRule,
private DbClient dbClient = dbTester.getDbClient();
private DbSession dbSession = dbTester.getSession();
- private IssueIndexer issueIndexer = new IssueIndexer(system2, dbClient, esTester.client());
+ private IssueIndexer issueIndexer = new IssueIndexer(dbClient, esTester.client());
private PermissionIndexer permissionIndexer = new PermissionIndexer(dbClient, esTester.client(), issueIndexer);
- private ViewIndexer underTest = new ViewIndexer(system2, dbClient, esTester.client());
+ private ViewIndexer underTest = new ViewIndexer(dbClient, esTester.client());
@Test
public void index_on_startup() {
ViewIndexer indexer = spy(underTest);
- doNothing().when(indexer).index();
+ doNothing().when(indexer).indexOnStartup();
indexer.indexOnStartup();
verify(indexer).indexOnStartup();
}
@Test
public void index_nothing() {
- underTest.index();
+ underTest.indexOnStartup();
assertThat(esTester.countDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW)).isEqualTo(0L);
}
public void index() {
dbTester.prepareDbUnit(getClass(), "index.xml");
- underTest.index();
+ underTest.indexOnStartup();
List<ViewDoc> docs = esTester.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
assertThat(docs).hasSize(4);
esTester.putDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW,
new ViewDoc().setUuid("ABCD").setProjects(newArrayList("BCDE")));
- underTest.index();
+ underTest.indexOnStartup();
// ... But they shouldn't be indexed
assertThat(esTester.countDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW)).isEqualTo(1L);
@Test
public void clear_views_lookup_cache_on_index_view_uuid() {
IssueIndex issueIndex = new IssueIndex(esTester.client(), System2.INSTANCE, userSessionRule, new AuthorizationTypeSupport(userSessionRule));
- IssueIndexer issueIndexer = new IssueIndexer(system2, dbClient, esTester.client());
+ IssueIndexer issueIndexer = new IssueIndexer(dbClient, esTester.client());
String viewUuid = "ABCD";
projects / sonarqube.git / commitdiff