1 package test.integration;
2
3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.assertNull;
5 import static org.junit.Assert.fail;
6 import generated.model.de.fhdw.partner.Account;
7 import generated.model.de.fhdw.partner.AccountNumber;
8 import generated.model.de.fhdw.partner.Bankidentifier;
9 import generated.model.de.fhdw.partner.City;
10 import generated.model.de.fhdw.partner.Country;
11 import generated.model.de.fhdw.partner.GlobalTelefonbuch;
12 import generated.model.de.fhdw.partner.IBAN_Finder;
13 import generated.model.de.fhdw.partner.Kommunikationskanal;
14 import generated.model.de.fhdw.partner.NatuerlichePerson;
15 import generated.model.de.fhdw.partner.PersonGroups;
16 import generated.model.de.fhdw.partner.Telefon;
17 import generated.model.de.fhdw.partner.Telefonbuch;
18 import generated.model.de.fhdw.partner.TelefonbuchMitPersonAlsKey;
19 import generated.model.de.fhdw.partner.Telefonbuecher;
20 import generated.model.de.fhdw.partner.service.PersonService;
21
22 import java.util.HashSet;
23 import java.util.Iterator;
24 import java.util.Map;
25 import java.util.Set;
26 import java.util.concurrent.ConcurrentHashMap;
27
28 import org.junit.Ignore;
29 import org.junit.Test;
30
31 import de.fhdw.wtf.context.model.Int;
32 import de.fhdw.wtf.context.model.Str;
33 import de.fhdw.wtf.context.model.collections.ImmutableCollection;
34 import de.fhdw.wtf.context.model.collections.MutableList;
35 import de.fhdw.wtf.context.model.collections.MutableMap;
36 import de.fhdw.wtf.context.model.collections.functors.Operator;
37 import de.fhdw.wtf.persistence.exception.PersistenceException;
38
39
40
41
42 public abstract class TestPersonModel extends IntegrationTestSuperClass {
43
44 final Str jonass = new Str("Jonas Tangermann");
45 final Str patricks = new Str("Patrick Sören Stünkel");
46 final Str alexs = new Str("Alexander Sebastian Clauß");
47 final Str chriss = new Str("Christian Probst");
48 final Int i12345 = new Int(12345);
49 final Int i23456 = new Int(23456);
50 final Int i34567 = new Int(34567);
51 final Int i45678 = new Int(45678);
52
53 abstract protected PersonService getPersonService() throws PersistenceException;
54
55 @Ignore
56 public void findPersonTest() throws PersistenceException {
57 final PersonService service = this.getPersonService();
58 service.publish();
59 final ImmutableCollection<NatuerlichePerson> persons = service.findePersonen(new Str("Probst"));
60 assertEquals(this.chriss, persons.front().getName());
61
62 }
63
64 @Ignore
65 public void deleteKanalTest() throws PersistenceException {
66 final PersonService service = this.getPersonService();
67 service.publish();
68 final ImmutableCollection<NatuerlichePerson> persons = service.findePersonen(new Str("Tangermann"));
69 final Iterator<Kommunikationskanal> kanalI = persons.front().getKanal().iterator();
70 while (kanalI.hasNext()) {
71 final Telefon t = (Telefon) kanalI.next();
72 assertEquals(this.i12345, t.getNr());
73 kanalI.remove();
74 }
75 final ImmutableCollection<NatuerlichePerson> personsAfterdel = service.findePersonen(new Str("Tangermann"));
76 final Iterator<Kommunikationskanal> kanalIA = personsAfterdel.front().getKanal().iterator();
77 while (kanalIA.hasNext()) {
78 fail();
79 }
80 }
81
82 @Ignore
83 public void traversalTest() throws PersistenceException {
84 final PersonService service = this.getPersonService();
85 service.publish();
86 final ImmutableCollection<NatuerlichePerson> persons = service.findePersonen(new Str("Clauß"));
87 final Iterator<Kommunikationskanal> kanalI = persons.front().getKanal().iterator();
88 while (kanalI.hasNext()) {
89 final Telefon t = (Telefon) kanalI.next();
90 assertEquals(this.i12345, t.getNr());
91 }
92 }
93
94 @Ignore
95 public void valueChange() throws PersistenceException {
96 final PersonService service = this.getPersonService();
97 service.publish();
98 final ImmutableCollection<NatuerlichePerson> persons = service.findePersonen(new Str("Stünkel"));
99 final NatuerlichePerson current = persons.front();
100 assertEquals(this.patricks, current.getName());
101 current.setName(current.getName().concat(new Str("us")));
102 final ImmutableCollection<NatuerlichePerson> personsAfterValueChange =
103 service.findePersonen(new Str("Stünkel%"));
104 assertEquals(new Str("Patrick Sören Stünkelus"), personsAfterValueChange.front().getName());
105 }
106
107 @Ignore
108 public void testAggregation() throws Exception {
109 final PersonService service = this.getPersonService();
110 service.publish();
111 final ImmutableCollection<NatuerlichePerson> persons = service.findePersonen(new Str("Stünkel"));
112 assertEquals(new Int(1), persons.reduce(new Operator<NatuerlichePerson, Int>() {
113
114 @Override
115 public Int n() {
116 return new Int(0);
117 }
118
119 @Override
120 public Int add(final Int first, final NatuerlichePerson second) {
121 return first.add(new Int(1));
122 }
123 }));
124 }
125
126 @Test
127 public void testMapGetValue() throws Exception {
128 final PersonService service = this.getPersonService();
129 service.publish();
130 final NatuerlichePerson alex = service.createPerson(this.alexs);
131 final Telefon talex = service.createTelefon(this.i12345);
132
133 final Telefonbuch telefonbuch = service.createTelefonbuch();
134 service.addTelefonbuchEintrag(telefonbuch, talex, alex);
135 final NatuerlichePerson inhaber = service.findeInhaberEinesTelefons(telefonbuch, talex);
136 assertEquals(alex, inhaber);
137 }
138
139 @Test
140 public void testMapRemove() throws Exception {
141 final PersonService service = this.getPersonService();
142 service.publish();
143 final NatuerlichePerson alex = service.createPerson(this.alexs);
144 final Telefon talex = service.createTelefon(this.i12345);
145
146 final Telefonbuch telefonbuch = service.createTelefonbuch();
147 service.addTelefonbuchEintrag(telefonbuch, talex, alex);
148 final NatuerlichePerson inhaber = service.entferneInhaberEinesTelefons(telefonbuch, talex);
149 assertEquals(alex, inhaber);
150 final NatuerlichePerson geloeschterInhaber = service.findeInhaberEinesTelefons(telefonbuch, talex);
151 assertNull(geloeschterInhaber);
152 }
153
154 @Test
155 public void testMapMapMap() throws Exception {
156 final PersonService service = this.getPersonService();
157 service.publish();
158 final IBAN_Finder finder = service.createIban_Finder();
159 final Country country = service.createCountry(new Str("DE"));
160 final Bankidentifier blz = service.createBankidentifier(new Int(500100));
161 final AccountNumber number = service.createAccountNumber(new Int(12321312));
162 final Account account = service.createAccount();
163
164 service.addAccount(finder, country, blz, number, account);
165
166 final Account foundaccount = service.findAccount(finder, country, blz, number);
167
168 assertEquals(account, foundaccount);
169 }
170
171 @Test
172 public void testSetSet() throws Exception {
173 final PersonService service = this.getPersonService();
174 service.publish();
175 final PersonGroups groups = service.createPersonGroups();
176 final NatuerlichePerson p1 = service.createPerson(this.alexs);
177 final NatuerlichePerson p2 = service.createPerson(this.chriss);
178 final NatuerlichePerson p3 = service.createPerson(this.jonass);
179 final NatuerlichePerson p4 = service.createPerson(this.patricks);
180
181 final MutableList<NatuerlichePerson> set1 = new MutableList<>();
182 set1.insert(p1);
183 set1.insert(p2);
184 final MutableList<NatuerlichePerson> set2 = new MutableList<>();
185 set2.insert(p3);
186 set2.insert(p4);
187 service.addPersonGroup(groups, set1);
188 service.addPersonGroup(groups, set2);
189
190 final Set<Set<NatuerlichePerson>> expected = new HashSet<>();
191 final Set<NatuerlichePerson> g1 = new HashSet<>();
192 g1.add(p1);
193 g1.add(p2);
194 final Set<NatuerlichePerson> g2 = new HashSet<>();
195 g2.add(p3);
196 g2.add(p4);
197 expected.add(g1);
198 expected.add(g2);
199
200 final Set<Set<NatuerlichePerson>> actual = new HashSet<>();
201
202 final Iterator<MutableList<NatuerlichePerson>> groupIterator = groups.getPersonGroups().iterator();
203 while (groupIterator.hasNext()) {
204 final MutableList<NatuerlichePerson> personSet = groupIterator.next();
205 final Iterator<NatuerlichePerson> personIterator = personSet.iterator();
206
207 final Set<NatuerlichePerson> innerSet = new HashSet<>();
208 while (personIterator.hasNext()) {
209 final NatuerlichePerson person = personIterator.next();
210 innerSet.add(person);
211 }
212
213 actual.add(innerSet);
214 }
215
216 assertEquals(expected, actual);
217 }
218
219 @Test
220 public void testSetMapSet() throws Exception {
221 final PersonService service = this.getPersonService();
222 service.publish();
223 final TelefonbuchMitPersonAlsKey telefonbuch1 = service.createTelefonbuchMitPersonAlsKey();
224 final TelefonbuchMitPersonAlsKey telefonbuch2 = service.createTelefonbuchMitPersonAlsKey();
225 final Telefonbuecher telefonbuecher = service.createTelefonbuecher();
226
227 final NatuerlichePerson p1 = service.createPerson(this.alexs);
228 final Telefon telefonAlex1 = service.createTelefon(this.i12345);
229 final Telefon telefonAlex2 = service.createTelefon(this.i23456);
230 final MutableList<Telefon> telefonAlex = new MutableList<>();
231 telefonAlex.insert(telefonAlex1);
232 telefonAlex.insert(telefonAlex2);
233
234 final NatuerlichePerson p2 = service.createPerson(this.chriss);
235 final Telefon telefonChris1 = service.createTelefon(this.i34567);
236 final Telefon telefonChris2 = service.createTelefon(this.i45678);
237 final MutableList<Telefon> telefonChris = new MutableList<>();
238 telefonChris.insert(telefonChris1);
239 telefonChris.insert(telefonChris2);
240
241 service.addTelefonnummernZuPerson(telefonbuch1, p1, telefonAlex);
242 service.addTelefonnummernZuPerson(telefonbuch2, p2, telefonChris);
243
244 telefonbuecher.addTelefonbuch(telefonbuch1.getEintraege());
245 telefonbuecher.addTelefonbuch(telefonbuch2.getEintraege());
246
247
248 final Set<Map<NatuerlichePerson, Set<Telefon>>> expected = new HashSet<>();
249 final Set<Telefon> telefonAlexHashSet = new HashSet<>();
250 telefonAlexHashSet.add(telefonAlex1);
251 telefonAlexHashSet.add(telefonAlex2);
252 final Set<Telefon> telefonChrisHashSet = new HashSet<>();
253 telefonChrisHashSet.add(telefonChris1);
254 telefonChrisHashSet.add(telefonChris2);
255
256 final Map<NatuerlichePerson, Set<Telefon>> telefonbuchMitAlex = new ConcurrentHashMap<>();
257 telefonbuchMitAlex.put(p1, telefonAlexHashSet);
258 final Map<NatuerlichePerson, Set<Telefon>> telefonbuchMitChris = new ConcurrentHashMap<>();
259 telefonbuchMitChris.put(p2, telefonChrisHashSet);
260
261 expected.add(telefonbuchMitAlex);
262 expected.add(telefonbuchMitChris);
263
264
265 final Set<Map<NatuerlichePerson, Set<Telefon>>> actual = new HashSet<>();
266
267 final Iterator<MutableMap<NatuerlichePerson, MutableList<Telefon>>> iterator =
268 telefonbuecher.getTelefonbuecher().iterator();
269 while (iterator.hasNext()) {
270 final Map<NatuerlichePerson, Set<Telefon>> telefonbuchToFill = new ConcurrentHashMap<>();
271
272 final MutableMap<NatuerlichePerson, MutableList<Telefon>> telefonbuch = iterator.next();
273 NatuerlichePerson person = p1;
274 MutableList<Telefon> innerSet = telefonbuch.get(p1);
275 if (innerSet == null) {
276 innerSet = telefonbuch.get(p2);
277 person = p2;
278 }
279
280 final Iterator<Telefon> innerIterator = innerSet.iterator();
281 final Set<Telefon> setToFill = new HashSet<>();
282 while (innerIterator.hasNext()) {
283 setToFill.add(innerIterator.next());
284 }
285
286 telefonbuchToFill.put(person, setToFill);
287 actual.add(telefonbuchToFill);
288 }
289
290 assertEquals(expected, actual);
291 }
292
293 @Test
294 public void testMapSetMap() throws Exception {
295 final PersonService service = this.getPersonService();
296 service.publish();
297
298 final Telefonbuch telefonbuch1 = service.createTelefonbuch();
299 final Telefonbuch telefonbuch2 = service.createTelefonbuch();
300 final GlobalTelefonbuch globalTelefonbuch = service.createGlobalTelefonbuch();
301
302 final City hannover = service.createCity(new Str("Hannover"));
303 final NatuerlichePerson alex = service.createPerson(this.alexs);
304 final Telefon telefonAlex1 = service.createTelefon(this.i12345);
305 service.addTelefonbuchEintrag(telefonbuch1, telefonAlex1, alex);
306
307 final City dortmund = service.createCity(new Str("Dortmund"));
308 final NatuerlichePerson chris = service.createPerson(this.chriss);
309 final Telefon telefonChris1 = service.createTelefon(this.i34567);
310 service.addTelefonbuchEintrag(telefonbuch2, telefonChris1, chris);
311
312 globalTelefonbuch.addTelefonbuchToCity(hannover, telefonbuch1);
313 globalTelefonbuch.addTelefonbuchToCity(dortmund, telefonbuch2);
314
315
316 final Map<City, Set<Map<Telefon, NatuerlichePerson>>> expected = new ConcurrentHashMap<>();
317 final Map<Telefon, NatuerlichePerson> telefonbuch1ex = new ConcurrentHashMap<>();
318 telefonbuch1ex.put(telefonAlex1, alex);
319 final Set<Map<Telefon, NatuerlichePerson>> firstSet = new HashSet<>();
320 firstSet.add(telefonbuch1ex);
321
322 final Map<Telefon, NatuerlichePerson> telefonbuch2ex = new ConcurrentHashMap<>();
323 telefonbuch2ex.put(telefonChris1, chris);
324 final Set<Map<Telefon, NatuerlichePerson>> secondSet = new HashSet<>();
325 secondSet.add(telefonbuch2ex);
326
327 expected.put(hannover, firstSet);
328 expected.put(dortmund, secondSet);
329
330
331 final Map<City, Set<Map<Telefon, NatuerlichePerson>>> actual = new ConcurrentHashMap<>();
332
333 final Set<Map<Telefon, NatuerlichePerson>> actualHannoverSet = new HashSet<>();
334 final MutableList<MutableMap<Telefon, NatuerlichePerson>> hannoverSet =
335 globalTelefonbuch.getTelefonbuchMapsPerCity().get(hannover);
336 final Iterator<MutableMap<Telefon, NatuerlichePerson>> hannoverIterator = hannoverSet.iterator();
337 while (hannoverIterator.hasNext()) {
338 final MutableMap<Telefon, NatuerlichePerson> telefonbuchHannover = hannoverIterator.next();
339 final NatuerlichePerson personHannover = telefonbuchHannover.get(telefonAlex1);
340 final Map<Telefon, NatuerlichePerson> actualHannoverMap = new ConcurrentHashMap<>();
341 actualHannoverMap.put(telefonAlex1, personHannover);
342 actualHannoverSet.add(actualHannoverMap);
343 }
344 actual.put(hannover, actualHannoverSet);
345
346 final Set<Map<Telefon, NatuerlichePerson>> actualDortmundSet = new HashSet<>();
347 final MutableList<MutableMap<Telefon, NatuerlichePerson>> dortmundSet =
348 globalTelefonbuch.getTelefonbuchMapsPerCity().get(dortmund);
349 final Iterator<MutableMap<Telefon, NatuerlichePerson>> dortmundIterator = dortmundSet.iterator();
350 while (dortmundIterator.hasNext()) {
351 final MutableMap<Telefon, NatuerlichePerson> telefonbuchdortmund = dortmundIterator.next();
352 final NatuerlichePerson personDortmund = telefonbuchdortmund.get(telefonChris1);
353 final Map<Telefon, NatuerlichePerson> actualDortmundMap = new ConcurrentHashMap<>();
354 actualDortmundMap.put(telefonChris1, personDortmund);
355 actualDortmundSet.add(actualDortmundMap);
356 }
357 actual.put(dortmund, actualDortmundSet);
358
359 assertEquals(expected, actual);
360 }
361 }