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.lar.test;
016    
017    import com.liferay.portal.kernel.comment.CommentManagerUtil;
018    import com.liferay.portal.kernel.test.rule.DeleteAfterTestRun;
019    import com.liferay.portal.kernel.test.util.GroupTestUtil;
020    import com.liferay.portal.kernel.test.util.RandomTestUtil;
021    import com.liferay.portal.kernel.test.util.ServiceContextTestUtil;
022    import com.liferay.portal.kernel.test.util.TestPropsValues;
023    import com.liferay.portal.kernel.util.DateUtil;
024    import com.liferay.portal.kernel.util.ListUtil;
025    import com.liferay.portal.kernel.util.Time;
026    import com.liferay.portal.kernel.workflow.WorkflowConstants;
027    import com.liferay.portal.kernel.xml.Document;
028    import com.liferay.portal.kernel.xml.Element;
029    import com.liferay.portal.kernel.xml.SAXReaderUtil;
030    import com.liferay.portal.kernel.zip.ZipReader;
031    import com.liferay.portal.kernel.zip.ZipReaderFactoryUtil;
032    import com.liferay.portal.kernel.zip.ZipWriter;
033    import com.liferay.portal.kernel.zip.ZipWriterFactoryUtil;
034    import com.liferay.portal.model.Company;
035    import com.liferay.portal.model.Group;
036    import com.liferay.portal.model.StagedGroupedModel;
037    import com.liferay.portal.model.StagedModel;
038    import com.liferay.portal.model.User;
039    import com.liferay.portal.service.CompanyLocalServiceUtil;
040    import com.liferay.portal.service.GroupLocalServiceUtil;
041    import com.liferay.portal.service.IdentityServiceContextFunction;
042    import com.liferay.portal.service.ServiceContext;
043    import com.liferay.portal.service.ServiceContextThreadLocal;
044    import com.liferay.portal.service.test.ServiceTestUtil;
045    import com.liferay.portlet.asset.model.AssetCategory;
046    import com.liferay.portlet.asset.model.AssetEntry;
047    import com.liferay.portlet.asset.model.AssetTag;
048    import com.liferay.portlet.asset.model.AssetVocabulary;
049    import com.liferay.portlet.asset.service.AssetCategoryLocalServiceUtil;
050    import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
051    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
052    import com.liferay.portlet.asset.service.AssetVocabularyLocalServiceUtil;
053    import com.liferay.portlet.asset.util.test.AssetTestUtil;
054    import com.liferay.portlet.exportimport.lar.ExportImportClassedModelUtil;
055    import com.liferay.portlet.exportimport.lar.ExportImportPathUtil;
056    import com.liferay.portlet.exportimport.lar.ExportImportThreadLocal;
057    import com.liferay.portlet.exportimport.lar.PortletDataContext;
058    import com.liferay.portlet.exportimport.lar.PortletDataContextFactoryUtil;
059    import com.liferay.portlet.exportimport.lar.PortletDataHandlerKeys;
060    import com.liferay.portlet.exportimport.lar.StagedModelDataHandler;
061    import com.liferay.portlet.exportimport.lar.StagedModelDataHandlerRegistryUtil;
062    import com.liferay.portlet.exportimport.lar.StagedModelDataHandlerUtil;
063    import com.liferay.portlet.exportimport.lar.UserIdStrategy;
064    import com.liferay.portlet.messageboards.model.MBMessage;
065    import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
066    import com.liferay.portlet.ratings.model.RatingsEntry;
067    import com.liferay.portlet.ratings.service.RatingsEntryLocalServiceUtil;
068    import com.liferay.portlet.ratings.util.test.RatingsTestUtil;
069    
070    import java.io.Serializable;
071    
072    import java.util.ArrayList;
073    import java.util.Date;
074    import java.util.HashMap;
075    import java.util.Iterator;
076    import java.util.LinkedHashMap;
077    import java.util.List;
078    import java.util.Map;
079    
080    import org.junit.After;
081    import org.junit.Assert;
082    import org.junit.Before;
083    import org.junit.Test;
084    
085    /**
086     * @author Daniel Kocsis
087     * @author Mate Thurzo
088     */
089    public abstract class BaseStagedModelDataHandlerTestCase {
090    
091            @Before
092            public void setUp() throws Exception {
093                    liveGroup = GroupTestUtil.addGroup();
094                    stagingGroup = GroupTestUtil.addGroup();
095    
096                    ServiceTestUtil.setUser(TestPropsValues.getUser());
097    
098                    ServiceContext serviceContext =
099                            ServiceContextTestUtil.getServiceContext(stagingGroup.getGroupId());
100    
101                    ServiceContextThreadLocal.pushServiceContext(serviceContext);
102            }
103    
104            @After
105            public void tearDown() throws Exception {
106                    ServiceContextThreadLocal.popServiceContext();
107            }
108    
109            @Test
110            public void testCleanStagedModelDataHandler() throws Exception {
111    
112                    // Export
113    
114                    initExport();
115    
116                    Map<String, List<StagedModel>> dependentStagedModelsMap =
117                            addDependentStagedModelsMap(stagingGroup);
118    
119                    StagedModel stagedModel = addStagedModel(
120                            stagingGroup, dependentStagedModelsMap);
121    
122                    // Comments
123    
124                    addComments(stagedModel);
125    
126                    // Ratings
127    
128                    addRatings(stagedModel);
129    
130                    StagedModelDataHandlerUtil.exportStagedModel(
131                            portletDataContext, stagedModel);
132    
133                    validateExport(
134                            portletDataContext, stagedModel, dependentStagedModelsMap);
135    
136                    // Import
137    
138                    initImport();
139    
140                    deleteStagedModel(stagedModel, dependentStagedModelsMap, stagingGroup);
141    
142                    // Reread the staged model for import from ZIP for true testing
143    
144                    StagedModel exportedStagedModel = readExportedStagedModel(stagedModel);
145    
146                    Assert.assertNotNull(exportedStagedModel);
147    
148                    StagedModelDataHandlerUtil.importStagedModel(
149                            portletDataContext, exportedStagedModel);
150            }
151    
152            public void testLastPublishDate() throws Exception {
153                    if (!supportLastPublishDateUpdate()) {
154                            return;
155                    }
156    
157                    Map<String, List<StagedModel>> dependentStagedModelsMap =
158                            new HashMap<>();
159    
160                    StagedGroupedModel stagedGroupedModel =
161                            (StagedGroupedModel)addStagedModel(
162                                    stagingGroup, dependentStagedModelsMap);
163    
164                    Assert.assertNull(stagedGroupedModel.getLastPublishDate());
165    
166                    initExport();
167    
168                    // Update last publish date
169    
170                    Map<String, String[]> parameterMap =
171                            portletDataContext.getParameterMap();
172    
173                    parameterMap.put(
174                            PortletDataHandlerKeys.UPDATE_LAST_PUBLISH_DATE,
175                            new String[] {Boolean.TRUE.toString()});
176    
177                    try {
178                            ExportImportThreadLocal.setPortletStagingInProcess(true);
179    
180                            StagedModelDataHandlerUtil.exportStagedModel(
181                                    portletDataContext, stagedGroupedModel);
182                    }
183                    finally {
184                            ExportImportThreadLocal.setPortletStagingInProcess(false);
185                    }
186    
187                    Assert.assertEquals(
188                            portletDataContext.getEndDate(),
189                            stagedGroupedModel.getLastPublishDate());
190    
191                    // Do not update last publish date
192    
193                    Date originalLastPublishDate = stagedGroupedModel.getLastPublishDate();
194    
195                    parameterMap.put(
196                            PortletDataHandlerKeys.UPDATE_LAST_PUBLISH_DATE,
197                            new String[] {Boolean.TRUE.toString()});
198    
199                    try {
200                            ExportImportThreadLocal.setPortletStagingInProcess(true);
201    
202                            StagedModelDataHandlerUtil.exportStagedModel(
203                                    portletDataContext, stagedGroupedModel);
204                    }
205                    finally {
206                            ExportImportThreadLocal.setPortletStagingInProcess(false);
207                    }
208    
209                    Assert.assertEquals(
210                            originalLastPublishDate, stagedGroupedModel.getLastPublishDate());
211            }
212    
213            @Test
214            public void testStagedModelDataHandler() throws Exception {
215    
216                    // Export
217    
218                    initExport();
219    
220                    Map<String, List<StagedModel>> dependentStagedModelsMap =
221                            addDependentStagedModelsMap(stagingGroup);
222    
223                    StagedModel stagedModel = addStagedModel(
224                            stagingGroup, dependentStagedModelsMap);
225    
226                    // Assets
227    
228                    StagedModelAssets stagedModelAssets = updateAssetEntry(
229                            stagedModel, stagingGroup);
230    
231                    // Comments
232    
233                    addComments(stagedModel);
234    
235                    // Ratings
236    
237                    addRatings(stagedModel);
238    
239                    StagedModelDataHandlerUtil.exportStagedModel(
240                            portletDataContext, stagedModel);
241    
242                    validateExport(
243                            portletDataContext, stagedModel, dependentStagedModelsMap);
244    
245                    // Import
246    
247                    initImport();
248    
249                    // Reread the staged model for import from ZIP for true testing
250    
251                    StagedModel exportedStagedModel = readExportedStagedModel(stagedModel);
252    
253                    Assert.assertNotNull(exportedStagedModel);
254    
255                    StagedModelDataHandlerUtil.importStagedModel(
256                            portletDataContext, exportedStagedModel);
257    
258                    validateImport(
259                            stagedModel, stagedModelAssets, dependentStagedModelsMap,
260                            liveGroup);
261            }
262    
263            @Test
264            public void testVersioning() throws Exception {
265                    if (!isVersionableStagedModel()) {
266                            return;
267                    }
268    
269                    Map<String, List<StagedModel>> dependentStagedModelsMap =
270                            addDependentStagedModelsMap(stagingGroup);
271    
272                    StagedModel stagedModel = addStagedModel(
273                            stagingGroup, dependentStagedModelsMap);
274    
275                    stagedModel = addVersion(stagedModel);
276    
277                    exportImportStagedModel(stagedModel);
278    
279                    StagedModel importedStagedModel = getStagedModel(
280                            stagedModel.getUuid(), liveGroup);
281    
282                    Assert.assertNotNull(importedStagedModel);
283    
284                    validateImportedStagedModel(stagedModel, importedStagedModel);
285            }
286    
287            @Test
288            public void testVersioning2() throws Exception {
289                    if (!isVersionableStagedModel()) {
290                            return;
291                    }
292    
293                    Map<String, List<StagedModel>> dependentStagedModelsMap =
294                            addDependentStagedModelsMap(stagingGroup);
295    
296                    StagedModel stagedModel = addStagedModel(
297                            stagingGroup, dependentStagedModelsMap);
298    
299                    // Make sure the dates are different
300    
301                    Thread.sleep(4000);
302    
303                    exportImportStagedModel(stagedModel);
304    
305                    StagedModel importedStagedModel = getStagedModel(
306                            stagedModel.getUuid(), liveGroup);
307    
308                    validateImportedStagedModel(stagedModel, importedStagedModel);
309    
310                    stagedModel = addVersion(stagedModel);
311    
312                    exportImportStagedModel(stagedModel);
313    
314                    importedStagedModel = getStagedModel(stagedModel.getUuid(), liveGroup);
315    
316                    validateImportedStagedModel(stagedModel, importedStagedModel);
317            }
318    
319            @Test
320            public void testVersioningExportImportTwice() throws Exception {
321                    if (!isVersionableStagedModel()) {
322                            return;
323                    }
324    
325                    Map<String, List<StagedModel>> dependentStagedModelsMap =
326                            addDependentStagedModelsMap(stagingGroup);
327    
328                    StagedModel stagedModel = addStagedModel(
329                            stagingGroup, dependentStagedModelsMap);
330    
331                    stagedModel = addVersion(stagedModel);
332    
333                    exportImportStagedModel(stagedModel);
334    
335                    StagedModel importedStagedModel = getStagedModel(
336                            stagedModel.getUuid(), liveGroup);
337    
338                    Assert.assertNotNull(importedStagedModel);
339    
340                    validateImportedStagedModel(stagedModel, importedStagedModel);
341    
342                    exportImportStagedModel(stagedModel);
343    
344                    importedStagedModel = getStagedModel(stagedModel.getUuid(), liveGroup);
345    
346                    Assert.assertNotNull(importedStagedModel);
347    
348                    validateImportedStagedModel(stagedModel, importedStagedModel);
349            }
350    
351            protected void addComments(StagedModel stagedModel) throws Exception {
352                    if (!isCommentableStagedModel()) {
353                            return;
354                    }
355    
356                    User user = TestPropsValues.getUser();
357                    String className = ExportImportClassedModelUtil.getClassName(
358                            stagedModel);
359                    long classPK = ExportImportClassedModelUtil.getClassPK(stagedModel);
360    
361                    ServiceContext serviceContext =
362                            ServiceContextTestUtil.getServiceContext(
363                                    stagingGroup.getGroupId(), user.getUserId());
364    
365                    CommentManagerUtil.addComment(
366                            user.getUserId(), stagingGroup.getGroupId(), className, classPK,
367                            user.getFullName(), RandomTestUtil.randomString(),
368                            RandomTestUtil.randomString(50),
369                            new IdentityServiceContextFunction(serviceContext));
370            }
371    
372            protected List<StagedModel> addDependentStagedModel(
373                    Map<String, List<StagedModel>> dependentStagedModelsMap, Class<?> clazz,
374                    StagedModel dependentStagedModel) {
375    
376                    List<StagedModel> dependentStagedModels = dependentStagedModelsMap.get(
377                            clazz.getSimpleName());
378    
379                    if (dependentStagedModels == null) {
380                            dependentStagedModels = new ArrayList<>();
381    
382                            dependentStagedModelsMap.put(
383                                    clazz.getSimpleName(), dependentStagedModels);
384                    }
385    
386                    dependentStagedModels.add(dependentStagedModel);
387    
388                    return dependentStagedModels;
389            }
390    
391            protected Map<String, List<StagedModel>> addDependentStagedModelsMap(
392                            Group group)
393                    throws Exception {
394    
395                    return new HashMap<>();
396            }
397    
398            protected void addRatings(StagedModel stagedModel) throws Exception {
399                    RatingsTestUtil.addEntry(
400                            ExportImportClassedModelUtil.getClassName(stagedModel),
401                            ExportImportClassedModelUtil.getClassPK(stagedModel));
402            }
403    
404            protected abstract StagedModel addStagedModel(
405                            Group group,
406                            Map<String, List<StagedModel>> dependentStagedModelsMap)
407                    throws Exception;
408    
409            protected StagedModel addVersion(StagedModel stagedModel) throws Exception {
410                    return null;
411            }
412    
413            protected void deleteStagedModel(
414                            StagedModel stagedModel,
415                            Map<String, List<StagedModel>> dependentStagedModelsMap,
416                            Group group)
417                    throws Exception {
418    
419                    @SuppressWarnings("rawtypes")
420                    StagedModelDataHandler stagedModelDataHandler =
421                            StagedModelDataHandlerRegistryUtil.getStagedModelDataHandler(
422                                    ExportImportClassedModelUtil.getClassName(stagedModel));
423    
424                    stagedModelDataHandler.deleteStagedModel(stagedModel);
425    
426                    for (List<StagedModel> dependentStagedModels :
427                                    dependentStagedModelsMap.values()) {
428    
429                            for (StagedModel dependentStagedModel : dependentStagedModels) {
430                                    stagedModelDataHandler =
431                                            StagedModelDataHandlerRegistryUtil.
432                                                    getStagedModelDataHandler(
433                                                            ExportImportClassedModelUtil.getClassName(
434                                                                    dependentStagedModel));
435    
436                                    stagedModelDataHandler.deleteStagedModel(dependentStagedModel);
437                            }
438                    }
439            }
440    
441            protected void exportImportStagedModel(StagedModel stagedModel)
442                    throws Exception {
443    
444                    initExport();
445    
446                    StagedModelDataHandlerUtil.exportStagedModel(
447                            portletDataContext, stagedModel);
448    
449                    initImport();
450    
451                    StagedModel exportedStagedModel = readExportedStagedModel(stagedModel);
452    
453                    Assert.assertNotNull(exportedStagedModel);
454    
455                    StagedModelDataHandlerUtil.importStagedModel(
456                            portletDataContext, exportedStagedModel);
457            }
458    
459            protected AssetEntry fetchAssetEntry(StagedModel stagedModel, Group group)
460                    throws Exception {
461    
462                    return AssetEntryLocalServiceUtil.fetchEntry(
463                            group.getGroupId(), stagedModel.getUuid());
464            }
465    
466            protected Date getEndDate() {
467                    return new Date();
468            }
469    
470            protected Map<String, String[]> getParameterMap() {
471                    Map<String, String[]> parameterMap = new LinkedHashMap<>();
472    
473                    parameterMap.put(
474                            PortletDataHandlerKeys.DATA_STRATEGY,
475                            new String[] {
476                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE
477                            });
478                    parameterMap.put(
479                            PortletDataHandlerKeys.IGNORE_LAST_PUBLISH_DATE,
480                            new String[] {Boolean.TRUE.toString()});
481                    parameterMap.put(
482                            PortletDataHandlerKeys.PORTLET_CONFIGURATION,
483                            new String[] {Boolean.TRUE.toString()});
484                    parameterMap.put(
485                            PortletDataHandlerKeys.PORTLET_CONFIGURATION_ALL,
486                            new String[] {Boolean.TRUE.toString()});
487                    parameterMap.put(
488                            PortletDataHandlerKeys.PORTLET_DATA,
489                            new String[] {Boolean.TRUE.toString()});
490                    parameterMap.put(
491                            PortletDataHandlerKeys.PORTLET_DATA_ALL,
492                            new String[] {Boolean.TRUE.toString()});
493                    parameterMap.put(
494                            PortletDataHandlerKeys.PORTLET_SETUP_ALL,
495                            new String[] {Boolean.TRUE.toString()});
496    
497                    return parameterMap;
498            }
499    
500            protected abstract StagedModel getStagedModel(String uuid, Group group);
501    
502            protected abstract Class<? extends StagedModel> getStagedModelClass();
503    
504            protected Date getStartDate() {
505                    return new Date(System.currentTimeMillis() - Time.HOUR);
506            }
507    
508            protected void initExport() throws Exception {
509                    zipWriter = ZipWriterFactoryUtil.getZipWriter();
510    
511                    portletDataContext =
512                            PortletDataContextFactoryUtil.createExportPortletDataContext(
513                                    stagingGroup.getCompanyId(), stagingGroup.getGroupId(),
514                                    getParameterMap(), getStartDate(), getEndDate(), zipWriter);
515    
516                    rootElement = SAXReaderUtil.createElement("root");
517    
518                    portletDataContext.setExportDataRootElement(rootElement);
519    
520                    missingReferencesElement = rootElement.addElement("missing-references");
521    
522                    portletDataContext.setMissingReferencesElement(
523                            missingReferencesElement);
524            }
525    
526            protected void initImport() throws Exception {
527                    userIdStrategy = new TestUserIdStrategy();
528    
529                    zipReader = ZipReaderFactoryUtil.getZipReader(zipWriter.getFile());
530    
531                    String xml = zipReader.getEntryAsString("/manifest.xml");
532    
533                    if (xml == null) {
534                            Document document = SAXReaderUtil.createDocument();
535    
536                            Element rootElement = document.addElement("root");
537    
538                            rootElement.addElement("header");
539    
540                            zipWriter.addEntry("/manifest.xml", document.asXML());
541    
542                            zipReader = ZipReaderFactoryUtil.getZipReader(zipWriter.getFile());
543                    }
544    
545                    portletDataContext =
546                            PortletDataContextFactoryUtil.createImportPortletDataContext(
547                                    liveGroup.getCompanyId(), liveGroup.getGroupId(),
548                                    getParameterMap(), userIdStrategy, zipReader);
549    
550                    portletDataContext.setImportDataRootElement(rootElement);
551    
552                    Element missingReferencesElement = rootElement.element(
553                            "missing-references");
554    
555                    if (missingReferencesElement == null) {
556                            missingReferencesElement = rootElement.addElement(
557                                    "missing-references");
558                    }
559    
560                    portletDataContext.setMissingReferencesElement(
561                            missingReferencesElement);
562    
563                    Group sourceCompanyGroup = GroupLocalServiceUtil.getCompanyGroup(
564                            stagingGroup.getCompanyId());
565    
566                    portletDataContext.setSourceCompanyGroupId(
567                            sourceCompanyGroup.getGroupId());
568    
569                    portletDataContext.setSourceCompanyId(stagingGroup.getCompanyId());
570                    portletDataContext.setSourceGroupId(stagingGroup.getGroupId());
571            }
572    
573            protected boolean isCommentableStagedModel() {
574                    return false;
575            }
576    
577            protected boolean isVersionableStagedModel() {
578                    return false;
579            }
580    
581            protected StagedModel readExportedStagedModel(StagedModel stagedModel) {
582                    String stagedModelPath = ExportImportPathUtil.getModelPath(stagedModel);
583    
584                    StagedModel exportedStagedModel =
585                            (StagedModel)portletDataContext.getZipEntryAsObject(
586                                    stagedModelPath);
587    
588                    return exportedStagedModel;
589            }
590    
591            protected boolean supportLastPublishDateUpdate() {
592                    return false;
593            }
594    
595            protected StagedModelAssets updateAssetEntry(
596                            StagedModel stagedModel, Group group)
597                    throws Exception {
598    
599                    AssetEntry assetEntry = fetchAssetEntry(stagedModel, group);
600    
601                    if (assetEntry == null) {
602                            return null;
603                    }
604    
605                    AssetVocabulary assetVocabulary = AssetTestUtil.addVocabulary(
606                            stagingGroup.getGroupId());
607    
608                    AssetCategory assetCategory = AssetTestUtil.addCategory(
609                            stagingGroup.getGroupId(), assetVocabulary.getVocabularyId());
610    
611                    Company company = CompanyLocalServiceUtil.getCompany(
612                            stagedModel.getCompanyId());
613    
614                    Group companyGroup = company.getGroup();
615    
616                    AssetVocabulary companyAssetVocabulary = AssetTestUtil.addVocabulary(
617                            companyGroup.getGroupId());
618    
619                    AssetCategory companyAssetCategory = AssetTestUtil.addCategory(
620                            companyGroup.getGroupId(),
621                            companyAssetVocabulary.getVocabularyId());
622    
623                    AssetTag assetTag = AssetTestUtil.addTag(stagingGroup.getGroupId());
624    
625                    AssetEntryLocalServiceUtil.updateEntry(
626                            TestPropsValues.getUserId(), stagingGroup.getGroupId(),
627                            assetEntry.getClassName(), assetEntry.getClassPK(),
628                            new long[] {
629                                    assetCategory.getCategoryId(),
630                                    companyAssetCategory.getCategoryId()
631                            },
632                            new String[] {assetTag.getName()});
633    
634                    return new StagedModelAssets(assetCategory, assetTag, assetVocabulary);
635            }
636    
637            protected void validateAssets(
638                            StagedModel stagedModel, StagedModelAssets stagedModelAssets,
639                            Group group)
640                    throws Exception {
641    
642                    if (stagedModelAssets == null) {
643                            return;
644                    }
645    
646                    AssetEntry assetEntry = fetchAssetEntry(stagedModel, group);
647    
648                    List<AssetCategory> assetCategories =
649                            AssetCategoryLocalServiceUtil.getEntryCategories(
650                                    assetEntry.getEntryId());
651    
652                    Assert.assertEquals(2, assetCategories.size());
653    
654                    AssetCategory stagedAssetCategory =
655                            stagedModelAssets.getAssetCategory();
656    
657                    AssetCategory importedAssetCategory = null;
658    
659                    Company company = CompanyLocalServiceUtil.getCompany(
660                            group.getCompanyId());
661    
662                    long companyGroupId = company.getGroupId();
663    
664                    for (AssetCategory assetCategory : assetCategories) {
665                            long groupId = assetCategory.getGroupId();
666    
667                            if (groupId != companyGroupId) {
668                                    importedAssetCategory = assetCategory;
669    
670                                    break;
671                            }
672                    }
673    
674                    Assert.assertEquals(
675                            stagedAssetCategory.getUuid(), importedAssetCategory.getUuid());
676    
677                    List<AssetTag> assetTags = AssetTagLocalServiceUtil.getEntryTags(
678                            assetEntry.getEntryId());
679    
680                    Assert.assertEquals(1, assetTags.size());
681    
682                    AssetTag assetTag = stagedModelAssets.getAssetTag();
683                    AssetTag importedAssetTag = assetTags.get(0);
684    
685                    Assert.assertEquals(assetTag.getName(), importedAssetTag.getName());
686    
687                    AssetVocabulary assetVocabulary =
688                            stagedModelAssets.getAssetVocabulary();
689                    AssetVocabulary importedAssetVocabulary =
690                            AssetVocabularyLocalServiceUtil.getVocabulary(
691                                    importedAssetCategory.getVocabularyId());
692    
693                    Assert.assertEquals(
694                            assetVocabulary.getUuid(), importedAssetVocabulary.getUuid());
695            }
696    
697            protected void validateComments(
698                            StagedModel stagedModel, StagedModel importedStagedModel,
699                            Group group)
700                    throws Exception {
701    
702                    if (!isCommentableStagedModel()) {
703                            return;
704                    }
705    
706                    List<MBMessage> discussionMBMessages =
707                            MBMessageLocalServiceUtil.getMessages(
708                                    ExportImportClassedModelUtil.getClassName(stagedModel),
709                                    ExportImportClassedModelUtil.getClassPK(stagedModel),
710                                    WorkflowConstants.STATUS_ANY);
711    
712                    if (ListUtil.isEmpty(discussionMBMessages)) {
713                            return;
714                    }
715    
716                    int importedDiscussionMBMessagesCount =
717                            MBMessageLocalServiceUtil.getDiscussionMessagesCount(
718                                    ExportImportClassedModelUtil.getClassName(importedStagedModel),
719                                    ExportImportClassedModelUtil.getClassPK(importedStagedModel),
720                                    WorkflowConstants.STATUS_ANY);
721    
722                    Assert.assertEquals(
723                            discussionMBMessages.size(), importedDiscussionMBMessagesCount + 1);
724    
725                    for (MBMessage discussionMBMessage : discussionMBMessages) {
726                            if (discussionMBMessage.isRoot()) {
727                                    continue;
728                            }
729    
730                            MBMessage importedDiscussionMBMessage =
731                                    MBMessageLocalServiceUtil.fetchMBMessageByUuidAndGroupId(
732                                            discussionMBMessage.getUuid(), group.getGroupId());
733    
734                            Assert.assertNotNull(importedDiscussionMBMessage);
735                    }
736            }
737    
738            protected void validateExport(
739                            PortletDataContext portletDataContext, StagedModel stagedModel,
740                            Map<String, List<StagedModel>> dependentStagedModelsMap)
741                    throws Exception {
742    
743                    Element rootElement = portletDataContext.getExportDataRootElement();
744    
745                    List<Element> stagedModelGroupElements = new ArrayList<>();
746    
747                    Class<?> stagedModelClass = getStagedModelClass();
748    
749                    String stagedModelClassSimpleName = stagedModelClass.getSimpleName();
750    
751                    stagedModelGroupElements.addAll(
752                            rootElement.elements(stagedModelClassSimpleName));
753    
754                    for (String dependentStagedModelClassSimpleName :
755                                    dependentStagedModelsMap.keySet()) {
756    
757                            stagedModelGroupElements.addAll(
758                                    rootElement.elements(dependentStagedModelClassSimpleName));
759                    }
760    
761                    for (Element stagedModelGroupElement : stagedModelGroupElements) {
762                            String className = stagedModelGroupElement.getName();
763    
764                            if (className.equals("missing-references")) {
765                                    continue;
766                            }
767    
768                            List<StagedModel> dependentStagedModels =
769                                    dependentStagedModelsMap.get(className);
770    
771                            if (dependentStagedModels == null) {
772                                    dependentStagedModels = new ArrayList<>();
773                            }
774                            else {
775                                    dependentStagedModels = ListUtil.copy(dependentStagedModels);
776                            }
777    
778                            if (className.equals(stagedModelClassSimpleName)) {
779                                    dependentStagedModels.add(stagedModel);
780                            }
781    
782                            List<Element> elements = stagedModelGroupElement.elements();
783    
784                            Assert.assertEquals(dependentStagedModels.size(), elements.size());
785    
786                            for (Element element : elements) {
787                                    String path = element.attributeValue("path");
788    
789                                    Assert.assertNotNull(path);
790    
791                                    Iterator<StagedModel> iterator =
792                                            dependentStagedModels.iterator();
793    
794                                    while (iterator.hasNext()) {
795                                            StagedModel dependentStagedModel = iterator.next();
796    
797                                            String dependentStagedModelPath =
798                                                    ExportImportPathUtil.getModelPath(dependentStagedModel);
799    
800                                            if (path.equals(dependentStagedModelPath)) {
801                                                    iterator.remove();
802                                            }
803                                    }
804                            }
805    
806                            Assert.assertTrue(
807                                    "There is more than one element exported with the same path",
808                                    dependentStagedModels.isEmpty());
809                    }
810            }
811    
812            protected void validateImport(
813                            Map<String, List<StagedModel>> dependentStagedModelsMap,
814                            Group group)
815                    throws Exception {
816            }
817    
818            protected void validateImport(
819                            StagedModel stagedModel, StagedModelAssets stagedModelAssets,
820                            Map<String, List<StagedModel>> dependentStagedModelsMap,
821                            Group group)
822                    throws Exception {
823    
824                    StagedModel importedStagedModel = getStagedModel(
825                            stagedModel.getUuid(), group);
826    
827                    Assert.assertNotNull(importedStagedModel);
828    
829                    validateAssets(importedStagedModel, stagedModelAssets, group);
830                    validateComments(stagedModel, importedStagedModel, group);
831                    validateImport(dependentStagedModelsMap, group);
832                    validateImportedStagedModel(stagedModel, importedStagedModel);
833                    validateRatings(stagedModel, importedStagedModel);
834            }
835    
836            protected void validateImportedStagedModel(
837                            StagedModel stagedModel, StagedModel importedStagedModel)
838                    throws Exception {
839    
840                    Assert.assertTrue(
841                            stagedModel.getCreateDate() + " " +
842                                    importedStagedModel.getCreateDate(),
843                            DateUtil.equals(
844                                    stagedModel.getCreateDate(),
845                                    importedStagedModel.getCreateDate()));
846                    Assert.assertTrue(
847                            stagedModel.getModifiedDate() + " " +
848                                    importedStagedModel.getModifiedDate(),
849                            DateUtil.equals(
850                                    stagedModel.getModifiedDate(),
851                                    importedStagedModel.getModifiedDate()));
852                    Assert.assertEquals(
853                            stagedModel.getUuid(), importedStagedModel.getUuid());
854            }
855    
856            protected void validateRatings(
857                            StagedModel stagedModel, StagedModel importedStagedModel)
858                    throws Exception {
859    
860                    List<RatingsEntry> ratingsEntries =
861                            RatingsEntryLocalServiceUtil.getEntries(
862                                    ExportImportClassedModelUtil.getClassName(stagedModel),
863                                    ExportImportClassedModelUtil.getClassPK(stagedModel),
864                                    WorkflowConstants.STATUS_ANY);
865    
866                    List<RatingsEntry> importedRatingsEntries =
867                            RatingsEntryLocalServiceUtil.getEntries(
868                                    ExportImportClassedModelUtil.getClassName(importedStagedModel),
869                                    ExportImportClassedModelUtil.getClassPK(importedStagedModel),
870                                    WorkflowConstants.STATUS_ANY);
871    
872                    Assert.assertEquals(
873                            ratingsEntries.size(), importedRatingsEntries.size());
874    
875                    for (RatingsEntry ratingsEntry : ratingsEntries) {
876                            Iterator<RatingsEntry> iterator = importedRatingsEntries.iterator();
877    
878                            while (iterator.hasNext()) {
879                                    RatingsEntry importedRatingsEntry = iterator.next();
880    
881                                    if (ratingsEntry.getScore() ==
882                                                    importedRatingsEntry.getScore()) {
883    
884                                            iterator.remove();
885    
886                                            break;
887                                    }
888                            }
889                    }
890    
891                    Assert.assertTrue(importedRatingsEntries.isEmpty());
892            }
893    
894            @DeleteAfterTestRun
895            protected Group liveGroup;
896    
897            protected Element missingReferencesElement;
898            protected PortletDataContext portletDataContext;
899            protected Element rootElement;
900    
901            @DeleteAfterTestRun
902            protected Group stagingGroup;
903    
904            protected UserIdStrategy userIdStrategy;
905            protected ZipReader zipReader;
906            protected ZipWriter zipWriter;
907    
908            protected class StagedModelAssets implements Serializable {
909    
910                    public StagedModelAssets(
911                            AssetCategory assetCategory, AssetTag assetTag,
912                            AssetVocabulary assetVocabulary) {
913    
914                            _assetCategory = assetCategory;
915                            _assetTag = assetTag;
916                            _assetVocabulary = assetVocabulary;
917                    }
918    
919                    public AssetCategory getAssetCategory() {
920                            return _assetCategory;
921                    }
922    
923                    public AssetTag getAssetTag() {
924                            return _assetTag;
925                    }
926    
927                    public AssetVocabulary getAssetVocabulary() {
928                            return _assetVocabulary;
929                    }
930    
931                    public void setAssetCategory(AssetCategory assetCategory) {
932                            _assetCategory = assetCategory;
933                    }
934    
935                    public void setAssetTag(AssetTag assetTag) {
936                            _assetTag = assetTag;
937                    }
938    
939                    public void setAssetVocabulary(AssetVocabulary assetVocabulary) {
940                            _assetVocabulary = assetVocabulary;
941                    }
942    
943                    private AssetCategory _assetCategory;
944                    private AssetTag _assetTag;
945                    private AssetVocabulary _assetVocabulary;
946    
947            }
948    
949            protected class TestUserIdStrategy implements UserIdStrategy {
950    
951                    @Override
952                    public long getUserId(String userUuid) {
953                            try {
954                                    return TestPropsValues.getUserId();
955                            }
956                            catch (Exception e) {
957                                    return 0;
958                            }
959                    }
960    
961            }
962    
963    }