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