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