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 testSearchMixedPhraseKeywords() throws Exception {
170                    searchByMixedPhraseKeywords();
171            }
172    
173            @Test
174            public void testSearchMyEntries() throws Exception {
175                    searchMyEntries();
176            }
177    
178            @Test
179            public void testSearchRecentEntries() throws Exception {
180                    searchRecentEntries();
181            }
182    
183            @Test
184            public void testSearchStatus() throws Exception {
185                    searchStatus();
186            }
187    
188            @Test
189            public void testSearchVersions() throws Exception {
190                    searchVersions();
191            }
192    
193            @Test
194            public void testSearchWithinDDMStructure() throws Exception {
195                    searchWithinDDMStructure();
196            }
197    
198            protected void addAttachment(ClassedModel classedModel) throws Exception {
199            }
200    
201            protected BaseModel<?> addBaseModel(
202                            BaseModel<?> parentBaseModel, boolean approved, String keywords,
203                            ServiceContext serviceContext)
204                    throws Exception {
205    
206                    boolean workflowEnabled = WorkflowThreadLocal.isEnabled();
207    
208                    try {
209                            WorkflowThreadLocal.setEnabled(true);
210    
211                            BaseModel<?> baseModel = addBaseModelWithWorkflow(
212                                    parentBaseModel, approved, keywords, serviceContext);
213    
214                            return baseModel;
215                    }
216                    finally {
217                            WorkflowThreadLocal.setEnabled(workflowEnabled);
218                    }
219            }
220    
221            protected BaseModel<?> addBaseModelWithDDMStructure(
222                            BaseModel<?> parentBaseModel, String keywords,
223                            ServiceContext serviceContext)
224                    throws Exception {
225    
226                    return addBaseModel(parentBaseModel, true, keywords, serviceContext);
227            }
228    
229            protected BaseModel<?> addBaseModelWithWorkflow(
230                            BaseModel<?> parentBaseModel, boolean approved,
231                            Map<Locale, String> keywordsMap, ServiceContext serviceContext)
232                    throws Exception {
233    
234                    return addBaseModelWithWorkflow(
235                            parentBaseModel, approved, keywordsMap.get(LocaleUtil.getDefault()),
236                            serviceContext);
237            }
238    
239            protected abstract BaseModel<?> addBaseModelWithWorkflow(
240                            BaseModel<?> parentBaseModel, boolean approved, String keywords,
241                            ServiceContext serviceContext)
242                    throws Exception;
243    
244            protected void addComment(
245                            ClassedModel classedModel, String body,
246                            ServiceContext serviceContext)
247                    throws Exception {
248    
249                    User user = TestPropsValues.getUser();
250    
251                    List<MBMessage> messages = MBMessageLocalServiceUtil.getMessages(
252                            getBaseModelClassName(), getBaseModelClassPK(classedModel),
253                            WorkflowConstants.STATUS_ANY);
254    
255                    MBMessage message = messages.get(0);
256    
257                    MBMessageLocalServiceUtil.addDiscussionMessage(
258                            user.getUserId(), user.getFullName(),
259                            serviceContext.getScopeGroupId(), getBaseModelClassName(),
260                            getBaseModelClassPK(classedModel), message.getThreadId(),
261                            message.getMessageId(), message.getSubject(), body, serviceContext);
262            }
263    
264            protected void assertBaseModelsCount(
265                            final int expectedCount, final SearchContext searchContext)
266                    throws Exception {
267    
268                    IdempotentRetryAssert.retryAssert(
269                            10, TimeUnit.SECONDS,
270                            new Callable<Void>() {
271    
272                                    @Override
273                                    public Void call() throws Exception {
274                                            int actualCount = searchBaseModelsCount(searchContext);
275    
276                                            Assert.assertEquals(expectedCount, actualCount);
277    
278                                            return null;
279                                    }
280    
281                            });
282            }
283    
284            protected void assertBaseModelsCount(
285                            int expectedCount, String keywords, SearchContext searchContext)
286                    throws Exception {
287    
288                    searchContext.setKeywords(keywords);
289    
290                    assertBaseModelsCount(expectedCount, searchContext);
291            }
292    
293            protected void assertGroupEntriesCount(long expectedCount)
294                    throws Exception {
295    
296                    assertGroupEntriesCount(expectedCount, 0);
297            }
298    
299            protected void assertGroupEntriesCount(
300                            final long expectedCount, final long userId)
301                    throws Exception {
302    
303                    IdempotentRetryAssert.retryAssert(
304                            3, TimeUnit.SECONDS,
305                            new Callable<Void>() {
306    
307                                    @Override
308                                    public Void call() throws Exception {
309                                            long actualCount = searchGroupEntriesCount(
310                                                    group.getGroupId(), userId);
311    
312                                            Assert.assertEquals(expectedCount, actualCount);
313    
314                                            return null;
315                                    }
316    
317                            });
318            }
319    
320            protected void assertGroupEntriesCount(long expectedCount, User user)
321                    throws Exception {
322    
323                    assertGroupEntriesCount(expectedCount, user.getUserId());
324            }
325    
326            protected void deleteBaseModel(BaseModel<?> baseModel) throws Exception {
327                    deleteBaseModel((Long)baseModel.getPrimaryKeyObj());
328            }
329    
330            protected void deleteBaseModel(long primaryKey) throws Exception {
331            }
332    
333            protected void expireBaseModelVersions(
334                            BaseModel<?> baseModel, boolean expireAllVersions,
335                            ServiceContext serviceContext)
336                    throws Exception {
337            }
338    
339            protected abstract Class<?> getBaseModelClass();
340    
341            protected String getBaseModelClassName() {
342                    Class<?> clazz = getBaseModelClass();
343    
344                    return clazz.getName();
345            }
346    
347            protected Long getBaseModelClassPK(ClassedModel classedModel) {
348                    return (Long)classedModel.getPrimaryKeyObj();
349            }
350    
351            protected String getDDMStructureFieldName() {
352                    return StringPool.BLANK;
353            }
354    
355            protected BaseModel<?> getParentBaseModel(
356                            BaseModel<?> parentBaseModel, ServiceContext serviceContext)
357                    throws Exception {
358    
359                    return parentBaseModel;
360            }
361    
362            protected BaseModel<?> getParentBaseModel(
363                            Group group, ServiceContext serviceContext)
364                    throws Exception {
365    
366                    return group;
367            }
368    
369            protected String getParentBaseModelClassName() {
370                    return StringPool.BLANK;
371            }
372    
373            protected abstract String getSearchKeywords();
374    
375            protected boolean isCheckBaseModelPermission() {
376                    return CHECK_BASE_MODEL_PERMISSION;
377            }
378    
379            protected boolean isExpirableAllVersions() {
380                    return false;
381            }
382    
383            protected void moveBaseModelToTrash(long primaryKey) throws Exception {
384            }
385    
386            protected void moveParentBaseModelToTrash(long primaryKey)
387                    throws Exception {
388            }
389    
390            protected void searchAttachments() throws Exception {
391                    ServiceContext serviceContext =
392                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
393    
394                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
395                            group.getGroupId());
396    
397                    searchContext.setIncludeAttachments(true);
398    
399                    BaseModel<?> parentBaseModel = getParentBaseModel(
400                            group, serviceContext);
401    
402                    int initialBaseModelsSearchCount = 0;
403    
404                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
405    
406                    baseModel = addBaseModel(
407                            parentBaseModel, true, RandomTestUtil.randomString(),
408                            serviceContext);
409    
410                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
411    
412                    addAttachment(baseModel);
413    
414                    assertBaseModelsCount(initialBaseModelsSearchCount + 2, searchContext);
415    
416                    moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
417    
418                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
419            }
420    
421            protected void searchBaseModel() throws Exception {
422                    searchBaseModel(0);
423            }
424    
425            protected void searchBaseModel(int initialBaseModelsSearchCount)
426                    throws Exception {
427    
428                    ServiceContext serviceContext =
429                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
430    
431                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
432                            group.getGroupId());
433    
434                    BaseModel<?> parentBaseModel = getParentBaseModel(
435                            group, serviceContext);
436    
437                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
438    
439                    baseModel = addBaseModel(
440                            parentBaseModel, true, RandomTestUtil.randomString(),
441                            serviceContext);
442    
443                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
444            }
445    
446            protected int searchBaseModelsCount(
447                            Class<?> clazz, long groupId, SearchContext searchContext)
448                    throws Exception {
449    
450                    Indexer<?> indexer = IndexerRegistryUtil.getIndexer(clazz);
451    
452                    searchContext.setGroupIds(new long[] {groupId});
453    
454                    Hits results = indexer.search(searchContext);
455    
456                    return results.getLength();
457            }
458    
459            protected int searchBaseModelsCount(SearchContext searchContext)
460                    throws Exception {
461    
462                    return searchBaseModelsCount(
463                            getBaseModelClass(), group.getGroupId(), searchContext);
464            }
465    
466            protected void searchBaseModelWithDelete() throws Exception {
467                    searchBaseModelWithDelete(0);
468            }
469    
470            protected void searchBaseModelWithDelete(int initialBaseModelsSearchCount)
471                    throws Exception {
472    
473                    ServiceContext serviceContext =
474                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
475    
476                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
477                            group.getGroupId());
478    
479                    BaseModel<?> parentBaseModel = getParentBaseModel(
480                            group, serviceContext);
481    
482                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
483    
484                    baseModel = addBaseModel(
485                            parentBaseModel, true, getSearchKeywords(), serviceContext);
486    
487                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
488    
489                    deleteBaseModel(baseModel);
490    
491                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
492            }
493    
494            protected void searchBaseModelWithTrash() throws Exception {
495                    searchBaseModelWithTrash(0);
496            }
497    
498            protected void searchBaseModelWithTrash(int initialBaseModelsSearchCount)
499                    throws Exception {
500    
501                    ServiceContext serviceContext =
502                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
503    
504                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
505                            group.getGroupId());
506    
507                    BaseModel<?> parentBaseModel = getParentBaseModel(
508                            group, serviceContext);
509    
510                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
511    
512                    baseModel = addBaseModel(
513                            parentBaseModel, true, getSearchKeywords(), serviceContext);
514    
515                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
516    
517                    moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
518    
519                    searchContext.setKeywords(getSearchKeywords());
520    
521                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
522            }
523    
524            protected void searchBaseModelWithUpdate() throws Exception {
525                    ServiceContext serviceContext =
526                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
527    
528                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
529                            group.getGroupId());
530    
531                    BaseModel<?> parentBaseModel = getParentBaseModel(
532                            group, serviceContext);
533    
534                    searchContext.setKeywords(getSearchKeywords());
535    
536                    int initialBaseModelsSearchCount = 0;
537    
538                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
539    
540                    baseModel = addBaseModel(
541                            parentBaseModel, true, getSearchKeywords(), serviceContext);
542    
543                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
544    
545                    String updatedKeywords = RandomTestUtil.randomString(
546                            BBCodeRandomizerBumper.INSTANCE);
547    
548                    baseModel = updateBaseModel(baseModel, updatedKeywords, serviceContext);
549    
550                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
551    
552                    searchContext.setKeywords(updatedKeywords);
553    
554                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
555            }
556    
557            protected void searchByDDMStructureField() throws Exception {
558                    ServiceContext serviceContext =
559                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
560    
561                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
562                            group.getGroupId());
563    
564                    int initialBaseModelsSearchCount = 0;
565    
566                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
567    
568                    BaseModel<?> parentBaseModel = getParentBaseModel(
569                            group, serviceContext);
570    
571                    baseModel = addBaseModelWithDDMStructure(
572                            parentBaseModel, getSearchKeywords(), serviceContext);
573    
574                    searchContext.setAttribute(
575                            "ddmStructureFieldName", getDDMStructureFieldName());
576                    searchContext.setAttribute(
577                            "ddmStructureFieldValue", getSearchKeywords());
578    
579                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
580    
581                    updateDDMStructure(serviceContext);
582    
583                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
584            }
585    
586            protected void searchByKeywords() throws Exception {
587                    ServiceContext serviceContext =
588                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
589    
590                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
591                            group.getGroupId());
592    
593                    searchContext.setKeywords(getSearchKeywords());
594    
595                    int initialBaseModelsSearchCount = 0;
596    
597                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
598    
599                    BaseModel<?> parentBaseModel = getParentBaseModel(
600                            group, serviceContext);
601    
602                    baseModel = addBaseModel(
603                            parentBaseModel, true, getSearchKeywords(), serviceContext);
604    
605                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
606            }
607    
608            protected void searchByKeywordsInsideParentBaseModel() throws Exception {
609                    ServiceContext serviceContext =
610                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
611    
612                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
613                            group.getGroupId());
614    
615                    baseModel = addBaseModel(
616                            null, true, getSearchKeywords(), serviceContext);
617    
618                    BaseModel<?> parentBaseModel1 = getParentBaseModel(
619                            group, serviceContext);
620    
621                    searchContext.setFolderIds(
622                            new long[] {(Long)parentBaseModel1.getPrimaryKeyObj()});
623                    searchContext.setKeywords(getSearchKeywords());
624    
625                    int initialBaseModelsSearchCount = 0;
626    
627                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
628    
629                    baseModel = addBaseModel(
630                            parentBaseModel1, true, getSearchKeywords(), serviceContext);
631    
632                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
633    
634                    BaseModel<?> parentBaseModel2 = getParentBaseModel(
635                            parentBaseModel1, serviceContext);
636    
637                    baseModel = addBaseModel(
638                            parentBaseModel2, true, getSearchKeywords(), serviceContext);
639    
640                    assertBaseModelsCount(initialBaseModelsSearchCount + 2, searchContext);
641            }
642    
643            protected void searchByMixedPhraseKeywords() throws Exception {
644                    ServiceContext serviceContext =
645                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
646    
647                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
648                            group.getGroupId());
649    
650                    String keyword1 = getSearchKeywords() + 1;
651                    String keyword2 = getSearchKeywords() + 2;
652                    String keyword3 = getSearchKeywords() + 3;
653                    String keyword4 = getSearchKeywords() + 4;
654                    String keyword5 = getSearchKeywords() + 5;
655                    String keyword6 = getSearchKeywords() + 6;
656                    String keyword7 = getSearchKeywords() + 7;
657    
658                    String combinedKeywords =
659                            keyword1 + " " + keyword2 + " " + keyword3 + " " + keyword4 + " " +
660                                    keyword5 + " " + keyword6 + " " + keyword7;
661    
662                    searchContext.setKeywords(combinedKeywords);
663    
664                    int initialBaseModelsSearchCount = 0;
665    
666                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
667    
668                    BaseModel<?> parentBaseModel = getParentBaseModel(
669                            group, serviceContext);
670    
671                    baseModel = addBaseModel(
672                            parentBaseModel, true, combinedKeywords, serviceContext);
673    
674                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
675    
676                    searchContext = SearchContextTestUtil.getSearchContext(
677                            group.getGroupId());
678    
679                    searchContext.setKeywords("\"" + keyword1 + " " + keyword2 + "\"");
680    
681                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
682    
683                    searchContext = SearchContextTestUtil.getSearchContext(
684                            group.getGroupId());
685    
686                    searchContext.setKeywords("\"" + keyword2 + " " + keyword1 + "\"");
687    
688                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
689    
690                    searchContext = SearchContextTestUtil.getSearchContext(
691                            group.getGroupId());
692    
693                    searchContext.setKeywords("\"" + keyword2 + " " + keyword4 + "\"");
694    
695                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
696    
697                    searchContext = SearchContextTestUtil.getSearchContext(
698                            group.getGroupId());
699    
700                    searchContext.setKeywords(
701                            keyword1 + " \"" + keyword2 + " " + keyword3 + "\"");
702    
703                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
704    
705                    searchContext = SearchContextTestUtil.getSearchContext(
706                            group.getGroupId());
707    
708                    searchContext.setKeywords(
709                            RandomTestUtil.randomString() + " \"" + keyword2 + " " + keyword3 +
710                                    "\"" + " " + keyword5);
711    
712                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
713    
714                    searchContext.setKeywords(
715                            RandomTestUtil.randomString() + " \"" + keyword2 + " " + keyword5 +
716                                    "\"" + " " + RandomTestUtil.randomString());
717    
718                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
719            }
720    
721            protected void searchComments() throws Exception {
722                    ServiceContext serviceContext =
723                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
724    
725                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
726                            group.getGroupId());
727    
728                    searchContext.setIncludeDiscussions(true);
729    
730                    BaseModel<?> parentBaseModel = getParentBaseModel(
731                            group, serviceContext);
732    
733                    int initialBaseModelsSearchCount = 0;
734    
735                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
736    
737                    baseModel = addBaseModel(
738                            parentBaseModel, true, RandomTestUtil.randomString(),
739                            serviceContext);
740    
741                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
742    
743                    addComment(baseModel, getSearchKeywords(), serviceContext);
744    
745                    assertBaseModelsCount(initialBaseModelsSearchCount + 2, searchContext);
746    
747                    moveBaseModelToTrash((Long)baseModel.getPrimaryKeyObj());
748    
749                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
750            }
751    
752            protected void searchExpireVersions(boolean expireAllVersions)
753                    throws Exception {
754    
755                    ServiceContext serviceContext =
756                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
757    
758                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
759                            group.getGroupId());
760    
761                    searchContext.setKeywords(getSearchKeywords());
762    
763                    int initialBaseModelsCount = 0;
764    
765                    assertBaseModelsCount(initialBaseModelsCount, searchContext);
766    
767                    BaseModel<?> parentBaseModel = getParentBaseModel(
768                            group, serviceContext);
769    
770                    baseModel = addBaseModel(
771                            parentBaseModel, true, getSearchKeywords(), serviceContext);
772    
773                    assertBaseModelsCount(initialBaseModelsCount + 1, searchContext);
774    
775                    baseModel = updateBaseModel(baseModel, "liferay", serviceContext);
776    
777                    assertBaseModelsCount(initialBaseModelsCount, searchContext);
778    
779                    expireBaseModelVersions(baseModel, expireAllVersions, serviceContext);
780    
781                    if (expireAllVersions && isExpirableAllVersions()) {
782                            assertBaseModelsCount(initialBaseModelsCount, searchContext);
783                    }
784                    else {
785                            assertBaseModelsCount(initialBaseModelsCount + 1, searchContext);
786                    }
787            }
788    
789            protected long searchGroupEntriesCount(long groupId, long userId)
790                    throws Exception {
791    
792                    return -1;
793            }
794    
795            protected void searchMyEntries() throws Exception {
796                    User user1 = UserTestUtil.addUser(null, 0);
797    
798                    long initialUser1SearchGroupEntriesCount = 0;
799    
800                    assertGroupEntriesCount(initialUser1SearchGroupEntriesCount, user1);
801    
802                    User user2 = UserTestUtil.addUser(null, 0);
803    
804                    long initialUser2SearchGroupEntriesCount = 0;
805    
806                    assertGroupEntriesCount(initialUser2SearchGroupEntriesCount, user2);
807    
808                    ServiceContext serviceContext =
809                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
810    
811                    BaseModel<?> parentBaseModel1 = getParentBaseModel(
812                            group, serviceContext);
813                    BaseModel<?> parentBaseModel2 = getParentBaseModel(
814                            group, serviceContext);
815    
816                    String name = PrincipalThreadLocal.getName();
817    
818                    long userId = serviceContext.getUserId();
819    
820                    try {
821                            PrincipalThreadLocal.setName(user1.getUserId());
822    
823                            serviceContext.setUserId(user1.getUserId());
824    
825                            baseModel = addBaseModel(
826                                    parentBaseModel1, true, RandomTestUtil.randomString(),
827                                    serviceContext);
828                            baseModel = addBaseModel(
829                                    parentBaseModel1, true, RandomTestUtil.randomString(),
830                                    serviceContext);
831                            baseModel = addBaseModel(
832                                    parentBaseModel2, true, RandomTestUtil.randomString(),
833                                    serviceContext);
834    
835                            PrincipalThreadLocal.setName(user2.getUserId());
836    
837                            serviceContext.setUserId(user2.getUserId());
838    
839                            baseModel = addBaseModel(
840                                    parentBaseModel1, true, RandomTestUtil.randomString(),
841                                    serviceContext);
842                            baseModel = addBaseModel(
843                                    parentBaseModel2, true, RandomTestUtil.randomString(),
844                                    serviceContext);
845                    }
846                    finally {
847                            PrincipalThreadLocal.setName(name);
848    
849                            serviceContext.setUserId(userId);
850                    }
851    
852                    assertGroupEntriesCount(initialUser1SearchGroupEntriesCount + 3, user1);
853                    assertGroupEntriesCount(initialUser2SearchGroupEntriesCount + 2, user2);
854    
855                    moveParentBaseModelToTrash((Long)parentBaseModel2.getPrimaryKeyObj());
856    
857                    assertGroupEntriesCount(initialUser1SearchGroupEntriesCount + 2, user1);
858                    assertGroupEntriesCount(initialUser2SearchGroupEntriesCount + 1, user2);
859    
860                    TrashHandler parentTrashHandler =
861                            TrashHandlerRegistryUtil.getTrashHandler(
862                                    getParentBaseModelClassName());
863    
864                    parentTrashHandler.restoreTrashEntry(
865                            user1.getUserId(), (Long)parentBaseModel2.getPrimaryKeyObj());
866    
867                    assertGroupEntriesCount(initialUser1SearchGroupEntriesCount + 3, user1);
868                    assertGroupEntriesCount(initialUser2SearchGroupEntriesCount + 2, user2);
869            }
870    
871            protected void searchRecentEntries() throws Exception {
872                    long initialSearchGroupEntriesCount = 0;
873    
874                    assertGroupEntriesCount(initialSearchGroupEntriesCount);
875    
876                    ServiceContext serviceContext =
877                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
878    
879                    BaseModel<?> parentBaseModel1 = getParentBaseModel(
880                            group, serviceContext);
881                    BaseModel<?> parentBaseModel2 = getParentBaseModel(
882                            group, serviceContext);
883    
884                    String name = PrincipalThreadLocal.getName();
885    
886                    try {
887                            User user1 = UserTestUtil.addUser(null, 0);
888    
889                            PrincipalThreadLocal.setName(user1.getUserId());
890    
891                            baseModel = addBaseModel(
892                                    parentBaseModel1, true, RandomTestUtil.randomString(),
893                                    serviceContext);
894                            baseModel = addBaseModel(
895                                    parentBaseModel1, true, RandomTestUtil.randomString(),
896                                    serviceContext);
897                            baseModel = addBaseModel(
898                                    parentBaseModel2, true, RandomTestUtil.randomString(),
899                                    serviceContext);
900    
901                            User user2 = UserTestUtil.addUser(null, 0);
902    
903                            PrincipalThreadLocal.setName(user2.getUserId());
904    
905                            baseModel = addBaseModel(
906                                    parentBaseModel1, true, RandomTestUtil.randomString(),
907                                    serviceContext);
908                            baseModel = addBaseModel(
909                                    parentBaseModel2, true, RandomTestUtil.randomString(),
910                                    serviceContext);
911                    }
912                    finally {
913                            PrincipalThreadLocal.setName(name);
914                    }
915    
916                    assertGroupEntriesCount(initialSearchGroupEntriesCount + 5);
917    
918                    moveParentBaseModelToTrash((Long)parentBaseModel2.getPrimaryKeyObj());
919    
920                    assertGroupEntriesCount(initialSearchGroupEntriesCount + 3);
921    
922                    TrashHandler parentTrashHandler =
923                            TrashHandlerRegistryUtil.getTrashHandler(
924                                    getParentBaseModelClassName());
925    
926                    parentTrashHandler.restoreTrashEntry(
927                            TestPropsValues.getUserId(),
928                            (Long)parentBaseModel2.getPrimaryKeyObj());
929    
930                    assertGroupEntriesCount(initialSearchGroupEntriesCount + 5);
931            }
932    
933            protected void searchStatus() throws Exception {
934                    ServiceContext serviceContext =
935                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
936    
937                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
938                            group.getGroupId());
939    
940                    int initialBaseModelsCount = 0;
941    
942                    assertBaseModelsCount(initialBaseModelsCount, "1.0", searchContext);
943    
944                    BaseModel<?> parentBaseModel = getParentBaseModel(
945                            group, serviceContext);
946    
947                    baseModel = addBaseModel(
948                            parentBaseModel, false, "Version 1.0", serviceContext);
949    
950                    assertBaseModelsCount(initialBaseModelsCount, searchContext);
951    
952                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
953    
954                    baseModel = updateBaseModel(baseModel, "Version 1.1", serviceContext);
955    
956                    assertBaseModelsCount(initialBaseModelsCount, "1.0", searchContext);
957                    assertBaseModelsCount(initialBaseModelsCount + 1, "1.1", searchContext);
958    
959                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
960    
961                    baseModel = updateBaseModel(baseModel, "Version 1.2", serviceContext);
962    
963                    assertBaseModelsCount(initialBaseModelsCount + 1, "1.1", searchContext);
964                    assertBaseModelsCount(initialBaseModelsCount, "1.2", searchContext);
965    
966                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_PUBLISH);
967    
968                    baseModel = updateBaseModel(baseModel, "Version 1.3", serviceContext);
969    
970                    assertBaseModelsCount(initialBaseModelsCount, "1.2", searchContext);
971                    assertBaseModelsCount(initialBaseModelsCount + 1, "1.3", searchContext);
972            }
973    
974            protected void searchVersions() throws Exception {
975                    ServiceContext serviceContext =
976                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
977    
978                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
979                            group.getGroupId());
980    
981                    searchContext.setKeywords(getSearchKeywords());
982    
983                    int initialBaseModelsCount = 0;
984    
985                    assertBaseModelsCount(initialBaseModelsCount, searchContext);
986    
987                    BaseModel<?> parentBaseModel = getParentBaseModel(
988                            group, serviceContext);
989    
990                    baseModel = addBaseModel(
991                            parentBaseModel, true, getSearchKeywords(), serviceContext);
992    
993                    assertBaseModelsCount(initialBaseModelsCount + 1, searchContext);
994    
995                    baseModel = updateBaseModel(baseModel, "liferay", serviceContext);
996    
997                    assertBaseModelsCount(initialBaseModelsCount, searchContext);
998    
999                    baseModel = updateBaseModel(baseModel, "portal", serviceContext);
1000    
1001                    searchContext.setKeywords("portal");
1002    
1003                    assertBaseModelsCount(initialBaseModelsCount + 1, searchContext);
1004            }
1005    
1006            protected void searchWithinDDMStructure() throws Exception {
1007                    ServiceContext serviceContext =
1008                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
1009    
1010                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
1011                            group.getGroupId());
1012    
1013                    searchContext.setKeywords(getSearchKeywords());
1014    
1015                    int initialBaseModelsSearchCount = 0;
1016    
1017                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
1018    
1019                    BaseModel<?> parentBaseModel = getParentBaseModel(
1020                            group, serviceContext);
1021    
1022                    baseModel = addBaseModelWithDDMStructure(
1023                            parentBaseModel, getSearchKeywords(), serviceContext);
1024    
1025                    assertBaseModelsCount(initialBaseModelsSearchCount + 1, searchContext);
1026            }
1027    
1028            protected void testUserPermissions(
1029                            boolean addBaseModelPermission,
1030                            boolean addParentBaseModelPermission)
1031                    throws Exception {
1032    
1033                    ServiceContext serviceContext =
1034                            ServiceContextTestUtil.getServiceContext(group.getGroupId());
1035    
1036                    SearchContext searchContext = SearchContextTestUtil.getSearchContext(
1037                            group.getGroupId());
1038    
1039                    searchContext.setKeywords(getSearchKeywords());
1040    
1041                    int initialBaseModelsSearchCount = 0;
1042    
1043                    assertBaseModelsCount(initialBaseModelsSearchCount, searchContext);
1044    
1045                    serviceContext.setAddGroupPermissions(addParentBaseModelPermission);
1046                    serviceContext.setAddGuestPermissions(addParentBaseModelPermission);
1047    
1048                    BaseModel<?> parentBaseModel = getParentBaseModel(
1049                            group, serviceContext);
1050    
1051                    serviceContext.setAddGroupPermissions(addBaseModelPermission);
1052                    serviceContext.setAddGuestPermissions(addBaseModelPermission);
1053    
1054                    baseModel = addBaseModel(
1055                            parentBaseModel, true, getSearchKeywords(), serviceContext);
1056    
1057                    User user = UserTestUtil.addUser(null, 0);
1058    
1059                    PermissionChecker originalPermissionChecker =
1060                            PermissionThreadLocal.getPermissionChecker();
1061    
1062                    try {
1063                            PermissionChecker permissionChecker =
1064                                    PermissionCheckerFactoryUtil.create(user);
1065    
1066                            PermissionThreadLocal.setPermissionChecker(permissionChecker);
1067    
1068                            searchContext.setUserId(user.getUserId());
1069    
1070                            int baseModelsCount = initialBaseModelsSearchCount;
1071    
1072                            if (addBaseModelPermission && !isCheckBaseModelPermission()) {
1073                                    baseModelsCount++;
1074                            }
1075    
1076                            assertBaseModelsCount(baseModelsCount, searchContext);
1077                    }
1078                    finally {
1079                            PermissionThreadLocal.setPermissionChecker(
1080                                    originalPermissionChecker);
1081                    }
1082            }
1083    
1084            protected BaseModel<?> updateBaseModel(
1085                            BaseModel<?> baseModel, String keywords,
1086                            ServiceContext serviceContext)
1087                    throws Exception {
1088    
1089                    return baseModel;
1090            }
1091    
1092            protected void updateDDMStructure(ServiceContext serviceContext)
1093                    throws Exception {
1094            }
1095    
1096            protected final boolean CHECK_BASE_MODEL_PERMISSION = true;
1097    
1098            protected BaseModel<?> baseModel;
1099    
1100            @DeleteAfterTestRun
1101            protected Group group;
1102    
1103    }