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