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