/
EnforcerRetrieverTest.java
117 lines (100 loc) · 4.83 KB
/
EnforcerRetrieverTest.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*
* Copyright (c) 2017 Contributors to the Eclipse Foundation
*
* See the NOTICE file(s) distributed with this work for additional
* information regarding copyright ownership.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.ditto.services.concierge.enforcement;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
import org.eclipse.ditto.model.base.common.HttpStatusCode;
import org.eclipse.ditto.model.base.exceptions.DittoRuntimeException;
import org.eclipse.ditto.model.enforcers.Enforcer;
import org.eclipse.ditto.services.utils.cache.Cache;
import org.eclipse.ditto.services.utils.cache.EntityId;
import org.eclipse.ditto.services.utils.cache.entry.Entry;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class EnforcerRetrieverTest {
@Mock
private Cache<EntityId, Entry<EntityId>> idCache;
@Mock
private Cache<EntityId, Entry<Enforcer>> enforcerCache;
private EnforcerRetriever retriever;
@Before
public void setUp() {
retriever = new EnforcerRetriever(idCache, enforcerCache);
}
@Test
public void verifyLookupRevealsInnerException() throws ExecutionException, InterruptedException {
final DittoRuntimeException expectedException =
DittoRuntimeException.newBuilder("this should be happening", HttpStatusCode.HTTPVERSION_NOT_SUPPORTED)
.build();
final EntityId entityId = EntityId.of("any", "id");
when(idCache.get(any(EntityId.class))).thenReturn(
CompletableFuture.completedFuture(Optional.of(Entry.nonexistent())));
final CompletionStage<Void> result = retriever.retrieve(entityId, (entityIdEntry, enforcerEntry) -> {
throw expectedException;
});
verify(idCache).get(entityId);
verifyZeroInteractions(enforcerCache);
verifyException(result, expectedException);
}
@Test
public void verifyLookupRevealsInnermostException() throws ExecutionException, InterruptedException {
final DittoRuntimeException expectedException =
DittoRuntimeException.newBuilder("this should be happening", HttpStatusCode.HTTPVERSION_NOT_SUPPORTED)
.build();
final EntityId entityId = EntityId.of("any", "id");
final EntityId innerEntityId = EntityId.of("other", "randomId");
when(idCache.get(any(EntityId.class))).thenReturn(
CompletableFuture.completedFuture(Optional.of(Entry.permanent(innerEntityId))));
when(enforcerCache.get(any(EntityId.class))).thenReturn(
CompletableFuture.completedFuture(Optional.of(Entry.nonexistent())));
final CompletionStage<Void> result = retriever.retrieve(entityId, (entityIdEntry, enforcerEntry) -> {
throw expectedException;
});
verify(idCache).get(entityId);
verify(enforcerCache).get(innerEntityId);
verifyException(result, expectedException);
}
@Test
public void verifyLookupEnforcerRevealsException() throws ExecutionException, InterruptedException {
final DittoRuntimeException expectedException =
DittoRuntimeException.newBuilder("this should be happening", HttpStatusCode.HTTPVERSION_NOT_SUPPORTED)
.build();
final EntityId entityId = EntityId.of("any", "id");
when(enforcerCache.get(any(EntityId.class))).thenReturn(
CompletableFuture.completedFuture(Optional.of(Entry.nonexistent())));
final CompletionStage<Void> result = retriever.retrieveByEnforcerKey(entityId, enforcerEntry -> {
throw expectedException;
});
verify(enforcerCache).get(entityId);
verifyException(result, expectedException);
}
private void verifyException(final CompletionStage<Void> completionStage, final Throwable expectedException)
throws ExecutionException, InterruptedException {
assertThat(completionStage.thenApply(_void -> new RuntimeException("this should not be happening"))
.exceptionally(executionException -> (RuntimeException) executionException.getCause())
.toCompletableFuture()
.get())
.isEqualTo(expectedException);
}
}