1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.syncope.core.provisioning.api;
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.assertTrue;
24 import static org.mockito.ArgumentMatchers.any;
25 import static org.mockito.Mockito.times;
26 import static org.mockito.Mockito.verify;
27
28 import java.util.ArrayList;
29 import java.util.HashSet;
30 import java.util.List;
31 import java.util.Map;
32 import java.util.Set;
33 import org.apache.commons.lang3.tuple.Pair;
34 import org.apache.syncope.common.lib.types.ResourceOperation;
35 import org.junit.jupiter.api.Test;
36 import org.mockito.Mock;
37 import org.springframework.test.util.ReflectionTestUtils;
38
39 public class PropagationByResourceTest extends AbstractTest {
40
41 private static final String KEY = "testKey";
42
43 private final PropagationByResource<String> propagationByResource = new PropagationByResource<>();
44
45 @Test
46 public void voidMethods(
47 final @Mock Set<String> toBeCreated,
48 final @Mock Set<String> toBeUpdated,
49 final @Mock Set<String> toBeDeleted,
50 final @Mock Map<String, String> oldConnObjectKeys,
51 final @Mock PropagationByResource<String> propByRes) {
52
53 ReflectionTestUtils.setField(propagationByResource, "toBeCreated", toBeCreated);
54 ReflectionTestUtils.setField(propagationByResource, "toBeUpdated", toBeUpdated);
55 ReflectionTestUtils.setField(propagationByResource, "toBeDeleted", toBeDeleted);
56 ReflectionTestUtils.setField(propagationByResource, "oldConnObjectKeys", oldConnObjectKeys);
57
58 propagationByResource.purge();
59 verify(toBeCreated).removeAll(toBeDeleted);
60 verify(toBeCreated).removeAll(toBeUpdated);
61 verify(toBeUpdated).removeAll(toBeDeleted);
62
63 propagationByResource.clear();
64 verify(toBeCreated).clear();
65 verify(toBeCreated).clear();
66 verify(toBeUpdated).clear();
67
68 propagationByResource.merge(null);
69 verify(toBeCreated, times(0)).addAll(any());
70 verify(toBeUpdated, times(0)).addAll(any());
71 verify(toBeDeleted, times(0)).addAll(any());
72 verify(oldConnObjectKeys, times(0)).putAll(any());
73
74 propagationByResource.merge(propByRes);
75 verify(toBeCreated).addAll(any());
76 verify(toBeUpdated).addAll(any());
77 verify(toBeDeleted).addAll(any());
78
79 String oldConnObjectKey = "oldConnObjectKey";
80 propagationByResource.addOldConnObjectKey(KEY, oldConnObjectKey);
81 verify(oldConnObjectKeys).put(KEY, oldConnObjectKey);
82 propagationByResource.addOldConnObjectKey(KEY, null);
83 verify(oldConnObjectKeys, times(0)).put(KEY, null);
84 propagationByResource.addOldConnObjectKey(null, null);
85 verify(oldConnObjectKeys, times(0)).put(null, null);
86 }
87
88 @Test
89 public void add() {
90 assertTrue(propagationByResource.add(ResourceOperation.CREATE, KEY));
91 assertTrue(propagationByResource.add(ResourceOperation.UPDATE, KEY));
92 assertTrue(propagationByResource.add(ResourceOperation.DELETE, KEY));
93 assertFalse(propagationByResource.add(ResourceOperation.NONE, KEY));
94 }
95
96 @Test
97 public void addAll() {
98 List<String> keys = new ArrayList<>();
99 keys.add("testKey1");
100 keys.add("testKey2");
101
102 assertTrue(propagationByResource.addAll(ResourceOperation.CREATE, keys));
103 assertTrue(propagationByResource.addAll(ResourceOperation.UPDATE, keys));
104 assertTrue(propagationByResource.addAll(ResourceOperation.DELETE, keys));
105 assertFalse(propagationByResource.addAll(ResourceOperation.NONE, keys));
106 }
107
108 @Test
109 public void remove() {
110 assertFalse(propagationByResource.remove(ResourceOperation.CREATE, KEY));
111 assertFalse(propagationByResource.remove(ResourceOperation.UPDATE, KEY));
112 assertFalse(propagationByResource.remove(ResourceOperation.DELETE, KEY));
113 assertFalse(propagationByResource.remove(ResourceOperation.NONE, KEY));
114 }
115
116 @Test
117 public void removeAll() {
118 Set<String> keys = new HashSet<>();
119 keys.add("testKey1");
120 keys.add("testKey2");
121
122 assertFalse(propagationByResource.removeAll(ResourceOperation.CREATE, keys));
123 assertFalse(propagationByResource.removeAll(ResourceOperation.UPDATE, keys));
124 assertFalse(propagationByResource.removeAll(ResourceOperation.DELETE, keys));
125 assertFalse(propagationByResource.removeAll(ResourceOperation.NONE, keys));
126 }
127
128 @Test
129 public void removeAndRetainAll() {
130 List<String> keys = new ArrayList<>();
131 keys.add("testKey1");
132 keys.add("testKey2");
133
134 assertFalse(propagationByResource.removeAll(keys));
135 assertFalse(propagationByResource.retainAll(keys));
136 }
137
138 @Test
139 public void contains() {
140 assertFalse(propagationByResource.contains(ResourceOperation.CREATE, KEY));
141 assertFalse(propagationByResource.contains(ResourceOperation.UPDATE, KEY));
142 assertFalse(propagationByResource.contains(ResourceOperation.DELETE, KEY));
143 assertFalse(propagationByResource.contains(ResourceOperation.NONE, KEY));
144
145 Set<String> matchingList = new HashSet<>();
146 matchingList.add(KEY);
147 assertFalse(propagationByResource.contains(KEY));
148
149 ReflectionTestUtils.setField(propagationByResource, "toBeDeleted", matchingList);
150 assertTrue(propagationByResource.contains(KEY));
151 }
152
153 @Test
154 public void get() {
155 Set<String> matchingList = new HashSet<>();
156 matchingList.add(KEY);
157
158 ReflectionTestUtils.setField(propagationByResource, "toBeDeleted", matchingList);
159 assertEquals(matchingList, propagationByResource.get(ResourceOperation.DELETE));
160 assertEquals(Set.of(), propagationByResource.get(ResourceOperation.CREATE));
161 assertEquals(Set.of(), propagationByResource.get(ResourceOperation.UPDATE));
162 assertEquals(Set.of(), propagationByResource.get(ResourceOperation.NONE));
163
164 }
165
166 @Test
167 public void asMap() {
168 assertEquals(Map.of(), propagationByResource.asMap());
169 }
170
171 @Test
172 public void set() {
173 Set<String> keys = new HashSet<>();
174 keys.add("testKey1");
175 keys.add("testKey2");
176
177 propagationByResource.set(ResourceOperation.CREATE, Set.of());
178 assertEquals(Set.of(), ReflectionTestUtils.getField(propagationByResource, "toBeCreated"));
179 propagationByResource.set(ResourceOperation.CREATE, keys);
180 assertEquals(keys, ReflectionTestUtils.getField(propagationByResource, "toBeCreated"));
181 propagationByResource.set(ResourceOperation.UPDATE, keys);
182 assertEquals(keys, ReflectionTestUtils.getField(propagationByResource, "toBeUpdated"));
183 propagationByResource.set(ResourceOperation.DELETE, keys);
184 assertEquals(keys, ReflectionTestUtils.getField(propagationByResource, "toBeDeleted"));
185 }
186
187 @Test
188 public void byLinkedAccount() {
189 PropagationByResource<Pair<String, String>> propByLinkedAccount = new PropagationByResource<>();
190 propByLinkedAccount.add(ResourceOperation.CREATE, Pair.of("resource1", "connObjectKey1"));
191 propByLinkedAccount.add(ResourceOperation.CREATE, Pair.of("resource2", "connObjectKey2"));
192
193 assertEquals(2, propByLinkedAccount.asMap().size());
194 assertEquals(ResourceOperation.CREATE, propByLinkedAccount.asMap().get(Pair.of("resource1", "connObjectKey1")));
195 assertEquals(ResourceOperation.CREATE, propByLinkedAccount.asMap().get(Pair.of("resource2", "connObjectKey2")));
196
197 Set<String> noPropResourceKeys = Set.of("resource2");
198 propByLinkedAccount.get(ResourceOperation.CREATE).
199 removeIf(account -> noPropResourceKeys.contains(account.getLeft()));
200
201 assertEquals(1, propByLinkedAccount.asMap().size());
202 assertEquals(ResourceOperation.CREATE, propByLinkedAccount.asMap().get(Pair.of("resource1", "connObjectKey1")));
203 }
204 }