001
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
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
113
114 initExport();
115
116 Map<String, List<StagedModel>> dependentStagedModelsMap =
117 addDependentStagedModelsMap(stagingGroup);
118
119 StagedModel stagedModel = addStagedModel(
120 stagingGroup, dependentStagedModelsMap);
121
122
123
124 addComments(stagedModel);
125
126
127
128 addRatings(stagedModel);
129
130 StagedModelDataHandlerUtil.exportStagedModel(
131 portletDataContext, stagedModel);
132
133 validateExport(
134 portletDataContext, stagedModel, dependentStagedModelsMap);
135
136
137
138 initImport();
139
140 deleteStagedModel(stagedModel, dependentStagedModelsMap, stagingGroup);
141
142
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
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
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
217
218 initExport();
219
220 Map<String, List<StagedModel>> dependentStagedModelsMap =
221 addDependentStagedModelsMap(stagingGroup);
222
223 StagedModel stagedModel = addStagedModel(
224 stagingGroup, dependentStagedModelsMap);
225
226
227
228 StagedModelAssets stagedModelAssets = updateAssetEntry(
229 stagedModel, stagingGroup);
230
231
232
233 addComments(stagedModel);
234
235
236
237 addRatings(stagedModel);
238
239 StagedModelDataHandlerUtil.exportStagedModel(
240 portletDataContext, stagedModel);
241
242 validateExport(
243 portletDataContext, stagedModel, dependentStagedModelsMap);
244
245
246
247 initImport();
248
249
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
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 }