Java ESIntegTestCase类代码示例

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
private BlobStoreRepository setupRepo() {
    final Client client = client();
    final Path location = ESIntegTestCase.randomRepoPath(node().settings());
    final String repositoryName = "test-repo";

    PutRepositoryResponse putRepositoryResponse =
        client.admin().cluster().preparePutRepository(repositoryName)
                                .setType("fs")
                                .setSettings(Settings.builder().put(node().settings()).put("location", location))
                                .get();
    assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));

    final RepositoriesService repositoriesService = getInstanceFromNode(RepositoriesService.class);
    @SuppressWarnings("unchecked") final BlobStoreRepository repository =
        (BlobStoreRepository) repositoriesService.repository(repositoryName);
    return repository;
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
public MockEngineSupport(EngineConfig config, Class<? extends FilterDirectoryReader> wrapper) {
    Settings settings = config.getIndexSettings().getSettings();
    shardId = config.getShardId();
    filterCache = config.getQueryCache();
    filterCachingPolicy = config.getQueryCachingPolicy();
    final long seed =  config.getIndexSettings().getValue(ESIntegTestCase.INDEX_TEST_SEED_SETTING);
    Random random = new Random(seed);
    final double ratio = WRAP_READER_RATIO.get(settings);
    boolean wrapReader = random.nextDouble() < ratio;
    if (logger.isTraceEnabled()) {
        logger.trace("Using [{}] for shard [{}] seed: [{}] wrapReader: [{}]", this.getClass().getName(), shardId, seed, wrapReader);
    }
    mockContext = new MockContext(random, wrapReader, wrapper, settings);
    this.searcherCloseable = new SearcherCloseable();
    LuceneTestCase.closeAfterSuite(searcherCloseable); // only one suite closeable per Engine
    this.disableFlushOnClose = DISABLE_FLUSH_ON_CLOSE.get(settings);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
@Inject
public MockFSDirectoryService(IndexSettings idxSettings, IndexStore indexStore, final ShardPath path) {
    super(idxSettings, indexStore, path);
    Settings indexSettings = idxSettings.getSettings();
    final long seed = idxSettings.getValue(ESIntegTestCase.INDEX_TEST_SEED_SETTING);
    this.random = new Random(seed);

    randomIOExceptionRate = RANDOM_IO_EXCEPTION_RATE_SETTING.get(indexSettings);
    randomIOExceptionRateOnOpen = RANDOM_IO_EXCEPTION_RATE_ON_OPEN_SETTING.get(indexSettings);
    preventDoubleWrite = RANDOM_PREVENT_DOUBLE_WRITE_SETTING.get(indexSettings);
    noDeleteOpenFile = RANDOM_NO_DELETE_OPEN_FILE_SETTING.exists(indexSettings) ? RANDOM_NO_DELETE_OPEN_FILE_SETTING.get(indexSettings) : random.nextBoolean();
    random.nextInt(shardId.getId() + 1); // some randomness per shard
    throttle = MockDirectoryWrapper.Throttling.NEVER;
    crashIndex = CRASH_INDEX_SETTING.get(indexSettings);

    if (logger.isDebugEnabled()) {
        logger.debug("Using MockDirWrapper with seed [{}] throttle: [{}] crashIndex: [{}]", SeedUtils.formatSeed(seed),
                throttle, crashIndex);
    }
    delegateService = randomDirectorService(indexStore, path);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
private static void checkSignificantTermsAggregationCorrect(ESIntegTestCase testCase) {
    SearchResponse response = client().prepareSearch(INDEX_NAME).setTypes(DOC_TYPE).addAggregation(
            terms("class").field(CLASS_FIELD).subAggregation(significantTerms("sig_terms").field(TEXT_FIELD)))
            .execute().actionGet();
    assertSearchResponse(response);
    StringTerms classes = response.getAggregations().get("class");
    Assert.assertThat(classes.getBuckets().size(), equalTo(2));
    for (Terms.Bucket classBucket : classes.getBuckets()) {
        Map<String, Aggregation> aggs = classBucket.getAggregations().asMap();
        Assert.assertTrue(aggs.containsKey("sig_terms"));
        SignificantTerms agg = (SignificantTerms) aggs.get("sig_terms");
        Assert.assertThat(agg.getBuckets().size(), equalTo(1));
        SignificantTerms.Bucket sigBucket = agg.iterator().next();
        String term = sigBucket.getKeyAsString();
        String classTerm = classBucket.getKeyAsString();
        Assert.assertTrue(term.equals(classTerm));
    }
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
public static void index01Docs(String type, String settings, ESIntegTestCase testCase) throws ExecutionException, InterruptedException {
    String textMappings = "type=" + type;
    if (type.equals("text")) {
        textMappings += ",fielddata=true";
    }
    assertAcked(testCase.prepareCreate(INDEX_NAME).setSettings(settings, XContentType.JSON)
            .addMapping("doc", "text", textMappings, CLASS_FIELD, "type=keyword"));
    String[] gb = {"0", "1"};
    List<IndexRequestBuilder> indexRequestBuilderList = new ArrayList<>();
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "1")
            .setSource(TEXT_FIELD, "1", CLASS_FIELD, "1"));
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "2")
            .setSource(TEXT_FIELD, "1", CLASS_FIELD, "1"));
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "3")
            .setSource(TEXT_FIELD, "0", CLASS_FIELD, "0"));
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "4")
            .setSource(TEXT_FIELD, "0", CLASS_FIELD, "0"));
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "5")
            .setSource(TEXT_FIELD, gb, CLASS_FIELD, "1"));
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "6")
            .setSource(TEXT_FIELD, gb, CLASS_FIELD, "0"));
    indexRequestBuilderList.add(client().prepareIndex(INDEX_NAME, DOC_TYPE, "7")
            .setSource(TEXT_FIELD, "0", CLASS_FIELD, "0"));
    testCase.indexRandom(true, false, indexRequestBuilderList);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
