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