001
014
015 package com.liferay.portlet.trash.test;
016
017 import com.liferay.portal.NoSuchModelException;
018 import com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery;
019 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
020 import com.liferay.portal.kernel.dao.orm.Property;
021 import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
022 import com.liferay.portal.kernel.dao.orm.QueryUtil;
023 import com.liferay.portal.kernel.search.Hits;
024 import com.liferay.portal.kernel.search.Indexer;
025 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
026 import com.liferay.portal.kernel.search.SearchContext;
027 import com.liferay.portal.kernel.test.rule.DeleteAfterTestRun;
028 import com.liferay.portal.kernel.test.util.GroupTestUtil;
029 import com.liferay.portal.kernel.test.util.SearchContextTestUtil;
030 import com.liferay.portal.kernel.test.util.ServiceContextTestUtil;
031 import com.liferay.portal.kernel.test.util.TestPropsValues;
032 import com.liferay.portal.kernel.trash.TrashHandler;
033 import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
034 import com.liferay.portal.kernel.util.StringPool;
035 import com.liferay.portal.kernel.workflow.WorkflowConstants;
036 import com.liferay.portal.kernel.workflow.WorkflowThreadLocal;
037 import com.liferay.portal.model.BaseModel;
038 import com.liferay.portal.model.ClassedModel;
039 import com.liferay.portal.model.ContainerModel;
040 import com.liferay.portal.model.Group;
041 import com.liferay.portal.model.SystemEventConstants;
042 import com.liferay.portal.model.TrashedModel;
043 import com.liferay.portal.model.WorkflowedModel;
044 import com.liferay.portal.service.ServiceContext;
045 import com.liferay.portal.service.SystemEventLocalServiceUtil;
046 import com.liferay.portal.util.PortalUtil;
047 import com.liferay.portlet.asset.model.AssetEntry;
048 import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
049 import com.liferay.portlet.trash.model.TrashEntry;
050 import com.liferay.portlet.trash.service.TrashEntryLocalServiceUtil;
051 import com.liferay.portlet.trash.service.TrashEntryServiceUtil;
052 import com.liferay.portlet.trash.service.TrashVersionLocalServiceUtil;
053
054 import java.util.ArrayList;
055 import java.util.Collections;
056 import java.util.List;
057
058 import org.junit.Assert;
059 import org.junit.Assume;
060 import org.junit.Before;
061 import org.junit.Test;
062
063
069 public abstract class BaseTrashHandlerTestCase {
070
071 @Before
072 public void setUp() throws Exception {
073 group = GroupTestUtil.addGroup();
074 }
075
076 @Test
077 public void testAddBaseModelWithApprovedStatus() throws Exception {
078 ServiceContext serviceContext =
079 ServiceContextTestUtil.getServiceContext(group.getGroupId());
080
081 BaseModel<?> parentBaseModel = getParentBaseModel(
082 group, serviceContext);
083
084 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
085 parentBaseModel);
086 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
087
088 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
089
090 Assert.assertEquals(
091 initialBaseModelsCount + 1,
092 getNotInTrashBaseModelsCount(parentBaseModel));
093
094 Assert.assertEquals(
095 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
096 }
097
098 @Test
099 public void testAddBaseModelWithApprovedStatusAndIndexable()
100 throws Exception {
101
102 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
103
104 ServiceContext serviceContext =
105 ServiceContextTestUtil.getServiceContext(group.getGroupId());
106
107 BaseModel<?> parentBaseModel = getParentBaseModel(
108 group, serviceContext);
109
110 int initialBaseModelsSearchCount = searchBaseModelsCount(
111 getBaseModelClass(), group.getGroupId());
112 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
113 getSearchKeywords(), serviceContext);
114
115 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
116
117 Assert.assertEquals(
118 initialBaseModelsSearchCount + 1,
119 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
120
121 Assert.assertEquals(
122 initialTrashEntriesSearchCount,
123 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
124 }
125
126 @Test
127 public void testAddBaseModelWithApprovedStatusIsVisible() throws Exception {
128 ServiceContext serviceContext =
129 ServiceContextTestUtil.getServiceContext(group.getGroupId());
130
131 BaseModel<?> parentBaseModel = getParentBaseModel(
132 group, serviceContext);
133
134 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
135
136 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
137
138 if (isAssetableModel()) {
139 Assert.assertTrue(isAssetEntryVisible(baseModel));
140 }
141 }
142
143 @Test
144 public void testAddBaseModelWithDraftStatus() throws Exception {
145 ServiceContext serviceContext =
146 ServiceContextTestUtil.getServiceContext(group.getGroupId());
147
148 BaseModel<?> parentBaseModel = getParentBaseModel(
149 group, serviceContext);
150
151 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
152 parentBaseModel);
153 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
154
155 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
156
157 Assert.assertEquals(
158 initialBaseModelsCount + 1,
159 getNotInTrashBaseModelsCount(parentBaseModel));
160
161 Assert.assertEquals(
162 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
163 }
164
165 @Test
166 public void testAddBaseModelWithDraftStatusIndexable() throws Exception {
167 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
168
169 ServiceContext serviceContext =
170 ServiceContextTestUtil.getServiceContext(group.getGroupId());
171
172 BaseModel<?> parentBaseModel = getParentBaseModel(
173 group, serviceContext);
174
175 int initialBaseModelsSearchCount = searchBaseModelsCount(
176 getBaseModelClass(), group.getGroupId());
177 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
178 getSearchKeywords(), serviceContext);
179
180 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
181
182 Assert.assertEquals(
183 initialBaseModelsSearchCount,
184 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
185
186 Assert.assertEquals(
187 initialTrashEntriesSearchCount,
188 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
189 }
190
191 @Test
192 public void testAddBaseModelWithDraftStatusIsNotVisible() throws Exception {
193 ServiceContext serviceContext =
194 ServiceContextTestUtil.getServiceContext(group.getGroupId());
195
196 BaseModel<?> parentBaseModel = getParentBaseModel(
197 group, serviceContext);
198
199 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
200
201 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
202
203 if (isAssetableModel()) {
204 Assert.assertFalse(isAssetEntryVisible(baseModel));
205 }
206 }
207
208 @Test
209 public void testAddVersionBaseModel() throws Exception {
210 ServiceContext serviceContext =
211 ServiceContextTestUtil.getServiceContext(group.getGroupId());
212
213 BaseModel<?> parentBaseModel = getParentBaseModel(
214 group, serviceContext);
215
216 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
217 parentBaseModel);
218 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
219
220 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
221
222 baseModel = updateBaseModel(
223 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
224
225 Assert.assertEquals(
226 initialBaseModelsCount + 1,
227 getNotInTrashBaseModelsCount(parentBaseModel));
228 Assert.assertEquals(
229 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
230 }
231
232 @Test
233 public void testAddVersionBaseModelIndexable() throws Exception {
234 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
235
236 ServiceContext serviceContext =
237 ServiceContextTestUtil.getServiceContext(group.getGroupId());
238
239 BaseModel<?> parentBaseModel = getParentBaseModel(
240 group, serviceContext);
241
242 int initialBaseModelsSearchCount = searchBaseModelsCount(
243 getBaseModelClass(), group.getGroupId());
244 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
245 getSearchKeywords(), serviceContext);
246
247 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
248
249 baseModel = updateBaseModel(
250 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
251
252 Assert.assertEquals(
253 initialBaseModelsSearchCount + 1,
254 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
255 Assert.assertEquals(
256 initialTrashEntriesSearchCount,
257 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
258
259 if (isAssetableModel()) {
260 Assert.assertTrue(isAssetEntryVisible(baseModel));
261 }
262 }
263
264 @Test
265 public void testAddVersionBaseModelIsVisible() throws Exception {
266 ServiceContext serviceContext =
267 ServiceContextTestUtil.getServiceContext(group.getGroupId());
268
269 BaseModel<?> parentBaseModel = getParentBaseModel(
270 group, serviceContext);
271
272 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
273
274 baseModel = updateBaseModel(
275 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
276
277 if (isAssetableModel()) {
278 Assert.assertTrue(isAssetEntryVisible(baseModel));
279 }
280 }
281
282 @Test
283 public void testDeleteTrashVersions() throws Exception {
284 ServiceContext serviceContext =
285 ServiceContextTestUtil.getServiceContext(group.getGroupId());
286
287 BaseModel<?> parentBaseModel = getParentBaseModel(
288 group, serviceContext);
289
290 int initialTrashVersionsCount =
291 TrashVersionLocalServiceUtil.getTrashVersionsCount();
292
293 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
294
295 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
296
297 baseModel = updateBaseModel(
298 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
299
300 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
301
302 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
303 getBaseModelClassName());
304
305 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
306
307 Assert.assertEquals(
308 initialTrashVersionsCount,
309 TrashVersionLocalServiceUtil.getTrashVersionsCount());
310 }
311
312 @Test
313 public void testMoveBaseModelToTrash() throws Exception {
314 ServiceContext serviceContext =
315 ServiceContextTestUtil.getServiceContext(group.getGroupId());
316
317 BaseModel<?> parentBaseModel = getParentBaseModel(
318 group, serviceContext);
319
320 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
321 parentBaseModel);
322 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
323
324 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
325
326 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
327
328 Assert.assertEquals(
329 initialBaseModelsCount,
330 getNotInTrashBaseModelsCount(parentBaseModel));
331 Assert.assertEquals(
332 initialTrashEntriesCount + 1,
333 getTrashEntriesCount(group.getGroupId()));
334
335 TrashEntry trashEntry = TrashEntryLocalServiceUtil.getEntry(
336 getBaseModelClassName(), getTrashEntryClassPK(baseModel));
337
338 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
339 getBaseModelClassName());
340
341 Assert.assertEquals(
342 1,
343 getDeletionSystemEventCount(
344 trashHandler, trashEntry.getSystemEventSetKey()));
345 }
346
347 @Test
348 public void testMoveBaseModelToTrashIndexable() throws Exception {
349 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
350
351 ServiceContext serviceContext =
352 ServiceContextTestUtil.getServiceContext(group.getGroupId());
353
354 BaseModel<?> parentBaseModel = getParentBaseModel(
355 group, serviceContext);
356
357 int initialBaseModelsSearchCount = searchBaseModelsCount(
358 getBaseModelClass(), group.getGroupId());
359 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
360 getSearchKeywords(), serviceContext);
361
362 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
363
364 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
365
366 Assert.assertEquals(
367 initialBaseModelsSearchCount,
368 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
369 Assert.assertEquals(
370 initialTrashEntriesSearchCount + 1,
371 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
372 }
373
374 @Test
375 public void testMoveBaseModelToTrashIsNotVisible() throws Exception {
376 ServiceContext serviceContext =
377 ServiceContextTestUtil.getServiceContext(group.getGroupId());
378
379 BaseModel<?> parentBaseModel = getParentBaseModel(
380 group, serviceContext);
381
382 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
383
384 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
385
386 if (isAssetableModel()) {
387 Assert.assertFalse(isAssetEntryVisible(baseModel));
388 }
389 }
390
391 @Test
392 public void testMoveBaseModelToTrashStatusIsInTrash() throws Exception {
393 ServiceContext serviceContext =
394 ServiceContextTestUtil.getServiceContext(group.getGroupId());
395
396 BaseModel<?> parentBaseModel = getParentBaseModel(
397 group, serviceContext);
398
399 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
400
401 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
402
403 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
404
405 workflowedModel = getWorkflowedModel(
406 getBaseModel((Long)baseModel.getPrimaryKeyObj()));
407
408 Assert.assertEquals(
409 WorkflowConstants.STATUS_IN_TRASH, workflowedModel.getStatus());
410 }
411
412 @Test
413 public void testMoveBaseModelToTrashUniqueTitleNotChange()
414 throws Exception {
415
416 ServiceContext serviceContext =
417 ServiceContextTestUtil.getServiceContext(group.getGroupId());
418
419 BaseModel<?> parentBaseModel = getParentBaseModel(
420 group, serviceContext);
421
422 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
423
424 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
425
426 String uniqueTitle = getUniqueTitle(baseModel);
427
428 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
429
430 if (uniqueTitle != null) {
431 Assert.assertEquals(uniqueTitle, getUniqueTitle(baseModel));
432 }
433 }
434
435 @Test
436 public void testTrashAndDeleteWithApprovedStatus() throws Exception {
437 ServiceContext serviceContext =
438 ServiceContextTestUtil.getServiceContext(group.getGroupId());
439
440 BaseModel<?> parentBaseModel = getParentBaseModel(
441 group, serviceContext);
442
443 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
444 parentBaseModel);
445
446 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
447
448 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
449
450 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
451
452 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
453 getBaseModelClassName());
454
455 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
456
457 Assert.assertEquals(
458 initialBaseModelsCount,
459 getNotInTrashBaseModelsCount(parentBaseModel));
460
461 if (isAssetableModel()) {
462 Assert.assertNull(fetchAssetEntry(baseModel));
463 }
464
465 Assert.assertEquals(1, getDeletionSystemEventCount(trashHandler, -1));
466 }
467
468 @Test
469 public void testTrashAndDeleteWithApprovedStatusIndexable()
470 throws Exception {
471
472 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
473
474 ServiceContext serviceContext =
475 ServiceContextTestUtil.getServiceContext(group.getGroupId());
476
477 BaseModel<?> parentBaseModel = getParentBaseModel(
478 group, serviceContext);
479
480 int initialBaseModelsSearchCount = searchBaseModelsCount(
481 getBaseModelClass(), group.getGroupId());
482 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
483 getSearchKeywords(), serviceContext);
484
485 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
486
487 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
488
489 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
490
491 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
492 getBaseModelClassName());
493
494 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
495
496 Assert.assertEquals(
497 initialBaseModelsSearchCount,
498 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
499 Assert.assertEquals(
500 initialTrashEntriesSearchCount,
501 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
502 }
503
504 @Test
505 public void testTrashAndDeleteWithDraftStatus() throws Exception {
506 ServiceContext serviceContext =
507 ServiceContextTestUtil.getServiceContext(group.getGroupId());
508
509 BaseModel<?> parentBaseModel = getParentBaseModel(
510 group, serviceContext);
511
512 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
513 parentBaseModel);
514
515 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
516
517 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
518
519 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
520
521 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
522 getBaseModelClassName());
523
524 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
525
526 Assert.assertEquals(
527 initialBaseModelsCount,
528 getNotInTrashBaseModelsCount(parentBaseModel));
529
530 if (isAssetableModel()) {
531 Assert.assertNull(fetchAssetEntry(baseModel));
532 }
533
534 Assert.assertEquals(1, getDeletionSystemEventCount(trashHandler, -1));
535 }
536
537 @Test
538 public void testTrashAndDeleteWithDraftStatusIndexable() throws Exception {
539 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
540
541 ServiceContext serviceContext =
542 ServiceContextTestUtil.getServiceContext(group.getGroupId());
543
544 BaseModel<?> parentBaseModel = getParentBaseModel(
545 group, serviceContext);
546
547 int initialBaseModelsSearchCount = searchBaseModelsCount(
548 getBaseModelClass(), group.getGroupId());
549 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
550 getSearchKeywords(), serviceContext);
551
552 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
553
554 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
555
556 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
557
558 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
559 getBaseModelClassName());
560
561 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
562
563 Assert.assertEquals(
564 initialBaseModelsSearchCount,
565 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
566 Assert.assertEquals(
567 initialTrashEntriesSearchCount,
568 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
569 }
570
571 @Test
572 public void testTrashAndRestoreWithApprovedStatus() throws Exception {
573 ServiceContext serviceContext =
574 ServiceContextTestUtil.getServiceContext(group.getGroupId());
575
576 BaseModel<?> parentBaseModel = getParentBaseModel(
577 group, serviceContext);
578
579 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
580 parentBaseModel);
581
582 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
583
584 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
585
586 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
587
588 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
589 getBaseModelClassName());
590
591 trashHandler.restoreTrashEntry(
592 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
593
594 Assert.assertEquals(
595 initialBaseModelsCount + 1,
596 getNotInTrashBaseModelsCount(parentBaseModel));
597
598 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
599
600 Assert.assertEquals(0, getDeletionSystemEventCount(trashHandler, -1));
601 }
602
603 @Test
604 public void testTrashAndRestoreWithApprovedStatusIndexable()
605 throws Exception {
606
607 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
608
609 ServiceContext serviceContext =
610 ServiceContextTestUtil.getServiceContext(group.getGroupId());
611
612 BaseModel<?> parentBaseModel = getParentBaseModel(
613 group, serviceContext);
614
615 int initialBaseModelsSearchCount = searchBaseModelsCount(
616 getBaseModelClass(), group.getGroupId());
617 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
618 getSearchKeywords(), serviceContext);
619
620 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
621
622 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
623
624 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
625
626 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
627 getBaseModelClassName());
628
629 trashHandler.restoreTrashEntry(
630 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
631
632 Assert.assertEquals(
633 initialBaseModelsSearchCount + 1,
634 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
635
636 Assert.assertEquals(
637 initialTrashEntriesSearchCount,
638 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
639 }
640
641 @Test
642 public void testTrashAndRestoreWithApprovedStatusIsVisible()
643 throws Exception {
644
645 ServiceContext serviceContext =
646 ServiceContextTestUtil.getServiceContext(group.getGroupId());
647
648 BaseModel<?> parentBaseModel = getParentBaseModel(
649 group, serviceContext);
650
651 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
652
653 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
654
655 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
656
657 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
658 getBaseModelClassName());
659
660 trashHandler.restoreTrashEntry(
661 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
662
663 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
664
665 if (isAssetableModel()) {
666 Assert.assertTrue(isAssetEntryVisible(baseModel));
667 }
668 }
669
670 @Test
671 public void testTrashAndRestoreWithApprovedStatusRestoreStatus()
672 throws Exception {
673
674 ServiceContext serviceContext =
675 ServiceContextTestUtil.getServiceContext(group.getGroupId());
676
677 BaseModel<?> parentBaseModel = getParentBaseModel(
678 group, serviceContext);
679
680 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
681
682 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
683
684 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
685
686 int oldStatus = workflowedModel.getStatus();
687
688 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
689
690 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
691 getBaseModelClassName());
692
693 trashHandler.restoreTrashEntry(
694 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
695
696 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
697
698 workflowedModel = getWorkflowedModel(baseModel);
699
700 Assert.assertEquals(oldStatus, workflowedModel.getStatus());
701 }
702
703 @Test
704 public void testTrashAndRestoreWithApprovedStatusRestoreUniqueTitle()
705 throws Exception {
706
707 ServiceContext serviceContext =
708 ServiceContextTestUtil.getServiceContext(group.getGroupId());
709
710 BaseModel<?> parentBaseModel = getParentBaseModel(
711 group, serviceContext);
712
713 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
714
715 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
716
717 String uniqueTitle = getUniqueTitle(baseModel);
718
719 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
720
721 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
722 getBaseModelClassName());
723
724 trashHandler.restoreTrashEntry(
725 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
726
727 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
728
729 if (uniqueTitle != null) {
730 Assert.assertEquals(uniqueTitle, getUniqueTitle(baseModel));
731 }
732 }
733
734 @Test
735 public void testTrashAndRestoreWithDraftStatus() throws Exception {
736 ServiceContext serviceContext =
737 ServiceContextTestUtil.getServiceContext(group.getGroupId());
738
739 BaseModel<?> parentBaseModel = getParentBaseModel(
740 group, serviceContext);
741
742 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
743 parentBaseModel);
744
745 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
746
747 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
748
749 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
750 getBaseModelClassName());
751
752 trashHandler.restoreTrashEntry(
753 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
754
755 Assert.assertEquals(
756 initialBaseModelsCount + 1,
757 getNotInTrashBaseModelsCount(parentBaseModel));
758
759 Assert.assertEquals(0, getDeletionSystemEventCount(trashHandler, -1));
760 }
761
762 @Test
763 public void testTrashAndRestoreWithDraftStatusIndexable() throws Exception {
764 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
765
766 ServiceContext serviceContext =
767 ServiceContextTestUtil.getServiceContext(group.getGroupId());
768
769 BaseModel<?> parentBaseModel = getParentBaseModel(
770 group, serviceContext);
771
772 int initialBaseModelsSearchCount = searchBaseModelsCount(
773 getBaseModelClass(), group.getGroupId());
774 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
775 getSearchKeywords(), serviceContext);
776
777 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
778
779 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
780
781 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
782 getBaseModelClassName());
783
784 trashHandler.restoreTrashEntry(
785 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
786
787 Assert.assertEquals(
788 initialBaseModelsSearchCount,
789 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
790
791 Assert.assertEquals(
792 initialTrashEntriesSearchCount,
793 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
794 }
795
796 @Test
797 public void testTrashAndRestoreWithDraftStatusIsNotVisible()
798 throws Exception {
799
800 ServiceContext serviceContext =
801 ServiceContextTestUtil.getServiceContext(group.getGroupId());
802
803 BaseModel<?> parentBaseModel = getParentBaseModel(
804 group, serviceContext);
805
806 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
807
808 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
809
810 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
811 getBaseModelClassName());
812
813 trashHandler.restoreTrashEntry(
814 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
815
816 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
817
818 if (isAssetableModel()) {
819 Assert.assertFalse(isAssetEntryVisible(baseModel));
820 }
821 }
822
823 @Test
824 public void testTrashAndRestoreWithDraftStatusRestoreStatus()
825 throws Exception {
826
827 ServiceContext serviceContext =
828 ServiceContextTestUtil.getServiceContext(group.getGroupId());
829
830 BaseModel<?> parentBaseModel = getParentBaseModel(
831 group, serviceContext);
832
833 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
834
835 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
836
837 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
838
839 int oldStatus = workflowedModel.getStatus();
840
841 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
842
843 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
844 getBaseModelClassName());
845
846 trashHandler.restoreTrashEntry(
847 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
848
849 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
850
851 workflowedModel = getWorkflowedModel(baseModel);
852
853 Assert.assertEquals(oldStatus, workflowedModel.getStatus());
854 }
855
856 @Test
857 public void testTrashAndRestoreWithDraftStatusRestoreUniqueTitle()
858 throws Exception {
859
860 ServiceContext serviceContext =
861 ServiceContextTestUtil.getServiceContext(group.getGroupId());
862
863 BaseModel<?> parentBaseModel = getParentBaseModel(
864 group, serviceContext);
865
866 baseModel = addBaseModel(parentBaseModel, false, serviceContext);
867
868 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
869
870 String uniqueTitle = getUniqueTitle(baseModel);
871
872 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
873
874 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
875 getBaseModelClassName());
876
877 trashHandler.restoreTrashEntry(
878 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
879
880 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
881
882 if (uniqueTitle != null) {
883 Assert.assertEquals(uniqueTitle, getUniqueTitle(baseModel));
884 }
885 }
886
887 @Test
888 public void testTrashBaseModelAndDeleteWithParentIsNotRestorable()
889 throws Exception {
890
891 ServiceContext serviceContext =
892 ServiceContextTestUtil.getServiceContext(group.getGroupId());
893
894 BaseModel<?> parentBaseModel = getParentBaseModel(
895 group, serviceContext);
896
897 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
898
899 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
900
901 deleteParentBaseModel(parentBaseModel, false);
902
903 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
904 getBaseModelClassName());
905
906 boolean restorable = trashHandler.isRestorable(
907 getAssetClassPK(baseModel));
908
909 Assert.assertFalse(restorable);
910 }
911
912 @Test
913 public void testTrashBaseModelAndParent() throws Exception {
914 ServiceContext serviceContext =
915 ServiceContextTestUtil.getServiceContext(group.getGroupId());
916
917 BaseModel<?> parentBaseModel = getParentBaseModel(
918 group, serviceContext);
919
920 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
921
922 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
923
924 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
925
926 Assert.assertFalse(isInTrashContainer(baseModel));
927
928 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
929
930 Assert.assertTrue(isInTrashContainer(baseModel));
931
932 Assert.assertEquals(
933 initialTrashEntriesCount + 2,
934 getTrashEntriesCount(group.getGroupId()));
935
936 TrashHandler parentTrashHandler =
937 TrashHandlerRegistryUtil.getTrashHandler(
938 getParentBaseModelClassName());
939
940 if (getBaseModelClassName().equals(getParentBaseModelClassName())) {
941 Assert.assertEquals(
942 0,
943 parentTrashHandler.getTrashContainedModelsCount(
944 (Long)parentBaseModel.getPrimaryKeyObj()));
945 Assert.assertEquals(
946 1,
947 parentTrashHandler.getTrashContainerModelsCount(
948 (Long)parentBaseModel.getPrimaryKeyObj()));
949 }
950 else {
951 Assert.assertEquals(
952 1,
953 parentTrashHandler.getTrashContainedModelsCount(
954 (Long)parentBaseModel.getPrimaryKeyObj()));
955 Assert.assertEquals(
956 0,
957 parentTrashHandler.getTrashContainerModelsCount(
958 (Long)parentBaseModel.getPrimaryKeyObj()));
959 }
960 }
961
962 @Test
963 public void testTrashBaseModelAndParentAndDeleteGroupTrashEntries()
964 throws Exception {
965
966 ServiceContext serviceContext =
967 ServiceContextTestUtil.getServiceContext(group.getGroupId());
968
969 BaseModel<?> parentBaseModel = getParentBaseModel(
970 group, serviceContext);
971
972 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
973
974 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
975
976 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
977
978 TrashEntryServiceUtil.deleteEntries(group.getGroupId());
979
980 Assert.assertEquals(0, getTrashEntriesCount(group.getGroupId()));
981
982 try {
983 getBaseModel((Long)baseModel.getPrimaryKeyObj());
984
985 Assert.fail();
986 }
987 catch (NoSuchModelException nsme) {
988 }
989 }
990
991 @Test
992 public void testTrashBaseModelAndParentAndDeleteParent() throws Exception {
993 ServiceContext serviceContext =
994 ServiceContextTestUtil.getServiceContext(group.getGroupId());
995
996 BaseModel<?> parentBaseModel = getParentBaseModel(
997 group, serviceContext);
998
999 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1000 parentBaseModel);
1001 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1002
1003 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1004
1005 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1006
1007 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1008
1009 TrashHandler parentTrashHandler =
1010 TrashHandlerRegistryUtil.getTrashHandler(
1011 getParentBaseModelClassName());
1012
1013 parentTrashHandler.deleteTrashEntry(
1014 (Long)parentBaseModel.getPrimaryKeyObj());
1015
1016 Assert.assertEquals(
1017 initialBaseModelsCount,
1018 getNotInTrashBaseModelsCount(parentBaseModel));
1019
1020 if (isBaseModelMoveableFromTrash()) {
1021 Assert.assertEquals(
1022 initialTrashEntriesCount + 1,
1023 getTrashEntriesCount(group.getGroupId()));
1024
1025 TrashHandler trashHandler =
1026 TrashHandlerRegistryUtil.getTrashHandler(
1027 getBaseModelClassName());
1028
1029 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
1030 }
1031 else {
1032 try {
1033 getBaseModel((Long)baseModel.getPrimaryKeyObj());
1034
1035 Assert.fail();
1036 }
1037 catch (NoSuchModelException nsme) {
1038 }
1039 }
1040
1041 Assert.assertEquals(
1042 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1043 }
1044
1045 @Test
1046 public void testTrashBaseModelAndParentAndRestoreModel() throws Exception {
1047 ServiceContext serviceContext =
1048 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1049
1050 BaseModel<?> parentBaseModel = getParentBaseModel(
1051 group, serviceContext);
1052
1053 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1054 parentBaseModel);
1055 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1056
1057 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1058
1059 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1060
1061 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1062
1063 if (isBaseModelMoveableFromTrash()) {
1064 BaseModel<?> newParentBaseModel = moveBaseModelFromTrash(
1065 baseModel, group, serviceContext);
1066
1067 Assert.assertEquals(
1068 initialBaseModelsCount + 1,
1069 getNotInTrashBaseModelsCount(newParentBaseModel));
1070 Assert.assertEquals(
1071 initialTrashEntriesCount + 1,
1072 getTrashEntriesCount(group.getGroupId()));
1073 }
1074 }
1075
1076 @Test
1077 public void testTrashBaseModelAndParentAndRestoreModelIsVisible()
1078 throws Exception {
1079
1080 ServiceContext serviceContext =
1081 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1082
1083 BaseModel<?> parentBaseModel = getParentBaseModel(
1084 group, serviceContext);
1085
1086 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1087
1088 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1089
1090 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1091
1092 if (isBaseModelMoveableFromTrash()) {
1093 moveBaseModelFromTrash(baseModel, group, serviceContext);
1094
1095 if (isAssetableModel()) {
1096 Assert.assertTrue(isAssetEntryVisible(baseModel));
1097 }
1098 }
1099 }
1100
1101 @Test
1102 public void testTrashBaseModelAndParentIsNotVisible() throws Exception {
1103 ServiceContext serviceContext =
1104 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1105
1106 BaseModel<?> parentBaseModel = getParentBaseModel(
1107 group, serviceContext);
1108
1109 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1110
1111 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1112
1113 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1114
1115 if (isAssetableModel()) {
1116 Assert.assertFalse(isAssetEntryVisible(baseModel));
1117 }
1118 }
1119
1120 @Test
1121 public void testTrashBaseModelAndTrashParentAndDeleteParentIsNotRestorable()
1122 throws Exception {
1123
1124 ServiceContext serviceContext =
1125 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1126
1127 BaseModel<?> parentBaseModel = getParentBaseModel(
1128 group, serviceContext);
1129
1130 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1131
1132 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1133
1134 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1135
1136 TrashHandler parentTrashHandler =
1137 TrashHandlerRegistryUtil.getTrashHandler(
1138 getParentBaseModelClassName());
1139
1140 parentTrashHandler.deleteTrashEntry(
1141 (Long)parentBaseModel.getPrimaryKeyObj());
1142
1143 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1144 getBaseModelClassName());
1145
1146 boolean restorable = trashHandler.isRestorable(
1147 getAssetClassPK(baseModel));
1148
1149 Assert.assertFalse(restorable);
1150 }
1151
1152 @Test
1153 public void testTrashBaseModelAndTrashParentIsNotRestorable()
1154 throws Exception {
1155
1156 ServiceContext serviceContext =
1157 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1158
1159 BaseModel<?> parentBaseModel = getParentBaseModel(
1160 group, serviceContext);
1161
1162 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1163
1164 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1165
1166 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1167
1168 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1169 getBaseModelClassName());
1170
1171 boolean restorable = trashHandler.isRestorable(
1172 getAssetClassPK(baseModel));
1173
1174 Assert.assertFalse(restorable);
1175 }
1176
1177 @Test
1178 public void testTrashBaseModelWithParentIsRestorable() throws Exception {
1179 ServiceContext serviceContext =
1180 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1181
1182 BaseModel<?> parentBaseModel = getParentBaseModel(
1183 group, serviceContext);
1184
1185 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1186
1187 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1188
1189 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1190 getBaseModelClassName());
1191
1192 boolean restorable = trashHandler.isRestorable(
1193 getAssetClassPK(baseModel));
1194
1195 Assert.assertTrue(restorable);
1196 }
1197
1198 @Test
1199 public void testTrashDuplicate() throws Exception {
1200 ServiceContext serviceContext =
1201 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1202
1203 BaseModel<?> parentBaseModel = getParentBaseModel(
1204 group, serviceContext);
1205
1206 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1207 parentBaseModel);
1208 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1209
1210 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1211
1212 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1213
1214 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
1215
1216 Assert.assertTrue(isBaseModelTrashName(baseModel));
1217
1218 BaseModel<?> duplicateBaseModel = addBaseModel(
1219 parentBaseModel, true, serviceContext);
1220
1221 moveBaseModelToTrash((Long)duplicateBaseModel.getPrimaryKeyObj());
1222
1223 duplicateBaseModel = getBaseModel(
1224 (Long)duplicateBaseModel.getPrimaryKeyObj());
1225
1226 Assert.assertEquals(
1227 initialBaseModelsCount,
1228 getNotInTrashBaseModelsCount(parentBaseModel));
1229 Assert.assertEquals(
1230 initialTrashEntriesCount + 2,
1231 getTrashEntriesCount(group.getGroupId()));
1232
1233 Assert.assertTrue(isBaseModelTrashName(duplicateBaseModel));
1234 }
1235
1236 @Test
1237 public void testTrashGrandparentBaseModel() throws Exception {
1238 ServiceContext serviceContext =
1239 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1240
1241 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1242 group, serviceContext);
1243
1244 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1245 grandparentBaseModel);
1246 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1247
1248 BaseModel<?> parentBaseModel = getParentBaseModel(
1249 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1250 serviceContext);
1251
1252 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1253
1254 if (getBaseModelClassName().equals(getParentBaseModelClassName())) {
1255 Assert.assertEquals(
1256 initialBaseModelsCount + 1,
1257 getNotInTrashBaseModelsCount(grandparentBaseModel));
1258 }
1259 else {
1260 Assert.assertEquals(
1261 initialBaseModelsCount,
1262 getNotInTrashBaseModelsCount(grandparentBaseModel));
1263 }
1264
1265 moveParentBaseModelToTrash(
1266 (Long)grandparentBaseModel.getPrimaryKeyObj());
1267
1268 Assert.assertTrue(isInTrashContainer(baseModel));
1269 Assert.assertTrue(isInTrashContainer(parentBaseModel));
1270 Assert.assertEquals(
1271 initialBaseModelsCount,
1272 getNotInTrashBaseModelsCount(grandparentBaseModel));
1273 Assert.assertEquals(
1274 initialTrashEntriesCount + 1,
1275 getTrashEntriesCount(group.getGroupId()));
1276
1277 if (isAssetableModel()) {
1278 Assert.assertFalse(isAssetEntryVisible(baseModel));
1279 }
1280
1281 if (isAssetableParentModel()) {
1282 Assert.assertFalse(isAssetEntryVisible(parentBaseModel));
1283 }
1284 }
1285
1286 @Test
1287 public void testTrashGrandparentBaseModelAndRestoreParentModel()
1288 throws Exception {
1289
1290 ServiceContext serviceContext =
1291 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1292
1293 BaseModel<?> grandparentBaseModel = getParentBaseModel(
1294 group, serviceContext);
1295
1296 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1297
1298 BaseModel<?> parentBaseModel = getParentBaseModel(
1299 group, (Long)grandparentBaseModel.getPrimaryKeyObj(),
1300 serviceContext);
1301
1302 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1303
1304 moveParentBaseModelToTrash(
1305 (Long)grandparentBaseModel.getPrimaryKeyObj());
1306
1307 TrashHandler parentTrashHandler =
1308 TrashHandlerRegistryUtil.getTrashHandler(
1309 getParentBaseModelClassName());
1310
1311 parentTrashHandler.restoreTrashEntry(
1312 TestPropsValues.getUserId(),
1313 (Long)grandparentBaseModel.getPrimaryKeyObj());
1314
1315 Assert.assertEquals(
1316 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1317
1318 Assert.assertFalse(isInTrashContainer(baseModel));
1319 Assert.assertFalse(isInTrashContainer(parentBaseModel));
1320
1321 if (isAssetableModel()) {
1322 Assert.assertTrue(isAssetEntryVisible(baseModel));
1323 }
1324
1325 if (isAssetableParentModel()) {
1326 Assert.assertTrue(isAssetEntryVisible(parentBaseModel));
1327 }
1328 }
1329
1330 @Test
1331 public void testTrashIsRestorableBaseModel() throws Exception {
1332 ServiceContext serviceContext =
1333 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1334
1335 baseModel = addBaseModelWithWorkflow(true, serviceContext);
1336
1337 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1338
1339 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1340 getBaseModelClassName());
1341
1342 boolean restorable = trashHandler.isRestorable(
1343 getAssetClassPK(baseModel));
1344
1345 Assert.assertTrue(restorable);
1346 }
1347
1348 @Test
1349 public void testTrashMoveBaseModel() throws Exception {
1350 ServiceContext serviceContext =
1351 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1352
1353 BaseModel<?> parentBaseModel = getParentBaseModel(
1354 group, serviceContext);
1355
1356 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1357
1358 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1359
1360 Assert.assertTrue(isInTrashContainer(baseModel));
1361
1362 if (isAssetableModel()) {
1363 Assert.assertFalse(isAssetEntryVisible(baseModel));
1364 }
1365
1366 if (!isBaseModelMoveableFromTrash()) {
1367 return;
1368 }
1369
1370 moveBaseModelFromTrash(baseModel, group, serviceContext);
1371
1372 if (isAssetableModel()) {
1373 Assert.assertTrue(isAssetEntryVisible(baseModel));
1374 }
1375 }
1376
1377 @Test
1378 public void testTrashMoveBaseModelIndexable() throws Exception {
1379 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
1380
1381 ServiceContext serviceContext =
1382 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1383
1384 int initialBaseModelsSearchCount = searchBaseModelsCount(
1385 getBaseModelClass(), group.getGroupId());
1386
1387 BaseModel<?> parentBaseModel = getParentBaseModel(
1388 group, serviceContext);
1389
1390 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1391
1392 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1393
1394 Assert.assertEquals(
1395 initialBaseModelsSearchCount,
1396 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
1397
1398 if (!isBaseModelMoveableFromTrash()) {
1399 return;
1400 }
1401
1402 moveBaseModelFromTrash(baseModel, group, serviceContext);
1403
1404 if (isBaseModelContainerModel()) {
1405 Assert.assertEquals(
1406 initialBaseModelsSearchCount + 2,
1407 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
1408 }
1409 else {
1410 Assert.assertEquals(
1411 initialBaseModelsSearchCount + 1,
1412 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
1413 }
1414 }
1415
1416 @Test
1417 public void testTrashMyBaseModel() throws Exception {
1418 ServiceContext serviceContext =
1419 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1420
1421 BaseModel<?> parentBaseModel = getParentBaseModel(
1422 group, serviceContext);
1423
1424 int initialBaseModelsCount = getMineBaseModelsCount(
1425 group.getGroupId(), TestPropsValues.getUserId());
1426
1427 addBaseModel(parentBaseModel, true, serviceContext);
1428
1429 Assert.assertEquals(
1430 initialBaseModelsCount + 1,
1431 getMineBaseModelsCount(
1432 group.getGroupId(), TestPropsValues.getUserId()));
1433
1434 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1435
1436 Assert.assertEquals(
1437 initialBaseModelsCount,
1438 getMineBaseModelsCount(
1439 group.getGroupId(), TestPropsValues.getUserId()));
1440 }
1441
1442 @Test
1443 public void testTrashParent() throws Exception {
1444 ServiceContext serviceContext =
1445 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1446
1447 BaseModel<?> parentBaseModel = getParentBaseModel(
1448 group, serviceContext);
1449
1450 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1451 parentBaseModel);
1452 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1453
1454 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1455
1456 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1457
1458 Assert.assertTrue(isInTrashContainer(baseModel));
1459
1460 Assert.assertEquals(
1461 initialBaseModelsCount,
1462 getNotInTrashBaseModelsCount(parentBaseModel));
1463 Assert.assertEquals(
1464 initialTrashEntriesCount + 1,
1465 getTrashEntriesCount(group.getGroupId()));
1466
1467 TrashHandler parentTrashHandler =
1468 TrashHandlerRegistryUtil.getTrashHandler(
1469 getParentBaseModelClassName());
1470
1471 if (getBaseModelClassName().equals(getParentBaseModelClassName())) {
1472 Assert.assertEquals(
1473 0,
1474 parentTrashHandler.getTrashContainedModelsCount(
1475 (Long)parentBaseModel.getPrimaryKeyObj()));
1476 Assert.assertEquals(
1477 1,
1478 parentTrashHandler.getTrashContainerModelsCount(
1479 (Long)parentBaseModel.getPrimaryKeyObj()));
1480 }
1481 else {
1482 Assert.assertEquals(
1483 1,
1484 parentTrashHandler.getTrashContainedModelsCount(
1485 (Long)parentBaseModel.getPrimaryKeyObj()));
1486 Assert.assertEquals(
1487 0,
1488 parentTrashHandler.getTrashContainerModelsCount(
1489 (Long)parentBaseModel.getPrimaryKeyObj()));
1490 }
1491
1492 if (isAssetableModel()) {
1493 Assert.assertFalse(isAssetEntryVisible(baseModel));
1494 }
1495 }
1496
1497 @Test
1498 public void testTrashParentAndDeleteGroupTrashEntries() throws Exception {
1499 ServiceContext serviceContext =
1500 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1501
1502 BaseModel<?> parentBaseModel = getParentBaseModel(
1503 group, serviceContext);
1504
1505 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1506
1507 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1508
1509 TrashEntryServiceUtil.deleteEntries(group.getGroupId());
1510
1511 Assert.assertEquals(0, getTrashEntriesCount(group.getGroupId()));
1512
1513 try {
1514 getBaseModel((Long)baseModel.getPrimaryKeyObj());
1515
1516 Assert.fail();
1517 }
1518 catch (NoSuchModelException nsme) {
1519 }
1520 }
1521
1522 @Test
1523 public void testTrashParentAndDeleteParent() throws Exception {
1524 ServiceContext serviceContext =
1525 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1526
1527 BaseModel<?> parentBaseModel = getParentBaseModel(
1528 group, serviceContext);
1529
1530 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1531 parentBaseModel);
1532 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1533
1534 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1535
1536 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1537
1538 TrashHandler parentTrashHandler =
1539 TrashHandlerRegistryUtil.getTrashHandler(
1540 getParentBaseModelClassName());
1541
1542 parentTrashHandler.deleteTrashEntry(
1543 (Long)parentBaseModel.getPrimaryKeyObj());
1544
1545 Assert.assertEquals(
1546 initialBaseModelsCount,
1547 getNotInTrashBaseModelsCount(parentBaseModel));
1548
1549 try {
1550 getBaseModel((Long)baseModel.getPrimaryKeyObj());
1551
1552 Assert.fail();
1553 }
1554 catch (NoSuchModelException nsme) {
1555 }
1556
1557 Assert.assertEquals(
1558 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1559 }
1560
1561 @Test
1562 public void testTrashRecentBaseModel() throws Exception {
1563 ServiceContext serviceContext =
1564 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1565
1566 BaseModel<?> parentBaseModel = getParentBaseModel(
1567 group, serviceContext);
1568
1569 int initialBaseModelsCount = getRecentBaseModelsCount(
1570 group.getGroupId());
1571
1572 addBaseModel(parentBaseModel, true, serviceContext);
1573
1574 Assert.assertEquals(
1575 initialBaseModelsCount + 1,
1576 getRecentBaseModelsCount(group.getGroupId()));
1577
1578 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1579
1580 Assert.assertEquals(
1581 initialBaseModelsCount,
1582 getRecentBaseModelsCount(group.getGroupId()));
1583 }
1584
1585 @Test
1586 public void testTrashVersionBaseModel() throws Exception {
1587 ServiceContext serviceContext =
1588 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1589
1590 BaseModel<?> parentBaseModel = getParentBaseModel(
1591 group, serviceContext);
1592
1593 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1594 parentBaseModel);
1595 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1596
1597 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1598
1599 baseModel = updateBaseModel(
1600 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1601
1602 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1603
1604 Assert.assertEquals(
1605 initialBaseModelsCount,
1606 getNotInTrashBaseModelsCount(parentBaseModel));
1607 Assert.assertEquals(
1608 initialTrashEntriesCount + 1,
1609 getTrashEntriesCount(group.getGroupId()));
1610 }
1611
1612 @Test
1613 public void testTrashVersionBaseModelAndDelete() throws Exception {
1614 ServiceContext serviceContext =
1615 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1616
1617 BaseModel<?> parentBaseModel = getParentBaseModel(
1618 group, serviceContext);
1619
1620 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1621 parentBaseModel);
1622 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1623
1624 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1625
1626 baseModel = updateBaseModel(
1627 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1628
1629 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1630
1631 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1632 getBaseModelClassName());
1633
1634 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
1635
1636 Assert.assertEquals(
1637 initialBaseModelsCount,
1638 getNotInTrashBaseModelsCount(parentBaseModel));
1639 Assert.assertEquals(
1640 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1641
1642 if (isAssetableModel()) {
1643 Assert.assertNull(fetchAssetEntry(baseModel));
1644 }
1645 }
1646
1647 @Test
1648 public void testTrashVersionBaseModelAndDeleteIndexable() throws Exception {
1649 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
1650
1651 ServiceContext serviceContext =
1652 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1653
1654 BaseModel<?> parentBaseModel = getParentBaseModel(
1655 group, serviceContext);
1656
1657 int initialBaseModelsSearchCount = searchBaseModelsCount(
1658 getBaseModelClass(), group.getGroupId());
1659 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
1660 getSearchKeywords(), serviceContext);
1661
1662 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1663
1664 baseModel = updateBaseModel(
1665 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1666
1667 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1668
1669 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1670 getBaseModelClassName());
1671
1672 trashHandler.deleteTrashEntry(getTrashEntryClassPK(baseModel));
1673
1674 Assert.assertEquals(
1675 initialBaseModelsSearchCount,
1676 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
1677 Assert.assertEquals(
1678 initialTrashEntriesSearchCount,
1679 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
1680 }
1681
1682 @Test
1683 public void testTrashVersionBaseModelAndRestore() throws Exception {
1684 ServiceContext serviceContext =
1685 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1686
1687 BaseModel<?> parentBaseModel = getParentBaseModel(
1688 group, serviceContext);
1689
1690 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1691 parentBaseModel);
1692 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1693
1694 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1695
1696 baseModel = updateBaseModel(
1697 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1698
1699 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1700
1701 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1702 getBaseModelClassName());
1703
1704 trashHandler.restoreTrashEntry(
1705 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
1706
1707 Assert.assertEquals(
1708 initialBaseModelsCount + 1,
1709 getNotInTrashBaseModelsCount(parentBaseModel));
1710 Assert.assertEquals(
1711 initialTrashEntriesCount, getTrashEntriesCount(group.getGroupId()));
1712 }
1713
1714 @Test
1715 public void testTrashVersionBaseModelAndRestoreIndexable()
1716 throws Exception {
1717
1718 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
1719
1720 ServiceContext serviceContext =
1721 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1722
1723 BaseModel<?> parentBaseModel = getParentBaseModel(
1724 group, serviceContext);
1725
1726 int initialBaseModelsSearchCount = searchBaseModelsCount(
1727 getBaseModelClass(), group.getGroupId());
1728 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
1729 getSearchKeywords(), serviceContext);
1730
1731 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1732
1733 baseModel = updateBaseModel(
1734 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1735
1736 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1737
1738 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1739 getBaseModelClassName());
1740
1741 trashHandler.restoreTrashEntry(
1742 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
1743
1744 Assert.assertEquals(
1745 initialBaseModelsSearchCount + 1,
1746 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
1747 Assert.assertEquals(
1748 initialTrashEntriesSearchCount,
1749 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
1750 }
1751
1752 @Test
1753 public void testTrashVersionBaseModelAndRestoreIsVisible()
1754 throws Exception {
1755
1756 ServiceContext serviceContext =
1757 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1758
1759 BaseModel<?> parentBaseModel = getParentBaseModel(
1760 group, serviceContext);
1761
1762 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1763
1764 baseModel = updateBaseModel(
1765 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1766
1767 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1768
1769 TrashHandler trashHandler = TrashHandlerRegistryUtil.getTrashHandler(
1770 getBaseModelClassName());
1771
1772 trashHandler.restoreTrashEntry(
1773 TestPropsValues.getUserId(), getTrashEntryClassPK(baseModel));
1774
1775 if (isAssetableModel()) {
1776 Assert.assertTrue(isAssetEntryVisible(baseModel));
1777 }
1778 }
1779
1780 @Test
1781 public void testTrashVersionBaseModelIndexable() throws Exception {
1782 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
1783
1784 ServiceContext serviceContext =
1785 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1786
1787 BaseModel<?> parentBaseModel = getParentBaseModel(
1788 group, serviceContext);
1789
1790 int initialBaseModelsSearchCount = searchBaseModelsCount(
1791 getBaseModelClass(), group.getGroupId());
1792 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
1793 getSearchKeywords(), serviceContext);
1794
1795 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1796
1797 baseModel = updateBaseModel(
1798 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1799
1800 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1801
1802 Assert.assertEquals(
1803 initialBaseModelsSearchCount,
1804 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
1805 Assert.assertEquals(
1806 initialTrashEntriesSearchCount + 1,
1807 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
1808 }
1809
1810 @Test
1811 public void testTrashVersionBaseModelIsNotVisible() throws Exception {
1812 ServiceContext serviceContext =
1813 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1814
1815 BaseModel<?> parentBaseModel = getParentBaseModel(
1816 group, serviceContext);
1817
1818 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1819
1820 baseModel = updateBaseModel(
1821 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1822
1823 moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
1824
1825 if (isAssetableModel()) {
1826 Assert.assertFalse(isAssetEntryVisible(baseModel));
1827 }
1828 }
1829
1830 @Test
1831 public void testTrashVersionParentBaseModel() throws Exception {
1832 ServiceContext serviceContext =
1833 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1834
1835 BaseModel<?> parentBaseModel = getParentBaseModel(
1836 group, serviceContext);
1837
1838 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1839
1840 List<Integer> originalStatuses = new ArrayList<>();
1841
1842 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1843
1844 baseModel = expireBaseModel(baseModel, serviceContext);
1845
1846 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
1847
1848 originalStatuses.add(workflowedModel.getStatus());
1849
1850 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
1851
1852 baseModel = updateBaseModel(
1853 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1854
1855 workflowedModel = getWorkflowedModel(baseModel);
1856
1857 originalStatuses.add(workflowedModel.getStatus());
1858
1859 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
1860
1861 baseModel = updateBaseModel(
1862 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1863
1864 workflowedModel = getWorkflowedModel(baseModel);
1865
1866 originalStatuses.add(workflowedModel.getStatus());
1867
1868 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1869
1870 Assert.assertEquals(
1871 initialTrashEntriesCount + 1,
1872 getTrashEntriesCount(group.getGroupId()));
1873 Assert.assertTrue(isInTrashContainer(baseModel));
1874 }
1875
1876 @Test
1877 public void testTrashVersionParentBaseModelAndRestore() throws Exception {
1878 ServiceContext serviceContext =
1879 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1880
1881 BaseModel<?> parentBaseModel = getParentBaseModel(
1882 group, serviceContext);
1883
1884 int initialBaseModelsCount = getNotInTrashBaseModelsCount(
1885 parentBaseModel);
1886 int initialTrashEntriesCount = getTrashEntriesCount(group.getGroupId());
1887
1888 List<Integer> originalStatuses = new ArrayList<>();
1889
1890 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1891
1892 baseModel = expireBaseModel(baseModel, serviceContext);
1893
1894 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
1895
1896 originalStatuses.add(workflowedModel.getStatus());
1897
1898 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
1899
1900 baseModel = updateBaseModel(
1901 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1902
1903 workflowedModel = getWorkflowedModel(baseModel);
1904
1905 originalStatuses.add(workflowedModel.getStatus());
1906
1907 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
1908
1909 baseModel = updateBaseModel(
1910 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1911
1912 workflowedModel = getWorkflowedModel(baseModel);
1913
1914 originalStatuses.add(workflowedModel.getStatus());
1915
1916 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
1917
1918 if (isBaseModelMoveableFromTrash()) {
1919 BaseModel<?> newParentBaseModel = moveBaseModelFromTrash(
1920 baseModel, group, serviceContext);
1921
1922 baseModel = getBaseModel((Long)baseModel.getPrimaryKeyObj());
1923
1924 Assert.assertEquals(
1925 initialBaseModelsCount + 1,
1926 getNotInTrashBaseModelsCount(newParentBaseModel));
1927 Assert.assertEquals(
1928 initialTrashEntriesCount + 1,
1929 getTrashEntriesCount(group.getGroupId()));
1930 Assert.assertFalse(isInTrashContainer(baseModel));
1931
1932 if (isAssetableModel()) {
1933 Assert.assertTrue(isAssetEntryVisible(baseModel));
1934 }
1935 }
1936 else {
1937 restoreParentBaseModelFromTrash(
1938 (Long)parentBaseModel.getPrimaryKeyObj());
1939
1940 List<? extends WorkflowedModel> childrenWorkflowedModels =
1941 getChildrenWorkflowedModels(parentBaseModel);
1942
1943 for (int i = 1; i <= childrenWorkflowedModels.size(); i++) {
1944 WorkflowedModel childrenWorkflowedModel =
1945 childrenWorkflowedModels.get(i - 1);
1946
1947 int originalStatus = originalStatuses.get(
1948 childrenWorkflowedModels.size() - i);
1949
1950 Assert.assertEquals(
1951 originalStatus, childrenWorkflowedModel.getStatus());
1952 }
1953 }
1954 }
1955
1956 @Test
1957 public void testTrashVersionParentBaseModelIndexable() throws Exception {
1958 Assume.assumeTrue(this instanceof WhenIsIndexableBaseModel);
1959
1960 ServiceContext serviceContext =
1961 ServiceContextTestUtil.getServiceContext(group.getGroupId());
1962
1963 BaseModel<?> parentBaseModel = getParentBaseModel(
1964 group, serviceContext);
1965
1966 int initialBaseModelsSearchCount = searchBaseModelsCount(
1967 getBaseModelClass(), group.getGroupId());
1968 int initialTrashEntriesSearchCount = searchTrashEntriesCount(
1969 getSearchKeywords(), serviceContext);
1970
1971 List<Integer> originalStatuses = new ArrayList<>();
1972
1973 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
1974
1975 baseModel = expireBaseModel(baseModel, serviceContext);
1976
1977 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
1978
1979 originalStatuses.add(workflowedModel.getStatus());
1980
1981 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
1982
1983 baseModel = updateBaseModel(
1984 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1985
1986 workflowedModel = getWorkflowedModel(baseModel);
1987
1988 originalStatuses.add(workflowedModel.getStatus());
1989
1990 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
1991
1992 baseModel = updateBaseModel(
1993 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
1994
1995 workflowedModel = getWorkflowedModel(baseModel);
1996
1997 originalStatuses.add(workflowedModel.getStatus());
1998
1999 Assert.assertEquals(
2000 initialBaseModelsSearchCount + 1,
2001 searchBaseModelsCount(getBaseModelClass(), group.getGroupId()));
2002 Assert.assertEquals(
2003 initialTrashEntriesSearchCount,
2004 searchTrashEntriesCount(getSearchKeywords(), serviceContext));
2005 }
2006
2007 @Test
2008 public void testTrashVersionParentBaseModelIsNotVisible() throws Exception {
2009 ServiceContext serviceContext =
2010 ServiceContextTestUtil.getServiceContext(group.getGroupId());
2011
2012 BaseModel<?> parentBaseModel = getParentBaseModel(
2013 group, serviceContext);
2014
2015 List<Integer> originalStatuses = new ArrayList<>();
2016
2017 baseModel = addBaseModel(parentBaseModel, true, serviceContext);
2018
2019 baseModel = expireBaseModel(baseModel, serviceContext);
2020
2021 WorkflowedModel workflowedModel = getWorkflowedModel(baseModel);
2022
2023 originalStatuses.add(workflowedModel.getStatus());
2024
2025 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
2026
2027 baseModel = updateBaseModel(
2028 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2029
2030 workflowedModel = getWorkflowedModel(baseModel);
2031
2032 originalStatuses.add(workflowedModel.getStatus());
2033
2034 serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
2035
2036 baseModel = updateBaseModel(
2037 (Long)baseModel.getPrimaryKeyObj(), serviceContext);
2038
2039 workflowedModel = getWorkflowedModel(baseModel);
2040
2041 originalStatuses.add(workflowedModel.getStatus());
2042
2043 moveParentBaseModelToTrash((Long)parentBaseModel.getPrimaryKeyObj());
2044
2045 if (isAssetableModel()) {
2046 Assert.assertFalse(isAssetEntryVisible(baseModel));
2047 }
2048 }
2049
2050 protected BaseModel<?> addBaseModel(
2051 BaseModel<?> parentBaseModel, boolean approved,
2052 ServiceContext serviceContext)
2053 throws Exception {
2054
2055 boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
2056
2057 try {
2058 WorkflowThreadLocal.setEnabled(true);
2059
2060 BaseModel<?> baseModel = addBaseModelWithWorkflow(
2061 parentBaseModel, approved, serviceContext);
2062
2063 return baseModel;
2064 }
2065 finally {
2066 WorkflowThreadLocal.setEnabled(workflowEnabled);
2067 }
2068 }
2069
2070 protected abstract BaseModel<?> addBaseModelWithWorkflow(
2071 BaseModel<?> parentBaseModel, boolean approved,
2072 ServiceContext serviceContext)
2073 throws Exception;
2074
2075 protected BaseModel<?> addBaseModelWithWorkflow(
2076 boolean approved, ServiceContext serviceContext)
2077 throws Exception {
2078
2079 BaseModel<?> parentBaseModel = getParentBaseModel(
2080 group, serviceContext);
2081
2082 return addBaseModelWithWorkflow(
2083 parentBaseModel, approved, serviceContext);
2084 }
2085
2086 protected void deleteParentBaseModel(
2087 BaseModel<?> parentBaseModel, boolean includeTrashedEntries)
2088 throws Exception {
2089 }
2090
2091 protected BaseModel<?> expireBaseModel(
2092 BaseModel<?> baseModel, ServiceContext serviceContext)
2093 throws Exception {
2094
2095 return baseModel;
2096 }
2097
2098 protected AssetEntry fetchAssetEntry(Class<?> clazz, long classPK)
2099 throws Exception {
2100
2101 return AssetEntryLocalServiceUtil.fetchEntry(clazz.getName(), classPK);
2102 }
2103
2104 protected AssetEntry fetchAssetEntry(ClassedModel classedModel)
2105 throws Exception {
2106
2107 return fetchAssetEntry(
2108 classedModel.getModelClass(),
2109 (Long)classedModel.getPrimaryKeyObj());
2110 }
2111
2112 protected Long getAssetClassPK(ClassedModel classedModel) {
2113 return (Long)classedModel.getPrimaryKeyObj();
2114 }
2115
2116 protected abstract BaseModel<?> getBaseModel(long primaryKey)
2117 throws Exception;
2118
2119 protected abstract Class<?> getBaseModelClass();
2120
2121 protected String getBaseModelClassName() {
2122 Class<?> clazz = getBaseModelClass();
2123
2124 return clazz.getName();
2125 }
2126
2127 protected String getBaseModelName(ClassedModel classedModel) {
2128 return StringPool.BLANK;
2129 }
2130
2131 protected List<? extends WorkflowedModel> getChildrenWorkflowedModels(
2132 BaseModel<?> parentBaseModel)
2133 throws Exception {
2134
2135 return Collections.emptyList();
2136 }
2137
2138 protected long getDeletionSystemEventCount(
2139 TrashHandler trashHandler, final long systemEventSetKey)
2140 throws Exception {
2141
2142 final long systemEventClassNameId = PortalUtil.getClassNameId(
2143 trashHandler.getSystemEventClassName());
2144
2145 ActionableDynamicQuery actionableDynamicQuery =
2146 SystemEventLocalServiceUtil.getActionableDynamicQuery();
2147
2148 actionableDynamicQuery.setAddCriteriaMethod(
2149 new ActionableDynamicQuery.AddCriteriaMethod() {
2150
2151 @Override
2152 public void addCriteria(DynamicQuery dynamicQuery) {
2153 Property classNameIdProperty = PropertyFactoryUtil.forName(
2154 "classNameId");
2155
2156 dynamicQuery.add(
2157 classNameIdProperty.eq(systemEventClassNameId));
2158
2159 if (systemEventSetKey > 0) {
2160 Property systemEventSetKeyProperty =
2161 PropertyFactoryUtil.forName("systemEventSetKey");
2162
2163 dynamicQuery.add(
2164 systemEventSetKeyProperty.eq(systemEventSetKey));
2165 }
2166
2167 Property typeProperty = PropertyFactoryUtil.forName("type");
2168
2169 dynamicQuery.add(
2170 typeProperty.eq(SystemEventConstants.TYPE_DELETE));
2171 }
2172
2173 });
2174 actionableDynamicQuery.setGroupId(group.getGroupId());
2175
2176 return actionableDynamicQuery.performCount();
2177 }
2178
2179 protected int getMineBaseModelsCount(long groupId, long userId)
2180 throws Exception {
2181
2182 return 0;
2183 }
2184
2185 protected abstract int getNotInTrashBaseModelsCount(
2186 BaseModel<?> parentBaseModel)
2187 throws Exception;
2188
2189 protected BaseModel<?> getParentBaseModel(
2190 Group group, long parentBaseModelId, ServiceContext serviceContext)
2191 throws Exception {
2192
2193 return group;
2194 }
2195
2196 protected BaseModel<?> getParentBaseModel(
2197 Group group, ServiceContext serviceContext)
2198 throws Exception {
2199
2200 return group;
2201 }
2202
2203 protected Class<?> getParentBaseModelClass() {
2204 return getBaseModelClass();
2205 }
2206
2207 protected String getParentBaseModelClassName() {
2208 Class<?> clazz = getParentBaseModelClass();
2209
2210 return clazz.getName();
2211 }
2212
2213 protected int getRecentBaseModelsCount(long groupId) throws Exception {
2214 return 0;
2215 }
2216
2217 protected abstract String getSearchKeywords();
2218
2219 protected int getTrashEntriesCount(long groupId) throws Exception {
2220 return TrashEntryLocalServiceUtil.getEntriesCount(groupId);
2221 }
2222
2223 protected long getTrashEntryClassPK(ClassedModel classedModel) {
2224 return (Long)classedModel.getPrimaryKeyObj();
2225 }
2226
2227 protected abstract String getUniqueTitle(BaseModel<?> baseModel);
2228
2229 protected WorkflowedModel getWorkflowedModel(ClassedModel baseModel)
2230 throws Exception {
2231
2232 return (WorkflowedModel)baseModel;
2233 }
2234
2235 protected boolean isAssetableModel() {
2236 return true;
2237 }
2238
2239 protected boolean isAssetableParentModel() {
2240 return true;
2241 }
2242
2243 protected boolean isAssetEntryVisible(ClassedModel classedModel)
2244 throws Exception {
2245
2246 AssetEntry assetEntry = AssetEntryLocalServiceUtil.getEntry(
2247 classedModel.getModelClassName(), getAssetClassPK(classedModel));
2248
2249 return assetEntry.isVisible();
2250 }
2251
2252 protected boolean isBaseModelContainerModel() {
2253 if (baseModel instanceof ContainerModel) {
2254 return true;
2255 }
2256
2257 return false;
2258 }
2259
2260 protected boolean isBaseModelMoveableFromTrash() {
2261 return true;
2262 }
2263
2264 protected boolean isBaseModelTrashName(ClassedModel classedModel) {
2265 String baseModelName = getBaseModelName(classedModel);
2266
2267 if (baseModelName.startsWith(StringPool.SLASH)) {
2268 return true;
2269 }
2270
2271 return false;
2272 }
2273
2274 protected boolean isInTrashContainer(ClassedModel classedModel)
2275 throws Exception {
2276
2277 if (classedModel instanceof TrashedModel) {
2278 TrashedModel trashedModel = (TrashedModel)classedModel;
2279
2280 return trashedModel.isInTrashContainer();
2281 }
2282
2283 return false;
2284 }
2285
2286 protected BaseModel<?> moveBaseModelFromTrash(
2287 ClassedModel classedModel, Group group,
2288 ServiceContext serviceContext)
2289 throws Exception {
2290
2291 return getParentBaseModel(group, serviceContext);
2292 }
2293
2294 protected abstract void moveBaseModelToTrash(long primaryKey)
2295 throws Exception;
2296
2297 protected void moveParentBaseModelToTrash(long primaryKey)
2298 throws Exception {
2299 }
2300
2301 protected void restoreParentBaseModelFromTrash(long primaryKey)
2302 throws Exception {
2303 }
2304
2305 protected int searchBaseModelsCount(Class<?> clazz, long groupId)
2306 throws Exception {
2307
2308 Indexer indexer = IndexerRegistryUtil.getIndexer(clazz);
2309
2310 SearchContext searchContext = SearchContextTestUtil.getSearchContext();
2311
2312 searchContext.setGroupIds(new long[] {groupId});
2313
2314 Hits results = indexer.search(searchContext);
2315
2316 return results.getLength();
2317 }
2318
2319 protected int searchTrashEntriesCount(
2320 String keywords, ServiceContext serviceContext)
2321 throws Exception {
2322
2323 Hits results = TrashEntryLocalServiceUtil.search(
2324 serviceContext.getCompanyId(), serviceContext.getScopeGroupId(),
2325 serviceContext.getUserId(), keywords, QueryUtil.ALL_POS,
2326 QueryUtil.ALL_POS, null);
2327
2328 return results.getLength();
2329 }
2330
2331 protected BaseModel<?> updateBaseModel(
2332 long primaryKey, ServiceContext serviceContext)
2333 throws Exception {
2334
2335 return getBaseModel(primaryKey);
2336 }
2337
2338 protected BaseModel<?> baseModel;
2339
2340 @DeleteAfterTestRun
2341 protected Group group;
2342
2343 }