-
Notifications
You must be signed in to change notification settings - Fork 214
/
PersistenceActorTestBase.java
176 lines (151 loc) · 7.61 KB
/
PersistenceActorTestBase.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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
/*
* 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.policies.service.persistence.actors;
import static java.util.Objects.requireNonNull;
import static org.eclipse.ditto.policies.service.persistence.TestConstants.Policy.SUBJECT_TYPE;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import org.eclipse.ditto.base.model.auth.AuthorizationModelFactory;
import org.eclipse.ditto.base.model.auth.AuthorizationSubject;
import org.eclipse.ditto.base.model.auth.DittoAuthorizationContextType;
import org.eclipse.ditto.base.model.headers.DittoHeaders;
import org.eclipse.ditto.base.model.json.JsonSchemaVersion;
import org.eclipse.ditto.json.JsonPointer;
import org.eclipse.ditto.policies.api.Permission;
import org.eclipse.ditto.policies.model.EffectedPermissions;
import org.eclipse.ditto.policies.model.Label;
import org.eclipse.ditto.policies.model.Permissions;
import org.eclipse.ditto.policies.model.PoliciesModelFactory;
import org.eclipse.ditto.policies.model.PoliciesResourceType;
import org.eclipse.ditto.policies.model.Policy;
import org.eclipse.ditto.policies.model.PolicyEntry;
import org.eclipse.ditto.policies.model.PolicyId;
import org.eclipse.ditto.policies.model.PolicyLifecycle;
import org.eclipse.ditto.policies.model.Resource;
import org.eclipse.ditto.policies.model.Resources;
import org.eclipse.ditto.policies.model.Subject;
import org.eclipse.ditto.policies.model.SubjectId;
import org.eclipse.ditto.policies.model.SubjectIssuer;
import org.eclipse.ditto.policies.model.Subjects;
import org.eclipse.ditto.policies.service.common.config.DefaultPolicyConfig;
import org.eclipse.ditto.policies.service.common.config.PolicyConfig;
import org.eclipse.ditto.policies.service.persistence.TestConstants;
import org.junit.After;
import org.junit.BeforeClass;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.apache.pekko.actor.ActorRef;
import org.apache.pekko.actor.ActorSystem;
import org.apache.pekko.stream.Attributes;
import org.apache.pekko.testkit.TestProbe;
import org.apache.pekko.testkit.javadsl.TestKit;
/**
* Base test class for testing persistence actors of the policies persistence.
*/
public abstract class PersistenceActorTestBase {
protected static final PolicyId POLICY_ID = PolicyId.of("org.eclipse.ditto", "myPolicy");
protected static final PolicyLifecycle POLICY_LIFECYCLE = PolicyLifecycle.ACTIVE;
protected static final JsonPointer POLICY_RESOURCE_PATH = JsonPointer.empty();
protected static final Resource POLICY_RESOURCE_ALL =
Resource.newInstance(PoliciesResourceType.policyResource(POLICY_RESOURCE_PATH),
EffectedPermissions.newInstance(TestConstants.Policy.PERMISSIONS_ALL,
PoliciesModelFactory.noPermissions()));
protected static final Resource POLICY_RESOURCE_READ =
Resource.newInstance(PoliciesResourceType.policyResource(POLICY_RESOURCE_PATH),
EffectedPermissions.newInstance(Permissions.newInstance(Permission.READ),
PoliciesModelFactory.noPermissions()));
private static final SubjectIssuer ISSUER_GOOGLE = SubjectIssuer.GOOGLE;
protected static final SubjectId POLICY_SUBJECT_ID = SubjectId.newInstance(ISSUER_GOOGLE, "allowedId");
protected static final Subject POLICY_SUBJECT = Subject.newInstance(POLICY_SUBJECT_ID, SUBJECT_TYPE);
protected static final Resources POLICY_RESOURCES_ALL = Resources.newInstance(POLICY_RESOURCE_ALL);
protected static final Resources POLICY_RESOURCES_READ = Resources.newInstance(POLICY_RESOURCE_READ);
protected static final Subjects POLICY_SUBJECTS = Subjects.newInstance(POLICY_SUBJECT);
protected static final Label POLICY_LABEL = Label.of("all");
protected static final Label ANOTHER_POLICY_LABEL = Label.of("another");
protected static final String AUTH_SUBJECT = ISSUER_GOOGLE + ":allowedId";
protected static final String UNAUTH_SUBJECT = ISSUER_GOOGLE + ":denied";
private static final PolicyEntry POLICY_ENTRY =
PoliciesModelFactory.newPolicyEntry(POLICY_LABEL, POLICY_SUBJECTS, POLICY_RESOURCES_ALL);
protected static final PolicyEntry ANOTHER_POLICY_ENTRY =
PoliciesModelFactory.newPolicyEntry(ANOTHER_POLICY_LABEL, POLICY_SUBJECTS, POLICY_RESOURCES_READ);
private static final long POLICY_REVISION = 0;
static final Instant TIMESTAMP = Instant.EPOCH;
protected static Config testConfig;
protected static PolicyConfig policyConfig;
protected ActorSystem actorSystem = null;
protected ActorRef pubSubMediator = null;
protected TestProbe pubSubMediatorTestProbe = null;
protected DittoHeaders dittoHeadersV2;
@BeforeClass
public static void initTestFixture() {
testConfig = ConfigFactory.load("test");
policyConfig = DefaultPolicyConfig.of(testConfig.getConfig("ditto.policies"));
}
protected static DittoHeaders createDittoHeaders(final JsonSchemaVersion schemaVersion,
final String... authSubjectIds) {
final List<AuthorizationSubject> authSubjects = Arrays.stream(authSubjectIds)
.map(AuthorizationModelFactory::newAuthSubject)
.collect(Collectors.toList());
return DittoHeaders.newBuilder()
.correlationId(null)
.schemaVersion(schemaVersion)
.authorizationContext(
AuthorizationModelFactory.newAuthContext(DittoAuthorizationContextType.UNSPECIFIED,
authSubjects))
.build();
}
protected static Policy createPolicyWithRandomId() {
final Random rnd = new Random();
final String policyName = POLICY_ID.getName() + rnd.nextInt();
return createPolicyWithId(policyName);
}
protected static Policy createPolicyWithId(final String policyName) {
return PoliciesModelFactory.newPolicyBuilder(PolicyId.of("test.ns", policyName))
.setLifecycle(POLICY_LIFECYCLE)
.set(POLICY_ENTRY)
.set(ANOTHER_POLICY_ENTRY)
.setRevision(POLICY_REVISION)
.build();
}
protected void setup(final Config customConfig) {
requireNonNull(customConfig, "Consider to use ConfigFactory.empty()");
final Config config = customConfig.withFallback(ConfigFactory.load("test"));
init(config);
}
protected void setUpBase() {
final Config config = ConfigFactory.load("test");
init(config);
}
private void init(final Config config) {
actorSystem = ActorSystem.create("AkkaTestSystem", config);
pubSubMediatorTestProbe = new TestProbe(actorSystem, "mock-pubSub-mediator");
pubSubMediator = pubSubMediatorTestProbe.ref();
dittoHeadersV2 = createDittoHeaders(JsonSchemaVersion.V_2, AUTH_SUBJECT);
}
@After
public void tearDownBase() {
if (actorSystem != null) {
TestKit.shutdownActorSystem(actorSystem);
actorSystem = null;
}
}
/**
* Disable logging for 1 test to hide stacktrace or other logs on level ERROR. Comment out to debug the test.
*/
protected void disableLogging() {
actorSystem.eventStream().setLogLevel(Attributes.logLevelOff());
}
}