From 0045af853fe1a151c2d562efc0f8c692389d600d Mon Sep 17 00:00:00 2001 From: Tran Le Date: Tue, 26 Feb 2013 17:16:07 -0500 Subject: Revert "Updated EclipseLink tests jars" This reverts commit f3ce73267dfbbbcf5ca2e6032649d211afcf3962. --- jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml | 2 +- ...seLink2_0JavaElementCollectionMappingTests.java | 2275 ++++++++++++++++++++ .../EclipseLink2_0JavaManyToManyMappingTests.java | 1410 ++++++++++++ .../EclipseLink1_1OrmPersistentAttributeTests.java | 435 ++++ ...pseLink2_0OrmElementCollectionMappingTests.java | 1703 +++++++++++++++ ...EclipseLink2_1PersistenceUnitDefaultsTests.java | 330 +++ .../EclipseLink2_0PersistenceUnitTestCase.java | 57 + .../EclipseLink2_2JpaMetadataConversionTests.java | 823 +++++++ .../EclipseLinkPersistenceUnitTestCase.java | 53 + ...clipseLinkCorePersistenceContextModelTests.java | 48 + .../SchemaGenerationBasicAdapterTests.java | 153 ++ ...lipseLinkStaticWeavingBuilderMetadataTests.java | 67 + .../EclipseLink2_0JavaResourceModelTestCase.java | 34 + .../EclipseLink2_3JavaResourceModelTestCase.java | 34 + ...enantDiscriminatorColumnAnnotation2_3Tests.java | 330 +++ .../EclipselinkMultitenantAnnotation2_3Tests.java | 138 ++ .../JptEclipseLinkCoreJavaResourceModelTests.java | 50 + .../test.xml | 4 +- 18 files changed, 7943 insertions(+), 3 deletions(-) create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java create mode 100644 jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java (limited to 'jpa') diff --git a/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml b/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml index 0ac07d8cb9..1609ffb9ff 100644 --- a/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml +++ b/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml @@ -21,7 +21,7 @@ - + diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java new file mode 100644 index 0000000000..03b42ab318 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java @@ -0,0 +1,2275 @@ +/******************************************************************************* + * Copyright (c) 2009, 2012 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.java; + +import java.util.Iterator; +import java.util.ListIterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceField; +import org.eclipse.jpt.common.core.resource.java.JavaResourceType; +import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind; +import org.eclipse.jpt.common.core.resource.java.NestableAnnotation; +import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter; +import org.eclipse.jpt.common.utility.internal.ReflectionTools; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.core.MappingKeys; +import org.eclipse.jpt.jpa.core.context.AttributeOverride; +import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer; +import org.eclipse.jpt.jpa.core.context.BasicMapping; +import org.eclipse.jpt.jpa.core.context.Embeddable; +import org.eclipse.jpt.jpa.core.context.EmbeddedIdMapping; +import org.eclipse.jpt.jpa.core.context.EmbeddedMapping; +import org.eclipse.jpt.jpa.core.context.EnumType; +import org.eclipse.jpt.jpa.core.context.BaseEnumeratedConverter; +import org.eclipse.jpt.jpa.core.context.FetchType; +import org.eclipse.jpt.jpa.core.context.IdMapping; +import org.eclipse.jpt.jpa.core.context.ManyToManyMapping; +import org.eclipse.jpt.jpa.core.context.ManyToOneMapping; +import org.eclipse.jpt.jpa.core.context.OneToManyMapping; +import org.eclipse.jpt.jpa.core.context.PersistentAttribute; +import org.eclipse.jpt.jpa.core.context.PersistentType; +import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride; +import org.eclipse.jpt.jpa.core.context.BaseTemporalConverter; +import org.eclipse.jpt.jpa.core.context.TemporalType; +import org.eclipse.jpt.jpa.core.context.TransientMapping; +import org.eclipse.jpt.jpa.core.context.TypeMapping; +import org.eclipse.jpt.jpa.core.context.VersionMapping; +import org.eclipse.jpt.jpa.core.context.VirtualAttributeOverride; +import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride; +import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer; +import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType; +import org.eclipse.jpt.jpa.core.context.persistence.ClassRef; +import org.eclipse.jpt.jpa.core.jpa2.context.ElementCollectionMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.OrderColumn2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaElementCollectionMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.ElementCollection2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyClass2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyColumn2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyEnumerated2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyTemporal2_0Annotation; +import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.BasicAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.ColumnAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.EmbeddedAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.EmbeddedIdAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.IdAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.core.resource.java.ManyToManyAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.ManyToOneAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.MapKeyAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.OneToManyAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.TransientAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.VersionAnnotation; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConvert; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkConvertAnnotation; +import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_0ContextModelTestCase; + +@SuppressWarnings("nls") +public class EclipseLink2_0JavaElementCollectionMappingTests + extends EclipseLink2_0ContextModelTestCase +{ + public static final String EMBEDDABLE_TYPE_NAME = "Address"; + public static final String FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME = PACKAGE_NAME + "." + EMBEDDABLE_TYPE_NAME; + + private ICompilationUnit createTestEntityWithElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@ElementCollection").append(CR); + } + }); + } + private ICompilationUnit createTestEntityWithElementCollectionMappingWithConvert() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, EclipseLink.CONVERT); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@ElementCollection").append(CR); + sb.append("@Convert(\"class-instance\")").append(CR); + } + }); + } + + + private ICompilationUnit createTestEntityWithGenericEmbeddableElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Collection
addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithGenericBasicElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Collection addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithNonGenericElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Collection addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithValidGenericMapElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Map addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithValidNonGenericMapElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Map addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private void createTestTargetEmbeddableAddress() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDED); + sb.append(";"); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("Address").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private String city;").append(CR); + sb.append(CR); + sb.append(" @Embedded").append(CR); + sb.append(" private State state;").append(CR); + sb.append(CR); + sb.append(" private int zip;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter); + } + + private void createTestEmbeddableState() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("State").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private String name;").append(CR); + sb.append(CR); + sb.append(" private String abbr;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter); + } + + private ICompilationUnit createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Map parcels;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private void createTestEmbeddablePropertyInfo() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDED); + sb.append(";"); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("PropertyInfo").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private Integer parcelNumber;").append(CR); + sb.append(CR); + sb.append(" private Integer size;").append(CR); + sb.append(CR); + sb.append(" private java.math.BigDecimal tax;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter); + } + + private void createSelfReferentialElementCollection() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA2_0.ELEMENT_COLLECTION); + sb.append(";"); + sb.append(CR).append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("Foo").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.List elementCollection;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Foo.java", sourceWriter); + } + + public EclipseLink2_0JavaElementCollectionMappingTests(String name) { + super(name); + } + + public void testMorphToBasicMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof BasicMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(BasicAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToDefault() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + } + + public void testMorphToVersionMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof VersionMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(VersionAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToIdMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof IdMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(IdAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToEmbeddedMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof EmbeddedMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(EmbeddedAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToEmbeddedIdMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof EmbeddedIdMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(EmbeddedIdAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToTransientMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof TransientMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(TransientAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToManyToOneMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof ManyToOneMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(ManyToOneAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToOneToManyMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof OneToManyMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(OneToManyAnnotation.ANNOTATION_NAME)); + } + + public void testMorphToManyToManyMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + + persistentAttribute.setMappingKey(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY); + assertTrue(persistentAttribute.getMapping() instanceof ManyToManyMapping); + assertFalse(persistentAttribute.getMapping().isDefault()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME)); + assertNotNull(resourceField.getAnnotation(ManyToManyAnnotation.ANNOTATION_NAME)); + } + + public void testUpdateSpecifiedTargetEntity() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + ElementCollection2_0Annotation elementCollectionAnnotation = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME); + + assertNull(elementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollectionAnnotation.getTargetClass()); + + //set target class in the resource model, verify context model updated + elementCollectionAnnotation.setTargetClass("newTargetClass"); + this.getJpaProject().synchronizeContextModel(); + assertEquals("newTargetClass", elementCollectionMapping.getSpecifiedTargetClass()); + assertEquals("newTargetClass", elementCollectionAnnotation.getTargetClass()); + + //set target class to null in the resource model + elementCollectionAnnotation.setTargetClass(null); + this.getJpaProject().synchronizeContextModel(); + assertNull(elementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollectionAnnotation.getTargetClass()); + } + + public void testModifySpecifiedTargetClass() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + ElementCollection2_0Annotation elementCollection = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME); + + assertNull(elementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollection.getTargetClass()); + + //set target class in the context model, verify resource model updated + elementCollectionMapping.setSpecifiedTargetClass("newTargetClass"); + assertEquals("newTargetClass", elementCollectionMapping.getSpecifiedTargetClass()); + assertEquals("newTargetClass", elementCollection.getTargetClass()); + + //set target class to null in the context model + elementCollectionMapping.setSpecifiedTargetClass(null); + assertNull(elementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollection.getTargetClass()); + } + + public void testDefaultTargetClass() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + //targetEntity not in the persistence unit, default still set, handled by validation + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass()); + + //add targetEntity to the persistence unit + addXmlClassRef(PACKAGE_NAME + ".Address"); + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass()); + + //test default still the same when specified target entity it set + elementCollectionMapping.setSpecifiedTargetClass("foo"); + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass()); + + ListIterator classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + classRefs.next(); + ClassRef addressClassRef = classRefs.next(); + JavaPersistentType addressPersistentType = addressClassRef.getJavaPersistentType(); + + //test target is not an Embeddable, default target entity still exists, this case handled with validation + addressPersistentType.setMappingKey(MappingKeys.NULL_TYPE_MAPPING_KEY); + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass()); + } + + public void testDefaultTargetClassNonGenericCollection() throws Exception { + createTestEntityWithNonGenericElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getDefaultTargetClass()); + } + + public void testDefaultTargetClassGenericCollection() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass()); + } + + public void testDefaultTargetClassNonGenericMap() throws Exception { + createTestEntityWithValidNonGenericMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getDefaultTargetClass()); + } + + public void testDefaultTargetClassGenericMap() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass()); + } + + public void testTargetClass() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getTargetClass()); + + elementCollectionMapping.setSpecifiedTargetClass("foo"); + assertEquals("foo", elementCollectionMapping.getTargetClass()); + + elementCollectionMapping.setSpecifiedTargetClass(null); + assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getTargetClass()); + } + + protected Embeddable getResolvedTargetEmbeddable(ElementCollectionMapping2_0 mapping) { + return (Embeddable) ReflectionTools.executeMethod(mapping, "getResolvedTargetEmbeddable"); + } + + public void testResolvedTargetEmbeddable() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + //target embeddable not in the persistence unit + assertNull(this.getResolvedTargetEmbeddable(elementCollectionMapping)); + + //add target embeddable to the persistence unit, now target embeddable should resolve + createTestTargetEmbeddableAddress(); + addXmlClassRef(PACKAGE_NAME + ".Address"); + ListIterator classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + classRefs.next(); + ClassRef addressClassRef = classRefs.next(); + TypeMapping addressTypeMapping = addressClassRef.getJavaPersistentType().getMapping(); + assertEquals(addressTypeMapping, this.getResolvedTargetEmbeddable(elementCollectionMapping)); + + //test default still the same when specified target entity it set + elementCollectionMapping.setSpecifiedTargetClass("foo"); + assertNull(this.getResolvedTargetEmbeddable(elementCollectionMapping)); + + + elementCollectionMapping.setSpecifiedTargetClass(PACKAGE_NAME + ".Address"); + assertEquals(addressTypeMapping, this.getResolvedTargetEmbeddable(elementCollectionMapping)); + + + elementCollectionMapping.setSpecifiedTargetClass(null); + assertEquals(addressTypeMapping, this.getResolvedTargetEmbeddable(elementCollectionMapping)); + } + + public void testResolvedTargetEmbeddableWithBasicType() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + //target is a basic type, so resolved target embeddable is null + assertNull(this.getResolvedTargetEmbeddable(elementCollectionMapping)); + } + + public void testUpdateSpecifiedFetch() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + ElementCollection2_0Annotation elementCollection = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME); + + assertNull(elementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + + //set fetch in the resource model, verify context model updated + elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.java.FetchType.EAGER); + getJpaProject().synchronizeContextModel(); + + assertEquals(FetchType.EAGER, elementCollectionMapping.getSpecifiedFetch()); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.EAGER, elementCollection.getFetch()); + + elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.java.FetchType.LAZY); + getJpaProject().synchronizeContextModel(); + + assertEquals(FetchType.LAZY, elementCollectionMapping.getSpecifiedFetch()); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.LAZY, elementCollection.getFetch()); + + //set fetch to null in the resource model + elementCollection.setFetch(null); + getJpaProject().synchronizeContextModel(); + + assertNull(elementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + } + + public void testModifySpecifiedFetch() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + ElementCollection2_0Annotation elementCollection = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME); + + assertNull(elementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + + //set fetch in the context model, verify resource model updated + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertEquals(FetchType.EAGER, elementCollectionMapping.getSpecifiedFetch()); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.EAGER, elementCollection.getFetch()); + + elementCollectionMapping.setSpecifiedFetch(FetchType.LAZY); + assertEquals(FetchType.LAZY, elementCollectionMapping.getSpecifiedFetch()); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.LAZY, elementCollection.getFetch()); + + //set fetch to null in the context model + elementCollectionMapping.setSpecifiedFetch(null); + assertNull(elementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + } + + public void testGetValueTypeEmbeddable() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType()); + } + + public void testGetValueTypeNone() throws Exception { + createTestEntityWithNonGenericElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.NO_TYPE, elementCollectionMapping.getValueType()); + + elementCollectionMapping.setSpecifiedTargetClass("Address"); + assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType()); + } + + public void testGetValueTypeBasic() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.BASIC_TYPE, elementCollectionMapping.getValueType()); + } + + public void testUpdateMapKey() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(elementCollectionMapping.getSpecifiedMapKey()); + assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME)); + + //set mapKey in the resource model, verify context model does not change + resourceField.addAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + assertNull(elementCollectionMapping.getSpecifiedMapKey()); + MapKeyAnnotation mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNotNull(mapKey); + + //set mapKey name in the resource model, verify context model updated + mapKey.setName("myMapKey"); + getJpaProject().synchronizeContextModel(); + + assertEquals("myMapKey", elementCollectionMapping.getSpecifiedMapKey()); + assertEquals("myMapKey", mapKey.getName()); + + //set mapKey name to null in the resource model + mapKey.setName(null); + getJpaProject().synchronizeContextModel(); + assertNull(elementCollectionMapping.getSpecifiedMapKey()); + assertNull(mapKey.getName()); + + mapKey.setName("myMapKey"); + resourceField.removeAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNull(elementCollectionMapping.getSpecifiedMapKey()); + assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME)); + } + + public void testModifyMapKey() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(elementCollectionMapping.getSpecifiedMapKey()); + assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME)); + + //set mapKey in the context model, verify resource model updated + elementCollectionMapping.setSpecifiedMapKey("myMapKey"); + MapKeyAnnotation mapKeyAnnotation = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertEquals("myMapKey", elementCollectionMapping.getSpecifiedMapKey()); + assertEquals("myMapKey", mapKeyAnnotation.getName()); + + //set mapKey to null in the context model + elementCollectionMapping.setSpecifiedMapKey(null); + assertNull(elementCollectionMapping.getSpecifiedMapKey()); + mapKeyAnnotation = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNull(mapKeyAnnotation.getName()); + } + + public void testCandidateMapKeyNames() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping2_0 = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + Iterator mapKeyNames = + elementCollectionMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.name", mapKeyNames.next()); + assertEquals("state.abbr", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + } + + public void testCandidateMapKeyNames2() throws Exception { + createTestEntityWithValidNonGenericMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping2_0 = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + Iterator mapKeyNames = elementCollectionMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + + elementCollectionMapping2_0.setSpecifiedTargetClass("Address"); + mapKeyNames = elementCollectionMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.name", mapKeyNames.next()); + assertEquals("state.abbr", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + + elementCollectionMapping2_0.setSpecifiedTargetClass("String"); + mapKeyNames = elementCollectionMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + } + + public void testUpdateMapKeyClass() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(elementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + + //set mapKey in the resource model, verify context model does not change + resourceField.addAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + assertNull(elementCollectionMapping.getSpecifiedMapKeyClass()); + MapKeyClass2_0Annotation mapKeyClassAnnotation = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + assertNotNull(mapKeyClassAnnotation); + + //set mapKey name in the resource model, verify context model updated + mapKeyClassAnnotation.setValue("myMapKeyClass"); + this.getJpaProject().synchronizeContextModel(); + assertEquals("myMapKeyClass", elementCollectionMapping.getSpecifiedMapKeyClass()); + assertEquals("myMapKeyClass", mapKeyClassAnnotation.getValue()); + + //set mapKey name to null in the resource model + mapKeyClassAnnotation.setValue(null); + getJpaProject().synchronizeContextModel(); + + assertNull(elementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(mapKeyClassAnnotation.getValue()); + + mapKeyClassAnnotation.setValue("myMapKeyClass"); + resourceField.removeAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + assertNull(elementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + } + + public void testModifyMapKeyClass() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(elementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + + //set mapKey in the context model, verify resource model updated + elementCollectionMapping.setSpecifiedMapKeyClass("String"); + MapKeyClass2_0Annotation mapKeyClass = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + assertEquals("String", elementCollectionMapping.getSpecifiedMapKeyClass()); + assertEquals("String", mapKeyClass.getValue()); + + //set mapKey to null in the context model + elementCollectionMapping.setSpecifiedMapKeyClass(null); + assertNull(elementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + } + + public void testDefaultMapKeyClass() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals("java.lang.Integer", elementCollectionMapping.getDefaultMapKeyClass()); + + //test default still the same when specified target entity it set + elementCollectionMapping.setSpecifiedMapKeyClass("foo"); + assertEquals("java.lang.Integer", elementCollectionMapping.getDefaultMapKeyClass()); + } + + public void testDefaultMapKeyClassCollectionType() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getDefaultMapKeyClass()); + } + + public void testMapKeyClass() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals("java.lang.Integer", elementCollectionMapping.getMapKeyClass()); + + elementCollectionMapping.setSpecifiedMapKeyClass("foo"); + assertEquals("foo", elementCollectionMapping.getMapKeyClass()); + + elementCollectionMapping.setSpecifiedMapKeyClass(null); + assertEquals("java.lang.Integer", elementCollectionMapping.getMapKeyClass()); + } + + public void testOrderColumnDefaults() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + Orderable2_0 orderable = ((Orderable2_0) elementCollectionMapping.getOrderable()); + assertEquals(false, orderable.isOrderColumnOrdering()); + assertEquals(true, orderable.isNoOrdering()); + + orderable.setOrderColumnOrdering(true); + OrderColumn2_0 orderColumn = orderable.getOrderColumn(); + assertEquals(true, orderable.isOrderColumnOrdering()); + assertEquals(null, orderColumn.getSpecifiedName()); + assertEquals("addresses_ORDER", orderColumn.getDefaultName()); + assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable()); + + orderColumn.setSpecifiedName("FOO"); + assertEquals("FOO", orderColumn.getSpecifiedName()); + assertEquals("addresses_ORDER", orderColumn.getDefaultName()); + assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable()); + } + + public void testGetValueColumn() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getValueColumn().getSpecifiedName()); + assertEquals("id", elementCollectionMapping.getValueColumn().getName()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + ColumnAnnotation column = (ColumnAnnotation) resourceField.addAnnotation(JPA.COLUMN); + column.setName("foo"); + getJpaProject().synchronizeContextModel(); + + assertEquals("foo", elementCollectionMapping.getValueColumn().getSpecifiedName()); + assertEquals("foo", elementCollectionMapping.getValueColumn().getName()); + assertEquals("id", elementCollectionMapping.getValueColumn().getDefaultName()); + } + + public void testSpecifiedAttributeOverrides() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + JavaAttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + + ListIterator specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + + assertFalse(specifiedAttributeOverrides.hasNext()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("BAR"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("BAZ"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", specifiedAttributeOverrides.next().getName()); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + //move an annotation to the resource model and verify the context model is updated + resourceField.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAZ", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertFalse(specifiedAttributeOverrides.hasNext()); + } + + public void testVirtualAttributeOverrides() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertEquals("addresses", resourceField.getName()); + assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME)); + + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + ReadOnlyAttributeOverride defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("city", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_addresses", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + ListIterator classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + classRefs.next(); + Embeddable embeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping(); + + BasicMapping cityMapping = (BasicMapping) embeddable.getPersistentType().getAttributeNamed("city").getMapping(); + cityMapping.getColumn().setSpecifiedName("FOO"); + cityMapping.getColumn().setSpecifiedTable("BAR"); + cityMapping.getColumn().setColumnDefinition("COLUMN_DEF"); + cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE); + cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5)); + cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6)); + cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7)); + + assertEquals("addresses", resourceField.getName()); + assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME)); + + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("FOO", defaultAttributeOverride.getColumn().getName()); + assertEquals("BAR", defaultAttributeOverride.getColumn().getTable()); + assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(false, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(false, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(5, defaultAttributeOverride.getColumn().getLength()); + assertEquals(6, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(7, defaultAttributeOverride.getColumn().getScale()); + + cityMapping.getColumn().setSpecifiedName(null); + cityMapping.getColumn().setSpecifiedTable(null); + cityMapping.getColumn().setColumnDefinition(null); + cityMapping.getColumn().setSpecifiedInsertable(null); + cityMapping.getColumn().setSpecifiedUpdatable(null); + cityMapping.getColumn().setSpecifiedUnique(null); + cityMapping.getColumn().setSpecifiedNullable(null); + cityMapping.getColumn().setSpecifiedLength(null); + cityMapping.getColumn().setSpecifiedPrecision(null); + cityMapping.getColumn().setSpecifiedScale(null); + defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("city", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_addresses", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + annotation.setName("city"); + getJpaProject().synchronizeContextModel(); + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testSpecifiedAttributeOverridesSize() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + assertEquals(0, attributeOverrideContainer.getSpecifiedOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("BAR"); + getJpaProject().synchronizeContextModel(); + + assertEquals(2, attributeOverrideContainer.getSpecifiedOverridesSize()); + } + + public void testAttributeOverridesSize() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + assertEquals(4, attributeOverrideContainer.getOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("BAR"); + getJpaProject().synchronizeContextModel(); + + assertEquals(6, attributeOverrideContainer.getOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("city"); + getJpaProject().synchronizeContextModel(); + assertEquals(6, attributeOverrideContainer.getOverridesSize()); + } + + public void testVirtualAttributeOverridesSize() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + getJpaProject().synchronizeContextModel(); + + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("city"); + getJpaProject().synchronizeContextModel(); + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("state.name"); + getJpaProject().synchronizeContextModel(); + assertEquals(2, attributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testAttributeOverrideSetVirtual() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + attributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + assertEquals("city", attributeOverrideContainer.getVirtualOverrides().iterator().next().getName()); + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + + attributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + assertFalse(attributeOverrides.hasNext()); + + Iterator virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + assertEquals("city", virtualAttributeOverrides.next().getName()); + assertEquals("state.name", virtualAttributeOverrides.next().getName()); + assertEquals("state.abbr", virtualAttributeOverrides.next().getName()); + assertEquals("zip", virtualAttributeOverrides.next().getName()); + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testAttributeOverrideSetVirtual2() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + ListIterator virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + virtualAttributeOverrides.next(); + virtualAttributeOverrides.next().convertToSpecified(); + attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + } + + public void testMoveSpecifiedAttributeOverride() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + resourceField.moveAnnotation(1, 0, AttributeOverrideAnnotation.ANNOTATION_NAME); + + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + } + + public void testNestedVirtualAttributeOverrides() throws Exception { + createTestEntityWithGenericEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ListIterator specifiedClassRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + PersistentType persistentType = specifiedClassRefs.next().getJavaPersistentType(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentType.getAttributeNamed("addresses").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + ListIterator virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + ReadOnlyAttributeOverride virtualAttributeOverride = virtualAttributeOverrides.next(); + assertEquals("city", virtualAttributeOverride.getName()); + virtualAttributeOverride = virtualAttributeOverrides.next(); + assertEquals("state.name", virtualAttributeOverride.getName()); + virtualAttributeOverride = virtualAttributeOverrides.next(); + assertEquals("state.abbr", virtualAttributeOverride.getName()); + virtualAttributeOverride = virtualAttributeOverrides.next(); + assertEquals("zip", virtualAttributeOverride.getName()); + assertEquals(false, virtualAttributeOverrides.hasNext()); + + + PersistentType addressPersistentType = specifiedClassRefs.next().getJavaPersistentType(); + EmbeddedMapping nestedEmbeddedMapping = (EmbeddedMapping) addressPersistentType.getAttributeNamed("state").getMapping(); + AttributeOverrideContainer nestedAttributeOverrideContainer = nestedEmbeddedMapping.getAttributeOverrideContainer(); + assertEquals(2, nestedAttributeOverrideContainer.getVirtualOverridesSize()); + virtualAttributeOverrides = nestedAttributeOverrideContainer.getVirtualOverrides().iterator(); + virtualAttributeOverride = virtualAttributeOverrides.next(); + assertEquals("name", virtualAttributeOverride.getName()); + virtualAttributeOverride = virtualAttributeOverrides.next(); + assertEquals("abbr", virtualAttributeOverride.getName()); + + PersistentType statePersistentType = specifiedClassRefs.next().getJavaPersistentType(); + BasicMapping abbrMapping = (BasicMapping) statePersistentType.getAttributeNamed("abbr").getMapping(); + abbrMapping.getColumn().setSpecifiedName("BLAH"); + abbrMapping.getColumn().setSpecifiedTable("BLAH_TABLE"); + abbrMapping.getColumn().setColumnDefinition("COLUMN_DEFINITION"); + abbrMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE); + abbrMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE); + abbrMapping.getColumn().setSpecifiedUnique(Boolean.TRUE); + abbrMapping.getColumn().setSpecifiedNullable(Boolean.FALSE); + abbrMapping.getColumn().setSpecifiedLength(Integer.valueOf(5)); + abbrMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6)); + abbrMapping.getColumn().setSpecifiedScale(Integer.valueOf(7)); + + //check the nested embedded (Address.state) attribute override to verify it is getting settings from the specified column on State.abbr + virtualAttributeOverride = ((EmbeddedMapping) addressPersistentType.getAttributeNamed("state").getMapping()).getAttributeOverrideContainer().getOverrideNamed("abbr"); + assertEquals("abbr", virtualAttributeOverride.getName()); + assertEquals("BLAH", virtualAttributeOverride.getColumn().getName()); + assertEquals("BLAH_TABLE", virtualAttributeOverride.getColumn().getTable()); + assertEquals("COLUMN_DEFINITION", virtualAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(false, virtualAttributeOverride.getColumn().isInsertable()); + assertEquals(false, virtualAttributeOverride.getColumn().isUpdatable()); + assertEquals(true, virtualAttributeOverride.getColumn().isUnique()); + assertEquals(false, virtualAttributeOverride.getColumn().isNullable()); + assertEquals(5, virtualAttributeOverride.getColumn().getLength()); + assertEquals(6, virtualAttributeOverride.getColumn().getPrecision()); + assertEquals(7, virtualAttributeOverride.getColumn().getScale()); + } + + public void testGetMapKeyColumn() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getMapKeyColumn().getSpecifiedName()); + assertEquals("addresses_KEY", elementCollectionMapping.getMapKeyColumn().getName()); + assertEquals(TYPE_NAME + "_addresses", elementCollectionMapping.getMapKeyColumn().getTable());//collection table name + + elementCollectionMapping.getCollectionTable().setSpecifiedName("MY_COLLECTION_TABLE"); + assertEquals("MY_COLLECTION_TABLE", elementCollectionMapping.getMapKeyColumn().getTable()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyColumn2_0Annotation column = (MapKeyColumn2_0Annotation) resourceField.addAnnotation(JPA2_0.MAP_KEY_COLUMN); + column.setName("foo"); + getJpaProject().synchronizeContextModel(); + + assertEquals("foo", elementCollectionMapping.getMapKeyColumn().getSpecifiedName()); + assertEquals("foo", elementCollectionMapping.getMapKeyColumn().getName()); + assertEquals("addresses_KEY", elementCollectionMapping.getMapKeyColumn().getDefaultName()); + } + + public void testMapKeyValueSpecifiedAttributeOverrides() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + + JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + + ListIterator specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + + assertFalse(specifiedAttributeOverrides.hasNext()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.BAR"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAZ"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + ListIterator specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BLAH"); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + //move an annotation to the resource model and verify the context model is updated + resourceField.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedAttributeOverrides.next().getName()); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAR", specifiedAttributeOverrides.next().getName()); + assertFalse(specifiedAttributeOverrides.hasNext()); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertFalse(specifiedAttributeOverrides.hasNext()); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + } + + public void testMapKeyValueVirtualAttributeOverrides() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertEquals("parcels", resourceField.getName()); + assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME)); + + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + ReadOnlyAttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("city", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + ListIterator classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + classRefs.next(); + Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping(); + + BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping(); + cityMapping.getColumn().setSpecifiedName("FOO"); + cityMapping.getColumn().setSpecifiedTable("BAR"); + cityMapping.getColumn().setColumnDefinition("COLUMN_DEF"); + cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE); + cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5)); + cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6)); + cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7)); + + assertEquals("parcels", resourceField.getName()); + assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME)); + + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("FOO", defaultAttributeOverride.getColumn().getName()); + assertEquals("BAR", defaultAttributeOverride.getColumn().getTable()); + assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(false, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(false, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(5, defaultAttributeOverride.getColumn().getLength()); + assertEquals(6, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(7, defaultAttributeOverride.getColumn().getScale()); + + cityMapping.getColumn().setSpecifiedName(null); + cityMapping.getColumn().setSpecifiedTable(null); + cityMapping.getColumn().setColumnDefinition(null); + cityMapping.getColumn().setSpecifiedInsertable(null); + cityMapping.getColumn().setSpecifiedUpdatable(null); + cityMapping.getColumn().setSpecifiedUnique(null); + cityMapping.getColumn().setSpecifiedNullable(null); + cityMapping.getColumn().setSpecifiedLength(null); + cityMapping.getColumn().setSpecifiedPrecision(null); + cityMapping.getColumn().setSpecifiedScale(null); + defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("city", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + annotation.setName("key.city"); + getJpaProject().synchronizeContextModel(); + assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("parcelNumber", defaultAttributeOverride.getName()); + assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + classRefs.next(); + classRefs.next(); + Embeddable propertyInfoEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping(); + + BasicMapping parcelNumberMapping = (BasicMapping) propertyInfoEmbeddable.getPersistentType().getAttributeNamed("parcelNumber").getMapping(); + parcelNumberMapping.getColumn().setSpecifiedName("FOO1"); + parcelNumberMapping.getColumn().setSpecifiedTable("BAR1"); + parcelNumberMapping.getColumn().setColumnDefinition("COLUMN_DEF1"); + parcelNumberMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE); + parcelNumberMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE); + parcelNumberMapping.getColumn().setSpecifiedUnique(Boolean.TRUE); + parcelNumberMapping.getColumn().setSpecifiedNullable(Boolean.FALSE); + parcelNumberMapping.getColumn().setSpecifiedLength(Integer.valueOf(5)); + parcelNumberMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6)); + parcelNumberMapping.getColumn().setSpecifiedScale(Integer.valueOf(7)); + + assertEquals("parcels", resourceField.getName()); + + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("parcelNumber", defaultAttributeOverride.getName()); + assertEquals("FOO1", defaultAttributeOverride.getColumn().getName()); + assertEquals("BAR1", defaultAttributeOverride.getColumn().getTable()); + assertEquals("COLUMN_DEF1", defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(false, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(false, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(5, defaultAttributeOverride.getColumn().getLength()); + assertEquals(6, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(7, defaultAttributeOverride.getColumn().getScale()); + + parcelNumberMapping.getColumn().setSpecifiedName(null); + parcelNumberMapping.getColumn().setSpecifiedTable(null); + parcelNumberMapping.getColumn().setColumnDefinition(null); + parcelNumberMapping.getColumn().setSpecifiedInsertable(null); + parcelNumberMapping.getColumn().setSpecifiedUpdatable(null); + parcelNumberMapping.getColumn().setSpecifiedUnique(null); + parcelNumberMapping.getColumn().setSpecifiedNullable(null); + parcelNumberMapping.getColumn().setSpecifiedLength(null); + parcelNumberMapping.getColumn().setSpecifiedPrecision(null); + parcelNumberMapping.getColumn().setSpecifiedScale(null); + defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("parcelNumber", defaultAttributeOverride.getName()); + assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + annotation.setName("value.parcelNumber"); + getJpaProject().synchronizeContextModel(); + assertEquals(2, attributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + assertEquals(0, valueAttributeOverrideContainer.getSpecifiedOverridesSize()); + assertEquals(0, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAR"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.FOO2"); + getJpaProject().synchronizeContextModel(); + + assertEquals(2, valueAttributeOverrideContainer.getSpecifiedOverridesSize()); + assertEquals(1, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize()); + } + + public void testMapKeyValueAttributeOverridesSize() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + assertEquals(4, mapKeyAttributeOverrideContainer.getOverridesSize()); + assertEquals(3, valueAttributeOverrideContainer.getOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAR"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.FOO2"); + getJpaProject().synchronizeContextModel(); + + assertEquals(5, mapKeyAttributeOverrideContainer.getOverridesSize()); + assertEquals(5, valueAttributeOverrideContainer.getOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("city"); + getJpaProject().synchronizeContextModel(); + assertEquals(5, mapKeyAttributeOverrideContainer.getOverridesSize()); + assertEquals(6, valueAttributeOverrideContainer.getOverridesSize()); + } + + public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(3, valueAttributeOverrideContainer.getVirtualOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAR"); + getJpaProject().synchronizeContextModel(); + + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(3, valueAttributeOverrideContainer.getVirtualOverridesSize()); + + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.city"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.parcelNumber"); + getJpaProject().synchronizeContextModel(); + assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(2, valueAttributeOverrideContainer.getVirtualOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.state.name"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("size"); + getJpaProject().synchronizeContextModel(); + assertEquals(2, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(1, valueAttributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + valueAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + assertEquals("parcelNumber", valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().getName()); + assertEquals(2, valueAttributeOverrideContainer.getVirtualOverridesSize()); + assertEquals("city", mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().getName()); + assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + + valueAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + assertFalse(attributeOverrides.hasNext()); + + Iterator virtualAttributeOverrides = valueAttributeOverrideContainer.getVirtualOverrides().iterator(); + assertEquals("parcelNumber", virtualAttributeOverrides.next().getName()); + assertEquals("size", virtualAttributeOverrides.next().getName()); + assertEquals("tax", virtualAttributeOverrides.next().getName()); + assertEquals(3, valueAttributeOverrideContainer.getVirtualOverridesSize()); + + virtualAttributeOverrides = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator(); + assertEquals("city", virtualAttributeOverrides.next().getName()); + assertEquals("state.name", virtualAttributeOverrides.next().getName()); + assertEquals("state.abbr", virtualAttributeOverrides.next().getName()); + assertEquals("zip", virtualAttributeOverrides.next().getName()); + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + } + + + public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception { + createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + createTestEmbeddablePropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer(); + valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + ListIterator specifiedOverrides = valueAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("parcelNumber", specifiedOverrides.next().getName()); + assertEquals("size", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + + specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("city", specifiedOverrides.next().getName()); + assertEquals("state.name", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + resourceField.moveAnnotation(1, 0, AttributeOverrideAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + specifiedOverrides = valueAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("size", specifiedOverrides.next().getName()); + assertEquals("parcelNumber", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + + specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("city", specifiedOverrides.next().getName()); + assertEquals("state.name", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + + + resourceField.moveAnnotation(3, 2, AttributeOverrideAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + specifiedOverrides = valueAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("size", specifiedOverrides.next().getName()); + assertEquals("parcelNumber", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + + specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("state.name", specifiedOverrides.next().getName()); + assertEquals("city", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + } + + public void testSelfReferentialElementCollection() throws Exception { + createSelfReferentialElementCollection(); + addXmlClassRef(PACKAGE_NAME + ".Foo"); + + //If there is a StackOverflowError you will not be able to get the mapping + JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("elementCollection").getMapping(); + assertFalse(elementCollectionMapping.getAllOverridableAttributeMappingNames().iterator().hasNext()); + } + + + public void testSetSpecifiedMapKeyEnumerated() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertNull(elementCollectionMapping.getMapKeyConverter().getType()); + + elementCollectionMapping.setMapKeyConverter(BaseEnumeratedConverter.class); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME); + + assertNotNull(enumerated); + assertEquals(null, enumerated.getValue()); + + ((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.STRING); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING, enumerated.getValue()); + + ((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(null); + assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME)); + assertNull(enumerated.getValue()); + + elementCollectionMapping.setMapKeyConverter(null); + assertNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME)); + } + + public void testGetSpecifiedMapKeyEnumeratedUpdatesFromResourceModelChange() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getMapKeyConverter().getType()); + + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.addAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME); + enumerated.setValue(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING); + getJpaProject().synchronizeContextModel(); + + assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType()); + + enumerated.setValue(null); + getJpaProject().synchronizeContextModel(); + assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME)); + assertNull(((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType()); + assertFalse(elementCollectionMapping.isDefault()); + assertSame(elementCollectionMapping, persistentAttribute.getMapping()); + } + + public void testSetMapKeyTemporal() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertNull(elementCollectionMapping.getMapKeyConverter().getType()); + + elementCollectionMapping.setMapKeyConverter(BaseTemporalConverter.class); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME); + + assertNotNull(temporal); + assertEquals(null, temporal.getValue()); + + ((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).setTemporalType(TemporalType.TIME); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME, temporal.getValue()); + + ((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).setTemporalType(null); + assertNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME)); + } + + public void testGetMapKeyTemporalUpdatesFromResourceModelChange() throws Exception { + createTestEntityWithValidGenericMapElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getMapKeyConverter().getType()); + + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.addAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME); + temporal.setValue(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME); + getJpaProject().synchronizeContextModel(); + + assertEquals(TemporalType.TIME, ((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).getTemporalType()); + + temporal.setValue(null); + getJpaProject().synchronizeContextModel(); + assertNotNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME)); + assertNull(((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).getTemporalType()); + assertFalse(elementCollectionMapping.isDefault()); + assertSame(elementCollectionMapping, persistentAttribute.getMapping()); + } + + + public void testGetConvert() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + resourceField.addAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(EclipseLinkConvert.class, elementCollectionMapping.getConverter().getType()); + } + + public void testGetConvert2() throws Exception { + createTestEntityWithElementCollectionMappingWithConvert(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertEquals(EclipseLinkConvert.class, elementCollectionMapping.getConverter().getType()); + assertEquals(EclipseLinkConvert.CLASS_INSTANCE_CONVERTER, ((EclipseLinkConvert) elementCollectionMapping.getConverter()).getConverterName()); + } + + public void testSetConvert() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + assertNull(elementCollectionMapping.getConverter().getType()); + + elementCollectionMapping.setConverter(EclipseLinkConvert.class); + ((EclipseLinkConvert) elementCollectionMapping.getConverter()).setSpecifiedConverterName("foo"); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + EclipseLinkConvertAnnotation eclipselinkConvert = (EclipseLinkConvertAnnotation) resourceField.getAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME); + + assertEquals("foo", eclipselinkConvert.getValue()); + + elementCollectionMapping.setConverter(null); + assertNull(resourceField.getAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME)); + } + + public void testGetConvertUpdatesFromResourceModelChange() throws Exception { + createTestEntityWithElementCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping(); + + assertNull(elementCollectionMapping.getConverter().getType()); + + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + EclipseLinkConvertAnnotation convert = (EclipseLinkConvertAnnotation) resourceField.addAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME); + convert.setValue("foo"); + getJpaProject().synchronizeContextModel(); + + assertEquals(EclipseLinkConvert.class, elementCollectionMapping.getConverter().getType()); + assertEquals("foo", ((EclipseLinkConvert) elementCollectionMapping.getConverter()).getConverterName()); + + resourceField.removeAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + assertNull(elementCollectionMapping.getConverter().getType()); + assertFalse(elementCollectionMapping.isDefault()); + assertSame(elementCollectionMapping, persistentAttribute.getMapping()); + } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java new file mode 100644 index 0000000000..754fd71d20 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java @@ -0,0 +1,1410 @@ +/******************************************************************************* + * Copyright (c) 2010, 2012 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + *******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.java; + +import java.util.Iterator; +import java.util.ListIterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind; +import org.eclipse.jpt.common.core.resource.java.JavaResourceField; +import org.eclipse.jpt.common.core.resource.java.JavaResourceType; +import org.eclipse.jpt.common.core.resource.java.NestableAnnotation; +import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.core.context.AttributeMapping; +import org.eclipse.jpt.jpa.core.context.BasicMapping; +import org.eclipse.jpt.jpa.core.context.Embeddable; +import org.eclipse.jpt.jpa.core.context.Entity; +import org.eclipse.jpt.jpa.core.context.EnumType; +import org.eclipse.jpt.jpa.core.context.BaseEnumeratedConverter; +import org.eclipse.jpt.jpa.core.context.JoinTableRelationshipStrategy; +import org.eclipse.jpt.jpa.core.context.ManyToManyMapping; +import org.eclipse.jpt.jpa.core.context.PersistentAttribute; +import org.eclipse.jpt.jpa.core.context.PersistentType; +import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride; +import org.eclipse.jpt.jpa.core.context.BaseTemporalConverter; +import org.eclipse.jpt.jpa.core.context.TemporalType; +import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride; +import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer; +import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType; +import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAttributeOverride; +import org.eclipse.jpt.jpa.core.context.persistence.ClassRef; +import org.eclipse.jpt.jpa.core.jpa2.context.ManyToManyMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.OrderColumn2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaManyToManyMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyClass2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyColumn2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyEnumerated2_0Annotation; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyTemporal2_0Annotation; +import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.core.resource.java.MapKeyAnnotation; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkJoinFetch; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkJoinFetchType; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkRelationshipMapping; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkJoinFetchAnnotation; +import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_0ContextModelTestCase; + +@SuppressWarnings("nls") +public class EclipseLink2_0JavaManyToManyMappingTests + extends EclipseLink2_0ContextModelTestCase +{ + public EclipseLink2_0JavaManyToManyMappingTests(String name) { + super(name); + } + + private ICompilationUnit createTestEntityWithJoinFetchManyToMany() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.MANY_TO_MANY, EclipseLink.JOIN_FETCH); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@ManyToMany").append(CR); + sb.append("@JoinFetch").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithValidManyToManyMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID, "java.util.Collection"); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ManyToMany").append(CR); + sb.append(" private Collection
addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithValidGenericMapManyToManyMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ManyToMany").append(CR); + sb.append(" private java.util.Map addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithValidNonGenericMapManyToManyMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ManyToMany").append(CR); + sb.append(" private java.util.Map addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private void createTestTargetEntityAddress() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.ENTITY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDED); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.MANY_TO_MANY); + sb.append(";"); + sb.append(CR); + sb.append("@Entity"); + sb.append(CR); + sb.append("public class ").append("Address").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + sb.append(" private int id;").append(CR); + sb.append(CR); + sb.append(" private String city;").append(CR); + sb.append(CR); + sb.append(" @Embedded").append(CR); + sb.append(" private State state;").append(CR); + sb.append(CR); + sb.append(" private int zip;").append(CR); + sb.append(CR); + sb.append(" @ManyToMany").append(CR); + sb.append(" private java.util.Collection employees;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter); + } + + private void createTestTargetEntityAddressWithElementCollection() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.ENTITY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA2_0.ELEMENT_COLLECTION); + sb.append(";"); + sb.append(CR); + sb.append("@Entity"); + sb.append(CR); + sb.append("public class ").append("Address").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + sb.append(" private int id;").append(CR); + sb.append(CR); + sb.append(" private String city;").append(CR); + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Collection state;").append(CR); + sb.append(CR); + sb.append(" private int zip;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter); + } + + private void createTestEmbeddableState() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("State").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private String foo;").append(CR); + sb.append(CR); + sb.append(" private String address;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter); + } + + private ICompilationUnit createTestEntityWithEmbeddableKeyManyToManyMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ManyToMany").append(CR); + sb.append(" private java.util.Map parcels;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private void createTestEmbeddableAddress() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDED); + sb.append(";"); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("Address").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private String city;").append(CR); + sb.append(CR); + sb.append(" @Embedded").append(CR); + sb.append(" private State state;").append(CR); + sb.append(CR); + sb.append(" private int zip;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter); + } + + private void createTestEntityPropertyInfo() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.ENTITY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDED); + sb.append(";"); + sb.append(CR); + sb.append("@Entity"); + sb.append(CR); + sb.append("public class ").append("PropertyInfo").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private Integer parcelNumber;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + sb.append(" private Integer size;").append(CR); + sb.append(CR); + sb.append(" private java.math.BigDecimal tax;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter); + } + + public void testGetJoinFetchValue() throws Exception { + createTestEntityWithJoinFetchManyToMany(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + EclipseLinkRelationshipMapping manyToManyMapping = (EclipseLinkRelationshipMapping) persistentAttribute.getMapping(); + EclipseLinkJoinFetch contextJoinFetch = manyToManyMapping.getJoinFetch(); + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + EclipseLinkJoinFetchAnnotation joinFetchAnnotation = (EclipseLinkJoinFetchAnnotation) resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME); + + // base annotated, test context value + + assertNull(joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue()); + + // change resource to INNER specifically, test context + + joinFetchAnnotation.setValue(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.INNER); + + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.INNER, joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue()); + + // change resource to OUTER, test context + + joinFetchAnnotation.setValue(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.OUTER); + getJpaProject().synchronizeContextModel(); + + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.OUTER, joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.OUTER, contextJoinFetch.getValue()); + + // remove value from resource, test context + + joinFetchAnnotation.setValue(null); + getJpaProject().synchronizeContextModel(); + + assertNull(joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue()); + + // remove annotation, text context + + resourceField.removeAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + assertNull(joinFetchAnnotation.getValue()); + assertNull(contextJoinFetch.getValue()); + } + + public void testSetJoinFetchValue() throws Exception { + createTestEntityWithJoinFetchManyToMany(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + EclipseLinkRelationshipMapping manyToManyMapping = (EclipseLinkRelationshipMapping) persistentAttribute.getMapping(); + EclipseLinkJoinFetch contextJoinFetch = manyToManyMapping.getJoinFetch(); + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + EclipseLinkJoinFetchAnnotation joinFetchAnnotation = (EclipseLinkJoinFetchAnnotation) resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME); + + // base annotated, test resource value + + assertNull(joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue()); + + // change context to INNER specifically, test resource + + contextJoinFetch.setValue(EclipseLinkJoinFetchType.INNER); + + assertNull(joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue()); + + // change context to OUTER, test resource + + contextJoinFetch.setValue(EclipseLinkJoinFetchType.OUTER); + + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.OUTER, joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.OUTER, contextJoinFetch.getValue()); + + // set context to null, test resource + + contextJoinFetch.setValue(null); + + assertNull(resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME)); + assertNull(contextJoinFetch.getValue()); + + // change context to INNER specifically (this time from no annotation), test resource + + contextJoinFetch.setValue(EclipseLinkJoinFetchType.INNER); + joinFetchAnnotation = (EclipseLinkJoinFetchAnnotation) resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME); + + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.INNER, joinFetchAnnotation.getValue()); + assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue()); + } + + public void testCandidateMappedByAttributeNames() throws Exception { + createTestEntityWithValidManyToManyMapping(); + createTestTargetEntityAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + PersistentAttribute persistentAttribute = (getJavaPersistentType()).getAttributes().iterator().next(); + ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping(); + + Iterator attributeNames = + manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator(); + assertEquals("id", attributeNames.next()); + assertEquals("city", attributeNames.next()); + assertEquals("state", attributeNames.next()); + assertEquals("state.foo", attributeNames.next()); + assertEquals("state.address", attributeNames.next()); + assertEquals("zip", attributeNames.next()); + assertEquals("employees", attributeNames.next()); + assertFalse(attributeNames.hasNext()); + + manyToManyMapping.setSpecifiedTargetEntity("foo"); + attributeNames = + manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator(); + assertFalse(attributeNames.hasNext()); + + manyToManyMapping.setSpecifiedTargetEntity(null); + attributeNames = + manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator(); + assertEquals("id", attributeNames.next()); + assertEquals("city", attributeNames.next()); + assertEquals("state", attributeNames.next()); + assertEquals("state.foo", attributeNames.next()); + assertEquals("state.address", attributeNames.next()); + assertEquals("zip", attributeNames.next()); + assertEquals("employees", attributeNames.next()); + assertFalse(attributeNames.hasNext()); + + AttributeMapping stateFooMapping = manyToManyMapping.getResolvedTargetEntity().resolveAttributeMapping("state.foo"); + assertEquals("foo", stateFooMapping.getName()); + } + + public void testCandidateMappedByAttributeNamesElementCollection() throws Exception { + createTestEntityWithValidManyToManyMapping(); + createTestTargetEntityAddressWithElementCollection(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + PersistentAttribute persistentAttribute = (getJavaPersistentType()).getAttributes().iterator().next(); + ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping(); + + Iterator attributeNames = + manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator(); + assertEquals("id", attributeNames.next()); + assertEquals("city", attributeNames.next()); + assertEquals("state", attributeNames.next()); + assertEquals("state.foo", attributeNames.next()); + assertEquals("state.address", attributeNames.next()); + assertEquals("zip", attributeNames.next()); + assertFalse(attributeNames.hasNext()); + + manyToManyMapping.setSpecifiedTargetEntity("foo"); + attributeNames = + manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator(); + assertFalse(attributeNames.hasNext()); + + manyToManyMapping.setSpecifiedTargetEntity(null); + attributeNames = + manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator(); + assertEquals("id", attributeNames.next()); + assertEquals("city", attributeNames.next()); + assertEquals("state", attributeNames.next()); + assertEquals("state.foo", attributeNames.next()); + assertEquals("state.address", attributeNames.next()); + assertEquals("zip", attributeNames.next()); + assertFalse(attributeNames.hasNext()); + + AttributeMapping stateFooMapping = manyToManyMapping.getResolvedTargetEntity().resolveAttributeMapping("state.foo"); + assertEquals("foo", stateFooMapping.getName()); + } + + public void testUpdateMapKey() throws Exception { + createTestEntityWithValidManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(manyToManyMapping.getSpecifiedMapKey()); + assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME)); + + //set mapKey in the resource model, verify context model does not change + resourceField.addAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNull(manyToManyMapping.getSpecifiedMapKey()); + MapKeyAnnotation mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNotNull(mapKey); + + //set mapKey name in the resource model, verify context model updated + mapKey.setName("myMapKey"); + getJpaProject().synchronizeContextModel(); + + assertEquals("myMapKey", manyToManyMapping.getSpecifiedMapKey()); + assertEquals("myMapKey", mapKey.getName()); + + //set mapKey name to null in the resource model + mapKey.setName(null); + getJpaProject().synchronizeContextModel(); + + assertNull(manyToManyMapping.getSpecifiedMapKey()); + assertNull(mapKey.getName()); + + mapKey.setName("myMapKey"); + resourceField.removeAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNull(manyToManyMapping.getSpecifiedMapKey()); + assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME)); + } + + public void testModifyMapKey() throws Exception { + createTestEntityWithValidManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(manyToManyMapping.getSpecifiedMapKey()); + assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME)); + + //set mapKey in the context model, verify resource model updated + manyToManyMapping.setSpecifiedMapKey("myMapKey"); + MapKeyAnnotation mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertEquals("myMapKey", manyToManyMapping.getSpecifiedMapKey()); + assertEquals("myMapKey", mapKey.getName()); + //set mapKey to null in the context model + manyToManyMapping.setSpecifiedMapKey(null); + assertNull(manyToManyMapping.getSpecifiedMapKey()); + mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME); + assertNull(mapKey.getName()); + } + + public void testCandidateMapKeyNames() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + createTestTargetEntityAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping manyToManyMapping2_0 = (ManyToManyMapping) persistentAttribute.getMapping(); + + Iterator mapKeyNames = + manyToManyMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals("id", mapKeyNames.next()); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.foo", mapKeyNames.next()); + assertEquals("state.address", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertEquals("employees", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + } + + public void testCandidateMapKeyNames2() throws Exception { + createTestEntityWithValidNonGenericMapManyToManyMapping(); + createTestTargetEntityAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping manyToManyMapping2_0 = (ManyToManyMapping) persistentAttribute.getMapping(); + + Iterator mapKeyNames = manyToManyMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + + manyToManyMapping2_0.setSpecifiedTargetEntity("Address"); + mapKeyNames = manyToManyMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals("id", mapKeyNames.next()); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.foo", mapKeyNames.next()); + assertEquals("state.address", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertEquals("employees", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + + manyToManyMapping2_0.setSpecifiedTargetEntity("String"); + mapKeyNames = manyToManyMapping2_0.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + } + + public void testUpdateMapKeyClass() throws Exception { + createTestEntityWithValidManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(manyToManyMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + + //set mapKey in the resource model, verify context model does not change + resourceField.addAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + assertNull(manyToManyMapping.getSpecifiedMapKeyClass()); + MapKeyClass2_0Annotation mapKeyClassAnnotation = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + assertNotNull(mapKeyClassAnnotation); + + //set mapKey name in the resource model, verify context model updated + mapKeyClassAnnotation.setValue("myMapKeyClass"); + this.getJpaProject().synchronizeContextModel(); + assertEquals("myMapKeyClass", manyToManyMapping.getSpecifiedMapKeyClass()); + assertEquals("myMapKeyClass", mapKeyClassAnnotation.getValue()); + + //set mapKey name to null in the resource model + mapKeyClassAnnotation.setValue(null); + this.getJpaProject().synchronizeContextModel(); + assertNull(manyToManyMapping.getSpecifiedMapKeyClass()); + assertNull(mapKeyClassAnnotation.getValue()); + + mapKeyClassAnnotation.setValue("myMapKeyClass"); + resourceField.removeAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + assertNull(manyToManyMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + } + + public void testModifyMapKeyClass() throws Exception { + createTestEntityWithValidManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + assertNull(manyToManyMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + + //set mapKey in the context model, verify resource model updated + manyToManyMapping.setSpecifiedMapKeyClass("String"); + MapKeyClass2_0Annotation mapKeyClass = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME); + assertEquals("String", manyToManyMapping.getSpecifiedMapKeyClass()); + assertEquals("String", mapKeyClass.getValue()); + + //set mapKey to null in the context model + manyToManyMapping.setSpecifiedMapKeyClass(null); + assertNull(manyToManyMapping.getSpecifiedMapKeyClass()); + assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME)); + } + + public void testDefaultMapKeyClass() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + createTestTargetEntityAddress(); + createTestEmbeddableState(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + + assertEquals("java.lang.Integer", manyToManyMapping.getDefaultMapKeyClass()); + + //test default still the same when specified target entity it set + manyToManyMapping.setSpecifiedMapKeyClass("foo"); + assertEquals("java.lang.Integer", manyToManyMapping.getDefaultMapKeyClass()); + } + + public void testDefaultMapKeyClassCollectionType() throws Exception { + createTestEntityWithValidManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + + assertNull(manyToManyMapping.getDefaultMapKeyClass()); + } + + public void testMapKeyClass() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + + assertEquals("java.lang.Integer", manyToManyMapping.getMapKeyClass()); + + manyToManyMapping.setSpecifiedMapKeyClass("foo"); + assertEquals("foo", manyToManyMapping.getMapKeyClass()); + + manyToManyMapping.setSpecifiedMapKeyClass(null); + assertEquals("java.lang.Integer", manyToManyMapping.getMapKeyClass()); + } + + public void testOrderColumnDefaults() throws Exception { + createTestEntityPrintQueue(); + createTestEntityPrintJob(); + + addXmlClassRef(PACKAGE_NAME + ".PrintQueue"); + addXmlClassRef(PACKAGE_NAME + ".PrintJob"); + JavaPersistentType printQueuePersistentType = (JavaPersistentType) getPersistenceUnit().getPersistentType("test.PrintQueue"); + ManyToManyMapping jobsMapping = (ManyToManyMapping) printQueuePersistentType.getAttributeNamed("jobs").getMapping(); + JavaPersistentType printJobPersistentType = (JavaPersistentType) getPersistenceUnit().getPersistentType("test.PrintJob"); + ManyToManyMapping queuesMapping = (ManyToManyMapping) printJobPersistentType.getAttributeNamed("queues").getMapping(); + + Orderable2_0 jobsOrderable = ((Orderable2_0) jobsMapping.getOrderable()); + OrderColumn2_0 jobsOrderColumn = jobsOrderable.getOrderColumn(); + assertEquals(true, jobsOrderable.isOrderColumnOrdering()); + assertEquals(null, jobsOrderColumn.getSpecifiedName()); + assertEquals("jobs_ORDER", jobsOrderColumn.getDefaultName()); + assertEquals("PrintJob_PrintQueue", jobsOrderColumn.getTable()); //the join table name + Orderable2_0 queuesOrderable = ((Orderable2_0) queuesMapping.getOrderable()); + OrderColumn2_0 queuesOrderColumn = queuesOrderable.getOrderColumn(); + assertEquals(true, queuesOrderable.isOrderColumnOrdering()); + assertEquals(null, queuesOrderColumn.getSpecifiedName()); + assertEquals("queues_ORDER", queuesOrderColumn.getDefaultName()); + assertEquals("PrintJob_PrintQueue", queuesOrderColumn.getTable()); + + jobsOrderColumn.setSpecifiedName("FOO"); + assertEquals("FOO", jobsOrderColumn.getSpecifiedName()); + assertEquals("jobs_ORDER", jobsOrderColumn.getDefaultName()); + assertEquals("PrintJob_PrintQueue", jobsOrderColumn.getTable()); + queuesOrderColumn.setSpecifiedName("BAR"); + assertEquals("BAR", queuesOrderColumn.getSpecifiedName()); + assertEquals("queues_ORDER", queuesOrderColumn.getDefaultName()); + assertEquals("PrintJob_PrintQueue", queuesOrderColumn.getTable()); + + ((Entity) printJobPersistentType.getMapping()).getTable().setSpecifiedName("MY_TABLE"); + assertEquals("MY_TABLE_PrintQueue", jobsOrderColumn.getTable()); + assertEquals("MY_TABLE_PrintQueue", queuesOrderColumn.getTable()); + + ((Entity) printQueuePersistentType.getMapping()).getTable().setSpecifiedName("OTHER_TABLE"); + assertEquals("MY_TABLE_OTHER_TABLE", jobsOrderColumn.getTable()); + assertEquals("MY_TABLE_OTHER_TABLE", queuesOrderColumn.getTable()); + + queuesMapping.getRelationship().getJoinTableStrategy().getJoinTable().setSpecifiedName("MY_JOIN_TABLE"); + assertEquals("MY_JOIN_TABLE", jobsOrderColumn.getTable()); + assertEquals("MY_JOIN_TABLE", queuesOrderColumn.getTable()); + } + + private void createTestEntityPrintQueue() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.ENTITY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.MANY_TO_MANY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA2_0.ORDER_COLUMN); + sb.append(";"); + sb.append(CR); + sb.append("@Entity"); + sb.append(CR); + sb.append("public class ").append("PrintQueue").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + sb.append(" private String name;").append(CR); + sb.append(CR); + sb.append(" @ManyToMany(mappedBy=\"queues\")").append(CR); + sb.append(" @OrderColumn").append(CR); + sb.append(" private java.util.List jobs;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "PrintQueue.java", sourceWriter); + } + + private void createTestEntityPrintJob() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.ENTITY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.MANY_TO_MANY); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA2_0.ORDER_COLUMN); + sb.append(";"); + sb.append(CR); + sb.append("@Entity"); + sb.append(CR); + sb.append("public class ").append("PrintJob").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + sb.append(" private int id;").append(CR); + sb.append(CR); + sb.append(" @ManyToMany").append(CR); + sb.append(" @OrderColumn").append(CR); + sb.append(" private java.util.List queues;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "PrintJob.java", sourceWriter); + } + + public void testGetMapKeyColumnMappedByStrategy() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + createTestTargetEntityAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + manyToManyMapping.getRelationship().setStrategyToMappedBy(); + manyToManyMapping.getRelationship().getMappedByStrategy().setMappedByAttribute("employees"); + + assertNull(manyToManyMapping.getMapKeyColumn().getSpecifiedName()); + assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getName()); + assertEquals("Address_" + TYPE_NAME, manyToManyMapping.getMapKeyColumn().getTable());//join table name of owning many-to-many + + PersistentType persistentType = getPersistenceUnit().getPersistentType("test.Address"); + ManyToManyMapping owningManyToManyMapping = (ManyToManyMapping) persistentType.getAttributeNamed("employees").getMapping(); + ((JoinTableRelationshipStrategy) owningManyToManyMapping.getRelationship().getStrategy()).getJoinTable().setSpecifiedName("MY_JOIN_TABLE"); + assertEquals("MY_JOIN_TABLE", manyToManyMapping.getMapKeyColumn().getTable()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyColumn2_0Annotation column = (MapKeyColumn2_0Annotation) resourceField.addAnnotation(JPA2_0.MAP_KEY_COLUMN); + column.setName("foo"); + getJpaProject().synchronizeContextModel(); + + assertEquals("foo", manyToManyMapping.getMapKeyColumn().getSpecifiedName()); + assertEquals("foo", manyToManyMapping.getMapKeyColumn().getName()); + assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getDefaultName()); + } + + public void testGetMapKeyColumnJoinTableStrategy() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + createTestTargetEntityAddress(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping(); + + assertNull(manyToManyMapping.getMapKeyColumn().getSpecifiedName()); + assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getName()); + assertEquals(TYPE_NAME + "_Address", manyToManyMapping.getMapKeyColumn().getTable());//join table name + + manyToManyMapping.getRelationship().getJoinTableStrategy().getJoinTable().setSpecifiedName("MY_JOIN_TABLE"); + assertEquals("MY_JOIN_TABLE", manyToManyMapping.getMapKeyColumn().getTable()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyColumn2_0Annotation column = (MapKeyColumn2_0Annotation) resourceField.addAnnotation(JPA2_0.MAP_KEY_COLUMN); + column.setName("foo"); + getJpaProject().synchronizeContextModel(); + + assertEquals("foo", manyToManyMapping.getMapKeyColumn().getSpecifiedName()); + assertEquals("foo", manyToManyMapping.getMapKeyColumn().getName()); + assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getDefaultName()); + } + + public void testMapKeySpecifiedAttributeOverrides() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".State"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + + ListIterator specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.BAR"); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAZ"); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BLAH"); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + //move an annotation to the resource model and verify the context model is updated + resourceField.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName()); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName()); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + + resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + getJpaProject().synchronizeContextModel(); + specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertFalse(specifiedMapKeyAttributeOverrides.hasNext()); + } + + public void testMapKeyValueVirtualAttributeOverrides() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + assertEquals("parcels", resourceField.getName()); + assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME)); + + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + ReadOnlyAttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("city", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + ListIterator classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator(); + classRefs.next(); + Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping(); + + BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping(); + cityMapping.getColumn().setSpecifiedName("FOO"); + cityMapping.getColumn().setSpecifiedTable("BAR"); + cityMapping.getColumn().setColumnDefinition("COLUMN_DEF"); + cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE); + cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE); + cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5)); + cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6)); + cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7)); + + assertEquals("parcels", resourceField.getName()); + assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME)); + + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("FOO", defaultAttributeOverride.getColumn().getName()); + assertEquals("BAR", defaultAttributeOverride.getColumn().getTable()); + assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(false, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(false, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(5, defaultAttributeOverride.getColumn().getLength()); + assertEquals(6, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(7, defaultAttributeOverride.getColumn().getScale()); + + cityMapping.getColumn().setSpecifiedName(null); + cityMapping.getColumn().setSpecifiedTable(null); + cityMapping.getColumn().setColumnDefinition(null); + cityMapping.getColumn().setSpecifiedInsertable(null); + cityMapping.getColumn().setSpecifiedUpdatable(null); + cityMapping.getColumn().setSpecifiedUnique(null); + cityMapping.getColumn().setSpecifiedNullable(null); + cityMapping.getColumn().setSpecifiedLength(null); + cityMapping.getColumn().setSpecifiedPrecision(null); + cityMapping.getColumn().setSpecifiedScale(null); + defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next(); + assertEquals("city", defaultAttributeOverride.getName()); + assertEquals("city", defaultAttributeOverride.getColumn().getName()); + assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable()); + assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition()); + assertEquals(true, defaultAttributeOverride.getColumn().isInsertable()); + assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable()); + assertEquals(false, defaultAttributeOverride.getColumn().isUnique()); + assertEquals(true, defaultAttributeOverride.getColumn().isNullable()); + assertEquals(255, defaultAttributeOverride.getColumn().getLength()); + assertEquals(0, defaultAttributeOverride.getColumn().getPrecision()); + assertEquals(0, defaultAttributeOverride.getColumn().getScale()); + + AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + annotation.setName("key.city"); + getJpaProject().synchronizeContextModel(); + assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + assertEquals(0, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAR"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.FOO2"); + getJpaProject().synchronizeContextModel(); + + assertEquals(3, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize()); + } + + public void testMapKeyValueAttributeOverridesSize() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + assertEquals(4, mapKeyAttributeOverrideContainer.getOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAR"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("value.FOO2"); + getJpaProject().synchronizeContextModel(); + + assertEquals(7, mapKeyAttributeOverrideContainer.getOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("city"); + getJpaProject().synchronizeContextModel(); + assertEquals(7, mapKeyAttributeOverrideContainer.getOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.state.foo"); + getJpaProject().synchronizeContextModel(); + assertEquals(7, mapKeyAttributeOverrideContainer.getOverridesSize()); + } + + public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + //add an annotation to the resource model and verify the context model is updated + AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("FOO"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.BAR"); + getJpaProject().synchronizeContextModel(); + + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.city"); + getJpaProject().synchronizeContextModel(); + assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("key.state.foo"); + attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE); + attributeOverride.setName("size"); + getJpaProject().synchronizeContextModel(); + assertEquals(2, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + } + + public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual(); + attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + assertFalse(attributeOverrides.hasNext()); + + Iterator virtualAttributeOverrides = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator(); + assertEquals("city", virtualAttributeOverrides.next().getName()); + assertEquals("state.foo", virtualAttributeOverrides.next().getName()); + assertEquals("state.address", virtualAttributeOverrides.next().getName()); + assertEquals("zip", virtualAttributeOverrides.next().getName()); + assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize()); + } + + + public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception { + createTestEntityWithEmbeddableKeyManyToManyMapping(); + createTestEmbeddableAddress(); + createTestEmbeddableState(); + createTestEntityPropertyInfo(); + + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + addXmlClassRef(PACKAGE_NAME + ".Address"); + addXmlClassRef(PACKAGE_NAME + ".PropertyInfo"); + addXmlClassRef(PACKAGE_NAME + ".State"); + + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping(); + JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + ListIterator specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("city", specifiedOverrides.next().getName()); + assertEquals("state.foo", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + + resourceField.moveAnnotation(1, 0, AttributeOverrideAnnotation.ANNOTATION_NAME); + getJpaProject().synchronizeContextModel(); + + Iterator attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator(); + + assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName()); + assertFalse(attributeOverrides.hasNext()); + + specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("state.foo", specifiedOverrides.next().getName()); + assertEquals("city", specifiedOverrides.next().getName()); + assertFalse(specifiedOverrides.hasNext()); + } + + public void testSetSpecifiedMapKeyEnumerated() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping(); + assertNull(manyToManyMapping.getMapKeyConverter().getType()); + + manyToManyMapping.setMapKeyConverter(BaseEnumeratedConverter.class); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME); + + assertNotNull(enumerated); + assertEquals(null, enumerated.getValue()); + + ((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.STRING); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING, enumerated.getValue()); + + ((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).setSpecifiedEnumType(null); + assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME)); + assertNull(enumerated.getValue()); + + manyToManyMapping.setMapKeyConverter(null); + assertNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME)); + } + + public void testGetSpecifiedMapKeyEnumeratedUpdatesFromResourceModelChange() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping(); + + assertNull(manyToManyMapping.getMapKeyConverter().getType()); + + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.addAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME); + enumerated.setValue(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING); + getJpaProject().synchronizeContextModel(); + + assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).getSpecifiedEnumType()); + + enumerated.setValue(null); + getJpaProject().synchronizeContextModel(); + assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME)); + assertNull(((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).getSpecifiedEnumType()); + assertFalse(manyToManyMapping.isDefault()); + assertSame(manyToManyMapping, persistentAttribute.getMapping()); + } + + public void testSetMapKeyTemporal() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping(); + assertNull(manyToManyMapping.getMapKeyConverter().getType()); + + manyToManyMapping.setMapKeyConverter(BaseTemporalConverter.class); + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME); + + assertNotNull(temporal); + assertEquals(null, temporal.getValue()); + + ((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).setTemporalType(TemporalType.TIME); + assertEquals(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME, temporal.getValue()); + + ((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).setTemporalType(null); + assertNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME)); + } + + public void testGetMapKeyTemporalUpdatesFromResourceModelChange() throws Exception { + createTestEntityWithValidGenericMapManyToManyMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next(); + JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping(); + + assertNull(manyToManyMapping.getMapKeyConverter().getType()); + + + JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE); + JavaResourceField resourceField = resourceType.getFields().iterator().next(); + MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.addAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME); + temporal.setValue(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME); + getJpaProject().synchronizeContextModel(); + + assertEquals(TemporalType.TIME, ((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).getTemporalType()); + + temporal.setValue(null); + getJpaProject().synchronizeContextModel(); + assertNotNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME)); + assertNull(((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).getTemporalType()); + assertFalse(manyToManyMapping.isDefault()); + assertSame(manyToManyMapping, persistentAttribute.getMapping()); + } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java new file mode 100644 index 0000000000..d337783f5b --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java @@ -0,0 +1,435 @@ +/******************************************************************************* + * Copyright (c) 2009, 2012 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + *******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm; + +import java.util.Iterator; +import java.util.ListIterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.common.core.resource.java.JavaResourceField; +import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.core.MappingKeys; +import org.eclipse.jpt.jpa.core.context.AccessType; +import org.eclipse.jpt.jpa.core.context.BasicMapping; +import org.eclipse.jpt.jpa.core.context.IdMapping; +import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute; +import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentAttribute; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType; +import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyPersistentAttribute; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm.OrmEclipseLinkIdMapping; +import org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm.OrmEclipseLinkOneToOneMapping; +import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink1_1ContextModelTestCase; + +@SuppressWarnings("nls") +public class EclipseLink1_1OrmPersistentAttributeTests + extends EclipseLink1_1ContextModelTestCase +{ + public EclipseLink1_1OrmPersistentAttributeTests(String name) { + super(name); + } + + + private ICompilationUnit createTestTypeNullAttributeMapping() throws Exception { + + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" private Address address;").append(CR); + sb.append(CR); + } + }); + } + + private ICompilationUnit createTestEntityIdMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, JPA.COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity"); + } + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Id"); + sb.append("@Column(name=\"FOO\")"); + } + }); + } + + private ICompilationUnit createTestEntityIdMappingPropertyAccess() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, JPA.COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity"); + } + @Override + public void appendGetIdMethodAnnotationTo(StringBuilder sb) { + sb.append("@Id"); + sb.append("@Column(name=\"FOO\")"); + } + }); + } + + private ICompilationUnit createTestEntityOneToOneMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ONE_TO_ONE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity"); + } + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@OneToOne"); + sb.append(" private Address address;"); + } + }); + } + + public void testMakeSpecified() throws Exception { + createTestType(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + assertEquals(2, ormPersistentType.getDefaultAttributesSize()); + + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + assertEquals("id", ormPersistentAttribute.getName()); + assertTrue(ormPersistentAttribute.isVirtual()); + ormPersistentAttribute.addToXml(); + + assertEquals(1, ormPersistentType.getDefaultAttributesSize()); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + assertEquals("id", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + + ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + ormPersistentAttribute.addToXml(); + + assertEquals(0, ormPersistentType.getDefaultAttributesSize()); + assertEquals(2, ormPersistentType.getSpecifiedAttributesSize()); + Iterator specifiedAttributes = ormPersistentType.getSpecifiedAttributes().iterator(); + specifiedOrmPersistentAttribute = specifiedAttributes.next(); + assertEquals("id", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + + specifiedOrmPersistentAttribute = specifiedAttributes.next(); + assertEquals("name", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + } + + public void testMakeSpecifiedMappingKey() throws Exception { + createTestTypeNullAttributeMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + assertEquals(3, ormPersistentType.getDefaultAttributesSize()); + + //take a virtual mapping with a mapping type and make it specified + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + assertEquals("address", ormPersistentAttribute.getName()); + assertTrue(ormPersistentAttribute.isVirtual()); + assertNull(ormPersistentAttribute.getMapping().getKey()); + ormPersistentAttribute.addToXml(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY); + + assertEquals(2, ormPersistentType.getDefaultAttributesSize()); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + assertEquals("address", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + assertTrue(specifiedOrmPersistentAttribute.getMapping() instanceof OrmEclipseLinkOneToOneMapping); + + + ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + ormPersistentAttribute.addToXml(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY); + + assertEquals(1, ormPersistentType.getDefaultAttributesSize()); + assertEquals(2, ormPersistentType.getSpecifiedAttributesSize()); + Iterator specifiedAttributes = ormPersistentType.getSpecifiedAttributes().iterator(); + + specifiedOrmPersistentAttribute = specifiedAttributes.next(); + assertEquals("id", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + assertTrue(specifiedOrmPersistentAttribute.getMapping() instanceof OrmEclipseLinkIdMapping); + + specifiedOrmPersistentAttribute = specifiedAttributes.next(); + assertEquals("address", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + } + + public void testMakeVirtual() throws Exception { + createTestType(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + assertEquals(2, ormPersistentType.getDefaultAttributesSize()); + + ormPersistentType.getDefaultAttributes().iterator().next().addToXml(); + ormPersistentType.getDefaultAttributes().iterator().next().addToXml(); + + assertEquals(0, ormPersistentType.getDefaultAttributesSize()); + assertEquals(2, ormPersistentType.getSpecifiedAttributesSize()); + OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + assertEquals("id", specifiedOrmPersistentAttribute.getName()); + assertFalse(specifiedOrmPersistentAttribute.isVirtual()); + + specifiedOrmPersistentAttribute.removeFromXml(); + assertEquals(1, ormPersistentType.getDefaultAttributesSize()); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + + specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + specifiedOrmPersistentAttribute.removeFromXml(); + assertEquals(2, ormPersistentType.getDefaultAttributesSize()); + assertEquals(0, ormPersistentType.getSpecifiedAttributesSize()); + + Iterator virtualAttributes = ormPersistentType.getDefaultAttributes().iterator(); + OrmReadOnlyPersistentAttribute virtualAttribute = virtualAttributes.next(); + assertEquals("id", virtualAttribute.getName()); + virtualAttribute = virtualAttributes.next(); + assertEquals("name", virtualAttribute.getName()); + } + + public void testMakeVirtualNoUnderlyingJavaAttribute() throws Exception { + createTestType(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + assertEquals(2, ormPersistentType.getDefaultAttributesSize()); + + ormPersistentType.getDefaultAttributes().iterator().next().addToXml(); + ormPersistentType.getDefaultAttributes().iterator().next().addToXml(); + + + ormPersistentType.getSpecifiedAttributes().iterator().next().getMapping().setName("noJavaAttribute"); + assertEquals(1, ormPersistentType.getDefaultAttributesSize()); + assertEquals(2, ormPersistentType.getSpecifiedAttributesSize()); + + + OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + specifiedOrmPersistentAttribute.removeFromXml(); + assertEquals(1, ormPersistentType.getDefaultAttributesSize()); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + + assertEquals("id", ormPersistentType.getDefaultAttributes().iterator().next().getName()); + assertEquals("name", ormPersistentType.getSpecifiedAttributes().iterator().next().getName()); + } + + public void testVirtualMappingTypeWhenMetadataComplete() throws Exception { + createTestEntityIdMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + assertEquals("id", ormPersistentAttribute.getName()); + assertEquals(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey()); + assertEquals("FOO", ((IdMapping) ormPersistentAttribute.getMapping()).getColumn().getName()); + + + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + + ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + assertEquals("id", ormPersistentAttribute.getName()); + assertEquals(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey()); + assertEquals("id", ((BasicMapping) ormPersistentAttribute.getMapping()).getColumn().getName()); + } + + public void testVirtualMappingTypeWhenMetadataComplete2() throws Exception { + createTestEntityOneToOneMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + assertEquals("address", ormPersistentAttribute.getName()); + assertEquals(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey()); + + + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + + ormPersistentAttribute = ormPersistentType.getAttributeNamed("address"); + assertEquals("address", ormPersistentAttribute.getName()); + assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey()); + } + + public void testGetJavaPersistentAttribute() throws Exception { + createTestEntityIdMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType(); + + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id"); + + //virtual orm attribute, access type matches java : FIELD, name matches java + assertTrue(ormPersistentAttribute.isVirtual()); + assertNotSame(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute()); + JavaResourceAttribute javaResourceAttribute = ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute(); + assertTrue(javaResourceAttribute instanceof JavaResourceField); + assertEquals("id", javaResourceAttribute.getName()); + assertEquals(javaPersistentType.getJavaResourceType().getFields().iterator().next(), javaResourceAttribute); + + + //specified orm attribute, access type matches java : FIELD, name matches java + //javaPersistentAttribute should be == to java context model object + ormPersistentAttribute.addToXml(); + ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + assertFalse(ormPersistentAttribute.isVirtual()); + assertEquals(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute()); + + + //virtual orm attribute, java access type FIELD, orm access type PROPERTY, name matches java + //verify both the property java resource attribute and the field java resource attribute are used in orm + //because the field is annotated and property is specified + ((OrmPersistentAttribute) ormPersistentAttribute).removeFromXml(); + ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + ormPersistentType.setSpecifiedAccess(AccessType.PROPERTY); + ListIterator attributes = ormPersistentType.getAttributes().iterator(); + OrmReadOnlyPersistentAttribute idFieldAttribute = attributes.next(); + OrmReadOnlyPersistentAttribute idPropertyAttribute = attributes.next(); + assertEquals(ormPersistentAttribute, idFieldAttribute); + assertNotSame(ormPersistentAttribute, idPropertyAttribute); + ormPersistentAttribute = idPropertyAttribute; + assertNotSame(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute()); + assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess()); + assertEquals(AccessType.PROPERTY, ormPersistentAttribute.getJavaPersistentAttribute().getAccess()); + assertEquals(AccessType.FIELD, idFieldAttribute.getJavaPersistentAttribute().getAccess()); + javaResourceAttribute = ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute(); + assertEquals("id", javaResourceAttribute.getName()); + assertEquals(javaPersistentType.getJavaResourceType().getMethods().iterator().next(), javaResourceAttribute); + + + ormPersistentType.setSpecifiedAccess(null);//default access will be field + ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + OrmPersistentAttribute ormPersistentAttribute2 = ormPersistentAttribute.addToXml(); + ormPersistentAttribute2.getMapping().setName("id2"); + assertEquals(null, ormPersistentAttribute2.getJavaPersistentAttribute()); + + ormPersistentAttribute2.getMapping().setName(null); + assertEquals(null, ormPersistentAttribute2.getJavaPersistentAttribute()); + + ormPersistentAttribute2.getMapping().setName("id"); + assertEquals(javaPersistentAttribute, ormPersistentAttribute2.getJavaPersistentAttribute()); + + + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + assertEquals(javaPersistentAttribute, ormPersistentAttribute2.getJavaPersistentAttribute()); + } + + public void testGetJavaPersistentAttributeMixedAccess() throws Exception { + createTestEntityIdMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + ormPersistentType.setSpecifiedAccess(AccessType.PROPERTY); + JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType(); + + ListIterator attributes = ormPersistentType.getAttributes().iterator(); + OrmReadOnlyPersistentAttribute ormFieldAttribute = attributes.next(); + OrmReadOnlyPersistentAttribute ormPropertyAttribute = attributes.next(); + JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id"); + + assertEquals(AccessType.FIELD, ormFieldAttribute.getAccess()); + assertEquals(AccessType.PROPERTY, ormPropertyAttribute.getAccess()); + assertEquals(AccessType.FIELD, javaPersistentAttribute.getOwningPersistentType().getAccess()); + assertTrue(ormFieldAttribute.isVirtual()); + assertTrue(ormPropertyAttribute.isVirtual()); + assertNotSame(javaPersistentAttribute, ormPropertyAttribute.getJavaPersistentAttribute()); + assertEquals(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY, ormFieldAttribute.getMappingKey()); + assertEquals(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY, ormPropertyAttribute.getMappingKey()); + assertEquals(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY, javaPersistentAttribute.getMappingKey()); + + + ormPropertyAttribute.addToXml(); + ormPropertyAttribute = ormPersistentType.getAttributeNamed("id"); + assertFalse(ormPropertyAttribute.isVirtual()); + assertEquals(AccessType.PROPERTY, ormPropertyAttribute.getAccess()); + assertNotSame(javaPersistentAttribute, ormPropertyAttribute.getJavaPersistentAttribute()); + assertTrue(ormPropertyAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.METHOD); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD); + + ((OrmPersistentAttribute) ormPropertyAttribute).setSpecifiedAccess(AccessType.FIELD); + ormPropertyAttribute = ormPersistentType.getAttributeNamed("id"); + assertFalse(ormPropertyAttribute.isVirtual()); + assertEquals(AccessType.FIELD, ormPropertyAttribute.getAccess()); + assertEquals(javaPersistentAttribute, ormPropertyAttribute.getJavaPersistentAttribute()); + assertTrue(ormPropertyAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.FIELD); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD); + } + + public void testGetAccess() throws Exception { + createTestEntityIdMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType(); + + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id"); + + assertTrue(ormPersistentAttribute.isVirtual()); + assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess()); + assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.FIELD); + assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess()); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD); + + + ormPersistentAttribute.addToXml(); + ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + assertFalse(ormPersistentAttribute.isVirtual()); + assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess()); + assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.FIELD); + assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess()); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD); + + + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + assertFalse(ormPersistentAttribute.isVirtual()); + assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess()); + assertEquals(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute()); + assertEquals(AccessType.FIELD, ormPersistentAttribute.getJavaPersistentAttribute().getAccess()); + assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess()); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD); + } + + public void testGetAccessPropertyInJava() throws Exception { + createTestEntityIdMappingPropertyAccess(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType(); + + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id"); + + assertTrue(ormPersistentAttribute.isVirtual()); + assertEquals(AccessType.PROPERTY, ormPersistentAttribute.getAccess()); + assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.METHOD); + assertEquals(AccessType.PROPERTY, javaPersistentAttribute.getAccess()); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.METHOD); + + + ormPersistentAttribute.addToXml(); + ormPersistentAttribute = ormPersistentType.getAttributeNamed("id"); + assertFalse(ormPersistentAttribute.isVirtual()); + assertEquals(AccessType.PROPERTY, ormPersistentAttribute.getAccess()); + assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.METHOD); + assertEquals(AccessType.PROPERTY, javaPersistentAttribute.getAccess()); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.METHOD); + + + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + assertFalse(ormPersistentAttribute.isVirtual()); + assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess()); + assertNotSame(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute()); + assertEquals(AccessType.FIELD, ormPersistentAttribute.getJavaPersistentAttribute().getAccess()); + assertEquals(AccessType.PROPERTY, javaPersistentAttribute.getAccess()); + assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.METHOD); + } + +} \ No newline at end of file diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java new file mode 100644 index 0000000000..9dccb43689 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java @@ -0,0 +1,1703 @@ +/******************************************************************************* + * Copyright (c) 2010, 2012 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm; + +import java.util.Iterator; +import java.util.ListIterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.core.MappingKeys; +import org.eclipse.jpt.jpa.core.context.AttributeOverride; +import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer; +import org.eclipse.jpt.jpa.core.context.BasicMapping; +import org.eclipse.jpt.jpa.core.context.Column; +import org.eclipse.jpt.jpa.core.context.EmbeddedIdMapping; +import org.eclipse.jpt.jpa.core.context.EmbeddedMapping; +import org.eclipse.jpt.jpa.core.context.EnumType; +import org.eclipse.jpt.jpa.core.context.BaseEnumeratedConverter; +import org.eclipse.jpt.jpa.core.context.FetchType; +import org.eclipse.jpt.jpa.core.context.IdMapping; +import org.eclipse.jpt.jpa.core.context.ManyToManyMapping; +import org.eclipse.jpt.jpa.core.context.ManyToOneMapping; +import org.eclipse.jpt.jpa.core.context.OneToManyMapping; +import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride; +import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn; +import org.eclipse.jpt.jpa.core.context.BaseTemporalConverter; +import org.eclipse.jpt.jpa.core.context.TemporalType; +import org.eclipse.jpt.jpa.core.context.TransientMapping; +import org.eclipse.jpt.jpa.core.context.VersionMapping; +import org.eclipse.jpt.jpa.core.context.VirtualAttributeOverride; +import org.eclipse.jpt.jpa.core.context.java.JavaBasicMapping; +import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverride; +import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer; +import org.eclipse.jpt.jpa.core.context.orm.OrmColumn; +import org.eclipse.jpt.jpa.core.context.orm.OrmEntity; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentAttribute; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType; +import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyPersistentAttribute; +import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.ElementCollectionMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.OrderColumn2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaElementCollectionMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmElementCollectionMapping2_0; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory; +import org.eclipse.jpt.jpa.core.resource.orm.XmlElementCollection; +import org.eclipse.jpt.jpa.core.resource.orm.v2_0.XmlElementCollection_2_0; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConvert; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkElementCollectionMapping2_0; +import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlConvertibleMapping; +import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_0ContextModelTestCase; + +@SuppressWarnings("nls") +public class EclipseLink2_0OrmElementCollectionMappingTests + extends EclipseLink2_0ContextModelTestCase +{ + private static final String ATTRIBUTE_OVERRIDE_NAME = "city"; + private static final String ATTRIBUTE_OVERRIDE_COLUMN_NAME = "E_CITY"; + + public EclipseLink2_0OrmElementCollectionMappingTests(String name) { + super(name); + } + + private ICompilationUnit createTestEntityWithElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.FETCH_TYPE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection(targetClass=String.class, fetch=FetchType.EAGER)"); + sb.append(CR); + sb.append(" private java.util.Collection
address;").append(CR); + sb.append(CR); + sb.append(" @Id"); + } + }); + } + + private void createTestTargetEmbeddableAddress() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA.ID); + sb.append(";"); + sb.append(CR); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("Address").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private String city;").append(CR); + sb.append(CR); + sb.append(" private State state;").append(CR); + sb.append(CR); + sb.append(" private int zip;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter); + } + + private ICompilationUnit createTestEntityWithEmbeddableElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.FETCH_TYPE, JPA.ATTRIBUTE_OVERRIDE, JPA.COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection"); + sb.append(CR); + sb.append(" @AttributeOverride(name=\"" + ATTRIBUTE_OVERRIDE_NAME + "\", column=@Column(name=\"" + ATTRIBUTE_OVERRIDE_COLUMN_NAME + "\"))"); + sb.append(" private java.util.Collection
addresses;").append(CR); + sb.append(CR); + sb.append(" @Id"); + } + }); + } + + private ICompilationUnit createTestEntityWithNonGenericElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Collection addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithGenericBasicElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Collection addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private ICompilationUnit createTestEntityWithValidMapElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Map addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private void createTestEmbeddableState() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append(CR); + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("State").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" private String name;").append(CR); + sb.append(CR); + sb.append(" private String abbr;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter); + } + + private ICompilationUnit createTestEntityWithValidNonGenericMapElementCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.Map addresses;").append(CR); + sb.append(CR); + sb.append(" @Id").append(CR); + } + }); + } + + private void createSelfReferentialElementCollection() throws Exception { + SourceWriter sourceWriter = new SourceWriter() { + public void appendSourceTo(StringBuilder sb) { + sb.append("import "); + sb.append(JPA.EMBEDDABLE); + sb.append(";"); + sb.append(CR); + sb.append("import "); + sb.append(JPA2_0.ELEMENT_COLLECTION); + sb.append(";"); + sb.append(CR).append(CR); + sb.append("@Embeddable"); + sb.append(CR); + sb.append("public class ").append("Foo").append(" "); + sb.append("{").append(CR); + sb.append(CR); + sb.append(" @ElementCollection").append(CR); + sb.append(" private java.util.List elementCollection;").append(CR); + sb.append(CR); + sb.append("}").append(CR); + } + }; + this.javaProject.createCompilationUnit(PACKAGE_NAME, "Foo.java", sourceWriter); + } + + private ICompilationUnit createTestTypeWithCollection() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator("java.util.Collection"); + } + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append(" private Collection elementCollection;").append(CR); + } + }); + } + + public void testUpdateName() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertEquals("elementCollection", ormElementCollectionMapping.getName()); + assertEquals("elementCollection", elementCollection.getName()); + + //set name in the resource model, verify context model updated + elementCollection.setName("newName"); + assertEquals("newName", ormElementCollectionMapping.getName()); + assertEquals("newName", elementCollection.getName()); + + //set name to null in the resource model + elementCollection.setName(null); + assertNull(ormElementCollectionMapping.getName()); + assertNull(elementCollection.getName()); + } + + public void testModifyName() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertEquals("elementCollection", ormElementCollectionMapping.getName()); + assertEquals("elementCollection", elementCollection.getName()); + + //set name in the context model, verify resource model updated + ormElementCollectionMapping.setName("newName"); + assertEquals("newName", ormElementCollectionMapping.getName()); + assertEquals("newName", elementCollection.getName()); + + //set name to null in the context model + ormElementCollectionMapping.setName(null); + assertNull(ormElementCollectionMapping.getName()); + assertNull(elementCollection.getName()); + } + + public void testMappingNoUnderylingJavaAttribute() throws Exception { + createTestEntityWithElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("address"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ormPersistentAttribute.getMapping().setName("foo"); + + assertEquals(3, ormPersistentType.getDefaultAttributesSize()); + + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + assertEquals("foo", ormElementCollectionMapping.getName()); + + assertNull(ormElementCollectionMapping.getSpecifiedFetch()); + assertEquals(FetchType.LAZY, ormElementCollectionMapping.getFetch()); + } + + + public void testVirtualMappingMetadataCompleteFalse() throws Exception { + createTestEntityWithElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + assertEquals(3, ormPersistentType.getDefaultAttributesSize()); + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + + ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertEquals("address", virtualElementCollectionMapping.getName()); + assertEquals(FetchType.EAGER, virtualElementCollectionMapping.getSpecifiedFetch()); + assertEquals("String", virtualElementCollectionMapping.getSpecifiedTargetClass()); + + ormPersistentAttribute.addToXml(); + ormPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertEquals("address", ormElementCollectionMapping.getName()); + assertEquals(null, ormElementCollectionMapping.getSpecifiedFetch()); + assertEquals(FetchType.LAZY, ormElementCollectionMapping.getDefaultFetch()); + assertEquals(null, ormElementCollectionMapping.getSpecifiedTargetClass()); + assertEquals(PACKAGE_NAME + ".Address", ormElementCollectionMapping.getDefaultTargetClass()); + } + + public void testVirtualMappingMetadataCompleteTrue() throws Exception { + createTestEntityWithElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + assertEquals(3, ormPersistentType.getDefaultAttributesSize()); + OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("address"); + + assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey()); + + ormPersistentAttribute.addToXml(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ormPersistentAttribute= ormPersistentType.getSpecifiedAttributes().iterator().next(); + + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertEquals("address", ormElementCollectionMapping.getName()); + assertEquals(FetchType.LAZY, ormElementCollectionMapping.getFetch()); + } + + public void testSpecifiedMapping() throws Exception { + createTestEntityWithElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + + ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("address"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + assertEquals(2, ormPersistentType.getDefaultAttributesSize()); + + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next(); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + assertEquals("address", ormElementCollectionMapping.getName()); + assertNull(ormElementCollectionMapping.getSpecifiedFetch()); + assertEquals(FetchType.LAZY, ormElementCollectionMapping.getFetch()); + } + + + public void testMorphToIdMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof IdMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); + } + + public void testMorphToVersionMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof VersionMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); + } + + public void testMorphToTransientMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof TransientMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); + } + + public void testMorphToEmbeddedMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof EmbeddedMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); + } + + public void testMorphToEmbeddedIdMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof EmbeddedIdMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); + } + + public void testMorphToManyToManyMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof ManyToManyMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); +// assertEquals(FetchType.EAGER, ((ManyToManyMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch()); + } + + public void testMorphToOneToManyMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof OneToManyMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); +// assertEquals(FetchType.EAGER, ((OneToManyMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch()); + } + + public void testMorphToManyToOneMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof ManyToOneMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); +// assertEquals(FetchType.EAGER, ((ManyToOneMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch()); + } + + public void testMorphToBasicMapping() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + assertFalse(elementCollectionMapping.isDefault()); + elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertFalse(elementCollectionMapping.isDefault()); + + ormPersistentAttribute.setMappingKey(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY); + assertEquals(1, ormPersistentType.getSpecifiedAttributesSize()); + assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next()); + assertTrue(ormPersistentAttribute.getMapping() instanceof BasicMapping); + assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName()); +//TODO assertEquals(FetchType.EAGER, ((IBasicMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch()); + } + + public void testUpdateSpecifiedFetch() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + + //set fetch in the resource model, verify context model updated + elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.orm.FetchType.EAGER); + assertEquals(FetchType.EAGER, ormElementCollectionMapping.getSpecifiedFetch()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.EAGER, elementCollection.getFetch()); + + elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.orm.FetchType.LAZY); + assertEquals(FetchType.LAZY, ormElementCollectionMapping.getSpecifiedFetch()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.LAZY, elementCollection.getFetch()); + + //set fetch to null in the resource model + elementCollection.setFetch(null); + assertNull(ormElementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + } + + public void testModifySpecifiedFetch() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedFetch()); + assertNull(elementCollection.getFetch()); + + //set fetch in the context model, verify resource model updated + ormElementCollectionMapping.setSpecifiedFetch(FetchType.EAGER); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.EAGER, elementCollection.getFetch()); + assertEquals(FetchType.EAGER, ormElementCollectionMapping.getSpecifiedFetch()); + + ormElementCollectionMapping.setSpecifiedFetch(FetchType.LAZY); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.LAZY, elementCollection.getFetch()); + assertEquals(FetchType.LAZY, ormElementCollectionMapping.getSpecifiedFetch()); + + //set fetch to null in the context model + ormElementCollectionMapping.setSpecifiedFetch(null); + assertNull(elementCollection.getFetch()); + assertNull(ormElementCollectionMapping.getSpecifiedFetch()); + } + + public void testUpdateSpecifiedTargetClass() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection_2_0 elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollection.getTargetClass()); + + //set target class in the resource model, verify context model updated + elementCollection.setTargetClass("newTargetClass"); + assertEquals("newTargetClass", ormElementCollectionMapping.getSpecifiedTargetClass()); + assertEquals("newTargetClass", elementCollection.getTargetClass()); + + //set target class to null in the resource model + elementCollection.setTargetClass(null); + assertNull(ormElementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollection.getTargetClass()); + } + + public void testModifySpecifiedTargetClass() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection_2_0 elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollection.getTargetClass()); + + //set target class in the context model, verify resource model updated + ormElementCollectionMapping.setSpecifiedTargetClass("newTargetClass"); + assertEquals("newTargetClass", ormElementCollectionMapping.getSpecifiedTargetClass()); + assertEquals("newTargetClass", elementCollection.getTargetClass()); + + //set target class to null in the context model + ormElementCollectionMapping.setSpecifiedTargetClass(null); + assertNull(ormElementCollectionMapping.getSpecifiedTargetClass()); + assertNull(elementCollection.getTargetClass()); + } + + + public void testGetValueTypeEmbeddable() throws Exception { + createTestEntityWithEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, "test.Address"); + + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType()); + } + + public void testGetValueTypeEntity() throws Exception { + createTestEntityWithEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.Address"); + + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.BASIC_TYPE, elementCollectionMapping.getValueType()); + } + + public void testGetValueTypeNone() throws Exception { + createTestEntityWithNonGenericElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, "test.Address"); + + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.NO_TYPE, elementCollectionMapping.getValueType()); + + elementCollectionMapping.setSpecifiedTargetClass("test.Address"); + assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType()); + } + + public void testGetValueTypeBasic() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.Address"); + + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + assertEquals(ElementCollectionMapping2_0.Type.BASIC_TYPE, elementCollectionMapping.getValueType()); + } + + + public void testUpdateMapKey() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedMapKey()); + assertNull(elementCollection.getMapKey()); + + //set mapKey in the resource model, verify context model does not change + elementCollection.setMapKey(OrmFactory.eINSTANCE.createMapKey()); + assertNull(ormElementCollectionMapping.getSpecifiedMapKey()); + assertNotNull(elementCollection.getMapKey()); + + //set mapKey name in the resource model, verify context model updated + elementCollection.getMapKey().setName("myMapKey"); + assertEquals("myMapKey", ormElementCollectionMapping.getSpecifiedMapKey()); + assertEquals("myMapKey", elementCollection.getMapKey().getName()); + + //set mapKey name to null in the resource model + elementCollection.getMapKey().setName(null); + assertNull(ormElementCollectionMapping.getSpecifiedMapKey()); + assertNull(elementCollection.getMapKey().getName()); + + elementCollection.getMapKey().setName("myMapKey"); + elementCollection.setMapKey(null); + assertNull(ormElementCollectionMapping.getSpecifiedMapKey()); + assertNull(elementCollection.getMapKey()); + } + + public void testUpdateVirtualMapKey() throws Exception { + createTestEntityWithValidMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping(); + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + assertNull(virtualElementCollectionMapping.getSpecifiedMapKey()); + assertNull(virtualElementCollectionMapping.getMapKey()); + assertFalse(virtualElementCollectionMapping.isPkMapKey()); + assertFalse(virtualElementCollectionMapping.isCustomMapKey()); + assertTrue(virtualElementCollectionMapping.isNoMapKey()); + + //set pk mapKey in the java, verify virtual orm mapping updates + javaElementCollectionMapping.setPkMapKey(true); + assertEquals(null, virtualElementCollectionMapping.getMapKey());//no primary key on an embeddable + assertTrue(virtualElementCollectionMapping.isPkMapKey()); + assertFalse(virtualElementCollectionMapping.isCustomMapKey()); + assertFalse(virtualElementCollectionMapping.isNoMapKey()); + + + //set custom specified mapKey in the java, verify virtual orm mapping updates + javaElementCollectionMapping.setCustomMapKey(true); + javaElementCollectionMapping.setSpecifiedMapKey("city"); + assertEquals("city", virtualElementCollectionMapping.getSpecifiedMapKey()); + assertEquals("city", virtualElementCollectionMapping.getMapKey()); + assertFalse(virtualElementCollectionMapping.isPkMapKey()); + assertTrue(virtualElementCollectionMapping.isCustomMapKey()); + assertFalse(virtualElementCollectionMapping.isNoMapKey()); + } + + public void testModifyMapKey() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection xmlElementColection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedMapKey()); + assertNull(xmlElementColection.getMapKey()); + + //set mapKey in the context model, verify resource model updated + ormElementCollectionMapping.setSpecifiedMapKey("myMapKey"); + assertEquals("myMapKey", ormElementCollectionMapping.getSpecifiedMapKey()); + assertEquals("myMapKey", xmlElementColection.getMapKey().getName()); + + //set mapKey to null in the context model + ormElementCollectionMapping.setSpecifiedMapKey(null); + assertNull(ormElementCollectionMapping.getSpecifiedMapKey()); + assertNull(xmlElementColection.getMapKey().getName()); + } + + public void testCandidateMapKeyNames() throws Exception { + createTestEntityWithValidMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping(); + + Iterator mapKeyNames = + virtualElementCollectionMapping.getCandidateMapKeyNames().iterator(); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.name", mapKeyNames.next()); + assertEquals("state.abbr", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + } + + public void testCandidateMapKeyNames2() throws Exception { + createTestEntityWithValidNonGenericMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State"); + OrmReadOnlyPersistentAttribute attribute = ormPersistentType.getAttributeNamed("addresses"); + ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) attribute.getMapping(); + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + + Iterator mapKeyNames = virtualElementCollectionMapping.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + + javaElementCollectionMapping.setSpecifiedTargetClass("test.Address"); + mapKeyNames = virtualElementCollectionMapping.getCandidateMapKeyNames().iterator(); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.name", mapKeyNames.next()); + assertEquals("state.abbr", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + + attribute.addToXml(); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping(); + mapKeyNames = ormElementCollectionMapping.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + + ormElementCollectionMapping.setSpecifiedTargetClass("test.Address"); + mapKeyNames = ormElementCollectionMapping.getCandidateMapKeyNames().iterator(); + assertEquals("city", mapKeyNames.next()); + assertEquals("state", mapKeyNames.next()); + assertEquals("state.name", mapKeyNames.next()); + assertEquals("state.abbr", mapKeyNames.next()); + assertEquals("zip", mapKeyNames.next()); + assertFalse(mapKeyNames.hasNext()); + + ormElementCollectionMapping.setSpecifiedTargetClass("String"); + mapKeyNames = ormElementCollectionMapping.getCandidateMapKeyNames().iterator(); + assertEquals(false, mapKeyNames.hasNext()); + } + + public void testUpdateMapKeyClass() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(elementCollection.getMapKeyClass()); + + //set mapKey in the resource model, verify context model does not change + elementCollection.setMapKeyClass(OrmFactory.eINSTANCE.createXmlClassReference()); + assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertNotNull(elementCollection.getMapKeyClass()); + + //set mapKey name in the resource model, verify context model updated + elementCollection.getMapKeyClass().setClassName("String"); + assertEquals("String", ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertEquals("String", elementCollection.getMapKeyClass().getClassName()); + + //set mapKey name to null in the resource model + elementCollection.getMapKeyClass().setClassName(null); + assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(elementCollection.getMapKeyClass().getClassName()); + + elementCollection.getMapKeyClass().setClassName("String"); + elementCollection.setMapKeyClass(null); + assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(elementCollection.getMapKeyClass()); + } + + public void testUpdateVirtualMapKeyClass() throws Exception { + createTestEntityWithValidMapElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State"); + + ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping(); + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + assertNull(virtualElementCollectionMapping.getSpecifiedMapKeyClass()); + assertEquals("java.lang.String", virtualElementCollectionMapping.getMapKeyClass()); + assertEquals("java.lang.String", virtualElementCollectionMapping.getDefaultMapKeyClass()); + + //set pk mapKey in the java, verify virtual orm mapping updates + javaElementCollectionMapping.setSpecifiedMapKeyClass("Integer"); + assertEquals("Integer", virtualElementCollectionMapping.getMapKeyClass()); + assertEquals("Integer", virtualElementCollectionMapping.getSpecifiedMapKeyClass()); + assertEquals("java.lang.String", virtualElementCollectionMapping.getDefaultMapKeyClass()); + } + + public void testModifyMapKeyClass() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(elementCollection.getMapKeyClass()); + + //set mapKey in the context model, verify resource model updated + ormElementCollectionMapping.setSpecifiedMapKeyClass("String"); + assertEquals("String", ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertEquals("String", elementCollection.getMapKeyClass().getClassName()); + + //set mapKey to null in the context model + ormElementCollectionMapping.setSpecifiedMapKeyClass(null); + assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass()); + assertNull(elementCollection.getMapKeyClass()); + } + public void testOrderColumnDefaults() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 elementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + Orderable2_0 orderable = (Orderable2_0) elementCollectionMapping.getOrderable(); + assertEquals(false, orderable.isOrderColumnOrdering()); + assertEquals(true, orderable.isNoOrdering()); + + orderable.setOrderColumnOrdering(true); + OrderColumn2_0 orderColumn = orderable.getOrderColumn(); + assertEquals(true, orderable.isOrderColumnOrdering()); + assertEquals(null, orderColumn.getSpecifiedName()); + assertEquals("addresses_ORDER", orderColumn.getDefaultName()); + assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable()); + + orderColumn.setSpecifiedName("FOO"); + assertEquals("FOO", orderColumn.getSpecifiedName()); + assertEquals("addresses_ORDER", orderColumn.getDefaultName()); + assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable()); + } + + public void testVirtualOrderColumn() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 elementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + + Orderable2_0 orderable = (Orderable2_0) elementCollectionMapping.getOrderable(); + assertEquals(false, orderable.isOrderColumnOrdering()); + assertEquals(true, orderable.isNoOrdering()); + + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentAttribute.getJavaPersistentAttribute().getMapping(); + ((Orderable2_0) javaElementCollectionMapping.getOrderable()).setOrderColumnOrdering(true); + + assertEquals(false, orderable.isOrderColumnOrdering()); + assertEquals(true, orderable.isNoOrdering()); + + ormPersistentAttribute.removeFromXml(); + OrmReadOnlyPersistentAttribute ormPersistentAttribute2 = ormPersistentType.getAttributeNamed("addresses"); + ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute2.getMapping(); + orderable = (Orderable2_0) virtualElementCollectionMapping.getOrderable(); + assertEquals(true, orderable.isOrderColumnOrdering()); + assertEquals(false, orderable.isNoOrdering()); + assertEquals(TYPE_NAME + "_addresses", orderable.getOrderColumn().getTable()); + assertEquals("addresses_ORDER", orderable.getOrderColumn().getName()); + + ((Orderable2_0) javaElementCollectionMapping.getOrderable()).getOrderColumn().setSpecifiedName("FOO"); + assertEquals(TYPE_NAME + "_addresses", orderable.getOrderColumn().getTable()); + assertEquals("FOO", orderable.getOrderColumn().getName()); + } + + public void testVirtualValueColumnDefaults() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + //virtual attrubte in orm.xml, java attribute has no value Column annotation + OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + Column virtualColumn = addressesVirtualMapping.getValueColumn(); + assertEquals("addresses", virtualColumn.getName()); + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable()); + assertEquals(null, virtualColumn.getColumnDefinition()); + assertTrue(virtualColumn.isInsertable()); + assertTrue(virtualColumn.isUpdatable()); + assertTrue(virtualColumn.isNullable()); + assertFalse(virtualColumn.isUnique()); + assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, virtualColumn.getLength()); + assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, virtualColumn.getPrecision()); + assertEquals(ReadOnlyColumn.DEFAULT_SCALE, virtualColumn.getScale()); + + //set Column annotation in Java + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + javaElementCollectionMapping.getValueColumn().setSpecifiedName("FOO"); + javaElementCollectionMapping.getValueColumn().setSpecifiedTable("FOO_TABLE"); + javaElementCollectionMapping.getValueColumn().setColumnDefinition("COLUMN_DEFINITION"); + javaElementCollectionMapping.getValueColumn().setSpecifiedInsertable(Boolean.FALSE); + javaElementCollectionMapping.getValueColumn().setSpecifiedUpdatable(Boolean.FALSE); + javaElementCollectionMapping.getValueColumn().setSpecifiedNullable(Boolean.FALSE); + javaElementCollectionMapping.getValueColumn().setSpecifiedUnique(Boolean.TRUE); + javaElementCollectionMapping.getValueColumn().setSpecifiedLength(Integer.valueOf(45)); + javaElementCollectionMapping.getValueColumn().setSpecifiedPrecision(Integer.valueOf(46)); + javaElementCollectionMapping.getValueColumn().setSpecifiedScale(Integer.valueOf(47)); + + assertEquals("FOO", virtualColumn.getSpecifiedName()); + assertEquals("FOO_TABLE", virtualColumn.getSpecifiedTable()); + assertEquals("COLUMN_DEFINITION", virtualColumn.getColumnDefinition()); + assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedInsertable()); + assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedUpdatable()); + assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedNullable()); + assertEquals(Boolean.TRUE, virtualColumn.getSpecifiedUnique()); + assertEquals(Integer.valueOf(45), virtualColumn.getSpecifiedLength()); + assertEquals(Integer.valueOf(46), virtualColumn.getSpecifiedPrecision()); + assertEquals(Integer.valueOf(47), virtualColumn.getSpecifiedScale()); + + + //set metadata-complete, orm.xml virtual column ignores java column annotation + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + addressesPersistentAttribute = ormPersistentType.getAttributeNamed("addresses"); + //no longer an element collection mapping + assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, addressesPersistentAttribute.getMappingKey()); + } + + public void testNullColumnDefaults() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + OrmElementCollectionMapping2_0 addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + OrmColumn ormColumn = addressesVirtualMapping.getValueColumn(); + + //set Column annotation in Java + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + javaElementCollectionMapping.getValueColumn().setSpecifiedName("FOO"); + javaElementCollectionMapping.getValueColumn().setSpecifiedTable("FOO_TABLE"); + javaElementCollectionMapping.getValueColumn().setColumnDefinition("COLUMN_DEFINITION"); + javaElementCollectionMapping.getValueColumn().setSpecifiedInsertable(Boolean.FALSE); + javaElementCollectionMapping.getValueColumn().setSpecifiedUpdatable(Boolean.FALSE); + javaElementCollectionMapping.getValueColumn().setSpecifiedNullable(Boolean.FALSE); + javaElementCollectionMapping.getValueColumn().setSpecifiedUnique(Boolean.TRUE); + javaElementCollectionMapping.getValueColumn().setSpecifiedLength(Integer.valueOf(45)); + javaElementCollectionMapping.getValueColumn().setSpecifiedPrecision(Integer.valueOf(46)); + javaElementCollectionMapping.getValueColumn().setSpecifiedScale(Integer.valueOf(47)); + + + assertEquals("addresses", ormColumn.getDefaultName()); + assertEquals(TYPE_NAME + "_addresses", ormColumn.getDefaultTable()); + assertEquals(true, ormColumn.isDefaultInsertable()); + assertEquals(true, ormColumn.isDefaultUpdatable()); + assertEquals(true, ormColumn.isDefaultNullable()); + assertEquals(false, ormColumn.isDefaultUnique()); + assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, ormColumn.getDefaultLength()); + assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, ormColumn.getDefaultPrecision()); + assertEquals(ReadOnlyColumn.DEFAULT_SCALE, ormColumn.getDefaultScale()); + assertNull(ormColumn.getSpecifiedName()); + assertNull(ormColumn.getSpecifiedTable()); + assertNull(ormColumn.getColumnDefinition()); + assertNull(ormColumn.getSpecifiedInsertable()); + assertNull(ormColumn.getSpecifiedUpdatable()); + assertNull(ormColumn.getSpecifiedNullable()); + assertNull(ormColumn.getSpecifiedUnique()); + assertNull(ormColumn.getSpecifiedLength()); + assertNull(ormColumn.getSpecifiedPrecision()); + assertNull(ormColumn.getSpecifiedScale()); + } + + public void testVirtualValueColumnTable() throws Exception { + createTestEntityWithGenericBasicElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + //default attribute in orm.xml, java attribute has no Column annotation + OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + Column virtualColumn = addressesVirtualMapping.getValueColumn(); + + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable()); + + //entity table should have no affect on the collection table default name + ((OrmEntity) ormPersistentType.getMapping()).getTable().setSpecifiedName("ORM_TABLE"); + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable()); + + //set Column table element in Java + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + javaElementCollectionMapping.getCollectionTable().setSpecifiedName("JAVA_COLLECTION_TABLE"); + assertEquals("JAVA_COLLECTION_TABLE", virtualColumn.getTable()); + javaElementCollectionMapping.getValueColumn().setSpecifiedTable("JAVA_TABLE"); + assertEquals("JAVA_TABLE", virtualColumn.getTable()); + + //make name persistent attribute not default + addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + virtualColumn = addressesVirtualMapping.getValueColumn(); + assertNull(virtualColumn.getSpecifiedTable()); + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getDefaultTable()); + } + + public void testMoveSpecifiedAttributeOverride() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + OrmAttributeOverrideContainer attributeOverrideContainer = ormElementCollectionMapping.getValueAttributeOverrideContainer(); + XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride()); + elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride()); + elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride()); + + elementCollectionResource.getAttributeOverrides().get(0).setName("FOO"); + elementCollectionResource.getAttributeOverrides().get(1).setName("BAR"); + elementCollectionResource.getAttributeOverrides().get(2).setName("BAZ"); + + assertEquals(3, elementCollectionResource.getAttributeOverrides().size()); + + attributeOverrideContainer.moveSpecifiedOverride(2, 0); + ListIterator attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAR", attributeOverrides.next().getName()); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertEquals("FOO", attributeOverrides.next().getName()); + + assertEquals("BAR", elementCollectionResource.getAttributeOverrides().get(0).getName()); + assertEquals("BAZ", elementCollectionResource.getAttributeOverrides().get(1).getName()); + assertEquals("FOO", elementCollectionResource.getAttributeOverrides().get(2).getName()); + + + attributeOverrideContainer.moveSpecifiedOverride(0, 1); + attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertEquals("BAR", attributeOverrides.next().getName()); + assertEquals("FOO", attributeOverrides.next().getName()); + + assertEquals("BAZ", elementCollectionResource.getAttributeOverrides().get(0).getName()); + assertEquals("BAR", elementCollectionResource.getAttributeOverrides().get(1).getName()); + assertEquals("FOO", elementCollectionResource.getAttributeOverrides().get(2).getName()); + } + + public void testUpdateAttributeOverrides() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + OrmAttributeOverrideContainer attributeOverrideContainer = ormElementCollectionMapping.getValueAttributeOverrideContainer(); + XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride()); + elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride()); + elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride()); + + elementCollectionResource.getAttributeOverrides().get(0).setName("FOO"); + elementCollectionResource.getAttributeOverrides().get(1).setName("BAR"); + elementCollectionResource.getAttributeOverrides().get(2).setName("BAZ"); + + ListIterator attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("FOO", attributeOverrides.next().getName()); + assertEquals("BAR", attributeOverrides.next().getName()); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertFalse(attributeOverrides.hasNext()); + + elementCollectionResource.getAttributeOverrides().move(2, 0); + attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAR", attributeOverrides.next().getName()); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertEquals("FOO", attributeOverrides.next().getName()); + assertFalse(attributeOverrides.hasNext()); + + elementCollectionResource.getAttributeOverrides().move(0, 1); + attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertEquals("BAR", attributeOverrides.next().getName()); + assertEquals("FOO", attributeOverrides.next().getName()); + assertFalse(attributeOverrides.hasNext()); + + elementCollectionResource.getAttributeOverrides().remove(1); + attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertEquals("FOO", attributeOverrides.next().getName()); + assertFalse(attributeOverrides.hasNext()); + + elementCollectionResource.getAttributeOverrides().remove(1); + attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + assertEquals("BAZ", attributeOverrides.next().getName()); + assertFalse(attributeOverrides.hasNext()); + + elementCollectionResource.getAttributeOverrides().remove(0); + assertFalse(attributeOverrideContainer.getSpecifiedOverrides().iterator().hasNext()); + } + + public void testElementCollectionMappingNoUnderylingJavaAttribute() throws Exception { + createTestEntityWithEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses")); + ormPersistentAttribute.getMapping().setName("foo"); + assertEquals(3, ormPersistentType.getDefaultAttributesSize()); + + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + OrmAttributeOverrideContainer attributeOverrideContainer = ormElementCollectionMapping.getValueAttributeOverrideContainer(); + + assertEquals("foo", ormElementCollectionMapping.getName()); + + + assertFalse(attributeOverrideContainer.getSpecifiedOverrides().iterator().hasNext()); + assertFalse(attributeOverrideContainer.getVirtualOverrides().iterator().hasNext()); + } + + public void testVirtualAttributeOverrides() throws Exception { + createTestEntityWithEmbeddableElementCollectionMapping(); + createTestTargetEmbeddableAddress(); + createTestEmbeddableState(); + + OrmPersistentType persistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address"); + OrmPersistentType persistentType3 = getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State"); + + //embedded mapping is virtual, specified attribute overrides should exist + OrmReadOnlyPersistentAttribute ormPersistentAttribute = persistentType.getAttributeNamed("addresses"); + ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + assertEquals(4, attributeOverrideContainer.getOverridesSize()); + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(1, attributeOverrideContainer.getSpecifiedOverridesSize()); + ListIterator specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + ReadOnlyAttributeOverride attributeOverride = specifiedAttributeOverrides.next(); + assertEquals("city", attributeOverride.getName()); + ListIterator virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + attributeOverride = virtualAttributeOverrides.next(); + assertEquals("state.name", attributeOverride.getName()); + attributeOverride = virtualAttributeOverrides.next(); + assertEquals("state.abbr", attributeOverride.getName()); + attributeOverride = virtualAttributeOverrides.next(); + assertEquals("zip", attributeOverride.getName()); + + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentAttribute.getJavaPersistentAttribute().getMapping(); + Column javaAttributeOverrideColumn = javaElementCollectionMapping.getValueAttributeOverrideContainer().getSpecifiedOverrides().iterator().next().getColumn(); + + javaAttributeOverrideColumn.setSpecifiedName("FOO_COLUMN"); + javaAttributeOverrideColumn.setSpecifiedTable("FOO_TABLE"); + javaAttributeOverrideColumn.setColumnDefinition("COLUMN_DEF"); + javaAttributeOverrideColumn.setSpecifiedInsertable(Boolean.FALSE); + javaAttributeOverrideColumn.setSpecifiedUpdatable(Boolean.FALSE); + javaAttributeOverrideColumn.setSpecifiedUnique(Boolean.TRUE); + javaAttributeOverrideColumn.setSpecifiedNullable(Boolean.FALSE); + javaAttributeOverrideColumn.setSpecifiedLength(Integer.valueOf(5)); + javaAttributeOverrideColumn.setSpecifiedPrecision(Integer.valueOf(6)); + javaAttributeOverrideColumn.setSpecifiedScale(Integer.valueOf(7)); + + JavaBasicMapping javaBasicMapping = (JavaBasicMapping) persistentType3.getJavaPersistentType().getAttributeNamed("name").getMapping(); + javaBasicMapping.getColumn().setSpecifiedName("MY_STATE_COLUMN"); + assertEquals(4, attributeOverrideContainer.getOverridesSize()); + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(1, attributeOverrideContainer.getSpecifiedOverridesSize()); + specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator(); + attributeOverride = specifiedAttributeOverrides.next(); + assertEquals("city", attributeOverride.getName()); + assertEquals("FOO_COLUMN", attributeOverride.getColumn().getSpecifiedName()); + assertEquals("FOO_TABLE", attributeOverride.getColumn().getSpecifiedTable()); + assertEquals("COLUMN_DEF", attributeOverride.getColumn().getColumnDefinition()); + assertEquals(false, attributeOverride.getColumn().isInsertable()); + assertEquals(false, attributeOverride.getColumn().isUpdatable()); + assertEquals(true, attributeOverride.getColumn().isUnique()); + assertEquals(false, attributeOverride.getColumn().isNullable()); + assertEquals(5, attributeOverride.getColumn().getLength()); + assertEquals(6, attributeOverride.getColumn().getPrecision()); + assertEquals(7, attributeOverride.getColumn().getScale()); + + virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + attributeOverride = virtualAttributeOverrides.next(); + assertEquals("state.name", attributeOverride.getName()); + assertEquals("MY_STATE_COLUMN", attributeOverride.getColumn().getSpecifiedName()); + attributeOverride = virtualAttributeOverrides.next(); + assertEquals("state.abbr", attributeOverride.getName()); + attributeOverride = virtualAttributeOverrides.next(); + assertEquals("zip", attributeOverride.getName()); + + + + //embedded mapping is specified, virtual attribute overrides should exist + persistentType.getAttributeNamed("addresses").addToXml(); + elementCollectionMapping = (OrmElementCollectionMapping2_0) persistentType.getAttributeNamed("addresses").getMapping(); + attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer(); + assertEquals(4, attributeOverrideContainer.getOverridesSize()); + assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize()); + assertEquals(0, attributeOverrideContainer.getSpecifiedOverridesSize()); + virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + ReadOnlyAttributeOverride virtualOverride = virtualAttributeOverrides.next(); + assertEquals("city", virtualOverride.getName()); + virtualOverride = virtualAttributeOverrides.next(); + assertEquals("state.name", virtualOverride.getName()); + assertEquals("MY_STATE_COLUMN", virtualOverride.getColumn().getName()); + assertEquals(TYPE_NAME + "_addresses", virtualOverride.getColumn().getTable()); + assertEquals(null, virtualOverride.getColumn().getColumnDefinition()); + assertEquals(true, virtualOverride.getColumn().isInsertable()); + assertEquals(true, virtualOverride.getColumn().isUpdatable()); + assertEquals(false, virtualOverride.getColumn().isUnique()); + assertEquals(true, virtualOverride.getColumn().isNullable()); + assertEquals(255, virtualOverride.getColumn().getLength()); + assertEquals(0, virtualOverride.getColumn().getPrecision()); + assertEquals(0, virtualOverride.getColumn().getScale()); + virtualOverride = virtualAttributeOverrides.next(); + assertEquals("state.abbr", virtualOverride.getName()); + assertEquals(TYPE_NAME + "_addresses", virtualOverride.getColumn().getDefaultTable()); + virtualOverride = virtualAttributeOverrides.next(); + assertEquals("zip", virtualOverride.getName()); + + //set one of the virtual attribute overrides to specified, verify others are still virtual + attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified(); + + assertEquals(4, attributeOverrideContainer.getOverridesSize()); + assertEquals(1, attributeOverrideContainer.getSpecifiedOverridesSize()); + assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize()); + assertEquals("city", attributeOverrideContainer.getSpecifiedOverrides().iterator().next().getName()); + virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator(); + virtualOverride = virtualAttributeOverrides.next(); + assertEquals("state.name", virtualOverride.getName()); + virtualOverride = virtualAttributeOverrides.next(); + assertEquals("state.abbr", virtualOverride.getName()); + virtualOverride = virtualAttributeOverrides.next(); + assertEquals("zip", virtualOverride.getName()); + } + public void testVirtualMapKeyColumnDefaults() throws Exception { + createTestEntityWithValidMapElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + //virtual attribute in orm.xml, java attribute has no value Column annotation + OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + Column virtualColumn = addressesVirtualMapping.getMapKeyColumn(); + assertEquals("addresses_KEY", virtualColumn.getName()); + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable()); + assertEquals(null, virtualColumn.getColumnDefinition()); + assertTrue(virtualColumn.isInsertable()); + assertTrue(virtualColumn.isUpdatable()); + assertTrue(virtualColumn.isNullable()); + assertFalse(virtualColumn.isUnique()); + assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, virtualColumn.getLength()); + assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, virtualColumn.getPrecision()); + assertEquals(ReadOnlyColumn.DEFAULT_SCALE, virtualColumn.getScale()); + + //set Column annotation in Java + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedName("FOO"); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedTable("FOO_TABLE"); + javaElementCollectionMapping.getMapKeyColumn().setColumnDefinition("COLUMN_DEFINITION"); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedInsertable(Boolean.FALSE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUpdatable(Boolean.FALSE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedNullable(Boolean.FALSE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUnique(Boolean.TRUE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedLength(Integer.valueOf(45)); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedPrecision(Integer.valueOf(46)); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedScale(Integer.valueOf(47)); + + assertEquals("FOO", virtualColumn.getSpecifiedName()); + assertEquals("FOO_TABLE", virtualColumn.getSpecifiedTable()); + assertEquals("COLUMN_DEFINITION", virtualColumn.getColumnDefinition()); + assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedInsertable()); + assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedUpdatable()); + assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedNullable()); + assertEquals(Boolean.TRUE, virtualColumn.getSpecifiedUnique()); + assertEquals(Integer.valueOf(45), virtualColumn.getSpecifiedLength()); + assertEquals(Integer.valueOf(46), virtualColumn.getSpecifiedPrecision()); + assertEquals(Integer.valueOf(47), virtualColumn.getSpecifiedScale()); + + + //set metadata-complete, orm.xml virtual column ignores java column annotation + ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE); + addressesPersistentAttribute = ormPersistentType.getAttributeNamed("addresses"); + //no longer an element collection mapping + assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, addressesPersistentAttribute.getMappingKey()); + } + + public void testNullMapKeyColumnDefaults() throws Exception { + createTestEntityWithValidMapElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + + OrmElementCollectionMapping2_0 addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + Column ormColumn = addressesVirtualMapping.getMapKeyColumn(); + + //set Column annotation in Java + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedName("FOO"); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedTable("FOO_TABLE"); + javaElementCollectionMapping.getMapKeyColumn().setColumnDefinition("COLUMN_DEFINITION"); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedInsertable(Boolean.FALSE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUpdatable(Boolean.FALSE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedNullable(Boolean.FALSE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUnique(Boolean.TRUE); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedLength(Integer.valueOf(45)); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedPrecision(Integer.valueOf(46)); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedScale(Integer.valueOf(47)); + + + assertEquals("addresses_KEY", ormColumn.getDefaultName()); + assertEquals(TYPE_NAME + "_addresses", ormColumn.getDefaultTable()); + assertEquals(true, ormColumn.isDefaultInsertable()); + assertEquals(true, ormColumn.isDefaultUpdatable()); + assertEquals(true, ormColumn.isDefaultNullable()); + assertEquals(false, ormColumn.isDefaultUnique()); + assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, ormColumn.getDefaultLength()); + assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, ormColumn.getDefaultPrecision()); + assertEquals(ReadOnlyColumn.DEFAULT_SCALE, ormColumn.getDefaultScale()); + assertNull(ormColumn.getSpecifiedName()); + assertNull(ormColumn.getSpecifiedTable()); + assertNull(ormColumn.getColumnDefinition()); + assertNull(ormColumn.getSpecifiedInsertable()); + assertNull(ormColumn.getSpecifiedUpdatable()); + assertNull(ormColumn.getSpecifiedNullable()); + assertNull(ormColumn.getSpecifiedUnique()); + assertNull(ormColumn.getSpecifiedLength()); + assertNull(ormColumn.getSpecifiedPrecision()); + assertNull(ormColumn.getSpecifiedScale()); + } + + public void testVirtualMapKeyColumnTable() throws Exception { + createTestEntityWithValidMapElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + + //virtual attribute in orm.xml, java attribute has no Column annotation + OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next(); + ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + Column virtualColumn = addressesVirtualMapping.getMapKeyColumn(); + + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable()); + + //entity table should have no affect on the collection table default name + ((OrmEntity) ormPersistentType.getMapping()).getTable().setSpecifiedName("ORM_TABLE"); + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable()); + + //set Column table element in Java + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping(); + javaElementCollectionMapping.getCollectionTable().setSpecifiedName("JAVA_COLLECTION_TABLE"); + assertEquals("JAVA_COLLECTION_TABLE", virtualColumn.getTable()); + javaElementCollectionMapping.getMapKeyColumn().setSpecifiedTable("JAVA_TABLE"); + assertEquals("JAVA_TABLE", virtualColumn.getTable()); + + //make addresses persistent attribute not default + addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping(); + virtualColumn = addressesVirtualMapping.getMapKeyColumn(); + assertNull(virtualColumn.getSpecifiedTable()); + assertEquals(TYPE_NAME + "_addresses", virtualColumn.getDefaultTable()); + } + + public void testSelfReferentialElementCollectionMapping() throws Exception { + createSelfReferentialElementCollection(); + OrmPersistentType persistentType = getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Foo"); + + ElementCollectionMapping2_0 mapping = (ElementCollectionMapping2_0) persistentType.getAttributeNamed("elementCollection").getMapping(); + assertFalse(mapping.getAllOverridableAttributeMappingNames().iterator().hasNext()); + } + + public void testUpdateSpecifiedEnumerated() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + assertNull(elementCollectionResource.getMapKeyEnumerated()); + + //set enumerated in the resource model, verify context model updated + elementCollectionResource.setMapKeyEnumerated(org.eclipse.jpt.jpa.core.resource.orm.EnumType.ORDINAL); + assertEquals(EnumType.ORDINAL, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.ORDINAL, elementCollectionResource.getMapKeyEnumerated()); + + elementCollectionResource.setMapKeyEnumerated(org.eclipse.jpt.jpa.core.resource.orm.EnumType.STRING); + assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.STRING, elementCollectionResource.getMapKeyEnumerated()); + + //set enumerated to null in the resource model + elementCollectionResource.setMapKeyEnumerated(null); + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + assertNull(elementCollectionResource.getMapKeyEnumerated()); + } + + public void testModifySpecifiedEnumerated() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + assertNull(elementCollectionResource.getMapKeyEnumerated()); + + //set enumerated in the context model, verify resource model updated + ormElementCollectionMapping.setMapKeyConverter(BaseEnumeratedConverter.class); + ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.ORDINAL); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.ORDINAL, elementCollectionResource.getMapKeyEnumerated()); + assertEquals(EnumType.ORDINAL, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType()); + + ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.STRING); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.STRING, elementCollectionResource.getMapKeyEnumerated()); + assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType()); + + //set enumerated to null in the context model + ormElementCollectionMapping.setMapKeyConverter(null); + assertNull(elementCollectionResource.getMapKeyEnumerated()); + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + } + + public void testUpdateSpecifiedTemporal() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + assertNull(elementCollectionResource.getMapKeyTemporal()); + + //set temporal in the resource model, verify context model updated + elementCollectionResource.setMapKeyTemporal(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.DATE); + assertEquals(TemporalType.DATE, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.DATE, elementCollectionResource.getMapKeyTemporal()); + + elementCollectionResource.setMapKeyTemporal(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIME); + assertEquals(TemporalType.TIME, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIME, elementCollectionResource.getMapKeyTemporal()); + + elementCollectionResource.setMapKeyTemporal(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIMESTAMP); + assertEquals(TemporalType.TIMESTAMP, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIMESTAMP, elementCollectionResource.getMapKeyTemporal()); + + //set temporal to null in the resource model + elementCollectionResource.setMapKeyTemporal(null); + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + assertNull(elementCollectionResource.getMapKeyTemporal()); + } + + public void testModifySpecifiedTemporal() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + assertNull(elementCollectionResource.getMapKeyTemporal()); + + //set temporal in the context model, verify resource model updated + ormElementCollectionMapping.setMapKeyConverter(BaseTemporalConverter.class); + ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).setTemporalType(TemporalType.DATE); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.DATE, elementCollectionResource.getMapKeyTemporal()); + assertEquals(TemporalType.DATE, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType()); + + ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).setTemporalType(TemporalType.TIME); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIME, elementCollectionResource.getMapKeyTemporal()); + assertEquals(TemporalType.TIME, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType()); + + //set temporal to null in the context model + ormElementCollectionMapping.setMapKeyConverter(null); + assertNull(elementCollectionResource.getMapKeyTemporal()); + assertNull(ormElementCollectionMapping.getMapKeyConverter().getType()); + } + + public void testUpdateConvert() throws Exception { + createTestEntityWithElementCollectionMapping(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("address"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlConvertibleMapping elementCollectionResource = (XmlConvertibleMapping) getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("address").getMapping(); + + assertNull(ormElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + + //set lob in the resource model, verify context model updated + elementCollectionResource.setConvert("myConvert"); + assertEquals(EclipseLinkConvert.class, ormElementCollectionMapping.getConverter().getType()); + assertEquals("myConvert", elementCollectionResource.getConvert()); + + //set lob to null in the resource model + elementCollectionResource.setConvert(null); + assertNull(ormElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + + + javaElementCollectionMapping.setConverter(EclipseLinkConvert.class); + ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).setSpecifiedConverterName("foo"); + + assertNull(ormElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + assertEquals("foo", ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).getSpecifiedConverterName()); + + + ormPersistentAttribute.removeFromXml(); + OrmReadOnlyPersistentAttribute ormPersistentAttribute2 = ormPersistentType.getAttributeNamed("address"); + EclipseLinkElementCollectionMapping2_0 virtualElementCollectionMapping = (EclipseLinkElementCollectionMapping2_0) ormPersistentAttribute2.getMapping(); + + assertEquals(EclipseLinkConvert.class, virtualElementCollectionMapping.getConverter().getType()); + assertEquals("foo", ((EclipseLinkConvert) virtualElementCollectionMapping.getConverter()).getSpecifiedConverterName()); + assertEquals(null, elementCollectionResource.getConvert()); + assertEquals("foo", ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).getSpecifiedConverterName()); + + ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).setSpecifiedConverterName("bar"); + assertEquals(EclipseLinkConvert.class, virtualElementCollectionMapping.getConverter().getType()); + assertEquals("bar", ((EclipseLinkConvert) virtualElementCollectionMapping.getConverter()).getSpecifiedConverterName()); + assertEquals(null, elementCollectionResource.getConvert()); + assertEquals("bar", ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).getSpecifiedConverterName()); + + javaElementCollectionMapping.setConverter(null); + assertNull(virtualElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + assertNull(javaElementCollectionMapping.getConverter().getType()); + } + + public void testModifyConvert() throws Exception { + createTestTypeWithCollection(); + + OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME); + OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY); + OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping(); + XmlConvertibleMapping elementCollectionResource = (XmlConvertibleMapping) getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0); + + assertNull(ormElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + + //set lob in the context model, verify resource model updated + ormElementCollectionMapping.setConverter(EclipseLinkConvert.class); + assertEquals("", elementCollectionResource.getConvert()); + assertEquals(EclipseLinkConvert.class, ormElementCollectionMapping.getConverter().getType()); + + ((EclipseLinkConvert) ormElementCollectionMapping.getConverter()).setSpecifiedConverterName("bar"); + assertEquals("bar", elementCollectionResource.getConvert()); + assertEquals(EclipseLinkConvert.class, ormElementCollectionMapping.getConverter().getType()); + assertEquals("bar", ((EclipseLinkConvert) ormElementCollectionMapping.getConverter()).getSpecifiedConverterName()); + + ((EclipseLinkConvert) ormElementCollectionMapping.getConverter()).setSpecifiedConverterName(null); + + assertNull(ormElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + + //set lob to false in the context model + ormElementCollectionMapping.setConverter(null); + assertNull(ormElementCollectionMapping.getConverter().getType()); + assertEquals(null, elementCollectionResource.getConvert()); + } +} \ No newline at end of file diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java new file mode 100644 index 0000000000..39c93db3c2 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java @@ -0,0 +1,330 @@ +/******************************************************************************* + * Copyright (c) 2012 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm; + +import org.eclipse.jpt.jpa.core.context.AccessType; +import org.eclipse.jpt.jpa.core.context.orm.OrmPersistenceUnitDefaults; +import org.eclipse.jpt.jpa.core.resource.orm.XmlPersistenceUnitMetadata; +import org.eclipse.jpt.jpa.core.resource.persistence.PersistenceFactory; +import org.eclipse.jpt.jpa.core.resource.persistence.XmlMappingFileRef; +import org.eclipse.jpt.jpa.eclipselink.core.JptJpaEclipseLinkCorePlugin; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkAccessType; +import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkPersistenceUnitDefaults; +import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory; +import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlPersistenceUnitDefaults; +import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_1ContextModelTestCase; + +@SuppressWarnings("nls") +public class EclipseLink2_1PersistenceUnitDefaultsTests + extends EclipseLink2_1ContextModelTestCase +{ + public EclipseLink2_1PersistenceUnitDefaultsTests(String name) { + super(name); + } + + + @Override + protected void setUp() throws Exception { + super.setUp(); + XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef(); + mappingFileRef.setFileName(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef); + getPersistenceXmlResource().save(null); + } + + protected EclipseLinkPersistenceUnitDefaults getPersistenceUnitDefaults() { + return(EclipseLinkPersistenceUnitDefaults) getEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults(); + } + + protected XmlPersistenceUnitDefaults getXmlPersistenceUnitDefaults() { + return (XmlPersistenceUnitDefaults) getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults(); + } + + public void testIsAllFeaturesUnset() throws Exception { + OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + XmlPersistenceUnitMetadata persistenceUnitMetadata = EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata(); + getXmlEntityMappings().setPersistenceUnitMetadata(persistenceUnitMetadata); + assertTrue(persistenceUnitMetadata.isUnset()); + + XmlPersistenceUnitDefaults persistenceUnitDefaultsResource = EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults(); + persistenceUnitMetadata.setPersistenceUnitDefaults(persistenceUnitDefaultsResource); + assertTrue(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setCascadePersist(true); + assertFalse(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setCascadePersist(false); + assertTrue(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setSchema("asdf"); + assertFalse(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setSchema(null); + assertTrue(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setCatalog("asdf"); + assertFalse(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setCatalog(null); + assertTrue(persistenceUnitDefaultsResource.isUnset()); + + + persistenceUnitDefaultsResource.setAccess(org.eclipse.jpt.jpa.core.resource.orm.AccessType.PROPERTY); + assertFalse(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setAccess(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD); + assertFalse(persistenceUnitDefaultsResource.isUnset()); + + persistenceUnitDefaultsResource.setAccess(null); + assertTrue(persistenceUnitDefaultsResource.isUnset()); + } + + + public void testUpdateAccess() throws Exception { + OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set access in the resource model, verify context model updated + getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata()); + getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults()); + getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setAccess(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD); + assertEquals(AccessType.FIELD, persistenceUnitDefaults.getAccess()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setAccess(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL); + assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getAccess()); + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + //set access to null in the resource model + getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setAccess(null); + assertNull(persistenceUnitDefaults.getAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + } + + public void testModifyAccess() throws Exception { + OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSpecifiedAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set access in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedAccess(AccessType.PROPERTY); + assertEquals(AccessType.PROPERTY, persistenceUnitDefaults.getSpecifiedAccess()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.PROPERTY, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + persistenceUnitDefaults.setSpecifiedAccess(EclipseLinkAccessType.VIRTUAL); + assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getSpecifiedAccess()); + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + //set access to null in the context model + persistenceUnitDefaults.setSpecifiedAccess(null); + assertNull(persistenceUnitDefaults.getSpecifiedAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + } + + public void testModifyAccess2() throws Exception { + OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSpecifiedAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set access in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedAccess(AccessType.FIELD); + assertEquals(AccessType.FIELD, persistenceUnitDefaults.getSpecifiedAccess()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + //set access in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedAccess(EclipseLinkAccessType.VIRTUAL); + assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getSpecifiedAccess()); + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + //set another element on the persistence-unit-defaults element so it doesn't get removed + getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setCascadePersist(true); + //set access to null in the context model + persistenceUnitDefaults.setSpecifiedAccess(null); + assertNull(persistenceUnitDefaults.getSpecifiedAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + } + + public void testModifyAccess3() throws Exception { + OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSpecifiedAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + //set another element on the persistence-unit-metadata element so only persistence-unit-defaults element gets removed + getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata()); + getXmlEntityMappings().getPersistenceUnitMetadata().setXmlMappingMetadataComplete(true); + + //set access in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedAccess(AccessType.FIELD); + assertEquals(AccessType.FIELD, persistenceUnitDefaults.getSpecifiedAccess()); + assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + //set access in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedAccess(EclipseLinkAccessType.VIRTUAL); + assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getSpecifiedAccess()); + assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess()); + + //set access to null in the context model + persistenceUnitDefaults.setSpecifiedAccess(null); + assertNull(persistenceUnitDefaults.getSpecifiedAccess()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults()); + } + + public void testUpdateGetMethod() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set getMethod in the resource model, verify context model updated + getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata()); + getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults()); + getXmlPersistenceUnitDefaults().setAccessMethods(EclipseLinkOrmFactory.eINSTANCE.createXmlAccessMethods()); + + getXmlPersistenceUnitDefaults().getAccessMethods().setGetMethod("getFoo"); + assertEquals("getFoo", persistenceUnitDefaults.getGetMethod()); + assertEquals("getFoo", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod()); + + //set getMethod to null in the resource model + getXmlPersistenceUnitDefaults().getAccessMethods().setGetMethod(null); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod()); + } + + public void testModifyGetMethod() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set getMethod in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedGetMethod("getMe"); + assertEquals("getMe", persistenceUnitDefaults.getGetMethod()); + assertEquals("getMe", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod()); + + //set getMethod to null in the context model + persistenceUnitDefaults.setSpecifiedGetMethod(null); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + } + + public void testModifyGetMethod2() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set getMethod in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedGetMethod("getMe"); + assertEquals("getMe", persistenceUnitDefaults.getGetMethod()); + assertEquals("getMe", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod()); + + //set another element on the access-methods element so it doesn't get removed + getXmlPersistenceUnitDefaults().getAccessMethods().setSetMethod("setMe"); + //set getMethod to null in the context model + persistenceUnitDefaults.setSpecifiedGetMethod(null); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod()); + } + + public void testModifyGetMethod3() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + //set another element on the ersistence-unit-defaults element so only access-methods element gets removed + getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata()); + getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults()); + getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setCascadePersist(true); + + //set getMethod in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedGetMethod("getMe"); + assertEquals("getMe", persistenceUnitDefaults.getGetMethod()); + assertEquals("getMe", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod()); + + //set getMethod to null in the context model + persistenceUnitDefaults.setSpecifiedGetMethod(null); + assertNull(persistenceUnitDefaults.getGetMethod()); + assertNull(getXmlPersistenceUnitDefaults().getAccessMethods()); + } + + public void testUpdateSetMethod() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set getMethod in the resource model, verify context model updated + getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata()); + getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults()); + getXmlPersistenceUnitDefaults().setAccessMethods(EclipseLinkOrmFactory.eINSTANCE.createXmlAccessMethods()); + + getXmlPersistenceUnitDefaults().getAccessMethods().setSetMethod("setFoo"); + assertEquals("setFoo", persistenceUnitDefaults.getSetMethod()); + assertEquals("setFoo", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod()); + + //set getMethod to null in the resource model + getXmlPersistenceUnitDefaults().getAccessMethods().setSetMethod(null); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod()); + } + + public void testModifySetMethod() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set getMethod in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedSetMethod("setMe"); + assertEquals("setMe", persistenceUnitDefaults.getSetMethod()); + assertEquals("setMe", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod()); + + //set getMethod to null in the context model + persistenceUnitDefaults.setSpecifiedSetMethod(null); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + } + + public void testModifySetMethod2() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + + //set getMethod in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedSetMethod("setMe"); + assertEquals("setMe", persistenceUnitDefaults.getSetMethod()); + assertEquals("setMe", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod()); + + //set another element on the access-methods element so it doesn't get removed + getXmlPersistenceUnitDefaults().getAccessMethods().setGetMethod("getMe"); + //set getMethod to null in the context model + persistenceUnitDefaults.setSpecifiedSetMethod(null); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod()); + } + + public void testModifySetMethod3() throws Exception { + EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults(); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlEntityMappings().getPersistenceUnitMetadata()); + //set another element on the ersistence-unit-defaults element so only access-methods element gets removed + getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata()); + getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults()); + getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setCascadePersist(true); + + //set getMethod in the context model, verify resource model modified + persistenceUnitDefaults.setSpecifiedSetMethod("setMe"); + assertEquals("setMe", persistenceUnitDefaults.getSetMethod()); + assertEquals("setMe", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod()); + + //set getMethod to null in the context model + persistenceUnitDefaults.setSpecifiedSetMethod(null); + assertNull(persistenceUnitDefaults.getSetMethod()); + assertNull(getXmlPersistenceUnitDefaults().getAccessMethods()); + } + +} \ No newline at end of file diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java new file mode 100644 index 0000000000..55a6479832 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java @@ -0,0 +1,57 @@ +/******************************************************************************* + * Copyright (c) 2009, 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + *******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence; + +import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel; +import org.eclipse.jpt.common.utility.model.value.PropertyValueModel; +import org.eclipse.jpt.jpa.core.JpaFacet; +import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetDataModelProperties; +import org.eclipse.jpt.jpa.core.tests.internal.context.persistence.PersistenceUnitTestCase; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit; +import org.eclipse.jpt.jpa.eclipselink.core.platform.EclipseLinkPlatform; +import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties; +import org.eclipse.wst.common.frameworks.datamodel.IDataModel; + +/** + * EclipseLink2_0PersistenceUnitTestCase + */ +public abstract class EclipseLink2_0PersistenceUnitTestCase extends PersistenceUnitTestCase +{ + protected EclipseLinkPersistenceUnit subject; + + protected PropertyValueModel subjectHolder; + + // ********** constructors ********** + protected EclipseLink2_0PersistenceUnitTestCase(String name) { + super(name); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + this.subject = this.getPersistenceUnit(); + this.subjectHolder = new SimplePropertyValueModel(this.subject); + this.populatePu(); + } + + @Override + protected IDataModel buildJpaConfigDataModel() { + IDataModel dataModel = super.buildJpaConfigDataModel(); + dataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, JpaFacet.VERSION_2_0.getVersionString()); + dataModel.setProperty(JpaFacetDataModelProperties.PLATFORM, EclipseLinkPlatform.VERSION_2_0); + return dataModel; + } + + @Override + protected EclipseLinkPersistenceUnit getPersistenceUnit() { + return (EclipseLinkPersistenceUnit) super.getPersistenceUnit(); + } + +} \ No newline at end of file diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java new file mode 100644 index 0000000000..0eecf5c287 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java @@ -0,0 +1,823 @@ +/******************************************************************************* + * Copyright (c) 2011, 2012 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence; + +import java.util.Collection; +import java.util.Iterator; +import java.util.ListIterator; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.utility.internal.CollectionTools; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.core.JptJpaCorePlugin; +import org.eclipse.jpt.jpa.core.context.java.JavaEntity; +import org.eclipse.jpt.jpa.core.context.java.JavaIdMapping; +import org.eclipse.jpt.jpa.core.context.orm.EntityMappings; +import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit; +import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.persistence.Generic2_0JpaMetadataConversionTests; +import org.eclipse.jpt.jpa.eclipselink.core.JptJpaEclipseLinkCorePlugin; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConversionValue; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConvertibleMapping; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkCustomConverter; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkObjectTypeConverter; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkStructConverter; +import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTypeConverter; +import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkEmbeddable; +import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkEntity; +import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkMappedSuperclass; +import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkEntityMappings; +import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmEclipseLinkConverterContainer; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit; +import org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm.OrmEclipseLinkCustomConverter; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink; +import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_2ContextModelTestCase; + +@SuppressWarnings("nls") +public class EclipseLink2_2JpaMetadataConversionTests extends EclipseLink2_2ContextModelTestCase { + + private IProgressMonitor progressMonitor; + + public EclipseLink2_2JpaMetadataConversionTests(String name) { + super(name); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + this.progressMonitor = new IProgressMonitor() { + public void worked(int work) {} + public void subTask(String name) {} + public void setTaskName(String name) {} + public void setCanceled(boolean value) {} + public boolean isCanceled() {return false;} + public void internalWorked(double work) {} + public void done() {} + public void beginTask(String name, int totalWork) {} + } ; + } + + @Override + protected void tearDown() throws Exception { + this.progressMonitor = null; + super.tearDown(); + } + + // ************ metadata conversion of equivalent queries on EclipseLink platform************* + + private ICompilationUnit createTestEntityWithDuplicateQueries() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, JPA.NAMED_QUERY, JPA.NAMED_NATIVE_QUERIES, JPA.NAMED_NATIVE_QUERY); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@NamedQuery(name=\"nquery\")").append(CR); + sb.append("@NamedNativeQueries({" + + "@NamedNativeQuery(name=\"nnq1\", query=\"abcd\"), " + + "@NamedNativeQuery(name=\"nnq1\", query=\"abcde\")})"); + } + }); + } + + private ICompilationUnit createTestEntityWithEquivalentQueries() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.NAMED_NATIVE_QUERIES, JPA.NAMED_NATIVE_QUERY, JPA.QUERY_HINT); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@NamedNativeQueries({" + + "@NamedNativeQuery(name=\"nnq1\", query=\"abcd\", resultClass=foo1.class, resultSetMapping=\"bar1\", " + + "hints={@QueryHint(name=\"nnq1hint1\", value = \"aaa\"), " + + "@QueryHint(name=\"nnq1hint2\", value=\"bbb\")}), " + + "@NamedNativeQuery(name=\"nnq1\", query=\"abcd\", resultClass=foo1.class, resultSetMapping=\"bar1\", " + + "hints={@QueryHint(name=\"nnq1hint1\", value = \"aaa\"), " + + "@QueryHint(name=\"nnq1hint2\", value=\"bbb\")})})"); + } + }); + } + + public void testConvertDuplicateQueries() throws Exception { + createTestEntityWithDuplicateQueries(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistenceUnit persistenceUnit = getPersistenceUnit(); + + addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString()); + EntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaQueries(entityMappings, progressMonitor); + + JavaEntity entity = getJavaEntity(); + // test duplicate Java queries are not converted to eclipselink-orm.xml and + // not removed from the Java entity, but unique query is + assertEquals(0, entity.getQueryContainer().getNamedQueriesSize()); + assertEquals(2, entity.getQueryContainer().getNamedNativeQueriesSize()); + assertEquals(1, entityMappings.getQueryContainer().getNamedQueriesSize()); + assertEquals(0, entityMappings.getQueryContainer().getNamedNativeQueriesSize()); + } + + public void testConvertEquivalentQueries() throws Exception { + createTestEntityWithEquivalentQueries(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEntity entity = getJavaEntity(); + + addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString()); + EntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaQueries(entityMappings, progressMonitor); + + // test only one of the equivalent Java queries are converted + // to eclipselink-orm.xml and the rest are removed + assertEquals(0, entity.getQueryContainer().getNamedNativeQueriesSize()); + assertEquals(1, entityMappings.getQueryContainer().getNamedNativeQueriesSize()); + } + + // ************ metadata conversion of equivalent generators on EclipseLink platform************* + + private ICompilationUnit createTestEntityWithDuplicateGenerators() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, JPA.TABLE_GENERATOR, JPA.SEQUENCE_GENERATOR); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@TableGenerator(name=\"tgen\", initialValue=100)").append(CR); + sb.append("@SequenceGenerator(name=\"sgen\", initialValue=10)"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Id").append(CR); + sb.append("@TableGenerator(name=\"tgen\", initialValue=10)").append(CR); + sb.append("@SequenceGenerator(name=\"sgen\", initialValue=1)"); + } + }); + } + + private ICompilationUnit createTestEntityWithEquivalentGenerators() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, JPA.TABLE_GENERATOR, JPA.SEQUENCE_GENERATOR); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@TableGenerator(name=\"tgen\", table=\"ID_GEN\", schema=\"APP\", catalog=\"FOO\"," + + "pkColumnName=\"GEN_NAME\", valueColumnName=\"GEN_VALUE\", pkColumnValue=\"TGEN\"," + + "allocationSize=50, initialValue=100)").append(CR); + sb.append("@SequenceGenerator(name=\"sgen\", sequenceName=\"Foo_Seq\", schema=\"SYS\", catalog=\"BAR\"," + + "allocationSize=5, initialValue=10)"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Id").append(CR); + sb.append("@TableGenerator(name=\"tgen\", table=\"ID_GEN\", schema=\"APP\", catalog=\"FOO\"," + + "pkColumnName=\"GEN_NAME\", valueColumnName=\"GEN_VALUE\", pkColumnValue=\"TGEN\"," + + "allocationSize=50, initialValue=100)").append(CR); + sb.append("@SequenceGenerator(name=\"sgen\", sequenceName=\"Foo_Seq\", schema=\"SYS\", catalog=\"BAR\"," + + "allocationSize=5, initialValue=10)"); + } + }); + } + + public void testConvertDuplicateGenerators() throws Exception { + createTestEntityWithDuplicateGenerators(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + PersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEntity entity = getJavaEntity(); + JavaIdMapping mapping = (JavaIdMapping)entity.getIdAttribute().getMapping(); + + addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString()); + EntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaGenerators(entityMappings, progressMonitor); + + // test duplicate Java generators are not converted to eclipselink-orm.xml and + // not removed from the Java entity, but unique generator is + assertNotNull(entity.getGeneratorContainer().getSequenceGenerator()); + assertNotNull(entity.getGeneratorContainer().getTableGenerator()); + assertEquals(0, entityMappings.getSequenceGeneratorsSize()); + assertEquals(0, entityMappings.getTableGeneratorsSize()); + assertNotNull(mapping.getGeneratorContainer().getSequenceGenerator()); + assertNotNull(mapping.getGeneratorContainer().getTableGenerator()); + } + + public void testConvertEquivalentGenerators() throws Exception { + createTestEntityWithEquivalentGenerators(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEntity entity = getJavaEntity(); + JavaIdMapping mapping = (JavaIdMapping)entity.getIdAttribute().getMapping(); + + addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString()); + EntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaGenerators(entityMappings, progressMonitor); + + // test only one of the equivalent generators are converted to + // eclipselink-orm.xml and the rest are removed + assertNull(entity.getGeneratorContainer().getSequenceGenerator()); + assertNull(entity.getGeneratorContainer().getTableGenerator()); + assertNull(mapping.getGeneratorContainer().getSequenceGenerator()); + assertNull(mapping.getGeneratorContainer().getTableGenerator()); + assertEquals(1, entityMappings.getSequenceGeneratorsSize()); + assertEquals(1, entityMappings.getTableGeneratorsSize()); + } + + // ************ entity with converters************* + + private ICompilationUnit createTestEntityWithConverters() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER, + EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR); + sb.append("@TypeConverter(name=\"type\", dataType=Number.class, objectType=Integer.class)").append(CR); + sb.append("@ObjectTypeConverter(name=\"otype\", dataType=Character.class, objectType=String.class, " + + "conversionValues={@ConversionValue(dataValue=\"m\", objectValue=\"male\"), " + + "@ConversionValue(dataValue=\"f\", objectValue=\"female\")}," + + "defaultObjectValue=\"female\")").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")"); + } + }); + } + + private ICompilationUnit createTestEntityWithConverterOnConvertibleMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.ID, EclipseLink.CONVERTERS, EclipseLink.CONVERTER); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Id").append(CR); + sb.append("@Converters({" + + "@Converter(name = \"custom1\", converterClass=foo1.class)," + + "@Converter(name = \"custom2\", converterClass=foo2.class)})"); + } + }); + } + + private ICompilationUnit createTestEntityWithConverterOnCollectionMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, + "java.util.Map", EclipseLink.STRUCT_CONVERTER); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity"); + } + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@ElementCollection").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")").append(CR); + sb.append(" private Map projects;"); + } + }); + } + + private ICompilationUnit createTestEntityWithDuplicateConvertersOfDiffTypes() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.BASIC, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER, + EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR); + sb.append("@TypeConverter(name=\"type\")").append(CR); + sb.append("@ObjectTypeConverter(name=\"type\")").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Basic").append(CR); + sb.append("@ObjectTypeConverter(name=\"otype\")"); + } + }); + } + + private ICompilationUnit createTestEntity2WithDuplicateConvertersOfSameType() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.BASIC, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER, + EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR); + sb.append("@TypeConverter(name=\"type\")").append(CR); + sb.append("@ObjectTypeConverter(name=\"otype\")").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Basic").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=bar.class)"); + } + }); + } + + private ICompilationUnit createTestEntityWithEquivalentConverters() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.ENTITY, JPA.BASIC, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER, + EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Entity").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR); + sb.append("@TypeConverter(name=\"type\")").append(CR); + sb.append("@ObjectTypeConverter(name=\"otype\")").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")"); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Basic").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)"); + } + }); + } + + public void testConvertConvertersonEntity() throws Exception { + createTestEntityWithConverters(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkEntity entity = getJavaEntity(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter are converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0); + + // test the mapping file converters have correct values + EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next(); + assertEquals("custom", custom.getName()); + assertEquals("foo", custom.getConverterClass()); + + EclipseLinkTypeConverter type = entityMappings.getConverterContainer().getTypeConverters().iterator().next(); + assertEquals("type", type.getName()); + assertEquals("java.lang.Number", type.getDataType()); + assertEquals("java.lang.Integer", type.getObjectType()); + + EclipseLinkObjectTypeConverter otype = entityMappings.getConverterContainer().getObjectTypeConverters().iterator().next(); + assertEquals("otype", otype.getName()); + assertEquals("java.lang.Character", otype.getDataType()); + assertEquals("java.lang.String", otype.getObjectType()); + ListIterator values = otype.getConversionValues().iterator(); + EclipseLinkConversionValue value1 = values.next(); + assertEquals("m", value1.getDataValue()); + assertEquals("male", value1.getObjectValue()); + EclipseLinkConversionValue value2 = values.next(); + assertEquals("f", value2.getDataValue()); + assertEquals("female", value2.getObjectValue()); + assertEquals("female", otype.getDefaultObjectValue()); + + EclipseLinkStructConverter struct = entityMappings.getConverterContainer().getStructConverters().iterator().next(); + assertEquals("struct", struct.getName()); + assertEquals("bar", struct.getConverterClass()); + } + + public void testConvertConvertersOnEntityConvertibleMapping() throws Exception { + createTestEntityWithConverterOnConvertibleMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkEntity entity = getJavaEntity(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(2, entityMappings.getConverterContainer().getCustomConvertersSize()); + + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getIdAttribute().getMapping(); + + assertEquals(mapping.getConverterContainer().getConvertersSize(), 0); + + // test the mapping file converter have correct values + Collection customConverters = CollectionTools.collection(entityMappings.getConverterContainer().getCustomConverters()); + EclipseLinkCustomConverter custom1 = Generic2_0JpaMetadataConversionTests.selectNodeNamed(customConverters, "custom1"); + assertEquals("custom1", custom1.getName()); + assertEquals("foo1", custom1.getConverterClass()); + EclipseLinkCustomConverter custom2 = Generic2_0JpaMetadataConversionTests.selectNodeNamed(customConverters, "custom2"); + assertEquals("custom2", custom2.getName()); + assertEquals("foo2", custom2.getConverterClass()); + } + + public void testConvertConvertersOnCollectionMapping() throws Exception { + createTestEntityWithConverterOnCollectionMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkEntity entity = getJavaEntity(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + + if (entity.getAttributeMappings().iterator().hasNext()) { + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next(); + assertEquals(mapping.getConverterContainer().getConvertersSize(), 0); + } + + // test the mapping file converter have correct values + EclipseLinkStructConverter custom = entityMappings.getConverterContainer().getStructConverters().iterator().next(); + assertEquals("struct", custom.getName()); + assertEquals("bar", custom.getConverterClass()); + + // TODO test converting converter on map key - not supported yet + } + + public void testConvertOverriddenConverters() throws Exception { + createTestEntityWithDuplicateConvertersOfDiffTypes(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + OrmEclipseLinkConverterContainer ormConvertercontainer = entityMappings.getConverterContainer(); + EclipseLinkCustomConverter converter = ormConvertercontainer.addCustomConverter(ormConvertercontainer.getCustomConvertersSize()); + converter.setName("type"); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEclipseLinkEntity entity = getJavaEntity(); + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next(); + assertTrue(CollectionTools.contains(persistenceUnit.getConverters(), mapping.getConverterContainer().getConverters().iterator().next())); + + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test overriden Java converters are not converted to eclipselink-orm.xml and + // not removed from the Java entity, but unique converters are + assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 1); + assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 1); + assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0); + assertEquals(mapping.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(2, ormConvertercontainer.getCustomConvertersSize()); + assertEquals(1, ormConvertercontainer.getStructConvertersSize()); + assertEquals(0, ormConvertercontainer.getTypeConvertersSize()); + assertEquals(1, ormConvertercontainer.getObjectTypeConvertersSize()); + } + + public void testConvertDuplicateConvertersWithDiffTypes() throws Exception { + createTestEntityWithDuplicateConvertersOfDiffTypes(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEclipseLinkEntity entity = getJavaEntity(); + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next(); + + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test duplicate Java converters are not converted to eclipselink-orm.xml and + // not removed from the Java entity, but unique converters are + assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 1); + assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 1); + assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0); + assertEquals(mapping.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + assertEquals(0, entityMappings.getConverterContainer().getTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize()); + } + + public void testConvertDuplicateConvertersWithSameType() throws Exception { + createTestEntity2WithDuplicateConvertersOfSameType(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEclipseLinkEntity entity = getJavaEntity(); + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next(); + + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test duplicate Java converters are not converted to eclipselink-orm.xml and + // not removed from the Java entity, but unique converters are + assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 1); + assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0); + assertEquals(mapping.getConverterContainer().getCustomConvertersSize(), 1); + assertEquals(0, entityMappings.getConverterContainer().getCustomConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize()); + } + + public void testConvertEquivalentConverters() throws Exception { + createTestEntityWithEquivalentConverters(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + + JavaEclipseLinkEntity entity = getJavaEntity(); + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next(); + + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test only one of the equivalent converters is converted to + // eclipselink-orm.xml and the rest are removed + assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0); + assertEquals(mapping.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize()); + } + + // ************ embeddable with converters************* + + private ICompilationUnit createTestEmbeddableWithConverters() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.EMBEDDABLE, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER, + EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Embeddable").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR); + sb.append("@TypeConverter(name=\"type\", dataType=Number.class, objectType=Integer.class)").append(CR); + sb.append("@ObjectTypeConverter(name=\"otype\", dataType=Character.class, objectType=String.class, " + + "conversionValues={@ConversionValue(dataValue=\"m\", objectValue=\"male\"), " + + "@ConversionValue(dataValue=\"f\", objectValue=\"female\")}," + + "defaultObjectValue=\"female\")").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")"); + } + }); + } + + private ICompilationUnit createTestEmbeddableWithConverterOnConvertibleMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.EMBEDDABLE, JPA.VERSION, EclipseLink.CONVERTER); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Embeddable").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Version").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)"); + } + }); + } + + public void testConvertConvertersOnEmbeddable() throws Exception { + createTestEmbeddableWithConverters(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkEmbeddable embeddable = getJavaEmbeddable(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter are converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + assertEquals(embeddable.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(embeddable.getConverterContainer().getTypeConvertersSize(), 0); + assertEquals(embeddable.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(embeddable.getConverterContainer().getStructConvertersSize(), 0); + + // test the mapping file converters have correct values + EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next(); + assertEquals("custom", custom.getName()); + assertEquals("foo", custom.getConverterClass()); + + EclipseLinkTypeConverter type = entityMappings.getConverterContainer().getTypeConverters().iterator().next(); + assertEquals("type", type.getName()); + assertEquals("java.lang.Number", type.getDataType()); + assertEquals("java.lang.Integer", type.getObjectType()); + + EclipseLinkObjectTypeConverter otype = entityMappings.getConverterContainer().getObjectTypeConverters().iterator().next(); + assertEquals("otype", otype.getName()); + assertEquals("java.lang.Character", otype.getDataType()); + assertEquals("java.lang.String", otype.getObjectType()); + ListIterator values = otype.getConversionValues().iterator(); + EclipseLinkConversionValue value1 = values.next(); + assertEquals("m", value1.getDataValue()); + assertEquals("male", value1.getObjectValue()); + EclipseLinkConversionValue value2 = values.next(); + assertEquals("f", value2.getDataValue()); + assertEquals("female", value2.getObjectValue()); + assertEquals("female", otype.getDefaultObjectValue()); + + EclipseLinkStructConverter struct = entityMappings.getConverterContainer().getStructConverters().iterator().next(); + assertEquals("struct", struct.getName()); + assertEquals("bar", struct.getConverterClass()); + } + + public void testConvertConvertersOnEmbeddableConvertibleMapping() throws Exception { + createTestEmbeddableWithConverterOnConvertibleMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkEmbeddable embeddable = getJavaEmbeddable(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)embeddable.getAttributeMappings().iterator().next(); + assertEquals(mapping.getConverterContainer().getConvertersSize(), 0); + + // test the mapping file converter have correct values + EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next(); + assertEquals("custom", custom.getName()); + assertEquals("foo", custom.getConverterClass()); + } + + // ************ mapped superclass with converters************* + private ICompilationUnit createTestMappedSuperclassWithConverters() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.MAPPED_SUPERCLASS, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER, + EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@MappedSuperclass").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR); + sb.append("@TypeConverter(name=\"type\", dataType=Number.class, objectType=Integer.class)").append(CR); + sb.append("@ObjectTypeConverter(name=\"otype\", dataType=Character.class, objectType=String.class, " + + "conversionValues={@ConversionValue(dataValue=\"m\", objectValue=\"male\"), " + + "@ConversionValue(dataValue=\"f\", objectValue=\"female\")}," + + "defaultObjectValue=\"female\")").append(CR); + sb.append("@StructConverter(name=\"struct\", converter=\"bar\")"); + } + }); + } + + private ICompilationUnit createTestMappedSuperclassWithConverterOnConvertibleMapping() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(JPA.MAPPED_SUPERCLASS, JPA.ID, EclipseLink.CONVERTER); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@MappedSuperclass").append(CR); + } + + @Override + public void appendIdFieldAnnotationTo(StringBuilder sb) { + sb.append("@Id").append(CR); + sb.append("@Converter(name=\"custom\", converterClass=foo.class)"); + } + }); + } + + public void testConvertConvertersOnMappedSuperclass() throws Exception { + createTestMappedSuperclassWithConverters(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkMappedSuperclass mappedSuperclass = getJavaMappedSuperclass(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter are converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize()); + assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize()); + assertEquals(mappedSuperclass.getConverterContainer().getCustomConvertersSize(), 0); + assertEquals(mappedSuperclass.getConverterContainer().getTypeConvertersSize(), 0); + assertEquals(mappedSuperclass.getConverterContainer().getObjectTypeConvertersSize(), 0); + assertEquals(mappedSuperclass.getConverterContainer().getStructConvertersSize(), 0); + + // test the mapping file converters have correct values + EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next(); + assertEquals("custom", custom.getName()); + assertEquals("foo", custom.getConverterClass()); + + EclipseLinkTypeConverter type = entityMappings.getConverterContainer().getTypeConverters().iterator().next(); + assertEquals("type", type.getName()); + assertEquals("java.lang.Number", type.getDataType()); + assertEquals("java.lang.Integer", type.getObjectType()); + + EclipseLinkObjectTypeConverter otype = entityMappings.getConverterContainer().getObjectTypeConverters().iterator().next(); + assertEquals("otype", otype.getName()); + assertEquals("java.lang.Character", otype.getDataType()); + assertEquals("java.lang.String", otype.getObjectType()); + ListIterator values = otype.getConversionValues().iterator(); + EclipseLinkConversionValue value1 = values.next(); + assertEquals("m", value1.getDataValue()); + assertEquals("male", value1.getObjectValue()); + EclipseLinkConversionValue value2 = values.next(); + assertEquals("f", value2.getDataValue()); + assertEquals("female", value2.getObjectValue()); + assertEquals("female", otype.getDefaultObjectValue()); + + EclipseLinkStructConverter struct = entityMappings.getConverterContainer().getStructConverters().iterator().next(); + assertEquals("struct", struct.getName()); + assertEquals("bar", struct.getConverterClass()); + } + + public void testConvertConvertersOnMappedSuperclassConvertibleMapping() throws Exception { + createTestMappedSuperclassWithConverterOnConvertibleMapping(); + addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME); + + JavaEclipseLinkMappedSuperclass mappedSuperclass = getJavaMappedSuperclass(); + addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString()); + EclipseLinkEntityMappings entityMappings = getEntityMappings(); + + EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit(); + persistenceUnit.convertJavaConverters(entityMappings, progressMonitor); + + // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity + assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize()); + + EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)mappedSuperclass.getAttributeMappings().iterator().next(); + assertEquals(mapping.getConverterContainer().getConvertersSize(), 0); + + // test the mapping file converter have correct values + EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next(); + assertEquals("custom", custom.getName()); + assertEquals("foo", custom.getConverterClass()); + } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java new file mode 100644 index 0000000000..d6ca4d10f5 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java @@ -0,0 +1,53 @@ +/******************************************************************************* + * Copyright (c) 2008, 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + *******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence; + +import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel; +import org.eclipse.jpt.common.utility.model.value.PropertyValueModel; +import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetDataModelProperties; +import org.eclipse.jpt.jpa.core.tests.internal.context.persistence.PersistenceUnitTestCase; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit; +import org.eclipse.jpt.jpa.eclipselink.core.platform.EclipseLinkPlatform; +import org.eclipse.wst.common.frameworks.datamodel.IDataModel; + +/** + * PersistenceUnitTestCase + */ +public abstract class EclipseLinkPersistenceUnitTestCase extends PersistenceUnitTestCase +{ + protected EclipseLinkPersistenceUnit subject; + + protected PropertyValueModel subjectHolder; + + // ********** constructors ********** + protected EclipseLinkPersistenceUnitTestCase(String name) { + super(name); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + this.subject = this.getPersistenceUnit(); + this.subjectHolder = new SimplePropertyValueModel(this.subject); + this.populatePu(); + } + + @Override + protected IDataModel buildJpaConfigDataModel() { + IDataModel dataModel = super.buildJpaConfigDataModel(); + dataModel.setProperty(JpaFacetDataModelProperties.PLATFORM, EclipseLinkPlatform.VERSION_1_0); + return dataModel; + } + + @Override + protected EclipseLinkPersistenceUnit getPersistenceUnit() { + return (EclipseLinkPersistenceUnit) super.getPersistenceUnit(); + } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java new file mode 100644 index 0000000000..3525425419 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java @@ -0,0 +1,48 @@ +/******************************************************************************* + * Copyright (c) 2010, 2011 Oracle. + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License v1.0 which + * accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Oracle - initial API and implementation + *******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class JptEclipseLinkCorePersistenceContextModelTests extends TestCase +{ + public static Test suite() { + TestSuite suite = new TestSuite(JptEclipseLinkCorePersistenceContextModelTests.class.getName()); + suite.addTestSuite(EclipseLinkPersistenceUnitTests.class); + suite.addTestSuite(GeneralPropertiesValueModelTests.class); + suite.addTestSuite(GeneralPropertiesAdapterTests.class); +// suite.addTestSuite(ConnectionValueModelTests.class); + suite.addTestSuite(EclipseLinkConnectionTests.class); + suite.addTestSuite(CustomizationValueModelTests.class); + suite.addTestSuite(EclipseLinkCustomizationTests.class); + suite.addTestSuite(CachingValueModelTests.class); + suite.addTestSuite(CachingAdapterTests.class); + suite.addTestSuite(LoggingValueModelTests.class); + suite.addTestSuite(LoggingAdapterTests.class); + suite.addTestSuite(OptionsValueModelTests.class); + suite.addTestSuite(OptionsAdapterTests.class); + suite.addTestSuite(SchemaGenerationValueModelTests.class); + suite.addTestSuite(SchemaGenerationBasicAdapterTests.class); + suite.addTestSuite(SchemaGenerationAdapterTests.class); + suite.addTestSuite(EclipseLink2_0ConnectionTests.class); + suite.addTestSuite(EclipseLink2_0LoggingTests.class); + suite.addTestSuite(EclipseLink2_0OptionsTests.class); + suite.addTestSuite(EclipseLink2_2JpaMetadataConversionTests.class); + return suite; + } + + private JptEclipseLinkCorePersistenceContextModelTests() { + super(); + throw new UnsupportedOperationException(); + } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java new file mode 100644 index 0000000000..9638330836 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java @@ -0,0 +1,153 @@ +/******************************************************************************* + * Copyright (c) 2008, 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence; + +import org.eclipse.jpt.common.utility.internal.iterables.ListIterable; +import org.eclipse.jpt.common.utility.internal.model.value.ItemPropertyListValueModelAdapter; +import org.eclipse.jpt.common.utility.internal.model.value.ListAspectAdapter; +import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener; +import org.eclipse.jpt.common.utility.model.value.ListValueModel; +import org.eclipse.jpt.common.utility.model.value.PropertyValueModel; +import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit; +import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnitProperties; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.DdlGenerationType; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.OutputMode; +import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.SchemaGeneration; + +/** + * Tests the update of OutputMode model object by the SchemaGeneration adapter + * when the PersistenceUnit changes. + */ +@SuppressWarnings("nls") +public class SchemaGenerationBasicAdapterTests extends EclipseLinkPersistenceUnitTestCase +{ + private SchemaGeneration schemaGeneration; + + public static final String outputModeKey = SchemaGeneration.ECLIPSELINK_DDL_GENERATION_OUTPUT_MODE; + public static final String ddlGenTypeKey = SchemaGeneration.ECLIPSELINK_DDL_GENERATION_TYPE; + + public static final OutputMode OUTPUT_MODE_TEST_VALUE = OutputMode.sql_script; + public static final OutputMode OUTPUT_MODE_TEST_VALUE_2 = OutputMode.database; + + public static final DdlGenerationType DDL_GENERATION_TYPE_TEST_VALUE = DdlGenerationType.drop_and_create_tables; + public static final DdlGenerationType DDL_GENERATION_TYPE_TEST_VALUE_2 = DdlGenerationType.none; + + public SchemaGenerationBasicAdapterTests(String name) { + super(name); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + + this.schemaGeneration = this.subject.getSchemaGeneration(); + PropertyChangeListener propertyChangeListener = this.buildPropertyChangeListener(); + this.schemaGeneration.addPropertyChangeListener(SchemaGeneration.OUTPUT_MODE_PROPERTY, propertyChangeListener); + this.schemaGeneration.addPropertyChangeListener(SchemaGeneration.DDL_GENERATION_TYPE_PROPERTY, propertyChangeListener); + this.clearEvent(); + } + + /** + * Initializes directly the PU properties before testing. Cannot use + * Property Holder to initialize because it is not created yet + */ + @Override + protected void populatePu() { + this.propertiesTotal = 6; + this.modelPropertiesSizeOriginal = 2; + this.modelPropertiesSize = this.modelPropertiesSizeOriginal; + + this.persistenceUnitSetProperty("property.0", "value.0"); + this.persistenceUnitSetProperty(outputModeKey, this.getPropertyStringValueOf(OUTPUT_MODE_TEST_VALUE)); + this.persistenceUnitSetProperty("property.2", "value.2"); + this.persistenceUnitSetProperty("property.3", "value.3"); + this.persistenceUnitSetProperty("property.4", "value.4"); + this.persistenceUnitSetProperty(ddlGenTypeKey, this.getPropertyStringValueOf(DDL_GENERATION_TYPE_TEST_VALUE)); + return; + } + + /** ****** test methods ******* */ + + /** + * Tests the update of OutputMode property by the SchemaGeneration adapter + * when the PU changes. + */ + public void testOutputModeUpdate() throws Exception { + ListValueModel propertiesAdapter = this.buildPropertiesAdapter(this.subjectHolder); + ListValueModel propertyListAdapter = new ItemPropertyListValueModelAdapter(propertiesAdapter, PersistenceUnit.Property.VALUE_PROPERTY); + + this.verifyHasListeners(this.schemaGeneration, SchemaGeneration.OUTPUT_MODE_PROPERTY); + + // Basic + assertTrue(schemaGeneration.itemIsProperty(this.getPersistenceUnit().getProperty(outputModeKey))); + assertEquals(OUTPUT_MODE_TEST_VALUE, this.schemaGeneration.getOutputMode()); + + // Replace + this.persistenceUnitSetProperty(outputModeKey, OUTPUT_MODE_TEST_VALUE_2); + this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE_2, this.schemaGeneration.getOutputMode()); + + // Remove + this.clearEvent(); + --this.propertiesTotal; + --this.modelPropertiesSize; + this.getPersistenceUnit().removeProperty(outputModeKey); + assertNull(this.getPersistenceUnit().getProperty(outputModeKey)); + assertEquals(this.modelPropertiesSize, this.modelPropertiesSizeOriginal - 1); + assertNotNull(this.propertyChangedEvent); + assertNull(this.propertyChangedEvent.getNewValue()); + + // Add original OutputMode + ++this.propertiesTotal; + ++this.modelPropertiesSize; + this.persistenceUnitSetProperty(outputModeKey, OUTPUT_MODE_TEST_VALUE); + this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE, this.schemaGeneration.getOutputMode()); + + // Replace again + this.persistenceUnitSetProperty(outputModeKey, OUTPUT_MODE_TEST_VALUE_2); + this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE_2, this.schemaGeneration.getOutputMode()); + + // Replace by setting model object + this.clearEvent(); + this.schemaGeneration.setOutputMode(OUTPUT_MODE_TEST_VALUE); + this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE, this.schemaGeneration.getOutputMode()); + } + + // ****** convenience methods ******* + @Override + protected PersistenceUnitProperties getModel() { + return this.schemaGeneration; + } + + private ListValueModel buildPropertiesAdapter(PropertyValueModel subjectHolder) { + return new ListAspectAdapter(subjectHolder, PersistenceUnit.PROPERTIES_LIST) { + @Override + protected ListIterable getListIterable() { + return this.subject.getProperties(); + } + + @Override + protected int size_() { + return this.subject.getPropertiesSize(); + } + }; + } + + // ********** get/set property ********** + @Override + protected void setProperty(String propertyName, Object newValue) throws Exception { + throw new UnsupportedOperationException(); + } + + @Override + protected Object getProperty(String propertyName) throws NoSuchFieldException { + throw new UnsupportedOperationException(); + } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java new file mode 100644 index 0000000000..e10ad455cf --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java @@ -0,0 +1,67 @@ +/******************************************************************************* +* Copyright (c) 2012 Oracle. All rights reserved. +* This program and the accompanying materials are made available under the +* terms of the Eclipse Public License v1.0, which accompanies this distribution +* and is available at http://www.eclipse.org/legal/epl-v10.html. +* +* Contributors: +* Oracle - initial API and implementation +*******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.metadata; + +import junit.framework.Assert; + +import org.eclipse.jpt.jpa.core.tests.internal.metadata.JpaMetadataTests; +import org.eclipse.jpt.jpa.eclipselink.core.builder.EclipseLinkStaticWeavingBuilderConfigurator; + +/** + * JpaStaticWeavingBuilderMetadataTests + */ +public class EclipseLinkStaticWeavingBuilderMetadataTests extends JpaMetadataTests { + + public static final String SOURCE_PREF_KEY = "staticweave.SOURCE"; //$NON-NLS-1$ + public static final String LOG_LEVEL_PREF_KEY = "staticweave.LOG_LEVEL"; //$NON-NLS-1$ + + public static final String SOURCE_TEST_VALUE = "bin"; //$NON-NLS-1$ + public static final String LOG_LEVEL_TEST_VALUE = "ALL"; //$NON-NLS-1$ + + protected EclipseLinkStaticWeavingBuilderConfigurator projectPrefsManager; + + // ********** constructor ********** + + public EclipseLinkStaticWeavingBuilderMetadataTests(String name) { + super(name); + } + + // ********** overrides ********** + + @Override + protected void setUp() throws Exception { + super.setUp(); + + this.projectPrefsManager = new EclipseLinkStaticWeavingBuilderConfigurator(this.getJavaProject().getProject()); + Assert.assertNotNull(this.projectPrefsManager); + } + + // ********** tests ********** + + public void testSourceLocationProjectMetadata() throws Exception { + + this.projectPrefsManager.setSourceLocationPreference(SOURCE_TEST_VALUE); + this.projectPrefsManager.getLegacyProjectPreferences().flush(); + + String value = this.getProjectPrefs().get(SOURCE_PREF_KEY); + Assert.assertNotNull(value); + Assert.assertTrue(SOURCE_TEST_VALUE.equals(value)); + } + + public void testLogLevelProjectMetadata() throws Exception { + + this.projectPrefsManager.setLogLevelPreference(LOG_LEVEL_TEST_VALUE); + this.projectPrefsManager.getLegacyProjectPreferences().flush(); + + String value = this.getProjectPrefs().get(LOG_LEVEL_PREF_KEY); + Assert.assertNotNull(value); + Assert.assertTrue(LOG_LEVEL_TEST_VALUE.equals(value)); + } +} \ No newline at end of file diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java new file mode 100644 index 0000000000..e521e0b6f8 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java @@ -0,0 +1,34 @@ +/******************************************************************************* + * Copyright (c) 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java; + +import org.eclipse.jpt.common.core.AnnotationProvider; +import org.eclipse.jpt.jpa.core.internal.GenericJpaAnnotationDefinitionProvider; +import org.eclipse.jpt.jpa.core.internal.JpaAnnotationProvider; +import org.eclipse.jpt.jpa.core.tests.internal.resource.java.JpaJavaResourceModelTestCase; +import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLink2_0JpaAnnotationDefinitionProvider; + +public class EclipseLink2_0JavaResourceModelTestCase extends JpaJavaResourceModelTestCase +{ + + public static final String ECLIPSELINK_ANNOTATIONS_PACKAGE_NAME = "org.eclipse.persistence.annotations"; //$NON-NLS-1$ + + public EclipseLink2_0JavaResourceModelTestCase(String name) { + super(name); + } + + @Override + protected AnnotationProvider buildAnnotationProvider() { + return new JpaAnnotationProvider( + GenericJpaAnnotationDefinitionProvider.instance(), + EclipseLink2_0JpaAnnotationDefinitionProvider.instance()); + } + +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java new file mode 100644 index 0000000000..299511293c --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java @@ -0,0 +1,34 @@ +/******************************************************************************* + * Copyright (c) 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java; + +import org.eclipse.jpt.common.core.AnnotationProvider; +import org.eclipse.jpt.jpa.core.internal.GenericJpaAnnotationDefinitionProvider; +import org.eclipse.jpt.jpa.core.internal.JpaAnnotationProvider; +import org.eclipse.jpt.jpa.core.tests.internal.resource.java.JpaJavaResourceModelTestCase; +import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLink2_3JpaAnnotationDefinitionProvider; + +public class EclipseLink2_3JavaResourceModelTestCase extends JpaJavaResourceModelTestCase +{ + + public static final String ECLIPSELINK_ANNOTATIONS_PACKAGE_NAME = "org.eclipse.persistence.annotations"; //$NON-NLS-1$ + + public EclipseLink2_3JavaResourceModelTestCase(String name) { + super(name); + } + + @Override + protected AnnotationProvider buildAnnotationProvider() { + return new JpaAnnotationProvider( + GenericJpaAnnotationDefinitionProvider.instance(), + EclipseLink2_3JpaAnnotationDefinitionProvider.instance()); + } + +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java new file mode 100644 index 0000000000..d7c44fbc50 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java @@ -0,0 +1,330 @@ +/******************************************************************************* + * Copyright (c) 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java; + +import java.util.Iterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceType; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.core.resource.java.DiscriminatorType; +import org.eclipse.jpt.jpa.core.resource.java.JPA; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkTenantDiscriminatorColumnAnnotation2_3; + +@SuppressWarnings("nls") +public class EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests extends EclipseLink2_3JavaResourceModelTestCase { + + private static final String COLUMN_NAME = "MY_COLUMN"; + private static final String COLUMN_COLUMN_DEFINITION = "COLUMN_DEFINITION"; + private static final String COLUMN_CONTEXT_PROPERTY = "eclipselink.foo-id"; + private static final String COLUMN_TABLE = "MY_TABLE"; + + public EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests(String name) { + super(name); + } + + private ICompilationUnit createTestTenantDiscriminatorColumn() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn"); + } + }); + } + + private ICompilationUnit createTestTenantDiscriminatorColumnWithName() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(name = \"" + COLUMN_NAME + "\")"); + } + }); + } + + private ICompilationUnit createTestTenantDiscriminatorColumnWithColumnDefinition() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(columnDefinition = \"" + COLUMN_COLUMN_DEFINITION + "\")"); + } + }); + } + + private ICompilationUnit createTestTenantDiscriminatorColumnWithContextProperty() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(contextProperty = \"" + COLUMN_CONTEXT_PROPERTY + "\")"); + } + }); + } + + private ICompilationUnit createTestTenantDiscriminatorColumnWithTable() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(table = \"" + COLUMN_TABLE + "\")"); + } + }); + } + + private ICompilationUnit createTestTenenatDiscriminatorColumnWithDiscriminatorType() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN, JPA.DISCRIMINATOR_TYPE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(discriminatorType = DiscriminatorType.CHAR)"); + } + }); + } + + private ICompilationUnit createTestColumnWithIntElement(final String intElement) throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(" + intElement + " = 5)"); + } + }); + } + + private ICompilationUnit createTestColumnWithBooleanElement(final String booleanElement) throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@TenantDiscriminatorColumn(" + booleanElement + " = true)"); + } + }); + } + + public void testGetName() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithName(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + assertNotNull(column); + assertEquals(COLUMN_NAME, column.getName()); + } + + public void testGetNull() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + assertNotNull(column); + assertNull(column.getName()); + assertNull(column.getDiscriminatorType()); + assertNull(column.getColumnDefinition()); + } + + public void testSetName() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNotNull(column); + assertNull(column.getName()); + + column.setName("Foo"); + assertEquals("Foo", column.getName()); + + assertSourceContains("@TenantDiscriminatorColumn(name = \"Foo\")", cu); + } + + public void testSetNameNull() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithName(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertEquals(COLUMN_NAME, column.getName()); + + column.setName(null); + assertNull(column.getName()); + + assertSourceDoesNotContain("(name", cu); + } + + public void testGetColumnDefinition() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithColumnDefinition(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + assertEquals(COLUMN_COLUMN_DEFINITION, column.getColumnDefinition()); + } + + public void testSetColumnDefinition() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNotNull(column); + assertNull(column.getColumnDefinition()); + + column.setColumnDefinition("Foo"); + assertEquals("Foo", column.getColumnDefinition()); + + assertSourceContains("@TenantDiscriminatorColumn(columnDefinition = \"Foo\")", cu); + + + column.setColumnDefinition(null); + assertSourceDoesNotContain("(columnDefinition", cu); + } + + public void testGetLength() throws Exception { + ICompilationUnit cu = this.createTestColumnWithIntElement("length"); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertEquals(Integer.valueOf(5), column.getLength()); + } + + public void testSetLength() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNotNull(column); + assertNull(column.getLength()); + + column.setLength(Integer.valueOf(5)); + assertEquals(Integer.valueOf(5), column.getLength()); + + assertSourceContains("@TenantDiscriminatorColumn(length = 5)", cu); + + column.setLength(null); + assertSourceDoesNotContain("(length", cu); + } + + public void testGetDiscriminatorType() throws Exception { + ICompilationUnit cu = this.createTestTenenatDiscriminatorColumnWithDiscriminatorType(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + assertEquals(DiscriminatorType.CHAR, column.getDiscriminatorType()); + } + + public void testSetDiscriminatorType() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNull(column.getDiscriminatorType()); + + column.setDiscriminatorType(DiscriminatorType.INTEGER); + assertEquals(DiscriminatorType.INTEGER, column.getDiscriminatorType()); + + assertSourceContains("@TenantDiscriminatorColumn(discriminatorType = INTEGER)", cu); + + column.setDiscriminatorType(null); + assertSourceDoesNotContain("(discriminatorType", cu); + } + + public void testGetContextProperty() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithContextProperty(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + assertEquals(COLUMN_CONTEXT_PROPERTY, column.getContextProperty()); + } + + public void testSetContextProperty() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNotNull(column); + assertNull(column.getContextProperty()); + + column.setContextProperty("Foo"); + assertEquals("Foo", column.getContextProperty()); + + assertSourceContains("@TenantDiscriminatorColumn(contextProperty = \"Foo\")", cu); + + + column.setContextProperty(null); + assertSourceDoesNotContain("(contextProperty", cu); + } + + public void testGetTable() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithTable(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + assertEquals(COLUMN_TABLE, column.getTable()); + } + + public void testSetTable() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNotNull(column); + assertNull(column.getTable()); + + column.setTable("Foo"); + assertEquals("Foo", column.getTable()); + + assertSourceContains("@TenantDiscriminatorColumn(table = \"Foo\")", cu); + + + column.setTable(null); + assertSourceDoesNotContain("(table", cu); + } + + public void testGetPrimaryKey() throws Exception { + ICompilationUnit cu = this.createTestColumnWithBooleanElement("primaryKey"); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertEquals(Boolean.TRUE, column.getPrimaryKey()); + } + + public void testSetPrimaryKey() throws Exception { + ICompilationUnit cu = this.createTestTenantDiscriminatorColumn(); + JavaResourceType resourceType = buildJavaResourceType(cu); + EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN); + + assertNotNull(column); + assertNull(column.getPrimaryKey()); + + column.setPrimaryKey(Boolean.FALSE); + assertEquals(Boolean.FALSE, column.getPrimaryKey()); + + assertSourceContains("@TenantDiscriminatorColumn(primaryKey = false)", cu); + + column.setPrimaryKey(null); + assertSourceDoesNotContain("primaryKey", cu); + } + +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java new file mode 100644 index 0000000000..390048d533 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java @@ -0,0 +1,138 @@ +/******************************************************************************* + * Copyright (c) 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java; + +import java.util.Iterator; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jpt.common.core.resource.java.JavaResourceType; +import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkMultitenantAnnotation2_3; +import org.eclipse.jpt.jpa.eclipselink.core.resource.java.MultitenantType2_3; + +@SuppressWarnings("nls") +public class EclipselinkMultitenantAnnotation2_3Tests extends EclipseLink2_3JavaResourceModelTestCase { + + public EclipselinkMultitenantAnnotation2_3Tests(String name) { + super(name); + } + + private ICompilationUnit createTestMultitenant() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.MULTITENANT); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Multitenant"); + } + }); + } + + private ICompilationUnit createTestMultitenantWithValue() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.MULTITENANT, EclipseLink.MULTITENANT_TYPE); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Multitenant(MultitenantType.SINGLE_TABLE)"); + } + }); + } + + private ICompilationUnit createTestCacheWithIncludeCriteria() throws Exception { + return this.createTestType(new DefaultAnnotationWriter() { + @Override + public Iterator imports() { + return new ArrayIterator(EclipseLink.MULTITENANT); + } + @Override + public void appendTypeAnnotationTo(StringBuilder sb) { + sb.append("@Multitenant(includeCriteria=true)"); + } + }); + } + + public void testMultitenant() throws Exception { + ICompilationUnit cu = this.createTestMultitenant(); + JavaResourceType resourceType = buildJavaResourceType(cu); + + EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); + assertNotNull(multitenant); + } + + public void testGetValue() throws Exception { + ICompilationUnit cu = this.createTestMultitenantWithValue(); + JavaResourceType resourceType = buildJavaResourceType(cu); + + EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); + assertEquals(MultitenantType2_3.SINGLE_TABLE, multitenant.getValue()); + } + + public void testSetValue() throws Exception { + ICompilationUnit cu = this.createTestMultitenantWithValue(); + JavaResourceType resourceType = buildJavaResourceType(cu); + + EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); + assertEquals(MultitenantType2_3.SINGLE_TABLE, multitenant.getValue()); + + multitenant.setValue(MultitenantType2_3.TABLE_PER_TENANT); + assertEquals(MultitenantType2_3.TABLE_PER_TENANT, multitenant.getValue()); + + assertSourceContains("@Multitenant(TABLE_PER_TENANT)", cu); + + multitenant.setValue(null); + assertNull(multitenant.getValue()); + + assertSourceDoesNotContain("(TABLE_PER_TENANT)", cu); + assertSourceContains("@Multitenant", cu); + assertSourceDoesNotContain("@Multitenant(", cu); + } + +// +// public void testGetIncludeCriteria() throws Exception { +// ICompilationUnit cu = this.createTestCacheWithIncludeCriteria(); +// JavaResourceType resourceType = buildJavaResourceType(cu); +// +// EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); +// assertEquals(Boolean.TRUE, multitenant.getIncludeCriteria()); +// } +// +// public void testSetIncludeCriteria() throws Exception { +// ICompilationUnit cu = this.createTestCacheWithIncludeCriteria(); +// JavaResourceType resourceType = buildJavaResourceType(cu); +// +// EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); +// assertEquals(Boolean.TRUE, multitenant.getIncludeCriteria()); +// +// multitenant.setIncludeCriteria(Boolean.FALSE); +// assertEquals(Boolean.FALSE, multitenant.getIncludeCriteria()); +// +// assertSourceContains("@Multitenant(includeCriteria=false)", cu); +// } +// +// public void testSetIncludeCriteriaNull() throws Exception { +// ICompilationUnit cu = this.createTestCacheWithIncludeCriteria(); +// JavaResourceType resourceType = buildJavaResourceType(cu); +// +// EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); +// assertEquals(Boolean.TRUE, multitenant.getIncludeCriteria()); +// +// multitenant.setIncludeCriteria(null); +// multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT); +// assertNull(multitenant.getIncludeCriteria()); +// +// assertSourceContains("@Multitenant", cu); +// assertSourceDoesNotContain("@Multitenant(", cu); +// } +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java new file mode 100644 index 0000000000..17d5d04489 --- /dev/null +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java @@ -0,0 +1,50 @@ +/******************************************************************************* + * Copyright (c) 2007, 2011 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java; + +import junit.framework.Test; +import junit.framework.TestSuite; + +public class JptEclipseLinkCoreJavaResourceModelTests { + + public static Test suite() { + TestSuite suite = new TestSuite(JptEclipseLinkCoreJavaResourceModelTests.class.getName()); + suite.addTestSuite(CacheTests.class); + suite.addTestSuite(ChangeTrackingTests.class); + suite.addTestSuite(ConversionValueAnnotationTests.class); + suite.addTestSuite(ConvertAnnotationTests.class); + suite.addTestSuite(ConverterAnnotationTests.class); + suite.addTestSuite(CustomizerAnnotationTests.class); + suite.addTestSuite(ExistenceCheckingTests.class); + suite.addTestSuite(JoinFetchTests.class); + suite.addTestSuite(MutableAnnotationTests.class); + suite.addTestSuite(ObjectTypeConverterAnnotationTests.class); + suite.addTestSuite(EclipseLinkPrimaryKeyAnnotationTests.class); + suite.addTestSuite(PrivateOwnedTests.class); + suite.addTestSuite(ReadOnlyTests.class); + suite.addTestSuite(ReadTransformerAnnotationTests.class); + suite.addTestSuite(StructConverterAnnotationTests.class); + suite.addTestSuite(TimeOfDayTests.class); + suite.addTestSuite(TransformationAnnotationTests.class); + suite.addTestSuite(TypeConverterAnnotationTests.class); + suite.addTestSuite(WriteTransformerAnnotationTests.class); + suite.addTestSuite(MapKeyConvertAnnotation2_0Tests.class); + suite.addTestSuite(EclipselinkMultitenantAnnotation2_3Tests.class); + suite.addTestSuite(EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.class); + + return suite; + } + + private JptEclipseLinkCoreJavaResourceModelTests() { + super(); + throw new UnsupportedOperationException(); + } + +} diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml index 1d48c747cd..41a8dcde8f 100644 --- a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml +++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml @@ -32,10 +32,10 @@ - + - + -- cgit v1.2.3