honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Test improvements

This commit is contained in:
Colin Goodheart-Smithe 2017-12-15 10:52:37 +00:00
parent 3da42f5603
commit 9e693b544c
6 changed files with 186 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
x-pack/plugin/src/main/java/org/elasticsearch/xpack/indexlifecycle/LifecyclePolicy.java
View File

@ -7,11 +7,11 @@ package org.elasticsearch.xpack.indexlifecycle;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.cluster.AbstractDiffable;
import org.elasticsearch.cluster.NamedDiffable;
import org.elasticsearch.common.Nullable;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.collect.Tuple;
import org.elasticsearch.common.io.stream.NamedWriteable;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.logging.ESLoggerFactory;
@ -41,7 +41,8 @@ import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constru
* dictate the order in which the {@link Phase}s are executed and will define
* which {@link LifecycleAction}s are allowed in each phase.
*/
public abstract class LifecyclePolicy extends AbstractDiffable<LifecyclePolicy> implements ToXContentObject, NamedWriteable {
public abstract class LifecyclePolicy extends AbstractDiffable<LifecyclePolicy>
implements ToXContentObject, NamedDiffable<LifecyclePolicy> {
private static final Logger logger = ESLoggerFactory.getLogger(LifecyclePolicy.class);
public static final ParseField PHASES_FIELD = new ParseField("phases");

18
x-pack/plugin/src/main/java/org/elasticsearch/xpack/indexlifecycle/ShrinkAction.java
View File

@ -6,9 +6,6 @@
package org.elasticsearch.xpack.indexlifecycle;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.cluster.service.ClusterService;
import org.elasticsearch.common.Strings;
@ -59,19 +56,8 @@ public class ShrinkAction implements LifecycleAction {
@Override
public void execute(Index index, Client client, ClusterService clusterService, Listener listener) {
client.admin().indices().delete(new DeleteIndexRequest(index.getName()), new ActionListener<DeleteIndexResponse>() {
@Override
public void onResponse(DeleteIndexResponse deleteIndexResponse) {
logger.error(deleteIndexResponse);
listener.onSuccess(true);
}
@Override
public void onFailure(Exception e) {
logger.error(e);
listener.onFailure(e);
}
});
// nocommit: stub
listener.onSuccess(true);
}
@Override

12
x-pack/plugin/src/test/java/org/elasticsearch/xpack/indexlifecycle/InternalIndexLifecycleContextTests.java
View File

@ -219,6 +219,18 @@ public class InternalIndexLifecycleContextTests extends ESTestCase {
assertEquals(phase, context.getPhase());
}
public void testGetReplicas() {
int replicas = randomIntBetween(0, 5);
IndexMetaData idxMeta = IndexMetaData.builder("test").settings(Settings.builder().put("index.version.created", 7000001L).build())
.numberOfShards(randomIntBetween(1, 5)).numberOfReplicas(replicas).build();
InternalIndexLifecycleContext context = new InternalIndexLifecycleContext(idxMeta, null, null, () -> {
throw new AssertionError("nowSupplier should not be called");
});
assertEquals(replicas, context.getNumberOfReplicas());
}
public void testSetAction() {
long creationDate = randomNonNegativeLong();
String newAction = randomAlphaOfLengthBetween(1, 20);

4
x-pack/plugin/src/test/java/org/elasticsearch/xpack/indexlifecycle/MockIndexLifecycleContext.java
View File

@ -66,9 +66,7 @@ public abstract class MockIndexLifecycleContext implements IndexLifecycleContext
}
@Override
public boolean canExecute(Phase phase) {
return true;
}
public abstract boolean canExecute(Phase phase);
@Override
public void executeAction(LifecycleAction action, LifecycleAction.Listener listener) {

86
x-pack/plugin/src/test/java/org/elasticsearch/xpack/indexlifecycle/MockIndexLifecycleContextTests.java
View File

@ -61,6 +61,21 @@ public class MockIndexLifecycleContextTests extends ESTestCase {
assertEquals(phase, context.getPhase());
}
public void testGetReplicas() {
int replicas = randomIntBetween(1, 10);
MockIndexLifecycleContext context = new MockIndexLifecycleContext(randomAlphaOfLengthBetween(1, 20),
randomAlphaOfLengthBetween(1, 20), randomAlphaOfLengthBetween(1, 20), replicas) {
@Override
public boolean canExecute(Phase phase) {
throw new AssertionError("canExecute should not have been called.");
}
};
assertEquals(replicas, context.getNumberOfReplicas());
}
public void testSetAction() {
String targetName = randomAlphaOfLengthBetween(1, 20);
String phase = randomAlphaOfLengthBetween(1, 20);
@ -161,4 +176,75 @@ public class MockIndexLifecycleContextTests extends ESTestCase {
assertEquals(1L, action.getExecutedCount());
assertEquals(true, listenerCalled.get());
}
public void testFailOnPhaseSetter() {
String phase = randomAlphaOfLengthBetween(1, 20);
String action = randomAlphaOfLengthBetween(1, 20);
MockIndexLifecycleContext context = new MockIndexLifecycleContext(randomAlphaOfLengthBetween(1, 20),
phase, action, randomIntBetween(0, 10)) {
@Override
public boolean canExecute(Phase phase) {
throw new AssertionError("canExecute should not have been called.");
}
};
RuntimeException exception = new RuntimeException();
context.failOnSetters(exception);
SetOnce<Exception> listenerCalled = new SetOnce<>();
context.setPhase(randomAlphaOfLengthBetween(1, 20), new Listener() {
@Override
public void onSuccess() {
throw new AssertionError("Unexpected method call");
}
@Override
public void onFailure(Exception e) {
listenerCalled.set(e);
}
});
assertSame(exception, listenerCalled.get());
assertEquals(phase, context.getPhase());
assertEquals(action, context.getAction());
}
public void testFailOnActionSetter() {
String phase = randomAlphaOfLengthBetween(1, 20);
String action = randomAlphaOfLengthBetween(1, 20);
MockIndexLifecycleContext context = new MockIndexLifecycleContext(randomAlphaOfLengthBetween(1, 20),
phase, action, randomIntBetween(0, 10)) {
@Override
public boolean canExecute(Phase phase) {
throw new AssertionError("canExecute should not have been called.");
}
};
RuntimeException exception = new RuntimeException();
context.failOnSetters(exception);
SetOnce<Exception> listenerCalled = new SetOnce<>();
context.setAction(randomAlphaOfLengthBetween(1, 20), new Listener() {
@Override
public void onSuccess() {
throw new AssertionError("Unexpected method call");
}
@Override
public void onFailure(Exception e) {
listenerCalled.set(e);
}
});
assertSame(exception, listenerCalled.get());
assertEquals(phase, context.getPhase());
assertEquals(action, context.getAction());
}
}

89
x-pack/plugin/src/test/java/org/elasticsearch/xpack/indexlifecycle/TimeseriesLifecyclePolicyTests.java
View File

@ -44,6 +44,7 @@ public class TimeseriesLifecyclePolicyTests extends AbstractSerializingTestCase<
private static final ReplicasAction TEST_REPLICAS_ACTION = new ReplicasAction(1);
private static final RolloverAction TEST_ROLLOVER_ACTION = new RolloverAction("", new ByteSizeValue(1), null, null);
private static final ShrinkAction TEST_SHRINK_ACTION = new ShrinkAction();
private static final List<String> VALID_PHASE_NAMES = Arrays.asList();
@Before
public void setup() {
@ -63,7 +64,33 @@ public class TimeseriesLifecyclePolicyTests extends AbstractSerializingTestCase<
@Override
protected LifecyclePolicy createTestInstance() {
return new TimeseriesLifecyclePolicy(lifecycleName, Collections.emptyMap());
Map<String, Phase> phases = TimeseriesLifecyclePolicy.VALID_PHASES.stream()
.map(phaseName -> new Phase(phaseName,
TimeValue.parseTimeValue(randomTimeValue(0, 1000000000, "s", "m", "h", "d"), "test_after"), Collections.emptyMap()))
.collect(Collectors.toMap(Phase::getName, Function.identity()));
return new TimeseriesLifecyclePolicy(lifecycleName, phases);
}
@Override
protected LifecyclePolicy mutateInstance(LifecyclePolicy instance) throws IOException {
String name = instance.getName();
Map<String, Phase> phases = instance.getPhases();
switch (between(0, 1)) {
case 0:
name = name + randomAlphaOfLengthBetween(1, 5);
break;
case 1:
phases = randomValueOtherThan(phases,
() -> TimeseriesLifecyclePolicy.VALID_PHASES.stream()
.map(phaseName -> new Phase(phaseName,
TimeValue.parseTimeValue(randomTimeValue(0, 1000000000, "s", "m", "h", "d"), "test_after"),
Collections.emptyMap()))
.collect(Collectors.toMap(Phase::getName, Function.identity())));
break;
default:
throw new AssertionError("Illegal randomisation branch");
}
return new TimeseriesLifecyclePolicy(name, phases);
}
@Override
@ -229,13 +256,21 @@ public class TimeseriesLifecyclePolicyTests extends AbstractSerializingTestCase<
Map<String, LifecycleAction> actions = VALID_HOT_ACTIONS
.stream().map(this::getTestAction).collect(Collectors.toMap(LifecycleAction::getWriteableName, Function.identity()));
Phase hotPhase = new Phase("hot", TimeValue.ZERO, actions);
MockIndexLifecycleContext context = new MockIndexLifecycleContext(indexName, "", "", 0){};
MockIndexLifecycleContext context = new MockIndexLifecycleContext(indexName, "", "", 0) {
@Override
public boolean canExecute(Phase phase) {
assertSame(hotPhase, phase);
return true;
}
};
TimeseriesLifecyclePolicy policy = new TimeseriesLifecyclePolicy(lifecycleName, Collections.singletonMap("hot", hotPhase));
LifecyclePolicy.NextActionProvider provider = policy.getActionProvider(context, hotPhase);
assertThat(provider.next(null), equalTo(TEST_ROLLOVER_ACTION));
assertNull(provider.next(TEST_ROLLOVER_ACTION));
}
@AwaitsFix(bugUrl = "This gets into an infinite loop if there are other actions as well as the replicas action")
public void testWarmActionProviderReplicasActionSortOrder() {
String indexName = randomAlphaOfLengthBetween(1, 10);
Map<String, LifecycleAction> actions = randomSubsetOf(VALID_WARM_ACTIONS)
@ -243,17 +278,36 @@ public class TimeseriesLifecyclePolicyTests extends AbstractSerializingTestCase<
actions.put(ReplicasAction.NAME, TEST_REPLICAS_ACTION);
Phase warmPhase = new Phase("warm", TimeValue.ZERO, actions);
MockIndexLifecycleContext context =new MockIndexLifecycleContext(indexName, "", "",
TEST_REPLICAS_ACTION.getNumberOfReplicas() + 1){};
TEST_REPLICAS_ACTION.getNumberOfReplicas() + 1) {
@Override
public boolean canExecute(Phase phase) {
assertSame(warmPhase, phase);
return true;
}
};
TimeseriesLifecyclePolicy policy = new TimeseriesLifecyclePolicy(lifecycleName, Collections.singletonMap("warm", warmPhase));
LifecyclePolicy.NextActionProvider provider = policy.getActionProvider(context, warmPhase);
assertThat(provider.next(null), equalTo(TEST_REPLICAS_ACTION));
context = new MockIndexLifecycleContext(indexName, "", "",
TEST_REPLICAS_ACTION.getNumberOfReplicas() - 1){};
TEST_REPLICAS_ACTION.getNumberOfReplicas() - 1) {
@Override
public boolean canExecute(Phase phase) {
assertSame(warmPhase, phase);
return true;
}
};
provider = policy.getActionProvider(context, warmPhase);
if (actions.size() > 1) {
LifecycleAction current = provider.next(null);
assertThat(current, not(equalTo(TEST_REPLICAS_ACTION)));
while (true) {
// NOCOMMIT This loop never exits as there is no break condition
// also provider.next(current) never evaluates to null because
// when called with the replicas action it always returns a
// non-null action. We should avoid using while true here
// because it means if there is a bug we will hang the build
if (provider.next(current) == null) {
assertThat(current, equalTo(TEST_REPLICAS_ACTION));
} else {
@ -272,12 +326,26 @@ public class TimeseriesLifecyclePolicyTests extends AbstractSerializingTestCase<
actions.put(ReplicasAction.NAME, TEST_REPLICAS_ACTION);
Phase coldPhase = new Phase("cold", TimeValue.ZERO, actions);
MockIndexLifecycleContext context =new MockIndexLifecycleContext(indexName, "", "",
TEST_REPLICAS_ACTION.getNumberOfReplicas() + 1){};
TEST_REPLICAS_ACTION.getNumberOfReplicas() + 1) {
@Override
public boolean canExecute(Phase phase) {
assertSame(coldPhase, phase);
return true;
}
};
TimeseriesLifecyclePolicy policy = new TimeseriesLifecyclePolicy(lifecycleName, Collections.singletonMap("cold", coldPhase));
LifecyclePolicy.NextActionProvider provider = policy.getActionProvider(context, coldPhase);
assertThat(provider.next(null), equalTo(TEST_REPLICAS_ACTION));
context = new MockIndexLifecycleContext(indexName, "", "",
TEST_REPLICAS_ACTION.getNumberOfReplicas() - 1){};
TEST_REPLICAS_ACTION.getNumberOfReplicas() - 1) {
@Override
public boolean canExecute(Phase phase) {
assertSame(coldPhase, phase);
return true;
}
};
provider = policy.getActionProvider(context, coldPhase);
if (actions.size() > 1) {
LifecycleAction current = provider.next(null);
@ -294,7 +362,14 @@ public class TimeseriesLifecyclePolicyTests extends AbstractSerializingTestCase<
.stream().map(this::getTestAction).collect(Collectors.toMap(LifecycleAction::getWriteableName, Function.identity()));
Phase deletePhase = new Phase("delete", TimeValue.ZERO, actions);
MockIndexLifecycleContext context = new MockIndexLifecycleContext(indexName, "", "", 0){};
MockIndexLifecycleContext context = new MockIndexLifecycleContext(indexName, "", "", 0) {
@Override
public boolean canExecute(Phase phase) {
assertSame(deletePhase, phase);
return true;
}
};
TimeseriesLifecyclePolicy policy = new TimeseriesLifecyclePolicy(lifecycleName, Collections.singletonMap("delete", deletePhase));
LifecyclePolicy.NextActionProvider provider = policy.getActionProvider(context, deletePhase);
assertThat(provider.next(null), equalTo(TEST_DELETE_ACTION));