@Test
public void testFindUniqueAttributes() {
final AttributeDescriptorModel attributeDescriptor1 = new AttributeDescriptorModel();
attributeDescriptor1.setUnique(Boolean.TRUE);
final Set<String> unique = new HashSet<String>();
unique.add("unique1");
final ItemModelConverter modelConverter = mock(ItemModelConverter.class);
when(modelConverter.getUniqueAttributes()).thenReturn(unique);
when(converterRegistry.getModelConverterBySourceType("model1")).thenReturn(modelConverter);
final Set<String> actualUnique = typeService.getUniqueAttributes("model1");
Assert.assertEquals("One attribute expected", 1, actualUnique.size());
Assert.assertEquals("Unexpected attribute got", "unique1", actualUnique.iterator().next());
}
@Test
public void testGetUniqueAttributesWithoutModelConverter() {
final AttributeDescriptorModel attributeDescriptor1 = new AttributeDescriptorModel();
attributeDescriptor1.setUnique(Boolean.TRUE);
final ModelConverter nonItemModelConverter = mock(ModelConverter.class);
final ComposedTypeModel nonItemModel = mock(ComposedTypeModel.class);
when(converterRegistry.getModelConverterBySourceType("nonItemModel"))
.thenReturn(nonItemModelConverter);
when((nonItemModel).getDeclaredattributedescriptors())
.thenReturn(Collections.singletonList(attributeDescriptor1));
when(typeDao.findComposedTypeByCode("nonItemModel")).thenReturn(nonItemModel);
final Set<String> actualUnique = typeService.getUniqueAttributes("nonItemModel");
Assert.assertEquals("One attribute expected", 1, actualUnique.size());
}
@Test
public void testFindMandatoryAttributesWithoutModelConverter() {
final AttributeDescriptorModel attributeDescriptor1 = new AttributeDescriptorModel();
attributeDescriptor1.setModifiers(Integer.valueOf(AttributeDescriptor.WRITE_FLAG));
final ModelConverter nonItemModelConverter = mock(ModelConverter.class);
final ComposedTypeModel nonItemModel = mock(ComposedTypeModel.class);
when(converterRegistry.getModelConverterBySourceType("nonItemModel"))
.thenReturn(nonItemModelConverter);
when((nonItemModel).getDeclaredattributedescriptors())
.thenReturn(Collections.singletonList(attributeDescriptor1));
when(typeDao.findComposedTypeByCode("nonItemModel")).thenReturn(nonItemModel);
final Set<String> actualMandatory = typeService.getMandatoryAttributes("nonItemModel", false);
Assert.assertEquals("One attribute expected", 1, actualMandatory.size());
}
@Test
public void testUniqueNullAttributeSlayerAPI() {
final ComposedTypeModel typeUnderInvestigation =
typeService.getComposedTypeForClass(LinkModel.class);
final AttributeDescriptorModel attributeDesc =
typeService.getAttributeDescriptor(typeUnderInvestigation, LinkModel.LANGUAGE);
Assert.assertTrue(attributeDesc.getOptional().booleanValue());
Assert.assertTrue(attributeDesc.getUnique().booleanValue());
final LinkModel link1 = modelService.create(LinkModel.class);
link1.setQualifier("link1");
link1.setSource(source);
link1.setTarget(target);
// the optional unique attribute
link1.setLanguage(language);
modelService.save(link1); // <-- OK!
final LinkModel link2 = modelService.create(LinkModel.class);
link2.setQualifier("link2");
link2.setSource(source);
link2.setTarget(target);
// the optional unique attribute
link2.setLanguage(null);
modelService.save(link2); // <-- OK! //<-- still OK, only one null value!
final LinkModel link3 = modelService.create(LinkModel.class);
link3.setQualifier("link3");
link3.setSource(source);
link3.setTarget(target);
// the optional unique attribute
link3.setLanguage(null);
boolean success = false;
try {
modelService.save(link3); // <-- what happens now?!
Assert.fail(
"Should have failed with 'ModelSavingException' for ambiguous unique attribute, which is 'null'");
} catch (final ModelSavingException e) {
success = true;
}
Assert.assertTrue(
"Should have failed with 'ModelSavingException' for ambiguous unique attribute, which is 'null'",
success);
}
/** creating some dummy data. */
@Before
public void init() {
modelService = createMock(ModelService.class);
preparer = new AttributeConstraintPreparer();
preparer.setModelService(modelService);
attrValidator = new AttributeConstraintValidator();
attrValidator.setModelService(modelService);
typeValidator = new TypeConstraintValidator();
typeValidator.setModelService(modelService);
prodModCT = new ComposedTypeModel();
prodModCT.setJaloclass(Product.class);
prodModCT.setCode("Product");
prodModCodeAD = new AttributeDescriptorModel();
prodModCodeAD.setQualifier("code");
prodModCodeAD.setEnclosingType(prodModCT);
}
@Test
public void testGetInitialAttributeDescriptorsForType() {
final ComposedTypeModel model = mock(ComposedTypeModel.class);
final AttributeDescriptorModel attributeDescriptor1 = new AttributeDescriptorModel();
attributeDescriptor1.setInitial(Boolean.TRUE);
when(model.getDeclaredattributedescriptors())
.thenReturn(Collections.singletonList(attributeDescriptor1));
final AttributeDescriptorModel attributeDescriptor2 = new AttributeDescriptorModel();
attributeDescriptor2.setInitial(Boolean.FALSE);
when(model.getInheritedattributedescriptors())
.thenReturn(Collections.singletonList(attributeDescriptor2));
final Set<AttributeDescriptorModel> attributeDescriptors =
typeService.getInitialAttributeDescriptorsForType(model);
Assert.assertEquals(
"One initial attribute descriptor should be returned, got: " + attributeDescriptors.size(),
1,
attributeDescriptors.size());
}
@Test
public void testFindMandatoryAttributes() {
final AttributeDescriptorModel attributeDescriptor1 = new AttributeDescriptorModel();
attributeDescriptor1.setModifiers(Integer.valueOf(AttributeDescriptor.WRITE_FLAG));
final Set<String> mandatory = new HashSet<String>();
mandatory.add("mandatory1");
final ItemModelConverter modelConverter = mock(ItemModelConverter.class);
when(modelConverter.getMandatoryAttributes()).thenReturn(mandatory);
when(modelConverter.getMandatoryAttributesForCreation()).thenReturn(Collections.EMPTY_SET);
when(converterRegistry.getModelConverterBySourceType("model1")).thenReturn(modelConverter);
Set<String> actualMandatory = typeService.getMandatoryAttributes("model1", false);
Assert.assertEquals("One attribute expected", 1, actualMandatory.size());
Assert.assertEquals(
"Unexpected attribute got", "mandatory1", actualMandatory.iterator().next());
actualMandatory = typeService.getMandatoryAttributes("model1", true);
Assert.assertEquals(
"Zero attributes expected with force create set", 0, actualMandatory.size());
}
@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());
}
