123 lines
4.7 KiB
Java
123 lines
4.7 KiB
Java
/*
|
|
* Copyright (C) 2018 The Dagger Authors.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package dagger.functional.producers.cancellation;
|
|
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
import static java.util.concurrent.TimeUnit.MILLISECONDS;
|
|
|
|
import com.google.common.util.concurrent.ListenableFuture;
|
|
import com.google.common.util.concurrent.MoreExecutors;
|
|
import dagger.functional.producers.cancellation.CancellationComponent.Dependency;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.junit.runners.JUnit4;
|
|
|
|
/** Tests cancellation of tasks in production subcomponents. */
|
|
@RunWith(JUnit4.class)
|
|
public class ProducerSubcomponentCancellationTest {
|
|
|
|
private final ProducerTester tester = new ProducerTester();
|
|
private final CancellationComponent component =
|
|
DaggerCancellationComponent.builder()
|
|
.module(new CancellationModule(tester))
|
|
.dependency(new Dependency(tester))
|
|
.executor(MoreExecutors.directExecutor())
|
|
.build();
|
|
private final CancellationSubcomponent subcomponent =
|
|
component.subcomponentBuilder().module(new CancellationSubcomponentModule(tester)).build();
|
|
|
|
@Test
|
|
public void initialState() {
|
|
tester.assertNoStartedNodes();
|
|
}
|
|
|
|
@Test
|
|
public void cancellingSubcomponent_doesNotCancelParent() throws Exception {
|
|
ListenableFuture<String> subcomponentEntryPoint = subcomponent.subcomponentEntryPoint();
|
|
|
|
// Subcomponent entry point depends on all leaves from the parent component and on the single
|
|
// leaf in the subcomponent itself, so they should all have started.
|
|
tester.assertStarted("leaf1", "leaf2", "leaf3", "subLeaf").only();
|
|
|
|
assertThat(subcomponentEntryPoint.cancel(true)).isTrue();
|
|
assertThat(subcomponentEntryPoint.isCancelled()).isTrue();
|
|
|
|
// None of the tasks running in the parent were cancelled.
|
|
tester.assertNotCancelled("leaf1", "leaf2", "leaf3");
|
|
tester.assertCancelled("subLeaf").only();
|
|
|
|
// Finish all the parent tasks to ensure that it can still complete normally.
|
|
tester.complete(
|
|
"dependencyFuture",
|
|
"leaf1",
|
|
"leaf2",
|
|
"leaf3",
|
|
"foo",
|
|
"bar",
|
|
"baz",
|
|
"qux",
|
|
"entryPoint1",
|
|
"entryPoint2");
|
|
|
|
assertThat(component.entryPoint1().get(1, MILLISECONDS)).isEqualTo("completed");
|
|
assertThat(component.entryPoint2().get().get(1, MILLISECONDS)).isEqualTo("completed");
|
|
}
|
|
|
|
@Test
|
|
public void cancellingSubcomponent_preventsUnstartedNodesFromStarting() {
|
|
ListenableFuture<String> subcomponentEntryPoint = subcomponent.subcomponentEntryPoint();
|
|
|
|
tester.complete("subLeaf");
|
|
tester.assertNotStarted("subTask1", "subTask2");
|
|
|
|
subcomponentEntryPoint.cancel(true);
|
|
|
|
// Complete the remaining dependencies of subTask1 and subTask2.
|
|
tester.complete("leaf1", "leaf2", "leaf3", "foo", "bar", "baz", "qux");
|
|
|
|
// Since the subcomponent was cancelled, they are not started.
|
|
tester.assertNotStarted("subTask1", "subTask2");
|
|
}
|
|
|
|
@Test
|
|
public void cancellingProducerFromComponentDependency_inSubcomponent_cancelsUnderlyingTask()
|
|
throws Exception {
|
|
// Request subcomponent's entry point.
|
|
ListenableFuture<String> subcomponentEntryPoint = subcomponent.subcomponentEntryPoint();
|
|
|
|
// Finish all parent tasks so that the subcomponent's tasks can start.
|
|
tester.complete("leaf1", "leaf2", "leaf3", "foo", "bar", "baz", "qux", "subLeaf");
|
|
|
|
tester.assertStarted("subTask1", "subTask2");
|
|
tester.assertNotCancelled("subTask1", "subTask2");
|
|
|
|
// When subTask2 runs, it cancels the dependency future.
|
|
// TODO(cgdecker): Is this what we want to happen?
|
|
// On the one hand, there's a policy of "futures from component dependencies come from outside
|
|
// our control and should be cancelled unconditionally". On the other hand, the dependency is
|
|
// coming from the parent component, and the policy is also not to cancel things belonging to
|
|
// the parent unless it allows that.
|
|
tester.assertCancelled("dependencyFuture");
|
|
|
|
// The future it returns didn't depend directly on that future, though, so the subcomponent
|
|
// should be able to complete normally.
|
|
tester.complete("subTask1", "subTask2", "subEntryPoint");
|
|
|
|
assertThat(subcomponentEntryPoint.get(1, MILLISECONDS)).isEqualTo("completed");
|
|
}
|
|
}
|