/** Test check if Overwriting of unique key attribute cache is working */ @Test public void testOverwriteUniqueKeyAttributeCache() { final ComposedType priceRowComposedTypeSpy = Mockito.spy(TypeManager.getInstance().getComposedType(PriceRow.class)); final CatalogManager catalogManager = CatalogManager.getInstance(); final Map args = new HashMap(); args.put(CatalogVersionSyncJob.CODE, "foo"); args.put(CatalogVersionSyncJob.SOURCEVERSION, srcCatalogVersion); args.put(CatalogVersionSyncJob.TARGETVERSION, tgtCatalogVersion); args.put(CatalogVersionSyncJob.MAXTHREADS, Integer.valueOf(1)); final CatalogVersionSyncJob job = catalogManager.createCatalogVersionSyncJob(args); final CatalogVersionSyncCronJob cjob = (CatalogVersionSyncCronJob) job.newExecution(); ctx = Mockito.spy(new CatalogVersionSyncCopyContext(job, cjob, null)); Mockito.when(priceRowComposedTypeSpy.getAttributeDescriptorsIncludingPrivate()) .thenReturn(Collections.EMPTY_SET); Mockito.when(priceRowSpy.getComposedType()).thenReturn(priceRowComposedTypeSpy); ctx.queryNonCatalogItemCopy(priceRowSpy); ctx.queryCatalogItemCopy(priceRowSpy); }
@Test public void testSpringCreation() throws JaloInvalidParameterException, JaloDuplicateCodeException, JaloGenericCreationException, JaloAbstractTypeException { final ComposedType unitType = TypeManager.getInstance().getComposedType(Unit.class); final ComposedType ct = TypeManager.getInstance().createComposedType(unitType, "MyUnit"); ct.setJaloClass(MyUnit.class); final Map<String, Object> params = new HashMap<String, Object>(); params.put(Unit.CODE, "code"); params.put(Unit.UNITTYPE, "type"); final MyUnit u = (MyUnit) ct.newInstance(params); assertEquals("<code>", u.getCode()); assertEquals("type", u.getUnitType()); assertTrue(u instanceof MySpringUnit); params.clear(); params.put(Unit.CODE, "code2"); params.put(Unit.UNITTYPE, "type"); final Unit controlUnit = (Unit) unitType.newInstance(params); assertEquals("code2", controlUnit.getCode()); assertEquals("type", controlUnit.getUnitType()); assertFalse(controlUnit instanceof MyUnit); }
private Product createProduct(final String code, final ComposedType composedType) throws JaloGenericCreationException, JaloAbstractTypeException { final Map args = new HashMap(); args.put(Product.CODE, code); args.put(CatalogConstants.Attributes.Product.CATALOGVERSION, srcCatalogVersion); return (Product) composedType.newInstance(args); }
@SuppressWarnings("deprecation") protected static SyncItemJob setupStoreTemplateSyncJobs( final CatalogVersionSyncJobModel syncJobModel, final ModelService modelService) { // configure root types final SyncItemJob syncJob = modelService.getSource(syncJobModel); if (syncJob == null) { LOG.warn( "Could not setup catalog version synchronization job. Reason: Synchronization job not found."); } else { final List<ComposedType> rootTypes = new ArrayList<ComposedType>(2); final ComposedType cmsItemType = TypeManager.getInstance().getComposedType(Cms2Constants.TC.CMSITEM); rootTypes.add(cmsItemType); rootTypes.add(TypeManager.getInstance().getComposedType(Cms2Constants.TC.CMSRELATION)); rootTypes.add(TypeManager.getInstance().getComposedType(Media.class)); syncJob.setRootTypes(JaloSession.getCurrentSession().getSessionContext(), rootTypes); syncJob.setSyncLanguages( JaloSession.getCurrentSession().getSessionContext(), C2LManager.getInstance().getAllLanguages()); final Collection<SyncAttributeDescriptorConfig> syncAttributeConfigs = syncJob.getSyncAttributeConfigurations(); for (final SyncAttributeDescriptorConfig syncAttributeDescriptorConfig : syncAttributeConfigs) { final Type attributeType = syncAttributeDescriptorConfig.getAttributeDescriptor().getAttributeType(); if ((syncAttributeDescriptorConfig .getAttributeDescriptor() .getEnclosingType() .isAssignableFrom(cmsItemType) && cmsItemType.isAssignableFrom(attributeType)) || ((attributeType instanceof CollectionType) && cmsItemType.isAssignableFrom( ((CollectionType) attributeType).getElementType()))) { syncAttributeDescriptorConfig.setCopyByValue(true); } } } return syncJob; }
@Test public void testExclusiveSync() { assertNull(catalogManager.getCounterpartItem(product1, tgt)); assertNull(catalogManager.getCounterpartItem(product2, tgt)); assertNull(catalogManager.getCounterpartItem(product3, tgt)); final ComposedType pType = TypeManager.getInstance().getComposedType(Product.class); final AttributeDescriptor nameAd = pType.getAttributeDescriptorIncludingPrivate(Product.NAME); final AttributeDescriptor unitAd = pType.getAttributeDescriptorIncludingPrivate(Product.UNIT); final int threads = CatalogVersionSyncJob.getDefaultMaxThreads(jaloSession.getTenant()) * 2; final CatalogVersionSyncJob exclJob1 = createSyncJob("excl1", src, tgt, threads, true); exclJob1.setCreateNewItems(false); // don't create new items in full sync SyncAttributeDescriptorConfig nameCfg = exclJob1.getConfigFor(nameAd, true); nameCfg.setIncludedInSync(true); // +name SyncAttributeDescriptorConfig unitCfg = exclJob1.getConfigFor(unitAd, true); unitCfg.setIncludedInSync(false); // -unit final CatalogVersionSyncJob exclJob2 = createSyncJob("excl2", src, tgt, threads, true); exclJob2.setCreateNewItems(true); // don't create new items in full sync nameCfg = exclJob2.getConfigFor(nameAd, true); nameCfg.setIncludedInSync(false); // -name unitCfg = exclJob2.getConfigFor(unitAd, true); unitCfg.setIncludedInSync(true); // +unit // 1. run job1 -> no item should be copied final CatalogVersionSyncCronJob run1 = (CatalogVersionSyncCronJob) exclJob1.newExecution(); exclJob1.configureFullVersionSync(run1); exclJob1.perform(run1, true); assertEquals(run1.getResult(), run1.getSuccessResult()); assertNull(catalogManager.getCounterpartItem(product1, tgt)); assertNull(catalogManager.getCounterpartItem(product2, tgt)); assertNull(catalogManager.getCounterpartItem(product3, tgt)); assertNull(catalogManager.getSynchronizedCopy(product1, exclJob1)); assertNull(catalogManager.getSynchronizedCopy(product2, exclJob1)); assertNull(catalogManager.getSynchronizedCopy(product3, exclJob1)); // 2. run job2 -> now all products should be copied -> without name final CatalogVersionSyncCronJob run2 = (CatalogVersionSyncCronJob) exclJob2.newExecution(); exclJob2.configureFullVersionSync(run2); exclJob2.perform(run2, true); assertEquals(run2.getResult(), run2.getSuccessResult()); Product p1tgt = (Product) catalogManager.getSynchronizedCopy(product1, exclJob2); Product p2tgt = (Product) catalogManager.getSynchronizedCopy(product2, exclJob2); Product p3tgt = (Product) catalogManager.getSynchronizedCopy(product3, exclJob2); assertNotNull(p1tgt); assertNotNull(p2tgt); assertNotNull(p3tgt); assertNotSame(product1, p1tgt); assertNotSame(product2, p2tgt); assertNotSame(product3, p3tgt); assertEquals(product1.getCode(), p1tgt.getCode()); assertEquals(product1.getUnit(), p1tgt.getUnit()); assertNull(p1tgt.getName(deCtx)); assertNull(p1tgt.getName(enCtx)); assertEquals(product2.getCode(), p2tgt.getCode()); assertEquals(product2.getUnit(), p2tgt.getUnit()); assertNull(p2tgt.getName(deCtx)); assertNull(p2tgt.getName(enCtx)); assertEquals(product3.getCode(), p3tgt.getCode()); assertEquals(product3.getUnit(), p3tgt.getUnit()); assertNull(p3tgt.getName(deCtx)); assertNull(p3tgt.getName(enCtx)); List<ItemSyncTimestamp> p1ts = catalogManager.getSynchronizedCopies(product1); List<ItemSyncTimestamp> p2ts = catalogManager.getSynchronizedCopies(product2); List<ItemSyncTimestamp> p3ts = catalogManager.getSynchronizedCopies(product3); assertEquals(1, p1ts.size()); assertEquals(1, p2ts.size()); assertEquals(1, p3ts.size()); final ItemSyncTimestamp itemSyncTimestamp1 = p1ts.get(0); final ItemSyncTimestamp itemSyncTimestamp2 = p2ts.get(0); final ItemSyncTimestamp itemSyncTimestamp3 = p3ts.get(0); assertEquals(src, itemSyncTimestamp1.getSourceVersion()); assertEquals(tgt, itemSyncTimestamp1.getTargetVersion()); assertEquals(product1, itemSyncTimestamp1.getSourceItem()); assertEquals(p1tgt, itemSyncTimestamp1.getTargetItem()); assertEquals( product1.getModificationTime(), itemSyncTimestamp1.getLastSyncSourceModifiedTime()); assertEquals(false, itemSyncTimestamp1.isOutdatedAsPrimitive()); assertEquals(exclJob2, itemSyncTimestamp1.getSyncJob()); assertEquals(src, itemSyncTimestamp2.getSourceVersion()); assertEquals(tgt, itemSyncTimestamp2.getTargetVersion()); assertEquals(product2, itemSyncTimestamp2.getSourceItem()); assertEquals(p2tgt, itemSyncTimestamp2.getTargetItem()); assertEquals( product2.getModificationTime(), itemSyncTimestamp2.getLastSyncSourceModifiedTime()); assertEquals(false, itemSyncTimestamp2.isOutdatedAsPrimitive()); assertEquals(exclJob2, itemSyncTimestamp2.getSyncJob()); assertEquals(src, itemSyncTimestamp3.getSourceVersion()); assertEquals(tgt, itemSyncTimestamp3.getTargetVersion()); assertEquals(product3, itemSyncTimestamp3.getSourceItem()); assertEquals(p3tgt, itemSyncTimestamp3.getTargetItem()); assertEquals( product3.getModificationTime(), itemSyncTimestamp3.getLastSyncSourceModifiedTime()); assertEquals(false, itemSyncTimestamp3.isOutdatedAsPrimitive()); assertEquals(exclJob2, itemSyncTimestamp3.getSyncJob()); // 3. run job1 again -> now names should be copied as well final CatalogVersionSyncCronJob run3 = (CatalogVersionSyncCronJob) exclJob1.newExecution(); exclJob1.configureFullVersionSync(run3); exclJob1.perform(run3, true); assertEquals(run3.getResult(), run3.getSuccessResult()); p1tgt = (Product) catalogManager.getSynchronizedCopy(product1, exclJob1); p2tgt = (Product) catalogManager.getSynchronizedCopy(product2, exclJob1); p3tgt = (Product) catalogManager.getSynchronizedCopy(product3, exclJob1); assertEquals(product1.getCode(), p1tgt.getCode()); assertEquals(product1.getUnit(), p1tgt.getUnit()); assertEquals(product1.getName(deCtx), p1tgt.getName(deCtx)); assertEquals(product1.getName(enCtx), p1tgt.getName(enCtx)); assertEquals(product2.getCode(), p2tgt.getCode()); assertEquals(product2.getUnit(), p2tgt.getUnit()); assertEquals(product2.getName(deCtx), p2tgt.getName(deCtx)); assertEquals(product2.getName(enCtx), p2tgt.getName(enCtx)); assertEquals(product3.getCode(), p3tgt.getCode()); assertEquals(product3.getUnit(), p3tgt.getUnit()); assertEquals(product3.getName(deCtx), p3tgt.getName(deCtx)); assertEquals(product3.getName(enCtx), p3tgt.getName(enCtx)); p1ts = catalogManager.getSynchronizedCopies(product1); p2ts = catalogManager.getSynchronizedCopies(product2); p3ts = catalogManager.getSynchronizedCopies(product3); assertEquals(2, p1ts.size()); assertEquals(2, p2ts.size()); assertEquals(2, p3ts.size()); final ItemSyncTimestamp t1j1 = getTS(p1ts, exclJob1); final ItemSyncTimestamp t1j2 = getTS(p1ts, exclJob2); ItemSyncTimestamp t2j1 = getTS(p2ts, exclJob1); ItemSyncTimestamp t2j2 = getTS(p2ts, exclJob2); final ItemSyncTimestamp t3j1 = getTS(p3ts, exclJob1); final ItemSyncTimestamp t3j2 = getTS(p3ts, exclJob2); assertNotNull(t1j1); assertNotNull(t1j2); assertNotSame(t1j1, t1j2); assertNotNull(t2j1); assertNotNull(t2j2); assertNotSame(t2j1, t2j2); assertNotNull(t3j1); assertNotNull(t3j2); assertNotSame(t3j1, t3j2); assertEquals(src, t1j1.getSourceVersion()); assertEquals(tgt, t1j1.getTargetVersion()); assertEquals(product1, t1j1.getSourceItem()); assertEquals(p1tgt, t1j1.getTargetItem()); assertEquals(product1.getModificationTime(), t1j1.getLastSyncSourceModifiedTime()); assertEquals(false, t1j1.isOutdatedAsPrimitive()); assertEquals(exclJob1, t1j1.getSyncJob()); assertEquals(src, t1j2.getSourceVersion()); assertEquals(tgt, t1j2.getTargetVersion()); assertEquals(product1, t1j2.getSourceItem()); assertEquals(p1tgt, t1j2.getTargetItem()); assertEquals(product1.getModificationTime(), t1j2.getLastSyncSourceModifiedTime()); assertEquals(false, t1j2.isOutdatedAsPrimitive()); assertEquals(exclJob2, t1j2.getSyncJob()); assertEquals(src, t2j1.getSourceVersion()); assertEquals(tgt, t2j1.getTargetVersion()); assertEquals(product2, t2j1.getSourceItem()); assertEquals(p2tgt, t2j1.getTargetItem()); assertEquals(product2.getModificationTime(), t2j1.getLastSyncSourceModifiedTime()); assertEquals(false, t2j1.isOutdatedAsPrimitive()); assertEquals(exclJob1, t2j1.getSyncJob()); assertEquals(src, t2j2.getSourceVersion()); assertEquals(tgt, t2j2.getTargetVersion()); assertEquals(product2, t2j2.getSourceItem()); assertEquals(p2tgt, t2j2.getTargetItem()); assertEquals(product2.getModificationTime(), t2j2.getLastSyncSourceModifiedTime()); assertEquals(false, t2j2.isOutdatedAsPrimitive()); assertEquals(exclJob2, t2j2.getSyncJob()); assertEquals(src, t3j1.getSourceVersion()); assertEquals(tgt, t3j1.getTargetVersion()); assertEquals(product3, t3j1.getSourceItem()); assertEquals(p3tgt, t3j1.getTargetItem()); assertEquals(product3.getModificationTime(), t3j1.getLastSyncSourceModifiedTime()); assertEquals(false, t3j1.isOutdatedAsPrimitive()); assertEquals(exclJob1, t3j1.getSyncJob()); assertEquals(src, t3j2.getSourceVersion()); assertEquals(tgt, t3j2.getTargetVersion()); assertEquals(product3, t3j2.getSourceItem()); assertEquals(p3tgt, t3j2.getTargetItem()); assertEquals(product3.getModificationTime(), t3j2.getLastSyncSourceModifiedTime()); assertEquals(false, t3j2.isOutdatedAsPrimitive()); assertEquals(exclJob2, t3j2.getSyncJob()); // sleep at least one seconds to avoid item having the same modification timestamp as before!!! try { Thread.sleep(1100); } catch (final InterruptedException e) { // ok } // now change name of one product product2.setName(enCtx, "foo"); // 4. run job1 again -> should update name final CatalogVersionSyncCronJob run4 = (CatalogVersionSyncCronJob) exclJob1.newExecution(); exclJob1.configureFullVersionSync(run4); exclJob1.perform(run4, true); assertEquals(run4.getResult(), run4.getSuccessResult()); p2tgt = (Product) catalogManager.getSynchronizedCopy(product2, exclJob1); assertEquals(product2.getCode(), p2tgt.getCode()); assertEquals(product2.getUnit(), p2tgt.getUnit()); assertEquals(product2.getName(deCtx), p2tgt.getName(deCtx)); assertEquals(product2.getName(enCtx), p2tgt.getName(enCtx)); p2ts = catalogManager.getSynchronizedCopies(product2); assertEquals(2, p2ts.size()); t2j1 = getTS(p2ts, exclJob1); t2j2 = getTS(p2ts, exclJob2); assertNotNull(t2j1); assertNotNull(t2j2); assertNotSame(t2j1, t2j2); assertEquals(src, t2j1.getSourceVersion()); assertEquals(tgt, t2j1.getTargetVersion()); assertEquals(product2, t2j1.getSourceItem()); assertEquals(product2.getModificationTime(), t2j1.getLastSyncSourceModifiedTime()); assertEquals(p2tgt, t2j1.getTargetItem()); assertEquals(false, t2j1.isOutdatedAsPrimitive()); assertEquals(exclJob1, t2j1.getSyncJob()); assertEquals(src, t2j2.getSourceVersion()); assertEquals(tgt, t2j2.getTargetVersion()); assertEquals(product2, t2j2.getSourceItem()); assertEquals(p2tgt, t2j2.getTargetItem()); assertTrue(product2.getModificationTime().after(t2j2.getLastSyncSourceModifiedTime())); assertEquals(true, t2j2.isOutdatedAsPrimitive()); assertEquals(exclJob2, t2j2.getSyncJob()); // 5. run job2 again -> should update timestamp but change nothing else final CatalogVersionSyncCronJob run5 = (CatalogVersionSyncCronJob) exclJob2.newExecution(); exclJob2.configureFullVersionSync(run5); exclJob2.perform(run5, true); assertEquals(run5.getResult(), run5.getSuccessResult()); p2tgt = (Product) catalogManager.getSynchronizedCopy(product2, exclJob2); assertEquals(product2.getCode(), p2tgt.getCode()); assertEquals(product2.getUnit(), p2tgt.getUnit()); assertEquals(product2.getName(deCtx), p2tgt.getName(deCtx)); assertEquals(product2.getName(enCtx), p2tgt.getName(enCtx)); p2ts = catalogManager.getSynchronizedCopies(product2); assertEquals(2, p2ts.size()); t2j1 = getTS(p2ts, exclJob1); t2j2 = getTS(p2ts, exclJob2); assertNotNull(t2j1); assertNotNull(t2j2); assertNotSame(t2j1, t2j2); assertEquals(src, t2j1.getSourceVersion()); assertEquals(tgt, t2j1.getTargetVersion()); assertEquals(product2, t2j1.getSourceItem()); assertEquals(p2tgt, t2j1.getTargetItem()); assertEquals(product2.getModificationTime(), t2j1.getLastSyncSourceModifiedTime()); assertEquals(false, t2j1.isOutdatedAsPrimitive()); assertEquals(exclJob1, t2j1.getSyncJob()); assertEquals(src, t2j2.getSourceVersion()); assertEquals(tgt, t2j2.getTargetVersion()); assertEquals(product2, t2j2.getSourceItem()); assertEquals(p2tgt, t2j2.getTargetItem()); assertEquals(product2.getModificationTime(), t2j2.getLastSyncSourceModifiedTime()); assertEquals(false, t2j2.isOutdatedAsPrimitive()); assertEquals(exclJob2, t2j2.getSyncJob()); }
@Test public void testGetAttributesForModiferCriteria() { final AttributeDescriptorModel declaredDescriptor = mock(AttributeDescriptorModel.class); when(declaredDescriptor.getModifiers()).thenReturn(Integer.valueOf(AttributeModifiers.READ)); final AttributeDescriptorModel privateDescriptor = mock(AttributeDescriptorModel.class); when(privateDescriptor.getModifiers()) .thenReturn(Integer.valueOf(AttributeModifiers.READ | AttributeModifiers.PRIVATE)); when(privateDescriptor.getPrivate()).thenReturn(Boolean.TRUE); final AttributeDescriptorModel inheritedDescriptor = mock(AttributeDescriptorModel.class); when(inheritedDescriptor.getModifiers()) .thenReturn(Integer.valueOf(AttributeModifiers.READ | AttributeModifiers.INHERITED)); final AttributeDescriptorModel writableDescriptor = mock(AttributeDescriptorModel.class); when(writableDescriptor.getModifiers()) .thenReturn(Integer.valueOf(AttributeModifiers.READ | AttributeModifiers.WRITE)); when(writableDescriptor.getWritable()).thenReturn(Boolean.TRUE); final AttributeDescriptorModel partofDescriptor = mock(AttributeDescriptorModel.class); when(partofDescriptor.getModifiers()) .thenReturn( Integer.valueOf( AttributeModifiers.READ | AttributeModifiers.PARTOF | AttributeModifiers.WRITE)); when(partofDescriptor.getWritable()).thenReturn(Boolean.TRUE); when(partofDescriptor.getPartOf()).thenReturn(Boolean.TRUE); final Set<AttributeDescriptorModel> declaredDescriptorModels = new HashSet<AttributeDescriptorModel>(); declaredDescriptorModels.add(declaredDescriptor); declaredDescriptorModels.add(writableDescriptor); declaredDescriptorModels.add(partofDescriptor); final Set<AttributeDescriptorModel> inheritedDescriptorModels = new HashSet<AttributeDescriptorModel>(); inheritedDescriptorModels.add(inheritedDescriptor); final ComposedTypeModel typeModel = mock(ComposedTypeModel.class); when((typeModel).getDeclaredattributedescriptors()).thenReturn(declaredDescriptorModels); when((typeModel).getInheritedattributedescriptors()).thenReturn(inheritedDescriptorModels); final PK descriptorPk = PK.fromLong(1234567890); final AttributeDescriptor privateDescriptorItem = mock(AttributeDescriptor.class); when(privateDescriptorItem.getPK()).thenReturn(descriptorPk); when(Boolean.valueOf(privateDescriptorItem.isPrivate())).thenReturn(Boolean.TRUE); final Set<AttributeDescriptor> privateDescriptorItems = new HashSet<AttributeDescriptor>(); privateDescriptorItems.add(privateDescriptorItem); final ComposedType composedType = mock(ComposedType.class); when(modelService.getSource(typeModel)).thenReturn(composedType); when(composedType.getAttributeDescriptorsIncludingPrivate()).thenReturn(privateDescriptorItems); when(modelService.get(privateDescriptorItem)).thenReturn(privateDescriptor); when(typeDao.findComposedTypeByCode("modifierTest")).thenReturn(typeModel); final AttributeModifierCriteria modifierCriteria = new AttributeModifierCriteria(0, AttributeModifiers.ALL, 0); Assert.assertEquals( "Five declared descriptors expected", 5, typeService.getAttributesForModifiers("modifierTest", modifierCriteria).size()); modifierCriteria.addDisallowed(AttributeModifiers.PRIVATE); Assert.assertEquals( "Four declared descriptors expected", 4, typeService.getAttributesForModifiers("modifierTest", modifierCriteria).size()); modifierCriteria.addDisallowed(AttributeModifiers.INHERITED); Assert.assertEquals( "Three declared descriptors expected", 3, typeService.getAttributesForModifiers("modifierTest", modifierCriteria).size()); modifierCriteria.addRequired(AttributeModifiers.WRITE); Assert.assertEquals( "Two declared descriptors expected", 2, typeService.getAttributesForModifiers("modifierTest", modifierCriteria).size()); modifierCriteria.addRequired(AttributeModifiers.PARTOF); Assert.assertEquals( "One declared descriptor expected", 1, typeService.getAttributesForModifiers("modifierTest", modifierCriteria).size()); }