1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.exoplatform.social.core.jpa.storage;
19
20 import org.exoplatform.container.component.RequestLifeCycle;
21 import org.exoplatform.social.core.identity.model.Identity;
22 import org.exoplatform.social.core.identity.model.Profile;
23 import org.exoplatform.social.core.identity.provider.SpaceIdentityProvider;
24 import org.exoplatform.social.core.jpa.test.AbstractCoreTest;
25 import org.exoplatform.social.core.jpa.test.MaxQueryNumber;
26 import org.exoplatform.social.core.model.AvatarAttachment;
27 import org.exoplatform.social.core.model.BannerAttachment;
28 import org.exoplatform.social.core.service.LinkProvider;
29 import org.exoplatform.social.core.space.SpaceFilter;
30 import org.exoplatform.social.core.space.impl.DefaultSpaceApplicationHandler;
31 import org.exoplatform.social.core.space.model.Space;
32 import org.exoplatform.social.core.storage.api.IdentityStorage;
33 import org.exoplatform.social.core.storage.api.SpaceStorage;
34 import org.exoplatform.social.core.storage.impl.StorageUtils;
35
36 import java.io.InputStream;
37 import java.util.List;
38
39 public abstract class SpaceStorageTest extends AbstractCoreTest {
40
41 private SpaceStorage spaceStorage;
42
43 private IdentityStorage identityStorage;
44
45 private Identity rootIdentity;
46 private Identity johnIdentity;
47 private Identity maryIdentity;
48 private Identity demoIdentity;
49
50 @Override
51 protected void setUp() throws Exception {
52 super.setUp();
53 spaceStorage = (SpaceStorage) this.getContainer().getComponentInstanceOfType(SpaceStorage.class);
54 identityStorage = (IdentityStorage) this.getContainer().getComponentInstanceOfType(IdentityStorage.class);
55
56 rootIdentity = createIdentity("root");
57 johnIdentity = createIdentity("john");
58 maryIdentity = createIdentity("mary");
59 demoIdentity = createIdentity("demo");
60 }
61
62
63
64
65
66
67
68 protected Space getSpaceInstance(int number) {
69 Space space = new Space();
70 space.setApp("app1:appName1:true:active,app2:appName2:false:deactive");
71 space.setDisplayName("my space test " + number);
72 space.setPrettyName(space.getDisplayName());
73 space.setRegistration(Space.OPEN);
74 space.setDescription("add new space " + number);
75 space.setType(DefaultSpaceApplicationHandler.NAME);
76 space.setVisibility(Space.PUBLIC);
77 space.setPriority(Space.INTERMEDIATE_PRIORITY);
78 space.setGroupId("/spaces/space" + number);
79 String[] managers = new String[] { "demo", "tom" };
80 String[] members = new String[] { "raul", "ghost", "dragon" };
81 String[] invitedUsers = new String[] { "register1", "mary" };
82 String[] pendingUsers = new String[] { "jame", "paul", "hacker" };
83 space.setInvitedUsers(invitedUsers);
84 space.setPendingUsers(pendingUsers);
85 space.setManagers(managers);
86 space.setMembers(members);
87 space.setUrl(space.getPrettyName());
88 return space;
89 }
90
91
92
93
94
95
96
97 private Space getSpaceInstance(int number, String visible, String registration, String manager, String... members) {
98 Space space = new Space();
99 space.setApp("app:appName:true:active");
100 space.setDisplayName("my space test " + number);
101 space.setPrettyName(space.getDisplayName());
102 space.setRegistration(registration);
103 space.setDescription("add new space " + number);
104 space.setType(DefaultSpaceApplicationHandler.NAME);
105 space.setVisibility(visible);
106 space.setPriority(Space.INTERMEDIATE_PRIORITY);
107 space.setGroupId("/spaces/space" + number);
108 String[] managers = new String[] { manager };
109 String[] invitedUsers = new String[] {};
110 String[] pendingUsers = new String[] {};
111 space.setInvitedUsers(invitedUsers);
112 space.setPendingUsers(pendingUsers);
113 space.setManagers(managers);
114 space.setMembers(members);
115 space.setUrl(space.getPrettyName());
116 return space;
117 }
118
119
120
121
122
123
124
125 private Space getSpaceInstanceInvitedMember(int number,
126 String visible,
127 String registration,
128 String[] invitedMember,
129 String manager,
130 String... members) {
131 Space space = new Space();
132 space.setApp("app:appName:true:active");
133 space.setDisplayName("my space test " + number);
134 space.setPrettyName(space.getDisplayName());
135 space.setRegistration(registration);
136 space.setDescription("add new space " + number);
137 space.setType(DefaultSpaceApplicationHandler.NAME);
138 space.setVisibility(visible);
139 space.setPriority(Space.INTERMEDIATE_PRIORITY);
140 space.setGroupId("/spaces/space" + number);
141 space.setUrl(space.getPrettyName());
142 String[] managers = new String[] { manager };
143
144 String[] pendingUsers = new String[] {};
145 space.setInvitedUsers(invitedMember);
146 space.setPendingUsers(pendingUsers);
147 space.setManagers(managers);
148 space.setMembers(members);
149 return space;
150 }
151
152 private List<Space> getSpaceWithRoot(SpaceFilter filter) {
153 if (filter == null) {
154 return spaceStorage.getAllSpaces();
155 } else {
156 return spaceStorage.getSpacesByFilter(filter, 0, 200);
157 }
158 }
159
160
161
162
163
164
165
166 @MaxQueryNumber(1029)
167 public void testGetAllSpaces() throws Exception {
168 int totalSpaces = 10;
169 for (int i = 1; i <= totalSpaces; i++) {
170 Space space = this.getSpaceInstance(i);
171 spaceStorage.saveSpace(space, true);
172 persist();
173 }
174 assertEquals("spaceStorage.getAllSpaces().size() must return: " + totalSpaces,
175 totalSpaces,
176 spaceStorage.getAllSpaces().size());
177 }
178
179
180
181
182
183
184
185
186 @MaxQueryNumber(1029)
187 public void testGetSpaces() throws Exception {
188 int totalSpaces = 10;
189 for (int i = 1; i <= totalSpaces; i++) {
190 Space space = this.getSpaceInstance(i);
191 spaceStorage.saveSpace(space, true);
192 persist();
193 }
194 int offset = 0;
195 int limit = 10;
196 List<Space> spaceListAccess = spaceStorage.getSpaces(offset, limit);
197 assertNotNull("spaceListAccess must not be null", spaceListAccess);
198 assertEquals("spaceListAccess.size() must be: " + totalSpaces, totalSpaces, spaceListAccess.size());
199
200 spaceListAccess = spaceStorage.getSpaces(offset, 5);
201 assertNotNull("spaceListAccess must not be null", spaceListAccess);
202 assertEquals("spaceListAccess.size() must be: " + 5, 5, spaceListAccess.size());
203
204 spaceListAccess = spaceStorage.getSpaces(offset, 20);
205 assertNotNull("spaceListAccess must not be null", spaceListAccess);
206 assertEquals("spaceListAccess.size() must be: " + totalSpaces, totalSpaces, spaceListAccess.size());
207 }
208
209
210
211
212
213
214
215
216 @MaxQueryNumber(1006)
217 public void testGetAllSpacesCount() throws Exception {
218 int totalSpaces = 10;
219 for (int i = 1; i <= totalSpaces; i++) {
220 Space space = this.getSpaceInstance(i);
221 spaceStorage.saveSpace(space, true);
222 persist();
223 }
224 int spacesCount = spaceStorage.getAllSpacesCount();
225 assertEquals("spacesCount must be: ", totalSpaces, spacesCount);
226 }
227
228
229
230
231
232
233
234
235 @MaxQueryNumber(1029)
236 public void testGetSpacesByFilter() throws Exception {
237 int totalSpaces = 10;
238 for (int i = 1; i <= totalSpaces; i++) {
239 Space space = this.getSpaceInstance(i);
240 spaceStorage.saveSpace(space, true);
241 persist();
242 }
243 List<Space> foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter("add"), 0, 10);
244 assertNotNull("foundSpaces must not be null", foundSpaces);
245 assertEquals("foundSpaces.size() must return: " + totalSpaces, totalSpaces, foundSpaces.size());
246
247 foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter("my"), 0, 10);
248 assertNotNull("foundSpaces must not be null", foundSpaces);
249 assertEquals("foundSpaces.size() must return: " + totalSpaces, totalSpaces, foundSpaces.size());
250
251 foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter("my space test"), 0, 10);
252 assertNotNull("foundSpaces must not be null", foundSpaces);
253 assertEquals("foundSpaces.size() must return: " + totalSpaces, totalSpaces, foundSpaces.size());
254
255 foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter("hell gate"), 0, 10);
256 assertNotNull("foundSpaces must not be null", foundSpaces);
257 assertEquals("foundSpaces.size() must return: " + 0, 0, foundSpaces.size());
258
259 foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter('m'), 0, 10);
260 assertNotNull("foundSpaces must not be null", foundSpaces);
261 assertEquals("foundSpaces.size() must return: " + totalSpaces, totalSpaces, foundSpaces.size());
262
263 foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter('M'), 0, 10);
264 assertNotNull("foundSpaces must not be null", foundSpaces);
265 assertEquals("foundSpaces.size() must return: " + totalSpaces, totalSpaces, foundSpaces.size());
266
267 foundSpaces = spaceStorage.getSpacesByFilter(new SpaceFilter('k'), 0, 10);
268 assertNotNull("foundSpaces must not be null", foundSpaces);
269 assertEquals("foundSpaces.size() must return: " + 0, 0, foundSpaces.size());
270 }
271
272
273
274
275
276
277
278
279 @MaxQueryNumber(1006)
280 public void testGetAllSpacesByFilterCount() throws Exception {
281 int totalSpaces = 10;
282 for (int i = 1; i <= totalSpaces; i++) {
283 Space space = this.getSpaceInstance(i);
284 spaceStorage.saveSpace(space, true);
285 persist();
286 }
287 int count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter("add"));
288 assertEquals("count must be: " + totalSpaces, totalSpaces, count);
289
290 count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter("my"));
291 assertEquals("count must be: " + totalSpaces, totalSpaces, count);
292
293 count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter("my space test"));
294 assertEquals("count must be: " + totalSpaces, totalSpaces, count);
295
296 count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter("hell gate"));
297 assertEquals("count must be: " + 0, 0, count);
298
299 count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter('m'));
300 assertEquals("count must be: " + totalSpaces, totalSpaces, count);
301
302 count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter('M'));
303 assertEquals("count must be: " + totalSpaces, totalSpaces, count);
304
305 count = spaceStorage.getAllSpacesByFilterCount(new SpaceFilter('k'));
306 assertEquals("count must be: " + 0, 0, count);
307 }
308
309
310
311
312
313
314
315
316 @MaxQueryNumber(1029)
317 public void testGetAccessibleSpaces() throws Exception {
318 int countSpace = 10;
319 Space[] listSpace = new Space[10];
320 for (int i = 0; i < countSpace; i++) {
321 listSpace[i] = this.getSpaceInstance(i);
322 spaceStorage.saveSpace(listSpace[i], true);
323 persist();
324 }
325 List<Space> accessibleSpaces = spaceStorage.getAccessibleSpaces("demo");
326 assertNotNull("accessibleSpaces must not be null", accessibleSpaces);
327 assertEquals("accessibleSpaces.size() must return: " + countSpace, countSpace, accessibleSpaces.size());
328 }
329
330
331
332
333
334
335
336
337 @MaxQueryNumber(2026)
338 public void testGetAccessibleSpacesByFilter() throws Exception {
339 int countSpace = 20;
340 Space[] listSpace = new Space[countSpace];
341 for (int i = 0; i < countSpace; i++) {
342 listSpace[i] = this.getSpaceInstance(i);
343 spaceStorage.saveSpace(listSpace[i], true);
344 persist();
345 }
346 List<Space> accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("demo", new SpaceFilter("my space test"), 0, 10);
347 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
348 assertEquals("accessibleSpacesByFilter.size() must return: ", 10, accessibleSpacesByFilter.size());
349
350 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("tom", new SpaceFilter("my space test"), 0, 10);
351 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
352 assertEquals("accessibleSpacesByFilter.size() must return: ", 10, accessibleSpacesByFilter.size());
353
354 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("ghost", new SpaceFilter("my space test"), 0, 10);
355 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
356 assertEquals("accessibleSpacesByFilter.size() must return: ", 10, accessibleSpacesByFilter.size());
357
358 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("demo", new SpaceFilter("add new"), 0, 10);
359 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
360 assertEquals("accessibleSpacesByFilter.size() must return: ", 10, accessibleSpacesByFilter.size());
361
362 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("demo", new SpaceFilter('m'), 0, 10);
363 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
364 assertEquals("accessibleSpacesByFilter.size() must return: ", 10, accessibleSpacesByFilter.size());
365
366 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("demo", new SpaceFilter('M'), 0, 10);
367 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
368 assertEquals("accessibleSpacesByFilter.size() must return: ", 10, accessibleSpacesByFilter.size());
369
370 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("demo", new SpaceFilter('K'), 0, 10);
371 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
372 assertEquals("accessibleSpacesByFilter.size() must return: ", 0, accessibleSpacesByFilter.size());
373
374 accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("newperson", new SpaceFilter("my space test"), 0, 10);
375 assertNotNull("accessibleSpacesByFilter must not be null", accessibleSpacesByFilter);
376 assertEquals("accessibleSpacesByFilter.size() must return: ", 0, accessibleSpacesByFilter.size());
377 }
378
379 @MaxQueryNumber(800)
380 public void testGetAccessibleSpacesByFilterApp() throws Exception {
381 Space space = this.getSpaceInstance(1);
382 spaceStorage.saveSpace(space, true);
383 persist();
384
385 SpaceFilter filter = new SpaceFilter("my space test");
386 filter.setAppId("app1,app2");
387
388 List<Space> accessibleSpacesByFilter = spaceStorage.getAccessibleSpacesByFilter("demo", filter, 0, 10);
389 assertEquals(1, accessibleSpacesByFilter.size());
390 }
391
392
393
394
395
396
397
398
399 @MaxQueryNumber(2026)
400 public void testGetAccessibleSpacesByFilterCount() throws Exception {
401 int countSpace = 20;
402 Space[] listSpace = new Space[countSpace];
403 for (int i = 0; i < countSpace; i++) {
404 listSpace[i] = this.getSpaceInstance(i);
405 spaceStorage.saveSpace(listSpace[i], true);
406 persist();
407 }
408 int accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("demo", new SpaceFilter("my space test"));
409 assertEquals("accessibleSpacesByFilterCount must be: ", countSpace, accessibleSpacesByFilterCount);
410
411 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("tom", new SpaceFilter("my space test"));
412 assertEquals("accessibleSpacesByFilterCount must be: ", countSpace, accessibleSpacesByFilterCount);
413
414 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("tom", new SpaceFilter('m'));
415 assertEquals("accessibleSpacesByFilterCount must be: ", countSpace, accessibleSpacesByFilterCount);
416
417 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("tom", new SpaceFilter('M'));
418 assertEquals("accessibleSpacesByFilterCount must be: ", countSpace, accessibleSpacesByFilterCount);
419
420 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("tom", new SpaceFilter('k'));
421 assertEquals("accessibleSpacesByFilterCount must be: ", 0, accessibleSpacesByFilterCount);
422
423 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("ghost", new SpaceFilter("my space test"));
424 assertEquals("accessibleSpacesByFilterCount must be: ", countSpace, accessibleSpacesByFilterCount);
425
426 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("demo", new SpaceFilter("add new"));
427 assertEquals("accessibleSpacesByFilterCount must be: ", countSpace, accessibleSpacesByFilterCount);
428
429 accessibleSpacesByFilterCount = spaceStorage.getAccessibleSpacesByFilterCount("newperson", new SpaceFilter("my space test"));
430 assertEquals("accessibleSpacesByFilterCount must be: ", 0, accessibleSpacesByFilterCount);
431 }
432
433
434
435
436
437
438
439
440 @MaxQueryNumber(1006)
441 public void testgetAccessibleSpacesCount() throws Exception {
442 int countSpace = 10;
443 Space[] listSpace = new Space[10];
444 for (int i = 0; i < countSpace; i++) {
445 listSpace[i] = this.getSpaceInstance(i);
446 spaceStorage.saveSpace(listSpace[i], true);
447 persist();
448 }
449 int accessibleSpacesCount = spaceStorage.getAccessibleSpacesCount("demo");
450 assertEquals("accessibleSpacesCount mus be: " + countSpace, countSpace, accessibleSpacesCount);
451
452 accessibleSpacesCount = spaceStorage.getAccessibleSpacesCount("dragon");
453 assertEquals("accessibleSpacesCount must be: " + countSpace, countSpace, accessibleSpacesCount);
454
455 accessibleSpacesCount = spaceStorage.getAccessibleSpacesCount("nobody");
456 assertEquals("accessibleSpacesCount must be: 0", 0, accessibleSpacesCount);
457 }
458
459
460
461
462
463
464
465
466 @MaxQueryNumber(1029)
467 public void testGetAccessibleSpacesWithOffset() throws Exception {
468 int countSpace = 10;
469 Space[] listSpace = new Space[10];
470 for (int i = 0; i < countSpace; i++) {
471 listSpace[i] = this.getSpaceInstance(i);
472 spaceStorage.saveSpace(listSpace[i], true);
473 persist();
474 }
475 List<Space> accessibleSpaces = spaceStorage.getAccessibleSpaces("demo", 0, 5);
476 assertNotNull("accessibleSpaces must not be null", accessibleSpaces);
477 assertEquals("accessibleSpaces.size() must return: " + 5, 5, accessibleSpaces.size());
478 }
479
480
481
482
483
484
485
486
487 @MaxQueryNumber(1029)
488 public void testGetEditableSpaces() throws Exception {
489 int countSpace = 10;
490 Space[] listSpace = new Space[10];
491 for (int i = 0; i < countSpace; i++) {
492 listSpace[i] = this.getSpaceInstance(i);
493 spaceStorage.saveSpace(listSpace[i], true);
494 persist();
495 }
496 List<Space> editableSpaces = spaceStorage.getEditableSpaces("demo");
497 assertNotNull("editableSpaces must not be null", editableSpaces);
498 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
499
500 editableSpaces = spaceStorage.getEditableSpaces("top");
501 assertNotNull("editableSpaces must not be null", editableSpaces);
502 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
503
504 editableSpaces = spaceStorage.getEditableSpaces("dragon");
505 assertNotNull("editableSpaces must not be null", editableSpaces);
506 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
507 }
508
509
510
511
512
513
514
515
516 @MaxQueryNumber(1029)
517 public void testGetEditableSpacesByFilter() throws Exception {
518 int countSpace = 10;
519 Space[] listSpace = new Space[10];
520 for (int i = 0; i < countSpace; i++) {
521 listSpace[i] = this.getSpaceInstance(i);
522 spaceStorage.saveSpace(listSpace[i], true);
523 persist();
524 }
525 List<Space> editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter("add new"), 0, 10);
526 assertNotNull("editableSpaces must not be null", editableSpaces);
527 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
528
529 editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter("m"), 0, 10);
530 assertNotNull("editableSpaces must not be null", editableSpaces);
531 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
532
533 editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter("M"), 0, 10);
534 assertNotNull("editableSpaces must not be null", editableSpaces);
535 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
536
537 editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter('m'), 0, 10);
538 assertNotNull("editableSpaces must not be null", editableSpaces);
539 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
540
541 editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter('M'), 0, 10);
542 assertNotNull("editableSpaces must not be null", editableSpaces);
543 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
544
545 editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter('K'), 0, 10);
546 assertNotNull("editableSpaces must not be null", editableSpaces);
547 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
548
549 editableSpaces = spaceStorage.getEditableSpacesByFilter("demo", new SpaceFilter("add new"), 0, 10);
550 assertNotNull("editableSpaces must not be null", editableSpaces);
551 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
552
553 editableSpaces = spaceStorage.getEditableSpacesByFilter("top", new SpaceFilter("my space test"), 0, 10);
554 assertNotNull("editableSpaces must not be null", editableSpaces);
555 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
556
557 editableSpaces = spaceStorage.getEditableSpacesByFilter("dragon", new SpaceFilter("m"), 0, 10);
558 assertNotNull("editableSpaces must not be null", editableSpaces);
559 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
560
561 editableSpaces = spaceStorage.getEditableSpacesByFilter("dragon", new SpaceFilter('m'), 0, 10);
562 assertNotNull("editableSpaces must not be null", editableSpaces);
563 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
564
565 editableSpaces = spaceStorage.getEditableSpacesByFilter("dragon", new SpaceFilter('M'), 0, 10);
566 assertNotNull("editableSpaces must not be null", editableSpaces);
567 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
568
569 editableSpaces = spaceStorage.getEditableSpacesByFilter("dragon", new SpaceFilter('k'), 0, 10);
570 assertNotNull("editableSpaces must not be null", editableSpaces);
571 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
572 }
573
574
575
576
577
578
579
580
581 @MaxQueryNumber(1006)
582 public void testGetEditableSpacesByFilterCount() throws Exception {
583 int countSpace = 10;
584 Space[] listSpace = new Space[10];
585 for (int i = 0; i < countSpace; i++) {
586 listSpace[i] = this.getSpaceInstance(i);
587 spaceStorage.saveSpace(listSpace[i], true);
588 persist();
589 }
590 int editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("demo", new SpaceFilter("add new"));
591 assertEquals("editableSpacesCount must be: " + countSpace, countSpace, editableSpacesCount);
592
593 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("demo", new SpaceFilter("m"));
594 assertEquals("editableSpacesCount must be: " + countSpace, countSpace, editableSpacesCount);
595
596 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("demo", new SpaceFilter("M"));
597 assertEquals("editableSpacesCount must be: " + countSpace, countSpace, editableSpacesCount);
598
599 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("demo", new SpaceFilter('m'));
600 assertEquals("editableSpacesCount must be: " + countSpace, countSpace, editableSpacesCount);
601
602 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("demo", new SpaceFilter('M'));
603 assertEquals("editableSpacesCount must be: " + countSpace, countSpace, editableSpacesCount);
604
605 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("demo", new SpaceFilter('K'));
606 assertEquals("editableSpacesCount must be: " + 0, 0, editableSpacesCount);
607
608 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("tom", new SpaceFilter("add new"));
609 assertEquals("editableSpacesCount must be: " + countSpace, countSpace, editableSpacesCount);
610
611 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("top", new SpaceFilter("my space test"));
612 assertEquals("editableSpacesCount must be: " + 0, 0, editableSpacesCount);
613
614 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("dragon", new SpaceFilter("m"));
615 assertEquals("editableSpacesCount must be: " + 0, 0, editableSpacesCount);
616
617 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("dragon", new SpaceFilter('m'));
618 assertEquals("editableSpacesCount must be: " + 0, 0, editableSpacesCount);
619
620 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("dragon", new SpaceFilter('M'));
621 assertEquals("editableSpacesCount must be: " + 0, 0, editableSpacesCount);
622
623 editableSpacesCount = spaceStorage.getEditableSpacesByFilterCount("dragon", new SpaceFilter('k'));
624 assertEquals("editableSpacesCount must be: " + 0, 0, editableSpacesCount);
625 }
626
627
628
629
630
631
632
633
634 @MaxQueryNumber(1029)
635 public void testGetEditableSpacesWithListAccess() throws Exception {
636 int countSpace = 10;
637 Space[] listSpace = new Space[10];
638 for (int i = 0; i < countSpace; i++) {
639 listSpace[i] = this.getSpaceInstance(i);
640 spaceStorage.saveSpace(listSpace[i], true);
641 persist();
642 }
643 List<Space> editableSpaces = spaceStorage.getEditableSpaces("demo", 0, countSpace);
644 assertNotNull("editableSpaces must not be null", editableSpaces);
645 assertEquals("editableSpaces.size() must return: " + countSpace, countSpace, editableSpaces.size());
646
647 editableSpaces = spaceStorage.getEditableSpaces("top", 0, countSpace);
648 assertNotNull("editableSpaces must not be null", editableSpaces);
649 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
650
651 editableSpaces = spaceStorage.getEditableSpaces("dragon", 0, 5);
652 assertNotNull("editableSpaces must not be null", editableSpaces);
653 assertEquals("editableSpaces.size() must return: " + 0, 0, editableSpaces.size());
654 }
655
656
657
658
659
660
661
662
663 @MaxQueryNumber(1029)
664 public void testGetInvitedSpaces() throws Exception {
665 int countSpace = 10;
666 Space[] listSpace = new Space[10];
667 for (int i = 0; i < countSpace; i++) {
668 listSpace[i] = this.getSpaceInstance(i);
669 spaceStorage.saveSpace(listSpace[i], true);
670 persist();
671 }
672 List<Space> invitedSpaces = spaceStorage.getInvitedSpaces("register1");
673 assertNotNull("invitedSpaces must not be null", invitedSpaces);
674 assertEquals("invitedSpaces.size() must return: " + countSpace, countSpace, invitedSpaces.size());
675
676 invitedSpaces = spaceStorage.getInvitedSpaces("register");
677 assertNotNull("invitedSpaces must not be null", invitedSpaces);
678 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
679
680 invitedSpaces = spaceStorage.getInvitedSpaces("mary");
681 assertNotNull("invitedSpaces must not be null", invitedSpaces);
682 assertEquals("invitedSpaces.size() must return: " + countSpace, countSpace, invitedSpaces.size());
683
684 invitedSpaces = spaceStorage.getInvitedSpaces("demo");
685 assertNotNull("invitedSpaces must not be null", invitedSpaces);
686 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
687 }
688
689
690
691
692
693
694
695
696 @MaxQueryNumber(1029)
697 public void testGetInvitedSpacesByFilter() throws Exception {
698 int countSpace = 10;
699 Space[] listSpace = new Space[10];
700 for (int i = 0; i < countSpace; i++) {
701 listSpace[i] = this.getSpaceInstance(i);
702 spaceStorage.saveSpace(listSpace[i], true);
703 persist();
704 }
705 List<Space> invitedSpaces = spaceStorage.getInvitedSpacesByFilter("register1", new SpaceFilter("add new"), 0, 10);
706 assertNotNull("invitedSpaces must not be null", invitedSpaces);
707 assertEquals("invitedSpaces.size() must return: " + countSpace, countSpace, invitedSpaces.size());
708
709 invitedSpaces = spaceStorage.getInvitedSpacesByFilter("register1", new SpaceFilter('m'), 0, 10);
710 assertNotNull("invitedSpaces must not be null", invitedSpaces);
711 assertEquals("invitedSpaces.size() must return: " + countSpace, countSpace, invitedSpaces.size());
712
713 invitedSpaces = spaceStorage.getInvitedSpacesByFilter("register1", new SpaceFilter('M'), 0, 10);
714 assertNotNull("invitedSpaces must not be null", invitedSpaces);
715 assertEquals("invitedSpaces.size() must return: " + countSpace, countSpace, invitedSpaces.size());
716
717 invitedSpaces = spaceStorage.getInvitedSpacesByFilter("register1", new SpaceFilter('k'), 0, 10);
718 assertNotNull("invitedSpaces must not be null", invitedSpaces);
719 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
720
721 invitedSpaces = spaceStorage.getInvitedSpacesByFilter("register", new SpaceFilter("my space test "), 0, 10);
722 assertNotNull("invitedSpaces must not be null", invitedSpaces);
723 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
724
725 invitedSpaces = spaceStorage.getInvitedSpacesByFilter("mary", new SpaceFilter("add"), 0, 10);
726 assertNotNull("invitedSpaces must not be null", invitedSpaces);
727 assertEquals("invitedSpaces.size() must return: " + countSpace, countSpace, invitedSpaces.size());
728
729 invitedSpaces = spaceStorage.getInvitedSpacesByFilter("demo", new SpaceFilter("my"), 0, 10);
730 assertNotNull("invitedSpaces must not be null", invitedSpaces);
731 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
732 }
733
734
735
736
737
738
739
740
741 @MaxQueryNumber(1006)
742 public void testGetInvitedSpacesByFilterCount() throws Exception {
743 int countSpace = 10;
744 Space[] listSpace = new Space[10];
745 for (int i = 0; i < countSpace; i++) {
746 listSpace[i] = this.getSpaceInstance(i);
747 spaceStorage.saveSpace(listSpace[i], true);
748 persist();
749 }
750 int invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("register1", new SpaceFilter("add new"));
751 assertEquals("invitedSpacesCount must be: " + countSpace, countSpace, invitedSpacesCount);
752
753 invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("register1", new SpaceFilter('m'));
754 assertEquals("invitedSpacesCount must be: " + countSpace, countSpace, invitedSpacesCount);
755
756 invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("register1", new SpaceFilter('M'));
757 assertEquals("invitedSpacesCount must be: " + countSpace, countSpace, invitedSpacesCount);
758
759 invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("register1", new SpaceFilter('k'));
760 assertEquals("invitedSpacesCount must be: " + 0, 0, invitedSpacesCount);
761
762 invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("register", new SpaceFilter("my space test "));
763 assertEquals("invitedSpacesCount must be: " + 0, 0, invitedSpacesCount);
764
765 invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("mary", new SpaceFilter("add"));
766 assertEquals("invitedSpacesCount must be: " + countSpace, countSpace, invitedSpacesCount);
767
768 invitedSpacesCount = spaceStorage.getInvitedSpacesByFilterCount("demo", new SpaceFilter("my"));
769 assertEquals("invitedSpacesCount must be: " + 0, 0, invitedSpacesCount);
770 }
771
772
773
774
775
776
777
778
779 @MaxQueryNumber(1029)
780 public void testGetInvitedSpacesWithOffset() throws Exception {
781 int countSpace = 10;
782 Space[] listSpace = new Space[10];
783 for (int i = 0; i < countSpace; i++) {
784 listSpace[i] = this.getSpaceInstance(i);
785 spaceStorage.saveSpace(listSpace[i], true);
786 persist();
787 }
788 List<Space> invitedSpaces = spaceStorage.getInvitedSpaces("register1", 0, 5);
789 assertNotNull("invitedSpaces must not be null", invitedSpaces);
790 assertEquals("invitedSpaces.size() must return: " + 5, 5, invitedSpaces.size());
791
792 invitedSpaces = spaceStorage.getInvitedSpaces("register", 0, 5);
793 assertNotNull("invitedSpaces must not be null", invitedSpaces);
794 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
795
796 invitedSpaces = spaceStorage.getInvitedSpaces("mary", 0, 5);
797 assertNotNull("invitedSpaces must not be null", invitedSpaces);
798 assertEquals("invitedSpaces.size() must return: " + 5, 5, invitedSpaces.size());
799
800 invitedSpaces = spaceStorage.getInvitedSpaces("demo", 0, 5);
801 assertNotNull("invitedSpaces must not be null", invitedSpaces);
802 assertEquals("invitedSpaces.size() must return: " + 0, 0, invitedSpaces.size());
803 }
804
805
806
807
808
809
810
811
812 @MaxQueryNumber(1029)
813 public void testGetInvitedSpacesCount() throws Exception {
814 int countSpace = 10;
815 Space[] listSpace = new Space[10];
816 for (int i = 0; i < countSpace; i++) {
817 listSpace[i] = this.getSpaceInstance(i);
818 spaceStorage.saveSpace(listSpace[i], true);
819 persist();
820 }
821 int invitedSpacesCount = spaceStorage.getInvitedSpacesCount("register1");
822 assertEquals("invitedSpacesCount must be: " + countSpace, countSpace, invitedSpacesCount);
823
824 invitedSpacesCount = spaceStorage.getInvitedSpacesCount("mary");
825 assertEquals("invitedSpacesCount must be: " + countSpace, countSpace, invitedSpacesCount);
826
827 invitedSpacesCount = spaceStorage.getInvitedSpacesCount("nobody");
828 assertEquals("invitedSpacesCount must be: 0", 0, invitedSpacesCount);
829 }
830
831
832
833
834
835
836
837
838 @MaxQueryNumber(1029)
839 public void testGetPendingSpaces() throws Exception {
840 int countSpace = 10;
841 Space[] listSpace = new Space[10];
842 for (int i = 0; i < countSpace; i++) {
843 listSpace[i] = this.getSpaceInstance(i);
844 spaceStorage.saveSpace(listSpace[i], true);
845 persist();
846 }
847 List<Space> pendingSpaces = spaceStorage.getPendingSpaces("hacker");
848 assertNotNull("pendingSpaces must not be null", pendingSpaces);
849 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
850
851 pendingSpaces = spaceStorage.getPendingSpaces("hack");
852 assertNotNull("pendingSpaces must not be null", pendingSpaces);
853 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
854
855 pendingSpaces = spaceStorage.getPendingSpaces("paul");
856 assertNotNull("pendingSpaces must not be null", pendingSpaces);
857 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
858
859 pendingSpaces = spaceStorage.getPendingSpaces("jame");
860 assertNotNull("pendingSpaces must not be null", pendingSpaces);
861 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
862
863 pendingSpaces = spaceStorage.getPendingSpaces("victory");
864 assertNotNull("pendingSpaces must not be null", pendingSpaces);
865 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
866 }
867
868
869
870
871
872
873
874
875 @MaxQueryNumber(1029)
876 public void testGetPendingSpacesByFilter() throws Exception {
877 int countSpace = 10;
878 Space[] listSpace = new Space[10];
879 for (int i = 0; i < countSpace; i++) {
880 listSpace[i] = this.getSpaceInstance(i);
881 spaceStorage.saveSpace(listSpace[i], true);
882 persist();
883 }
884 List<Space> pendingSpaces = spaceStorage.getPendingSpacesByFilter("hacker", new SpaceFilter("add new"), 0, 10);
885 assertNotNull("pendingSpaces must not be null", pendingSpaces);
886 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
887
888 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hacker", new SpaceFilter('m'), 0, 10);
889 assertNotNull("pendingSpaces must not be null", pendingSpaces);
890 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
891
892 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hacker", new SpaceFilter('M'), 0, 10);
893 assertNotNull("pendingSpaces must not be null", pendingSpaces);
894 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
895
896 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hacker", new SpaceFilter('k'), 0, 10);
897 assertNotNull("pendingSpaces must not be null", pendingSpaces);
898 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
899
900 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hack", new SpaceFilter("my space test"), 0, 10);
901 assertNotNull("pendingSpaces must not be null", pendingSpaces);
902 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
903
904 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hack", new SpaceFilter('m'), 0, 10);
905 assertNotNull("pendingSpaces must not be null", pendingSpaces);
906 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
907
908 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hack", new SpaceFilter('M'), 0, 10);
909 assertNotNull("pendingSpaces must not be null", pendingSpaces);
910 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
911
912 pendingSpaces = spaceStorage.getPendingSpacesByFilter("hack", new SpaceFilter('K'), 0, 10);
913 assertNotNull("pendingSpaces must not be null", pendingSpaces);
914 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
915
916 pendingSpaces = spaceStorage.getPendingSpacesByFilter("paul", new SpaceFilter("add"), 0, 10);
917 assertNotNull("pendingSpaces must not be null", pendingSpaces);
918 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
919
920 pendingSpaces = spaceStorage.getPendingSpacesByFilter("jame", new SpaceFilter("my"), 0, 10);
921 assertNotNull("pendingSpaces must not be null", pendingSpaces);
922 assertEquals("pendingSpaces.size() must return: " + countSpace, countSpace, pendingSpaces.size());
923
924 pendingSpaces = spaceStorage.getPendingSpacesByFilter("victory", new SpaceFilter("my space test "), 0, 10);
925 assertNotNull("pendingSpaces must not be null", pendingSpaces);
926 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
927 }
928
929
930
931
932
933
934
935
936 @MaxQueryNumber(1029)
937 public void testGetPendingSpacesByFilterCount() throws Exception {
938 int countSpace = 10;
939 Space[] listSpace = new Space[10];
940 for (int i = 0; i < countSpace; i++) {
941 listSpace[i] = this.getSpaceInstance(i);
942 spaceStorage.saveSpace(listSpace[i], true);
943 persist();
944 }
945 int pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hacker", new SpaceFilter("add new"));
946 assertEquals("pendingSpacesCount must be: " + countSpace, countSpace, pendingSpacesCount);
947
948 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hacker", new SpaceFilter('m'));
949 assertEquals("pendingSpacesCount must be: " + countSpace, countSpace, pendingSpacesCount);
950
951 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hacker", new SpaceFilter('M'));
952 assertEquals("pendingSpacesCount must be: " + countSpace, countSpace, pendingSpacesCount);
953
954 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hacker", new SpaceFilter('k'));
955 assertEquals("pendingSpacesCount must be: " + 0, 0, pendingSpacesCount);
956
957 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hack", new SpaceFilter("my space test"));
958 assertEquals("pendingSpacesCount must be: " + 0, 0, pendingSpacesCount);
959
960 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hack", new SpaceFilter('m'));
961 assertEquals("pendingSpacesCount must be: " + 0, 0, pendingSpacesCount);
962
963 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hack", new SpaceFilter('M'));
964 assertEquals("pendingSpacesCount must be: " + 0, 0, pendingSpacesCount);
965
966 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("hack", new SpaceFilter('K'));
967 assertEquals("pendingSpacesCount must be: " + 0, 0, pendingSpacesCount);
968
969 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("paul", new SpaceFilter("add"));
970 assertEquals("pendingSpacesCount must be: " + countSpace, countSpace, pendingSpacesCount);
971
972 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("jame", new SpaceFilter("my"));
973 assertEquals("pendingSpacesCount must be: " + countSpace, countSpace, pendingSpacesCount);
974
975 pendingSpacesCount = spaceStorage.getPendingSpacesByFilterCount("victory", new SpaceFilter("my space test "));
976 assertEquals("pendingSpacesCount must be: " + 0, 0, pendingSpacesCount);
977 }
978
979
980
981
982
983
984
985
986 @MaxQueryNumber(1029)
987 public void testGetPendingSpacesWithOffset() throws Exception {
988 int countSpace = 10;
989 Space[] listSpace = new Space[10];
990 for (int i = 0; i < countSpace; i++) {
991 listSpace[i] = this.getSpaceInstance(i);
992 spaceStorage.saveSpace(listSpace[i], true);
993 persist();
994 }
995 List<Space> pendingSpaces = spaceStorage.getPendingSpaces("hacker", 0, 5);
996 assertNotNull("pendingSpaces must not be null", pendingSpaces);
997 assertEquals("pendingSpaces.size() must return: " + 5, 5, pendingSpaces.size());
998
999 pendingSpaces = spaceStorage.getPendingSpaces("paul", 0, 5);
1000 assertNotNull("pendingSpaces must not be null", pendingSpaces);
1001 assertEquals("pendingSpaces.size() must return: " + 5, 5, pendingSpaces.size());
1002
1003 pendingSpaces = spaceStorage.getPendingSpaces("jame", 0, 5);
1004 assertNotNull("pendingSpaces must not be null", pendingSpaces);
1005 assertEquals("pendingSpaces.size() must return: " + 5, 5, pendingSpaces.size());
1006
1007 pendingSpaces = spaceStorage.getPendingSpaces("victory", 0, 5);
1008 assertNotNull("pendingSpaces must not be null", pendingSpaces);
1009 assertEquals("pendingSpaces.size() must return: " + 0, 0, pendingSpaces.size());
1010 }
1011
1012
1013
1014
1015
1016
1017
1018
1019 @MaxQueryNumber(1029)
1020 public void testGetPendingSpacesCount() throws Exception {
1021 int countSpace = 10;
1022 Space[] listSpace = new Space[10];
1023 for (int i = 0; i < countSpace; i++) {
1024 listSpace[i] = this.getSpaceInstance(i);
1025 spaceStorage.saveSpace(listSpace[i], true);
1026 persist();
1027 }
1028 int pendingSpaceCount = spaceStorage.getPendingSpacesCount("jame");
1029 assertEquals("pendingSpaceCount must be: " + countSpace, countSpace, pendingSpaceCount);
1030
1031 pendingSpaceCount = spaceStorage.getPendingSpacesCount("paul");
1032 assertEquals("pendingSpaceCount must be: " + countSpace, countSpace, pendingSpaceCount);
1033
1034 pendingSpaceCount = spaceStorage.getPendingSpacesCount("hacker");
1035 assertEquals("pendingSpaceCount must be: " + countSpace, countSpace, pendingSpaceCount);
1036
1037 pendingSpaceCount = spaceStorage.getPendingSpacesCount("nobody");
1038 assertEquals("pendingSpaceCount must be: 0", 0, pendingSpaceCount);
1039 }
1040
1041
1042
1043
1044
1045
1046
1047
1048 @MaxQueryNumber(1006)
1049 public void testGetPublicSpaces() throws Exception {
1050 int countSpace = 10;
1051 Space[] listSpace = new Space[10];
1052 for (int i = 0; i < countSpace; i++) {
1053 listSpace[i] = this.getSpaceInstance(i);
1054 spaceStorage.saveSpace(listSpace[i], true);
1055 persist();
1056 }
1057 List<Space> publicSpaces = spaceStorage.getPublicSpaces("mary");
1058 assertNotNull("publicSpaces must not be null", publicSpaces);
1059 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1060
1061 publicSpaces = spaceStorage.getPublicSpaces("demo");
1062 assertNotNull("publicSpaces must not be null", publicSpaces);
1063 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1064 }
1065
1066
1067
1068
1069
1070
1071
1072
1073 @MaxQueryNumber(1029)
1074 public void testGetPublicSpacesByFilter() throws Exception {
1075 int countSpace = 10;
1076 Space[] listSpace = new Space[10];
1077 for (int i = 0; i < countSpace; i++) {
1078 listSpace[i] = this.getSpaceInstance(i);
1079 spaceStorage.saveSpace(listSpace[i], true);
1080 persist();
1081 }
1082 List<Space> publicSpaces = spaceStorage.getPublicSpacesByFilter(maryIdentity.getRemoteId(), new SpaceFilter("add new"), 0, 10);
1083 assertNotNull("publicSpaces must not be null", publicSpaces);
1084 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1085
1086 publicSpaces = spaceStorage.getPublicSpacesByFilter(maryIdentity.getRemoteId(), new SpaceFilter("my space test"), 0, 10);
1087 assertNotNull("publicSpaces must not be null", publicSpaces);
1088 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1089
1090 publicSpaces = spaceStorage.getPublicSpacesByFilter(maryIdentity.getRemoteId(), new SpaceFilter('m'), 0, 10);
1091 assertNotNull("publicSpaces must not be null", publicSpaces);
1092 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1093
1094 publicSpaces = spaceStorage.getPublicSpacesByFilter(maryIdentity.getRemoteId(), new SpaceFilter('M'), 0, 10);
1095 assertNotNull("publicSpaces must not be null", publicSpaces);
1096 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1097
1098 publicSpaces = spaceStorage.getPublicSpacesByFilter(maryIdentity.getRemoteId(), new SpaceFilter("my space test"), 0, 10);
1099 assertNotNull("publicSpaces must not be null", publicSpaces);
1100 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1101
1102 publicSpaces = spaceStorage.getPublicSpacesByFilter("newStranger", new SpaceFilter('m'), 0, 10);
1103 assertNotNull("publicSpaces must not be null", publicSpaces);
1104 assertEquals("publicSpaces.size() must return: " + 10, 10, publicSpaces.size());
1105
1106 publicSpaces = spaceStorage.getPublicSpacesByFilter("newStranger", new SpaceFilter('M'), 0, 10);
1107 assertNotNull("publicSpaces must not be null", publicSpaces);
1108 assertEquals("publicSpaces.size() must return: " + 10, 10, publicSpaces.size());
1109
1110 publicSpaces = spaceStorage.getPublicSpacesByFilter("newStranger", new SpaceFilter("add new "), 0, 10);
1111 assertNotNull("publicSpaces must not be null", publicSpaces);
1112 assertEquals("publicSpaces.size() must return: " + 10, 10, publicSpaces.size());
1113
1114 publicSpaces = spaceStorage.getPublicSpacesByFilter("newStranger", new SpaceFilter("my space test "), 0, 10);
1115 assertNotNull("publicSpaces must not be null", publicSpaces);
1116 assertEquals("publicSpaces.size() must return: " + 10, 10, publicSpaces.size());
1117 }
1118
1119
1120
1121
1122
1123
1124
1125
1126 @MaxQueryNumber(1029)
1127 public void testGetPublicSpacesByFilterCount() throws Exception {
1128 int countSpace = 10;
1129 Space[] listSpace = new Space[10];
1130 for (int i = 0; i < countSpace; i++) {
1131 listSpace[i] = this.getSpaceInstance(i);
1132 spaceStorage.saveSpace(listSpace[i], true);
1133 persist();
1134 }
1135 int publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("mary", new SpaceFilter("add new"));
1136 assertEquals("publicSpacesByFilterCount must be: " + 0, 0, publicSpacesByFilterCount);
1137
1138 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("mary", new SpaceFilter("my space test"));
1139 assertEquals("publicSpacesByFilterCount must be: " + 0, 0, publicSpacesByFilterCount);
1140
1141 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("mary", new SpaceFilter('m'));
1142 assertEquals("publicSpacesByFilterCount must be: " + 0, 0, publicSpacesByFilterCount);
1143
1144 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("mary", new SpaceFilter('M'));
1145 assertEquals("publicSpacesByFilterCount must be: " + 0, 0, publicSpacesByFilterCount);
1146
1147 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("mary", new SpaceFilter("my space test"));
1148 assertEquals("publicSpacesByFilterCount must be: " + 0, 0, publicSpacesByFilterCount);
1149
1150 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("newstranger", new SpaceFilter('m'));
1151 assertEquals("publicSpacesByFilterCount must be: " + 10, 10, publicSpacesByFilterCount);
1152
1153 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("newstranger", new SpaceFilter('M'));
1154 assertEquals("publicSpacesByFilterCount must be: " + 10, 10, publicSpacesByFilterCount);
1155
1156 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("newstranger", new SpaceFilter("add new "));
1157 assertEquals("publicSpacesByFilterCount must be: " + 10, 10, publicSpacesByFilterCount);
1158
1159 publicSpacesByFilterCount = spaceStorage.getPublicSpacesByFilterCount("newstranger", new SpaceFilter("my space test "));
1160 assertEquals("publicSpacesByFilterCount must be: " + 10, 10, publicSpacesByFilterCount);
1161 }
1162
1163
1164
1165
1166
1167
1168
1169
1170 @MaxQueryNumber(1029)
1171 public void testGetPublicSpacesWithOffset() throws Exception {
1172 int countSpace = 10;
1173 Space[] listSpace = new Space[10];
1174 for (int i = 0; i < countSpace; i++) {
1175 listSpace[i] = this.getSpaceInstance(i);
1176 spaceStorage.saveSpace(listSpace[i], true);
1177 persist();
1178 }
1179 List<Space> publicSpaces = spaceStorage.getPublicSpaces("mary", 0, 5);
1180 assertNotNull("publicSpaces must not be null", publicSpaces);
1181 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1182
1183 publicSpaces = spaceStorage.getPublicSpaces("demo", 0, 5);
1184 assertNotNull("publicSpaces must not be null", publicSpaces);
1185 assertEquals("publicSpaces.size() must return: " + 0, 0, publicSpaces.size());
1186
1187 publicSpaces = spaceStorage.getPublicSpaces("headshot", 0, 5);
1188 assertNotNull("publicSpaces must not be null", publicSpaces);
1189 assertEquals("publicSpaces.size() must return: " + 5, 5, publicSpaces.size());
1190
1191 publicSpaces = spaceStorage.getPublicSpaces("hellgate", 0, countSpace);
1192 assertNotNull("publicSpaces must not be null", publicSpaces);
1193 assertEquals("publicSpaces.size() must return: " + countSpace, countSpace, publicSpaces.size());
1194 }
1195
1196
1197
1198
1199
1200
1201
1202
1203 @MaxQueryNumber(1006)
1204 public void testGetPublicSpacesCount() throws Exception {
1205 int countSpace = 10;
1206 Space[] listSpace = new Space[10];
1207 for (int i = 0; i < countSpace; i++) {
1208 listSpace[i] = this.getSpaceInstance(i);
1209 spaceStorage.saveSpace(listSpace[i], true);
1210 persist();
1211 }
1212 int publicSpacesCount = spaceStorage.getPublicSpacesCount("jame");
1213 assertEquals("publicSpacesCount must be: 0", 0, publicSpacesCount);
1214
1215 publicSpacesCount = spaceStorage.getPublicSpacesCount("paul");
1216 assertEquals("publicSpacesCount must be: 0", 0, publicSpacesCount);
1217
1218 publicSpacesCount = spaceStorage.getPublicSpacesCount("hacker");
1219 assertEquals("publicSpacesCount must be: 0", 0, publicSpacesCount);
1220
1221 publicSpacesCount = spaceStorage.getPublicSpacesCount("nobody");
1222 assertEquals("publicSpacesCount must be: " + countSpace, countSpace, publicSpacesCount);
1223 }
1224
1225
1226
1227
1228
1229
1230
1231
1232 @MaxQueryNumber(1029)
1233 public void testGetMemberSpaces() throws Exception {
1234 int countSpace = 10;
1235 Space[] listSpace = new Space[10];
1236 for (int i = 0; i < countSpace; i++) {
1237 listSpace[i] = this.getSpaceInstance(i);
1238 spaceStorage.saveSpace(listSpace[i], true);
1239 persist();
1240 }
1241
1242 List<Space> memberSpaces = spaceStorage.getMemberSpaces("raul");
1243 assertNotNull("memberSpaces must not be null", memberSpaces);
1244 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1245
1246 memberSpaces = spaceStorage.getMemberSpaces("ghost");
1247 assertNotNull("memberSpaces must not be null", memberSpaces);
1248 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1249
1250 memberSpaces = spaceStorage.getMemberSpaces("dragon");
1251 assertNotNull("memberSpaces must not be null", memberSpaces);
1252 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1253
1254 memberSpaces = spaceStorage.getMemberSpaces("demo");
1255 assertNotNull("memberSpaces must not be null", memberSpaces);
1256 assertEquals("memberSpaces.size() must return: 0", 0, memberSpaces.size());
1257 }
1258
1259
1260
1261
1262
1263
1264
1265
1266 @MaxQueryNumber(1029)
1267 public void testGetMemberSpacesByFilter() throws Exception {
1268 int countSpace = 10;
1269 Space[] listSpace = new Space[10];
1270 for (int i = 0; i < countSpace; i++) {
1271 listSpace[i] = this.getSpaceInstance(i);
1272 spaceStorage.saveSpace(listSpace[i], true);
1273 persist();
1274 }
1275
1276 List<Space> memberSpaces = spaceStorage.getMemberSpacesByFilter("raul", new SpaceFilter("my space test"), 0, 10);
1277 assertNotNull("memberSpaces must not be null", memberSpaces);
1278 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1279
1280 memberSpaces = spaceStorage.getMemberSpacesByFilter("ghost", new SpaceFilter("add new"), 0, 10);
1281 assertNotNull("memberSpaces must not be null", memberSpaces);
1282 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1283
1284 memberSpaces = spaceStorage.getMemberSpacesByFilter("ghost", new SpaceFilter("space"), 0, 10);
1285 assertNotNull("memberSpaces must not be null", memberSpaces);
1286 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1287
1288 memberSpaces = spaceStorage.getMemberSpacesByFilter("ghost", new SpaceFilter("new"), 0, 10);
1289 assertNotNull("memberSpaces must not be null", memberSpaces);
1290 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1291
1292 memberSpaces = spaceStorage.getMemberSpacesByFilter("ghost", new SpaceFilter('m'), 0, 10);
1293 assertNotNull("memberSpaces must not be null", memberSpaces);
1294 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1295
1296 memberSpaces = spaceStorage.getMemberSpacesByFilter("ghost", new SpaceFilter('M'), 0, 10);
1297 assertNotNull("memberSpaces must not be null", memberSpaces);
1298 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1299
1300 memberSpaces = spaceStorage.getMemberSpacesByFilter("ghost", new SpaceFilter('K'), 0, 10);
1301 assertNotNull("memberSpaces must not be null", memberSpaces);
1302 assertEquals("memberSpaces.size() must return: " + 0, 0, memberSpaces.size());
1303
1304 memberSpaces = spaceStorage.getMemberSpacesByFilter("dragon", new SpaceFilter("add"), 0, 10);
1305 assertNotNull("memberSpaces must not be null", memberSpaces);
1306 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1307
1308 memberSpaces = spaceStorage.getMemberSpacesByFilter("demo", new SpaceFilter("space"), 0, 10);
1309 assertNotNull("memberSpaces must not be null", memberSpaces);
1310 assertEquals("memberSpaces.size() must return: 0", 0, memberSpaces.size());
1311 }
1312
1313
1314
1315
1316
1317
1318
1319
1320 @MaxQueryNumber(1029)
1321 public void testGetMemberSpacesByFilterCount() throws Exception {
1322 int countSpace = 10;
1323 Space[] listSpace = new Space[10];
1324 for (int i = 0; i < countSpace; i++) {
1325 listSpace[i] = this.getSpaceInstance(i);
1326 spaceStorage.saveSpace(listSpace[i], true);
1327 persist();
1328 }
1329
1330 int memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("raul", new SpaceFilter("my space test"));
1331 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1332
1333 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("ghost", new SpaceFilter("add new"));
1334 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1335
1336 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("ghost", new SpaceFilter("space"));
1337 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1338
1339 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("ghost", new SpaceFilter("new"));
1340 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1341
1342 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("ghost", new SpaceFilter('m'));
1343 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1344
1345 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("ghost", new SpaceFilter('M'));
1346 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1347
1348 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("ghost", new SpaceFilter('K'));
1349 assertEquals("memberSpacesCount must be: " + 0, 0, memberSpacesCount);
1350
1351 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("dragon", new SpaceFilter("add"));
1352 assertEquals("memberSpacesCount must be: " + countSpace, countSpace, memberSpacesCount);
1353
1354 memberSpacesCount = spaceStorage.getMemberSpacesByFilterCount("demo", new SpaceFilter("space"));
1355 assertEquals("memberSpacesCount must be: 0", 0, memberSpacesCount);
1356 }
1357
1358
1359
1360
1361
1362
1363
1364
1365 @MaxQueryNumber(1029)
1366 public void testGetMemberSpacesWithListAccess() throws Exception {
1367 int countSpace = 10;
1368 for (int i = 0; i < countSpace; i++) {
1369 Space space = this.getSpaceInstance(i);
1370 spaceStorage.saveSpace(space, true);
1371 persist();
1372 }
1373
1374 List<Space> memberSpaces = spaceStorage.getMemberSpaces("raul", 0, 5);
1375 assertNotNull("memberSpaces must not be null", memberSpaces);
1376 assertEquals("memberSpaces.size() must return: " + 5, 5, memberSpaces.size());
1377
1378 memberSpaces = spaceStorage.getMemberSpaces("ghost", 0, countSpace);
1379 assertNotNull("memberSpaces must not be null", memberSpaces);
1380 assertEquals("memberSpaces.size() must return: " + countSpace, countSpace, memberSpaces.size());
1381
1382 memberSpaces = spaceStorage.getMemberSpaces("dragon", 0, 6);
1383 assertNotNull("memberSpaces must not be null", memberSpaces);
1384 assertEquals("memberSpaces.size() must return: " + 6, 6, memberSpaces.size());
1385
1386 memberSpaces = spaceStorage.getMemberSpaces("demo", 0, countSpace);
1387 assertNotNull("memberSpaces must not be null", memberSpaces);
1388 assertEquals("memberSpaces.size() must return: 0", 0, memberSpaces.size());
1389 }
1390
1391
1392
1393
1394
1395
1396
1397 @MaxQueryNumber(111)
1398 public void testGetSpaceById() throws Exception {
1399 int number = 1;
1400 Space space = this.getSpaceInstance(number);
1401
1402 spaceStorage.saveSpace(space, true);
1403 persist();
1404
1405 Space savedSpace = spaceStorage.getSpaceById(space.getId());
1406 assertNotNull("savedSpace must not be null", savedSpace);
1407 assertNotNull("savedSpace.getId() must not be null", savedSpace.getId());
1408 assertNotNull("savedSpace.getApp() must not be null", savedSpace.getApp());
1409 assertEquals("space.getId() must return: " + space.getId(), space.getId(), savedSpace.getId());
1410 assertEquals("space.getPrettyName() must return: " + space.getPrettyName(),
1411 space.getPrettyName(),
1412 savedSpace.getPrettyName());
1413 assertEquals("space.getRegistration() must return: " + space.getRegistration(),
1414 space.getRegistration(),
1415 savedSpace.getRegistration());
1416 assertEquals("space.getDescription() must return: " + space.getDescription(),
1417 space.getDescription(),
1418 savedSpace.getDescription());
1419 assertEquals("space.getType() must return: " + space.getType(), space.getType(), savedSpace.getType());
1420 assertEquals("space.getVisibility() must return: " + space.getVisibility(),
1421 space.getVisibility(),
1422 savedSpace.getVisibility());
1423 assertEquals("space.getPriority() must return: " + space.getPriority(), space.getPriority(), savedSpace.getPriority());
1424 }
1425
1426
1427
1428
1429
1430
1431
1432 @MaxQueryNumber(111)
1433 public void testGetSpaceByGroupId() throws Exception {
1434 Space space = getSpaceInstance(1);
1435 spaceStorage.saveSpace(space, true);
1436 persist();
1437 Space savedSpace = spaceStorage.getSpaceByGroupId(space.getGroupId());
1438
1439 assertNotNull("savedSpace must not be null", savedSpace);
1440 assertEquals(space.getId(), savedSpace.getId());
1441
1442 }
1443
1444
1445
1446
1447
1448
1449
1450 @MaxQueryNumber(111)
1451 public void testGetSpaceByUrl() throws Exception {
1452 int number = 1;
1453 Space space = this.getSpaceInstance(number);
1454 space.setUrl("http://fake.com.vn");
1455 spaceStorage.saveSpace(space, true);
1456 persist();
1457
1458
1459 Space savedSpace = spaceStorage.getSpaceByUrl(space.getUrl());
1460 assertNotNull("savedSpace must not be null", savedSpace);
1461 assertNotNull("savedSpace.getId() must not be null", savedSpace.getId());
1462 assertEquals("space.getId() must return: " + space.getId(), space.getId(), savedSpace.getId());
1463 assertEquals("space.getName() must return: " + space.getName(), space.getName(), savedSpace.getName());
1464
1465
1466 assertTrue("savedSpace.getName().equals(savedSpace.getPrettyName()) must return true",
1467 savedSpace.getName().equals(savedSpace.getPrettyName()));
1468
1469 assertEquals("space.getRegistration() must return: " + space.getRegistration(),
1470 space.getRegistration(),
1471 savedSpace.getRegistration());
1472 assertEquals("space.getDescription() must return: " + space.getDescription(),
1473 space.getDescription(),
1474 savedSpace.getDescription());
1475 assertEquals("space.getType() must return: " + space.getType(), space.getType(), savedSpace.getType());
1476 assertEquals("space.getVisibility() must equal savedSpace.getVisibility() = " + space.getVisibility(),
1477 space.getVisibility(),
1478 savedSpace.getVisibility());
1479 assertEquals("space.getPriority() must return: " + space.getPriority(), space.getPriority(), savedSpace.getPriority());
1480 assertEquals("space.getUrl() must return: " + space.getUrl(), space.getUrl(), savedSpace.getUrl());
1481 }
1482
1483
1484
1485
1486
1487
1488
1489 @MaxQueryNumber(111)
1490 public void testGetSpaceByPrettyName() throws Exception {
1491
1492 int number = 1;
1493
1494 Space space = this.getSpaceInstance(number);
1495 space.setType("CustomSpaceType");
1496
1497 spaceStorage.saveSpace(space, true);
1498 persist();
1499
1500
1501 Space foundSpaceList = spaceStorage.getSpaceByPrettyName(space.getPrettyName());
1502 assertNotNull("foundSpaceList must not be null", foundSpaceList);
1503 assertNotNull("foundSpaceList.getId() must not be null", foundSpaceList.getId());
1504 assertEquals("space.getId() must return: " + space.getId(), space.getId(), foundSpaceList.getId());
1505 assertEquals("space.getPrettyName() must return: " + space.getPrettyName(),
1506 space.getPrettyName(),
1507 foundSpaceList.getPrettyName());
1508 assertEquals("space.getRegistration() must return: " + space.getRegistration(),
1509 space.getRegistration(),
1510 foundSpaceList.getRegistration());
1511 assertEquals("space.getDescription() must return: " + space.getDescription(),
1512 space.getDescription(),
1513 foundSpaceList.getDescription());
1514 assertEquals("space.getType() must return: " + space.getType(), space.getType(), foundSpaceList.getType());
1515 assertEquals("space.getVisibility() must return: " + space.getVisibility(),
1516 space.getVisibility(),
1517 foundSpaceList.getVisibility());
1518 assertEquals("space.getPriority() must return: " + space.getPriority(), space.getPriority(), foundSpaceList.getPriority());
1519 }
1520
1521
1522
1523
1524
1525
1526
1527 @MaxQueryNumber(471)
1528 public void testDeleteSpace() throws Exception {
1529 int number = 1;
1530 Space space = this.getSpaceInstance(number);
1531 spaceStorage.saveSpace(space, true);
1532 persist();
1533 spaceStorage.deleteSpace(space.getId());
1534 }
1535
1536
1537
1538
1539
1540
1541
1542 @MaxQueryNumber(171)
1543 public void testSaveSpace() throws Exception {
1544 int number = 1;
1545 Space space = this.getSpaceInstance(number);
1546 spaceStorage.saveSpace(space, true);
1547 assertNotNull("space.getId() must not be null", space.getId());
1548 String newName = "newnamespace";
1549 space.setDisplayName(newName);
1550 space.setPrettyName(space.getDisplayName());
1551 spaceStorage.saveSpace(space, false);
1552 persist();
1553 assertEquals(newName, spaceStorage.getSpaceById(space.getId()).getName());
1554 assertEquals(newName, space.getName());
1555
1556 Space got = spaceStorage.getSpaceById(space.getId());
1557 assertEquals(null, got.getAvatarUrl());
1558 }
1559
1560
1561
1562
1563
1564
1565
1566 @MaxQueryNumber(560)
1567 public void testRenameSpace() throws Exception {
1568 int number = 1;
1569 Space space = this.getSpaceInstance(number);
1570 spaceStorage.saveSpace(space, true);
1571 assertNotNull("space.getId() must not be null", space.getId());
1572 String newName = "newnamespace";
1573 space.setDisplayName(newName);
1574 space.setPrettyName(space.getDisplayName());
1575 spaceStorage.saveSpace(space, false);
1576 persist();
1577 assertEquals("spaceStorage.getSpaceById(space.getId()).getName() must return: " + newName,
1578 newName,
1579 spaceStorage.getSpaceById(space.getId()).getPrettyName());
1580 assertEquals("space.getName() must return: " + newName, newName, space.getPrettyName());
1581
1582 Space got = spaceStorage.getSpaceById(space.getId());
1583 assertEquals(null, got.getAvatarUrl());
1584
1585 Identity spaceIdentity = new Identity(SpaceIdentityProvider.NAME, got.getPrettyName());
1586 identityStorage.saveIdentity(spaceIdentity);
1587
1588 String newDisplayName = "new display name";
1589 spaceStorage.renameSpace(space, newDisplayName);
1590
1591 got = spaceStorage.getSpaceById(space.getId());
1592 assertEquals(newDisplayName, got.getDisplayName());
1593 }
1594
1595
1596
1597
1598
1599
1600
1601 @MaxQueryNumber(210)
1602 public void _testSaveSpaceAvatar() throws Exception {
1603 int number = 1;
1604 Space space = this.getSpaceInstance(number);
1605 InputStream inputStream = getClass().getResourceAsStream("/eXo-Social.png");
1606 AvatarAttachment avatarAttachment = new AvatarAttachment(null,
1607 "avatar",
1608 "png",
1609 inputStream,
1610 null,
1611 System.currentTimeMillis());
1612 assertNotNull(avatarAttachment);
1613 space.setAvatarAttachment(avatarAttachment);
1614
1615 Identity identity = new Identity(SpaceIdentityProvider.NAME, space.getPrettyName());
1616 Profile profile = new Profile(identity);
1617 identity.setProfile(profile);
1618 profile.setProperty(Profile.AVATAR, avatarAttachment);
1619 identityStorage.saveIdentity(identity);
1620 identityStorage.saveProfile(profile);
1621
1622 spaceStorage.saveSpace(space, true);
1623 persist();
1624
1625 Space got = spaceStorage.getSpaceByPrettyName(space.getPrettyName());
1626
1627 assertNotNull(got.getAvatarUrl());
1628 String avatarRandomURL = got.getAvatarUrl();
1629 int indexOfLastupdatedParam = avatarRandomURL.indexOf("/?upd=");
1630 String avatarURL = null;
1631 if (indexOfLastupdatedParam != -1) {
1632 avatarURL = avatarRandomURL.substring(0, indexOfLastupdatedParam);
1633 } else {
1634 avatarURL = avatarRandomURL;
1635 }
1636 assertEquals(LinkProvider.escapeJCRSpecialCharacters(String.format("/rest/jcr/repository/portal-test/production/soc:providers/soc:space/soc:%s/soc:profile/soc:avatar",
1637 space.getPrettyName())),
1638 avatarURL);
1639 }
1640
1641
1642
1643
1644
1645
1646
1647 @MaxQueryNumber(210)
1648 public void testSaveSpaceBanner() throws Exception {
1649 int number = 1;
1650 Space space = this.getSpaceInstance(number);
1651 InputStream inputStream = getClass().getResourceAsStream("/eXo-Social.png");
1652 BannerAttachment bannerAttachment = new BannerAttachment(null,
1653 "banner",
1654 "png",
1655 inputStream,
1656 null,
1657 System.currentTimeMillis());
1658 assertNotNull(bannerAttachment);
1659 space.setBannerAttachment(bannerAttachment);
1660
1661 Identity identity = new Identity(SpaceIdentityProvider.NAME, space.getPrettyName());
1662 Profile profile = new Profile(identity);
1663 identity.setProfile(profile);
1664 profile.setProperty(Profile.BANNER, bannerAttachment);
1665 identityStorage.saveIdentity(identity);
1666 identityStorage.saveProfile(profile);
1667
1668 spaceStorage.saveSpace(space, true);
1669 StorageUtils.persist();
1670
1671 Space got = spaceStorage.getSpaceByPrettyName(space.getPrettyName());
1672
1673 assertNotNull(got.getBannerUrl());
1674 String bannerRandomURL = got.getBannerUrl();
1675 int indexOfLastupdatedParam = bannerRandomURL.indexOf("/?upd=");
1676 String bannerURL = null;
1677 if (indexOfLastupdatedParam != -1) {
1678 bannerURL = bannerRandomURL.substring(0, indexOfLastupdatedParam);
1679 } else {
1680 bannerURL = bannerRandomURL;
1681 }
1682 assertEquals(LinkProvider.escapeJCRSpecialCharacters(String.format("/rest/v1/social/spaces/my_space_test_1/banner",
1683 space.getPrettyName())),
1684 bannerURL);
1685 }
1686
1687
1688
1689
1690
1691
1692
1693
1694 @MaxQueryNumber(297)
1695 public void testUpdateSpace() throws Exception {
1696 int number = 1;
1697 Space space = this.getSpaceInstance(number);
1698 InputStream inputStream = getClass().getResourceAsStream("/eXo-Social.png");
1699 AvatarAttachment avatarAttachment = new AvatarAttachment(null,
1700 "avatar",
1701 "png",
1702 inputStream,
1703 null,
1704 System.currentTimeMillis());
1705 assertNotNull("avatar attachment should not be null", avatarAttachment);
1706 space.setAvatarAttachment(avatarAttachment);
1707 spaceStorage.saveSpace(space, true);
1708 persist();
1709
1710 Identity identity = new Identity(SpaceIdentityProvider.NAME, space.getPrettyName());
1711 Profile profile = new Profile(identity);
1712 identity.setProfile(profile);
1713 profile.setProperty(Profile.AVATAR, avatarAttachment);
1714 identityStorage.saveIdentity(identity);
1715
1716
1717
1718 Space spaceForUpdate = spaceStorage.getSpaceById(space.getId());
1719 spaceStorage.saveSpace(spaceForUpdate, false);
1720 persist();
1721
1722
1723 Space got = spaceStorage.getSpaceById(spaceForUpdate.getId());
1724
1725 assertNotNull("avatar URL should not be null", got.getAvatarUrl());
1726 }
1727
1728
1729
1730
1731
1732
1733
1734
1735 @MaxQueryNumber(210)
1736 public void testGetVisibleSpaces() throws Exception {
1737 int countSpace = 10;
1738 Space[] listSpace = new Space[10];
1739
1740
1741 for (int i = 0; i < countSpace; i++) {
1742
1743 if (i < 6)
1744
1745 listSpace[i] = this.getSpaceInstance(i, Space.PRIVATE, Space.OPEN, "demo");
1746 else
1747
1748 listSpace[i] = this.getSpaceInstance(i, Space.HIDDEN, Space.OPEN, "demo");
1749
1750 spaceStorage.saveSpace(listSpace[i], true);
1751 persist();
1752 }
1753
1754
1755 {
1756 int countSpace1 = 10;
1757 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", null);
1758 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1759 assertEquals("visibleSpaces() must return: " + countSpace1, countSpace1, visibleAllSpaces.size());
1760 }
1761
1762
1763
1764 {
1765 int countSpace2 = 10;
1766 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter('M'));
1767 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1768 assertEquals("visibleSpaces() must return: " + countSpace2, countSpace2, visibleAllSpaces.size());
1769 }
1770
1771
1772
1773 {
1774 int countSpace3 = 0;
1775 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter('A'));
1776 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1777 assertEquals("visibleSpaces() must return: " + countSpace3, countSpace3, visibleAllSpaces.size());
1778 }
1779
1780
1781 {
1782 int privateSpace1 = 6;
1783 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", null);
1784 assertNotNull("visibleSpaces must not be null", privateSpaces);
1785 assertEquals("visibleSpaces() must return: " + privateSpace1, privateSpace1, privateSpaces.size());
1786 }
1787
1788
1789
1790 {
1791 int privateSpace2 = 6;
1792 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter('M'));
1793 assertNotNull("visibleSpaces must not be null", privateSpaces);
1794 assertEquals("visibleSpaces() must return: " + privateSpace2, privateSpace2, privateSpaces.size());
1795 }
1796
1797
1798
1799 {
1800 int privateSpace3 = 0;
1801 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter('A'));
1802 assertNotNull("visibleSpaces must not be null", privateSpaces);
1803 assertEquals("visibleSpaces() must return: " + privateSpace3, privateSpace3, privateSpaces.size());
1804 }
1805 }
1806
1807
1808
1809
1810
1811
1812
1813
1814 @MaxQueryNumber(210)
1815 public void testGetVisibleSpacesWithValidate() throws Exception {
1816 int countSpace = 10;
1817 Space[] listSpace = new Space[10];
1818
1819
1820 for (int i = 0; i < countSpace; i++) {
1821
1822 if (i < 6)
1823
1824 listSpace[i] = this.getSpaceInstance(i, Space.PRIVATE, Space.VALIDATION, "demo");
1825 else
1826
1827 listSpace[i] = this.getSpaceInstance(i, Space.HIDDEN, Space.VALIDATION, "demo");
1828
1829 spaceStorage.saveSpace(listSpace[i], true);
1830 persist();
1831 }
1832
1833
1834 {
1835 int countSpace1 = 10;
1836 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", null);
1837 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1838 assertEquals("visibleSpaces() must return: " + countSpace1, countSpace1, visibleAllSpaces.size());
1839 }
1840
1841
1842
1843 {
1844 int countSpace2 = 10;
1845 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter('M'));
1846 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1847 assertEquals("visibleSpaces() must return: " + countSpace2, countSpace2, visibleAllSpaces.size());
1848 }
1849
1850
1851
1852 {
1853 int countSpace3 = 0;
1854 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter('A'));
1855 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1856 assertEquals("visibleSpaces() must return: " + countSpace3, countSpace3, visibleAllSpaces.size());
1857 }
1858
1859
1860 {
1861 int privateSpace1 = 6;
1862 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", null);
1863 assertNotNull("visibleSpaces must not be null", privateSpaces);
1864 assertEquals("visibleSpaces() must return: " + privateSpace1, privateSpace1, privateSpaces.size());
1865 }
1866
1867
1868
1869 {
1870 int privateSpace2 = 6;
1871 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter('M'));
1872 assertNotNull("visibleSpaces must not be null", privateSpaces);
1873 assertEquals("visibleSpaces() must return: " + privateSpace2, privateSpace2, privateSpaces.size());
1874 }
1875
1876
1877
1878 {
1879 int privateSpace3 = 0;
1880 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter('A'));
1881 assertNotNull("visibleSpaces must not be null", privateSpaces);
1882 assertEquals("visibleSpaces() must return: " + privateSpace3, privateSpace3, privateSpaces.size());
1883 }
1884 }
1885
1886
1887
1888
1889
1890
1891
1892
1893 @MaxQueryNumber(210)
1894 public void testGetVisibleSpacesFilterByName() throws Exception {
1895 int countSpace = 10;
1896 Space[] listSpace = new Space[10];
1897
1898
1899 for (int i = 0; i < countSpace; i++) {
1900
1901 if (i < 6)
1902
1903 listSpace[i] = this.getSpaceInstance(i, Space.PRIVATE, Space.OPEN, "demo");
1904 else
1905
1906 listSpace[i] = this.getSpaceInstance(i, Space.HIDDEN, Space.OPEN, "demo");
1907
1908 spaceStorage.saveSpace(listSpace[i], true);
1909 persist();
1910 }
1911
1912
1913 {
1914 int countSpace1 = 10;
1915 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", null);
1916 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1917 assertEquals("visibleSpaces() must return: " + countSpace1, countSpace1, visibleAllSpaces.size());
1918 }
1919
1920
1921
1922 {
1923 int countSpace2 = 10;
1924 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter("my space test"));
1925 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1926 assertEquals("visibleSpaces() must return: " + countSpace2, countSpace2, visibleAllSpaces.size());
1927 }
1928
1929
1930
1931 {
1932 int countSpace3 = 0;
1933 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter("your space"));
1934 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1935 assertEquals("visibleSpaces() must return: " + countSpace3, countSpace3, visibleAllSpaces.size());
1936 }
1937
1938
1939 {
1940 int privateSpace1 = 6;
1941 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", null);
1942 assertNotNull("visibleSpaces must not be null", privateSpaces);
1943 assertEquals("visibleSpaces() must return: " + privateSpace1, privateSpace1, privateSpaces.size());
1944 }
1945
1946
1947
1948 {
1949 int privateSpace2 = 6;
1950 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter("my space test"));
1951 assertNotNull("visibleSpaces must not be null", privateSpaces);
1952 assertEquals("visibleSpaces() must return: " + privateSpace2, privateSpace2, privateSpaces.size());
1953 }
1954
1955
1956
1957 {
1958 int privateSpace3 = 0;
1959 List<Space> privateSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter("your space"));
1960 assertNotNull("visibleSpaces must not be null", privateSpaces);
1961 assertEquals("visibleSpaces() must return: " + privateSpace3, privateSpace3, privateSpaces.size());
1962 }
1963 }
1964
1965
1966
1967
1968
1969
1970
1971
1972 @MaxQueryNumber(210)
1973 public void testGetVisibleSpacesCloseRegistration() throws Exception {
1974 int countSpace = 10;
1975 Space[] listSpace = new Space[10];
1976
1977
1978 for (int i = 0; i < countSpace; i++) {
1979
1980 if (i < 6)
1981
1982 listSpace[i] = this.getSpaceInstance(i, Space.PRIVATE, Space.CLOSE, "demo");
1983 else
1984
1985 listSpace[i] = this.getSpaceInstance(i, Space.HIDDEN, Space.CLOSE, "demo");
1986
1987 spaceStorage.saveSpace(listSpace[i], true);
1988 persist();
1989 }
1990
1991
1992 {
1993 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", null);
1994 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
1995 assertEquals("visibleSpaces() must return: " + countSpace, countSpace, visibleAllSpaces.size());
1996 }
1997
1998
1999 {
2000 int registrationCloseSpaceCount = 6;
2001 List<Space> registrationCloseSpaces = spaceStorage.getVisibleSpaces("mary", null);
2002 assertNotNull("registrationCloseSpaces must not be null", registrationCloseSpaces);
2003 assertEquals("registrationCloseSpaces must return: " + registrationCloseSpaceCount,
2004 registrationCloseSpaceCount,
2005 registrationCloseSpaces.size());
2006 }
2007 }
2008
2009
2010
2011
2012
2013
2014
2015
2016 @MaxQueryNumber(210)
2017 public void testGetVisibleSpacesCloseRegistrationByFilter() throws Exception {
2018 int countSpace = 10;
2019 Space[] listSpace = new Space[10];
2020
2021
2022 for (int i = 0; i < countSpace; i++) {
2023
2024 if (i < 6)
2025
2026
2027 listSpace[i] = this.getSpaceInstance(i, Space.PRIVATE, Space.CLOSE, "demo");
2028 else
2029
2030 listSpace[i] = this.getSpaceInstance(i, Space.HIDDEN, Space.CLOSE, "demo");
2031
2032 spaceStorage.saveSpace(listSpace[i], true);
2033 persist();
2034 }
2035
2036
2037
2038 {
2039 int countSpace1 = 10;
2040 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter('M'));
2041 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2042 assertEquals("visibleSpaces() must return: " + countSpace1, countSpace1, visibleAllSpaces.size());
2043 }
2044
2045
2046
2047 {
2048
2049 int countSpace2 = 0;
2050 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter('A'));
2051 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2052 assertEquals("visibleSpaces() must return: " + countSpace2, countSpace2, visibleAllSpaces.size());
2053 }
2054
2055
2056
2057 {
2058
2059 int countSpace3 = 10;
2060 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", new SpaceFilter("my space test"));
2061 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2062 assertEquals("visibleSpaces() must return: " + countSpace3, countSpace3, visibleAllSpaces.size());
2063 }
2064
2065
2066
2067 {
2068
2069 int countSpace4 = 10;
2070 List<Space> visibleAllSpaces = getSpaceWithRoot(new SpaceFilter("my space test"));
2071 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2072 assertEquals("visibleSpaces() must return: " + countSpace4, countSpace4, visibleAllSpaces.size());
2073 }
2074
2075
2076 {
2077
2078 int countSpace5 = 10;
2079 List<Space> visibleAllSpaces = getSpaceWithRoot(null);
2080 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2081 assertEquals("visibleSpaces() must return: " + countSpace5, countSpace5, visibleAllSpaces.size());
2082 }
2083
2084
2085
2086 {
2087
2088 int countSpace6 = 0;
2089 List<Space> visibleAllSpaces = getSpaceWithRoot(new SpaceFilter("your space"));
2090 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2091 assertEquals("visibleSpaces() must return: " + countSpace6, countSpace6, visibleAllSpaces.size());
2092 }
2093
2094
2095
2096 {
2097 int registrationCloseSpaceCount1 = 6;
2098 List<Space> registrationCloseSpaces = spaceStorage.getVisibleSpaces("mary", new SpaceFilter('M'));
2099 assertNotNull("registrationCloseSpaces must not be null", registrationCloseSpaces);
2100 assertEquals("registrationCloseSpaces must return: " + registrationCloseSpaceCount1,
2101 registrationCloseSpaceCount1,
2102 registrationCloseSpaces.size());
2103 }
2104
2105
2106
2107 {
2108 int registrationCloseSpaceCount2 = 10;
2109 List<Space> registrationCloseSpaces1 = spaceStorage.getSpacesByFilter(new SpaceFilter('M'), 0, 200);
2110 assertNotNull("registrationCloseSpaces must not be null", registrationCloseSpaces1);
2111 assertEquals("registrationCloseSpaces must return: " + registrationCloseSpaceCount2,
2112 registrationCloseSpaceCount2,
2113 registrationCloseSpaces1.size());
2114 }
2115 }
2116
2117
2118
2119
2120
2121
2122
2123
2124 @MaxQueryNumber(318)
2125 public void testGetVisibleSpacesInvitedMember() throws Exception {
2126 int countSpace = 10;
2127 Space[] listSpace = new Space[10];
2128
2129
2130 for (int i = 0; i < countSpace; i++) {
2131
2132 if (i < 6)
2133
2134 listSpace[i] = this.getSpaceInstanceInvitedMember(i,
2135 Space.PRIVATE,
2136 Space.CLOSE,
2137 new String[] { "mary", "hacker" },
2138 "demo");
2139 else
2140
2141 listSpace[i] = this.getSpaceInstance(i, Space.HIDDEN, Space.CLOSE, "demo");
2142
2143 spaceStorage.saveSpace(listSpace[i], true);
2144 persist();
2145 }
2146
2147
2148 {
2149 List<Space> visibleAllSpaces = spaceStorage.getVisibleSpaces("demo", null);
2150 assertNotNull("visibleSpaces must not be null", visibleAllSpaces);
2151 assertEquals("visibleSpaces() must return: " + countSpace, countSpace, visibleAllSpaces.size());
2152 }
2153
2154
2155 {
2156 int invitedSpaceCount1 = 6;
2157 List<Space> invitedSpaces1 = spaceStorage.getVisibleSpaces("mary", null);
2158 assertNotNull("invitedSpaces must not be null", invitedSpaces1);
2159 assertEquals("invitedSpaces must return: " + invitedSpaceCount1, invitedSpaceCount1, invitedSpaces1.size());
2160 }
2161
2162
2163 {
2164 int invitedSpaceCount1 = 6;
2165 List<Space> invitedSpaces1 = spaceStorage.getVisibleSpaces("hacker", null);
2166 assertNotNull("invitedSpaces must not be null", invitedSpaces1);
2167 assertEquals("invitedSpaces must return: " + invitedSpaceCount1, invitedSpaceCount1, invitedSpaces1.size());
2168 }
2169
2170
2171 {
2172 int invitedSpaceCount2 = 6;
2173 List<Space> invitedSpaces2 = spaceStorage.getVisibleSpaces("paul", null);
2174 assertNotNull("invitedSpaces must not be null", invitedSpaces2);
2175 assertEquals("invitedSpaces must return: " + invitedSpaceCount2, invitedSpaceCount2, invitedSpaces2.size());
2176 }
2177 }
2178
2179
2180
2181
2182
2183
2184 }