1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.syncope.core.persistence.jpa.outer;
20
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertFalse;
23 import static org.junit.jupiter.api.Assertions.assertNotNull;
24 import static org.junit.jupiter.api.Assertions.assertNull;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26
27 import java.util.List;
28 import java.util.Set;
29 import java.util.stream.Collectors;
30 import org.apache.syncope.common.lib.to.Item;
31 import org.apache.syncope.common.lib.to.Mapping;
32 import org.apache.syncope.common.lib.to.Provision;
33 import org.apache.syncope.common.lib.types.AnyTypeKind;
34 import org.apache.syncope.common.lib.types.MappingPurpose;
35 import org.apache.syncope.common.lib.types.TaskType;
36 import org.apache.syncope.core.persistence.api.dao.ConnInstanceDAO;
37 import org.apache.syncope.core.persistence.api.dao.ExternalResourceDAO;
38 import org.apache.syncope.core.persistence.api.dao.PolicyDAO;
39 import org.apache.syncope.core.persistence.api.dao.TaskDAO;
40 import org.apache.syncope.core.persistence.api.dao.UserDAO;
41 import org.apache.syncope.core.persistence.api.entity.ConnInstance;
42 import org.apache.syncope.core.persistence.api.entity.ExternalResource;
43 import org.apache.syncope.core.persistence.api.entity.policy.PasswordPolicy;
44 import org.apache.syncope.core.persistence.api.entity.task.PropagationTask;
45 import org.apache.syncope.core.persistence.api.entity.user.User;
46 import org.apache.syncope.core.persistence.jpa.AbstractTest;
47 import org.identityconnectors.framework.common.objects.ObjectClass;
48 import org.junit.jupiter.api.Test;
49 import org.springframework.beans.factory.annotation.Autowired;
50 import org.springframework.transaction.annotation.Transactional;
51
52 @Transactional("Master")
53 public class ResourceTest extends AbstractTest {
54
55 @Autowired
56 private ExternalResourceDAO resourceDAO;
57
58 @Autowired
59 private ConnInstanceDAO connInstanceDAO;
60
61 @Autowired
62 private UserDAO userDAO;
63
64 @Autowired
65 private TaskDAO taskDAO;
66
67 @Autowired
68 private PolicyDAO policyDAO;
69
70 @Test
71 public void createWithPasswordPolicy() {
72 final String resourceName = "resourceWithPasswordPolicy";
73
74 PasswordPolicy policy = policyDAO.find("986d1236-3ac5-4a19-810c-5ab21d79cba1");
75 ExternalResource resource = entityFactory.newEntity(ExternalResource.class);
76 resource.setKey(resourceName);
77 resource.setPasswordPolicy(policy);
78
79 ConnInstance connector = connInstanceDAO.find("88a7a819-dab5-46b4-9b90-0b9769eabdb8");
80 assertNotNull(connector);
81 resource.setConnector(connector);
82
83 ExternalResource actual = resourceDAO.save(resource);
84 assertNotNull(actual);
85
86 actual = resourceDAO.find(actual.getKey());
87 assertNotNull(actual);
88 assertNotNull(actual.getPasswordPolicy());
89
90 resourceDAO.delete(resourceName);
91 assertNull(resourceDAO.find(resourceName));
92
93 assertNotNull(policyDAO.find("986d1236-3ac5-4a19-810c-5ab21d79cba1"));
94 }
95
96 @Test
97 public void save() {
98 ExternalResource resource = entityFactory.newEntity(ExternalResource.class);
99 resource.setKey("ws-target-resource-save");
100
101
102 ConnInstance connector = connInstanceDAO.find("88a7a819-dab5-46b4-9b90-0b9769eabdb8");
103 assertNotNull(connector);
104
105 resource.setConnector(connector);
106
107 Provision provision = new Provision();
108 provision.setAnyType(AnyTypeKind.USER.name());
109 provision.setObjectClass(ObjectClass.ACCOUNT_NAME);
110 resource.getProvisions().add(provision);
111
112 Mapping mapping = new Mapping();
113 provision.setMapping(mapping);
114
115
116 for (int i = 0; i < 3; i++) {
117 Item item = new Item();
118 item.setExtAttrName("test" + i);
119 item.setIntAttrName("nonexistent" + i);
120 item.setMandatoryCondition("false");
121 item.setPurpose(MappingPurpose.PULL);
122 mapping.add(item);
123 }
124 Item connObjectKey = new Item();
125 connObjectKey.setExtAttrName("username");
126 connObjectKey.setIntAttrName("username");
127 connObjectKey.setPurpose(MappingPurpose.PROPAGATION);
128 mapping.setConnObjectKeyItem(connObjectKey);
129
130
131 Item derived = new Item();
132 derived.setConnObjectKey(false);
133 derived.setExtAttrName("fullname");
134 derived.setIntAttrName("cn");
135 derived.setPurpose(MappingPurpose.PROPAGATION);
136 mapping.add(derived);
137
138
139 ExternalResource actual = resourceDAO.save(resource);
140 entityManager().flush();
141 assertNotNull(actual);
142 assertNotNull(actual.getProvisionByAnyType(AnyTypeKind.USER.name()).get().getMapping());
143
144 entityManager().flush();
145 resourceDAO.detach(actual);
146 connInstanceDAO.detach(connector);
147
148
149 User user = userDAO.findByUsername("rossini");
150 assertNotNull(user);
151
152 user.add(actual);
153
154 entityManager().flush();
155
156
157 resource = resourceDAO.find(actual.getKey());
158 assertNotNull(resource);
159 resourceDAO.refresh(resource);
160
161
162 connector = connInstanceDAO.find("88a7a819-dab5-46b4-9b90-0b9769eabdb8");
163 assertNotNull(connector);
164 assertNotNull(connector.getResources());
165
166 assertNotNull(resource.getConnector());
167 assertTrue(resource.getConnector().equals(connector));
168
169
170 List<Item> items = resource.getProvisionByAnyType(
171 AnyTypeKind.USER.name()).get().getMapping().getItems();
172 assertNotNull(items);
173 assertEquals(5, items.size());
174
175
176 user = userDAO.findByUsername("rossini");
177 assertNotNull(user);
178 assertNotNull(user.getResources());
179 assertTrue(user.getResources().contains(actual));
180 }
181
182 @Test
183 public void delete() {
184 ExternalResource resource = resourceDAO.find("resource-testdb");
185 assertNotNull(resource);
186
187
188
189
190 ConnInstance connector = resource.getConnector();
191 assertNotNull(connector);
192
193
194
195
196
197 List<User> users = userDAO.findByResource(resource);
198 assertNotNull(users);
199
200 Set<String> userKeys = users.stream().map(User::getKey).collect(Collectors.toSet());
201
202
203
204 List<PropagationTask> propagationTasks = taskDAO.findAll(
205 TaskType.PROPAGATION, resource, null, null, null, -1, -1, List.of());
206 assertFalse(propagationTasks.isEmpty());
207
208
209 resourceDAO.delete(resource.getKey());
210
211
212 entityManager().flush();
213
214
215 ExternalResource actual = resourceDAO.find("resource-testdb");
216 assertNull(actual);
217
218
219 userKeys.stream().map(userDAO::find).forEach(user -> {
220 assertNotNull(user);
221 userDAO.findAllResources(user).
222 forEach(r -> assertFalse(r.getKey().equalsIgnoreCase(resource.getKey())));
223 });
224
225
226 ConnInstance actualConnector = connInstanceDAO.find(connector.getKey());
227 assertNotNull(actualConnector);
228 actualConnector.getResources().
229 forEach(res -> assertFalse(res.getKey().equalsIgnoreCase(resource.getKey())));
230
231
232 propagationTasks.forEach(task -> assertTrue(taskDAO.find(task.getKey()).isEmpty()));
233 }
234
235 @Test
236 public void issue243() {
237 ExternalResource csv = resourceDAO.find("resource-csv");
238 assertNotNull(csv);
239
240 int origMapItems = csv.getProvisionByAnyType(
241 AnyTypeKind.USER.name()).get().getMapping().getItems().size();
242
243 Item newMapItem = new Item();
244 newMapItem.setIntAttrName("TEST");
245 newMapItem.setExtAttrName("TEST");
246 newMapItem.setPurpose(MappingPurpose.PROPAGATION);
247 csv.getProvisionByAnyType(AnyTypeKind.USER.name()).get().getMapping().add(newMapItem);
248
249 resourceDAO.save(csv);
250 entityManager().flush();
251
252 csv = resourceDAO.find("resource-csv");
253 assertNotNull(csv);
254 assertEquals(
255 origMapItems + 1,
256 csv.getProvisionByAnyType(AnyTypeKind.USER.name()).get().getMapping().getItems().size());
257 }
258 }