001
014
015 package com.liferay.portlet.trash.test;
016
017 import com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery;
018 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019 import com.liferay.portal.kernel.dao.orm.Property;
020 import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
021 import com.liferay.portal.kernel.exception.NoSuchModelException;
022 import com.liferay.portal.kernel.model.BaseModel;
023 import com.liferay.portal.kernel.model.ClassedModel;
024 import com.liferay.portal.kernel.model.ContainerModel;
025 import com.liferay.portal.kernel.model.Group;
026 import com.liferay.portal.kernel.model.SystemEventConstants;
027 import com.liferay.portal.kernel.model.TrashedModel;
028 import com.liferay.portal.kernel.model.WorkflowedModel;
029 import com.liferay.portal.kernel.service.ServiceContext;
030 import com.liferay.portal.kernel.service.SystemEventLocalServiceUtil;
031 import com.liferay.portal.kernel.test.rule.DeleteAfterTestRun;
032 import com.liferay.portal.kernel.test.util.GroupTestUtil;
033 import com.liferay.portal.kernel.test.util.ServiceContextTestUtil;
034 import com.liferay.portal.kernel.test.util.TestPropsValues;
035 import com.liferay.portal.kernel.trash.TrashHandler;
036 import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
037 import com.liferay.portal.kernel.util.PortalUtil;
038 import com.liferay.portal.kernel.workflow.WorkflowConstants;
039 import com.liferay.portal.kernel.workflow.WorkflowThreadLocal;
040 import com.liferay.trash.kernel.exception.RestoreEntryException;
041 import com.liferay.trash.kernel.exception.TrashEntryException;
042 import com.liferay.trash.kernel.model.TrashEntry;
043 import com.liferay.trash.kernel.service.TrashEntryLocalServiceUtil;
044 import com.liferay.trash.kernel.service.TrashEntryServiceUtil;
045 import com.liferay.trash.kernel.service.TrashVersionLocalServiceUtil;
046 import com.liferay.trash.kernel.util.TrashUtil;
047
048 import java.util.ArrayList;
049 import java.util.List;
050 import java.util.Objects;
051
052 import org.junit.Assert;
053 import org.junit.Assume;
054 import org.junit.Before;
055 import org.junit.Test;
056
057
063 public abstract class BaseTrashHandlerTestCase {
064
065 @Before
066 public void setUp() throws Exception {
067 group = GroupTestUtil.addGroup();
068 }
069
070 @Test
071 public void testDeleteTrashVersions() throws Exception {
072 Assume.assumeTrue(this instanceof WhenHasParent);
073 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
074
075 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
076 (WhenIsUpdatableBaseModel)this;
077
078 ServiceContext serviceContext =
079 ServiceContextTestUtil.getServiceContext(group.getGroupId());
080
081 BaseModel<?> parentBaseModel = getParentBaseModel(
082 group, serviceContext);
083
084 int initialTrashVersionsCount =
085 TrashVersionLocalServiceUtil.getTrashVersionsCount();
086
087 baseModel = addBaseModel(parentBaseModel, serviceContext);
088
089 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
090
091 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
092 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
093
094 WhenHasParent whenHasParent = (WhenHasParent)this;
095
096 whenHasParent.moveParentBaseModelToTrash(
097 (Long)parentBaseModel.getPrimaryKeyObj());
098
099 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
100 getBaseModelClassName());
101
102 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
103
104 Assert.assertEquals(
105 initialTrashVersionsCount,
106 TrashVersionLocalServiceUtil.getTrashVersionsCount());
107 }
108
109 @Test
110 public void testMoveBaseModelToTrash() throws Exception {
111 ServiceContext serviceContext =
112 ServiceContextTestUtil.getServiceContext(group.getGroupId());
113
114 BaseModel<?> parentBaseModel = getParentBaseModel(
115 group, serviceContext);
116
117 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
118 parentBaseModel);
119 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
120
121 baseModel = addBaseModel(parentBaseModel, serviceContext);
122
123 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
124
125 Assert.assertEquals(
126 initialBaseModelsCount,
127 getNotInTrashBaseModelsCount(parentBaseModel));
128 Assert.assertEquals(
129 initialTrashEntriesCount + 1,
130 getTrashEntriesCount(group.getGroupId()));
131
132 TrashEntry trashEntry = TrashEntryLocalServiceUtil.getEntry(
133 getBaseModelClassName(), getTrashEntryClassPK(baseModel));
134
135 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
136 getBaseModelClassName());
137
138 Assert.assertEquals(
139 1,
140 getDeletionSystemEventCount(
141 trashHandler, trashEntry.getSystemEventSetKey()));
142 }
143
144 @Test
145 public void testMoveBaseModelToTrashIndexable() throws Exception {
146 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
147 Assume.assumeFalse(this instanceof WhenParentModelIsSameType);
148
149 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
150 (WhenIsIndexableBaseModel)this;
151
152 int initialBaseModelsSearchCount =
153 whenIsIndexableBaseModel.searchBaseModelsCount(
154 getBaseModelClass(), group.getGroupId());
155
156 ServiceContext serviceContext =
157 ServiceContextTestUtil.getServiceContext(group.getGroupId());
158
159 int initialTrashEntriesSearchCount =
160 whenIsIndexableBaseModel.searchTrashEntriesCount(
161 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
162
163 BaseModel<?> parentBaseModel = getParentBaseModel(
164 group, serviceContext);
165
166 baseModel = addBaseModel(parentBaseModel, serviceContext);
167
168 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
169
170 Assert.assertEquals(
171 initialBaseModelsSearchCount,
172 whenIsIndexableBaseModel.searchBaseModelsCount(
173 getBaseModelClass(), group.getGroupId()));
174 Assert.assertEquals(
175 initialTrashEntriesSearchCount + 1,
176 whenIsIndexableBaseModel.searchTrashEntriesCount(
177 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
178 }
179
180 @Test
181 public void testMoveBaseModelToTrashIndexableWithEqualsParentAndBaseModelClass()
182 throws Exception {
183
184 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
185 Assume.assumeTrue(this instanceof WhenParentModelIsSameType);
186
187 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
188 (WhenIsIndexableBaseModel)this;
189
190 int initialBaseModelsSearchCount =
191 whenIsIndexableBaseModel.searchBaseModelsCount(
192 getBaseModelClass(), group.getGroupId());
193
194 ServiceContext serviceContext =
195 ServiceContextTestUtil.getServiceContext(group.getGroupId());
196
197 int initialTrashEntriesSearchCount =
198 whenIsIndexableBaseModel.searchTrashEntriesCount(
199 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
200
201 BaseModel<?> parentBaseModel = getParentBaseModel(
202 group, serviceContext);
203
204 baseModel = addBaseModel(parentBaseModel, serviceContext);
205
206 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
207
208 Assert.assertEquals(
209 initialBaseModelsSearchCount + 1,
210 whenIsIndexableBaseModel.searchBaseModelsCount(
211 getBaseModelClass(), group.getGroupId()));
212 Assert.assertEquals(
213 initialTrashEntriesSearchCount + 1,
214 whenIsIndexableBaseModel.searchTrashEntriesCount(
215 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
216 }
217
218 @Test
219 public void testMoveBaseModelToTrashIsNotVisible() throws Exception {
220 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
221
222 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
223 (WhenIsAssetableBaseModel)this;
224
225 ServiceContext serviceContext =
226 ServiceContextTestUtil.getServiceContext(group.getGroupId());
227
228 BaseModel<?> parentBaseModel = getParentBaseModel(
229 group, serviceContext);
230
231 baseModel = addBaseModel(parentBaseModel, serviceContext);
232
233 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
234
235 Assert.assertFalse(
236 whenIsAssetableBaseModel.isAssetEntryVisible(
237 baseModel, getAssetClassPK(baseModel)));
238 }
239
240 @Test
241 public void testMoveBaseModelToTrashStatusIsInTrash() throws Exception {
242 ServiceContext serviceContext =
243 ServiceContextTestUtil.getServiceContext(group.getGroupId());
244
245 BaseModel<?> parentBaseModel = getParentBaseModel(
246 group, serviceContext);
247
248 baseModel = addBaseModel(parentBaseModel, serviceContext);
249
250 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
251
252 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
253
254 workflowedModel = getWorkflowedModel(
255 getBaseModel((Long)baseModel.getPrimaryKeyObj()));
256
257 Assert.assertEquals(
258 WorkflowConstants.STATUS_IN_TRASH, workflowedModel.getStatus());
259 }
260
261 @Test
262 public void testMoveBaseModelToTrashUniqueTitleNotChange()
263 throws Exception {
264
265 ServiceContext serviceContext =
266 ServiceContextTestUtil.getServiceContext(group.getGroupId());
267
268 BaseModel<?> parentBaseModel = getParentBaseModel(
269 group, serviceContext);
270
271 baseModel = addBaseModel(parentBaseModel, serviceContext);
272
273 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
274
275 String uniqueTitle = getUniqueTitle(baseModel);
276
277 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
278
279 if (uniqueTitle != null) {
280 Assert.assertEquals(uniqueTitle, getUniqueTitle(baseModel));
281 }
282 }
283
284 @Test
285 public void testTrashAndDeleteWithApprovedStatus() throws Exception {
286 ServiceContext serviceContext =
287 ServiceContextTestUtil.getServiceContext(group.getGroupId());
288
289 BaseModel<?> parentBaseModel = getParentBaseModel(
290 group, serviceContext);
291
292 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
293 parentBaseModel);
294
295 baseModel = addBaseModel(parentBaseModel, serviceContext);
296
297 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
298
299 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
300
301 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
302 getBaseModelClassName());
303
304 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
305
306 Assert.assertEquals(
307 initialBaseModelsCount,
308 getNotInTrashBaseModelsCount(parentBaseModel));
309
310 Assert.assertEquals(1, getDeletionSystemEventCount(trashHandler, -1));
311 }
312
313 @Test
314 public void testTrashAndDeleteWithApprovedStatusIndexable()
315 throws Exception {
316
317 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
318 Assume.assumeFalse(this instanceof WhenParentModelIsSameType);
319
320 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
321 (WhenIsIndexableBaseModel)this;
322
323 int initialBaseModelsSearchCount =
324 whenIsIndexableBaseModel.searchBaseModelsCount(
325 getBaseModelClass(), group.getGroupId());
326
327 ServiceContext serviceContext =
328 ServiceContextTestUtil.getServiceContext(group.getGroupId());
329
330 int initialTrashEntriesSearchCount =
331 whenIsIndexableBaseModel.searchTrashEntriesCount(
332 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
333
334 BaseModel<?> parentBaseModel = getParentBaseModel(
335 group, serviceContext);
336
337 baseModel = addBaseModel(parentBaseModel, serviceContext);
338
339 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
340
341 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
342
343 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
344 getBaseModelClassName());
345
346 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
347
348 Assert.assertEquals(
349 initialBaseModelsSearchCount,
350 whenIsIndexableBaseModel.searchBaseModelsCount(
351 getBaseModelClass(), group.getGroupId()));
352 Assert.assertEquals(
353 initialTrashEntriesSearchCount,
354 whenIsIndexableBaseModel.searchTrashEntriesCount(
355 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
356 }
357
358 @Test
359 public void testTrashAndDeleteWithApprovedStatusIndexableAndEqualsParentAndBaseModelClass()
360 throws Exception {
361
362 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
363 Assume.assumeTrue(this instanceof WhenParentModelIsSameType);
364
365 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
366 (WhenIsIndexableBaseModel)this;
367
368 int initialBaseModelsSearchCount =
369 whenIsIndexableBaseModel.searchBaseModelsCount(
370 getBaseModelClass(), group.getGroupId());
371
372 ServiceContext serviceContext =
373 ServiceContextTestUtil.getServiceContext(group.getGroupId());
374
375 int initialTrashEntriesSearchCount =
376 whenIsIndexableBaseModel.searchTrashEntriesCount(
377 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
378
379 BaseModel<?> parentBaseModel = getParentBaseModel(
380 group, serviceContext);
381
382 baseModel = addBaseModel(parentBaseModel, serviceContext);
383
384 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
385
386 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
387
388 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
389 getBaseModelClassName());
390
391 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
392
393 Assert.assertEquals(
394 initialBaseModelsSearchCount + 1,
395 whenIsIndexableBaseModel.searchBaseModelsCount(
396 getBaseModelClass(), group.getGroupId()));
397 Assert.assertEquals(
398 initialTrashEntriesSearchCount,
399 whenIsIndexableBaseModel.searchTrashEntriesCount(
400 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
401 }
402
403 @Test
404 public void testTrashAndDeleteWithApprovedStatusIsNotFound()
405 throws Exception {
406
407 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
408
409 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
410 (WhenIsAssetableBaseModel)this;
411
412 ServiceContext serviceContext =
413 ServiceContextTestUtil.getServiceContext(group.getGroupId());
414
415 BaseModel<?> parentBaseModel = getParentBaseModel(
416 group, serviceContext);
417
418 baseModel = addBaseModel(parentBaseModel, serviceContext);
419
420 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
421
422 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
423
424 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
425 getBaseModelClassName());
426
427 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
428
429 Assert.assertNull(whenIsAssetableBaseModel.fetchAssetEntry(baseModel));
430 }
431
432 @Test
433 public void testTrashAndDeleteWithDraftStatus() throws Exception {
434 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
435
436 ServiceContext serviceContext =
437 ServiceContextTestUtil.getServiceContext(group.getGroupId());
438
439 BaseModel<?> parentBaseModel = getParentBaseModel(
440 group, serviceContext);
441
442 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
443 parentBaseModel);
444
445 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
446
447 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
448
449 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
450
451 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
452 getBaseModelClassName());
453
454 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
455
456 Assert.assertEquals(
457 initialBaseModelsCount,
458 getNotInTrashBaseModelsCount(parentBaseModel));
459 Assert.assertEquals(1, getDeletionSystemEventCount(trashHandler, -1));
460 }
461
462 @Test
463 public void testTrashAndDeleteWithDraftStatusIndexable() throws Exception {
464 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
465 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
466
467 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
468 (WhenIsIndexableBaseModel)this;
469
470 int initialBaseModelsSearchCount =
471 whenIsIndexableBaseModel.searchBaseModelsCount(
472 getBaseModelClass(), group.getGroupId());
473
474 ServiceContext serviceContext =
475 ServiceContextTestUtil.getServiceContext(group.getGroupId());
476
477 int initialTrashEntriesSearchCount =
478 whenIsIndexableBaseModel.searchTrashEntriesCount(
479 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
480
481 BaseModel<?> parentBaseModel = getParentBaseModel(
482 group, serviceContext);
483
484 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
485
486 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
487
488 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
489
490 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
491 getBaseModelClassName());
492
493 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
494
495 Assert.assertEquals(
496 initialBaseModelsSearchCount,
497 whenIsIndexableBaseModel.searchBaseModelsCount(
498 getBaseModelClass(), group.getGroupId()));
499 Assert.assertEquals(
500 initialTrashEntriesSearchCount,
501 whenIsIndexableBaseModel.searchTrashEntriesCount(
502 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
503 }
504
505 @Test
506 public void testTrashAndDeleteWithDraftStatusIsNotFound() throws Exception {
507 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
508 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
509
510 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
511 (WhenIsAssetableBaseModel)this;
512
513 ServiceContext serviceContext =
514 ServiceContextTestUtil.getServiceContext(group.getGroupId());
515
516 BaseModel<?> parentBaseModel = getParentBaseModel(
517 group, serviceContext);
518
519 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
520
521 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
522
523 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
524
525 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
526 getBaseModelClassName());
527
528 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
529
530 Assert.assertNull(whenIsAssetableBaseModel.fetchAssetEntry(baseModel));
531 }
532
533 @Test
534 public void testTrashAndRestoreWithApprovedStatus() throws Exception {
535 ServiceContext serviceContext =
536 ServiceContextTestUtil.getServiceContext(group.getGroupId());
537
538 BaseModel<?> parentBaseModel = getParentBaseModel(
539 group, serviceContext);
540
541 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
542 parentBaseModel);
543
544 baseModel = addBaseModel(parentBaseModel, serviceContext);
545
546 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
547
548 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
549
550 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
551 getBaseModelClassName());
552
553 trashHandler.restoreTrashEntry(
554 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
555
556 Assert.assertEquals(
557 initialBaseModelsCount + 1,
558 getNotInTrashBaseModelsCount(parentBaseModel));
559
560 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
561
562 Assert.assertEquals(0, getDeletionSystemEventCount(trashHandler, -1));
563 }
564
565 @Test
566 public void testTrashAndRestoreWithApprovedStatusIndexable()
567 throws Exception {
568
569 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
570 Assume.assumeFalse(this instanceof WhenParentModelIsSameType);
571
572 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
573 (WhenIsIndexableBaseModel)this;
574
575 int initialBaseModelsSearchCount =
576 whenIsIndexableBaseModel.searchBaseModelsCount(
577 getBaseModelClass(), group.getGroupId());
578
579 ServiceContext serviceContext =
580 ServiceContextTestUtil.getServiceContext(group.getGroupId());
581
582 int initialTrashEntriesSearchCount =
583 whenIsIndexableBaseModel.searchTrashEntriesCount(
584 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
585
586 BaseModel<?> parentBaseModel = getParentBaseModel(
587 group, serviceContext);
588
589 baseModel = addBaseModel(parentBaseModel, serviceContext);
590
591 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
592
593 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
594
595 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
596 getBaseModelClassName());
597
598 trashHandler.restoreTrashEntry(
599 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
600
601 Assert.assertEquals(
602 initialBaseModelsSearchCount + 1,
603 whenIsIndexableBaseModel.searchBaseModelsCount(
604 getBaseModelClass(), group.getGroupId()));
605 Assert.assertEquals(
606 initialTrashEntriesSearchCount,
607 whenIsIndexableBaseModel.searchTrashEntriesCount(
608 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
609 }
610
611 @Test
612 public void testTrashAndRestoreWithApprovedStatusIndexableAndEqualsParentAndBaseModelClass()
613 throws Exception {
614
615 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
616 Assume.assumeTrue(this instanceof WhenParentModelIsSameType);
617
618 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
619 (WhenIsIndexableBaseModel)this;
620
621 int initialBaseModelsSearchCount =
622 whenIsIndexableBaseModel.searchBaseModelsCount(
623 getBaseModelClass(), group.getGroupId());
624
625 ServiceContext serviceContext =
626 ServiceContextTestUtil.getServiceContext(group.getGroupId());
627
628 int initialTrashEntriesSearchCount =
629 whenIsIndexableBaseModel.searchTrashEntriesCount(
630 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
631
632 BaseModel<?> parentBaseModel = getParentBaseModel(
633 group, serviceContext);
634
635 baseModel = addBaseModel(parentBaseModel, serviceContext);
636
637 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
638
639 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
640
641 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
642 getBaseModelClassName());
643
644 trashHandler.restoreTrashEntry(
645 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
646
647 Assert.assertEquals(
648 initialBaseModelsSearchCount + 2,
649 whenIsIndexableBaseModel.searchBaseModelsCount(
650 getBaseModelClass(), group.getGroupId()));
651 Assert.assertEquals(
652 initialTrashEntriesSearchCount,
653 whenIsIndexableBaseModel.searchTrashEntriesCount(
654 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
655 }
656
657 @Test
658 public void testTrashAndRestoreWithApprovedStatusIsVisible()
659 throws Exception {
660
661 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
662
663 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
664 (WhenIsAssetableBaseModel)this;
665
666 ServiceContext serviceContext =
667 ServiceContextTestUtil.getServiceContext(group.getGroupId());
668
669 BaseModel<?> parentBaseModel = getParentBaseModel(
670 group, serviceContext);
671
672 baseModel = addBaseModel(parentBaseModel, serviceContext);
673
674 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
675
676 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
677
678 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
679 getBaseModelClassName());
680
681 trashHandler.restoreTrashEntry(
682 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
683
684 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
685
686 Assert.assertTrue(
687 whenIsAssetableBaseModel.isAssetEntryVisible(
688 baseModel, getAssetClassPK(baseModel)));
689 }
690
691 @Test
692 public void testTrashAndRestoreWithApprovedStatusRestoreStatus()
693 throws Exception {
694
695 ServiceContext serviceContext =
696 ServiceContextTestUtil.getServiceContext(group.getGroupId());
697
698 BaseModel<?> parentBaseModel = getParentBaseModel(
699 group, serviceContext);
700
701 baseModel = addBaseModel(parentBaseModel, serviceContext);
702
703 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
704
705 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
706
707 int oldStatus = workflowedModel.getStatus();
708
709 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
710
711 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
712 getBaseModelClassName());
713
714 trashHandler.restoreTrashEntry(
715 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
716
717 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
718
719 workflowedModel = getWorkflowedModel(baseModel);
720
721 Assert.assertEquals(oldStatus, workflowedModel.getStatus());
722 }
723
724 @Test
725 public void testTrashAndRestoreWithApprovedStatusRestoreUniqueTitle()
726 throws Exception {
727
728 ServiceContext serviceContext =
729 ServiceContextTestUtil.getServiceContext(group.getGroupId());
730
731 BaseModel<?> parentBaseModel = getParentBaseModel(
732 group, serviceContext);
733
734 baseModel = addBaseModel(parentBaseModel, serviceContext);
735
736 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
737
738 String uniqueTitle = getUniqueTitle(baseModel);
739
740 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
741
742 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
743 getBaseModelClassName());
744
745 trashHandler.restoreTrashEntry(
746 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
747
748 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
749
750 if (uniqueTitle != null) {
751 Assert.assertEquals(uniqueTitle, getUniqueTitle(baseModel));
752 }
753 }
754
755 @Test
756 public void testTrashAndRestoreWithDraftStatus() throws Exception {
757 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
758
759 ServiceContext serviceContext =
760 ServiceContextTestUtil.getServiceContext(group.getGroupId());
761
762 BaseModel<?> parentBaseModel = getParentBaseModel(
763 group, serviceContext);
764
765 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
766 parentBaseModel);
767
768 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
769
770 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
771
772 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
773 getBaseModelClassName());
774
775 trashHandler.restoreTrashEntry(
776 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
777
778 Assert.assertEquals(
779 initialBaseModelsCount + 1,
780 getNotInTrashBaseModelsCount(parentBaseModel));
781
782 Assert.assertEquals(0, getDeletionSystemEventCount(trashHandler, -1));
783 }
784
785 @Test
786 public void testTrashAndRestoreWithDraftStatusIndexable() throws Exception {
787 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
788 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
789
790 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
791 (WhenIsIndexableBaseModel)this;
792
793 int initialBaseModelsSearchCount =
794 whenIsIndexableBaseModel.searchBaseModelsCount(
795 getBaseModelClass(), group.getGroupId());
796
797 ServiceContext serviceContext =
798 ServiceContextTestUtil.getServiceContext(group.getGroupId());
799
800 int initialTrashEntriesSearchCount =
801 whenIsIndexableBaseModel.searchTrashEntriesCount(
802 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
803
804 BaseModel<?> parentBaseModel = getParentBaseModel(
805 group, serviceContext);
806
807 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
808
809 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
810
811 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
812 getBaseModelClassName());
813
814 trashHandler.restoreTrashEntry(
815 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
816
817 Assert.assertEquals(
818 initialBaseModelsSearchCount,
819 whenIsIndexableBaseModel.searchBaseModelsCount(
820 getBaseModelClass(), group.getGroupId()));
821 Assert.assertEquals(
822 initialTrashEntriesSearchCount,
823 whenIsIndexableBaseModel.searchTrashEntriesCount(
824 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
825 }
826
827 @Test
828 public void testTrashAndRestoreWithDraftStatusIsNotVisible()
829 throws Exception {
830
831 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
832 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
833
834 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
835 (WhenIsAssetableBaseModel)this;
836
837 ServiceContext serviceContext =
838 ServiceContextTestUtil.getServiceContext(group.getGroupId());
839
840 BaseModel<?> parentBaseModel = getParentBaseModel(
841 group, serviceContext);
842
843 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
844
845 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
846
847 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
848 getBaseModelClassName());
849
850 trashHandler.restoreTrashEntry(
851 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
852
853 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
854
855 Assert.assertFalse(
856 whenIsAssetableBaseModel.isAssetEntryVisible(
857 baseModel, getAssetClassPK(baseModel)));
858 }
859
860 @Test
861 public void testTrashAndRestoreWithDraftStatusRestoreStatus()
862 throws Exception {
863
864 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
865
866 ServiceContext serviceContext =
867 ServiceContextTestUtil.getServiceContext(group.getGroupId());
868
869 BaseModel<?> parentBaseModel = getParentBaseModel(
870 group, serviceContext);
871
872 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
873
874 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
875
876 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
877
878 int oldStatus = workflowedModel.getStatus();
879
880 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
881
882 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
883 getBaseModelClassName());
884
885 trashHandler.restoreTrashEntry(
886 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
887
888 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
889
890 workflowedModel = getWorkflowedModel(baseModel);
891
892 Assert.assertEquals(oldStatus, workflowedModel.getStatus());
893 }
894
895 @Test
896 public void testTrashAndRestoreWithDraftStatusRestoreUniqueTitle()
897 throws Exception {
898
899 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
900
901 ServiceContext serviceContext =
902 ServiceContextTestUtil.getServiceContext(group.getGroupId());
903
904 BaseModel<?> parentBaseModel = getParentBaseModel(
905 group, serviceContext);
906
907 baseModel = addDraftBaseModel(parentBaseModel, serviceContext);
908
909 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
910
911 String uniqueTitle = getUniqueTitle(baseModel);
912
913 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
914
915 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
916 getBaseModelClassName());
917
918 trashHandler.restoreTrashEntry(
919 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
920
921 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
922
923 if (uniqueTitle != null) {
924 Assert.assertEquals(uniqueTitle, getUniqueTitle(baseModel));
925 }
926 }
927
928 @Test
929 public void testTrashBaseModelAndDeleteWithParentIsNotRestorable()
930 throws Exception {
931
932 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
933
934 ServiceContext serviceContext =
935 ServiceContextTestUtil.getServiceContext(group.getGroupId());
936
937 BaseModel<?> parentBaseModel = getParentBaseModel(
938 group, serviceContext);
939
940 baseModel = addBaseModel(parentBaseModel, serviceContext);
941
942 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
943
944 deleteParentBaseModel(parentBaseModel, false);
945
946 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
947 getBaseModelClassName());
948
949 boolean restorable = trashHandler.isRestorable(
950 getAssetClassPK(baseModel));
951
952 Assert.assertFalse(restorable);
953 }
954
955 @Test
956 public void testTrashBaseModelAndParentAndDeleteGroupTrashEntries()
957 throws Exception {
958
959 Assume.assumeTrue(this instanceof WhenHasParent);
960
961 WhenHasParent whenHasParent = (WhenHasParent)this;
962
963 ServiceContext serviceContext =
964 ServiceContextTestUtil.getServiceContext(group.getGroupId());
965
966 BaseModel<?> parentBaseModel = getParentBaseModel(
967 group, serviceContext);
968
969 baseModel = addBaseModel(parentBaseModel, serviceContext);
970
971 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
972
973 whenHasParent.moveParentBaseModelToTrash(
974 (Long)parentBaseModel.getPrimaryKeyObj());
975
976 TrashEntryServiceUtil.deleteEntries(group.getGroupId());
977
978 Assert.assertEquals(0, getTrashEntriesCount(group.getGroupId()));
979
980 try {
981 getBaseModel((Long)baseModel.getPrimaryKeyObj());
982
983 Assert.fail();
984 }
985 catch (NoSuchModelException nsme) {
986 }
987 }
988
989 @Test
990 public void testTrashBaseModelAndParentAndDeleteParent() throws Exception {
991 Assume.assumeTrue(this instanceof WhenHasParent);
992 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
993
994 WhenHasParent whenHasParent = (WhenHasParent)this;
995
996 ServiceContext serviceContext =
997 ServiceContextTestUtil.getServiceContext(group.getGroupId());
998
999 BaseModel<?> parentBaseModel = getParentBaseModel(
1000 group, serviceContext);
1001
1002 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1003 parentBaseModel);
1004 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1005
1006 baseModel = addBaseModel(parentBaseModel, serviceContext);
1007
1008 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1009
1010 whenHasParent.moveParentBaseModelToTrash(
1011 (Long)parentBaseModel.getPrimaryKeyObj());
1012
1013 TrashHandler parentTrashHandler =
1014 TrashHandlerRegistryUtil.getTrashHandler(
1015 whenHasParent.getParentBaseModelClassName());
1016
1017 parentTrashHandler.deleteTrashEntry(
1018 (Long)parentBaseModel.getPrimaryKeyObj());
1019
1020 Assert.assertEquals(
1021 initialBaseModelsCount,
1022 getNotInTrashBaseModelsCount(parentBaseModel));
1023 Assert.assertEquals(
1024 initialTrashEntriesCount + 1,
1025 getTrashEntriesCount(group.getGroupId()));
1026
1027 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1028 getBaseModelClassName());
1029
1030 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
1031
1032 Assert.assertEquals(
1033 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1034 }
1035
1036 @Test
1037 public void testTrashBaseModelAndParentAndDeleteParentNoMoveableFromTrash()
1038 throws Exception {
1039
1040 Assume.assumeTrue(this instanceof WhenHasParent);
1041 Assume.assumeFalse(this instanceof WhenIsMoveableFromTrashBaseModel);
1042
1043 WhenHasParent whenHasParent = (WhenHasParent)this;
1044
1045 ServiceContext serviceContext =
1046 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1047
1048 BaseModel<?> parentBaseModel = getParentBaseModel(
1049 group, serviceContext);
1050
1051 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1052 parentBaseModel);
1053 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1054
1055 baseModel = addBaseModel(parentBaseModel, serviceContext);
1056
1057 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1058
1059 whenHasParent.moveParentBaseModelToTrash(
1060 (Long)parentBaseModel.getPrimaryKeyObj());
1061
1062 TrashHandler parentTrashHandler =
1063 TrashHandlerRegistryUtil.getTrashHandler(
1064 whenHasParent.getParentBaseModelClassName());
1065
1066 parentTrashHandler.deleteTrashEntry(
1067 (Long)parentBaseModel.getPrimaryKeyObj());
1068
1069 Assert.assertEquals(
1070 initialBaseModelsCount,
1071 getNotInTrashBaseModelsCount(parentBaseModel));
1072
1073 try {
1074 getBaseModel((Long)baseModel.getPrimaryKeyObj());
1075
1076 Assert.fail();
1077 }
1078 catch (NoSuchModelException nsme) {
1079 }
1080
1081 Assert.assertEquals(
1082 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1083 }
1084
1085 @Test
1086 public void testTrashBaseModelAndParentAndRestore() throws Exception {
1087 Assume.assumeTrue(this instanceof WhenHasParent);
1088
1089 WhenHasParent whenHasParent = (WhenHasParent)this;
1090
1091 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1092
1093 ServiceContext serviceContext =
1094 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1095
1096 BaseModel<?> parentBaseModel = getParentBaseModel(
1097 group, serviceContext);
1098
1099 baseModel = addBaseModel(parentBaseModel, serviceContext);
1100
1101 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1102
1103 whenHasParent.moveParentBaseModelToTrash(
1104 (Long)parentBaseModel.getPrimaryKeyObj());
1105
1106 Assert.assertEquals(
1107 initialTrashEntriesCount + 2,
1108 getTrashEntriesCount(group.getGroupId()));
1109
1110 TrashHandler parentTrashHandler =
1111 TrashHandlerRegistryUtil.getTrashHandler(
1112 whenHasParent.getParentBaseModelClassName());
1113
1114 if (Objects.equals(
1115 getBaseModelClassName(),
1116 whenHasParent.getParentBaseModelClassName())) {
1117
1118 Assert.assertEquals(
1119 0,
1120 parentTrashHandler.getTrashContainedModelsCount(
1121 (Long)parentBaseModel.getPrimaryKeyObj()));
1122 Assert.assertEquals(
1123 1,
1124 parentTrashHandler.getTrashContainerModelsCount(
1125 (Long)parentBaseModel.getPrimaryKeyObj()));
1126 }
1127 else {
1128 Assert.assertEquals(
1129 1,
1130 parentTrashHandler.getTrashContainedModelsCount(
1131 (Long)parentBaseModel.getPrimaryKeyObj()));
1132 Assert.assertEquals(
1133 0,
1134 parentTrashHandler.getTrashContainerModelsCount(
1135 (Long)parentBaseModel.getPrimaryKeyObj()));
1136 }
1137 }
1138
1139 @Test
1140 public void testTrashBaseModelAndParentAndRestoreModel() throws Exception {
1141 Assume.assumeTrue(this instanceof WhenHasParent);
1142 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
1143
1144 WhenHasParent whenHasParent = (WhenHasParent)this;
1145
1146 ServiceContext serviceContext =
1147 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1148
1149 BaseModel<?> parentBaseModel = getParentBaseModel(
1150 group, serviceContext);
1151
1152 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1153 parentBaseModel);
1154 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1155
1156 baseModel = addBaseModel(parentBaseModel, serviceContext);
1157
1158 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1159
1160 whenHasParent.moveParentBaseModelToTrash(
1161 (Long)parentBaseModel.getPrimaryKeyObj());
1162
1163 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
1164 (WhenIsMoveableFromTrashBaseModel)this;
1165
1166 BaseModel<?> newParentBaseModel =
1167 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
1168 baseModel, group, serviceContext);
1169
1170 Assert.assertEquals(
1171 initialBaseModelsCount + 1,
1172 getNotInTrashBaseModelsCount(newParentBaseModel));
1173 Assert.assertEquals(
1174 initialTrashEntriesCount + 1,
1175 getTrashEntriesCount(group.getGroupId()));
1176 }
1177
1178 @Test
1179 public void testTrashBaseModelAndParentAndRestoreModelIsVisible()
1180 throws Exception {
1181
1182 Assume.assumeTrue(this instanceof WhenHasParent);
1183 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
1184 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
1185
1186 WhenHasParent whenHasParent = (WhenHasParent)this;
1187
1188 ServiceContext serviceContext =
1189 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1190
1191 BaseModel<?> parentBaseModel = getParentBaseModel(
1192 group, serviceContext);
1193
1194 baseModel = addBaseModel(parentBaseModel, serviceContext);
1195
1196 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1197
1198 whenHasParent.moveParentBaseModelToTrash(
1199 (Long)parentBaseModel.getPrimaryKeyObj());
1200
1201 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
1202 (WhenIsMoveableFromTrashBaseModel)this;
1203
1204 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
1205 baseModel, group, serviceContext);
1206
1207 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
1208 (WhenIsAssetableBaseModel)this;
1209
1210 Assert.assertTrue(
1211 whenIsAssetableBaseModel.isAssetEntryVisible(
1212 baseModel, getAssetClassPK(baseModel)));
1213 }
1214
1215 @Test
1216 public void testTrashBaseModelAndParentIsInContainerBaseModel()
1217 throws Exception {
1218
1219 Assume.assumeTrue(this instanceof WhenHasParent);
1220
1221 WhenHasParent whenHasParent = (WhenHasParent)this;
1222
1223 ServiceContext serviceContext =
1224 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1225
1226 BaseModel<?> parentBaseModel = getParentBaseModel(
1227 group, serviceContext);
1228
1229 baseModel = addBaseModel(parentBaseModel, serviceContext);
1230
1231 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1232
1233 whenHasParent.moveParentBaseModelToTrash(
1234 (Long)parentBaseModel.getPrimaryKeyObj());
1235
1236 Assert.assertTrue(isInTrashContainer(baseModel));
1237 }
1238
1239 @Test
1240 public void testTrashBaseModelAndParentIsNotVisible() throws Exception {
1241 Assume.assumeTrue(this instanceof WhenHasParent);
1242 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
1243
1244 WhenHasParent whenHasParent = (WhenHasParent)this;
1245
1246 ServiceContext serviceContext =
1247 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1248
1249 BaseModel<?> parentBaseModel = getParentBaseModel(
1250 group, serviceContext);
1251
1252 baseModel = addBaseModel(parentBaseModel, serviceContext);
1253
1254 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1255
1256 whenHasParent.moveParentBaseModelToTrash(
1257 (Long)parentBaseModel.getPrimaryKeyObj());
1258
1259 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
1260 (WhenIsAssetableBaseModel)this;
1261
1262 Assert.assertFalse(
1263 whenIsAssetableBaseModel.isAssetEntryVisible(
1264 baseModel, getAssetClassPK(baseModel)));
1265 }
1266
1267 @Test
1268 public void testTrashBaseModelAndTrashParentAndDeleteParentIsNotRestorable()
1269 throws Exception {
1270
1271 Assume.assumeTrue(this instanceof WhenHasParent);
1272 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
1273
1274 WhenHasParent whenHasParent = (WhenHasParent)this;
1275
1276 ServiceContext serviceContext =
1277 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1278
1279 BaseModel<?> parentBaseModel = getParentBaseModel(
1280 group, serviceContext);
1281
1282 baseModel = addBaseModel(parentBaseModel, serviceContext);
1283
1284 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1285
1286 whenHasParent.moveParentBaseModelToTrash(
1287 (Long)parentBaseModel.getPrimaryKeyObj());
1288
1289 TrashHandler parentTrashHandler =
1290 TrashHandlerRegistryUtil.getTrashHandler(
1291 whenHasParent.getParentBaseModelClassName());
1292
1293 parentTrashHandler.deleteTrashEntry(
1294 (Long)parentBaseModel.getPrimaryKeyObj());
1295
1296 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1297 getBaseModelClassName());
1298
1299 boolean restorable = trashHandler.isRestorable(
1300 getAssetClassPK(baseModel));
1301
1302 Assert.assertFalse(restorable);
1303 }
1304
1305 @Test
1306 public void testTrashBaseModelAndTrashParentIsNotRestorable()
1307 throws Exception {
1308
1309 Assume.assumeTrue(this instanceof WhenHasParent);
1310 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
1311
1312 WhenHasParent whenHasParent = (WhenHasParent)this;
1313
1314 ServiceContext serviceContext =
1315 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1316
1317 BaseModel<?> parentBaseModel = getParentBaseModel(
1318 group, serviceContext);
1319
1320 baseModel = addBaseModel(parentBaseModel, serviceContext);
1321
1322 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1323
1324 whenHasParent.moveParentBaseModelToTrash(
1325 (Long)parentBaseModel.getPrimaryKeyObj());
1326
1327 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1328 getBaseModelClassName());
1329
1330 boolean restorable = trashHandler.isRestorable(
1331 getAssetClassPK(baseModel));
1332
1333 Assert.assertFalse(restorable);
1334 }
1335
1336 @Test
1337 public void testTrashBaseModelIsInTrashContainer() throws Exception {
1338 ServiceContext serviceContext =
1339 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1340
1341 BaseModel<?> parentBaseModel = getParentBaseModel(
1342 group, serviceContext);
1343
1344 baseModel = addBaseModel(parentBaseModel, serviceContext);
1345
1346 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1347
1348 Assert.assertFalse(isInTrashContainer(baseModel));
1349 }
1350
1351 @Test
1352 public void testTrashBaseModelWithParentIsRestorable() throws Exception {
1353 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
1354
1355 ServiceContext serviceContext =
1356 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1357
1358 BaseModel<?> parentBaseModel = getParentBaseModel(
1359 group, serviceContext);
1360
1361 baseModel = addBaseModel(parentBaseModel, serviceContext);
1362
1363 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1364
1365 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1366 getBaseModelClassName());
1367
1368 boolean restorable = trashHandler.isRestorable(
1369 getAssetClassPK(baseModel));
1370
1371 Assert.assertTrue(restorable);
1372 }
1373
1374 @Test
1375 public void testTrashDuplicate() throws Exception {
1376 Assume.assumeTrue(this instanceof WhenCanBeDuplicatedInTrash);
1377
1378 WhenCanBeDuplicatedInTrash whenCanBeDuplicatedInTrash =
1379 (WhenCanBeDuplicatedInTrash)this;
1380
1381 ServiceContext serviceContext =
1382 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1383
1384 BaseModel<?> parentBaseModel = getParentBaseModel(
1385 group, serviceContext);
1386
1387 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1388 parentBaseModel);
1389 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1390
1391 baseModel = addBaseModel(parentBaseModel, serviceContext);
1392
1393 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1394
1395 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
1396
1397 String baseModelName = whenCanBeDuplicatedInTrash.getBaseModelName(
1398 baseModel);
1399
1400 Assert.assertTrue(TrashUtil.isValidTrashTitle(baseModelName));
1401
1402 BaseModel<?> duplicateBaseModel = addBaseModel(
1403 parentBaseModel, serviceContext);
1404
1405 moveBaseModelToTrash((Long)duplicateBaseModel.getPrimaryKeyObj());
1406
1407 duplicateBaseModel = getBaseModel(
1408 (Long)duplicateBaseModel.getPrimaryKeyObj());
1409
1410 Assert.assertEquals(
1411 initialBaseModelsCount,
1412 getNotInTrashBaseModelsCount(parentBaseModel));
1413 Assert.assertEquals(
1414 initialTrashEntriesCount + 2,
1415 getTrashEntriesCount(group.getGroupId()));
1416
1417 String duplicateBaseModelName =
1418 whenCanBeDuplicatedInTrash.getBaseModelName(duplicateBaseModel);
1419
1420 Assert.assertTrue(TrashUtil.isValidTrashTitle(duplicateBaseModelName));
1421 }
1422
1423 @Test
1424 public void testTrashGrandparentBaseModel() throws Exception {
1425 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1426
1427 WhenHasParent whenHasParent = (WhenHasParent)this;
1428
1429 ServiceContext serviceContext =
1430 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1431
1432 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1433 group, serviceContext);
1434
1435 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1436 grandparentBaseModel);
1437 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1438
1439 BaseModel<?> parentBaseModel = getParentBaseModel(
1440 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1441 serviceContext);
1442
1443 baseModel = addBaseModel(parentBaseModel, serviceContext);
1444
1445 if (Objects.equals(
1446 getBaseModelClassName(),
1447 whenHasParent.getParentBaseModelClassName())) {
1448
1449 Assert.assertEquals(
1450 initialBaseModelsCount + 1,
1451 getNotInTrashBaseModelsCount(grandparentBaseModel));
1452 }
1453 else {
1454 Assert.assertEquals(
1455 initialBaseModelsCount,
1456 getNotInTrashBaseModelsCount(grandparentBaseModel));
1457 }
1458
1459 whenHasParent.moveParentBaseModelToTrash(
1460 (Long)grandparentBaseModel.getPrimaryKeyObj());
1461
1462 Assert.assertTrue(isInTrashContainer(baseModel));
1463 Assert.assertTrue(isInTrashContainer(parentBaseModel));
1464 Assert.assertEquals(
1465 initialBaseModelsCount,
1466 getNotInTrashBaseModelsCount(grandparentBaseModel));
1467 Assert.assertEquals(
1468 initialTrashEntriesCount + 1,
1469 getTrashEntriesCount(group.getGroupId()));
1470 }
1471
1472 @Test
1473 public void testTrashGrandparentBaseModelAndRestoreParentModel()
1474 throws Exception {
1475
1476 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1477
1478 WhenHasParent whenHasParent = (WhenHasParent)this;
1479
1480 ServiceContext serviceContext =
1481 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1482
1483 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1484 group, serviceContext);
1485
1486 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1487
1488 BaseModel<?> parentBaseModel = getParentBaseModel(
1489 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1490 serviceContext);
1491
1492 baseModel = addBaseModel(parentBaseModel, serviceContext);
1493
1494 whenHasParent.moveParentBaseModelToTrash(
1495 (Long)grandparentBaseModel.getPrimaryKeyObj());
1496
1497 TrashHandler parentTrashHandler =
1498 TrashHandlerRegistryUtil.getTrashHandler(
1499 whenHasParent.getParentBaseModelClassName());
1500
1501 parentTrashHandler.restoreTrashEntry(
1502 TestPropsValues.getUserId(),
1503 (Long)grandparentBaseModel.getPrimaryKeyObj());
1504
1505 Assert.assertEquals(
1506 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1507 }
1508
1509 @Test
1510 public void testTrashGrandparentBaseModelAndRestoreParentModelIsNotInTrashContainer()
1511 throws Exception {
1512
1513 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1514
1515 WhenHasParent whenHasParent = (WhenHasParent)this;
1516
1517 ServiceContext serviceContext =
1518 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1519
1520 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1521 group, serviceContext);
1522
1523 BaseModel<?> parentBaseModel = getParentBaseModel(
1524 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1525 serviceContext);
1526
1527 baseModel = addBaseModel(parentBaseModel, serviceContext);
1528
1529 whenHasParent.moveParentBaseModelToTrash(
1530 (Long)grandparentBaseModel.getPrimaryKeyObj());
1531
1532 TrashHandler parentTrashHandler =
1533 TrashHandlerRegistryUtil.getTrashHandler(
1534 whenHasParent.getParentBaseModelClassName());
1535
1536 parentTrashHandler.restoreTrashEntry(
1537 TestPropsValues.getUserId(),
1538 (Long)grandparentBaseModel.getPrimaryKeyObj());
1539
1540 Assert.assertFalse(isInTrashContainer(baseModel));
1541 Assert.assertFalse(isInTrashContainer(parentBaseModel));
1542 }
1543
1544 @Test
1545 public void testTrashGrandparentBaseModelAndRestoreParentModelIsVisible()
1546 throws Exception {
1547
1548 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1549 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
1550
1551 WhenHasParent whenHasParent = (WhenHasParent)this;
1552
1553 ServiceContext serviceContext =
1554 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1555
1556 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1557 group, serviceContext);
1558
1559 BaseModel<?> parentBaseModel = getParentBaseModel(
1560 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1561 serviceContext);
1562
1563 baseModel = addBaseModel(parentBaseModel, serviceContext);
1564
1565 whenHasParent.moveParentBaseModelToTrash(
1566 (Long)grandparentBaseModel.getPrimaryKeyObj());
1567
1568 TrashHandler parentTrashHandler =
1569 TrashHandlerRegistryUtil.getTrashHandler(
1570 whenHasParent.getParentBaseModelClassName());
1571
1572 parentTrashHandler.restoreTrashEntry(
1573 TestPropsValues.getUserId(),
1574 (Long)grandparentBaseModel.getPrimaryKeyObj());
1575
1576 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
1577 (WhenIsAssetableBaseModel)this;
1578
1579 Assert.assertTrue(
1580 whenIsAssetableBaseModel.isAssetEntryVisible(
1581 baseModel, getAssetClassPK(baseModel)));
1582 }
1583
1584 @Test
1585 public void testTrashGrandparentBaseModelAndRestoreParentModelIsVisibleParent()
1586 throws Exception {
1587
1588 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1589 Assume.assumeTrue(this instanceof WhenIsAssetableParentModel);
1590
1591 WhenHasParent whenHasParent = (WhenHasParent)this;
1592
1593 ServiceContext serviceContext =
1594 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1595
1596 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1597 group, serviceContext);
1598
1599 BaseModel<?> parentBaseModel = getParentBaseModel(
1600 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1601 serviceContext);
1602
1603 baseModel = addBaseModel(parentBaseModel, serviceContext);
1604
1605 whenHasParent.moveParentBaseModelToTrash(
1606 (Long)grandparentBaseModel.getPrimaryKeyObj());
1607
1608 TrashHandler parentTrashHandler =
1609 TrashHandlerRegistryUtil.getTrashHandler(
1610 whenHasParent.getParentBaseModelClassName());
1611
1612 parentTrashHandler.restoreTrashEntry(
1613 TestPropsValues.getUserId(),
1614 (Long)grandparentBaseModel.getPrimaryKeyObj());
1615
1616 WhenIsAssetableParentModel whenIsAssetableParentModel =
1617 (WhenIsAssetableParentModel)this;
1618
1619 Assert.assertTrue(
1620 whenIsAssetableParentModel.isAssetEntryVisible(
1621 parentBaseModel, getAssetClassPK(parentBaseModel)));
1622 }
1623
1624 @Test
1625 public void testTrashGrandparentBaseModelIsNotVisible() throws Exception {
1626 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1627 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
1628
1629 WhenHasParent whenHasParent = (WhenHasParent)this;
1630
1631 ServiceContext serviceContext =
1632 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1633
1634 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1635 group, serviceContext);
1636
1637 BaseModel<?> parentBaseModel = getParentBaseModel(
1638 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1639 serviceContext);
1640
1641 baseModel = addBaseModel(parentBaseModel, serviceContext);
1642
1643 whenHasParent.moveParentBaseModelToTrash(
1644 (Long)grandparentBaseModel.getPrimaryKeyObj());
1645
1646 WhenIsAssetableBaseModel whenIsAssetableModel =
1647 (WhenIsAssetableBaseModel)this;
1648
1649 Assert.assertFalse(
1650 whenIsAssetableModel.isAssetEntryVisible(
1651 baseModel, getAssetClassPK(baseModel)));
1652 }
1653
1654 @Test
1655 public void testTrashGrandparentBaseModelIsNotVisibleParent()
1656 throws Exception {
1657
1658 Assume.assumeTrue(this instanceof WhenHasGrandParent);
1659 Assume.assumeTrue(this instanceof WhenIsAssetableParentModel);
1660
1661 WhenHasParent whenHasParent = (WhenHasParent)this;
1662
1663 ServiceContext serviceContext =
1664 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1665
1666 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1667 group, serviceContext);
1668
1669 BaseModel<?> parentBaseModel = getParentBaseModel(
1670 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1671 serviceContext);
1672
1673 baseModel = addBaseModel(parentBaseModel, serviceContext);
1674
1675 whenHasParent.moveParentBaseModelToTrash(
1676 (Long)grandparentBaseModel.getPrimaryKeyObj());
1677
1678 WhenIsAssetableParentModel whenIsAssetableParentModel =
1679 (WhenIsAssetableParentModel)this;
1680
1681 Assert.assertFalse(
1682 whenIsAssetableParentModel.isAssetEntryVisible(
1683 parentBaseModel, getAssetClassPK(parentBaseModel)));
1684 }
1685
1686 @Test
1687 public void testTrashIsRestorableBaseModel() throws Exception {
1688 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
1689
1690 ServiceContext serviceContext =
1691 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1692
1693 baseModel = addBaseModelWithWorkflow(serviceContext);
1694
1695 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1696
1697 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1698 getBaseModelClassName());
1699
1700 boolean restorable = trashHandler.isRestorable(
1701 getAssetClassPK(baseModel));
1702
1703 Assert.assertTrue(restorable);
1704 }
1705
1706 @Test
1707 public void testTrashMyBaseModel() throws Exception {
1708 Assume.assumeTrue(this instanceof WhenHasMyBaseModel);
1709 Assume.assumeTrue(this instanceof WhenHasParent);
1710
1711 WhenHasMyBaseModel whenHasMyBaseModel = (WhenHasMyBaseModel)this;
1712
1713 int initialBaseModelsCount = whenHasMyBaseModel.getMineBaseModelsCount(
1714 group.getGroupId(), TestPropsValues.getUserId());
1715
1716 ServiceContext serviceContext =
1717 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1718
1719 BaseModel<?> parentBaseModel = getParentBaseModel(
1720 group, serviceContext);
1721
1722 addBaseModel(parentBaseModel, serviceContext);
1723
1724 Assert.assertEquals(
1725 initialBaseModelsCount + 1,
1726 whenHasMyBaseModel.getMineBaseModelsCount(
1727 group.getGroupId(), TestPropsValues.getUserId()));
1728
1729 WhenHasParent whenHasParent = (WhenHasParent)this;
1730
1731 whenHasParent.moveParentBaseModelToTrash(
1732 (Long)parentBaseModel.getPrimaryKeyObj());
1733
1734 Assert.assertEquals(
1735 initialBaseModelsCount,
1736 whenHasMyBaseModel.getMineBaseModelsCount(
1737 group.getGroupId(), TestPropsValues.getUserId()));
1738 }
1739
1740 @Test
1741 public void testTrashParent() throws Exception {
1742 Assume.assumeTrue(this instanceof WhenHasParent);
1743
1744 WhenHasParent whenHasParent = (WhenHasParent)this;
1745
1746 ServiceContext serviceContext =
1747 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1748
1749 BaseModel<?> parentBaseModel = getParentBaseModel(
1750 group, serviceContext);
1751
1752 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1753 parentBaseModel);
1754 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1755
1756 baseModel = addBaseModel(parentBaseModel, serviceContext);
1757
1758 whenHasParent.moveParentBaseModelToTrash(
1759 (Long)parentBaseModel.getPrimaryKeyObj());
1760
1761 Assert.assertEquals(
1762 initialBaseModelsCount,
1763 getNotInTrashBaseModelsCount(parentBaseModel));
1764 Assert.assertEquals(
1765 initialTrashEntriesCount + 1,
1766 getTrashEntriesCount(group.getGroupId()));
1767
1768 TrashHandler parentTrashHandler =
1769 TrashHandlerRegistryUtil.getTrashHandler(
1770 whenHasParent.getParentBaseModelClassName());
1771
1772 if (Objects.equals(
1773 getBaseModelClassName(),
1774 whenHasParent.getParentBaseModelClassName())) {
1775
1776 Assert.assertEquals(
1777 0,
1778 parentTrashHandler.getTrashContainedModelsCount(
1779 (Long)parentBaseModel.getPrimaryKeyObj()));
1780 Assert.assertEquals(
1781 1,
1782 parentTrashHandler.getTrashContainerModelsCount(
1783 (Long)parentBaseModel.getPrimaryKeyObj()));
1784 }
1785 else {
1786 Assert.assertEquals(
1787 1,
1788 parentTrashHandler.getTrashContainedModelsCount(
1789 (Long)parentBaseModel.getPrimaryKeyObj()));
1790 Assert.assertEquals(
1791 0,
1792 parentTrashHandler.getTrashContainerModelsCount(
1793 (Long)parentBaseModel.getPrimaryKeyObj()));
1794 }
1795 }
1796
1797 @Test(expected = TrashEntryException.class)
1798 public void testTrashParentAndBaseModel() throws Exception {
1799 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
1800
1801 ServiceContext serviceContext =
1802 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1803
1804 BaseModel<?> parentBaseModel = getParentBaseModel(
1805 group, serviceContext);
1806
1807 baseModel = addBaseModel(parentBaseModel, serviceContext);
1808
1809 WhenHasParent whenHasParent = (WhenHasParent)this;
1810
1811 whenHasParent.moveParentBaseModelToTrash(
1812 (Long)parentBaseModel.getPrimaryKeyObj());
1813
1814 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1815 }
1816
1817 @Test
1818 public void testTrashParentAndDeleteGroupTrashEntries() throws Exception {
1819 Assume.assumeTrue(this instanceof WhenHasParent);
1820
1821 WhenHasParent whenHasParent = (WhenHasParent)this;
1822
1823 ServiceContext serviceContext =
1824 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1825
1826 BaseModel<?> parentBaseModel = getParentBaseModel(
1827 group, serviceContext);
1828
1829 baseModel = addBaseModel(parentBaseModel, serviceContext);
1830
1831 whenHasParent.moveParentBaseModelToTrash(
1832 (Long)parentBaseModel.getPrimaryKeyObj());
1833
1834 TrashEntryServiceUtil.deleteEntries(group.getGroupId());
1835
1836 Assert.assertEquals(0, getTrashEntriesCount(group.getGroupId()));
1837
1838 try {
1839 getBaseModel((Long)baseModel.getPrimaryKeyObj());
1840
1841 Assert.fail();
1842 }
1843 catch (NoSuchModelException nsme) {
1844 }
1845 }
1846
1847 @Test
1848 public void testTrashParentAndDeleteParent() throws Exception {
1849 Assume.assumeTrue(this instanceof WhenHasParent);
1850
1851 WhenHasParent whenHasParent = (WhenHasParent)this;
1852
1853 ServiceContext serviceContext =
1854 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1855
1856 BaseModel<?> parentBaseModel = getParentBaseModel(
1857 group, serviceContext);
1858
1859 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1860 parentBaseModel);
1861 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1862
1863 baseModel = addBaseModel(parentBaseModel, serviceContext);
1864
1865 whenHasParent.moveParentBaseModelToTrash(
1866 (Long)parentBaseModel.getPrimaryKeyObj());
1867
1868 TrashHandler parentTrashHandler =
1869 TrashHandlerRegistryUtil.getTrashHandler(
1870 whenHasParent.getParentBaseModelClassName());
1871
1872 parentTrashHandler.deleteTrashEntry(
1873 (Long)parentBaseModel.getPrimaryKeyObj());
1874
1875 Assert.assertEquals(
1876 initialBaseModelsCount,
1877 getNotInTrashBaseModelsCount(parentBaseModel));
1878
1879 try {
1880 getBaseModel((Long)baseModel.getPrimaryKeyObj());
1881
1882 Assert.fail();
1883 }
1884 catch (NoSuchModelException nsme) {
1885 }
1886
1887 Assert.assertEquals(
1888 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1889 }
1890
1891 @Test
1892 public void testTrashParentAndRestoreBaseModelIsVisible() throws Exception {
1893 Assume.assumeTrue(this instanceof WhenHasParent);
1894 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
1895 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
1896
1897 WhenHasParent whenHasParent = (WhenHasParent)this;
1898
1899 ServiceContext serviceContext =
1900 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1901
1902 BaseModel<?> parentBaseModel = getParentBaseModel(
1903 group, serviceContext);
1904
1905 baseModel = addBaseModel(parentBaseModel, serviceContext);
1906
1907 whenHasParent.moveParentBaseModelToTrash(
1908 (Long)parentBaseModel.getPrimaryKeyObj());
1909
1910 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
1911 (WhenIsMoveableFromTrashBaseModel)this;
1912
1913 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
1914 baseModel, group, serviceContext);
1915
1916 WhenIsAssetableBaseModel whenIsAssetableModel =
1917 (WhenIsAssetableBaseModel)this;
1918
1919 Assert.assertTrue(
1920 whenIsAssetableModel.isAssetEntryVisible(
1921 baseModel, getAssetClassPK(baseModel)));
1922 }
1923
1924 @Test
1925 public void testTrashParentAndRestoreIndexable() throws Exception {
1926 Assume.assumeTrue(this instanceof WhenHasParent);
1927 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
1928 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
1929
1930 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
1931 (WhenIsIndexableBaseModel)this;
1932
1933 int initialBaseModelsSearchCount =
1934 whenIsIndexableBaseModel.searchBaseModelsCount(
1935 getBaseModelClass(), group.getGroupId());
1936
1937 WhenHasParent whenHasParent = (WhenHasParent)this;
1938
1939 ServiceContext serviceContext =
1940 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1941
1942 BaseModel<?> parentBaseModel = getParentBaseModel(
1943 group, serviceContext);
1944
1945 baseModel = addBaseModel(parentBaseModel, serviceContext);
1946
1947 whenHasParent.moveParentBaseModelToTrash(
1948 (Long)parentBaseModel.getPrimaryKeyObj());
1949
1950 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
1951 (WhenIsMoveableFromTrashBaseModel)this;
1952
1953 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
1954 baseModel, group, serviceContext);
1955
1956 if (isBaseModelContainerModel()) {
1957 Assert.assertEquals(
1958 initialBaseModelsSearchCount + 2,
1959 whenIsIndexableBaseModel.searchBaseModelsCount(
1960 getBaseModelClass(), group.getGroupId()));
1961 }
1962 else {
1963 Assert.assertEquals(
1964 initialBaseModelsSearchCount + 1,
1965 whenIsIndexableBaseModel.searchBaseModelsCount(
1966 getBaseModelClass(), group.getGroupId()));
1967 }
1968 }
1969
1970 @Test(expected = RestoreEntryException.class)
1971 public void testTrashParentAndRestoreParentAndBaseModel() throws Exception {
1972 Assume.assumeTrue(this instanceof WhenHasParent);
1973 Assume.assumeTrue(this instanceof WhenIsRestorableBaseModel);
1974 Assume.assumeTrue(
1975 this instanceof WhenIsRestorableParentBaseModelFromTrash);
1976
1977 ServiceContext serviceContext =
1978 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1979
1980 BaseModel<?> parentBaseModel = getParentBaseModel(
1981 group, serviceContext);
1982
1983 baseModel = addBaseModel(parentBaseModel, serviceContext);
1984
1985 WhenHasParent whenHasParent = (WhenHasParent)this;
1986
1987 whenHasParent.moveParentBaseModelToTrash(
1988 (Long)parentBaseModel.getPrimaryKeyObj());
1989
1990 WhenIsRestorableParentBaseModelFromTrash
1991 whenIsRestorableParentBaseModelFromTrash =
1992 (WhenIsRestorableParentBaseModelFromTrash)this;
1993
1994 whenIsRestorableParentBaseModelFromTrash.
1995 restoreParentBaseModelFromTrash(
1996 (Long)parentBaseModel.getPrimaryKeyObj());
1997
1998 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1999 getBaseModelClassName());
2000
2001 trashHandler.restoreTrashEntry(
2002 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
2003 }
2004
2005 @Test
2006 public void testTrashParentIndexable() throws Exception {
2007 Assume.assumeTrue(this instanceof WhenHasParent);
2008 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2009
2010 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2011 (WhenIsIndexableBaseModel)this;
2012
2013 int initialBaseModelsSearchCount =
2014 whenIsIndexableBaseModel.searchBaseModelsCount(
2015 getBaseModelClass(), group.getGroupId());
2016
2017 WhenHasParent whenHasParent = (WhenHasParent)this;
2018
2019 ServiceContext serviceContext =
2020 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2021
2022 BaseModel<?> parentBaseModel = getParentBaseModel(
2023 group, serviceContext);
2024
2025 baseModel = addBaseModel(parentBaseModel, serviceContext);
2026
2027 whenHasParent.moveParentBaseModelToTrash(
2028 (Long)parentBaseModel.getPrimaryKeyObj());
2029
2030 Assert.assertEquals(
2031 initialBaseModelsSearchCount,
2032 whenIsIndexableBaseModel.searchBaseModelsCount(
2033 getBaseModelClass(), group.getGroupId()));
2034 }
2035
2036 @Test
2037 public void testTrashParentIsNotVisible() throws Exception {
2038 Assume.assumeTrue(this instanceof WhenHasParent);
2039 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
2040
2041 WhenHasParent whenHasParent = (WhenHasParent)this;
2042
2043 ServiceContext serviceContext =
2044 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2045
2046 BaseModel<?> parentBaseModel = getParentBaseModel(
2047 group, serviceContext);
2048
2049 baseModel = addBaseModel(parentBaseModel, serviceContext);
2050
2051 whenHasParent.moveParentBaseModelToTrash(
2052 (Long)parentBaseModel.getPrimaryKeyObj());
2053
2054 WhenIsAssetableBaseModel whenIsAssetableModel =
2055 (WhenIsAssetableBaseModel)this;
2056
2057 Assert.assertFalse(
2058 whenIsAssetableModel.isAssetEntryVisible(
2059 baseModel, getAssetClassPK(baseModel)));
2060 }
2061
2062 @Test
2063 public void testTrashParentWithBaseModelIsInTrashContainer()
2064 throws Exception {
2065
2066 Assume.assumeTrue(this instanceof WhenHasParent);
2067
2068 WhenHasParent whenHasParent = (WhenHasParent)this;
2069
2070 ServiceContext serviceContext =
2071 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2072
2073 BaseModel<?> parentBaseModel = getParentBaseModel(
2074 group, serviceContext);
2075
2076 baseModel = addBaseModel(parentBaseModel, serviceContext);
2077
2078 whenHasParent.moveParentBaseModelToTrash(
2079 (Long)parentBaseModel.getPrimaryKeyObj());
2080
2081 Assert.assertTrue(isInTrashContainer(baseModel));
2082 }
2083
2084 @Test
2085 public void testTrashParentWithBaseModelIsIsNotVisible() throws Exception {
2086 Assume.assumeTrue(this instanceof WhenHasParent);
2087 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
2088
2089 WhenHasParent whenHasParent = (WhenHasParent)this;
2090
2091 ServiceContext serviceContext =
2092 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2093
2094 BaseModel<?> parentBaseModel = getParentBaseModel(
2095 group, serviceContext);
2096
2097 baseModel = addBaseModel(parentBaseModel, serviceContext);
2098
2099 whenHasParent.moveParentBaseModelToTrash(
2100 (Long)parentBaseModel.getPrimaryKeyObj());
2101
2102 WhenIsAssetableBaseModel whenIsAssetableModel =
2103 (WhenIsAssetableBaseModel)this;
2104
2105 Assert.assertFalse(
2106 whenIsAssetableModel.isAssetEntryVisible(
2107 baseModel, getAssetClassPK(baseModel)));
2108 }
2109
2110 @Test
2111 public void testTrashRecentBaseModel() throws Exception {
2112 Assume.assumeTrue(this instanceof WhenHasParent);
2113 Assume.assumeTrue(this instanceof WhenHasRecentBaseModelCount);
2114
2115 WhenHasRecentBaseModelCount whenHasRecentBaseModelCount =
2116 (WhenHasRecentBaseModelCount)this;
2117
2118 int initialBaseModelsCount =
2119 whenHasRecentBaseModelCount.getRecentBaseModelsCount(
2120 group.getGroupId());
2121
2122 WhenHasParent whenHasParent = (WhenHasParent)this;
2123
2124 ServiceContext serviceContext =
2125 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2126
2127 BaseModel<?> parentBaseModel = getParentBaseModel(
2128 group, serviceContext);
2129
2130 addBaseModel(parentBaseModel, serviceContext);
2131
2132 Assert.assertEquals(
2133 initialBaseModelsCount + 1,
2134 whenHasRecentBaseModelCount.getRecentBaseModelsCount(
2135 group.getGroupId()));
2136
2137 whenHasParent.moveParentBaseModelToTrash(
2138 (Long)parentBaseModel.getPrimaryKeyObj());
2139
2140 Assert.assertEquals(
2141 initialBaseModelsCount,
2142 whenHasRecentBaseModelCount.getRecentBaseModelsCount(
2143 group.getGroupId()));
2144 }
2145
2146 @Test
2147 public void testTrashVersionBaseModel() throws Exception {
2148 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2149
2150 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2151 (WhenIsUpdatableBaseModel)this;
2152
2153 ServiceContext serviceContext =
2154 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2155
2156 BaseModel<?> parentBaseModel = getParentBaseModel(
2157 group, serviceContext);
2158
2159 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
2160 parentBaseModel);
2161 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
2162
2163 baseModel = addBaseModel(parentBaseModel, serviceContext);
2164
2165 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2166 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2167
2168 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2169
2170 Assert.assertEquals(
2171 initialBaseModelsCount,
2172 getNotInTrashBaseModelsCount(parentBaseModel));
2173 Assert.assertEquals(
2174 initialTrashEntriesCount + 1,
2175 getTrashEntriesCount(group.getGroupId()));
2176 }
2177
2178 @Test
2179 public void testTrashVersionBaseModelAndDelete() throws Exception {
2180 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2181
2182 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2183 (WhenIsUpdatableBaseModel)this;
2184
2185 ServiceContext serviceContext =
2186 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2187
2188 BaseModel<?> parentBaseModel = getParentBaseModel(
2189 group, serviceContext);
2190
2191 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
2192 parentBaseModel);
2193 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
2194
2195 baseModel = addBaseModel(parentBaseModel, serviceContext);
2196
2197 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2198 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2199
2200 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2201
2202 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2203 getBaseModelClassName());
2204
2205 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
2206
2207 Assert.assertEquals(
2208 initialBaseModelsCount,
2209 getNotInTrashBaseModelsCount(parentBaseModel));
2210 Assert.assertEquals(
2211 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
2212 }
2213
2214 @Test
2215 public void testTrashVersionBaseModelAndDeleteIndexable() throws Exception {
2216 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2217 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2218 Assume.assumeFalse(this instanceof WhenParentModelIsSameType);
2219
2220 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2221 (WhenIsIndexableBaseModel)this;
2222
2223 int initialBaseModelsSearchCount =
2224 whenIsIndexableBaseModel.searchBaseModelsCount(
2225 getBaseModelClass(), group.getGroupId());
2226
2227 ServiceContext serviceContext =
2228 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2229
2230 int initialTrashEntriesSearchCount =
2231 whenIsIndexableBaseModel.searchTrashEntriesCount(
2232 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
2233
2234 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2235 (WhenIsUpdatableBaseModel)this;
2236
2237 BaseModel<?> parentBaseModel = getParentBaseModel(
2238 group, serviceContext);
2239
2240 baseModel = addBaseModel(parentBaseModel, serviceContext);
2241
2242 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2243 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2244
2245 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2246
2247 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2248 getBaseModelClassName());
2249
2250 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
2251
2252 Assert.assertEquals(
2253 initialBaseModelsSearchCount,
2254 whenIsIndexableBaseModel.searchBaseModelsCount(
2255 getBaseModelClass(), group.getGroupId()));
2256 Assert.assertEquals(
2257 initialTrashEntriesSearchCount,
2258 whenIsIndexableBaseModel.searchTrashEntriesCount(
2259 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
2260 }
2261
2262 @Test
2263 public void testTrashVersionBaseModelAndDeleteIndexableWithEqualsParentAndBaseModelClass()
2264 throws Exception {
2265
2266 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2267 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2268 Assume.assumeTrue(this instanceof WhenParentModelIsSameType);
2269
2270 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2271 (WhenIsIndexableBaseModel)this;
2272
2273 int initialBaseModelsSearchCount =
2274 whenIsIndexableBaseModel.searchBaseModelsCount(
2275 getBaseModelClass(), group.getGroupId());
2276
2277 ServiceContext serviceContext =
2278 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2279
2280 int initialTrashEntriesSearchCount =
2281 whenIsIndexableBaseModel.searchTrashEntriesCount(
2282 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
2283
2284 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2285 (WhenIsUpdatableBaseModel)this;
2286
2287 BaseModel<?> parentBaseModel = getParentBaseModel(
2288 group, serviceContext);
2289
2290 baseModel = addBaseModel(parentBaseModel, serviceContext);
2291
2292 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2293 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2294
2295 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2296
2297 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2298 getBaseModelClassName());
2299
2300 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
2301
2302 Assert.assertEquals(
2303 initialBaseModelsSearchCount + 1,
2304 whenIsIndexableBaseModel.searchBaseModelsCount(
2305 getBaseModelClass(), group.getGroupId()));
2306 Assert.assertEquals(
2307 initialTrashEntriesSearchCount,
2308 whenIsIndexableBaseModel.searchTrashEntriesCount(
2309 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
2310 }
2311
2312 @Test
2313 public void testTrashVersionBaseModelAndDeleteIsNotFound()
2314 throws Exception {
2315
2316 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
2317 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2318
2319 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2320 (WhenIsUpdatableBaseModel)this;
2321
2322 ServiceContext serviceContext =
2323 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2324
2325 BaseModel<?> parentBaseModel = getParentBaseModel(
2326 group, serviceContext);
2327
2328 baseModel = addBaseModel(parentBaseModel, serviceContext);
2329
2330 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2331 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2332
2333 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2334
2335 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2336 getBaseModelClassName());
2337
2338 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
2339
2340 WhenIsAssetableBaseModel whenIsAssetableBaseModel =
2341 (WhenIsAssetableBaseModel)this;
2342
2343 Assert.assertNull(whenIsAssetableBaseModel.fetchAssetEntry(baseModel));
2344 }
2345
2346 @Test
2347 public void testTrashVersionBaseModelAndRestore() throws Exception {
2348 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2349
2350 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2351 (WhenIsUpdatableBaseModel)this;
2352
2353 ServiceContext serviceContext =
2354 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2355
2356 BaseModel<?> parentBaseModel = getParentBaseModel(
2357 group, serviceContext);
2358
2359 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
2360 parentBaseModel);
2361 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
2362
2363 baseModel = addBaseModel(parentBaseModel, serviceContext);
2364
2365 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2366 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2367
2368 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2369
2370 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2371 getBaseModelClassName());
2372
2373 trashHandler.restoreTrashEntry(
2374 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
2375
2376 Assert.assertEquals(
2377 initialBaseModelsCount + 1,
2378 getNotInTrashBaseModelsCount(parentBaseModel));
2379 Assert.assertEquals(
2380 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
2381 }
2382
2383 @Test
2384 public void testTrashVersionBaseModelAndRestoreIndexable()
2385 throws Exception {
2386
2387 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2388 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2389 Assume.assumeFalse(this instanceof WhenParentModelIsSameType);
2390
2391 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2392 (WhenIsIndexableBaseModel)this;
2393
2394 int initialBaseModelsSearchCount =
2395 whenIsIndexableBaseModel.searchBaseModelsCount(
2396 getBaseModelClass(), group.getGroupId());
2397
2398 ServiceContext serviceContext =
2399 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2400
2401 int initialTrashEntriesSearchCount =
2402 whenIsIndexableBaseModel.searchTrashEntriesCount(
2403 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
2404
2405 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2406 (WhenIsUpdatableBaseModel)this;
2407
2408 BaseModel<?> parentBaseModel = getParentBaseModel(
2409 group, serviceContext);
2410
2411 baseModel = addBaseModel(parentBaseModel, serviceContext);
2412
2413 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2414 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2415
2416 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2417
2418 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2419 getBaseModelClassName());
2420
2421 trashHandler.restoreTrashEntry(
2422 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
2423
2424 Assert.assertEquals(
2425 initialBaseModelsSearchCount + 1,
2426 whenIsIndexableBaseModel.searchBaseModelsCount(
2427 getBaseModelClass(), group.getGroupId()));
2428 Assert.assertEquals(
2429 initialTrashEntriesSearchCount,
2430 whenIsIndexableBaseModel.searchTrashEntriesCount(
2431 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
2432 }
2433
2434 @Test
2435 public void testTrashVersionBaseModelAndRestoreIndexableWithEqualsParentAndBaseModelClass()
2436 throws Exception {
2437
2438 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2439 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2440 Assume.assumeTrue(this instanceof WhenParentModelIsSameType);
2441
2442 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2443 (WhenIsIndexableBaseModel)this;
2444
2445 int initialBaseModelsSearchCount =
2446 whenIsIndexableBaseModel.searchBaseModelsCount(
2447 getBaseModelClass(), group.getGroupId());
2448
2449 ServiceContext serviceContext =
2450 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2451
2452 int initialTrashEntriesSearchCount =
2453 whenIsIndexableBaseModel.searchTrashEntriesCount(
2454 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
2455
2456 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2457 (WhenIsUpdatableBaseModel)this;
2458
2459 BaseModel<?> parentBaseModel = getParentBaseModel(
2460 group, serviceContext);
2461
2462 baseModel = addBaseModel(parentBaseModel, serviceContext);
2463
2464 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2465 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2466
2467 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2468
2469 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2470 getBaseModelClassName());
2471
2472 trashHandler.restoreTrashEntry(
2473 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
2474
2475 Assert.assertEquals(
2476 initialBaseModelsSearchCount + 2,
2477 whenIsIndexableBaseModel.searchBaseModelsCount(
2478 getBaseModelClass(), group.getGroupId()));
2479 Assert.assertEquals(
2480 initialTrashEntriesSearchCount,
2481 whenIsIndexableBaseModel.searchTrashEntriesCount(
2482 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
2483 }
2484
2485 @Test
2486 public void testTrashVersionBaseModelAndRestoreIsVisible()
2487 throws Exception {
2488
2489 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
2490 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2491
2492 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2493 (WhenIsUpdatableBaseModel)this;
2494
2495 ServiceContext serviceContext =
2496 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2497
2498 BaseModel<?> parentBaseModel = getParentBaseModel(
2499 group, serviceContext);
2500
2501 baseModel = addBaseModel(parentBaseModel, serviceContext);
2502
2503 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2504 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2505
2506 WhenIsAssetableBaseModel whenIsAssetableModel =
2507 (WhenIsAssetableBaseModel)this;
2508
2509 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2510
2511 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
2512 getBaseModelClassName());
2513
2514 trashHandler.restoreTrashEntry(
2515 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
2516
2517 Assert.assertTrue(
2518 whenIsAssetableModel.isAssetEntryVisible(
2519 baseModel, getAssetClassPK(baseModel)));
2520 }
2521
2522 @Test
2523 public void testTrashVersionBaseModelIndexable() throws Exception {
2524 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2525 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2526 Assume.assumeFalse(this instanceof WhenParentModelIsSameType);
2527
2528 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2529 (WhenIsIndexableBaseModel)this;
2530
2531 int initialBaseModelsSearchCount =
2532 whenIsIndexableBaseModel.searchBaseModelsCount(
2533 getBaseModelClass(), group.getGroupId());
2534
2535 ServiceContext serviceContext =
2536 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2537
2538 int initialTrashEntriesSearchCount =
2539 whenIsIndexableBaseModel.searchTrashEntriesCount(
2540 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
2541
2542 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2543 (WhenIsUpdatableBaseModel)this;
2544
2545 BaseModel<?> parentBaseModel = getParentBaseModel(
2546 group, serviceContext);
2547
2548 baseModel = addBaseModel(parentBaseModel, serviceContext);
2549
2550 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2551 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2552
2553 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2554
2555 Assert.assertEquals(
2556 initialBaseModelsSearchCount,
2557 whenIsIndexableBaseModel.searchBaseModelsCount(
2558 getBaseModelClass(), group.getGroupId()));
2559 Assert.assertEquals(
2560 initialTrashEntriesSearchCount + 1,
2561 whenIsIndexableBaseModel.searchTrashEntriesCount(
2562 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
2563 }
2564
2565 @Test
2566 public void testTrashVersionBaseModelIndexableWithEqualsParentAndBaseModelClass()
2567 throws Exception {
2568
2569 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2570 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2571 Assume.assumeTrue(this instanceof WhenParentModelIsSameType);
2572
2573 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2574 (WhenIsIndexableBaseModel)this;
2575
2576 int initialBaseModelsSearchCount =
2577 whenIsIndexableBaseModel.searchBaseModelsCount(
2578 getBaseModelClass(), group.getGroupId());
2579
2580 ServiceContext serviceContext =
2581 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2582
2583 int initialTrashEntriesSearchCount =
2584 whenIsIndexableBaseModel.searchTrashEntriesCount(
2585 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
2586
2587 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2588 (WhenIsUpdatableBaseModel)this;
2589
2590 BaseModel<?> parentBaseModel = getParentBaseModel(
2591 group, serviceContext);
2592
2593 baseModel = addBaseModel(parentBaseModel, serviceContext);
2594
2595 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2596 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2597
2598 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2599
2600 Assert.assertEquals(
2601 initialBaseModelsSearchCount + 1,
2602 whenIsIndexableBaseModel.searchBaseModelsCount(
2603 getBaseModelClass(), group.getGroupId()));
2604 Assert.assertEquals(
2605 initialTrashEntriesSearchCount + 1,
2606 whenIsIndexableBaseModel.searchTrashEntriesCount(
2607 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
2608 }
2609
2610 @Test
2611 public void testTrashVersionBaseModelIsNotVisible() throws Exception {
2612 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
2613 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2614
2615 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2616 (WhenIsUpdatableBaseModel)this;
2617
2618 ServiceContext serviceContext =
2619 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2620
2621 BaseModel<?> parentBaseModel = getParentBaseModel(
2622 group, serviceContext);
2623
2624 baseModel = addBaseModel(parentBaseModel, serviceContext);
2625
2626 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2627 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2628
2629 WhenIsAssetableBaseModel whenIsAssetableModel =
2630 (WhenIsAssetableBaseModel)this;
2631
2632 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
2633
2634 Assert.assertFalse(
2635 whenIsAssetableModel.isAssetEntryVisible(
2636 baseModel, getAssetClassPK(baseModel)));
2637 }
2638
2639 @Test
2640 public void testTrashVersionParentBaseModel() throws Exception {
2641 Assume.assumeTrue(this instanceof WhenHasParent);
2642 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2643 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
2644
2645 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
2646 (WhenIsVersionableBaseModel)this;
2647
2648 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
2649
2650 ServiceContext serviceContext =
2651 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2652
2653 BaseModel<?> parentBaseModel = getParentBaseModel(
2654 group, serviceContext);
2655
2656 baseModel = addBaseModel(parentBaseModel, serviceContext);
2657
2658 baseModel = whenIsVersionableBaseModel.expireBaseModel(
2659 baseModel, serviceContext);
2660
2661 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2662 (WhenIsUpdatableBaseModel)this;
2663
2664 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
2665
2666 List<Integer> originalStatuses = new ArrayList<>();
2667
2668 originalStatuses.add(workflowedModel.getStatus());
2669
2670 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
2671
2672 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2673 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2674
2675 workflowedModel = getWorkflowedModel(baseModel);
2676
2677 originalStatuses.add(workflowedModel.getStatus());
2678
2679 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
2680
2681 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2682 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2683
2684 WhenHasParent whenHasParent = (WhenHasParent)this;
2685
2686 workflowedModel = getWorkflowedModel(baseModel);
2687
2688 originalStatuses.add(workflowedModel.getStatus());
2689
2690 whenHasParent.moveParentBaseModelToTrash(
2691 (Long)parentBaseModel.getPrimaryKeyObj());
2692
2693 Assert.assertEquals(
2694 initialTrashEntriesCount + 1,
2695 getTrashEntriesCount(group.getGroupId()));
2696 Assert.assertTrue(isInTrashContainer(baseModel));
2697 }
2698
2699 @Test
2700 public void testTrashVersionParentBaseModelAndCustomRestore()
2701 throws Exception {
2702
2703 Assume.assumeTrue(this instanceof WhenHasParent);
2704 Assume.assumeFalse(this instanceof WhenIsMoveableFromTrashBaseModel);
2705 Assume.assumeTrue(
2706 this instanceof WhenIsRestorableParentBaseModelFromTrash);
2707 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2708 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
2709
2710 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
2711 (WhenIsVersionableBaseModel)this;
2712
2713 ServiceContext serviceContext =
2714 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2715
2716 BaseModel<?> parentBaseModel = getParentBaseModel(
2717 group, serviceContext);
2718
2719 baseModel = addBaseModel(parentBaseModel, serviceContext);
2720
2721 baseModel = whenIsVersionableBaseModel.expireBaseModel(
2722 baseModel, serviceContext);
2723
2724 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2725 (WhenIsUpdatableBaseModel)this;
2726
2727 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
2728
2729 List<Integer> originalStatuses = new ArrayList<>();
2730
2731 originalStatuses.add(workflowedModel.getStatus());
2732
2733 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
2734
2735 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2736 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2737
2738 workflowedModel = getWorkflowedModel(baseModel);
2739
2740 originalStatuses.add(workflowedModel.getStatus());
2741
2742 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
2743
2744 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2745 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2746
2747 WhenHasParent whenHasParent = (WhenHasParent)this;
2748
2749 workflowedModel = getWorkflowedModel(baseModel);
2750
2751 originalStatuses.add(workflowedModel.getStatus());
2752
2753 whenHasParent.moveParentBaseModelToTrash(
2754 (Long)parentBaseModel.getPrimaryKeyObj());
2755
2756 WhenIsRestorableParentBaseModelFromTrash
2757 whenIsRestorableParentBaseModelFromTrash =
2758 (WhenIsRestorableParentBaseModelFromTrash)this;
2759
2760 whenIsRestorableParentBaseModelFromTrash.
2761 restoreParentBaseModelFromTrash(
2762 (Long)parentBaseModel.getPrimaryKeyObj());
2763
2764 List<? extends WorkflowedModel> childrenWorkflowedModels =
2765 whenIsRestorableParentBaseModelFromTrash.
2766 getChildrenWorkflowedModels(parentBaseModel);
2767
2768 for (int i = 1; i <= childrenWorkflowedModels.size(); i++) {
2769 WorkflowedModel childrenWorkflowedModel =
2770 childrenWorkflowedModels.get(i - 1);
2771
2772 int originalStatus = originalStatuses.get(
2773 childrenWorkflowedModels.size() - i);
2774
2775 Assert.assertEquals(
2776 originalStatus, childrenWorkflowedModel.getStatus());
2777 }
2778 }
2779
2780 @Test
2781 public void testTrashVersionParentBaseModelAndRestore() throws Exception {
2782 Assume.assumeTrue(this instanceof WhenHasParent);
2783 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
2784 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2785 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
2786
2787 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
2788 (WhenIsVersionableBaseModel)this;
2789
2790 ServiceContext serviceContext =
2791 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2792
2793 BaseModel<?> parentBaseModel = getParentBaseModel(
2794 group, serviceContext);
2795
2796 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
2797 parentBaseModel);
2798 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
2799
2800 baseModel = addBaseModel(parentBaseModel, serviceContext);
2801
2802 baseModel = whenIsVersionableBaseModel.expireBaseModel(
2803 baseModel, serviceContext);
2804
2805 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2806 (WhenIsUpdatableBaseModel)this;
2807
2808 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
2809
2810 List<Integer> originalStatuses = new ArrayList<>();
2811
2812 originalStatuses.add(workflowedModel.getStatus());
2813
2814 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
2815
2816 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2817 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2818
2819 workflowedModel = getWorkflowedModel(baseModel);
2820
2821 originalStatuses.add(workflowedModel.getStatus());
2822
2823 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
2824
2825 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2826 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2827
2828 WhenHasParent whenHasParent = (WhenHasParent)this;
2829
2830 workflowedModel = getWorkflowedModel(baseModel);
2831
2832 originalStatuses.add(workflowedModel.getStatus());
2833
2834 whenHasParent.moveParentBaseModelToTrash(
2835 (Long)parentBaseModel.getPrimaryKeyObj());
2836
2837 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
2838 (WhenIsMoveableFromTrashBaseModel)this;
2839
2840 BaseModel<?> newParentBaseModel =
2841 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
2842 baseModel, group, serviceContext);
2843
2844 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
2845
2846 Assert.assertEquals(
2847 initialBaseModelsCount + 1,
2848 getNotInTrashBaseModelsCount(newParentBaseModel));
2849 Assert.assertEquals(
2850 initialTrashEntriesCount + 1,
2851 getTrashEntriesCount(group.getGroupId()));
2852 }
2853
2854 @Test
2855 public void testTrashVersionParentBaseModelAndRestoreIsNotInTrashContainer()
2856 throws Exception {
2857
2858 Assume.assumeTrue(this instanceof WhenHasParent);
2859 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
2860 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2861 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
2862
2863 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
2864 (WhenIsVersionableBaseModel)this;
2865
2866 ServiceContext serviceContext =
2867 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2868
2869 BaseModel<?> parentBaseModel = getParentBaseModel(
2870 group, serviceContext);
2871
2872 baseModel = addBaseModel(parentBaseModel, serviceContext);
2873
2874 baseModel = whenIsVersionableBaseModel.expireBaseModel(
2875 baseModel, serviceContext);
2876
2877 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2878 (WhenIsUpdatableBaseModel)this;
2879
2880 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
2881
2882 List<Integer> originalStatuses = new ArrayList<>();
2883
2884 originalStatuses.add(workflowedModel.getStatus());
2885
2886 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
2887
2888 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2889 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2890
2891 workflowedModel = getWorkflowedModel(baseModel);
2892
2893 originalStatuses.add(workflowedModel.getStatus());
2894
2895 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
2896
2897 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2898 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2899
2900 WhenHasParent whenHasParent = (WhenHasParent)this;
2901
2902 workflowedModel = getWorkflowedModel(baseModel);
2903
2904 originalStatuses.add(workflowedModel.getStatus());
2905
2906 whenHasParent.moveParentBaseModelToTrash(
2907 (Long)parentBaseModel.getPrimaryKeyObj());
2908
2909 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
2910 (WhenIsMoveableFromTrashBaseModel)this;
2911
2912 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
2913 baseModel, group, serviceContext);
2914
2915 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
2916
2917 Assert.assertFalse(isInTrashContainer(baseModel));
2918 }
2919
2920 @Test
2921 public void testTrashVersionParentBaseModelAndRestoreIsVisible()
2922 throws Exception {
2923
2924 Assume.assumeTrue(this instanceof WhenHasParent);
2925 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
2926 Assume.assumeTrue(this instanceof WhenIsMoveableFromTrashBaseModel);
2927 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2928 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
2929
2930 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
2931 (WhenIsVersionableBaseModel)this;
2932
2933 ServiceContext serviceContext =
2934 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2935
2936 BaseModel<?> parentBaseModel = getParentBaseModel(
2937 group, serviceContext);
2938
2939 baseModel = addBaseModel(parentBaseModel, serviceContext);
2940
2941 baseModel = whenIsVersionableBaseModel.expireBaseModel(
2942 baseModel, serviceContext);
2943
2944 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
2945 (WhenIsUpdatableBaseModel)this;
2946
2947 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
2948
2949 List<Integer> originalStatuses = new ArrayList<>();
2950
2951 originalStatuses.add(workflowedModel.getStatus());
2952
2953 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
2954
2955 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2956 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2957
2958 workflowedModel = getWorkflowedModel(baseModel);
2959
2960 originalStatuses.add(workflowedModel.getStatus());
2961
2962 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
2963
2964 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
2965 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2966
2967 WhenHasParent whenHasParent = (WhenHasParent)this;
2968
2969 workflowedModel = getWorkflowedModel(baseModel);
2970
2971 originalStatuses.add(workflowedModel.getStatus());
2972
2973 whenHasParent.moveParentBaseModelToTrash(
2974 (Long)parentBaseModel.getPrimaryKeyObj());
2975
2976 WhenIsMoveableFromTrashBaseModel whenIsMoveableFromTrashBaseModel =
2977 (WhenIsMoveableFromTrashBaseModel)this;
2978
2979 whenIsMoveableFromTrashBaseModel.moveBaseModelFromTrash(
2980 baseModel, group, serviceContext);
2981
2982 WhenIsAssetableBaseModel whenIsAssetableModel =
2983 (WhenIsAssetableBaseModel)this;
2984
2985 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
2986
2987 Assert.assertTrue(
2988 whenIsAssetableModel.isAssetEntryVisible(
2989 baseModel, getAssetClassPK(baseModel)));
2990 }
2991
2992 @Test
2993 public void testTrashVersionParentBaseModelIndexable() throws Exception {
2994 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
2995 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
2996 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
2997
2998 WhenIsIndexableBaseModel whenIsIndexableBaseModel =
2999 (WhenIsIndexableBaseModel)this;
3000
3001 int initialBaseModelsSearchCount =
3002 whenIsIndexableBaseModel.searchBaseModelsCount(
3003 getBaseModelClass(), group.getGroupId());
3004
3005 ServiceContext serviceContext =
3006 ServiceContextTestUtil.getServiceContext(group.getGroupId());
3007
3008 int initialTrashEntriesSearchCount =
3009 whenIsIndexableBaseModel.searchTrashEntriesCount(
3010 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext);
3011
3012 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
3013 (WhenIsVersionableBaseModel)this;
3014
3015 BaseModel<?> parentBaseModel = getParentBaseModel(
3016 group, serviceContext);
3017
3018 baseModel = addBaseModel(parentBaseModel, serviceContext);
3019
3020 baseModel = whenIsVersionableBaseModel.expireBaseModel(
3021 baseModel, serviceContext);
3022
3023 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
3024 (WhenIsUpdatableBaseModel)this;
3025
3026 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
3027
3028 List<Integer> originalStatuses = new ArrayList<>();
3029
3030 originalStatuses.add(workflowedModel.getStatus());
3031
3032 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
3033
3034 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
3035 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
3036
3037 workflowedModel = getWorkflowedModel(baseModel);
3038
3039 originalStatuses.add(workflowedModel.getStatus());
3040
3041 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
3042
3043 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
3044 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
3045
3046 workflowedModel = getWorkflowedModel(baseModel);
3047
3048 originalStatuses.add(workflowedModel.getStatus());
3049
3050 Assert.assertEquals(
3051 initialBaseModelsSearchCount + 1,
3052 whenIsIndexableBaseModel.searchBaseModelsCount(
3053 getBaseModelClass(), group.getGroupId()));
3054 Assert.assertEquals(
3055 initialTrashEntriesSearchCount,
3056 whenIsIndexableBaseModel.searchTrashEntriesCount(
3057 whenIsIndexableBaseModel.getSearchKeywords(), serviceContext));
3058 }
3059
3060 @Test
3061 public void testTrashVersionParentBaseModelIsNotVisible() throws Exception {
3062 Assume.assumeTrue(this instanceof WhenHasParent);
3063 Assume.assumeTrue(this instanceof WhenIsAssetableBaseModel);
3064 Assume.assumeTrue(this instanceof WhenIsUpdatableBaseModel);
3065 Assume.assumeTrue(this instanceof WhenIsVersionableBaseModel);
3066
3067 WhenIsVersionableBaseModel whenIsVersionableBaseModel =
3068 (WhenIsVersionableBaseModel)this;
3069
3070 ServiceContext serviceContext =
3071 ServiceContextTestUtil.getServiceContext(group.getGroupId());
3072
3073 BaseModel<?> parentBaseModel = getParentBaseModel(
3074 group, serviceContext);
3075
3076 baseModel = addBaseModel(parentBaseModel, serviceContext);
3077
3078 baseModel = whenIsVersionableBaseModel.expireBaseModel(
3079 baseModel, serviceContext);
3080
3081 WhenIsUpdatableBaseModel whenIsUpdatableBaseModel =
3082 (WhenIsUpdatableBaseModel)this;
3083
3084 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
3085
3086 List<Integer> originalStatuses = new ArrayList<>();
3087
3088 originalStatuses.add(workflowedModel.getStatus());
3089
3090 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
3091
3092 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
3093 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
3094
3095 workflowedModel = getWorkflowedModel(baseModel);
3096
3097 originalStatuses.add(workflowedModel.getStatus());
3098
3099 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
3100
3101 baseModel = whenIsUpdatableBaseModel.updateBaseModel(
3102 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
3103
3104 WhenHasParent whenHasParent = (WhenHasParent)this;
3105
3106 workflowedModel = getWorkflowedModel(baseModel);
3107
3108 originalStatuses.add(workflowedModel.getStatus());
3109
3110 whenHasParent.moveParentBaseModelToTrash(
3111 (Long)parentBaseModel.getPrimaryKeyObj());
3112
3113 WhenIsAssetableBaseModel whenIsAssetableModel =
3114 (WhenIsAssetableBaseModel)this;
3115
3116 Assert.assertFalse(
3117 whenIsAssetableModel.isAssetEntryVisible(
3118 baseModel, getAssetClassPK(baseModel)));
3119 }
3120
3121 protected BaseModel<?> addBaseModel(
3122 BaseModel<?> parentBaseModel, ServiceContext serviceContext)
3123 throws Exception {
3124
3125 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
3126
3127 try {
3128 WorkflowThreadLocal.setEnabled(true);
3129
3130 BaseModel<?> baseModel = addBaseModelWithWorkflow(
3131 parentBaseModel, serviceContext);
3132
3133 return baseModel;
3134 }
3135 finally {
3136 WorkflowThreadLocal.setEnabled(workflowEnabled);
3137 }
3138 }
3139
3140 protected abstract BaseModel<?> addBaseModelWithWorkflow(
3141 BaseModel<?> parentBaseModel, ServiceContext serviceContext)
3142 throws Exception;
3143
3144 protected BaseModel<?> addBaseModelWithWorkflow(
3145 ServiceContext serviceContext)
3146 throws Exception {
3147
3148 BaseModel<?> parentBaseModel = getParentBaseModel(
3149 group, serviceContext);
3150
3151 return addBaseModelWithWorkflow(parentBaseModel, serviceContext);
3152 }
3153
3154 protected BaseModel<?> addDraftBaseModel(
3155 BaseModel<?> parentBaseModel, ServiceContext serviceContext)
3156 throws Exception {
3157
3158 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
3159
3160 try {
3161 WorkflowThreadLocal.setEnabled(true);
3162
3163 Assume.assumeTrue(this instanceof WhenHasDraftStatus);
3164
3165 WhenHasDraftStatus whenHasDraftStatus = (WhenHasDraftStatus)this;
3166
3167 BaseModel<?> baseModel =
3168 whenHasDraftStatus.addDraftBaseModelWithWorkflow(
3169 parentBaseModel, serviceContext);
3170
3171 return baseModel;
3172 }
3173 finally {
3174 WorkflowThreadLocal.setEnabled(workflowEnabled);
3175 }
3176 }
3177
3178 protected void deleteParentBaseModel(
3179 BaseModel<?> parentBaseModel, boolean includeTrashedEntries)
3180 throws Exception {
3181 }
3182
3183 protected Long getAssetClassPK(ClassedModel classedModel) {
3184 return (Long)classedModel.getPrimaryKeyObj();
3185 }
3186
3187 protected abstract BaseModel<?> getBaseModel(long primaryKey)
3188 throws Exception;
3189
3190 protected abstract Class<?> getBaseModelClass();
3191
3192 protected String getBaseModelClassName() {
3193 Class<?> clazz = getBaseModelClass();
3194
3195 return clazz.getName();
3196 }
3197
3198 protected long getDeletionSystemEventCount(
3199 TrashHandler trashHandler, final long systemEventSetKey)
3200 throws Exception {
3201
3202 final long systemEventClassNameId = PortalUtil.getClassNameId(
3203 trashHandler.getSystemEventClassName());
3204
3205 ActionableDynamicQuery actionableDynamicQuery =
3206 SystemEventLocalServiceUtil.getActionableDynamicQuery();
3207
3208 actionableDynamicQuery.setAddCriteriaMethod(
3209 new ActionableDynamicQuery.AddCriteriaMethod() {
3210
3211 @Override
3212 public void addCriteria(DynamicQuery dynamicQuery) {
3213 Property classNameIdProperty = PropertyFactoryUtil.forName(
3214 "classNameId");
3215
3216 dynamicQuery.add(
3217 classNameIdProperty.eq(systemEventClassNameId));
3218
3219 if (systemEventSetKey > 0) {
3220 Property systemEventSetKeyProperty =
3221 PropertyFactoryUtil.forName("systemEventSetKey");
3222
3223 dynamicQuery.add(
3224 systemEventSetKeyProperty.eq(systemEventSetKey));
3225 }
3226
3227 Property typeProperty = PropertyFactoryUtil.forName("type");
3228
3229 dynamicQuery.add(
3230 typeProperty.eq(SystemEventConstants.TYPE_DELETE));
3231 }
3232
3233 });
3234 actionableDynamicQuery.setGroupId(group.getGroupId());
3235
3236 return actionableDynamicQuery.performCount();
3237 }
3238
3239 protected abstract int getNotInTrashBaseModelsCount(
3240 BaseModel<?> parentBaseModel)
3241 throws Exception;
3242
3243 protected BaseModel<?> getParentBaseModel(
3244 Group group, long parentBaseModelId, ServiceContext serviceContext)
3245 throws Exception {
3246
3247 return group;
3248 }
3249
3250 protected BaseModel<?> getParentBaseModel(
3251 Group group, ServiceContext serviceContext)
3252 throws Exception {
3253
3254 return group;
3255 }
3256
3257 protected int getTrashEntriesCount(long groupId) throws Exception {
3258 return TrashEntryLocalServiceUtil.getEntriesCount(groupId);
3259 }
3260
3261 protected long getTrashEntryClassPK(ClassedModel classedModel) {
3262 return (Long)classedModel.getPrimaryKeyObj();
3263 }
3264
3265 protected abstract String getUniqueTitle(BaseModel<?> baseModel);
3266
3267 protected WorkflowedModel getWorkflowedModel(ClassedModel baseModel)
3268 throws Exception {
3269
3270 return (WorkflowedModel)baseModel;
3271 }
3272
3273 protected boolean isBaseModelContainerModel() {
3274 if (baseModel instanceof ContainerModel) {
3275 return true;
3276 }
3277
3278 return false;
3279 }
3280
3281 protected boolean isInTrashContainer(ClassedModel classedModel)
3282 throws Exception {
3283
3284 if (classedModel instanceof TrashedModel) {
3285 TrashedModel trashedModel = (TrashedModel)classedModel;
3286
3287 return trashedModel.isInTrashContainer();
3288 }
3289
3290 return false;
3291 }
3292
3293 protected abstract void moveBaseModelToTrash(long primaryKey)
3294 throws Exception;
3295
3296 protected BaseModel<?> baseModel;
3297
3298 @DeleteAfterTestRun
3299 protected Group group;
3300
3301 }