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 isCommentableStagedModel() {
574 return false;
575 }
576
577 protected boolean isVersionableStagedModel() {
578 return false;
579 }
580
581 protected StagedModel readExportedStagedModel(StagedModel stagedModel) {
582 String stagedModelPath = ExportImportPathUtil.getModelPath(stagedModel);
583
584 StagedModel exportedStagedModel =
585 (StagedModel)portletDataContext.getZipEntryAsObject(
586 stagedModelPath);
587
588 return exportedStagedModel;
589 }
590
591 protected boolean supportLastPublishDateUpdate() {
592 return false;
593 }
594
595 protected StagedModelAssets updateAssetEntry(
596 StagedModel stagedModel, Group group)
597 throws Exception {
598
599 AssetEntry assetEntry = fetchAssetEntry(stagedModel, group);
600
601 if (assetEntry == null) {
602 return null;
603 }
604
605 AssetVocabulary assetVocabulary = AssetTestUtil.addVocabulary(
606 stagingGroup.getGroupId());
607
608 AssetCategory assetCategory = AssetTestUtil.addCategory(
609 stagingGroup.getGroupId(), assetVocabulary.getVocabularyId());
610
611 Company company = CompanyLocalServiceUtil.getCompany(
612 stagedModel.getCompanyId());
613
614 Group companyGroup = company.getGroup();
615
616 AssetVocabulary companyAssetVocabulary = AssetTestUtil.addVocabulary(
617 companyGroup.getGroupId());
618
619 AssetCategory companyAssetCategory = AssetTestUtil.addCategory(
620 companyGroup.getGroupId(),
621 companyAssetVocabulary.getVocabularyId());
622
623 AssetTag assetTag = AssetTestUtil.addTag(stagingGroup.getGroupId());
624
625 AssetEntryLocalServiceUtil.updateEntry(
626 TestPropsValues.getUserId(), stagingGroup.getGroupId(),
627 assetEntry.getClassName(), assetEntry.getClassPK(),
628 new long[] {
629 assetCategory.getCategoryId(),
630 companyAssetCategory.getCategoryId()
631 },
632 new String[] {assetTag.getName()});
633
634 return new StagedModelAssets(assetCategory, assetTag, assetVocabulary);
635 }
636
637 protected void validateAssets(
638 StagedModel stagedModel, StagedModelAssets stagedModelAssets,
639 Group group)
640 throws Exception {
641
642 if (stagedModelAssets == null) {
643 return;
644 }
645
646 AssetEntry assetEntry = fetchAssetEntry(stagedModel, group);
647
648 List<AssetCategory> assetCategories =
649 AssetCategoryLocalServiceUtil.getEntryCategories(
650 assetEntry.getEntryId());
651
652 Assert.assertEquals(2, assetCategories.size());
653
654 AssetCategory stagedAssetCategory =
655 stagedModelAssets.getAssetCategory();
656
657 AssetCategory importedAssetCategory = null;
658
659 Company company = CompanyLocalServiceUtil.getCompany(
660 group.getCompanyId());
661
662 long companyGroupId = company.getGroupId();
663
664 for (AssetCategory assetCategory : assetCategories) {
665 long groupId = assetCategory.getGroupId();
666
667 if (groupId != companyGroupId) {
668 importedAssetCategory = assetCategory;
669
670 break;
671 }
672 }
673
674 Assert.assertEquals(
675 stagedAssetCategory.getUuid(), importedAssetCategory.getUuid());
676
677 List<AssetTag> assetTags = AssetTagLocalServiceUtil.getEntryTags(
678 assetEntry.getEntryId());
679
680 Assert.assertEquals(1, assetTags.size());
681
682 AssetTag assetTag = stagedModelAssets.getAssetTag();
683 AssetTag importedAssetTag = assetTags.get(0);
684
685 Assert.assertEquals(assetTag.getName(), importedAssetTag.getName());
686
687 AssetVocabulary assetVocabulary =
688 stagedModelAssets.getAssetVocabulary();
689 AssetVocabulary importedAssetVocabulary =
690 AssetVocabularyLocalServiceUtil.getVocabulary(
691 importedAssetCategory.getVocabularyId());
692
693 Assert.assertEquals(
694 assetVocabulary.getUuid(), importedAssetVocabulary.getUuid());
695 }
696
697 protected void validateComments(
698 StagedModel stagedModel, StagedModel importedStagedModel,
699 Group group)
700 throws Exception {
701
702 if (!isCommentableStagedModel()) {
703 return;
704 }
705
706 List<MBMessage> discussionMBMessages =
707 MBMessageLocalServiceUtil.getMessages(
708 ExportImportClassedModelUtil.getClassName(stagedModel),
709 ExportImportClassedModelUtil.getClassPK(stagedModel),
710 WorkflowConstants.STATUS_ANY);
711
712 if (ListUtil.isEmpty(discussionMBMessages)) {
713 return;
714 }
715
716 int importedDiscussionMBMessagesCount =
717 MBMessageLocalServiceUtil.getDiscussionMessagesCount(
718 ExportImportClassedModelUtil.getClassName(importedStagedModel),
719 ExportImportClassedModelUtil.getClassPK(importedStagedModel),
720 WorkflowConstants.STATUS_ANY);
721
722 Assert.assertEquals(
723 discussionMBMessages.size(), importedDiscussionMBMessagesCount + 1);
724
725 for (MBMessage discussionMBMessage : discussionMBMessages) {
726 if (discussionMBMessage.isRoot()) {
727 continue;
728 }
729
730 MBMessage importedDiscussionMBMessage =
731 MBMessageLocalServiceUtil.fetchMBMessageByUuidAndGroupId(
732 discussionMBMessage.getUuid(), group.getGroupId());
733
734 Assert.assertNotNull(importedDiscussionMBMessage);
735 }
736 }
737
738 protected void validateExport(
739 PortletDataContext portletDataContext, StagedModel stagedModel,
740 Map<String, List<StagedModel>> dependentStagedModelsMap)
741 throws Exception {
742
743 Element rootElement = portletDataContext.getExportDataRootElement();
744
745 List<Element> stagedModelGroupElements = new ArrayList<>();
746
747 Class<?> stagedModelClass = getStagedModelClass();
748
749 String stagedModelClassSimpleName = stagedModelClass.getSimpleName();
750
751 stagedModelGroupElements.addAll(
752 rootElement.elements(stagedModelClassSimpleName));
753
754 for (String dependentStagedModelClassSimpleName :
755 dependentStagedModelsMap.keySet()) {
756
757 stagedModelGroupElements.addAll(
758 rootElement.elements(dependentStagedModelClassSimpleName));
759 }
760
761 for (Element stagedModelGroupElement : stagedModelGroupElements) {
762 String className = stagedModelGroupElement.getName();
763
764 if (className.equals("missing-references")) {
765 continue;
766 }
767
768 List<StagedModel> dependentStagedModels =
769 dependentStagedModelsMap.get(className);
770
771 if (dependentStagedModels == null) {
772 dependentStagedModels = new ArrayList<>();
773 }
774 else {
775 dependentStagedModels = ListUtil.copy(dependentStagedModels);
776 }
777
778 if (className.equals(stagedModelClassSimpleName)) {
779 dependentStagedModels.add(stagedModel);
780 }
781
782 List<Element> elements = stagedModelGroupElement.elements();
783
784 Assert.assertEquals(dependentStagedModels.size(), elements.size());
785
786 for (Element element : elements) {
787 String path = element.attributeValue("path");
788
789 Assert.assertNotNull(path);
790
791 Iterator<StagedModel> iterator =
792 dependentStagedModels.iterator();
793
794 while (iterator.hasNext()) {
795 StagedModel dependentStagedModel = iterator.next();
796
797 String dependentStagedModelPath =
798 ExportImportPathUtil.getModelPath(dependentStagedModel);
799
800 if (path.equals(dependentStagedModelPath)) {
801 iterator.remove();
802 }
803 }
804 }
805
806 Assert.assertTrue(
807 "There is more than one element exported with the same path",
808 dependentStagedModels.isEmpty());
809 }
810 }
811
812 protected void validateImport(
813 Map<String, List<StagedModel>> dependentStagedModelsMap,
814 Group group)
815 throws Exception {
816 }
817
818 protected void validateImport(
819 StagedModel stagedModel, StagedModelAssets stagedModelAssets,
820 Map<String, List<StagedModel>> dependentStagedModelsMap,
821 Group group)
822 throws Exception {
823
824 StagedModel importedStagedModel = getStagedModel(
825 stagedModel.getUuid(), group);
826
827 Assert.assertNotNull(importedStagedModel);
828
829 validateAssets(importedStagedModel, stagedModelAssets, group);
830 validateComments(stagedModel, importedStagedModel, group);
831 validateImport(dependentStagedModelsMap, group);
832 validateImportedStagedModel(stagedModel, importedStagedModel);
833 validateRatings(stagedModel, importedStagedModel);
834 }
835
836 protected void validateImportedStagedModel(
837 StagedModel stagedModel, StagedModel importedStagedModel)
838 throws Exception {
839
840 Assert.assertTrue(
841 stagedModel.getCreateDate() + " " +
842 importedStagedModel.getCreateDate(),
843 DateUtil.equals(
844 stagedModel.getCreateDate(),
845 importedStagedModel.getCreateDate()));
846 Assert.assertTrue(
847 stagedModel.getModifiedDate() + " " +
848 importedStagedModel.getModifiedDate(),
849 DateUtil.equals(
850 stagedModel.getModifiedDate(),
851 importedStagedModel.getModifiedDate()));
852 Assert.assertEquals(
853 stagedModel.getUuid(), importedStagedModel.getUuid());
854 }
855
856 protected void validateRatings(
857 StagedModel stagedModel, StagedModel importedStagedModel)
858 throws Exception {
859
860 List<RatingsEntry> ratingsEntries =
861 RatingsEntryLocalServiceUtil.getEntries(
862 ExportImportClassedModelUtil.getClassName(stagedModel),
863 ExportImportClassedModelUtil.getClassPK(stagedModel),
864 WorkflowConstants.STATUS_ANY);
865
866 List<RatingsEntry> importedRatingsEntries =
867 RatingsEntryLocalServiceUtil.getEntries(
868 ExportImportClassedModelUtil.getClassName(importedStagedModel),
869 ExportImportClassedModelUtil.getClassPK(importedStagedModel),
870 WorkflowConstants.STATUS_ANY);
871
872 Assert.assertEquals(
873 ratingsEntries.size(), importedRatingsEntries.size());
874
875 for (RatingsEntry ratingsEntry : ratingsEntries) {
876 Iterator<RatingsEntry> iterator = importedRatingsEntries.iterator();
877
878 while (iterator.hasNext()) {
879 RatingsEntry importedRatingsEntry = iterator.next();
880
881 if (ratingsEntry.getScore() ==
882 importedRatingsEntry.getScore()) {
883
884 iterator.remove();
885
886 break;
887 }
888 }
889 }
890
891 Assert.assertTrue(importedRatingsEntries.isEmpty());
892 }
893
894 @DeleteAfterTestRun
895 protected Group liveGroup;
896
897 protected Element missingReferencesElement;
898 protected PortletDataContext portletDataContext;
899 protected Element rootElement;
900
901 @DeleteAfterTestRun
902 protected Group stagingGroup;
903
904 protected UserIdStrategy userIdStrategy;
905 protected ZipReader zipReader;
906 protected ZipWriter zipWriter;
907
908 protected class StagedModelAssets implements Serializable {
909
910 public StagedModelAssets(
911 AssetCategory assetCategory, AssetTag assetTag,
912 AssetVocabulary assetVocabulary) {
913
914 _assetCategory = assetCategory;
915 _assetTag = assetTag;
916 _assetVocabulary = assetVocabulary;
917 }
918
919 public AssetCategory getAssetCategory() {
920 return _assetCategory;
921 }
922
923 public AssetTag getAssetTag() {
924 return _assetTag;
925 }
926
927 public AssetVocabulary getAssetVocabulary() {
928 return _assetVocabulary;
929 }
930
931 public void setAssetCategory(AssetCategory assetCategory) {
932 _assetCategory = assetCategory;
933 }
934
935 public void setAssetTag(AssetTag assetTag) {
936 _assetTag = assetTag;
937 }
938
939 public void setAssetVocabulary(AssetVocabulary assetVocabulary) {
940 _assetVocabulary = assetVocabulary;
941 }
942
943 private AssetCategory _assetCategory;
944 private AssetTag _assetTag;
945 private AssetVocabulary _assetVocabulary;
946
947 }
948
949 protected class TestUserIdStrategy implements UserIdStrategy {
950
951 @Override
952 public long getUserId(String userUuid) {
953 try {
954 return TestPropsValues.getUserId();
955 }
956 catch (Exception e) {
957 return 0;
958 }
959 }
960
961 }
962
963 }