+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2018 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program 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.
- *
- * This program 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.server.component.index;
-
-import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.server.es.EsTester;
-
-public class NewTest {
-
- @Rule
- public EsTester es = EsTester.core();
-
- @Test
- public void name() {
- IndicesExistsResponse x = es.client().prepareIndicesExist("components").get();
- System.out.println(x.isExists());
- IndicesExistsResponse x2 = es.client().prepareIndicesExist("components").get();
- System.out.println(x2.isExists());
- }
-}
*/
public <E extends BaseDoc> List<E> getDocuments(IndexType indexType, final Class<E> docClass) {
List<SearchHit> hits = getDocuments(indexType);
- return newArrayList(Collections2.transform(hits, input -> {
+ return new ArrayList<>(Collections2.transform(hits, input -> {
try {
return (E) ConstructorUtils.invokeConstructor(docClass, input.getSource());
} catch (Exception e) {
* Get a list of a specific field from all indexed documents.
*/
public <T> List<T> getDocumentFieldValues(IndexType indexType, final String fieldNameToReturn) {
- return newArrayList(Iterables.transform(getDocuments(indexType), input -> (T) input.sourceAsMap().get(fieldNameToReturn)));
+ return getDocuments(indexType)
+ .stream()
+ .map(input -> (T) input.getSourceAsMap().get(fieldNameToReturn))
+ .collect(Collectors.toList());
}
public List<String> getIds(IndexType indexType) {
- return getDocuments(indexType).stream().map(SearchHit::id).collect(Collectors.toList());
+ return getDocuments(indexType).stream().map(SearchHit::getId).collect(Collectors.toList());
}
public void lockWrites(IndexType index) {
public class ProxyClearCacheRequestBuilderTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public LogTester logTester = new LogTester();
@Test
public void clear_cache() {
- ClearIndicesCacheRequestBuilder requestBuilder = esTester.client().prepareClearCache();
+ ClearIndicesCacheRequestBuilder requestBuilder = es.client().prepareClearCache();
requestBuilder.get();
}
@Test
public void to_string() {
- assertThat(esTester.client().prepareClearCache().toString()).isEqualTo("ES clear cache request");
- assertThat(esTester.client().prepareClearCache("rules").toString()).isEqualTo("ES clear cache request on indices 'rules'");
- assertThat(esTester.client().prepareClearCache().setFields("key").toString()).isEqualTo("ES clear cache request on fields 'key'");
- assertThat(esTester.client().prepareClearCache().setFieldDataCache(true).toString()).isEqualTo("ES clear cache request with field data cache");
- assertThat(esTester.client().prepareClearCache().setRequestCache(true).toString()).isEqualTo("ES clear cache request with request cache");
+ assertThat(es.client().prepareClearCache().toString()).isEqualTo("ES clear cache request");
+ assertThat(es.client().prepareClearCache("rules").toString()).isEqualTo("ES clear cache request on indices 'rules'");
+ assertThat(es.client().prepareClearCache().setFields("key").toString()).isEqualTo("ES clear cache request on fields 'key'");
+ assertThat(es.client().prepareClearCache().setFieldDataCache(true).toString()).isEqualTo("ES clear cache request with field data cache");
+ assertThat(es.client().prepareClearCache().setRequestCache(true).toString()).isEqualTo("ES clear cache request with request cache");
}
@Test
public void trace_logs() {
logTester.setLevel(LoggerLevel.TRACE);
- ClearIndicesCacheRequestBuilder requestBuilder = esTester.client().prepareClearCache();
+ ClearIndicesCacheRequestBuilder requestBuilder = es.client().prepareClearCache();
requestBuilder.get();
assertThat(logTester.logs()).hasSize(1);
@Test
public void no_trace_logs() {
logTester.setLevel(LoggerLevel.DEBUG);
- ClearIndicesCacheRequestBuilder requestBuilder = esTester.client().prepareClearCache();
+ ClearIndicesCacheRequestBuilder requestBuilder = es.client().prepareClearCache();
requestBuilder.get();
assertThat(logTester.logs()).isEmpty();
@Test
public void get_with_string_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareClearCache().get("1");
+ es.client().prepareClearCache().get("1");
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void get_with_time_value_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareClearCache().get(TimeValue.timeValueMinutes(1));
+ es.client().prepareClearCache().get(TimeValue.timeValueMinutes(1));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void execute_should_throw_an_unsupported_operation_exception() {
try {
- esTester.client().prepareClearCache().execute();
+ es.client().prepareClearCache().execute();
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnsupportedOperationException.class).hasMessage("execute() should not be called as it's used for asynchronous");
public class ProxyWebServerHealthRequestBuilderTest {
@Rule
- public EsTester esTester = EsTester.custom();
+ public EsTester es = EsTester.custom();
@Rule
public LogTester logTester = new LogTester();
@Test
public void state() {
- ClusterHealthRequestBuilder requestBuilder = esTester.client().prepareHealth();
+ ClusterHealthRequestBuilder requestBuilder = es.client().prepareHealth();
ClusterHealthResponse state = requestBuilder.get();
assertThat(state.getStatus()).isEqualTo(ClusterHealthStatus.GREEN);
}
@Test
public void to_string() {
- assertThat(esTester.client().prepareHealth("rules").toString()).isEqualTo("ES cluster health request on indices 'rules'");
- assertThat(esTester.client().prepareHealth().toString()).isEqualTo("ES cluster health request");
+ assertThat(es.client().prepareHealth("rules").toString()).isEqualTo("ES cluster health request on indices 'rules'");
+ assertThat(es.client().prepareHealth().toString()).isEqualTo("ES cluster health request");
}
@Test
public void trace_logs() {
logTester.setLevel(LoggerLevel.TRACE);
- ClusterHealthRequestBuilder requestBuilder = esTester.client().prepareHealth();
+ ClusterHealthRequestBuilder requestBuilder = es.client().prepareHealth();
ClusterHealthResponse state = requestBuilder.get();
assertThat(state.getStatus()).isEqualTo(ClusterHealthStatus.GREEN);
@Test
public void get_with_string_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareHealth().get("1");
+ es.client().prepareHealth().get("1");
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void get_with_time_value_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareHealth().get(TimeValue.timeValueMinutes(1));
+ es.client().prepareHealth().get(TimeValue.timeValueMinutes(1));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void execute_should_throw_an_unsupported_operation_exception() {
try {
- esTester.client().prepareHealth().execute();
+ es.client().prepareHealth().execute();
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnsupportedOperationException.class).hasMessage("execute() should not be called as it's used for asynchronous");
public class ProxyWebServerStateRequestBuilderTest {
@Rule
- public EsTester esTester = EsTester.custom();
+ public EsTester es = EsTester.custom();
@Rule
public LogTester logTester = new LogTester();
@Test
public void state() {
- ClusterStateRequestBuilder requestBuilder = esTester.client().prepareState();
+ ClusterStateRequestBuilder requestBuilder = es.client().prepareState();
requestBuilder.get();
}
@Test
public void to_string() {
- assertThat(esTester.client().prepareState().setIndices("rules").toString()).isEqualTo("ES cluster state request on indices 'rules'");
- assertThat(esTester.client().prepareState().toString()).isEqualTo("ES cluster state request");
+ assertThat(es.client().prepareState().setIndices("rules").toString()).isEqualTo("ES cluster state request on indices 'rules'");
+ assertThat(es.client().prepareState().toString()).isEqualTo("ES cluster state request");
}
@Test
public void trace_logs() {
logTester.setLevel(LoggerLevel.TRACE);
- ClusterStateRequestBuilder requestBuilder = esTester.client().prepareState();
+ ClusterStateRequestBuilder requestBuilder = es.client().prepareState();
requestBuilder.get();
assertThat(logTester.logs()).hasSize(1);
@Test
public void get_with_string_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareState().get("1");
+ es.client().prepareState().get("1");
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void get_with_time_value_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareState().get(TimeValue.timeValueMinutes(1));
+ es.client().prepareState().get(TimeValue.timeValueMinutes(1));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void execute_should_throw_an_unsupported_operation_exception() {
try {
- esTester.client().prepareState().execute();
+ es.client().prepareState().execute();
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnsupportedOperationException.class).hasMessage("execute() should not be called as it's used for asynchronous");
public class ProxyWebServerStatsRequestBuilderTest {
@Rule
- public EsTester esTester = EsTester.custom();
+ public EsTester es = EsTester.custom();
@Rule
public LogTester logTester = new LogTester();
@Test
public void stats() {
- ClusterStatsRequestBuilder requestBuilder = esTester.client().prepareClusterStats();
+ ClusterStatsRequestBuilder requestBuilder = es.client().prepareClusterStats();
requestBuilder.get();
}
@Test
public void to_string() {
- assertThat(esTester.client().prepareClusterStats().setNodesIds("node1").toString()).isEqualTo("ES cluster stats request on nodes 'node1'");
- assertThat(esTester.client().prepareClusterStats().toString()).isEqualTo("ES cluster stats request");
+ assertThat(es.client().prepareClusterStats().setNodesIds("node1").toString()).isEqualTo("ES cluster stats request on nodes 'node1'");
+ assertThat(es.client().prepareClusterStats().toString()).isEqualTo("ES cluster stats request");
}
@Test
public void trace_logs() {
logTester.setLevel(LoggerLevel.TRACE);
- ClusterStatsRequestBuilder requestBuilder = esTester.client().prepareClusterStats();
+ ClusterStatsRequestBuilder requestBuilder = es.client().prepareClusterStats();
requestBuilder.get();
assertThat(logTester.logs()).hasSize(1);
}
@Test
public void get_with_string_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareClusterStats().get("1");
+ es.client().prepareClusterStats().get("1");
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void get_with_time_value_timeout_is_not_yet_implemented() {
try {
- esTester.client().prepareClusterStats().get(TimeValue.timeValueMinutes(1));
+ es.client().prepareClusterStats().get(TimeValue.timeValueMinutes(1));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("Not yet implemented");
@Test
public void execute_should_throw_an_unsupported_operation_exception() {
try {
- esTester.client().prepareClusterStats().execute();
+ es.client().prepareClusterStats().execute();
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnsupportedOperationException.class).hasMessage("execute() should not be called as it's used for asynchronous");
public class EsStatusClusterCheckTest {
@Rule
- public EsTester esTester = EsTester.custom();
+ public EsTester es = EsTester.custom();
private final Random random = new Random();
- private EsStatusClusterCheck underTest = new EsStatusClusterCheck(esTester.client());
+ private EsStatusClusterCheck underTest = new EsStatusClusterCheck(es.client());
@Test
public void check_ignores_NodeHealth_arg_and_returns_RED_with_cause_if_an_exception_occurs_checking_ES_cluster_status() {
public class EsStatusNodeCheckTest {
@Rule
- public EsTester esTester = EsTester.custom();
+ public EsTester es = EsTester.custom();
- private EsStatusNodeCheck underTest = new EsStatusNodeCheck(esTester.client());
+ private EsStatusNodeCheck underTest = new EsStatusNodeCheck(es.client());
@Test
public void check_ignores_NodeHealth_arg_and_returns_RED_with_cause_if_an_exception_occurs_checking_ES_cluster_status() {
public DbTester dbTester = DbTester.create(system2);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
private DbClient dbClient = dbTester.getDbClient();
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
private NotificationManager notificationManager = mock(NotificationManager.class);
private ArgumentCaptor<IssueChangeNotification> notificationArgumentCaptor = ArgumentCaptor.forClass(IssueChangeNotification.class);
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
private TestIssueChangePostProcessor issueChangePostProcessor = new TestIssueChangePostProcessor();
private IssueUpdater underTest = new IssueUpdater(dbClient,
new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer), notificationManager, issueChangePostProcessor);
import java.util.List;
import org.junit.Rule;
import org.junit.Test;
-import org.sonar.api.config.internal.MapSettings;
import org.sonar.api.issue.Issue;
import org.sonar.api.utils.System2;
import org.sonar.db.component.ComponentDto;
public class IssueIndexProjectStatisticsTest {
private System2 system2 = mock(System2.class);
- private MapSettings settings = new MapSettings();
@Rule
public EsTester es = EsTester.core();
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private IssueDbTester issueDbTester = new IssueDbTester(dbTester);
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
private ServerIssueStorage serverIssueStorage = new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer);
private TestIssueChangePostProcessor issueChangePostProcessor = new TestIssueChangePostProcessor();
private IssueUpdater issueUpdater = new IssueUpdater(dbClient, serverIssueStorage, mock(NotificationManager.class), issueChangePostProcessor);
public DbTester dbTester = DbTester.create(system2);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private IssueWorkflow workflow = new IssueWorkflow(new FunctionExecutor(updater), updater);
private TransitionService transitionService = new TransitionService(userSession, workflow);
private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
private TestIssueChangePostProcessor issueChangePostProcessor = new TestIssueChangePostProcessor();
private IssueUpdater issueUpdater = new IssueUpdater(dbClient,
new ServerIssueStorage(system2, new DefaultRuleFinder(dbClient, defaultOrganizationProvider), dbClient, issueIndexer), mock(NotificationManager.class),
@Rule
public DbTester dbTester = DbTester.create();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
private ArgumentCaptor<SearchResponseData> preloadedSearchResponseDataCaptor = ArgumentCaptor.forClass(SearchResponseData.class);
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
private TestIssueChangePostProcessor issueChangePostProcessor = new TestIssueChangePostProcessor();
private WsActionTester tester = new WsActionTester(new SetSeverityAction(userSession, dbClient, new IssueFinder(dbClient, userSession), new IssueFieldsSetter(),
new IssueUpdater(dbClient,
@Rule
public DbTester db = DbTester.create();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private DbClient dbClient = db.getDbClient();
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
private ArgumentCaptor<SearchResponseData> preloadedSearchResponseDataCaptor = ArgumentCaptor.forClass(SearchResponseData.class);
private TestIssueChangePostProcessor issueChangePostProcessor = new TestIssueChangePostProcessor();
@Rule
public DbTester dbTester = DbTester.create();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private OperationResponseWriter responseWriter = mock(OperationResponseWriter.class);
private ArgumentCaptor<SearchResponseData> preloadedSearchResponseDataCaptor = ArgumentCaptor.forClass(SearchResponseData.class);
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
private TestIssueChangePostProcessor issueChangePostProcessor = new TestIssueChangePostProcessor();
private WsActionTester tester = new WsActionTester(new SetTypeAction(userSession, dbClient, new IssueFinder(dbClient, userSession), new IssueFieldsSetter(),
new IssueUpdater(dbClient,
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
-import org.sonar.api.config.internal.MapSettings;
import org.sonar.api.server.ws.WebService.Action;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.System2;
public class TagsActionTest {
- private MapSettings settings = new MapSettings();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
@Rule
public EsTester es = EsTester.core();
- DbClient dbClient = db.getDbClient();
- ComponentDto project;
-
- final DbSession dbSession = db.getSession();
-
- WsTester ws;
+ private DbClient dbClient = db.getDbClient();
+ private ComponentDto project;
+ private final DbSession dbSession = db.getSession();
+ private WsTester ws;
@Before
public void setUp() {
@Rule
public DbTester db = DbTester.create(System2.INSTANCE);
- final DbClient dbClient = db.getDbClient();
- final DbSession dbSession = db.getSession();
-
- WsTester ws;
- ComponentDto defaultProject;
+ private final DbClient dbClient = db.getDbClient();
+ private final DbSession dbSession = db.getSession();
+ private WsTester ws;
+ private ComponentDto defaultProject;
@Before
public void setUp() throws Exception {
@Rule
public EsTester es = EsTester.core();
- WsTester ws;
- DbClient dbClient = db.getDbClient();
- DbSession dbSession = db.getSession();
- ComponentDto defaultProject;
+ private WsTester ws;
+ private DbClient dbClient = db.getDbClient();
+ private DbSession dbSession = db.getSession();
+ private ComponentDto defaultProject;
@Before
public void setUp() {
public DbTester db = DbTester.create(new AlwaysIncreasingSystem2());
@Rule
- public EsTester esTester = EsTester.custom(new FooIndexDefinition());
+ public EsTester es = EsTester.custom(new FooIndexDefinition());
@Rule
public ExpectedException expectedException = ExpectedException.none();
protected PermissionUpdater newPermissionUpdater() {
return new PermissionUpdater(
- new ProjectIndexersImpl(new PermissionIndexer(db.getDbClient(), esTester.client())),
+ new ProjectIndexersImpl(new PermissionIndexer(db.getDbClient(), es.client())),
new UserPermissionChanger(db.getDbClient()),
new GroupPermissionChanger(db.getDbClient()));
}
public class BackendCleanupTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
- private BackendCleanup underTest = new BackendCleanup(esTester.client(), dbTester.getDbClient());
+ private BackendCleanup underTest = new BackendCleanup(es.client(), dbTester.getDbClient());
private OrganizationDto organization;
@Before
@Test
public void clear_indexes() {
- esTester.putDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDocTesting.newDoc());
- esTester.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
- esTester.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
+ es.putDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDocTesting.newDoc());
+ es.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
+ es.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
underTest.clearIndexes();
- assertThat(esTester.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(0);
- assertThat(esTester.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isEqualTo(0);
+ assertThat(es.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(0);
+ assertThat(es.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isEqualTo(0);
}
@Test
public void clear_all() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- esTester.putDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDocTesting.newDoc());
- esTester.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
- esTester.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
+ es.putDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDocTesting.newDoc());
+ es.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
+ es.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
underTest.clearAll();
- assertThat(esTester.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(0);
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(0);
- assertThat(esTester.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isEqualTo(0);
+ assertThat(es.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(0);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(0);
+ assertThat(es.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isEqualTo(0);
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(0);
assertThat(dbTester.countRowsOfTable("snapshots")).isEqualTo(0);
@Test
public void reset_data() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- esTester.putDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDocTesting.newDoc());
- esTester.putDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, new ViewDoc().setUuid("CDEF").setProjects(newArrayList("DEFG")));
- esTester.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
- esTester.putDocuments(ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES, new ProjectMeasuresDoc()
+ es.putDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE, IssueDocTesting.newDoc());
+ es.putDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, new ViewDoc().setUuid("CDEF").setProjects(newArrayList("DEFG")));
+ es.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
+ es.putDocuments(ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES, new ProjectMeasuresDoc()
.setId("PROJECT")
.setKey("Key")
.setName("Name"));
- esTester.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
+ es.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
underTest.resetData();
assertThat(dbTester.countRowsOfTable("projects")).isZero();
assertThat(dbTester.countRowsOfTable("snapshots")).isZero();
assertThat(dbTester.countRowsOfTable("properties")).isZero();
- assertThat(esTester.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isZero();
- assertThat(esTester.countDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW)).isZero();
- assertThat(esTester.countDocuments(ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES)).isZero();
- assertThat(esTester.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isZero();
+ assertThat(es.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isZero();
+ assertThat(es.countDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW)).isZero();
+ assertThat(es.countDocuments(ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES)).isZero();
+ assertThat(es.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isZero();
// Rules should not be removed
assertThat(dbTester.countRowsOfTable("rules")).isEqualTo(1);
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
}
private static RuleDoc newRuleDoc() {
public class EsIndexesSectionTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
- private EsIndexesSection underTest = new EsIndexesSection(esTester.client());
+ private EsIndexesSection underTest = new EsIndexesSection(es.client());
@Test
public void name() {
public class EsStateSectionTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
- private EsStateSection underTest = new EsStateSection(esTester.client());
+ private EsStateSection underTest = new EsStateSection(es.client());
@Test
public void name() {
public class EsClusterStateSectionTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
- private EsClusterStateSection underTest = new EsClusterStateSection(esTester.client());
+ private EsClusterStateSection underTest = new EsClusterStateSection(es.client());
@Test
public void test_name() {
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
@Rule
- public EsTester esTester = EsTester.custom(new FooIndexDefinition());
+ public EsTester es = EsTester.custom(new FooIndexDefinition());
@Rule
- public UserSessionRule userSessionRule = UserSessionRule.standalone()
- .logIn();
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().logIn();
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Rule
public DbTester db = new DbTester(System2.INSTANCE, null);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
public void setUp() {
dbClient = db.getDbClient();
dbSession = db.getSession();
- EsClient esClient = esTester.client();
+ EsClient esClient = es.client();
ruleIndex = new RuleIndex(esClient, System2.INSTANCE);
ruleIndexer = new RuleIndexer(esClient, dbClient);
activeRuleIndexer = new ActiveRuleIndexer(dbClient, esClient);
public UserSessionRule userSessionRule = UserSessionRule.standalone()
.logIn().setRoot();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public DbTester dbTester = DbTester.create();
private DbClient dbClient = dbTester.getDbClient();
private DbSession dbSession = dbTester.getSession();
- private RuleIndex ruleIndex = new RuleIndex(esTester.client(), System2.INSTANCE);
- private RuleIndexer ruleIndexer = new RuleIndexer(esTester.client(), dbClient);
- private ActiveRuleIndexer activeRuleIndexer = new ActiveRuleIndexer(dbClient, esTester.client());
+ private RuleIndex ruleIndex = new RuleIndex(es.client(), System2.INSTANCE);
+ private RuleIndexer ruleIndexer = new RuleIndexer(es.client(), dbClient);
+ private ActiveRuleIndexer activeRuleIndexer = new ActiveRuleIndexer(dbClient, es.client());
private TypeValidations typeValidations = new TypeValidations(emptyList());
private RuleActivator ruleActivator = new RuleActivator(System2.INSTANCE, dbClient, typeValidations, userSessionRule);
private QProfileRules qProfileRules = new QProfileRulesImpl(dbClient, ruleActivator, ruleIndex, activeRuleIndexer);
@org.junit.Rule
public DbTester dbTester = DbTester.create(system);
@org.junit.Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@org.junit.Rule
public LogTester logTester = new LogTester();
@Before
public void before() {
when(system.now()).thenReturn(DATE1.getTime());
- ruleIndexer = new RuleIndexer(esTester.client(), dbClient);
- ruleIndex = new RuleIndex(esTester.client(), system);
- activeRuleIndexer = new ActiveRuleIndexer(dbClient, esTester.client());
+ ruleIndexer = new RuleIndexer(es.client(), dbClient);
+ ruleIndex = new RuleIndex(es.client(), system);
+ activeRuleIndexer = new ActiveRuleIndexer(dbClient, es.client());
defaultOrganization = dbTester.getDefaultOrganization();
}
.containsOnly(RuleStatus.READY);
// verify index
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(numberOfRules);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(numberOfRules);
assertThat(ruleIndex.search(new RuleQuery(), new SearchOptions()).getIds())
.isNotEmpty();
.containsOnly(RuleStatus.REMOVED);
// verify index (documents are still in the index, but all are removed)
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(numberOfRules);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(numberOfRules);
assertThat(ruleIndex.search(new RuleQuery(), new SearchOptions()).getIds())
.isEmpty();
}
assertThat(dbClient.ruleDao().selectAllDefinitions(dbTester.getSession())).hasSize(2);
RuleDto rule1 = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY1);
RuleDto rule2 = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY2);
- assertThat(esTester.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).containsOnly(valueOf(rule1.getId()), valueOf(rule2.getId()));
+ assertThat(es.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).containsOnly(valueOf(rule1.getId()), valueOf(rule2.getId()));
// user adds tags and sets markdown note
rule1.setTags(newHashSet("usertag1", "usertag2"));
RuleDto rule1 = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY1);
RuleDto rule2 = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY2);
- assertThat(esTester.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).containsOnly(valueOf(rule1.getId()), valueOf(rule2.getId()));
+ assertThat(es.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).containsOnly(valueOf(rule1.getId()), valueOf(rule2.getId()));
assertThat(rule2.getStatus()).isEqualTo(RuleStatus.READY);
execute(new BigRepository());
assertThat(dbTester.countRowsOfTable("rules")).isEqualTo(BigRepository.SIZE);
assertThat(dbTester.countRowsOfTable("rules_parameters")).isEqualTo(BigRepository.SIZE * 20);
- assertThat(esTester.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).hasSize(BigRepository.SIZE);
+ assertThat(es.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).hasSize(BigRepository.SIZE);
}
@Test
public class RuleIndexerTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public DbTester dbTester = DbTester.create();
private DbClient dbClient = dbTester.getDbClient();
- private final RuleIndexer underTest = new RuleIndexer(esTester.client(), dbClient);
+ private final RuleIndexer underTest = new RuleIndexer(es.client(), dbClient);
private DbSession dbSession = dbTester.getSession();
private RuleDefinitionDto rule = new RuleDefinitionDto()
.setRuleKey("S001")
@Test
public void index_nothing() {
underTest.index(dbSession, Collections.emptyList());
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(0L);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(0L);
}
@Test
dbClient.ruleDao().insert(dbSession, rule);
underTest.commitAndIndex(dbSession, rule.getId());
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
}
@Test
dbClient.ruleDao().insert(dbSession, rule.setStatus(RuleStatus.READY));
dbSession.commit();
underTest.commitAndIndex(dbTester.getSession(), rule.getId());
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
// Remove rule
dbTester.getDbClient().ruleDao().update(dbTester.getSession(), rule.setStatus(RuleStatus.READY).setUpdatedAt(2000000000000L));
underTest.commitAndIndex(dbTester.getSession(), rule.getId());
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
}
@Test
.setRuleId(rule.getId())
.setScope(RuleExtensionScope.organization(organization.getUuid()));
assertThat(
- esTester.client()
+ es.client()
.prepareSearch(RuleIndexDefinition.INDEX_TYPE_RULE_EXTENSION)
.setQuery(termQuery("_id", doc.getId()))
.get()
RuleDefinitionDto rule = dbTester.rules().insert(r -> r.setDescription(description));
underTest.commitAndIndex(dbTester.getSession(), rule.getId());
- assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(1);
}
}
@Rule
public DbTester dbTester = DbTester.create();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public ExpectedException thrown = ExpectedException.none();
private DbClient dbClient = dbTester.getDbClient();
private DbSession dbSession = dbTester.getSession();
- private RuleIndexer ruleIndexer = spy(new RuleIndexer(esTester.client(), dbClient));
+ private RuleIndexer ruleIndexer = spy(new RuleIndexer(es.client(), dbClient));
private QProfileRules qProfileRules = mock(QProfileRules.class);
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.fromUuid("ORG1");
private RuleWsSupport ruleWsSupport = new RuleWsSupport(mock(DbClient.class), userSession, defaultOrganizationProvider);
public class ShowActionTest {
- public static final String INTERPRETED = "interpreted";
+ private static final String INTERPRETED = "interpreted";
@org.junit.Rule
public DbTester dbTester = DbTester.create();
@org.junit.Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@org.junit.Rule
public ExpectedException thrown = ExpectedException.none();
private DbClient dbClient = dbTester.getDbClient();
- private EsClient esClient = esTester.client();
+ private EsClient esClient = es.client();
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
private MacroInterpreter macroInterpreter = mock(MacroInterpreter.class);
public DbTester db = DbTester.create();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private DbClient dbClient = db.getDbClient();
- private EsClient esClient = esTester.client();
+ private EsClient esClient = es.client();
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
private Languages languages = new Languages();
private RuleMapper mapper = new RuleMapper(languages, createMacroInterpreter());
private RuleIndexer ruleIndexer = new RuleIndexer(esClient, dbClient);
private RuleUpdater ruleUpdater = new RuleUpdater(dbClient, ruleIndexer, System2.INSTANCE);
- private RuleWsSupport ruleWsSupport = new RuleWsSupport(dbClient, userSession, defaultOrganizationProvider);
private WsAction underTest = new UpdateAction(dbClient, ruleUpdater, mapper, userSession, defaultOrganizationProvider);
private WsActionTester ws = new WsActionTester(underTest);
import java.util.Collections;
import java.util.List;
import java.util.Locale;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
private static final String ORGANIZATION_UUID = "my-organization";
private static final String USER1_LOGIN = "user1";
private static final String USER2_LOGIN = "user2";
- private static final long DATE_1 = 1_500_000_000_000L;
- private static final long DATE_2 = 1_500_000_000_001L;
@Rule
- public EsTester esTester = EsTester.core();
-
- private UserIndex underTest;
+ public EsTester es = EsTester.core();
+ private UserIndex underTest = new UserIndex(es.client(), System2.INSTANCE);
private UserQuery.Builder userQuery = UserQuery.builder();
- @Before
- public void setUp() {
- underTest = new UserIndex(esTester.client(), System2.INSTANCE);
- }
-
@Test
public void get_nullable_by_login() {
UserDoc user1 = newUser(USER1_LOGIN, asList("scmA", "scmB"));
- esTester.putDocuments(INDEX_TYPE_USER, user1);
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, Collections.emptyList()));
+ es.putDocuments(INDEX_TYPE_USER, user1);
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, Collections.emptyList()));
UserDoc userDoc = underTest.getNullableByLogin(USER1_LOGIN);
assertThat(userDoc).isNotNull();
@Test
public void getNullableByLogin_is_case_sensitive() {
UserDoc user1 = newUser(USER1_LOGIN, asList("scmA", "scmB"));
- esTester.putDocuments(INDEX_TYPE_USER, user1);
+ es.putDocuments(INDEX_TYPE_USER, user1);
assertThat(underTest.getNullableByLogin(USER1_LOGIN)).isNotNull();
assertThat(underTest.getNullableByLogin("UsEr1")).isNull();
UserDoc user1 = newUser("user1", asList("user_1", "u1"));
UserDoc user2 = newUser("user_with_same_email_as_user1", asList("user_2")).setEmail(user1.email());
UserDoc user3 = newUser("inactive_user_with_same_scm_as_user1", user1.scmAccounts()).setActive(false);
- esTester.putDocuments(INDEX_TYPE_USER, user1);
- esTester.putDocuments(INDEX_TYPE_USER, user2);
- esTester.putDocuments(INDEX_TYPE_USER, user3);
+ es.putDocuments(INDEX_TYPE_USER, user1);
+ es.putDocuments(INDEX_TYPE_USER, user2);
+ es.putDocuments(INDEX_TYPE_USER, user3);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount(user1.scmAccounts().get(0), ORGANIZATION_UUID)).extractingResultOf("login").containsOnly(user1.login());
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount(user1.login(), ORGANIZATION_UUID)).extractingResultOf("login").containsOnly(user1.login());
public void getAtMostThreeActiveUsersForScmAccount_ignores_inactive_user() {
String scmAccount = "scmA";
UserDoc user = newUser(USER1_LOGIN, singletonList(scmAccount)).setActive(false);
- esTester.putDocuments(INDEX_TYPE_USER, user);
+ es.putDocuments(INDEX_TYPE_USER, user);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount(user.login(), ORGANIZATION_UUID)).isEmpty();
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount(scmAccount, ORGANIZATION_UUID)).isEmpty();
UserDoc user2 = newUser("user2", Collections.emptyList()).setEmail(email);
UserDoc user3 = newUser("user3", Collections.emptyList()).setEmail(email);
UserDoc user4 = newUser("user4", Collections.emptyList()).setEmail(email);
- esTester.putDocuments(INDEX_TYPE_USER, user1);
- esTester.putDocuments(INDEX_TYPE_USER, user2);
- esTester.putDocuments(INDEX_TYPE_USER, user3);
- esTester.putDocuments(INDEX_TYPE_USER, user4);
+ es.putDocuments(INDEX_TYPE_USER, user1);
+ es.putDocuments(INDEX_TYPE_USER, user2);
+ es.putDocuments(INDEX_TYPE_USER, user3);
+ es.putDocuments(INDEX_TYPE_USER, user4);
// restrict results to 3 users
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount(email, ORGANIZATION_UUID)).hasSize(3);
@Test
public void getAtMostThreeActiveUsersForScmAccount_is_case_sensitive_for_login() {
UserDoc user = newUser("the_login", singletonList("John.Smith"));
- esTester.putDocuments(INDEX_TYPE_USER, user);
+ es.putDocuments(INDEX_TYPE_USER, user);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("the_login", ORGANIZATION_UUID)).hasSize(1);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("the_Login", ORGANIZATION_UUID)).isEmpty();
@Test
public void getAtMostThreeActiveUsersForScmAccount_is_case_insensitive_for_email() {
UserDoc user = newUser("the_login", "the_EMAIL@corp.com", singletonList("John.Smith"));
- esTester.putDocuments(INDEX_TYPE_USER, user);
+ es.putDocuments(INDEX_TYPE_USER, user);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("the_EMAIL@corp.com", ORGANIZATION_UUID)).hasSize(1);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("the_email@corp.com", ORGANIZATION_UUID)).hasSize(1);
@Test
public void getAtMostThreeActiveUsersForScmAccount_is_case_insensitive_for_scm_account() {
UserDoc user = newUser("the_login", singletonList("John.Smith"));
- esTester.putDocuments(INDEX_TYPE_USER, user);
+ es.putDocuments(INDEX_TYPE_USER, user);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("John.Smith", ORGANIZATION_UUID)).hasSize(1);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("JOHN.SMIth", ORGANIZATION_UUID)).hasSize(1);
public void getAtMostThreeActiveUsersForScmAccount_search_only_user_within_given_organization() {
UserDoc user1 = newUser("user1", singletonList("same_scm")).setOrganizationUuids(singletonList(ORGANIZATION_UUID));
UserDoc user2 = newUser("user2", singletonList("same_scm")).setOrganizationUuids(singletonList("another_organization"));
- esTester.putDocuments(INDEX_TYPE_USER, user1);
- esTester.putDocuments(INDEX_TYPE_USER, user2);
+ es.putDocuments(INDEX_TYPE_USER, user1);
+ es.putDocuments(INDEX_TYPE_USER, user2);
assertThat(underTest.getAtMostThreeActiveUsersForScmAccount("same_scm", ORGANIZATION_UUID)).extractingResultOf("login").containsOnly(user1.login());
}
@Test
public void searchUsers() {
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER1_LOGIN, asList("user_1", "u1")).setEmail("email1"));
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, Collections.emptyList()).setEmail("email2"));
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER1_LOGIN, asList("user_1", "u1")).setEmail("email1"));
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, Collections.emptyList()).setEmail("email2"));
assertThat(underTest.search(userQuery.build(), new SearchOptions()).getDocs()).hasSize(2);
assertThat(underTest.search(userQuery.setTextQuery("user").build(), new SearchOptions()).getDocs()).hasSize(2);
@Test
public void search_users_filter_by_organization_uuid() {
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER1_LOGIN, asList("user_1", "u1")).setEmail("email1")
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER1_LOGIN, asList("user_1", "u1")).setEmail("email1")
.setOrganizationUuids(newArrayList("O1", "O2")));
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, emptyList()).setEmail("email2")
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, emptyList()).setEmail("email2")
.setOrganizationUuids(newArrayList("O2")));
assertThat(underTest.search(userQuery.setOrganizationUuid("O42").build(), new SearchOptions()).getDocs()).isEmpty();
@Test
public void search_users_filter_by_excluded_organization_uuid() {
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER1_LOGIN, asList("user_1", "u1")).setEmail("email1")
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER1_LOGIN, asList("user_1", "u1")).setEmail("email1")
.setOrganizationUuids(newArrayList("O1", "O2")));
- esTester.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, emptyList()).setEmail("email2")
+ es.putDocuments(INDEX_TYPE_USER, newUser(USER2_LOGIN, emptyList()).setEmail("email2")
.setOrganizationUuids(newArrayList("O2")));
assertThat(underTest.search(userQuery.setExcludedOrganizationUuid("O42").build(), new SearchOptions()).getDocs()).hasSize(2);
@Rule
public DbTester db = DbTester.create();
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone().logIn();
private TestOrganizationFlags organizationFlags = TestOrganizationFlags.standalone();
- private UserUpdater userUpdater = new UserUpdater(mock(NewUserNotifier.class), db.getDbClient(), new UserIndexer(db.getDbClient(), esTester.client()),
+ private UserUpdater userUpdater = new UserUpdater(mock(NewUserNotifier.class), db.getDbClient(), new UserIndexer(db.getDbClient(), es.client()),
organizationFlags,
TestDefaultOrganizationProvider.from(db),
mock(OrganizationCreation.class),
@Rule
public DbTester db = DbTester.create(system2);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
public ExpectedException expectedException = ExpectedException.none();
- private UserIndex index = new UserIndex(esTester.client(), System2.INSTANCE);
- private UserIndexer userIndexer = new UserIndexer(db.getDbClient(), esTester.client());
+ private UserIndex index = new UserIndex(es.client(), System2.INSTANCE);
+ private UserIndexer userIndexer = new UserIndexer(db.getDbClient(), es.client());
private GroupDto defaultGroupInDefaultOrg;
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
private TestOrganizationFlags organizationFlags = TestOrganizationFlags.standalone();
public DbTester db = DbTester.create(system2);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
- private UserIndex index = new UserIndex(esTester.client(), system2);
+ private UserIndex index = new UserIndex(es.client(), system2);
private DbClient dbClient = db.getDbClient();
- private UserIndexer userIndexer = new UserIndexer(dbClient, esTester.client());
+ private UserIndexer userIndexer = new UserIndexer(dbClient, es.client());
private DbSession dbSession = db.getSession();
private WsActionTester ws = new WsActionTester(new DeactivateAction(
private System2 system2 = System2.INSTANCE;
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private DbClient dbClient = db.getDbClient();
private DbSession dbSession = db.getSession();
- private UserIndex index = new UserIndex(esTester.client(), system2);
- private UserIndexer userIndexer = new UserIndexer(dbClient, esTester.client());
+ private UserIndex index = new UserIndex(es.client(), system2);
+ private UserIndexer userIndexer = new UserIndexer(dbClient, es.client());
private WsTester ws = new WsTester(new UsersWs(new SearchAction(userSession, index, dbClient, new AvatarResolverImpl())));
@Test
import org.sonar.server.es.EsTester;
import static com.google.common.collect.Lists.newArrayList;
-import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.server.view.index.ViewIndexDefinition.INDEX_TYPE_VIEW;
public class ViewIndexTest {
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
- ViewIndex index = new ViewIndex(esTester.client());
+ private ViewIndex index = new ViewIndex(es.client());
@Test
public void find_all_view_uuids() {
- ViewDoc view1 = new ViewDoc().setUuid("UUID1").setProjects(asList("P1"));
- ViewDoc view2 = new ViewDoc().setUuid("UUID2").setProjects(asList("P2"));
- esTester.putDocuments(INDEX_TYPE_VIEW, view1);
- esTester.putDocuments(INDEX_TYPE_VIEW, view2);
+ ViewDoc view1 = new ViewDoc().setUuid("UUID1").setProjects(singletonList("P1"));
+ ViewDoc view2 = new ViewDoc().setUuid("UUID2").setProjects(singletonList("P2"));
+ es.putDocuments(INDEX_TYPE_VIEW, view1);
+ es.putDocuments(INDEX_TYPE_VIEW, view2);
List<String> result = newArrayList(index.findAllViewUuids());
public DbTester dbTester = DbTester.create(system2);
@Rule
- public EsTester esTester = EsTester.core();
+ public EsTester es = EsTester.core();
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
private DbClient dbClient = dbTester.getDbClient();
private DbSession dbSession = dbTester.getSession();
- private IssueIndexer issueIndexer = new IssueIndexer(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
- private PermissionIndexer permissionIndexer = new PermissionIndexer(dbClient, esTester.client(), issueIndexer);
- private ViewIndexer underTest = new ViewIndexer(dbClient, esTester.client());
+ private IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
+ private PermissionIndexer permissionIndexer = new PermissionIndexer(dbClient, es.client(), issueIndexer);
+ private ViewIndexer underTest = new ViewIndexer(dbClient, es.client());
@Test
public void index_nothing() {
underTest.indexOnStartup(emptySet());
- assertThat(esTester.countDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW)).isEqualTo(0L);
+ assertThat(es.countDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW)).isEqualTo(0L);
}
@Test
underTest.indexOnStartup(emptySet());
- List<ViewDoc> docs = esTester.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
+ List<ViewDoc> docs = es.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
assertThat(docs).hasSize(4);
Map<String, ViewDoc> viewsByUuid = Maps.uniqueIndex(docs, ViewDoc::uuid);
underTest.index("EFGH");
- List<ViewDoc> docs = esTester.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
+ List<ViewDoc> docs = es.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
assertThat(docs).hasSize(2);
Map<String, ViewDoc> viewsByUuid = Maps.uniqueIndex(docs, ViewDoc::uuid);
public void index_view_doc() {
underTest.index(new ViewDoc().setUuid("EFGH").setProjects(newArrayList("KLMN", "JKLM")));
- List<ViewDoc> result = esTester.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
+ List<ViewDoc> result = es.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
assertThat(result).hasSize(1);
ViewDoc view = result.get(0);
dbTester.components().insertComponent(newProjectCopy("PC1", project, application));
underTest.index(application.uuid());
- List<ViewDoc> result = esTester.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
+ List<ViewDoc> result = es.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
assertThat(result).hasSize(1);
ViewDoc resultApp = result.get(0);
dbTester.components().insertComponent(newProjectCopy("PC1", project, application));
underTest.indexOnStartup(emptySet());
- List<ViewDoc> result = esTester.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
+ List<ViewDoc> result = es.getDocuments(ViewIndexDefinition.INDEX_TYPE_VIEW, ViewDoc.class);
assertThat(result).hasSize(1);
ViewDoc resultApp = result.get(0);
@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(esTester.client(), dbClient, new IssueIteratorFactory(dbClient));
+ IssueIndex issueIndex = new IssueIndex(es.client(), System2.INSTANCE, userSessionRule, new AuthorizationTypeSupport(userSessionRule));
+ IssueIndexer issueIndexer = new IssueIndexer(es.client(), dbClient, new IssueIteratorFactory(dbClient));
String viewUuid = "ABCD";
ViewDoc view1 = new ViewDoc().setUuid("UUID1").setProjects(asList("P1"));
ViewDoc view2 = new ViewDoc().setUuid("UUID2").setProjects(asList("P2", "P3", "P4"));
ViewDoc view3 = new ViewDoc().setUuid("UUID3").setProjects(asList("P2", "P3", "P4"));
- esTester.putDocuments(INDEX_TYPE_VIEW, view1);
- esTester.putDocuments(INDEX_TYPE_VIEW, view2);
- esTester.putDocuments(INDEX_TYPE_VIEW, view3);
+ es.putDocuments(INDEX_TYPE_VIEW, view1);
+ es.putDocuments(INDEX_TYPE_VIEW, view2);
+ es.putDocuments(INDEX_TYPE_VIEW, view3);
- assertThat(esTester.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
+ assertThat(es.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
.containsOnly(view1.uuid(), view2.uuid(), view3.uuid());
underTest.delete(dbSession, asList(view1.uuid(), view2.uuid()));
- assertThat(esTester.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
+ assertThat(es.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
.containsOnly(view3.uuid());
}
ViewDoc view1 = new ViewDoc().setUuid("UUID1").setProjects(asList("P1"));
ViewDoc view2 = new ViewDoc().setUuid("UUID2").setProjects(asList("P2", "P3", "P4"));
ViewDoc view3 = new ViewDoc().setUuid("UUID3").setProjects(asList("P2", "P3", "P4"));
- esTester.putDocuments(INDEX_TYPE_VIEW, view1);
- esTester.putDocuments(INDEX_TYPE_VIEW, view2);
- esTester.putDocuments(INDEX_TYPE_VIEW, view3);
+ es.putDocuments(INDEX_TYPE_VIEW, view1);
+ es.putDocuments(INDEX_TYPE_VIEW, view2);
+ es.putDocuments(INDEX_TYPE_VIEW, view3);
- assertThat(esTester.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
+ assertThat(es.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
.containsOnly(view1.uuid(), view2.uuid(), view3.uuid());
// Lock writes
- esTester.lockWrites(INDEX_TYPE_VIEW);
+ es.lockWrites(INDEX_TYPE_VIEW);
underTest.delete(dbSession, asList(view1.uuid(), view2.uuid()));
- assertThat(esTester.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
+ assertThat(es.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
.containsOnly(view1.uuid(), view2.uuid(), view3.uuid());
// Unlock writes
- esTester.unlockWrites(INDEX_TYPE_VIEW);
+ es.unlockWrites(INDEX_TYPE_VIEW);
- doRecover(() -> esTester.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID).size() == 3);
+ doRecover(() -> es.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID).size() == 3);
- assertThat(esTester.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
+ assertThat(es.getDocumentFieldValues(INDEX_TYPE_VIEW, ViewIndexDefinition.FIELD_UUID))
.containsOnly(view3.uuid());
}
projects / sonarqube.git / commitdiff