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.portal.search;
016    
017    import com.liferay.portal.kernel.search.Field;
018    import com.liferay.portal.kernel.search.Hits;
019    import com.liferay.portal.kernel.search.Indexer;
020    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
021    import com.liferay.portal.kernel.search.SearchContext;
022    import com.liferay.portal.kernel.trash.TrashHandler;
023    import com.liferay.portal.kernel.trash.TrashHandlerRegistryUtil;
024    import com.liferay.portal.kernel.util.LocaleUtil;
025    import com.liferay.portal.kernel.util.StringPool;
026    import com.liferay.portal.kernel.workflow.WorkflowConstants;
027    import com.liferay.portal.kernel.workflow.WorkflowThreadLocal;
028    import com.liferay.portal.model.BaseModel;
029    import com.liferay.portal.model.ClassedModel;
030    import com.liferay.portal.model.Group;
031    import com.liferay.portal.model.User;
032    import com.liferay.portal.security.auth.PrincipalThreadLocal;
033    import com.liferay.portal.security.permission.PermissionChecker;
034    import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
035    import com.liferay.portal.security.permission.PermissionThreadLocal;
036    import com.liferay.portal.service.ServiceContext;
037    import com.liferay.portal.test.DeleteAfterTestRun;
038    import com.liferay.portal.util.test.GroupTestUtil;
039    import com.liferay.portal.util.test.RandomTestUtil;
040    import com.liferay.portal.util.test.SearchContextTestUtil;
041    import com.liferay.portal.util.test.ServiceContextTestUtil;
042    import com.liferay.portal.util.test.TestPropsValues;
043    import com.liferay.portal.util.test.UserTestUtil;
044    import com.liferay.portlet.messageboards.model.MBMessage;
045    import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
046    
047    import java.util.HashMap;
048    import java.util.List;
049    import java.util.Locale;
050    import java.util.Map;
051    
052    import org.junit.Assert;
053    import org.junit.Before;
054    import org.junit.Test;
055    
056    /**
057     * @author Eudaldo Alonso
058     * @author Tibor Lipusz
059     */
060    public abstract class BaseSearchTestCase {
061    
062            @Before
063            public void setUp() throws Exception {
064                    group = GroupTestUtil.addGroup();
065            }
066    
067            @Test
068            public void testBaseModelUserPermissions() throws Exception {
069                    testUserPermissions(false, true);
070            }
071    
072            @Test
073            public void testLocalizedSearch() throws Exception {
074                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
075                            group.getGroupId());
076    
077                    int initialBaseModelsSearchCount = searchBaseModelsCount(
078                            getBaseModelClass(), group.getGroupId(), searchContext);
079    
080                    ServiceContext serviceContext =
081                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
082    
083                    BaseModel<?> parentBaseModel = getParentBaseModel(
084                            group, serviceContext);
085    
086                    Map<Locale, String> keywordsMap = new HashMap<Locale, String>();
087    
088                    keywordsMap.put(LocaleUtil.getDefault(), "entity title");
089                    keywordsMap.put(LocaleUtil.HUNGARY, "entitas neve");
090    
091                    baseModel = addBaseModelWithWorkflow(
092                            parentBaseModel, true, keywordsMap, serviceContext);
093    
094                    Assert.assertEquals(
095                            initialBaseModelsSearchCount + 1,
096                            searchBaseModelsCount(
097                                    getBaseModelClass(), group.getGroupId(), searchContext));
098    
099                    searchContext.setAttribute(Field.TITLE, "nev");
100                    searchContext.setKeywords("nev");
101                    searchContext.setLocale(LocaleUtil.HUNGARY);
102    
103                    Assert.assertEquals(
104                            initialBaseModelsSearchCount + 1,
105                            searchBaseModelsCount(
106                                    getBaseModelClass(), group.getGroupId(), searchContext));
107            }
108    
109            @Test
110            public void testParentBaseModelUserPermissions() throws Exception {
111                    testUserPermissions(true, false);
112            }
113    
114            @Test
115            public void testSearchAttachments() throws Exception {
116                    searchAttachments();
117            }
118    
119            @Test
120            public void testSearchBaseModel() throws Exception {
121                    searchBaseModel();
122            }
123    
124            @Test
125            public void testSearchBaseModelWithDelete() throws Exception {
126                    searchBaseModelWithDelete();
127            }
128    
129            @Test
130            public void testSearchBaseModelWithTrash() throws Exception {
131                    searchBaseModelWithTrash();
132            }
133    
134            @Test
135            public void testSearchBaseModelWithUpdate() throws Exception {
136                    searchBaseModelWithUpdate();
137            }
138    
139            @Test
140            public void testSearchByDDMStructureField() throws Exception {
141                    searchByDDMStructureField();
142            }
143    
144            @Test
145            public void testSearchByKeywords() throws Exception {
146                    searchByKeywords();
147            }
148    
149            @Test
150            public void testSearchByKeywordsInsideParentBaseModel() throws Exception {
151                    searchByKeywordsInsideParentBaseModel();
152            }
153    
154            @Test
155            public void testSearchComments() throws Exception {
156                    searchComments();
157            }
158    
159            @Test
160            public void testSearchExpireAllVersions() throws Exception {
161                    searchExpireVersions(false);
162            }
163    
164            @Test
165            public void testSearchExpireLatestVersion() throws Exception {
166                    searchExpireVersions(true);
167            }
168    
169            @Test
170            public void testSearchMyEntries() throws Exception {
171                    searchMyEntries();
172            }
173    
174            @Test
175            public void testSearchRecentEntries() throws Exception {
176                    searchRecentEntries();
177            }
178    
179            @Test
180            public void testSearchStatus() throws Exception {
181                    searchStatus();
182            }
183    
184            @Test
185            public void testSearchVersions() throws Exception {
186                    searchVersions();
187            }
188    
189            @Test
190            public void testSearchWithinDDMStructure() throws Exception {
191                    searchWithinDDMStructure();
192            }
193    
194            protected void addAttachment(ClassedModel classedModel) throws Exception {
195            }
196    
197            protected BaseModel<?> addBaseModel(
198                            BaseModel<?> parentBaseModel, boolean approved, String keywords,
199                            ServiceContext serviceContext)
200                    throws Exception {
201    
202                    boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
203    
204                    try {
205                            WorkflowThreadLocal.setEnabled(true);
206    
207                            BaseModel<?> baseModel = addBaseModelWithWorkflow(
208                                    parentBaseModel, approved, keywords, serviceContext);
209    
210                            return baseModel;
211                    }
212                    finally {
213                            WorkflowThreadLocal.setEnabled(workflowEnabled);
214                    }
215            }
216    
217            protected BaseModel<?> addBaseModelWithDDMStructure(
218                            BaseModel<?> parentBaseModel, String keywords,
219                            ServiceContext serviceContext)
220                    throws Exception {
221    
222                    return addBaseModel(parentBaseModel, true, keywords, serviceContext);
223            }
224    
225            protected BaseModel<?> addBaseModelWithWorkflow(
226                            BaseModel<?> parentBaseModel, boolean approved,
227                            Map<Locale, String> keywordsMap, ServiceContext serviceContext)
228                    throws Exception {
229    
230                    return addBaseModelWithWorkflow(
231                            parentBaseModel, approved, keywordsMap.get(LocaleUtil.getDefault()),
232                            serviceContext);
233            }
234    
235            protected abstract BaseModel<?> addBaseModelWithWorkflow(
236                            BaseModel<?> parentBaseModel, boolean approved, String keywords,
237                            ServiceContext serviceContext)
238                    throws Exception;
239    
240            protected void addComment(
241                            ClassedModel classedModel, String body,
242                            ServiceContext serviceContext)
243                    throws Exception {
244    
245                    User user = TestPropsValues.getUser();
246    
247                    List<MBMessage> messages = MBMessageLocalServiceUtil.getMessages(
248                            getBaseModelClassName(), getBaseModelClassPK(classedModel),
249                            WorkflowConstants.STATUS_ANY);
250    
251                    MBMessage message = messages.get(0);
252    
253                    MBMessageLocalServiceUtil.addDiscussionMessage(
254                            user.getUserId(), user.getFullName(),
255                            serviceContext.getScopeGroupId(), getBaseModelClassName(),
256                            getBaseModelClassPK(classedModel), message.getThreadId(),
257                            message.getMessageId(), message.getSubject(), body, serviceContext);
258            }
259    
260            protected void deleteBaseModel(BaseModel<?> baseModel) throws Exception {
261                    deleteBaseModel((Long)baseModel.getPrimaryKeyObj());
262            }
263    
264            protected void deleteBaseModel(long primaryKey) throws Exception {
265            }
266    
267            protected void expireBaseModelVersions(
268                            BaseModel<?> baseModel, boolean expireAllVersions,
269                            ServiceContext serviceContext)
270                    throws Exception {
271            }
272    
273            protected abstract Class<?> getBaseModelClass();
274    
275            protected String getBaseModelClassName() {
276                    Class<?> clazz = getBaseModelClass();
277    
278                    return clazz.getName();
279            }
280    
281            protected Long getBaseModelClassPK(ClassedModel classedModel) {
282                    return (Long)classedModel.getPrimaryKeyObj();
283            }
284    
285            protected String getDDMStructureFieldName() {
286                    return StringPool.BLANK;
287            }
288    
289            protected BaseModel<?> getParentBaseModel(
290                            BaseModel<?> parentBaseModel, ServiceContext serviceContext)
291                    throws Exception {
292    
293                    return parentBaseModel;
294            }
295    
296            protected BaseModel<?> getParentBaseModel(
297                            Group group, ServiceContext serviceContext)
298                    throws Exception {
299    
300                    return group;
301            }
302    
303            protected String getParentBaseModelClassName() {
304                    return StringPool.BLANK;
305            }
306    
307            protected abstract String getSearchKeywords();
308    
309            protected boolean isCheckBaseModelPermission() {
310                    return CHECK_BASE_MODEL_PERMISSION;
311            }
312    
313            protected boolean isExpirableAllVersions() {
314                    return false;
315            }
316    
317            protected void moveBaseModelToTrash(long primaryKey) throws Exception {
318            }
319    
320            protected void moveParentBaseModelToTrash(long primaryKey)
321                    throws Exception {
322            }
323    
324            protected void searchAttachments() throws Exception {
325                    ServiceContext serviceContext =
326                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
327    
328                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
329                            group.getGroupId());
330    
331                    searchContext.setIncludeAttachments(true);
332    
333                    BaseModel<?> parentBaseModel = getParentBaseModel(
334                            group, serviceContext);
335    
336                    int initialBaseModelsSearchCount = searchBaseModelsCount(
337                            getBaseModelClass(), group.getGroupId(), searchContext);
338    
339                    baseModel = addBaseModel(
340                            parentBaseModel, true, RandomTestUtil.randomString(),
341                            serviceContext);
342    
343                    Assert.assertEquals(
344                            initialBaseModelsSearchCount + 1,
345                            searchBaseModelsCount(
346                                    getBaseModelClass(), group.getGroupId(), searchContext));
347    
348                    addAttachment(baseModel);
349    
350                    Assert.assertEquals(
351                            initialBaseModelsSearchCount + 2,
352                            searchBaseModelsCount(
353                                    getBaseModelClass(), group.getGroupId(), searchContext));
354    
355                    moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
356    
357                    Assert.assertEquals(
358                            initialBaseModelsSearchCount,
359                            searchBaseModelsCount(
360                                    getBaseModelClass(), group.getGroupId(), searchContext));
361            }
362    
363            protected void searchBaseModel() throws Exception {
364                    ServiceContext serviceContext =
365                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
366    
367                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
368                            group.getGroupId());
369    
370                    BaseModel<?> parentBaseModel = getParentBaseModel(
371                            group, serviceContext);
372    
373                    int initialBaseModelsSearchCount = searchBaseModelsCount(
374                            getBaseModelClass(), group.getGroupId(), searchContext);
375    
376                    baseModel = addBaseModel(
377                            parentBaseModel, true, RandomTestUtil.randomString(),
378                            serviceContext);
379    
380                    Assert.assertEquals(
381                            initialBaseModelsSearchCount + 1,
382                            searchBaseModelsCount(
383                                    getBaseModelClass(), group.getGroupId(), searchContext));
384            }
385    
386            protected int searchBaseModelsCount(
387                            Class<?> clazz, long groupId, SearchContext searchContext)
388                    throws Exception {
389    
390                    Indexer indexer = IndexerRegistryUtil.getIndexer(clazz);
391    
392                    searchContext.setGroupIds(new long[] {groupId});
393    
394                    Hits results = indexer.search(searchContext);
395    
396                    return results.getLength();
397            }
398    
399            protected int searchBaseModelsCount(
400                            Class<?> clazz, long groupId, String keywords,
401                            SearchContext searchContext)
402                    throws Exception {
403    
404                    searchContext.setKeywords(keywords);
405    
406                    return searchBaseModelsCount(clazz, groupId, searchContext);
407            }
408    
409            protected void searchBaseModelWithDelete() throws Exception {
410                    ServiceContext serviceContext =
411                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
412    
413                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
414                            group.getGroupId());
415    
416                    BaseModel<?> parentBaseModel = getParentBaseModel(
417                            group, serviceContext);
418    
419                    int initialBaseModelsSearchCount = searchBaseModelsCount(
420                            getBaseModelClass(), group.getGroupId(), searchContext);
421    
422                    baseModel = addBaseModel(
423                            parentBaseModel, true, getSearchKeywords(), serviceContext);
424    
425                    Assert.assertEquals(
426                            initialBaseModelsSearchCount + 1,
427                            searchBaseModelsCount(
428                                    getBaseModelClass(), group.getGroupId(), searchContext));
429    
430                    deleteBaseModel(baseModel);
431    
432                    Assert.assertEquals(
433                            initialBaseModelsSearchCount,
434                            searchBaseModelsCount(
435                                    getBaseModelClass(), group.getGroupId(), searchContext));
436            }
437    
438            protected void searchBaseModelWithTrash() throws Exception {
439                    ServiceContext serviceContext =
440                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
441    
442                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
443                            group.getGroupId());
444    
445                    BaseModel<?> parentBaseModel = getParentBaseModel(
446                            group, serviceContext);
447    
448                    int initialBaseModelsSearchCount = searchBaseModelsCount(
449                            getBaseModelClass(), group.getGroupId(), searchContext);
450    
451                    baseModel = addBaseModel(
452                            parentBaseModel, true, getSearchKeywords(), serviceContext);
453    
454                    Assert.assertEquals(
455                            initialBaseModelsSearchCount + 1,
456                            searchBaseModelsCount(
457                                    getBaseModelClass(), group.getGroupId(), searchContext));
458    
459                    moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
460    
461                    searchContext.setKeywords(getSearchKeywords());
462    
463                    Assert.assertEquals(
464                            initialBaseModelsSearchCount,
465                            searchBaseModelsCount(
466                                    getBaseModelClass(), group.getGroupId(), searchContext));
467            }
468    
469            protected void searchBaseModelWithUpdate() throws Exception {
470                    ServiceContext serviceContext =
471                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
472    
473                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
474                            group.getGroupId());
475    
476                    BaseModel<?> parentBaseModel = getParentBaseModel(
477                            group, serviceContext);
478    
479                    searchContext.setKeywords(getSearchKeywords());
480    
481                    int initialBaseModelsSearchCount = searchBaseModelsCount(
482                            getBaseModelClass(), group.getGroupId(), searchContext);
483    
484                    baseModel = addBaseModel(
485                            parentBaseModel, true, getSearchKeywords(), serviceContext);
486    
487                    Assert.assertEquals(
488                            initialBaseModelsSearchCount + 1,
489                            searchBaseModelsCount(
490                                    getBaseModelClass(), group.getGroupId(), searchContext));
491    
492                    String updatedKeywords = RandomTestUtil.randomString();
493    
494                    baseModel = updateBaseModel(baseModel, updatedKeywords, serviceContext);
495    
496                    Assert.assertEquals(
497                            initialBaseModelsSearchCount,
498                            searchBaseModelsCount(
499                                    getBaseModelClass(), group.getGroupId(), searchContext));
500    
501                    searchContext.setKeywords(updatedKeywords);
502    
503                    Assert.assertEquals(
504                            initialBaseModelsSearchCount + 1,
505                            searchBaseModelsCount(
506                                    getBaseModelClass(), group.getGroupId(), searchContext));
507            }
508    
509            protected void searchByDDMStructureField() throws Exception {
510                    ServiceContext serviceContext =
511                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
512    
513                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
514                            group.getGroupId());
515    
516                    int initialBaseModelsSearchCount = searchBaseModelsCount(
517                            getBaseModelClass(), group.getGroupId(), searchContext);
518    
519                    BaseModel<?> parentBaseModel = getParentBaseModel(
520                            group, serviceContext);
521    
522                    baseModel = addBaseModelWithDDMStructure(
523                            parentBaseModel, getSearchKeywords(), serviceContext);
524    
525                    searchContext.setAttribute(
526                            "ddmStructureFieldName", getDDMStructureFieldName());
527                    searchContext.setAttribute(
528                            "ddmStructureFieldValue", getSearchKeywords());
529    
530                    Assert.assertEquals(
531                            initialBaseModelsSearchCount + 1,
532                            searchBaseModelsCount(
533                                    getBaseModelClass(), group.getGroupId(), searchContext));
534    
535                    updateDDMStructure(serviceContext);
536    
537                    Assert.assertEquals(
538                            initialBaseModelsSearchCount,
539                            searchBaseModelsCount(
540                                    getBaseModelClass(), group.getGroupId(), searchContext));
541            }
542    
543            protected void searchByKeywords() throws Exception {
544                    ServiceContext serviceContext =
545                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
546    
547                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
548                            group.getGroupId());
549    
550                    searchContext.setKeywords(getSearchKeywords());
551    
552                    int initialBaseModelsSearchCount = searchBaseModelsCount(
553                            getBaseModelClass(), group.getGroupId(), searchContext);
554    
555                    BaseModel<?> parentBaseModel = getParentBaseModel(
556                            group, serviceContext);
557    
558                    baseModel = addBaseModel(
559                            parentBaseModel, true, getSearchKeywords(), serviceContext);
560    
561                    Assert.assertEquals(
562                            initialBaseModelsSearchCount + 1,
563                            searchBaseModelsCount(
564                                    getBaseModelClass(), group.getGroupId(), searchContext));
565            }
566    
567            protected void searchByKeywordsInsideParentBaseModel() throws Exception {
568                    ServiceContext serviceContext =
569                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
570    
571                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
572                            group.getGroupId());
573    
574                    baseModel = addBaseModel(
575                            null, true, getSearchKeywords(), serviceContext);
576    
577                    BaseModel<?> parentBaseModel1 = getParentBaseModel(
578                            group, serviceContext);
579    
580                    searchContext.setFolderIds(
581                            new long[] {(Long)parentBaseModel1.getPrimaryKeyObj()});
582                    searchContext.setKeywords(getSearchKeywords());
583    
584                    int initialBaseModelsSearchCount = searchBaseModelsCount(
585                            getBaseModelClass(), group.getGroupId(), searchContext);
586    
587                    baseModel = addBaseModel(
588                            parentBaseModel1, true, getSearchKeywords(), serviceContext);
589    
590                    Assert.assertEquals(
591                            initialBaseModelsSearchCount + 1,
592                            searchBaseModelsCount(
593                                    getBaseModelClass(), group.getGroupId(), searchContext));
594    
595                    BaseModel<?> parentBaseModel2 = getParentBaseModel(
596                            parentBaseModel1, serviceContext);
597    
598                    baseModel = addBaseModel(
599                            parentBaseModel2, true, getSearchKeywords(), serviceContext);
600    
601                    Assert.assertEquals(
602                            initialBaseModelsSearchCount + 2,
603                            searchBaseModelsCount(
604                                    getBaseModelClass(), group.getGroupId(), searchContext));
605            }
606    
607            protected void searchComments() throws Exception {
608                    ServiceContext serviceContext =
609                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
610    
611                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
612                            group.getGroupId());
613    
614                    searchContext.setIncludeDiscussions(true);
615    
616                    BaseModel<?> parentBaseModel = getParentBaseModel(
617                            group, serviceContext);
618    
619                    int initialBaseModelsSearchCount = searchBaseModelsCount(
620                            getBaseModelClass(), group.getGroupId(), searchContext);
621    
622                    baseModel = addBaseModel(
623                            parentBaseModel, true, RandomTestUtil.randomString(),
624                            serviceContext);
625    
626                    Assert.assertEquals(
627                            initialBaseModelsSearchCount + 1,
628                            searchBaseModelsCount(
629                                    getBaseModelClass(), group.getGroupId(), searchContext));
630    
631                    addComment(baseModel, getSearchKeywords(), serviceContext);
632    
633                    Assert.assertEquals(
634                            initialBaseModelsSearchCount + 2,
635                            searchBaseModelsCount(
636                                    getBaseModelClass(), group.getGroupId(), searchContext));
637    
638                    moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
639    
640                    Assert.assertEquals(
641                            initialBaseModelsSearchCount,
642                            searchBaseModelsCount(
643                                    getBaseModelClass(), group.getGroupId(), searchContext));
644            }
645    
646            protected void searchExpireVersions(boolean expireAllVersions)
647                    throws Exception {
648    
649                    ServiceContext serviceContext =
650                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
651    
652                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
653                            group.getGroupId());
654    
655                    searchContext.setKeywords(getSearchKeywords());
656    
657                    int initialBaseModelsCount = searchBaseModelsCount(
658                            getBaseModelClass(), group.getGroupId(), searchContext);
659    
660                    BaseModel<?> parentBaseModel = getParentBaseModel(
661                            group, serviceContext);
662    
663                    baseModel = addBaseModel(
664                            parentBaseModel, true, getSearchKeywords(), serviceContext);
665    
666                    Assert.assertEquals(
667                            initialBaseModelsCount + 1,
668                            searchBaseModelsCount(
669                                    getBaseModelClass(), group.getGroupId(), searchContext));
670    
671                    baseModel = updateBaseModel(baseModel, "liferay", serviceContext);
672    
673                    Assert.assertEquals(
674                            initialBaseModelsCount,
675                            searchBaseModelsCount(
676                                    getBaseModelClass(), group.getGroupId(), searchContext));
677    
678                    expireBaseModelVersions(baseModel, expireAllVersions, serviceContext);
679    
680                    if (expireAllVersions && isExpirableAllVersions()) {
681                            Assert.assertEquals(
682                                    initialBaseModelsCount,
683                                    searchBaseModelsCount(
684                                            getBaseModelClass(), group.getGroupId(), searchContext));
685                    }
686                    else {
687                            Assert.assertEquals(
688                                    initialBaseModelsCount + 1,
689                                    searchBaseModelsCount(
690                                            getBaseModelClass(), group.getGroupId(), searchContext));
691                    }
692            }
693    
694            protected long searchGroupEntriesCount(long groupId, long userId)
695                    throws Exception {
696    
697                    return -1;
698            }
699    
700            protected void searchMyEntries() throws Exception {
701                    User user1 = UserTestUtil.addUser(null, 0);
702    
703                    long initialUser1SearchGroupEntriesCount = searchGroupEntriesCount(
704                            group.getGroupId(), user1.getUserId());
705    
706                    User user2 = UserTestUtil.addUser(null, 0);
707    
708                    long initialUser2SearchGroupEntriesCount = searchGroupEntriesCount(
709                            group.getGroupId(), user2.getUserId());
710    
711                    ServiceContext serviceContext =
712                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
713    
714                    BaseModel<?> parentBaseModel1 = getParentBaseModel(
715                            group, serviceContext);
716                    BaseModel<?> parentBaseModel2 = getParentBaseModel(
717                            group, serviceContext);
718    
719                    String name = PrincipalThreadLocal.getName();
720    
721                    long userId = serviceContext.getUserId();
722    
723                    try {
724                            PrincipalThreadLocal.setName(user1.getUserId());
725    
726                            serviceContext.setUserId(user1.getUserId());
727    
728                            baseModel = addBaseModel(
729                                    parentBaseModel1, true, RandomTestUtil.randomString(),
730                                    serviceContext);
731                            baseModel = addBaseModel(
732                                    parentBaseModel1, true, RandomTestUtil.randomString(),
733                                    serviceContext);
734                            baseModel = addBaseModel(
735                                    parentBaseModel2, true, RandomTestUtil.randomString(),
736                                    serviceContext);
737    
738                            PrincipalThreadLocal.setName(user2.getUserId());
739    
740                            serviceContext.setUserId(user2.getUserId());
741    
742                            baseModel = addBaseModel(
743                                    parentBaseModel1, true, RandomTestUtil.randomString(),
744                                    serviceContext);
745                            baseModel = addBaseModel(
746                                    parentBaseModel2, true, RandomTestUtil.randomString(),
747                                    serviceContext);
748                    }
749                    finally {
750                            PrincipalThreadLocal.setName(name);
751    
752                            serviceContext.setUserId(userId);
753                    }
754    
755                    Assert.assertEquals(
756                            initialUser1SearchGroupEntriesCount + 3,
757                            searchGroupEntriesCount(group.getGroupId(), user1.getUserId()));
758                    Assert.assertEquals(
759                            initialUser2SearchGroupEntriesCount + 2,
760                            searchGroupEntriesCount(group.getGroupId(), user2.getUserId()));
761    
762                    moveParentBaseModelToTrash((Long)parentBaseModel2.getPrimaryKeyObj());
763    
764                    Assert.assertEquals(
765                            initialUser1SearchGroupEntriesCount + 2,
766                            searchGroupEntriesCount(group.getGroupId(), user1.getUserId()));
767                    Assert.assertEquals(
768                            initialUser2SearchGroupEntriesCount + 1,
769                            searchGroupEntriesCount(group.getGroupId(), user2.getUserId()));
770    
771                    TrashHandler parentTrashHandler =
772                            TrashHandlerRegistryUtil.getTrashHandler(
773                                    getParentBaseModelClassName());
774    
775                    parentTrashHandler.restoreTrashEntry(
776                            user1.getUserId(), (Long)parentBaseModel2.getPrimaryKeyObj());
777    
778                    Assert.assertEquals(
779                            initialUser1SearchGroupEntriesCount + 3,
780                            searchGroupEntriesCount(group.getGroupId(), user1.getUserId()));
781                    Assert.assertEquals(
782                            initialUser2SearchGroupEntriesCount + 2,
783                            searchGroupEntriesCount(group.getGroupId(), user2.getUserId()));
784            }
785    
786            protected void searchRecentEntries() throws Exception {
787                    long initialSearchGroupEntriesCount = searchGroupEntriesCount(
788                            group.getGroupId(), 0);
789    
790                    ServiceContext serviceContext =
791                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
792    
793                    BaseModel<?> parentBaseModel1 = getParentBaseModel(
794                            group, serviceContext);
795                    BaseModel<?> parentBaseModel2 = getParentBaseModel(
796                            group, serviceContext);
797    
798                    String name = PrincipalThreadLocal.getName();
799    
800                    try {
801                            User user1 = UserTestUtil.addUser(null, 0);
802    
803                            PrincipalThreadLocal.setName(user1.getUserId());
804    
805                            baseModel = addBaseModel(
806                                    parentBaseModel1, true, RandomTestUtil.randomString(),
807                                    serviceContext);
808                            baseModel = addBaseModel(
809                                    parentBaseModel1, true, RandomTestUtil.randomString(),
810                                    serviceContext);
811                            baseModel = addBaseModel(
812                                    parentBaseModel2, true, RandomTestUtil.randomString(),
813                                    serviceContext);
814    
815                            User user2 = UserTestUtil.addUser(null, 0);
816    
817                            PrincipalThreadLocal.setName(user2.getUserId());
818    
819                            baseModel = addBaseModel(
820                                    parentBaseModel1, true, RandomTestUtil.randomString(),
821                                    serviceContext);
822                            baseModel = addBaseModel(
823                                    parentBaseModel2, true, RandomTestUtil.randomString(),
824                                    serviceContext);
825                    }
826                    finally {
827                            PrincipalThreadLocal.setName(name);
828                    }
829    
830                    Assert.assertEquals(
831                            initialSearchGroupEntriesCount + 5,
832                            searchGroupEntriesCount(group.getGroupId(), 0));
833    
834                    moveParentBaseModelToTrash((Long)parentBaseModel2.getPrimaryKeyObj());
835    
836                    Assert.assertEquals(
837                            initialSearchGroupEntriesCount + 3,
838                            searchGroupEntriesCount(group.getGroupId(), 0));
839    
840                    TrashHandler parentTrashHandler =
841                            TrashHandlerRegistryUtil.getTrashHandler(
842                                    getParentBaseModelClassName());
843    
844                    parentTrashHandler.restoreTrashEntry(
845                            TestPropsValues.getUserId(),
846                            (Long)parentBaseModel2.getPrimaryKeyObj());
847    
848                    Assert.assertEquals(
849                            initialSearchGroupEntriesCount + 5,
850                            searchGroupEntriesCount(group.getGroupId(), 0));
851            }
852    
853            protected void searchStatus() throws Exception {
854                    ServiceContext serviceContext =
855                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
856    
857                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
858                            group.getGroupId());
859    
860                    int initialBaseModelsCount = searchBaseModelsCount(
861                            getBaseModelClass(), group.getGroupId(), "1.0", searchContext);
862    
863                    BaseModel<?> parentBaseModel = getParentBaseModel(
864                            group, serviceContext);
865    
866                    baseModel = addBaseModel(
867                            parentBaseModel, false, "Version 1.0", serviceContext);
868    
869                    Assert.assertEquals(
870                            initialBaseModelsCount,
871                            searchBaseModelsCount(
872                                    getBaseModelClass(), group.getGroupId(), searchContext));
873    
874                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
875    
876                    baseModel = updateBaseModel(baseModel, "Version 1.1", serviceContext);
877    
878                    Assert.assertEquals(
879                            initialBaseModelsCount,
880                            searchBaseModelsCount(
881                                    getBaseModelClass(), group.getGroupId(), "1.0", searchContext));
882                    Assert.assertEquals(
883                            initialBaseModelsCount + 1,
884                            searchBaseModelsCount(
885                                    getBaseModelClass(), group.getGroupId(), "1.1", searchContext));
886    
887                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
888    
889                    baseModel = updateBaseModel(baseModel, "Version 1.2", serviceContext);
890    
891                    Assert.assertEquals(
892                            initialBaseModelsCount + 1,
893                            searchBaseModelsCount(
894                                    getBaseModelClass(), group.getGroupId(), "1.1", searchContext));
895                    Assert.assertEquals(
896                            initialBaseModelsCount,
897                            searchBaseModelsCount(
898                                    getBaseModelClass(), group.getGroupId(), "1.2", searchContext));
899    
900                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
901    
902                    baseModel = updateBaseModel(baseModel, "Version 1.3", serviceContext);
903    
904                    Assert.assertEquals(
905                            initialBaseModelsCount,
906                            searchBaseModelsCount(
907                                    getBaseModelClass(), group.getGroupId(), "1.2", searchContext));
908                    Assert.assertEquals(
909                            initialBaseModelsCount + 1,
910                            searchBaseModelsCount(
911                                    getBaseModelClass(), group.getGroupId(), "1.3", searchContext));
912            }
913    
914            protected void searchVersions() throws Exception {
915                    ServiceContext serviceContext =
916                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
917    
918                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
919                            group.getGroupId());
920    
921                    searchContext.setKeywords(getSearchKeywords());
922    
923                    int initialBaseModelsCount = searchBaseModelsCount(
924                            getBaseModelClass(), group.getGroupId(), searchContext);
925    
926                    BaseModel<?> parentBaseModel = getParentBaseModel(
927                            group, serviceContext);
928    
929                    baseModel = addBaseModel(
930                            parentBaseModel, true, getSearchKeywords(), serviceContext);
931    
932                    Assert.assertEquals(
933                            initialBaseModelsCount + 1,
934                            searchBaseModelsCount(
935                                    getBaseModelClass(), group.getGroupId(), searchContext));
936    
937                    baseModel = updateBaseModel(baseModel, "liferay", serviceContext);
938    
939                    Assert.assertEquals(
940                            initialBaseModelsCount,
941                            searchBaseModelsCount(
942                                    getBaseModelClass(), group.getGroupId(), searchContext));
943    
944                    baseModel = updateBaseModel(baseModel, "portal", serviceContext);
945    
946                    searchContext.setKeywords("portal");
947    
948                    Assert.assertEquals(
949                            initialBaseModelsCount + 1,
950                            searchBaseModelsCount(
951                                    getBaseModelClass(), group.getGroupId(), searchContext));
952            }
953    
954            protected void searchWithinDDMStructure() throws Exception {
955                    ServiceContext serviceContext =
956                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
957    
958                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
959                            group.getGroupId());
960    
961                    searchContext.setKeywords(getSearchKeywords());
962    
963                    int initialBaseModelsSearchCount = searchBaseModelsCount(
964                            getBaseModelClass(), group.getGroupId(), searchContext);
965    
966                    BaseModel<?> parentBaseModel = getParentBaseModel(
967                            group, serviceContext);
968    
969                    baseModel = addBaseModelWithDDMStructure(
970                            parentBaseModel,  getSearchKeywords(), serviceContext);
971    
972                    Assert.assertEquals(
973                            initialBaseModelsSearchCount + 1,
974                            searchBaseModelsCount(
975                                    getBaseModelClass(), group.getGroupId(), searchContext));
976            }
977    
978            protected void testUserPermissions(
979                            boolean addBaseModelPermission,
980                            boolean addParentBaseModelPermission)
981                    throws Exception {
982    
983                    ServiceContext serviceContext =
984                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
985    
986                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
987                            group.getGroupId());
988    
989                    searchContext.setKeywords(getSearchKeywords());
990    
991                    int initialBaseModelsSearchCount = searchBaseModelsCount(
992                            getBaseModelClass(), group.getGroupId(), searchContext);
993    
994                    serviceContext.setAddGroupPermissions(addParentBaseModelPermission);
995                    serviceContext.setAddGuestPermissions(addParentBaseModelPermission);
996    
997                    BaseModel<?> parentBaseModel = getParentBaseModel(
998                            group, serviceContext);
999    
1000                    serviceContext.setAddGroupPermissions(addBaseModelPermission);
1001                    serviceContext.setAddGuestPermissions(addBaseModelPermission);
1002    
1003                    baseModel = addBaseModel(
1004                            parentBaseModel, true, getSearchKeywords(), serviceContext);
1005    
1006                    User user = UserTestUtil.addUser(null, 0);
1007    
1008                    PermissionChecker originalPermissionChecker =
1009                            PermissionThreadLocal.getPermissionChecker();
1010    
1011                    try {
1012                            PermissionChecker permissionChecker =
1013                                    PermissionCheckerFactoryUtil.create(user);
1014    
1015                            PermissionThreadLocal.setPermissionChecker(permissionChecker);
1016    
1017                            searchContext.setUserId(user.getUserId());
1018    
1019                            int baseModelsCount =  initialBaseModelsSearchCount;
1020    
1021                            if (addBaseModelPermission && !isCheckBaseModelPermission()) {
1022                                    baseModelsCount++;
1023                            }
1024    
1025                            Assert.assertEquals(
1026                                    baseModelsCount,
1027                                    searchBaseModelsCount(
1028                                            getBaseModelClass(), group.getGroupId(), searchContext));
1029                    }
1030                    finally {
1031                            PermissionThreadLocal.setPermissionChecker(
1032                                    originalPermissionChecker);
1033                    }
1034            }
1035    
1036            protected BaseModel<?> updateBaseModel(
1037                            BaseModel<?> baseModel, String keywords,
1038                            ServiceContext serviceContext)
1039                    throws Exception {
1040    
1041                    return baseModel;
1042            }
1043    
1044            protected void updateDDMStructure(ServiceContext serviceContext)
1045                    throws Exception {
1046            }
1047    
1048            protected final boolean CHECK_BASE_MODEL_PERMISSION = true;
1049    
1050            protected BaseModel<?> baseModel;
1051    
1052            @DeleteAfterTestRun
1053            protected Group group;
1054    
1055    }