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