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