public ReproduceErrorMessageBuilder appendESProperties() {
    appendProperties("tests.es.logger.level");
    if (inVerifyPhase()) {
        // these properties only make sense for integration tests
        appendProperties(ESIntegTestCase.TESTS_ENABLE_MOCK_MODULES);
    }
    appendProperties("tests.assertion.disabled", "tests.security.manager", "tests.nightly", "tests.jvms",
                     "tests.client.ratio", "tests.heap.size", "tests.bwc", "tests.bwc.version");
    if (System.getProperty("tests.jvm.argline") != null && !System.getProperty("tests.jvm.argline").isEmpty()) {
        appendOpt("tests.jvm.argline", "\"" + System.getProperty("tests.jvm.argline") + "\"");
    }
    appendOpt("tests.locale", Locale.getDefault().toLanguageTag());
    appendOpt("tests.timezone", TimeZone.getDefault().getID());
    return this;
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
/**
 * Tells whether all the features provided as argument are supported
 */
public static boolean areAllSupported(List<String> features) {
    for (String feature : features) {
        if ("requires_replica".equals(feature) && ESIntegTestCase.cluster().numDataNodes() >= 2) {
            continue;
        }
        if (!SUPPORTED.contains(feature)) {
            return false;
        }
    }
    return true;
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
public static void aggregateAndCheckFromSeveralShards(ESIntegTestCase testCase) throws ExecutionException, InterruptedException {
    String type = ESTestCase.randomBoolean() ? "text" : "keyword";
    String settings = "{\"index.number_of_shards\": 5, \"index.number_of_replicas\": 0}";
    index01Docs(type, settings, testCase);
    testCase.ensureGreen();
    testCase.logClusterState();
    checkSignificantTermsAggregationCorrect(testCase);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
@Test
public void testPutAndFlush() throws Exception {
  InternalTestCluster cluster = ESIntegTestCase.internalCluster();
  cluster.ensureAtLeastNumDataNodes(3);
  Map<String, String> props = createProps();

  ElasticsearchSinkTask task = new ElasticsearchSinkTask();
  task.start(props, client);
  task.open(new HashSet<>(Arrays.asList(TOPIC_PARTITION, TOPIC_PARTITION2, TOPIC_PARTITION3)));

  String key = "key";
  Schema schema = createSchema();
  Struct record = createRecord(schema);

  Collection<SinkRecord> records = new ArrayList<>();
  SinkRecord sinkRecord = new SinkRecord(TOPIC, PARTITION, Schema.STRING_SCHEMA, key, schema, record, 0);
  records.add(sinkRecord);

  sinkRecord = new SinkRecord(TOPIC, PARTITION, Schema.STRING_SCHEMA, key, schema, record, 1);
  records.add(sinkRecord);

  task.put(records);
  task.flush(null);

  refresh();

  verifySearchResults(records, true, false);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testMapping() throws Exception {
  InternalTestCluster cluster = ESIntegTestCase.internalCluster();
  cluster.ensureAtLeastNumDataNodes(1);

  createIndex(INDEX);
  Schema schema = createSchema();
  Mapping.createMapping(client, INDEX, TYPE, schema);

  JsonObject mapping = Mapping.getMapping(client, INDEX, TYPE);
  assertNotNull(mapping);
  verifyMapping(schema, mapping);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
public AssertingTransportInterceptor(Settings settings, NamedWriteableRegistry namedWriteableRegistry) {
    final long seed = ESIntegTestCase.INDEX_TEST_SEED_SETTING.get(settings);
    random = new Random(seed);
    this.namedWriteableRegistry = namedWriteableRegistry;
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
ThrowingSubReaderWrapper(Settings settings) {
    final long seed = ESIntegTestCase.INDEX_TEST_SEED_SETTING.get(settings);
    this.topLevelRatio = EXCEPTION_TOP_LEVEL_RATIO_SETTING.get(settings);
    this.lowLevelRatio = EXCEPTION_LOW_LEVEL_RATIO_SETTING.get(settings);
    this.random = new Random(seed);
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
public void testRetrieveSnapshots() throws Exception {
    final Client client = client();
    final Path location = ESIntegTestCase.randomRepoPath(node().settings());
    final String repositoryName = "test-repo";

    logger.info("-->  creating repository");
    PutRepositoryResponse putRepositoryResponse =
        client.admin().cluster().preparePutRepository(repositoryName)
                                .setType("fs")
                                .setSettings(Settings.builder().put(node().settings()).put("location", location))
                                .get();
    assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));

    logger.info("--> creating an index and indexing documents");
    final String indexName = "test-idx";
    createIndex(indexName);
    ensureGreen();
    int numDocs = randomIntBetween(10, 20);
    for (int i = 0; i < numDocs; i++) {
        String id = Integer.toString(i);
        client().prepareIndex(indexName, "type1", id).setSource("text", "sometext").get();
    }
    client().admin().indices().prepareFlush(indexName).get();

    logger.info("--> create first snapshot");
    CreateSnapshotResponse createSnapshotResponse = client.admin()
                                                          .cluster()
                                                          .prepareCreateSnapshot(repositoryName, "test-snap-1")
                                                          .setWaitForCompletion(true)
                                                          .setIndices(indexName)
                                                          .get();
    final SnapshotId snapshotId1 = createSnapshotResponse.getSnapshotInfo().snapshotId();

    logger.info("--> create second snapshot");
    createSnapshotResponse = client.admin()
                                   .cluster()
                                   .prepareCreateSnapshot(repositoryName, "test-snap-2")
                                   .setWaitForCompletion(true)
                                   .setIndices(indexName)
                                   .get();
    final SnapshotId snapshotId2 = createSnapshotResponse.getSnapshotInfo().snapshotId();

    logger.info("--> make sure the node's repository can resolve the snapshots");
    final RepositoriesService repositoriesService = getInstanceFromNode(RepositoriesService.class);
    @SuppressWarnings("unchecked") final BlobStoreRepository repository =
        (BlobStoreRepository) repositoriesService.repository(repositoryName);
    final List<SnapshotId> originalSnapshots = Arrays.asList(snapshotId1, snapshotId2);

    List<SnapshotId> snapshotIds = repository.getRepositoryData().getSnapshotIds().stream()
        .sorted((s1, s2) -> s1.getName().compareTo(s2.getName())).collect(Collectors.toList());
    assertThat(snapshotIds, equalTo(originalSnapshots));
}
 

import org.elasticsearch.test.ESIntegTestCase; //导入依赖的package包/类
ThrowingSubReaderWrapper(Settings settings) {
    final long seed = ESIntegTestCase.INDEX_TEST_SEED_SETTING.get(settings);
    this.topLevelRatio = settings.getAsDouble(EXCEPTION_TOP_LEVEL_RATIO_KEY, 0.1d);
    this.lowLevelRatio = settings.getAsDouble(EXCEPTION_LOW_LEVEL_RATIO_KEY, 0.1d);
    this.random = new Random(seed);
}