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.asset.kernel.model.AssetCategory;
018    import com.liferay.asset.kernel.model.AssetEntry;
019    import com.liferay.asset.kernel.model.AssetTag;
020    import com.liferay.asset.kernel.model.AssetVocabulary;
021    import com.liferay.asset.kernel.service.AssetCategoryLocalServiceUtil;
022    import com.liferay.asset.kernel.service.AssetEntryLocalServiceUtil;
023    import com.liferay.asset.kernel.service.AssetTagLocalServiceUtil;
024    import com.liferay.asset.kernel.service.AssetVocabularyLocalServiceUtil;
025    import com.liferay.exportimport.kernel.lar.ExportImportClassedModelUtil;
026    import com.liferay.exportimport.kernel.lar.ExportImportPathUtil;
027    import com.liferay.exportimport.kernel.lar.ExportImportThreadLocal;
028    import com.liferay.exportimport.kernel.lar.PortletDataContext;
029    import com.liferay.exportimport.kernel.lar.PortletDataContextFactoryUtil;
030    import com.liferay.exportimport.kernel.lar.PortletDataHandlerKeys;
031    import com.liferay.exportimport.kernel.lar.StagedModelDataHandler;
032    import com.liferay.exportimport.kernel.lar.StagedModelDataHandlerRegistryUtil;
033    import com.liferay.exportimport.kernel.lar.StagedModelDataHandlerUtil;
034    import com.liferay.exportimport.kernel.lar.UserIdStrategy;
035    import com.liferay.message.boards.kernel.model.MBMessage;
036    import com.liferay.message.boards.kernel.service.MBMessageLocalServiceUtil;
037    import com.liferay.portal.kernel.comment.CommentManagerUtil;
038    import com.liferay.portal.kernel.model.Company;
039    import com.liferay.portal.kernel.model.Group;
040    import com.liferay.portal.kernel.model.StagedGroupedModel;
041    import com.liferay.portal.kernel.model.StagedModel;
042    import com.liferay.portal.kernel.model.User;
043    import com.liferay.portal.kernel.service.CompanyLocalServiceUtil;
044    import com.liferay.portal.kernel.service.GroupLocalServiceUtil;
045    import com.liferay.portal.kernel.service.IdentityServiceContextFunction;
046    import com.liferay.portal.kernel.service.ServiceContext;
047    import com.liferay.portal.kernel.service.ServiceContextThreadLocal;
048    import com.liferay.portal.kernel.test.rule.DeleteAfterTestRun;
049    import com.liferay.portal.kernel.test.util.GroupTestUtil;
050    import com.liferay.portal.kernel.test.util.RandomTestUtil;
051    import com.liferay.portal.kernel.test.util.ServiceContextTestUtil;
052    import com.liferay.portal.kernel.test.util.TestPropsValues;
053    import com.liferay.portal.kernel.util.DateUtil;
054    import com.liferay.portal.kernel.util.ListUtil;
055    import com.liferay.portal.kernel.util.Time;
056    import com.liferay.portal.kernel.workflow.WorkflowConstants;
057    import com.liferay.portal.kernel.xml.Document;
058    import com.liferay.portal.kernel.xml.Element;
059    import com.liferay.portal.kernel.xml.SAXReaderUtil;
060    import com.liferay.portal.kernel.zip.ZipReader;
061    import com.liferay.portal.kernel.zip.ZipReaderFactoryUtil;
062    import com.liferay.portal.kernel.zip.ZipWriter;
063    import com.liferay.portal.kernel.zip.ZipWriterFactoryUtil;
064    import com.liferay.portal.service.test.ServiceTestUtil;
065    import com.liferay.portlet.asset.util.test.AssetTestUtil;
066    import com.liferay.portlet.ratings.util.test.RatingsTestUtil;
067    import com.liferay.ratings.kernel.model.RatingsEntry;
068    import com.liferay.ratings.kernel.service.RatingsEntryLocalServiceUtil;
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 isAssetPrioritySupported() {
574                    return false;
575            }
576    
577            protected boolean isCommentableStagedModel() {
578                    return false;
579            }
580    
581            protected boolean isVersionableStagedModel() {
582                    return false;
583            }
584    
585            protected StagedModel readExportedStagedModel(StagedModel stagedModel) {
586                    String stagedModelPath = ExportImportPathUtil.getModelPath(stagedModel);
587    
588                    StagedModel exportedStagedModel =
589                            (StagedModel)portletDataContext.getZipEntryAsObject(
590                                    stagedModelPath);
591    
592                    return exportedStagedModel;
593            }
594    
595            protected boolean supportLastPublishDateUpdate() {
596                    return false;
597            }
598    
599            protected StagedModelAssets updateAssetEntry(
600                            StagedModel stagedModel, Group group)
601                    throws Exception {
602    
603                    AssetEntry assetEntry = fetchAssetEntry(stagedModel, group);
604    
605                    if (assetEntry == null) {
606                            return null;
607                    }
608    
609                    AssetVocabulary assetVocabulary = AssetTestUtil.addVocabulary(
610                            stagingGroup.getGroupId());
611    
612                    AssetCategory assetCategory = AssetTestUtil.addCategory(
613                            stagingGroup.getGroupId(), assetVocabulary.getVocabularyId());
614    
615                    Company company = CompanyLocalServiceUtil.getCompany(
616                            stagedModel.getCompanyId());
617    
618                    Group companyGroup = company.getGroup();
619    
620                    AssetVocabulary companyAssetVocabulary = AssetTestUtil.addVocabulary(
621                            companyGroup.getGroupId());
622    
623                    AssetCategory companyAssetCategory = AssetTestUtil.addCategory(
624                            companyGroup.getGroupId(),
625                            companyAssetVocabulary.getVocabularyId());
626    
627                    AssetTag assetTag = AssetTestUtil.addTag(stagingGroup.getGroupId());
628    
629                    double assetPriority = assetEntry.getPriority();
630    
631                    if (isAssetPrioritySupported()) {
632                            assetPriority = RandomTestUtil.nextDouble();
633                    }
634    
635                    assetEntry = AssetEntryLocalServiceUtil.updateEntry(
636                            TestPropsValues.getUserId(), stagingGroup.getGroupId(),
637                            assetEntry.getCreateDate(), assetEntry.getModifiedDate(),
638                            assetEntry.getClassName(), assetEntry.getClassPK(),
639                            assetEntry.getClassUuid(), assetEntry.getClassTypeId(),
640                            new long[] {
641                                    assetCategory.getCategoryId(),
642                                    companyAssetCategory.getCategoryId()
643                            },
644                            new String[] {assetTag.getName()}, assetEntry.isListable(),
645                            assetEntry.isVisible(), assetEntry.getStartDate(),
646                            assetEntry.getEndDate(), assetEntry.getPublishDate(),
647                            assetEntry.getExpirationDate(), assetEntry.getMimeType(),
648                            assetEntry.getTitle(), assetEntry.getDescription(),
649                            assetEntry.getSummary(), assetEntry.getUrl(),
650                            assetEntry.getLayoutUuid(), assetEntry.getHeight(),
651                            assetEntry.getWidth(), assetPriority);
652    
653                    return new StagedModelAssets(
654                            assetCategory, assetEntry, assetTag, assetVocabulary);
655            }
656    
657            protected void validateAssets(
658                            StagedModel stagedModel, StagedModelAssets stagedModelAssets,
659                            Group group)
660                    throws Exception {
661    
662                    if (stagedModelAssets == null) {
663                            return;
664                    }
665    
666                    AssetEntry importedAssetEntry = fetchAssetEntry(stagedModel, group);
667    
668                    if (isAssetPrioritySupported()) {
669                            AssetEntry assetEntry = stagedModelAssets.getAssetEntry();
670    
671                            Assert.assertEquals(
672                                    assetEntry.getPriority(), importedAssetEntry.getPriority(), 0D);
673                    }
674    
675                    List<AssetCategory> importedAssetCategories =
676                            AssetCategoryLocalServiceUtil.getEntryCategories(
677                                    importedAssetEntry.getEntryId());
678    
679                    Assert.assertEquals(2, importedAssetCategories.size());
680    
681                    AssetCategory stagedAssetCategory =
682                            stagedModelAssets.getAssetCategory();
683    
684                    AssetCategory importedAssetCategory = null;
685    
686                    Company company = CompanyLocalServiceUtil.getCompany(
687                            group.getCompanyId());
688    
689                    long companyGroupId = company.getGroupId();
690    
691                    for (AssetCategory assetCategory : importedAssetCategories) {
692                            long groupId = assetCategory.getGroupId();
693    
694                            if (groupId != companyGroupId) {
695                                    importedAssetCategory = assetCategory;
696    
697                                    break;
698                            }
699                    }
700    
701                    Assert.assertEquals(
702                            stagedAssetCategory.getUuid(), importedAssetCategory.getUuid());
703    
704                    List<AssetTag> importedAssetTags =
705                            AssetTagLocalServiceUtil.getEntryTags(
706                                    importedAssetEntry.getEntryId());
707    
708                    Assert.assertEquals(1, importedAssetTags.size());
709    
710                    AssetTag assetTag = stagedModelAssets.getAssetTag();
711                    AssetTag importedAssetTag = importedAssetTags.get(0);
712    
713                    Assert.assertEquals(assetTag.getName(), importedAssetTag.getName());
714    
715                    AssetVocabulary assetVocabulary =
716                            stagedModelAssets.getAssetVocabulary();
717                    AssetVocabulary importedAssetVocabulary =
718                            AssetVocabularyLocalServiceUtil.getVocabulary(
719                                    importedAssetCategory.getVocabularyId());
720    
721                    Assert.assertEquals(
722                            assetVocabulary.getUuid(), importedAssetVocabulary.getUuid());
723            }
724    
725            protected void validateComments(
726                            StagedModel stagedModel, StagedModel importedStagedModel,
727                            Group group)
728                    throws Exception {
729    
730                    if (!isCommentableStagedModel()) {
731                            return;
732                    }
733    
734                    List<MBMessage> discussionMBMessages =
735                            MBMessageLocalServiceUtil.getMessages(
736                                    ExportImportClassedModelUtil.getClassName(stagedModel),
737                                    ExportImportClassedModelUtil.getClassPK(stagedModel),
738                                    WorkflowConstants.STATUS_ANY);
739    
740                    if (ListUtil.isEmpty(discussionMBMessages)) {
741                            return;
742                    }
743    
744                    int importedDiscussionMBMessagesCount =
745                            MBMessageLocalServiceUtil.getDiscussionMessagesCount(
746                                    ExportImportClassedModelUtil.getClassName(importedStagedModel),
747                                    ExportImportClassedModelUtil.getClassPK(importedStagedModel),
748                                    WorkflowConstants.STATUS_ANY);
749    
750                    Assert.assertEquals(
751                            discussionMBMessages.size(), importedDiscussionMBMessagesCount + 1);
752    
753                    for (MBMessage discussionMBMessage : discussionMBMessages) {
754                            if (discussionMBMessage.isRoot()) {
755                                    continue;
756                            }
757    
758                            MBMessage importedDiscussionMBMessage =
759                                    MBMessageLocalServiceUtil.fetchMBMessageByUuidAndGroupId(
760                                            discussionMBMessage.getUuid(), group.getGroupId());
761    
762                            Assert.assertNotNull(importedDiscussionMBMessage);
763                    }
764            }
765    
766            protected void validateExport(
767                            PortletDataContext portletDataContext, StagedModel stagedModel,
768                            Map<String, List<StagedModel>> dependentStagedModelsMap)
769                    throws Exception {
770    
771                    Element rootElement = portletDataContext.getExportDataRootElement();
772    
773                    List<Element> stagedModelGroupElements = new ArrayList<>();
774    
775                    Class<?> stagedModelClass = getStagedModelClass();
776    
777                    String stagedModelClassSimpleName = stagedModelClass.getSimpleName();
778    
779                    stagedModelGroupElements.addAll(
780                            rootElement.elements(stagedModelClassSimpleName));
781    
782                    for (String dependentStagedModelClassSimpleName :
783                                    dependentStagedModelsMap.keySet()) {
784    
785                            stagedModelGroupElements.addAll(
786                                    rootElement.elements(dependentStagedModelClassSimpleName));
787                    }
788    
789                    for (Element stagedModelGroupElement : stagedModelGroupElements) {
790                            String className = stagedModelGroupElement.getName();
791    
792                            if (className.equals("missing-references")) {
793                                    continue;
794                            }
795    
796                            List<StagedModel> dependentStagedModels =
797                                    dependentStagedModelsMap.get(className);
798    
799                            if (dependentStagedModels == null) {
800                                    dependentStagedModels = new ArrayList<>();
801                            }
802                            else {
803                                    dependentStagedModels = ListUtil.copy(dependentStagedModels);
804                            }
805    
806                            if (className.equals(stagedModelClassSimpleName)) {
807                                    dependentStagedModels.add(stagedModel);
808                            }
809    
810                            List<Element> elements = stagedModelGroupElement.elements();
811    
812                            Assert.assertEquals(dependentStagedModels.size(), elements.size());
813    
814                            for (Element element : elements) {
815                                    String path = element.attributeValue("path");
816    
817                                    Assert.assertNotNull(path);
818    
819                                    Iterator<StagedModel> iterator =
820                                            dependentStagedModels.iterator();
821    
822                                    while (iterator.hasNext()) {
823                                            StagedModel dependentStagedModel = iterator.next();
824    
825                                            String dependentStagedModelPath =
826                                                    ExportImportPathUtil.getModelPath(dependentStagedModel);
827    
828                                            if (path.equals(dependentStagedModelPath)) {
829                                                    iterator.remove();
830                                            }
831                                    }
832                            }
833    
834                            Assert.assertTrue(
835                                    "There is more than one element exported with the same path",
836                                    dependentStagedModels.isEmpty());
837                    }
838            }
839    
840            protected void validateImport(
841                            Map<String, List<StagedModel>> dependentStagedModelsMap,
842                            Group group)
843                    throws Exception {
844            }
845    
846            protected void validateImport(
847                            StagedModel stagedModel, StagedModelAssets stagedModelAssets,
848                            Map<String, List<StagedModel>> dependentStagedModelsMap,
849                            Group group)
850                    throws Exception {
851    
852                    StagedModel importedStagedModel = getStagedModel(
853                            stagedModel.getUuid(), group);
854    
855                    Assert.assertNotNull(importedStagedModel);
856    
857                    validateAssets(importedStagedModel, stagedModelAssets, group);
858                    validateComments(stagedModel, importedStagedModel, group);
859                    validateImport(dependentStagedModelsMap, group);
860                    validateImportedStagedModel(stagedModel, importedStagedModel);
861                    validateRatings(stagedModel, importedStagedModel);
862            }
863    
864            protected void validateImportedStagedModel(
865                            StagedModel stagedModel, StagedModel importedStagedModel)
866                    throws Exception {
867    
868                    Assert.assertTrue(
869                            stagedModel.getCreateDate() + " " +
870                                    importedStagedModel.getCreateDate(),
871                            DateUtil.equals(
872                                    stagedModel.getCreateDate(),
873                                    importedStagedModel.getCreateDate()));
874                    Assert.assertTrue(
875                            stagedModel.getModifiedDate() + " " +
876                                    importedStagedModel.getModifiedDate(),
877                            DateUtil.equals(
878                                    stagedModel.getModifiedDate(),
879                                    importedStagedModel.getModifiedDate()));
880                    Assert.assertEquals(
881                            stagedModel.getUuid(), importedStagedModel.getUuid());
882            }
883    
884            protected void validateRatings(
885                            StagedModel stagedModel, StagedModel importedStagedModel)
886                    throws Exception {
887    
888                    List<RatingsEntry> ratingsEntries =
889                            RatingsEntryLocalServiceUtil.getEntries(
890                                    ExportImportClassedModelUtil.getClassName(stagedModel),
891                                    ExportImportClassedModelUtil.getClassPK(stagedModel),
892                                    WorkflowConstants.STATUS_ANY);
893    
894                    List<RatingsEntry> importedRatingsEntries =
895                            RatingsEntryLocalServiceUtil.getEntries(
896                                    ExportImportClassedModelUtil.getClassName(importedStagedModel),
897                                    ExportImportClassedModelUtil.getClassPK(importedStagedModel),
898                                    WorkflowConstants.STATUS_ANY);
899    
900                    Assert.assertEquals(
901                            ratingsEntries.size(), importedRatingsEntries.size());
902    
903                    for (RatingsEntry ratingsEntry : ratingsEntries) {
904                            Iterator<RatingsEntry> iterator = importedRatingsEntries.iterator();
905    
906                            while (iterator.hasNext()) {
907                                    RatingsEntry importedRatingsEntry = iterator.next();
908    
909                                    if (ratingsEntry.getScore() ==
910                                                    importedRatingsEntry.getScore()) {
911    
912                                            iterator.remove();
913    
914                                            break;
915                                    }
916                            }
917                    }
918    
919                    Assert.assertTrue(importedRatingsEntries.isEmpty());
920            }
921    
922            @DeleteAfterTestRun
923            protected Group liveGroup;
924    
925            protected Element missingReferencesElement;
926            protected PortletDataContext portletDataContext;
927            protected Element rootElement;
928    
929            @DeleteAfterTestRun
930            protected Group stagingGroup;
931    
932            protected UserIdStrategy userIdStrategy;
933            protected ZipReader zipReader;
934            protected ZipWriter zipWriter;
935    
936            protected class StagedModelAssets implements Serializable {
937    
938                    public StagedModelAssets(
939                            AssetCategory assetCategory, AssetEntry assetEntry,
940                            AssetTag assetTag, AssetVocabulary assetVocabulary) {
941    
942                            _assetCategory = assetCategory;
943                            _assetEntry = assetEntry;
944                            _assetTag = assetTag;
945                            _assetVocabulary = assetVocabulary;
946                    }
947    
948                    public AssetCategory getAssetCategory() {
949                            return _assetCategory;
950                    }
951    
952                    public AssetEntry getAssetEntry() {
953                            return _assetEntry;
954                    }
955    
956                    public AssetTag getAssetTag() {
957                            return _assetTag;
958                    }
959    
960                    public AssetVocabulary getAssetVocabulary() {
961                            return _assetVocabulary;
962                    }
963    
964                    public void setAssetCategory(AssetCategory assetCategory) {
965                            _assetCategory = assetCategory;
966                    }
967    
968                    public void setAssetEntry(AssetEntry assetEntry) {
969                            _assetEntry = assetEntry;
970                    }
971    
972                    public void setAssetTag(AssetTag assetTag) {
973                            _assetTag = assetTag;
974                    }
975    
976                    public void setAssetVocabulary(AssetVocabulary assetVocabulary) {
977                            _assetVocabulary = assetVocabulary;
978                    }
979    
980                    private AssetCategory _assetCategory;
981                    private AssetEntry _assetEntry;
982                    private AssetTag _assetTag;
983                    private AssetVocabulary _assetVocabulary;
984    
985            }
986    
987            protected class TestUserIdStrategy implements UserIdStrategy {
988    
989                    @Override
990                    public long getUserId(String userUuid) {
991                            try {
992                                    return TestPropsValues.getUserId();
993                            }
994                            catch (Exception e) {
995                                    return 0;
996                            }
997                    }
998    
999            }
1000    
1001    }