/** 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());
}
