-
Notifications
You must be signed in to change notification settings - Fork 214
/
PolicyAnnouncementManagerTest.java
131 lines (114 loc) · 5.35 KB
/
PolicyAnnouncementManagerTest.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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/*
* Copyright (c) 2021 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.policies.service.persistence.actors.announcements;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import org.eclipse.ditto.json.JsonPointer;
import org.eclipse.ditto.policies.model.PoliciesModelFactory;
import org.eclipse.ditto.policies.model.Policy;
import org.eclipse.ditto.policies.model.PolicyId;
import org.eclipse.ditto.policies.model.PolicyLifecycle;
import org.eclipse.ditto.policies.model.Subject;
import org.eclipse.ditto.policies.model.SubjectAnnouncement;
import org.eclipse.ditto.policies.model.SubjectId;
import org.eclipse.ditto.policies.model.SubjectType;
import org.junit.After;
import org.junit.Test;
import org.apache.pekko.actor.AbstractActor;
import org.apache.pekko.actor.ActorRef;
import org.apache.pekko.actor.ActorSystem;
import org.apache.pekko.actor.Props;
import org.apache.pekko.actor.Terminated;
import org.apache.pekko.japi.pf.ReceiveBuilder;
import org.apache.pekko.testkit.javadsl.TestKit;
/**
* Tests {@link PolicyAnnouncementManager}.
*/
public final class PolicyAnnouncementManagerTest {
private final ActorSystem system = ActorSystem.create();
@After
public void shutdown() {
TestKit.shutdownActorSystem(system);
}
@Test
public void deleting2SubjectsPublishesSubjectDeletionAnnouncement() {
new TestKit(system) {{
final Props forwarderProps = Props.create(Forwarder.class, () -> new Forwarder(getRef()));
final Props propsUnderTest = Props.create(PolicyAnnouncementManager.class,
() -> new PolicyAnnouncementManager(s -> forwarderProps));
final var subjectId = SubjectId.newInstance("issue:subject");
final var announcement = SubjectAnnouncement.of(null, true);
final var subject1 = Subject.newInstance(subjectId, SubjectType.newInstance("type1"), null, announcement);
final var subject2 = Subject.newInstance(subjectId, SubjectType.newInstance("type2"), null, announcement);
final var subject3 = Subject.newInstance("issuer:subject3", SubjectType.newInstance("type3"));
final Policy policy1 = PoliciesModelFactory.newPolicyBuilder(PolicyId.of("policy:id"))
.setLifecycle(PolicyLifecycle.ACTIVE)
.forLabel("label1")
.setSubject(subject1)
.setSubject(subject3)
.setGrantedPermissions("thing", JsonPointer.empty(), "READ", "WRITE")
.setGrantedPermissions("policy", JsonPointer.empty(), "READ", "WRITE")
.forLabel("label2")
.setSubject(subject2)
.setGrantedPermissions("thing", JsonPointer.empty(), "READ", "WRITE")
.build();
final Policy policy2 = policy1.toBuilder()
.forLabel("label1")
.removeSubject(subject1)
.forLabel("label2")
.removeSubject(subject2)
.build();
final ActorRef underTest = childActorOf(propsUnderTest, "underTest");
underTest.tell(policy1, getRef());
final var child1 = watch(expectMsgClass(ActorRef.class));
final var child2 = watch(expectMsgClass(ActorRef.class));
underTest.tell(policy2, getRef());
final var terminatedActor = new AtomicReference<ActorRef>();
final var subjectDeletedActor = new AtomicReference<ActorRef>();
final Consumer<Object> assertMessage = message -> {
if (message instanceof Terminated) {
terminatedActor.set(((Terminated) message).getActor());
} else {
assertThat(message).isEqualTo(SubjectExpiryActor.Message.SUBJECT_DELETED);
subjectDeletedActor.set(getLastSender());
}
};
final var message1 = expectMsgClass(Object.class);
assertMessage.accept(message1);
final var message2 = expectMsgClass(Object.class);
assertMessage.accept(message2);
final var childActors = Set.of(child1, child2);
assertThat(terminatedActor.get()).isIn(childActors);
assertThat(subjectDeletedActor.get()).isIn(childActors);
assertThat(terminatedActor.get()).isNotEqualTo(subjectDeletedActor.get());
}};
}
private static final class Forwarder extends AbstractActor {
private final ActorRef actorRef;
private Forwarder(final ActorRef actorRef) {
this.actorRef = actorRef;
}
@Override
public void preStart() {
actorRef.tell(getSelf(), getSelf());
}
@Override
public Receive createReceive() {
return ReceiveBuilder.create()
.matchAny(message -> actorRef.tell(message, getSelf()))
.build();
}
}
}