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