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