Java Processor.execute方法代码示例

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testRenameAtomicOperationRemoveFails() throws Exception {
    Map<String, Object> source = new HashMap<String, Object>() {
        @Override
        public Object remove(Object key) {
            if (key.equals("list")) {
                throw new UnsupportedOperationException();
            }
            return super.remove(key);
        }
    };
    source.put("list", Collections.singletonList("item"));

    IngestDocument ingestDocument = new IngestDocument(source, Collections.emptyMap());
    Processor processor = new RenameProcessor(randomAsciiOfLength(10), "list", "new_field", false);
    try {
        processor.execute(ingestDocument);
        fail("processor execute should have failed");
    } catch (UnsupportedOperationException e) {
        //the set failed, the old field has not been removed
        assertThat(ingestDocument.getSourceAndMetadata().containsKey("list"), equalTo(true));
        assertThat(ingestDocument.getSourceAndMetadata().containsKey("new_field"), equalTo(false));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testSortDoubles() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
    int numItems = randomIntBetween(1, 10);
    List<Double> fieldValue = new ArrayList<>(numItems);
    List<Double> expectedResult = new ArrayList<>(numItems);
    for (int j = 0; j < numItems; j++) {
        Double value = randomDoubleBetween(0.0, 100.0, true);
        fieldValue.add(value);
        expectedResult.add(value);
    }
    Collections.sort(expectedResult);

    SortOrder order = randomBoolean() ? SortOrder.ASCENDING : SortOrder.DESCENDING;
    if (order.equals(SortOrder.DESCENDING)) {
        Collections.reverse(expectedResult);
    }

    String fieldName = RandomDocumentPicks.addRandomField(random(), ingestDocument, fieldValue);
    Processor processor = new SortProcessor(randomAsciiOfLength(10), fieldName, order);
    processor.execute(ingestDocument);
    assertEquals(ingestDocument.getFieldValue(fieldName, List.class), expectedResult);
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testConvertBooleanError() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    String fieldName = RandomDocumentPicks.randomFieldName(random());
    String fieldValue;
    if (randomBoolean()) {
        fieldValue = "string-" + randomAsciiOfLengthBetween(1, 10);
    } else {
        //verify that only proper boolean values are supported and we are strict about it
        fieldValue = randomFrom("on", "off", "yes", "no", "0", "1");
    }
    ingestDocument.setFieldValue(fieldName, fieldValue);

    Processor processor = new ConvertProcessor(randomAsciiOfLength(10), fieldName, fieldName, Type.BOOLEAN, false);
    try {
        processor.execute(ingestDocument);
        fail("processor execute should have failed");
    } catch(Exception e) {
        assertThat(e.getMessage(), equalTo("[" + fieldValue + "] is not a boolean value, cannot convert to boolean"));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testSortBytes() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
    int numItems = randomIntBetween(1, 10);
    List<Byte> fieldValue = new ArrayList<>(numItems);
    List<Byte> expectedResult = new ArrayList<>(numItems);
    for (int j = 0; j < numItems; j++) {
        Byte value = randomByte();
        fieldValue.add(value);
        expectedResult.add(value);
    }
    Collections.sort(expectedResult);

    SortOrder order = randomBoolean() ? SortOrder.ASCENDING : SortOrder.DESCENDING;
    if (order.equals(SortOrder.DESCENDING)) {
        Collections.reverse(expectedResult);
    }

    String fieldName = RandomDocumentPicks.addRandomField(random(), ingestDocument, fieldValue);
    Processor processor = new SortProcessor(randomAsciiOfLength(10), fieldName, order);
    processor.execute(ingestDocument);
    assertEquals(ingestDocument.getFieldValue(fieldName, List.class), expectedResult);
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testGsub() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
    String fieldName = RandomDocumentPicks.addRandomField(random(), ingestDocument, "127.0.0.1");
    Processor processor = new GsubProcessor(randomAsciiOfLength(10), fieldName, Pattern.compile("\\."), "-");
    processor.execute(ingestDocument);
    assertThat(ingestDocument.getFieldValue(fieldName, String.class), equalTo("127-0-0-1"));
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void test() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
    String message = randomAsciiOfLength(10);
    Processor processor = new FailProcessor(randomAsciiOfLength(10), new TestTemplateService.MockTemplate(message));
    try {
        processor.execute(ingestDocument);
        fail("fail processor should throw an exception");
    } catch (FailProcessorException e) {
        assertThat(e.getMessage(), equalTo(message));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testConvertNonExistingField() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    String fieldName = RandomDocumentPicks.randomFieldName(random());
    Type type = randomFrom(Type.values());
    Processor processor = new ConvertProcessor(randomAsciiOfLength(10), fieldName, fieldName, type, false);
    try {
        processor.execute(ingestDocument);
        fail("processor execute should have failed");
    } catch (IllegalArgumentException e) {
        assertThat(e.getMessage(), containsString("not present as part of path [" + fieldName + "]"));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testGsubNullValue() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), Collections.singletonMap("field", null));
    Processor processor = new GsubProcessor(randomAsciiOfLength(10), "field", Pattern.compile("\\."), "-");
    try {
        processor.execute(ingestDocument);
        fail("processor execution should have failed");
    } catch (IllegalArgumentException e) {
        assertThat(e.getMessage(), equalTo("field [field] is null, cannot match pattern."));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testSetExistingFields() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
    String fieldName = RandomDocumentPicks.randomExistingFieldName(random(), ingestDocument);
    Object fieldValue = RandomDocumentPicks.randomFieldValue(random());
    Processor processor = createSetProcessor(fieldName, fieldValue, true);
    processor.execute(ingestDocument);
    assertThat(ingestDocument.hasField(fieldName), equalTo(true));
    assertThat(ingestDocument.getFieldValue(fieldName, Object.class), equalTo(fieldValue));
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testSetNewFields() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    //used to verify that there are no conflicts between subsequent fields going to be added
    IngestDocument testIngestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    Object fieldValue = RandomDocumentPicks.randomFieldValue(random());
    String fieldName = RandomDocumentPicks.addRandomField(random(), testIngestDocument, fieldValue);
    Processor processor = createSetProcessor(fieldName, fieldValue, true);
    processor.execute(ingestDocument);
    assertThat(ingestDocument.hasField(fieldName), equalTo(true));
    assertThat(ingestDocument.getFieldValue(fieldName, Object.class), equalTo(fieldValue));
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testSetFieldsTypeMismatch() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    ingestDocument.setFieldValue("field", "value");
    Processor processor = createSetProcessor("field.inner", "value", true);
    try {
        processor.execute(ingestDocument);
        fail("processor execute should have failed");
    } catch(IllegalArgumentException e) {
        assertThat(e.getMessage(), equalTo("cannot set [inner] with parent object of type [java.lang.String] as " +
                "part of path [field.inner]"));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testConvertNonExistingFieldWithIgnoreMissing() throws Exception {
    IngestDocument originalIngestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    IngestDocument ingestDocument = new IngestDocument(originalIngestDocument);
    String fieldName = RandomDocumentPicks.randomFieldName(random());
    Type type = randomFrom(Type.values());
    Processor processor = new ConvertProcessor(randomAsciiOfLength(10), fieldName, fieldName, type, true);
    processor.execute(ingestDocument);
    assertIngestDocument(originalIngestDocument, ingestDocument);
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testRemoveNonExistingField() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), new HashMap<>());
    String fieldName = RandomDocumentPicks.randomFieldName(random());
    Processor processor = new RemoveProcessor(randomAsciiOfLength(10), new TestTemplateService.MockTemplate(fieldName));
    try {
        processor.execute(ingestDocument);
        fail("remove field should have failed");
    } catch(IllegalArgumentException e) {
        assertThat(e.getMessage(), containsString("not present as part of path [" + fieldName + "]"));
    }
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testNullValueWithIgnoreMissing() throws Exception {
    Processor processor = newProcessor("field", true);
    IngestDocument originalIngestDocument = RandomDocumentPicks.randomIngestDocument(random(), Collections.singletonMap("field", null));
    IngestDocument ingestDocument = new IngestDocument(originalIngestDocument);
    processor.execute(ingestDocument);
    assertIngestDocument(originalIngestDocument, ingestDocument);
}
 

import org.elasticsearch.ingest.Processor; //导入方法依赖的package包/类
public void testConvertBoolean() throws Exception {
    IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
    boolean randomBoolean = randomBoolean();
    String booleanString = Boolean.toString(randomBoolean);
    if (randomBoolean) {
        booleanString = booleanString.toUpperCase(Locale.ROOT);
    }
    String fieldName = RandomDocumentPicks.addRandomField(random(), ingestDocument, booleanString);

    Processor processor = new ConvertProcessor(randomAsciiOfLength(10), fieldName, fieldName, Type.BOOLEAN, false);
    processor.execute(ingestDocument);
    assertThat(ingestDocument.getFieldValue(fieldName, Boolean.class), equalTo(randomBoolean));
}