HHH-14529 Copy orm.xml handling code to prepare for the new JAXB-based implementation
We will adapt the code in a later commit; I'm only doing the copy in this commit in order to keep the review manageable.
This commit is contained in:
Yoann Rodière
parent
55ef4d47f2
commit
7291036680
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,230 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.cfg.annotations.reflection.internal;
|
||||
|
||||
import java.lang.reflect.AnnotatedElement;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import javax.persistence.EntityListeners;
|
||||
import javax.persistence.NamedNativeQuery;
|
||||
import javax.persistence.NamedQuery;
|
||||
import javax.persistence.NamedStoredProcedureQuery;
|
||||
import javax.persistence.SequenceGenerator;
|
||||
import javax.persistence.SqlResultSetMapping;
|
||||
import javax.persistence.TableGenerator;
|
||||
|
||||
import org.hibernate.annotations.common.reflection.AnnotationReader;
|
||||
import org.hibernate.annotations.common.reflection.MetadataProvider;
|
||||
import org.hibernate.annotations.common.reflection.java.JavaMetadataProvider;
|
||||
import org.hibernate.boot.internal.ClassLoaderAccessImpl;
|
||||
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
|
||||
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
|
||||
import org.hibernate.boot.spi.BootstrapContext;
|
||||
import org.hibernate.boot.spi.ClassLoaderAccess;
|
||||
import org.hibernate.boot.spi.ClassLoaderAccessDelegateImpl;
|
||||
import org.hibernate.boot.spi.MetadataBuildingOptions;
|
||||
|
||||
import org.dom4j.Element;
|
||||
|
||||
/**
|
||||
* MetadataProvider aware of the JPA Deployment descriptor (orm.xml, ...).
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider {
|
||||
|
||||
private static final MetadataProvider STATELESS_BASE_DELEGATE = new JavaMetadataProvider();
|
||||
|
||||
private final ClassLoaderAccess classLoaderAccess;
|
||||
private final XMLContext xmlContext;
|
||||
|
||||
/**
|
||||
* We allow fully disabling XML sources so to improve the efficiency of
|
||||
* the boot process for those not using it.
|
||||
*/
|
||||
private final boolean xmlMappingEnabled;
|
||||
|
||||
private Map<Object, Object> defaults;
|
||||
private Map<AnnotatedElement, AnnotationReader> cache;
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link JPAXMLOverriddenMetadataProvider#JPAXMLOverriddenMetadataProvider(BootstrapContext)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public JPAXMLOverriddenMetadataProvider(final MetadataBuildingOptions metadataBuildingOptions) {
|
||||
this( new ClassLoaderAccessDelegateImpl() {
|
||||
ClassLoaderAccess delegate;
|
||||
|
||||
@Override
|
||||
protected ClassLoaderAccess getDelegate() {
|
||||
if ( delegate == null ) {
|
||||
delegate = new ClassLoaderAccessImpl(
|
||||
metadataBuildingOptions.getTempClassLoader(),
|
||||
metadataBuildingOptions.getServiceRegistry().getService( ClassLoaderService.class )
|
||||
);
|
||||
}
|
||||
return delegate;
|
||||
}
|
||||
},
|
||||
metadataBuildingOptions.isXmlMappingEnabled() );
|
||||
}
|
||||
|
||||
public JPAXMLOverriddenMetadataProvider(BootstrapContext bootstrapContext) {
|
||||
this( bootstrapContext.getClassLoaderAccess(),
|
||||
bootstrapContext.getMetadataBuildingOptions().isXmlMappingEnabled() );
|
||||
}
|
||||
|
||||
JPAXMLOverriddenMetadataProvider(ClassLoaderAccess classLoaderAccess, boolean xmlMetadataEnabled) {
|
||||
this.classLoaderAccess = classLoaderAccess;
|
||||
this.xmlContext = new XMLContext( classLoaderAccess );
|
||||
this.xmlMappingEnabled = xmlMetadataEnabled;
|
||||
}
|
||||
|
||||
//all of the above can be safely rebuilt from XMLContext: only XMLContext this object is serialized
|
||||
@Override
|
||||
public AnnotationReader getAnnotationReader(AnnotatedElement annotatedElement) {
|
||||
if ( cache == null ) {
|
||||
cache = new HashMap<>(50 );
|
||||
}
|
||||
AnnotationReader reader = cache.get( annotatedElement );
|
||||
if (reader == null) {
|
||||
if ( xmlContext.hasContext() ) {
|
||||
reader = new JPAXMLOverriddenAnnotationReader( annotatedElement, xmlContext, classLoaderAccess );
|
||||
}
|
||||
else {
|
||||
reader = STATELESS_BASE_DELEGATE.getAnnotationReader( annotatedElement );
|
||||
}
|
||||
cache.put( annotatedElement, reader );
|
||||
}
|
||||
return reader;
|
||||
}
|
||||
|
||||
// @Override
|
||||
// FIXME this method was introduced in HCANN 5.1.1: we can't mark it as @Override yet,
|
||||
// but it's expected to be invoked when we're running with the right HCANN version.
|
||||
public void reset() {
|
||||
//It's better to remove the HashMap, as it could grow rather large:
|
||||
//when doing a clear() the internal buckets array is not scaled down.
|
||||
this.cache = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<Object, Object> getDefaults() {
|
||||
if ( xmlMappingEnabled == false ) {
|
||||
return Collections.emptyMap();
|
||||
}
|
||||
else {
|
||||
if ( defaults == null ) {
|
||||
defaults = new HashMap<>();
|
||||
XMLContext.Default xmlDefaults = xmlContext.getDefault( null );
|
||||
|
||||
defaults.put( "schema", xmlDefaults.getSchema() );
|
||||
defaults.put( "catalog", xmlDefaults.getCatalog() );
|
||||
defaults.put( "delimited-identifier", xmlDefaults.getDelimitedIdentifier() );
|
||||
defaults.put( "cascade-persist", xmlDefaults.getCascadePersist() );
|
||||
List<Class> entityListeners = new ArrayList<Class>();
|
||||
for ( String className : xmlContext.getDefaultEntityListeners() ) {
|
||||
try {
|
||||
entityListeners.add( classLoaderAccess.classForName( className ) );
|
||||
}
|
||||
catch ( ClassLoadingException e ) {
|
||||
throw new IllegalStateException( "Default entity listener class not found: " + className );
|
||||
}
|
||||
}
|
||||
defaults.put( EntityListeners.class, entityListeners );
|
||||
for ( Element element : xmlContext.getAllDocuments() ) {
|
||||
@SuppressWarnings( "unchecked" )
|
||||
List<Element> elements = element.elements( "sequence-generator" );
|
||||
List<SequenceGenerator> sequenceGenerators = ( List<SequenceGenerator> ) defaults.get( SequenceGenerator.class );
|
||||
if ( sequenceGenerators == null ) {
|
||||
sequenceGenerators = new ArrayList<>();
|
||||
defaults.put( SequenceGenerator.class, sequenceGenerators );
|
||||
}
|
||||
for ( Element subelement : elements ) {
|
||||
sequenceGenerators.add( JPAXMLOverriddenAnnotationReader.buildSequenceGeneratorAnnotation( subelement ) );
|
||||
}
|
||||
|
||||
elements = element.elements( "table-generator" );
|
||||
List<TableGenerator> tableGenerators = ( List<TableGenerator> ) defaults.get( TableGenerator.class );
|
||||
if ( tableGenerators == null ) {
|
||||
tableGenerators = new ArrayList<>();
|
||||
defaults.put( TableGenerator.class, tableGenerators );
|
||||
}
|
||||
for ( Element subelement : elements ) {
|
||||
tableGenerators.add(
|
||||
JPAXMLOverriddenAnnotationReader.buildTableGeneratorAnnotation(
|
||||
subelement, xmlDefaults
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
List<NamedQuery> namedQueries = ( List<NamedQuery> ) defaults.get( NamedQuery.class );
|
||||
if ( namedQueries == null ) {
|
||||
namedQueries = new ArrayList<>();
|
||||
defaults.put( NamedQuery.class, namedQueries );
|
||||
}
|
||||
List<NamedQuery> currentNamedQueries = JPAXMLOverriddenAnnotationReader.buildNamedQueries(
|
||||
element,
|
||||
false,
|
||||
xmlDefaults,
|
||||
classLoaderAccess
|
||||
);
|
||||
namedQueries.addAll( currentNamedQueries );
|
||||
|
||||
List<NamedNativeQuery> namedNativeQueries = ( List<NamedNativeQuery> ) defaults.get( NamedNativeQuery.class );
|
||||
if ( namedNativeQueries == null ) {
|
||||
namedNativeQueries = new ArrayList<>();
|
||||
defaults.put( NamedNativeQuery.class, namedNativeQueries );
|
||||
}
|
||||
List<NamedNativeQuery> currentNamedNativeQueries = JPAXMLOverriddenAnnotationReader.buildNamedQueries(
|
||||
element,
|
||||
true,
|
||||
xmlDefaults,
|
||||
classLoaderAccess
|
||||
);
|
||||
namedNativeQueries.addAll( currentNamedNativeQueries );
|
||||
|
||||
List<SqlResultSetMapping> sqlResultSetMappings = ( List<SqlResultSetMapping> ) defaults.get(
|
||||
SqlResultSetMapping.class
|
||||
);
|
||||
if ( sqlResultSetMappings == null ) {
|
||||
sqlResultSetMappings = new ArrayList<>();
|
||||
defaults.put( SqlResultSetMapping.class, sqlResultSetMappings );
|
||||
}
|
||||
List<SqlResultSetMapping> currentSqlResultSetMappings = JPAXMLOverriddenAnnotationReader.buildSqlResultsetMappings(
|
||||
element,
|
||||
xmlDefaults,
|
||||
classLoaderAccess
|
||||
);
|
||||
sqlResultSetMappings.addAll( currentSqlResultSetMappings );
|
||||
|
||||
List<NamedStoredProcedureQuery> namedStoredProcedureQueries = (List<NamedStoredProcedureQuery>)defaults.get( NamedStoredProcedureQuery.class );
|
||||
if(namedStoredProcedureQueries==null){
|
||||
namedStoredProcedureQueries = new ArrayList<>( );
|
||||
defaults.put( NamedStoredProcedureQuery.class, namedStoredProcedureQueries );
|
||||
}
|
||||
List<NamedStoredProcedureQuery> currentNamedStoredProcedureQueries = JPAXMLOverriddenAnnotationReader
|
||||
.buildNamedStoreProcedureQueries(
|
||||
element,
|
||||
xmlDefaults,
|
||||
classLoaderAccess
|
||||
);
|
||||
namedStoredProcedureQueries.addAll( currentNamedStoredProcedureQueries );
|
||||
}
|
||||
}
|
||||
return defaults;
|
||||
}
|
||||
}
|
||||
|
||||
public XMLContext getXMLContext() {
|
||||
return xmlContext;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,359 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.cfg.annotations.reflection.internal;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import javax.persistence.AccessType;
|
||||
import javax.persistence.AttributeConverter;
|
||||
|
||||
import org.hibernate.AnnotationException;
|
||||
import org.hibernate.boot.AttributeConverterInfo;
|
||||
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
|
||||
import org.hibernate.boot.spi.BootstrapContext;
|
||||
import org.hibernate.boot.spi.ClassLoaderAccess;
|
||||
import org.hibernate.cfg.AttributeConverterDefinition;
|
||||
import org.hibernate.cfg.annotations.reflection.AttributeConverterDefinitionCollector;
|
||||
import org.hibernate.internal.CoreLogging;
|
||||
import org.hibernate.internal.CoreMessageLogger;
|
||||
import org.hibernate.internal.util.StringHelper;
|
||||
|
||||
import org.dom4j.Document;
|
||||
import org.dom4j.Element;
|
||||
|
||||
/**
|
||||
* A helper for consuming orm.xml mappings.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @author Brett Meyer
|
||||
*/
|
||||
public class XMLContext implements Serializable {
|
||||
private static final CoreMessageLogger LOG = CoreLogging.messageLogger( XMLContext.class );
|
||||
|
||||
private final ClassLoaderAccess classLoaderAccess;
|
||||
|
||||
private Default globalDefaults;
|
||||
private Map<String, Element> classOverriding = new HashMap<>();
|
||||
private Map<String, Default> defaultsOverriding = new HashMap<>();
|
||||
private List<Element> defaultElements = new ArrayList<>();
|
||||
private List<String> defaultEntityListeners = new ArrayList<>();
|
||||
private boolean hasContext = false;
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link XMLContext#XMLContext(BootstrapContext)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public XMLContext(ClassLoaderAccess classLoaderAccess) {
|
||||
this.classLoaderAccess = classLoaderAccess;
|
||||
}
|
||||
|
||||
public XMLContext(BootstrapContext bootstrapContext) {
|
||||
this.classLoaderAccess = bootstrapContext.getClassLoaderAccess();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param doc The xml document to add
|
||||
* @return Add an xml document to this context and return the list of added class names.
|
||||
*/
|
||||
@SuppressWarnings( "unchecked" )
|
||||
public List<String> addDocument(Document doc) {
|
||||
hasContext = true;
|
||||
List<String> addedClasses = new ArrayList<>();
|
||||
Element root = doc.getRootElement();
|
||||
//global defaults
|
||||
Element metadata = root.element( "persistence-unit-metadata" );
|
||||
if ( metadata != null ) {
|
||||
if ( globalDefaults == null ) {
|
||||
globalDefaults = new Default();
|
||||
globalDefaults.setMetadataComplete(
|
||||
metadata.element( "xml-mapping-metadata-complete" ) != null ?
|
||||
Boolean.TRUE :
|
||||
null
|
||||
);
|
||||
Element defaultElement = metadata.element( "persistence-unit-defaults" );
|
||||
if ( defaultElement != null ) {
|
||||
Element unitElement = defaultElement.element( "schema" );
|
||||
globalDefaults.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
|
||||
unitElement = defaultElement.element( "catalog" );
|
||||
globalDefaults.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
|
||||
unitElement = defaultElement.element( "access" );
|
||||
setAccess( unitElement, globalDefaults );
|
||||
unitElement = defaultElement.element( "cascade-persist" );
|
||||
globalDefaults.setCascadePersist( unitElement != null ? Boolean.TRUE : null );
|
||||
unitElement = defaultElement.element( "delimited-identifiers" );
|
||||
globalDefaults.setDelimitedIdentifiers( unitElement != null ? Boolean.TRUE : null );
|
||||
defaultEntityListeners.addAll( addEntityListenerClasses( defaultElement, null, addedClasses ) );
|
||||
}
|
||||
}
|
||||
else {
|
||||
LOG.duplicateMetadata();
|
||||
}
|
||||
}
|
||||
|
||||
//entity mapping default
|
||||
Default entityMappingDefault = new Default();
|
||||
Element unitElement = root.element( "package" );
|
||||
String packageName = unitElement != null ? unitElement.getTextTrim() : null;
|
||||
entityMappingDefault.setPackageName( packageName );
|
||||
unitElement = root.element( "schema" );
|
||||
entityMappingDefault.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
|
||||
unitElement = root.element( "catalog" );
|
||||
entityMappingDefault.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
|
||||
unitElement = root.element( "access" );
|
||||
setAccess( unitElement, entityMappingDefault );
|
||||
defaultElements.add( root );
|
||||
|
||||
setLocalAttributeConverterDefinitions( root.elements( "converter" ) );
|
||||
|
||||
List<Element> entities = root.elements( "entity" );
|
||||
addClass( entities, packageName, entityMappingDefault, addedClasses );
|
||||
|
||||
entities = root.elements( "mapped-superclass" );
|
||||
addClass( entities, packageName, entityMappingDefault, addedClasses );
|
||||
|
||||
entities = root.elements( "embeddable" );
|
||||
addClass( entities, packageName, entityMappingDefault, addedClasses );
|
||||
return addedClasses;
|
||||
}
|
||||
|
||||
private void setAccess(Element unitElement, Default defaultType) {
|
||||
if ( unitElement != null ) {
|
||||
String access = unitElement.getTextTrim();
|
||||
setAccess( access, defaultType );
|
||||
}
|
||||
}
|
||||
|
||||
private void setAccess( String access, Default defaultType) {
|
||||
AccessType type;
|
||||
if ( access != null ) {
|
||||
try {
|
||||
type = AccessType.valueOf( access );
|
||||
}
|
||||
catch ( IllegalArgumentException e ) {
|
||||
throw new AnnotationException( "Invalid access type " + access + " (check your xml configuration)" );
|
||||
}
|
||||
defaultType.setAccess( type );
|
||||
}
|
||||
}
|
||||
|
||||
private void addClass(List<Element> entities, String packageName, Default defaults, List<String> addedClasses) {
|
||||
for (Element element : entities) {
|
||||
String className = buildSafeClassName( element.attributeValue( "class" ), packageName );
|
||||
if ( classOverriding.containsKey( className ) ) {
|
||||
//maybe switch it to warn?
|
||||
throw new IllegalStateException( "Duplicate XML entry for " + className );
|
||||
}
|
||||
addedClasses.add( className );
|
||||
classOverriding.put( className, element );
|
||||
Default localDefault = new Default();
|
||||
localDefault.override( defaults );
|
||||
String metadataCompleteString = element.attributeValue( "metadata-complete" );
|
||||
if ( metadataCompleteString != null ) {
|
||||
localDefault.setMetadataComplete( Boolean.parseBoolean( metadataCompleteString ) );
|
||||
}
|
||||
String access = element.attributeValue( "access" );
|
||||
setAccess( access, localDefault );
|
||||
defaultsOverriding.put( className, localDefault );
|
||||
|
||||
LOG.debugf( "Adding XML overriding information for %s", className );
|
||||
addEntityListenerClasses( element, packageName, addedClasses );
|
||||
}
|
||||
}
|
||||
|
||||
private List<String> addEntityListenerClasses(Element element, String packageName, List<String> addedClasses) {
|
||||
List<String> localAddedClasses = new ArrayList<>();
|
||||
Element listeners = element.element( "entity-listeners" );
|
||||
if ( listeners != null ) {
|
||||
@SuppressWarnings( "unchecked" )
|
||||
List<Element> elements = listeners.elements( "entity-listener" );
|
||||
for (Element listener : elements) {
|
||||
String listenerClassName = buildSafeClassName( listener.attributeValue( "class" ), packageName );
|
||||
if ( classOverriding.containsKey( listenerClassName ) ) {
|
||||
//maybe switch it to warn?
|
||||
if ( "entity-listener".equals( classOverriding.get( listenerClassName ).getName() ) ) {
|
||||
LOG.duplicateListener( listenerClassName );
|
||||
continue;
|
||||
}
|
||||
throw new IllegalStateException("Duplicate XML entry for " + listenerClassName);
|
||||
}
|
||||
localAddedClasses.add( listenerClassName );
|
||||
classOverriding.put( listenerClassName, listener );
|
||||
}
|
||||
}
|
||||
LOG.debugf( "Adding XML overriding information for listeners: %s", localAddedClasses );
|
||||
addedClasses.addAll( localAddedClasses );
|
||||
return localAddedClasses;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private void setLocalAttributeConverterDefinitions(List<Element> converterElements) {
|
||||
for ( Element converterElement : converterElements ) {
|
||||
final String className = converterElement.attributeValue( "class" );
|
||||
final String autoApplyAttribute = converterElement.attributeValue( "auto-apply" );
|
||||
final boolean autoApply = autoApplyAttribute != null && Boolean.parseBoolean( autoApplyAttribute );
|
||||
|
||||
try {
|
||||
final Class<? extends AttributeConverter> attributeConverterClass = classLoaderAccess.classForName(
|
||||
className
|
||||
);
|
||||
attributeConverterInfoList.add(
|
||||
new AttributeConverterDefinition( attributeConverterClass.newInstance(), autoApply )
|
||||
);
|
||||
}
|
||||
catch (ClassLoadingException e) {
|
||||
throw new AnnotationException( "Unable to locate specified AttributeConverter implementation class : " + className, e );
|
||||
}
|
||||
catch (Exception e) {
|
||||
throw new AnnotationException( "Unable to instantiate specified AttributeConverter implementation class : " + className, e );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static String buildSafeClassName(String className, String defaultPackageName) {
|
||||
if ( className.indexOf( '.' ) < 0 && StringHelper.isNotEmpty( defaultPackageName ) ) {
|
||||
className = StringHelper.qualify( defaultPackageName, className );
|
||||
}
|
||||
return className;
|
||||
}
|
||||
|
||||
public static String buildSafeClassName(String className, XMLContext.Default defaults) {
|
||||
return buildSafeClassName( className, defaults.getPackageName() );
|
||||
}
|
||||
|
||||
public Default getDefault(String className) {
|
||||
Default xmlDefault = new Default();
|
||||
xmlDefault.override( globalDefaults );
|
||||
if ( className != null ) {
|
||||
Default entityMappingOverriding = defaultsOverriding.get( className );
|
||||
xmlDefault.override( entityMappingOverriding );
|
||||
}
|
||||
return xmlDefault;
|
||||
}
|
||||
|
||||
public Element getXMLTree(String className ) {
|
||||
return classOverriding.get( className );
|
||||
}
|
||||
|
||||
public List<Element> getAllDocuments() {
|
||||
return defaultElements;
|
||||
}
|
||||
|
||||
public boolean hasContext() {
|
||||
return hasContext;
|
||||
}
|
||||
|
||||
private List<AttributeConverterInfo> attributeConverterInfoList = new ArrayList<>();
|
||||
|
||||
public void applyDiscoveredAttributeConverters(AttributeConverterDefinitionCollector collector) {
|
||||
for ( AttributeConverterInfo info : attributeConverterInfoList ) {
|
||||
collector.addAttributeConverter( info );
|
||||
}
|
||||
attributeConverterInfoList.clear();
|
||||
}
|
||||
|
||||
public static class Default implements Serializable {
|
||||
private AccessType access;
|
||||
private String packageName;
|
||||
private String schema;
|
||||
private String catalog;
|
||||
private Boolean metadataComplete;
|
||||
private Boolean cascadePersist;
|
||||
private Boolean delimitedIdentifier;
|
||||
|
||||
public AccessType getAccess() {
|
||||
return access;
|
||||
}
|
||||
|
||||
protected void setAccess(AccessType access) {
|
||||
this.access = access;
|
||||
}
|
||||
|
||||
public String getCatalog() {
|
||||
return catalog;
|
||||
}
|
||||
|
||||
protected void setCatalog(String catalog) {
|
||||
this.catalog = catalog;
|
||||
}
|
||||
|
||||
public String getPackageName() {
|
||||
return packageName;
|
||||
}
|
||||
|
||||
protected void setPackageName(String packageName) {
|
||||
this.packageName = packageName;
|
||||
}
|
||||
|
||||
public String getSchema() {
|
||||
return schema;
|
||||
}
|
||||
|
||||
protected void setSchema(String schema) {
|
||||
this.schema = schema;
|
||||
}
|
||||
|
||||
public Boolean getMetadataComplete() {
|
||||
return metadataComplete;
|
||||
}
|
||||
|
||||
public boolean canUseJavaAnnotations() {
|
||||
return metadataComplete == null || !metadataComplete;
|
||||
}
|
||||
|
||||
protected void setMetadataComplete(Boolean metadataComplete) {
|
||||
this.metadataComplete = metadataComplete;
|
||||
}
|
||||
|
||||
public Boolean getCascadePersist() {
|
||||
return cascadePersist;
|
||||
}
|
||||
|
||||
void setCascadePersist(Boolean cascadePersist) {
|
||||
this.cascadePersist = cascadePersist;
|
||||
}
|
||||
|
||||
public void override(Default globalDefault) {
|
||||
if ( globalDefault != null ) {
|
||||
if ( globalDefault.getAccess() != null ) {
|
||||
access = globalDefault.getAccess();
|
||||
}
|
||||
if ( globalDefault.getPackageName() != null ) {
|
||||
packageName = globalDefault.getPackageName();
|
||||
}
|
||||
if ( globalDefault.getSchema() != null ) {
|
||||
schema = globalDefault.getSchema();
|
||||
}
|
||||
if ( globalDefault.getCatalog() != null ) {
|
||||
catalog = globalDefault.getCatalog();
|
||||
}
|
||||
if ( globalDefault.getDelimitedIdentifier() != null ) {
|
||||
delimitedIdentifier = globalDefault.getDelimitedIdentifier();
|
||||
}
|
||||
if ( globalDefault.getMetadataComplete() != null ) {
|
||||
metadataComplete = globalDefault.getMetadataComplete();
|
||||
}
|
||||
//TODO fix that in stone if cascade-persist is set already?
|
||||
if ( globalDefault.getCascadePersist() != null ) cascadePersist = globalDefault.getCascadePersist();
|
||||
}
|
||||
}
|
||||
|
||||
public void setDelimitedIdentifiers(Boolean delimitedIdentifier) {
|
||||
this.delimitedIdentifier = delimitedIdentifier;
|
||||
}
|
||||
|
||||
public Boolean getDelimitedIdentifier() {
|
||||
return delimitedIdentifier;
|
||||
}
|
||||
}
|
||||
|
||||
public List<String> getDefaultEntityListeners() {
|
||||
return defaultEntityListeners;
|
||||
}
|
||||
}
|
||||
|
|
@ -6,6 +6,8 @@
|
|||
*/
|
||||
package org.hibernate.test.annotations.reflection;
|
||||
|
||||
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
|
||||
import org.junit.Test;
|
||||
|
|
@ -13,9 +15,15 @@ import org.junit.Test;
|
|||
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
@TestForIssue( jiraKey = "HHH-11924")
|
||||
@TestForIssue(jiraKey = {"HHH-11924", "HHH-14529"})
|
||||
public class ElementCollectionConverterTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Override
|
||||
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
|
||||
// FIXME HHH-14529 configure the BootstrapServiceRegistry to use JAXB for orm.xml mappings
|
||||
super.prepareBootstrapRegistryBuilder( builder );
|
||||
}
|
||||
|
||||
@Override
|
||||
protected Class[] getAnnotatedClasses() {
|
||||
return new Class[] {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,432 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.reflection;
|
||||
|
||||
import org.dom4j.DocumentException;
|
||||
import org.dom4j.io.SAXReader;
|
||||
import org.hibernate.annotations.Columns;
|
||||
import org.hibernate.cfg.EJB3DTDEntityResolver;
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader;
|
||||
import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
|
||||
import org.hibernate.internal.util.xml.ErrorLogger;
|
||||
import org.hibernate.internal.util.xml.XMLHelper;
|
||||
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.junit4.BaseUnitTestCase;
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
|
||||
import org.junit.Test;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import org.xml.sax.SAXNotSupportedException;
|
||||
|
||||
import javax.persistence.*;
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
/**
|
||||
* Tests the new {@link JPAXMLOverriddenAnnotationReader},
|
||||
* which will be replacing {@link JPAOverriddenAnnotationReader}.
|
||||
* {@link JPAOverriddenAnnotationReader} is still the default implementation,
|
||||
* but we want to switch to {@link JPAXMLOverriddenAnnotationReader}
|
||||
* as soon as it will be practical.
|
||||
*
|
||||
* @see LegacyJPAOverriddenAnnotationReaderTest
|
||||
* @author Emmanuel Bernard
|
||||
*/
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class JPAXMLOverriddenAnnotationReaderTest extends BaseUnitTestCase {
|
||||
@Test
|
||||
public void testMappedSuperclassAnnotations() throws Exception {
|
||||
XMLContext context = buildContext(
|
||||
"org/hibernate/test/annotations/reflection/metadata-complete.xml"
|
||||
);
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( Organization.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertTrue( reader.isAnnotationPresent( MappedSuperclass.class ) );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEntityRelatedAnnotations() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Entity.class ) );
|
||||
assertEquals(
|
||||
"Default value in xml entity should not override @Entity.name", "JavaAdministration",
|
||||
reader.getAnnotation( Entity.class ).name()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( Table.class ) );
|
||||
assertEquals( "@Table not overridden", "tbl_admin", reader.getAnnotation( Table.class ).name() );
|
||||
assertEquals( "Default schema not overridden", "myschema", reader.getAnnotation( Table.class ).schema() );
|
||||
assertEquals(
|
||||
"Proper @Table.uniqueConstraints", 2,
|
||||
reader.getAnnotation( Table.class ).uniqueConstraints()[0].columnNames().length
|
||||
);
|
||||
String columnName = reader.getAnnotation( Table.class ).uniqueConstraints()[0].columnNames()[0];
|
||||
assertTrue(
|
||||
"Proper @Table.uniqueConstraints", "firstname".equals( columnName ) || "lastname".equals( columnName )
|
||||
);
|
||||
assertNull( "Both Java and XML used", reader.getAnnotation( SecondaryTable.class ) );
|
||||
assertNotNull( "XML does not work", reader.getAnnotation( SecondaryTables.class ) );
|
||||
SecondaryTable[] tables = reader.getAnnotation( SecondaryTables.class ).value();
|
||||
assertEquals( 1, tables.length );
|
||||
assertEquals( "admin2", tables[0].name() );
|
||||
assertEquals( "unique constraints ignored", 1, tables[0].uniqueConstraints().length );
|
||||
assertEquals( "pk join column ignored", 1, tables[0].pkJoinColumns().length );
|
||||
assertEquals( "pk join column ignored", "admin_id", tables[0].pkJoinColumns()[0].name() );
|
||||
assertNotNull( "Sequence Overriding not working", reader.getAnnotation( SequenceGenerator.class ) );
|
||||
assertEquals(
|
||||
"wrong sequence name", "seqhilo", reader.getAnnotation( SequenceGenerator.class ).sequenceName()
|
||||
);
|
||||
assertEquals( "default fails", 50, reader.getAnnotation( SequenceGenerator.class ).allocationSize() );
|
||||
assertNotNull( "TableOverriding not working", reader.getAnnotation( TableGenerator.class ) );
|
||||
assertEquals( "wrong tble name", "tablehilo", reader.getAnnotation( TableGenerator.class ).table() );
|
||||
assertEquals( "no schema overriding", "myschema", reader.getAnnotation( TableGenerator.class ).schema() );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( Match.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Table.class ) );
|
||||
assertEquals(
|
||||
"Java annotation not taken into account", "matchtable", reader.getAnnotation( Table.class ).name()
|
||||
);
|
||||
assertEquals(
|
||||
"Java annotation not taken into account", "matchschema", reader.getAnnotation( Table.class ).schema()
|
||||
);
|
||||
assertEquals( "Overriding not taken into account", "mycatalog", reader.getAnnotation( Table.class ).catalog() );
|
||||
assertNotNull( "SecondaryTable swallowed", reader.getAnnotation( SecondaryTables.class ) );
|
||||
assertEquals(
|
||||
"Default schema not taken into account", "myschema",
|
||||
reader.getAnnotation( SecondaryTables.class ).value()[0].schema()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( Inheritance.class ) );
|
||||
assertEquals(
|
||||
"inheritance strategy not overriden", InheritanceType.JOINED,
|
||||
reader.getAnnotation( Inheritance.class ).strategy()
|
||||
);
|
||||
assertNotNull( "NamedQuery not overriden", reader.getAnnotation( NamedQueries.class ) );
|
||||
assertEquals( "No deduplication", 3, reader.getAnnotation( NamedQueries.class ).value().length );
|
||||
assertEquals(
|
||||
"deduplication kept the Java version", 1,
|
||||
reader.getAnnotation( NamedQueries.class ).value()[1].hints().length
|
||||
);
|
||||
assertEquals(
|
||||
"org.hibernate.timeout", reader.getAnnotation( NamedQueries.class ).value()[1].hints()[0].name()
|
||||
);
|
||||
assertNotNull( "NamedNativeQuery not overriden", reader.getAnnotation( NamedNativeQueries.class ) );
|
||||
assertEquals( "No deduplication", 3, reader.getAnnotation( NamedNativeQueries.class ).value().length );
|
||||
assertEquals(
|
||||
"deduplication kept the Java version", 1,
|
||||
reader.getAnnotation( NamedNativeQueries.class ).value()[1].hints().length
|
||||
);
|
||||
assertEquals(
|
||||
"org.hibernate.timeout", reader.getAnnotation( NamedNativeQueries.class ).value()[1].hints()[0].name()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( SqlResultSetMappings.class ) );
|
||||
assertEquals(
|
||||
"competitor1Point", reader.getAnnotation( SqlResultSetMappings.class ).value()[0].columns()[0].name()
|
||||
);
|
||||
assertEquals(
|
||||
"competitor1Point",
|
||||
reader.getAnnotation( SqlResultSetMappings.class ).value()[0].entities()[0].fields()[0].column()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( ExcludeSuperclassListeners.class ) );
|
||||
assertNotNull( reader.getAnnotation( ExcludeDefaultListeners.class ) );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( Competition.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( MappedSuperclass.class ) );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( TennisMatch.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull( "Mutualize PKJC into PKJCs", reader.getAnnotation( PrimaryKeyJoinColumn.class ) );
|
||||
assertNotNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
|
||||
assertEquals(
|
||||
"PrimaryKeyJoinColumn overrden", "id",
|
||||
reader.getAnnotation( PrimaryKeyJoinColumns.class ).value()[0].name()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( AttributeOverrides.class ) );
|
||||
assertEquals( "Wrong deduplication", 3, reader.getAnnotation( AttributeOverrides.class ).value().length );
|
||||
assertEquals(
|
||||
"Wrong priority (XML vs java annotations)", "fld_net",
|
||||
reader.getAnnotation( AttributeOverrides.class ).value()[0].column().name()
|
||||
);
|
||||
assertEquals(
|
||||
"Column mapping", 2, reader.getAnnotation( AttributeOverrides.class ).value()[1].column().scale()
|
||||
);
|
||||
assertEquals(
|
||||
"Column mapping", true, reader.getAnnotation( AttributeOverrides.class ).value()[1].column().unique()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( AssociationOverrides.class ) );
|
||||
assertEquals( "no XML processing", 1, reader.getAnnotation( AssociationOverrides.class ).value().length );
|
||||
assertEquals(
|
||||
"wrong xml processing", "id",
|
||||
reader.getAnnotation( AssociationOverrides.class ).value()[0].joinColumns()[0].referencedColumnName()
|
||||
);
|
||||
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( SocialSecurityPhysicalAccount.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( IdClass.class ) );
|
||||
assertEquals( "id-class not used", SocialSecurityNumber.class, reader.getAnnotation( IdClass.class ).value() );
|
||||
assertEquals(
|
||||
"discriminator-value not used", "Physical", reader.getAnnotation( DiscriminatorValue.class ).value()
|
||||
);
|
||||
assertNotNull( "discriminator-column not used", reader.getAnnotation( DiscriminatorColumn.class ) );
|
||||
assertEquals(
|
||||
"discriminator-column.name default value broken", "DTYPE",
|
||||
reader.getAnnotation( DiscriminatorColumn.class ).name()
|
||||
);
|
||||
assertEquals(
|
||||
"discriminator-column.length broken", 34, reader.getAnnotation( DiscriminatorColumn.class ).length()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEntityRelatedAnnotationsMetadataComplete() throws Exception {
|
||||
XMLContext context = buildContext(
|
||||
"org/hibernate/test/annotations/reflection/metadata-complete.xml"
|
||||
);
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Entity.class ) );
|
||||
assertEquals(
|
||||
"Metadata complete should ignore java annotations", "", reader.getAnnotation( Entity.class ).name()
|
||||
);
|
||||
assertNotNull( reader.getAnnotation( Table.class ) );
|
||||
assertEquals( "@Table should not be used", "", reader.getAnnotation( Table.class ).name() );
|
||||
assertEquals( "Default schema not overriden", "myschema", reader.getAnnotation( Table.class ).schema() );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( Match.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Table.class ) );
|
||||
assertEquals( "@Table should not be used", "", reader.getAnnotation( Table.class ).name() );
|
||||
assertEquals( "Overriding not taken into account", "myschema", reader.getAnnotation( Table.class ).schema() );
|
||||
assertEquals( "Overriding not taken into account", "mycatalog", reader.getAnnotation( Table.class ).catalog() );
|
||||
assertNull( "Ignore Java annotation", reader.getAnnotation( SecondaryTable.class ) );
|
||||
assertNull( "Ignore Java annotation", reader.getAnnotation( SecondaryTables.class ) );
|
||||
assertNull( "Ignore Java annotation", reader.getAnnotation( Inheritance.class ) );
|
||||
assertNull( reader.getAnnotation( NamedQueries.class ) );
|
||||
assertNull( reader.getAnnotation( NamedNativeQueries.class ) );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( TennisMatch.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull( reader.getAnnotation( PrimaryKeyJoinColumn.class ) );
|
||||
assertNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( Competition.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull( reader.getAnnotation( MappedSuperclass.class ) );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( SocialSecurityMoralAccount.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull( reader.getAnnotation( IdClass.class ) );
|
||||
assertNull( reader.getAnnotation( DiscriminatorValue.class ) );
|
||||
assertNull( reader.getAnnotation( DiscriminatorColumn.class ) );
|
||||
assertNull( reader.getAnnotation( SequenceGenerator.class ) );
|
||||
assertNull( reader.getAnnotation( TableGenerator.class ) );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIdRelatedAnnotations() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
Method method = Administration.class.getDeclaredMethod( "getId" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull( reader.getAnnotation( Id.class ) );
|
||||
assertNull( reader.getAnnotation( Column.class ) );
|
||||
Field field = Administration.class.getDeclaredField( "id" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Id.class ) );
|
||||
assertNotNull( reader.getAnnotation( GeneratedValue.class ) );
|
||||
assertEquals( GenerationType.SEQUENCE, reader.getAnnotation( GeneratedValue.class ).strategy() );
|
||||
assertEquals( "generator", reader.getAnnotation( GeneratedValue.class ).generator() );
|
||||
assertNotNull( reader.getAnnotation( SequenceGenerator.class ) );
|
||||
assertEquals( "seq", reader.getAnnotation( SequenceGenerator.class ).sequenceName() );
|
||||
assertNotNull( reader.getAnnotation( Columns.class ) );
|
||||
assertEquals( 1, reader.getAnnotation( Columns.class ).columns().length );
|
||||
assertEquals( "fld_id", reader.getAnnotation( Columns.class ).columns()[0].name() );
|
||||
assertNotNull( reader.getAnnotation( Temporal.class ) );
|
||||
assertEquals( TemporalType.DATE, reader.getAnnotation( Temporal.class ).value() );
|
||||
|
||||
context = buildContext(
|
||||
"org/hibernate/test/annotations/reflection/metadata-complete.xml"
|
||||
);
|
||||
method = Administration.class.getDeclaredMethod( "getId" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull(
|
||||
"Default access type when not defined in metadata complete should be property",
|
||||
reader.getAnnotation( Id.class )
|
||||
);
|
||||
field = Administration.class.getDeclaredField( "id" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull(
|
||||
"Default access type when not defined in metadata complete should be property",
|
||||
reader.getAnnotation( Id.class )
|
||||
);
|
||||
|
||||
method = BusTrip.class.getDeclaredMethod( "getId" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNull( reader.getAnnotation( EmbeddedId.class ) );
|
||||
field = BusTrip.class.getDeclaredField( "id" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( EmbeddedId.class ) );
|
||||
assertNotNull( reader.getAnnotation( AttributeOverrides.class ) );
|
||||
assertEquals( 1, reader.getAnnotation( AttributeOverrides.class ).value().length );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBasicRelatedAnnotations() throws Exception {
|
||||
XMLContext context = buildContext(
|
||||
"org/hibernate/test/annotations/reflection/metadata-complete.xml"
|
||||
);
|
||||
Field field = BusTrip.class.getDeclaredField( "status" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Enumerated.class ) );
|
||||
assertEquals( EnumType.STRING, reader.getAnnotation( Enumerated.class ).value() );
|
||||
assertEquals( false, reader.getAnnotation( Basic.class ).optional() );
|
||||
field = BusTrip.class.getDeclaredField( "serial" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Lob.class ) );
|
||||
assertEquals( "serialbytes", reader.getAnnotation( Columns.class ).columns()[0].name() );
|
||||
field = BusTrip.class.getDeclaredField( "terminusTime" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Temporal.class ) );
|
||||
assertEquals( TemporalType.TIMESTAMP, reader.getAnnotation( Temporal.class ).value() );
|
||||
assertEquals( FetchType.LAZY, reader.getAnnotation( Basic.class ).fetch() );
|
||||
|
||||
field = BusTripPk.class.getDeclaredField( "busDriver" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.isAnnotationPresent( Basic.class ) );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testVersionRelatedAnnotations() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
Method method = Administration.class.getDeclaredMethod( "getVersion" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Version.class ) );
|
||||
|
||||
Field field = Match.class.getDeclaredField( "version" );
|
||||
assertNotNull( reader.getAnnotation( Version.class ) );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTransientAndEmbeddedRelatedAnnotations() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
|
||||
Field field = Administration.class.getDeclaredField( "transientField" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Transient.class ) );
|
||||
assertNull( reader.getAnnotation( Basic.class ) );
|
||||
|
||||
field = Match.class.getDeclaredField( "playerASSN" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( Embedded.class ) );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAssociationRelatedAnnotations() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
|
||||
Field field = Administration.class.getDeclaredField( "defaultBusTrip" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( OneToOne.class ) );
|
||||
assertNull( reader.getAnnotation( JoinColumns.class ) );
|
||||
assertNotNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
|
||||
assertEquals( "pk", reader.getAnnotation( PrimaryKeyJoinColumns.class ).value()[0].name() );
|
||||
assertEquals( 5, reader.getAnnotation( OneToOne.class ).cascade().length );
|
||||
assertEquals( FetchType.LAZY, reader.getAnnotation( OneToOne.class ).fetch() );
|
||||
assertEquals( "test", reader.getAnnotation( OneToOne.class ).mappedBy() );
|
||||
|
||||
context = buildContext(
|
||||
"org/hibernate/test/annotations/reflection/metadata-complete.xml"
|
||||
);
|
||||
field = BusTrip.class.getDeclaredField( "players" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( OneToMany.class ) );
|
||||
assertNotNull( reader.getAnnotation( JoinColumns.class ) );
|
||||
assertEquals( 2, reader.getAnnotation( JoinColumns.class ).value().length );
|
||||
assertEquals( "driver", reader.getAnnotation( JoinColumns.class ).value()[0].name() );
|
||||
assertNotNull( reader.getAnnotation( MapKey.class ) );
|
||||
assertEquals( "name", reader.getAnnotation( MapKey.class ).name() );
|
||||
|
||||
field = BusTrip.class.getDeclaredField( "roads" );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( ManyToMany.class ) );
|
||||
assertNotNull( reader.getAnnotation( JoinTable.class ) );
|
||||
assertEquals( "bus_road", reader.getAnnotation( JoinTable.class ).name() );
|
||||
assertEquals( 2, reader.getAnnotation( JoinTable.class ).joinColumns().length );
|
||||
assertEquals( 1, reader.getAnnotation( JoinTable.class ).inverseJoinColumns().length );
|
||||
assertEquals( 2, reader.getAnnotation( JoinTable.class ).uniqueConstraints()[0].columnNames().length );
|
||||
assertNotNull( reader.getAnnotation( OrderBy.class ) );
|
||||
assertEquals( "maxSpeed", reader.getAnnotation( OrderBy.class ).value() );
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestForIssue(jiraKey = "HHH-11924")
|
||||
public void testElementCollectionConverter() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
|
||||
Field field = Company.class.getDeclaredField( "organizations" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
|
||||
assertNotNull( reader.getAnnotation( ElementCollection.class ) );
|
||||
assertNotNull( reader.getAnnotation( Converts.class ) );
|
||||
assertNotNull( reader.getAnnotation( Converts.class ).value() );
|
||||
assertTrue( reader.getAnnotation( Converts.class ).value().length == 1 );
|
||||
assertEquals(OrganizationConverter.class, reader.getAnnotation( Converts.class ).value()[0].converter());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEntityListeners() throws Exception {
|
||||
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
|
||||
|
||||
Method method = Administration.class.getDeclaredMethod( "calculate" );
|
||||
JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertTrue( reader.isAnnotationPresent( PrePersist.class ) );
|
||||
|
||||
reader = new JPAXMLOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
|
||||
assertTrue( reader.isAnnotationPresent( EntityListeners.class ) );
|
||||
assertEquals( 1, reader.getAnnotation( EntityListeners.class ).value().length );
|
||||
assertEquals( LogListener.class, reader.getAnnotation( EntityListeners.class ).value()[0] );
|
||||
|
||||
method = LogListener.class.getDeclaredMethod( "noLog", Object.class );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertTrue( reader.isAnnotationPresent( PostLoad.class ) );
|
||||
|
||||
method = LogListener.class.getDeclaredMethod( "log", Object.class );
|
||||
reader = new JPAXMLOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
|
||||
assertTrue( reader.isAnnotationPresent( PrePersist.class ) );
|
||||
assertFalse( reader.isAnnotationPresent( PostPersist.class ) );
|
||||
|
||||
assertEquals( 1, context.getDefaultEntityListeners().size() );
|
||||
assertEquals( OtherLogListener.class.getName(), context.getDefaultEntityListeners().get( 0 ) );
|
||||
}
|
||||
|
||||
private XMLContext buildContext(String ormfile) throws SAXException, DocumentException, IOException {
|
||||
XMLHelper xmlHelper = new XMLHelper();
|
||||
InputStream is = ClassLoaderServiceTestingImpl.INSTANCE.locateResourceStream( ormfile );
|
||||
assertNotNull( "ORM.xml not found: " + ormfile, is );
|
||||
XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
|
||||
ErrorLogger errorLogger = new ErrorLogger();
|
||||
SAXReader saxReader = xmlHelper.createSAXReader( errorLogger, EJB3DTDEntityResolver.INSTANCE );
|
||||
//saxReader.setValidation( false );
|
||||
try {
|
||||
saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
|
||||
}
|
||||
catch ( SAXNotSupportedException e ) {
|
||||
saxReader.setValidation( false );
|
||||
}
|
||||
org.dom4j.Document doc;
|
||||
try {
|
||||
doc = saxReader.read( new InputSource( new BufferedInputStream( is ) ) );
|
||||
}
|
||||
finally {
|
||||
is.close();
|
||||
}
|
||||
if ( errorLogger.hasErrors() ) {
|
||||
System.out.println( errorLogger.getErrors().get( 0 ) );
|
||||
}
|
||||
assertFalse( errorLogger.hasErrors() );
|
||||
context.addDocument( doc );
|
||||
return context;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.reflection;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
/**
|
||||
* Tests the legacy {@link JPAOverriddenAnnotationReader},
|
||||
* which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}.
|
||||
* {@link JPAOverriddenAnnotationReader} is still the default implementation,
|
||||
* but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}
|
||||
* as soon as it will be practical.
|
||||
*
|
||||
* @see JPAXMLOverriddenAnnotationReaderTest
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
@TestForIssue( jiraKey = "HHH-11924")
|
||||
public class LegacyElementCollectionConverterTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Override
|
||||
protected Class[] getAnnotatedClasses() {
|
||||
return new Class[] {
|
||||
Company.class,
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String[] getXmlFiles() {
|
||||
return new String[] { "org/hibernate/test/annotations/reflection/element-collection-converter-orm.xml" };
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testConverterIsAppliedToElementCollection() {
|
||||
doInHibernate( this::sessionFactory, session -> {
|
||||
Company company = new Company();
|
||||
company.setId( 1L );
|
||||
|
||||
Organization org1 = new Organization();
|
||||
org1.setOrganizationId( "ACME" );
|
||||
|
||||
company.getOrganizations().add( org1 );
|
||||
|
||||
session.persist( company );
|
||||
} );
|
||||
|
||||
doInHibernate( this::sessionFactory, session -> {
|
||||
String organizationId = (String) session
|
||||
.createNativeQuery( "select organizations from Company_organizations" )
|
||||
.getSingleResult();
|
||||
assertEquals( "ORG-ACME", organizationId );
|
||||
|
||||
Company company = session.find( Company.class, 1L );
|
||||
|
||||
assertEquals( 1, company.getOrganizations().size() );
|
||||
assertEquals( "ACME" , company.getOrganizations().get( 0 ).getOrganizationId());
|
||||
} );
|
||||
}
|
||||
}
|
||||
|
|
@ -6,8 +6,61 @@
|
|||
*/
|
||||
package org.hibernate.test.annotations.reflection;
|
||||
|
||||
import org.dom4j.DocumentException;
|
||||
import org.dom4j.io.SAXReader;
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import javax.persistence.AssociationOverrides;
|
||||
import javax.persistence.AttributeOverrides;
|
||||
import javax.persistence.Basic;
|
||||
import javax.persistence.Column;
|
||||
import javax.persistence.Converts;
|
||||
import javax.persistence.DiscriminatorColumn;
|
||||
import javax.persistence.DiscriminatorValue;
|
||||
import javax.persistence.ElementCollection;
|
||||
import javax.persistence.Embedded;
|
||||
import javax.persistence.EmbeddedId;
|
||||
import javax.persistence.Entity;
|
||||
import javax.persistence.EntityListeners;
|
||||
import javax.persistence.EnumType;
|
||||
import javax.persistence.Enumerated;
|
||||
import javax.persistence.ExcludeDefaultListeners;
|
||||
import javax.persistence.ExcludeSuperclassListeners;
|
||||
import javax.persistence.FetchType;
|
||||
import javax.persistence.GeneratedValue;
|
||||
import javax.persistence.GenerationType;
|
||||
import javax.persistence.Id;
|
||||
import javax.persistence.IdClass;
|
||||
import javax.persistence.Inheritance;
|
||||
import javax.persistence.InheritanceType;
|
||||
import javax.persistence.JoinColumns;
|
||||
import javax.persistence.JoinTable;
|
||||
import javax.persistence.Lob;
|
||||
import javax.persistence.ManyToMany;
|
||||
import javax.persistence.MapKey;
|
||||
import javax.persistence.MappedSuperclass;
|
||||
import javax.persistence.NamedNativeQueries;
|
||||
import javax.persistence.NamedQueries;
|
||||
import javax.persistence.OneToMany;
|
||||
import javax.persistence.OneToOne;
|
||||
import javax.persistence.OrderBy;
|
||||
import javax.persistence.PostLoad;
|
||||
import javax.persistence.PostPersist;
|
||||
import javax.persistence.PrePersist;
|
||||
import javax.persistence.PrimaryKeyJoinColumn;
|
||||
import javax.persistence.PrimaryKeyJoinColumns;
|
||||
import javax.persistence.SecondaryTable;
|
||||
import javax.persistence.SecondaryTables;
|
||||
import javax.persistence.SequenceGenerator;
|
||||
import javax.persistence.SqlResultSetMappings;
|
||||
import javax.persistence.Table;
|
||||
import javax.persistence.TableGenerator;
|
||||
import javax.persistence.Temporal;
|
||||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.Transient;
|
||||
import javax.persistence.Version;
|
||||
|
||||
import org.hibernate.annotations.Columns;
|
||||
import org.hibernate.cfg.EJB3DTDEntityResolver;
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
|
@ -15,28 +68,37 @@ import org.hibernate.cfg.annotations.reflection.XMLContext;
|
|||
import org.hibernate.internal.util.xml.ErrorLogger;
|
||||
import org.hibernate.internal.util.xml.XMLHelper;
|
||||
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.junit4.BaseUnitTestCase;
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
|
||||
import org.hibernate.testing.junit4.BaseUnitTestCase;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.dom4j.DocumentException;
|
||||
import org.dom4j.io.SAXReader;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import org.xml.sax.SAXNotSupportedException;
|
||||
|
||||
import javax.persistence.*;
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Tests the legacy {@link JPAOverriddenAnnotationReader},
|
||||
* which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}.
|
||||
* {@link JPAOverriddenAnnotationReader} is still the default implementation,
|
||||
* but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}
|
||||
* as soon as it will be practical.
|
||||
*
|
||||
* @see JPAXMLOverriddenAnnotationReaderTest
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
public class JPAOverriddenAnnotationReaderTest extends BaseUnitTestCase {
|
||||
@Deprecated
|
||||
public class LegacyJPAOverriddenAnnotationReaderTest extends BaseUnitTestCase {
|
||||
@Test
|
||||
public void testMappedSuperclassAnnotations() throws Exception {
|
||||
XMLContext context = buildContext(
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.reflection;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
import org.hibernate.cfg.EJB3DTDEntityResolver;
|
||||
import org.hibernate.cfg.annotations.reflection.XMLContext;
|
||||
import org.hibernate.internal.util.xml.ErrorLogger;
|
||||
import org.hibernate.internal.util.xml.XMLHelper;
|
||||
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.dom4j.io.SAXReader;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXNotSupportedException;
|
||||
|
||||
/**
|
||||
* Tests the legacy {@link XMLContext},
|
||||
* which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext}.
|
||||
* {@link XMLContext} is still the default implementation,
|
||||
* but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext}
|
||||
* as soon as it will be practical.
|
||||
*
|
||||
* @see XMLContextTest
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link XMLContext}.
|
||||
*/
|
||||
public class LegacyXMLContextTest {
|
||||
@Test
|
||||
public void testAll() throws Exception {
|
||||
final XMLHelper xmlHelper = new XMLHelper();
|
||||
final XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
|
||||
|
||||
InputStream is = ClassLoaderServiceTestingImpl.INSTANCE.locateResourceStream(
|
||||
"org/hibernate/test/annotations/reflection/orm.xml"
|
||||
);
|
||||
Assert.assertNotNull( "ORM.xml not found", is );
|
||||
|
||||
final ErrorLogger errorLogger = new ErrorLogger();
|
||||
final SAXReader saxReader = xmlHelper.createSAXReader( errorLogger, EJB3DTDEntityResolver.INSTANCE );
|
||||
|
||||
try {
|
||||
saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
|
||||
}
|
||||
catch ( SAXNotSupportedException e ) {
|
||||
saxReader.setValidation( false );
|
||||
}
|
||||
org.dom4j.Document doc;
|
||||
try {
|
||||
doc = saxReader.read( new InputSource( new BufferedInputStream( is ) ) );
|
||||
}
|
||||
finally {
|
||||
try {
|
||||
is.close();
|
||||
}
|
||||
catch ( IOException ioe ) {
|
||||
//log.warn( "Could not close input stream", ioe );
|
||||
}
|
||||
}
|
||||
Assert.assertFalse( errorLogger.hasErrors() );
|
||||
context.addDocument( doc );
|
||||
}
|
||||
}
|
||||
|
|
@ -17,16 +17,24 @@ import org.xml.sax.InputSource;
|
|||
import org.xml.sax.SAXNotSupportedException;
|
||||
|
||||
import org.hibernate.cfg.EJB3DTDEntityResolver;
|
||||
import org.hibernate.cfg.annotations.reflection.XMLContext;
|
||||
import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
|
||||
import org.hibernate.internal.util.xml.ErrorLogger;
|
||||
import org.hibernate.internal.util.xml.XMLHelper;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
|
||||
|
||||
/**
|
||||
* Tests the new {@link XMLContext},
|
||||
* which will be replacing {@link org.hibernate.cfg.annotations.reflection.XMLContext}.
|
||||
* {@link org.hibernate.cfg.annotations.reflection.XMLContext} is still the default implementation,
|
||||
* but we want to switch to {@link XMLContext}
|
||||
* as soon as it will be practical.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
*/
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class XMLContextTest {
|
||||
@Test
|
||||
public void testAll() throws Exception {
|
||||
|
|
|
|||
|
|
@ -34,12 +34,14 @@ import javax.persistence.Temporal;
|
|||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class Ejb3XmlElementCollectionTest extends Ejb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
|
|
|
|||
|
|
@ -29,12 +29,14 @@ import javax.persistence.OrderColumn;
|
|||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class Ejb3XmlManyToManyTest extends Ejb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
|
|
|
|||
|
|
@ -18,12 +18,14 @@ import javax.persistence.ManyToOne;
|
|||
import javax.persistence.MapsId;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class Ejb3XmlManyToOneTest extends Ejb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoJoins() throws Exception {
|
||||
|
|
|
|||
|
|
@ -29,12 +29,14 @@ import javax.persistence.OrderColumn;
|
|||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class Ejb3XmlOneToManyTest extends Ejb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
|
|
|
|||
|
|
@ -20,12 +20,14 @@ import javax.persistence.PrimaryKeyJoinColumn;
|
|||
import javax.persistence.PrimaryKeyJoinColumns;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class Ejb3XmlOneToOneTest extends Ejb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import java.util.List;
|
|||
import org.hibernate.Session;
|
||||
import org.hibernate.SessionFactory;
|
||||
import org.hibernate.Transaction;
|
||||
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
|
||||
import org.hibernate.dialect.CockroachDB192Dialect;
|
||||
import org.hibernate.dialect.PostgreSQL81Dialect;
|
||||
import org.hibernate.dialect.PostgreSQLDialect;
|
||||
|
|
@ -19,6 +20,7 @@ import org.hibernate.dialect.TeradataDialect;
|
|||
import org.hibernate.persister.collection.BasicCollectionPersister;
|
||||
|
||||
import org.hibernate.testing.SkipForDialect;
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
|
||||
import org.junit.Test;
|
||||
|
||||
|
|
@ -28,7 +30,15 @@ import static org.junit.Assert.assertNotNull;
|
|||
/**
|
||||
* @author Emmanuel Bernard
|
||||
*/
|
||||
@TestForIssue(jiraKey = "HHH-14529")
|
||||
public class Ejb3XmlTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Override
|
||||
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
|
||||
// FIXME HHH-14529 configure the BootstrapServiceRegistry to use JAXB for orm.xml mappings
|
||||
super.prepareBootstrapRegistryBuilder( builder );
|
||||
}
|
||||
|
||||
@Test
|
||||
@SkipForDialect(value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class, CockroachDB192Dialect.class},
|
||||
comment = "postgresql jdbc driver does not implement the setQueryTimeout method")
|
||||
|
|
|
|||
|
|
@ -13,8 +13,8 @@ import java.lang.reflect.AnnotatedElement;
|
|||
import org.dom4j.Document;
|
||||
import org.dom4j.io.SAXReader;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
import org.hibernate.cfg.annotations.reflection.XMLContext;
|
||||
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader;
|
||||
import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
|
||||
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.junit4.BaseUnitTestCase;
|
||||
|
|
@ -28,8 +28,8 @@ import static org.junit.Assert.assertTrue;
|
|||
* XML to JPA annotations. The configuration is built within each test, and no
|
||||
* database is used. Thus, no schema generation or cleanup will be performed.
|
||||
*/
|
||||
abstract class Ejb3XmlTestCase extends BaseUnitTestCase {
|
||||
protected JPAOverriddenAnnotationReader reader;
|
||||
public abstract class Ejb3XmlTestCase extends BaseUnitTestCase {
|
||||
protected JPAXMLOverriddenAnnotationReader reader;
|
||||
|
||||
protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) {
|
||||
assertTrue(
|
||||
|
|
@ -45,11 +45,11 @@ abstract class Ejb3XmlTestCase extends BaseUnitTestCase {
|
|||
);
|
||||
}
|
||||
|
||||
protected JPAOverriddenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
|
||||
protected JPAXMLOverriddenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
|
||||
throws Exception {
|
||||
AnnotatedElement el = getAnnotatedElement( entityClass, fieldName );
|
||||
XMLContext xmlContext = getContext( ormResourceName );
|
||||
return new JPAOverriddenAnnotationReader( el, xmlContext, BootstrapContextImpl.INSTANCE );
|
||||
return new JPAXMLOverriddenAnnotationReader( el, xmlContext, BootstrapContextImpl.INSTANCE );
|
||||
}
|
||||
|
||||
protected AnnotatedElement getAnnotatedElement(Class<?> entityClass, String fieldName) throws Exception {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,716 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import javax.persistence.Access;
|
||||
import javax.persistence.AccessType;
|
||||
import javax.persistence.AssociationOverride;
|
||||
import javax.persistence.AssociationOverrides;
|
||||
import javax.persistence.AttributeOverride;
|
||||
import javax.persistence.AttributeOverrides;
|
||||
import javax.persistence.CollectionTable;
|
||||
import javax.persistence.Column;
|
||||
import javax.persistence.ElementCollection;
|
||||
import javax.persistence.EnumType;
|
||||
import javax.persistence.Enumerated;
|
||||
import javax.persistence.FetchType;
|
||||
import javax.persistence.JoinColumn;
|
||||
import javax.persistence.JoinTable;
|
||||
import javax.persistence.Lob;
|
||||
import javax.persistence.MapKey;
|
||||
import javax.persistence.MapKeyClass;
|
||||
import javax.persistence.MapKeyColumn;
|
||||
import javax.persistence.MapKeyEnumerated;
|
||||
import javax.persistence.MapKeyJoinColumn;
|
||||
import javax.persistence.MapKeyJoinColumns;
|
||||
import javax.persistence.MapKeyTemporal;
|
||||
import javax.persistence.OrderBy;
|
||||
import javax.persistence.OrderColumn;
|
||||
import javax.persistence.Temporal;
|
||||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlElementCollectionTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
public class LegacyEjb3XmlElementCollectionTest extends LegacyEjb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "element-collection.orm1.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( Column.class );
|
||||
assertAnnotationNotPresent( Temporal.class );
|
||||
assertAnnotationNotPresent( Enumerated.class );
|
||||
assertAnnotationNotPresent( Lob.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationNotPresent( AttributeOverrides.class );
|
||||
assertAnnotationNotPresent( AssociationOverride.class );
|
||||
assertAnnotationNotPresent( AssociationOverrides.class );
|
||||
assertAnnotationNotPresent( CollectionTable.class );
|
||||
assertAnnotationNotPresent( Access.class );
|
||||
ElementCollection relAnno = reader.getAnnotation( ElementCollection.class );
|
||||
assertEquals( FetchType.LAZY, relAnno.fetch() );
|
||||
assertEquals( void.class, relAnno.targetClass() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderBy() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "element-collection.orm2.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertEquals(
|
||||
"col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "element-collection.orm3.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationPresent( OrderColumn.class );
|
||||
OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
|
||||
assertEquals( "", orderColumnAnno.columnDefinition() );
|
||||
assertEquals( "", orderColumnAnno.name() );
|
||||
assertTrue( orderColumnAnno.insertable() );
|
||||
assertTrue( orderColumnAnno.nullable() );
|
||||
assertTrue( orderColumnAnno.updatable() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "element-collection.orm4.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationPresent( OrderColumn.class );
|
||||
OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
|
||||
assertEquals( "int", orderColumnAnno.columnDefinition() );
|
||||
assertEquals( "col1", orderColumnAnno.name() );
|
||||
assertFalse( orderColumnAnno.insertable() );
|
||||
assertFalse( orderColumnAnno.nullable() );
|
||||
assertFalse( orderColumnAnno.updatable() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm5.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm6.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyClass() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm7.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
Entity2.class, reader.getAnnotation( MapKeyClass.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyTemporal() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm8.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
TemporalType.DATE, reader.getAnnotation(
|
||||
MapKeyTemporal.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyEnumerated() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm9.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
EnumType.STRING, reader.getAnnotation(
|
||||
MapKeyEnumerated.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single map key attribute override, we still wrap it with
|
||||
* an AttributeOverrides annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleMapKeyAttributeOverride() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm10.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 1, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "col1", overrides[0].column().name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleMapKeyAttributeOverrides() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm11.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 2, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "", overrides[0].column().name() );
|
||||
assertFalse( overrides[0].column().unique() );
|
||||
assertTrue( overrides[0].column().nullable() );
|
||||
assertTrue( overrides[0].column().insertable() );
|
||||
assertTrue( overrides[0].column().updatable() );
|
||||
assertEquals( "", overrides[0].column().columnDefinition() );
|
||||
assertEquals( "", overrides[0].column().table() );
|
||||
assertEquals( 255, overrides[0].column().length() );
|
||||
assertEquals( 0, overrides[0].column().precision() );
|
||||
assertEquals( 0, overrides[0].column().scale() );
|
||||
assertEquals( "field2", overrides[1].name() );
|
||||
assertEquals( "col1", overrides[1].column().name() );
|
||||
assertTrue( overrides[1].column().unique() );
|
||||
assertFalse( overrides[1].column().nullable() );
|
||||
assertFalse( overrides[1].column().insertable() );
|
||||
assertFalse( overrides[1].column().updatable() );
|
||||
assertEquals( "int", overrides[1].column().columnDefinition() );
|
||||
assertEquals( "table1", overrides[1].column().table() );
|
||||
assertEquals( 50, overrides[1].column().length() );
|
||||
assertEquals( 2, overrides[1].column().precision() );
|
||||
assertEquals( 1, overrides[1].column().scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm12.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
|
||||
assertEquals( "", keyColAnno.columnDefinition() );
|
||||
assertEquals( "", keyColAnno.name() );
|
||||
assertEquals( "", keyColAnno.table() );
|
||||
assertFalse( keyColAnno.nullable() );
|
||||
assertTrue( keyColAnno.insertable() );
|
||||
assertFalse( keyColAnno.unique() );
|
||||
assertTrue( keyColAnno.updatable() );
|
||||
assertEquals( 255, keyColAnno.length() );
|
||||
assertEquals( 0, keyColAnno.precision() );
|
||||
assertEquals( 0, keyColAnno.scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm13.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
|
||||
assertEquals( "int", keyColAnno.columnDefinition() );
|
||||
assertEquals( "col1", keyColAnno.name() );
|
||||
assertEquals( "table1", keyColAnno.table() );
|
||||
assertTrue( keyColAnno.nullable() );
|
||||
assertFalse( keyColAnno.insertable() );
|
||||
assertTrue( keyColAnno.unique() );
|
||||
assertFalse( keyColAnno.updatable() );
|
||||
assertEquals( 50, keyColAnno.length() );
|
||||
assertEquals( 2, keyColAnno.precision() );
|
||||
assertEquals( 1, keyColAnno.scale() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single map key join column, we still wrap it with a
|
||||
* MapKeyJoinColumns annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleMapKeyJoinColumn() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm14.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyJoinColumns joinColumnsAnno = reader
|
||||
.getAnnotation( MapKeyJoinColumns.class );
|
||||
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleMapKeyJoinColumns() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm15.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyJoinColumns joinColumnsAnno = reader
|
||||
.getAnnotation( MapKeyJoinColumns.class );
|
||||
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertFalse( joinColumns[0].nullable() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
assertTrue( joinColumns[1].nullable() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertEquals( "table1", joinColumns[1].table() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm16.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( Column.class );
|
||||
Column column = reader.getAnnotation( Column.class );
|
||||
assertEquals( "", column.name() );
|
||||
assertFalse( column.unique() );
|
||||
assertTrue( column.nullable() );
|
||||
assertTrue( column.insertable() );
|
||||
assertTrue( column.updatable() );
|
||||
assertEquals( "", column.columnDefinition() );
|
||||
assertEquals( "", column.table() );
|
||||
assertEquals( 255, column.length() );
|
||||
assertEquals( 0, column.precision() );
|
||||
assertEquals( 0, column.scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm17.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( Column.class );
|
||||
Column column = reader.getAnnotation( Column.class );
|
||||
assertEquals( "col1", column.name() );
|
||||
assertTrue( column.unique() );
|
||||
assertFalse( column.nullable() );
|
||||
assertFalse( column.insertable() );
|
||||
assertFalse( column.updatable() );
|
||||
assertEquals( "int", column.columnDefinition() );
|
||||
assertEquals( "table1", column.table() );
|
||||
assertEquals( 50, column.length() );
|
||||
assertEquals( 2, column.precision() );
|
||||
assertEquals( 1, column.scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTemporal() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm18.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( Temporal.class );
|
||||
assertAnnotationNotPresent( Enumerated.class );
|
||||
assertAnnotationNotPresent( Lob.class );
|
||||
assertEquals(
|
||||
TemporalType.DATE, reader.getAnnotation(
|
||||
Temporal.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEnumerated() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm19.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( Temporal.class );
|
||||
assertAnnotationPresent( Enumerated.class );
|
||||
assertAnnotationNotPresent( Lob.class );
|
||||
assertEquals(
|
||||
EnumType.STRING, reader.getAnnotation(
|
||||
Enumerated.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLob() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm20.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( Temporal.class );
|
||||
assertAnnotationNotPresent( Enumerated.class );
|
||||
assertAnnotationPresent( Lob.class );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single attribute override, we still wrap it with an
|
||||
* AttributeOverrides annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleAttributeOverride() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm21.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 1, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "col1", overrides[0].column().name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleAttributeOverrides() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm22.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 2, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "", overrides[0].column().name() );
|
||||
assertFalse( overrides[0].column().unique() );
|
||||
assertTrue( overrides[0].column().nullable() );
|
||||
assertTrue( overrides[0].column().insertable() );
|
||||
assertTrue( overrides[0].column().updatable() );
|
||||
assertEquals( "", overrides[0].column().columnDefinition() );
|
||||
assertEquals( "", overrides[0].column().table() );
|
||||
assertEquals( 255, overrides[0].column().length() );
|
||||
assertEquals( 0, overrides[0].column().precision() );
|
||||
assertEquals( 0, overrides[0].column().scale() );
|
||||
assertEquals( "field2", overrides[1].name() );
|
||||
assertEquals( "col1", overrides[1].column().name() );
|
||||
assertTrue( overrides[1].column().unique() );
|
||||
assertFalse( overrides[1].column().nullable() );
|
||||
assertFalse( overrides[1].column().insertable() );
|
||||
assertFalse( overrides[1].column().updatable() );
|
||||
assertEquals( "int", overrides[1].column().columnDefinition() );
|
||||
assertEquals( "table1", overrides[1].column().table() );
|
||||
assertEquals( 50, overrides[1].column().length() );
|
||||
assertEquals( 2, overrides[1].column().precision() );
|
||||
assertEquals( 1, overrides[1].column().scale() );
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that map-key-attribute-override and attribute-override elements
|
||||
* both end up in the AttributeOverrides annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testMixedAttributeOverrides() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm23.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 2, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "col1", overrides[0].column().name() );
|
||||
assertEquals( "field2", overrides[1].name() );
|
||||
assertEquals( "col2", overrides[1].column().name() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single association override, we still wrap it with an
|
||||
* AssociationOverrides annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleAssociationOverride() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm24.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( AssociationOverride.class );
|
||||
assertAnnotationPresent( AssociationOverrides.class );
|
||||
AssociationOverrides overridesAnno = reader.getAnnotation( AssociationOverrides.class );
|
||||
AssociationOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 1, overrides.length );
|
||||
assertEquals( "association1", overrides[0].name() );
|
||||
assertEquals( 0, overrides[0].joinColumns().length );
|
||||
assertEquals( "", overrides[0].joinTable().name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleAssociationOverridesJoinColumns() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm25.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( AssociationOverride.class );
|
||||
assertAnnotationPresent( AssociationOverrides.class );
|
||||
AssociationOverrides overridesAnno = reader.getAnnotation( AssociationOverrides.class );
|
||||
AssociationOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 2, overrides.length );
|
||||
//First, an association using join table
|
||||
assertEquals( "association1", overrides[0].name() );
|
||||
assertEquals( 0, overrides[0].joinColumns().length );
|
||||
|
||||
JoinTable joinTableAnno = overrides[0].joinTable();
|
||||
assertEquals( "catalog1", joinTableAnno.catalog() );
|
||||
assertEquals( "table1", joinTableAnno.name() );
|
||||
assertEquals( "schema1", joinTableAnno.schema() );
|
||||
|
||||
//JoinColumns
|
||||
JoinColumn[] joinColumns = joinTableAnno.joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table2", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
|
||||
//InverseJoinColumns
|
||||
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
|
||||
assertEquals( 2, inverseJoinColumns.length );
|
||||
assertEquals( "", inverseJoinColumns[0].name() );
|
||||
assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", inverseJoinColumns[0].table() );
|
||||
assertEquals( "", inverseJoinColumns[0].columnDefinition() );
|
||||
assertTrue( inverseJoinColumns[0].insertable() );
|
||||
assertTrue( inverseJoinColumns[0].updatable() );
|
||||
assertTrue( inverseJoinColumns[0].nullable() );
|
||||
assertFalse( inverseJoinColumns[0].unique() );
|
||||
assertEquals( "col3", inverseJoinColumns[1].name() );
|
||||
assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table3", inverseJoinColumns[1].table() );
|
||||
assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
|
||||
assertFalse( inverseJoinColumns[1].insertable() );
|
||||
assertFalse( inverseJoinColumns[1].updatable() );
|
||||
assertFalse( inverseJoinColumns[1].nullable() );
|
||||
assertTrue( inverseJoinColumns[1].unique() );
|
||||
|
||||
//UniqueConstraints
|
||||
UniqueConstraint[] uniqueConstraints = joinTableAnno
|
||||
.uniqueConstraints();
|
||||
assertEquals( 2, uniqueConstraints.length );
|
||||
assertEquals( "", uniqueConstraints[0].name() );
|
||||
assertEquals( 1, uniqueConstraints[0].columnNames().length );
|
||||
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
|
||||
assertEquals( "uq1", uniqueConstraints[1].name() );
|
||||
assertEquals( 2, uniqueConstraints[1].columnNames().length );
|
||||
assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
|
||||
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
|
||||
|
||||
//Second, an association using join columns
|
||||
assertEquals( "association2", overrides[1].name() );
|
||||
|
||||
//JoinColumns
|
||||
joinColumns = overrides[1].joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col8", joinColumns[1].name() );
|
||||
assertEquals( "col9", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table4", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCollectionTableNoChildren() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm26.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( CollectionTable.class );
|
||||
CollectionTable tableAnno = reader.getAnnotation( CollectionTable.class );
|
||||
assertEquals( "", tableAnno.name() );
|
||||
assertEquals( "", tableAnno.catalog() );
|
||||
assertEquals( "", tableAnno.schema() );
|
||||
assertEquals( 0, tableAnno.joinColumns().length );
|
||||
assertEquals( 0, tableAnno.uniqueConstraints().length );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCollectionTableAllChildren() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "element-collection.orm27.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationPresent( CollectionTable.class );
|
||||
CollectionTable tableAnno = reader.getAnnotation( CollectionTable.class );
|
||||
assertEquals( "table1", tableAnno.name() );
|
||||
assertEquals( "catalog1", tableAnno.catalog() );
|
||||
assertEquals( "schema1", tableAnno.schema() );
|
||||
|
||||
//JoinColumns
|
||||
JoinColumn[] joinColumns = tableAnno.joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table2", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
|
||||
//UniqueConstraints
|
||||
UniqueConstraint[] uniqueConstraints = tableAnno.uniqueConstraints();
|
||||
assertEquals( 2, uniqueConstraints.length );
|
||||
assertEquals( "", uniqueConstraints[0].name() );
|
||||
assertEquals( 1, uniqueConstraints[0].columnNames().length );
|
||||
assertEquals( "col3", uniqueConstraints[0].columnNames()[0] );
|
||||
assertEquals( "uq1", uniqueConstraints[1].name() );
|
||||
assertEquals( 2, uniqueConstraints[1].columnNames().length );
|
||||
assertEquals( "col4", uniqueConstraints[1].columnNames()[0] );
|
||||
assertEquals( "col5", uniqueConstraints[1].columnNames()[1] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAllAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "element-collection.orm28.xml" );
|
||||
assertAnnotationPresent( ElementCollection.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( Column.class );
|
||||
assertAnnotationNotPresent( Temporal.class );
|
||||
assertAnnotationNotPresent( Enumerated.class );
|
||||
assertAnnotationNotPresent( Lob.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationNotPresent( AttributeOverrides.class );
|
||||
assertAnnotationNotPresent( AssociationOverride.class );
|
||||
assertAnnotationNotPresent( AssociationOverrides.class );
|
||||
assertAnnotationNotPresent( CollectionTable.class );
|
||||
assertAnnotationPresent( Access.class );
|
||||
ElementCollection relAnno = reader.getAnnotation( ElementCollection.class );
|
||||
assertEquals( FetchType.EAGER, relAnno.fetch() );
|
||||
assertEquals( Entity3.class, relAnno.targetClass() );
|
||||
assertEquals(
|
||||
AccessType.PROPERTY, reader.getAnnotation( Access.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,508 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import javax.persistence.Access;
|
||||
import javax.persistence.AccessType;
|
||||
import javax.persistence.AttributeOverride;
|
||||
import javax.persistence.AttributeOverrides;
|
||||
import javax.persistence.CascadeType;
|
||||
import javax.persistence.EnumType;
|
||||
import javax.persistence.FetchType;
|
||||
import javax.persistence.JoinColumn;
|
||||
import javax.persistence.JoinColumns;
|
||||
import javax.persistence.JoinTable;
|
||||
import javax.persistence.ManyToMany;
|
||||
import javax.persistence.MapKey;
|
||||
import javax.persistence.MapKeyClass;
|
||||
import javax.persistence.MapKeyColumn;
|
||||
import javax.persistence.MapKeyEnumerated;
|
||||
import javax.persistence.MapKeyJoinColumn;
|
||||
import javax.persistence.MapKeyJoinColumns;
|
||||
import javax.persistence.MapKeyTemporal;
|
||||
import javax.persistence.OrderBy;
|
||||
import javax.persistence.OrderColumn;
|
||||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlManyToManyTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
public class LegacyEjb3XmlManyToManyTest extends LegacyEjb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm1.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( Access.class );
|
||||
ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.LAZY, relAnno.fetch() );
|
||||
assertEquals( "", relAnno.mappedBy() );
|
||||
assertEquals( void.class, relAnno.targetEntity() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderBy() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm2.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertEquals(
|
||||
"col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm3.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationPresent( OrderColumn.class );
|
||||
OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
|
||||
assertEquals( "", orderColumnAnno.columnDefinition() );
|
||||
assertEquals( "", orderColumnAnno.name() );
|
||||
assertTrue( orderColumnAnno.insertable() );
|
||||
assertTrue( orderColumnAnno.nullable() );
|
||||
assertTrue( orderColumnAnno.updatable() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm4.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationPresent( OrderColumn.class );
|
||||
OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
|
||||
assertEquals( "int", orderColumnAnno.columnDefinition() );
|
||||
assertEquals( "col1", orderColumnAnno.name() );
|
||||
assertFalse( orderColumnAnno.insertable() );
|
||||
assertFalse( orderColumnAnno.nullable() );
|
||||
assertFalse( orderColumnAnno.updatable() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm5.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm6.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyClass() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm7.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
Entity2.class, reader.getAnnotation( MapKeyClass.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyTemporal() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm8.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
TemporalType.DATE, reader.getAnnotation(
|
||||
MapKeyTemporal.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyEnumerated() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm9.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
EnumType.STRING, reader.getAnnotation(
|
||||
MapKeyEnumerated.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single map key attribute override, we still wrap it with
|
||||
* an AttributeOverrides annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleMapKeyAttributeOverride() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm10.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 1, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "col1", overrides[0].column().name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleMapKeyAttributeOverrides() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm11.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 2, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "", overrides[0].column().name() );
|
||||
assertFalse( overrides[0].column().unique() );
|
||||
assertTrue( overrides[0].column().nullable() );
|
||||
assertTrue( overrides[0].column().insertable() );
|
||||
assertTrue( overrides[0].column().updatable() );
|
||||
assertEquals( "", overrides[0].column().columnDefinition() );
|
||||
assertEquals( "", overrides[0].column().table() );
|
||||
assertEquals( 255, overrides[0].column().length() );
|
||||
assertEquals( 0, overrides[0].column().precision() );
|
||||
assertEquals( 0, overrides[0].column().scale() );
|
||||
assertEquals( "field2", overrides[1].name() );
|
||||
assertEquals( "col1", overrides[1].column().name() );
|
||||
assertTrue( overrides[1].column().unique() );
|
||||
assertFalse( overrides[1].column().nullable() );
|
||||
assertFalse( overrides[1].column().insertable() );
|
||||
assertFalse( overrides[1].column().updatable() );
|
||||
assertEquals( "int", overrides[1].column().columnDefinition() );
|
||||
assertEquals( "table1", overrides[1].column().table() );
|
||||
assertEquals( 50, overrides[1].column().length() );
|
||||
assertEquals( 2, overrides[1].column().precision() );
|
||||
assertEquals( 1, overrides[1].column().scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm12.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
|
||||
assertEquals( "", keyColAnno.columnDefinition() );
|
||||
assertEquals( "", keyColAnno.name() );
|
||||
assertEquals( "", keyColAnno.table() );
|
||||
assertFalse( keyColAnno.nullable() );
|
||||
assertTrue( keyColAnno.insertable() );
|
||||
assertFalse( keyColAnno.unique() );
|
||||
assertTrue( keyColAnno.updatable() );
|
||||
assertEquals( 255, keyColAnno.length() );
|
||||
assertEquals( 0, keyColAnno.precision() );
|
||||
assertEquals( 0, keyColAnno.scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm13.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
|
||||
assertEquals( "int", keyColAnno.columnDefinition() );
|
||||
assertEquals( "col1", keyColAnno.name() );
|
||||
assertEquals( "table1", keyColAnno.table() );
|
||||
assertTrue( keyColAnno.nullable() );
|
||||
assertFalse( keyColAnno.insertable() );
|
||||
assertTrue( keyColAnno.unique() );
|
||||
assertFalse( keyColAnno.updatable() );
|
||||
assertEquals( 50, keyColAnno.length() );
|
||||
assertEquals( 2, keyColAnno.precision() );
|
||||
assertEquals( 1, keyColAnno.scale() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single map key join column, we still wrap it with a
|
||||
* MapKeyJoinColumns annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleMapKeyJoinColumn() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm14.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyJoinColumns joinColumnsAnno = reader
|
||||
.getAnnotation( MapKeyJoinColumns.class );
|
||||
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleMapKeyJoinColumns() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "many-to-many.orm15.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyJoinColumns joinColumnsAnno = reader
|
||||
.getAnnotation( MapKeyJoinColumns.class );
|
||||
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertFalse( joinColumns[0].nullable() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
assertTrue( joinColumns[1].nullable() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertEquals( "table1", joinColumns[1].table() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableNoChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm16.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "", joinTableAnno.catalog() );
|
||||
assertEquals( "", joinTableAnno.name() );
|
||||
assertEquals( "", joinTableAnno.schema() );
|
||||
assertEquals( 0, joinTableAnno.joinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.uniqueConstraints().length );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableAllChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm17.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "cat1", joinTableAnno.catalog() );
|
||||
assertEquals( "table1", joinTableAnno.name() );
|
||||
assertEquals( "schema1", joinTableAnno.schema() );
|
||||
|
||||
// JoinColumns
|
||||
JoinColumn[] joinColumns = joinTableAnno.joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table2", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
|
||||
// InverseJoinColumns
|
||||
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
|
||||
assertEquals( 2, inverseJoinColumns.length );
|
||||
assertEquals( "", inverseJoinColumns[0].name() );
|
||||
assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", inverseJoinColumns[0].table() );
|
||||
assertEquals( "", inverseJoinColumns[0].columnDefinition() );
|
||||
assertTrue( inverseJoinColumns[0].insertable() );
|
||||
assertTrue( inverseJoinColumns[0].updatable() );
|
||||
assertTrue( inverseJoinColumns[0].nullable() );
|
||||
assertFalse( inverseJoinColumns[0].unique() );
|
||||
assertEquals( "col3", inverseJoinColumns[1].name() );
|
||||
assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table3", inverseJoinColumns[1].table() );
|
||||
assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
|
||||
assertFalse( inverseJoinColumns[1].insertable() );
|
||||
assertFalse( inverseJoinColumns[1].updatable() );
|
||||
assertFalse( inverseJoinColumns[1].nullable() );
|
||||
assertTrue( inverseJoinColumns[1].unique() );
|
||||
|
||||
// UniqueConstraints
|
||||
UniqueConstraint[] uniqueConstraints = joinTableAnno
|
||||
.uniqueConstraints();
|
||||
assertEquals( 2, uniqueConstraints.length );
|
||||
assertEquals( "", uniqueConstraints[0].name() );
|
||||
assertEquals( 1, uniqueConstraints[0].columnNames().length );
|
||||
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
|
||||
assertEquals( "uq1", uniqueConstraints[1].name() );
|
||||
assertEquals( 2, uniqueConstraints[1].columnNames().length );
|
||||
assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
|
||||
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeAll() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm18.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
|
||||
assertEquals( 1, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeSomeWithDefaultPersist() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm19.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
|
||||
assertEquals( 4, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
|
||||
}
|
||||
|
||||
/**
|
||||
* Make sure that it doesn't break the handler when {@link CascadeType#ALL}
|
||||
* is specified in addition to a default cascade-persist or individual
|
||||
* cascade settings.
|
||||
*/
|
||||
@Test
|
||||
public void testCascadeAllPlusMore() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm20.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
|
||||
assertEquals( 6, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAllAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "many-to-many.orm21.xml" );
|
||||
assertAnnotationPresent( ManyToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationPresent( Access.class );
|
||||
ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.EAGER, relAnno.fetch() );
|
||||
assertEquals( "field2", relAnno.mappedBy() );
|
||||
assertEquals( Entity3.class, relAnno.targetEntity() );
|
||||
assertEquals(
|
||||
AccessType.PROPERTY, reader.getAnnotation( Access.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,245 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import javax.persistence.Access;
|
||||
import javax.persistence.AccessType;
|
||||
import javax.persistence.CascadeType;
|
||||
import javax.persistence.FetchType;
|
||||
import javax.persistence.Id;
|
||||
import javax.persistence.JoinColumn;
|
||||
import javax.persistence.JoinColumns;
|
||||
import javax.persistence.JoinTable;
|
||||
import javax.persistence.ManyToOne;
|
||||
import javax.persistence.MapsId;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlManyToOneTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
public class LegacyEjb3XmlManyToOneTest extends LegacyEjb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoJoins() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm1.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( Id.class );
|
||||
assertAnnotationNotPresent( MapsId.class );
|
||||
assertAnnotationNotPresent( Access.class );
|
||||
ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.EAGER, relAnno.fetch() );
|
||||
assertTrue( relAnno.optional() );
|
||||
assertEquals( void.class, relAnno.targetEntity() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single join column, we still wrap it with a JoinColumns
|
||||
* annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleJoinColumn() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm2.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
|
||||
JoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
assertEquals( "col2", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "table1", joinColumns[0].table() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleJoinColumns() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm3.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
|
||||
JoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table1", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableNoChildren() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm4.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "", joinTableAnno.catalog() );
|
||||
assertEquals( "", joinTableAnno.name() );
|
||||
assertEquals( "", joinTableAnno.schema() );
|
||||
assertEquals( 0, joinTableAnno.joinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.uniqueConstraints().length );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableAllChildren() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm5.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "cat1", joinTableAnno.catalog() );
|
||||
assertEquals( "table1", joinTableAnno.name() );
|
||||
assertEquals( "schema1", joinTableAnno.schema() );
|
||||
|
||||
// JoinColumns
|
||||
JoinColumn[] joinColumns = joinTableAnno.joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table2", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
|
||||
// InverseJoinColumns
|
||||
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
|
||||
assertEquals( 2, inverseJoinColumns.length );
|
||||
assertEquals( "", inverseJoinColumns[0].name() );
|
||||
assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", inverseJoinColumns[0].table() );
|
||||
assertEquals( "", inverseJoinColumns[0].columnDefinition() );
|
||||
assertTrue( inverseJoinColumns[0].insertable() );
|
||||
assertTrue( inverseJoinColumns[0].updatable() );
|
||||
assertTrue( inverseJoinColumns[0].nullable() );
|
||||
assertFalse( inverseJoinColumns[0].unique() );
|
||||
assertEquals( "col3", inverseJoinColumns[1].name() );
|
||||
assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table3", inverseJoinColumns[1].table() );
|
||||
assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
|
||||
assertFalse( inverseJoinColumns[1].insertable() );
|
||||
assertFalse( inverseJoinColumns[1].updatable() );
|
||||
assertFalse( inverseJoinColumns[1].nullable() );
|
||||
assertTrue( inverseJoinColumns[1].unique() );
|
||||
|
||||
// UniqueConstraints
|
||||
UniqueConstraint[] uniqueConstraints = joinTableAnno
|
||||
.uniqueConstraints();
|
||||
assertEquals( 2, uniqueConstraints.length );
|
||||
assertEquals( "", uniqueConstraints[0].name() );
|
||||
assertEquals( 1, uniqueConstraints[0].columnNames().length );
|
||||
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
|
||||
assertEquals( "uq1", uniqueConstraints[1].name() );
|
||||
assertEquals( 2, uniqueConstraints[1].columnNames().length );
|
||||
assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
|
||||
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAllAttributes() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm6.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationPresent( Id.class );
|
||||
assertAnnotationPresent( MapsId.class );
|
||||
assertAnnotationPresent( Access.class );
|
||||
ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.LAZY, relAnno.fetch() );
|
||||
assertFalse( relAnno.optional() );
|
||||
assertEquals( Entity3.class, relAnno.targetEntity() );
|
||||
assertEquals( "col1", reader.getAnnotation( MapsId.class ).value() );
|
||||
assertEquals(
|
||||
AccessType.PROPERTY, reader.getAnnotation( Access.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeAll() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm7.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
|
||||
assertEquals( 1, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeSomeWithDefaultPersist() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm8.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
|
||||
assertEquals( 4, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
|
||||
}
|
||||
|
||||
/**
|
||||
* Make sure that it doesn't break the handler when {@link CascadeType#ALL}
|
||||
* is specified in addition to a default cascade-persist or individual
|
||||
* cascade settings.
|
||||
*/
|
||||
@Test
|
||||
public void testCascadeAllPlusMore() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "many-to-one.orm9.xml" );
|
||||
assertAnnotationPresent( ManyToOne.class );
|
||||
ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
|
||||
assertEquals( 6, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,561 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import javax.persistence.Access;
|
||||
import javax.persistence.AccessType;
|
||||
import javax.persistence.AttributeOverride;
|
||||
import javax.persistence.AttributeOverrides;
|
||||
import javax.persistence.CascadeType;
|
||||
import javax.persistence.EnumType;
|
||||
import javax.persistence.FetchType;
|
||||
import javax.persistence.JoinColumn;
|
||||
import javax.persistence.JoinColumns;
|
||||
import javax.persistence.JoinTable;
|
||||
import javax.persistence.MapKey;
|
||||
import javax.persistence.MapKeyClass;
|
||||
import javax.persistence.MapKeyColumn;
|
||||
import javax.persistence.MapKeyEnumerated;
|
||||
import javax.persistence.MapKeyJoinColumn;
|
||||
import javax.persistence.MapKeyJoinColumns;
|
||||
import javax.persistence.MapKeyTemporal;
|
||||
import javax.persistence.OneToMany;
|
||||
import javax.persistence.OrderBy;
|
||||
import javax.persistence.OrderColumn;
|
||||
import javax.persistence.TemporalType;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlOneToManyTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
public class LegacyEjb3XmlOneToManyTest extends LegacyEjb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm1.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( Access.class );
|
||||
OneToMany relAnno = reader.getAnnotation( OneToMany.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.LAZY, relAnno.fetch() );
|
||||
assertEquals( "", relAnno.mappedBy() );
|
||||
assertFalse( relAnno.orphanRemoval() );
|
||||
assertEquals( void.class, relAnno.targetEntity() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderBy() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm2.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertEquals(
|
||||
"col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm3.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationPresent( OrderColumn.class );
|
||||
OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
|
||||
assertEquals( "", orderColumnAnno.columnDefinition() );
|
||||
assertEquals( "", orderColumnAnno.name() );
|
||||
assertTrue( orderColumnAnno.insertable() );
|
||||
assertTrue( orderColumnAnno.nullable() );
|
||||
assertTrue( orderColumnAnno.updatable() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOrderColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm4.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationPresent( OrderColumn.class );
|
||||
OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
|
||||
assertEquals( "int", orderColumnAnno.columnDefinition() );
|
||||
assertEquals( "col1", orderColumnAnno.name() );
|
||||
assertFalse( orderColumnAnno.insertable() );
|
||||
assertFalse( orderColumnAnno.nullable() );
|
||||
assertFalse( orderColumnAnno.updatable() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm5.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm6.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyClass() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm7.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
Entity2.class, reader.getAnnotation( MapKeyClass.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyTemporal() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm8.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
TemporalType.DATE, reader.getAnnotation(
|
||||
MapKeyTemporal.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyEnumerated() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm9.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertEquals(
|
||||
EnumType.STRING, reader.getAnnotation(
|
||||
MapKeyEnumerated.class
|
||||
).value()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single map key attribute override, we still wrap it with
|
||||
* an AttributeOverrides annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleMapKeyAttributeOverride() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm10.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 1, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "col1", overrides[0].column().name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleMapKeyAttributeOverrides() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm11.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( AttributeOverride.class );
|
||||
assertAnnotationPresent( AttributeOverrides.class );
|
||||
AttributeOverrides overridesAnno = reader
|
||||
.getAnnotation( AttributeOverrides.class );
|
||||
AttributeOverride[] overrides = overridesAnno.value();
|
||||
assertEquals( 2, overrides.length );
|
||||
assertEquals( "field1", overrides[0].name() );
|
||||
assertEquals( "", overrides[0].column().name() );
|
||||
assertFalse( overrides[0].column().unique() );
|
||||
assertTrue( overrides[0].column().nullable() );
|
||||
assertTrue( overrides[0].column().insertable() );
|
||||
assertTrue( overrides[0].column().updatable() );
|
||||
assertEquals( "", overrides[0].column().columnDefinition() );
|
||||
assertEquals( "", overrides[0].column().table() );
|
||||
assertEquals( 255, overrides[0].column().length() );
|
||||
assertEquals( 0, overrides[0].column().precision() );
|
||||
assertEquals( 0, overrides[0].column().scale() );
|
||||
assertEquals( "field2", overrides[1].name() );
|
||||
assertEquals( "col1", overrides[1].column().name() );
|
||||
assertTrue( overrides[1].column().unique() );
|
||||
assertFalse( overrides[1].column().nullable() );
|
||||
assertFalse( overrides[1].column().insertable() );
|
||||
assertFalse( overrides[1].column().updatable() );
|
||||
assertEquals( "int", overrides[1].column().columnDefinition() );
|
||||
assertEquals( "table1", overrides[1].column().table() );
|
||||
assertEquals( 50, overrides[1].column().length() );
|
||||
assertEquals( 2, overrides[1].column().precision() );
|
||||
assertEquals( 1, overrides[1].column().scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyColumnNoAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm12.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
|
||||
assertEquals( "", keyColAnno.columnDefinition() );
|
||||
assertEquals( "", keyColAnno.name() );
|
||||
assertEquals( "", keyColAnno.table() );
|
||||
assertFalse( keyColAnno.nullable() );
|
||||
assertTrue( keyColAnno.insertable() );
|
||||
assertFalse( keyColAnno.unique() );
|
||||
assertTrue( keyColAnno.updatable() );
|
||||
assertEquals( 255, keyColAnno.length() );
|
||||
assertEquals( 0, keyColAnno.precision() );
|
||||
assertEquals( 0, keyColAnno.scale() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMapKeyColumnAllAttributes() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm13.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
|
||||
assertEquals( "int", keyColAnno.columnDefinition() );
|
||||
assertEquals( "col1", keyColAnno.name() );
|
||||
assertEquals( "table1", keyColAnno.table() );
|
||||
assertTrue( keyColAnno.nullable() );
|
||||
assertFalse( keyColAnno.insertable() );
|
||||
assertTrue( keyColAnno.unique() );
|
||||
assertFalse( keyColAnno.updatable() );
|
||||
assertEquals( 50, keyColAnno.length() );
|
||||
assertEquals( 2, keyColAnno.precision() );
|
||||
assertEquals( 1, keyColAnno.scale() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single map key join column, we still wrap it with a
|
||||
* MapKeyJoinColumns annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleMapKeyJoinColumn() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm14.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyJoinColumns joinColumnsAnno = reader
|
||||
.getAnnotation( MapKeyJoinColumns.class );
|
||||
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleMapKeyJoinColumns() throws Exception {
|
||||
reader = getReader( Entity3.class, "field1", "one-to-many.orm15.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
MapKeyJoinColumns joinColumnsAnno = reader
|
||||
.getAnnotation( MapKeyJoinColumns.class );
|
||||
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertFalse( joinColumns[0].nullable() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
assertTrue( joinColumns[1].nullable() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertEquals( "table1", joinColumns[1].table() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableNoChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm16.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "", joinTableAnno.catalog() );
|
||||
assertEquals( "", joinTableAnno.name() );
|
||||
assertEquals( "", joinTableAnno.schema() );
|
||||
assertEquals( 0, joinTableAnno.joinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.uniqueConstraints().length );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableAllChildren() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm17.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "cat1", joinTableAnno.catalog() );
|
||||
assertEquals( "table1", joinTableAnno.name() );
|
||||
assertEquals( "schema1", joinTableAnno.schema() );
|
||||
|
||||
// JoinColumns
|
||||
JoinColumn[] joinColumns = joinTableAnno.joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table2", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
|
||||
// InverseJoinColumns
|
||||
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
|
||||
assertEquals( 2, inverseJoinColumns.length );
|
||||
assertEquals( "", inverseJoinColumns[0].name() );
|
||||
assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", inverseJoinColumns[0].table() );
|
||||
assertEquals( "", inverseJoinColumns[0].columnDefinition() );
|
||||
assertTrue( inverseJoinColumns[0].insertable() );
|
||||
assertTrue( inverseJoinColumns[0].updatable() );
|
||||
assertTrue( inverseJoinColumns[0].nullable() );
|
||||
assertFalse( inverseJoinColumns[0].unique() );
|
||||
assertEquals( "col3", inverseJoinColumns[1].name() );
|
||||
assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table3", inverseJoinColumns[1].table() );
|
||||
assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
|
||||
assertFalse( inverseJoinColumns[1].insertable() );
|
||||
assertFalse( inverseJoinColumns[1].updatable() );
|
||||
assertFalse( inverseJoinColumns[1].nullable() );
|
||||
assertTrue( inverseJoinColumns[1].unique() );
|
||||
|
||||
// UniqueConstraints
|
||||
UniqueConstraint[] uniqueConstraints = joinTableAnno
|
||||
.uniqueConstraints();
|
||||
assertEquals( 2, uniqueConstraints.length );
|
||||
assertEquals( "", uniqueConstraints[0].name() );
|
||||
assertEquals( 1, uniqueConstraints[0].columnNames().length );
|
||||
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
|
||||
assertEquals( "uq1", uniqueConstraints[1].name() );
|
||||
assertEquals( 2, uniqueConstraints[1].columnNames().length );
|
||||
assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
|
||||
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single join column, we still wrap it with a JoinColumns
|
||||
* annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleJoinColumn() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm18.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
|
||||
JoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
assertEquals( "col2", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "table1", joinColumns[0].table() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleJoinColumns() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm19.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
|
||||
JoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table1", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeAll() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm20.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
OneToMany relAnno = reader.getAnnotation( OneToMany.class );
|
||||
assertEquals( 1, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeSomeWithDefaultPersist() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm21.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
OneToMany relAnno = reader.getAnnotation( OneToMany.class );
|
||||
assertEquals( 4, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
|
||||
}
|
||||
|
||||
/**
|
||||
* Make sure that it doesn't break the handler when {@link CascadeType#ALL}
|
||||
* is specified in addition to a default cascade-persist or individual
|
||||
* cascade settings.
|
||||
*/
|
||||
@Test
|
||||
public void testCascadeAllPlusMore() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm22.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
OneToMany relAnno = reader.getAnnotation( OneToMany.class );
|
||||
assertEquals( 6, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAllAttributes() throws Exception {
|
||||
reader = getReader( Entity2.class, "field1", "one-to-many.orm23.xml" );
|
||||
assertAnnotationPresent( OneToMany.class );
|
||||
assertAnnotationNotPresent( OrderBy.class );
|
||||
assertAnnotationNotPresent( OrderColumn.class );
|
||||
assertAnnotationNotPresent( MapKey.class );
|
||||
assertAnnotationNotPresent( MapKeyClass.class );
|
||||
assertAnnotationNotPresent( MapKeyTemporal.class );
|
||||
assertAnnotationNotPresent( MapKeyEnumerated.class );
|
||||
assertAnnotationNotPresent( MapKeyColumn.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( MapKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationPresent( Access.class );
|
||||
OneToMany relAnno = reader.getAnnotation( OneToMany.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.EAGER, relAnno.fetch() );
|
||||
assertEquals( "field2", relAnno.mappedBy() );
|
||||
assertTrue( relAnno.orphanRemoval() );
|
||||
assertEquals( Entity3.class, relAnno.targetEntity() );
|
||||
assertEquals(
|
||||
AccessType.PROPERTY, reader.getAnnotation( Access.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,309 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import javax.persistence.Access;
|
||||
import javax.persistence.AccessType;
|
||||
import javax.persistence.CascadeType;
|
||||
import javax.persistence.FetchType;
|
||||
import javax.persistence.Id;
|
||||
import javax.persistence.JoinColumn;
|
||||
import javax.persistence.JoinColumns;
|
||||
import javax.persistence.JoinTable;
|
||||
import javax.persistence.MapsId;
|
||||
import javax.persistence.OneToOne;
|
||||
import javax.persistence.PrimaryKeyJoinColumn;
|
||||
import javax.persistence.PrimaryKeyJoinColumns;
|
||||
import javax.persistence.UniqueConstraint;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlOneToOneTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
public class LegacyEjb3XmlOneToOneTest extends LegacyEjb3XmlTestCase {
|
||||
@Test
|
||||
public void testNoChildren() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm1.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( MapsId.class );
|
||||
assertAnnotationNotPresent( Id.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( Access.class );
|
||||
OneToOne relAnno = reader.getAnnotation( OneToOne.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.EAGER, relAnno.fetch() );
|
||||
assertEquals( "", relAnno.mappedBy() );
|
||||
assertTrue( relAnno.optional() );
|
||||
assertFalse( relAnno.orphanRemoval() );
|
||||
assertEquals( void.class, relAnno.targetEntity() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single primary key join column, we still wrap it with
|
||||
* a PrimaryKeyJoinColumns annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSinglePrimaryKeyJoinColumn() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm2.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationPresent( PrimaryKeyJoinColumns.class );
|
||||
PrimaryKeyJoinColumns joinColumnsAnno =
|
||||
reader.getAnnotation( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
PrimaryKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
assertEquals( "col2", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "int", joinColumns[0].columnDefinition() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultiplePrimaryKeyJoinColumn() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm3.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
PrimaryKeyJoinColumns joinColumnsAnno =
|
||||
reader.getAnnotation( PrimaryKeyJoinColumns.class );
|
||||
PrimaryKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
}
|
||||
|
||||
/**
|
||||
* When there's a single join column, we still wrap it with a JoinColumns
|
||||
* annotation.
|
||||
*/
|
||||
@Test
|
||||
public void testSingleJoinColumn() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm4.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
|
||||
JoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 1, joinColumns.length );
|
||||
assertEquals( "col1", joinColumns[0].name() );
|
||||
assertEquals( "col2", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "table1", joinColumns[0].table() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleJoinColumns() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm5.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
|
||||
JoinColumn[] joinColumns = joinColumnsAnno.value();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table1", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableNoChildren() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm6.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "", joinTableAnno.catalog() );
|
||||
assertEquals( "", joinTableAnno.name() );
|
||||
assertEquals( "", joinTableAnno.schema() );
|
||||
assertEquals( 0, joinTableAnno.joinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
|
||||
assertEquals( 0, joinTableAnno.uniqueConstraints().length );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinTableAllChildren() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm7.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationPresent( JoinTable.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
|
||||
assertEquals( "cat1", joinTableAnno.catalog() );
|
||||
assertEquals( "table1", joinTableAnno.name() );
|
||||
assertEquals( "schema1", joinTableAnno.schema() );
|
||||
|
||||
// JoinColumns
|
||||
JoinColumn[] joinColumns = joinTableAnno.joinColumns();
|
||||
assertEquals( 2, joinColumns.length );
|
||||
assertEquals( "", joinColumns[0].name() );
|
||||
assertEquals( "", joinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", joinColumns[0].table() );
|
||||
assertEquals( "", joinColumns[0].columnDefinition() );
|
||||
assertTrue( joinColumns[0].insertable() );
|
||||
assertTrue( joinColumns[0].updatable() );
|
||||
assertTrue( joinColumns[0].nullable() );
|
||||
assertFalse( joinColumns[0].unique() );
|
||||
assertEquals( "col1", joinColumns[1].name() );
|
||||
assertEquals( "col2", joinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table2", joinColumns[1].table() );
|
||||
assertEquals( "int", joinColumns[1].columnDefinition() );
|
||||
assertFalse( joinColumns[1].insertable() );
|
||||
assertFalse( joinColumns[1].updatable() );
|
||||
assertFalse( joinColumns[1].nullable() );
|
||||
assertTrue( joinColumns[1].unique() );
|
||||
|
||||
// InverseJoinColumns
|
||||
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
|
||||
assertEquals( 2, inverseJoinColumns.length );
|
||||
assertEquals( "", inverseJoinColumns[0].name() );
|
||||
assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
|
||||
assertEquals( "", inverseJoinColumns[0].table() );
|
||||
assertEquals( "", inverseJoinColumns[0].columnDefinition() );
|
||||
assertTrue( inverseJoinColumns[0].insertable() );
|
||||
assertTrue( inverseJoinColumns[0].updatable() );
|
||||
assertTrue( inverseJoinColumns[0].nullable() );
|
||||
assertFalse( inverseJoinColumns[0].unique() );
|
||||
assertEquals( "col3", inverseJoinColumns[1].name() );
|
||||
assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
|
||||
assertEquals( "table3", inverseJoinColumns[1].table() );
|
||||
assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
|
||||
assertFalse( inverseJoinColumns[1].insertable() );
|
||||
assertFalse( inverseJoinColumns[1].updatable() );
|
||||
assertFalse( inverseJoinColumns[1].nullable() );
|
||||
assertTrue( inverseJoinColumns[1].unique() );
|
||||
|
||||
// UniqueConstraints
|
||||
UniqueConstraint[] uniqueConstraints = joinTableAnno
|
||||
.uniqueConstraints();
|
||||
assertEquals( 2, uniqueConstraints.length );
|
||||
assertEquals( "", uniqueConstraints[0].name() );
|
||||
assertEquals( 1, uniqueConstraints[0].columnNames().length );
|
||||
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
|
||||
assertEquals( "uq1", uniqueConstraints[1].name() );
|
||||
assertEquals( 2, uniqueConstraints[1].columnNames().length );
|
||||
assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
|
||||
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeAll() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm8.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
OneToOne relAnno = reader.getAnnotation( OneToOne.class );
|
||||
assertEquals( 1, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCascadeSomeWithDefaultPersist() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm9.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
OneToOne relAnno = reader.getAnnotation( OneToOne.class );
|
||||
assertEquals( 4, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
|
||||
}
|
||||
|
||||
/**
|
||||
* Make sure that it doesn't break the handler when {@link CascadeType#ALL}
|
||||
* is specified in addition to a default cascade-persist or individual
|
||||
* cascade settings.
|
||||
*/
|
||||
@Test
|
||||
public void testCascadeAllPlusMore() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm10.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
OneToOne relAnno = reader.getAnnotation( OneToOne.class );
|
||||
assertEquals( 6, relAnno.cascade().length );
|
||||
assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
|
||||
assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
|
||||
assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
|
||||
assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
|
||||
assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
|
||||
assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAllAttributes() throws Exception {
|
||||
reader = getReader( Entity1.class, "field1", "one-to-one.orm11.xml" );
|
||||
assertAnnotationPresent( OneToOne.class );
|
||||
assertAnnotationPresent( MapsId.class );
|
||||
assertAnnotationPresent( Id.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
|
||||
assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumns.class );
|
||||
assertAnnotationNotPresent( JoinColumn.class );
|
||||
assertAnnotationNotPresent( JoinTable.class );
|
||||
assertAnnotationPresent( Access.class );
|
||||
OneToOne relAnno = reader.getAnnotation( OneToOne.class );
|
||||
assertEquals( 0, relAnno.cascade().length );
|
||||
assertEquals( FetchType.LAZY, relAnno.fetch() );
|
||||
assertEquals( "field2", relAnno.mappedBy() );
|
||||
assertFalse( relAnno.optional() );
|
||||
assertTrue( relAnno.orphanRemoval() );
|
||||
assertEquals( Entity3.class, relAnno.targetEntity() );
|
||||
assertEquals(
|
||||
AccessType.PROPERTY, reader.getAnnotation( Access.class )
|
||||
.value()
|
||||
);
|
||||
assertEquals(
|
||||
"field3", reader.getAnnotation( MapsId.class )
|
||||
.value()
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
|
||||
import org.hibernate.Session;
|
||||
import org.hibernate.SessionFactory;
|
||||
import org.hibernate.Transaction;
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
import org.hibernate.dialect.CockroachDB192Dialect;
|
||||
import org.hibernate.dialect.PostgreSQL81Dialect;
|
||||
import org.hibernate.dialect.PostgreSQLDialect;
|
||||
import org.hibernate.dialect.TeradataDialect;
|
||||
import org.hibernate.persister.collection.BasicCollectionPersister;
|
||||
|
||||
import org.hibernate.testing.SkipForDialect;
|
||||
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
public class LegacyEjb3XmlTest extends BaseCoreFunctionalTestCase {
|
||||
@Test
|
||||
@SkipForDialect(value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class, CockroachDB192Dialect.class},
|
||||
comment = "postgresql jdbc driver does not implement the setQueryTimeout method")
|
||||
@SkipForDialect(value = TeradataDialect.class,
|
||||
jiraKey = "HHH-8190",
|
||||
comment = "uses Teradata reserved word - year")
|
||||
public void testEjb3Xml() throws Exception {
|
||||
Session s = openSession();
|
||||
Transaction tx = s.beginTransaction();
|
||||
CarModel model = new CarModel();
|
||||
model.setYear( new Date() );
|
||||
Manufacturer manufacturer = new Manufacturer();
|
||||
//s.persist( manufacturer );
|
||||
model.setManufacturer( manufacturer );
|
||||
manufacturer.getModels().add( model );
|
||||
s.persist( model );
|
||||
s.flush();
|
||||
s.clear();
|
||||
|
||||
model.setYear( new Date() );
|
||||
manufacturer = (Manufacturer) s.get( Manufacturer.class, manufacturer.getId() );
|
||||
@SuppressWarnings("unchecked")
|
||||
List<Model> cars = s.getNamedQuery( "allModelsPerManufacturer" )
|
||||
.setParameter( "manufacturer", manufacturer )
|
||||
.list();
|
||||
assertEquals( 1, cars.size() );
|
||||
for ( Model car : cars ) {
|
||||
assertNotNull( car.getManufacturer() );
|
||||
s.delete( manufacturer );
|
||||
s.delete( car );
|
||||
}
|
||||
tx.rollback();
|
||||
s.close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testXMLEntityHandled() throws Exception {
|
||||
Session s = openSession();
|
||||
s.getTransaction().begin();
|
||||
Lighter l = new Lighter();
|
||||
l.name = "Blue";
|
||||
l.power = "400F";
|
||||
s.persist( l );
|
||||
s.flush();
|
||||
s.getTransaction().rollback();
|
||||
s.close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testXmlDefaultOverriding() throws Exception {
|
||||
Session s = openSession();
|
||||
Transaction tx = s.beginTransaction();
|
||||
Manufacturer manufacturer = new Manufacturer();
|
||||
s.persist( manufacturer );
|
||||
s.flush();
|
||||
s.clear();
|
||||
|
||||
assertEquals( 1, s.getNamedQuery( "manufacturer.findAll" ).list().size() );
|
||||
tx.rollback();
|
||||
s.close();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void testMapXMLSupport() throws Exception {
|
||||
Session s = openSession();
|
||||
SessionFactory sf = s.getSessionFactory();
|
||||
Transaction tx = s.beginTransaction();
|
||||
|
||||
// Verify that we can persist an object with a couple Map mappings
|
||||
VicePresident vpSales = new VicePresident();
|
||||
vpSales.name = "Dwight";
|
||||
Company company = new Company();
|
||||
company.conferenceRoomExtensions.put( "8932", "x1234" );
|
||||
company.organization.put( "sales", vpSales );
|
||||
s.persist( company );
|
||||
s.flush();
|
||||
s.clear();
|
||||
|
||||
// For the element-collection, check that the orm.xml entries are honored.
|
||||
// This includes: map-key-column/column/collection-table/join-column
|
||||
BasicCollectionPersister confRoomMeta = (BasicCollectionPersister) sf.getCollectionMetadata( Company.class.getName() + ".conferenceRoomExtensions" );
|
||||
assertEquals( "company_id", confRoomMeta.getKeyColumnNames()[0] );
|
||||
assertEquals( "phone_extension", confRoomMeta.getElementColumnNames()[0] );
|
||||
assertEquals( "room_number", confRoomMeta.getIndexColumnNames()[0] );
|
||||
assertEquals( "phone_extension_lookup", confRoomMeta.getTableName() );
|
||||
tx.rollback();
|
||||
s.close();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected Class[] getAnnotatedClasses() {
|
||||
return new Class[] {
|
||||
CarModel.class,
|
||||
Manufacturer.class,
|
||||
Model.class,
|
||||
Light.class
|
||||
//Lighter.class xml only entuty
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String[] getXmlFiles() {
|
||||
return new String[] {
|
||||
"org/hibernate/test/annotations/xml/ejb3/orm.xml",
|
||||
"org/hibernate/test/annotations/xml/ejb3/orm2.xml",
|
||||
"org/hibernate/test/annotations/xml/ejb3/orm3.xml",
|
||||
"org/hibernate/test/annotations/xml/ejb3/orm4.xml"
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.AnnotatedElement;
|
||||
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
import org.hibernate.cfg.annotations.reflection.XMLContext;
|
||||
|
||||
import org.hibernate.testing.boot.BootstrapContextImpl;
|
||||
import org.hibernate.testing.junit4.BaseUnitTestCase;
|
||||
|
||||
import org.dom4j.Document;
|
||||
import org.dom4j.io.SAXReader;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Test superclass to provide utility methods for testing the mapping of JPA
|
||||
* XML to JPA annotations. The configuration is built within each test, and no
|
||||
* database is used. Thus, no schema generation or cleanup will be performed.
|
||||
* <p>
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@Deprecated
|
||||
abstract class LegacyEjb3XmlTestCase extends BaseUnitTestCase {
|
||||
protected JPAOverriddenAnnotationReader reader;
|
||||
|
||||
protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) {
|
||||
assertTrue(
|
||||
"Expected annotation " + annotationType.getSimpleName() + " was not present",
|
||||
reader.isAnnotationPresent( annotationType )
|
||||
);
|
||||
}
|
||||
|
||||
protected void assertAnnotationNotPresent(Class<? extends Annotation> annotationType) {
|
||||
assertFalse(
|
||||
"Unexpected annotation " + annotationType.getSimpleName() + " was present",
|
||||
reader.isAnnotationPresent( annotationType )
|
||||
);
|
||||
}
|
||||
|
||||
protected JPAOverriddenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
|
||||
throws Exception {
|
||||
AnnotatedElement el = getAnnotatedElement( entityClass, fieldName );
|
||||
XMLContext xmlContext = getContext( ormResourceName );
|
||||
return new JPAOverriddenAnnotationReader( el, xmlContext, BootstrapContextImpl.INSTANCE );
|
||||
}
|
||||
|
||||
protected AnnotatedElement getAnnotatedElement(Class<?> entityClass, String fieldName) throws Exception {
|
||||
return entityClass.getDeclaredField( fieldName );
|
||||
}
|
||||
|
||||
protected XMLContext getContext(String resourceName) throws Exception {
|
||||
InputStream is = getClass().getResourceAsStream( resourceName );
|
||||
assertNotNull( "Could not load resource " + resourceName, is );
|
||||
return getContext( is );
|
||||
}
|
||||
|
||||
protected XMLContext getContext(InputStream is) throws Exception {
|
||||
XMLContext xmlContext = new XMLContext( BootstrapContextImpl.INSTANCE );
|
||||
SAXReader reader = new SAXReader();
|
||||
reader.setFeature( "http://apache.org/xml/features/nonvalidating/load-external-dtd", false );
|
||||
reader.setFeature( "http://xml.org/sax/features/external-general-entities", false );
|
||||
reader.setFeature( "http://xml.org/sax/features/external-parameter-entities", false );
|
||||
Document doc = reader.read( is );
|
||||
xmlContext.addDocument( doc );
|
||||
return xmlContext;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import org.hibernate.InvalidMappingException;
|
||||
import org.hibernate.boot.MetadataSources;
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
import org.hibernate.internal.util.xml.UnsupportedOrmXsdVersionException;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.junit4.BaseUnitTestCase;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.NonExistentOrmVersionTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@TestForIssue(jiraKey = "HHH-6271")
|
||||
public class LegacyNonExistentOrmVersionTest extends BaseUnitTestCase {
|
||||
@Test
|
||||
public void testNonExistentOrmVersion() {
|
||||
try {
|
||||
new MetadataSources()
|
||||
.addResource( "org/hibernate/test/annotations/xml/ejb3/orm5.xml" )
|
||||
.buildMetadata();
|
||||
fail( "Expecting failure due to unsupported xsd version" );
|
||||
}
|
||||
catch ( InvalidMappingException expected ) {
|
||||
}
|
||||
catch ( UnsupportedOrmXsdVersionException expected ) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import org.hibernate.Session;
|
||||
import org.hibernate.Transaction;
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
import org.hibernate.internal.CoreMessageLogger;
|
||||
import org.hibernate.internal.util.xml.ErrorLogger;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
|
||||
import org.hibernate.testing.logger.LoggerInspectionRule;
|
||||
import org.hibernate.testing.logger.Triggerable;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.jboss.logging.Logger;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.OrmVersion1SupportedTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@TestForIssue(jiraKey = "HHH-6271")
|
||||
public class LegacyOrmVersion1SupportedTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Rule
|
||||
public LoggerInspectionRule logInspection = new LoggerInspectionRule(
|
||||
Logger.getMessageLogger(
|
||||
CoreMessageLogger.class,
|
||||
ErrorLogger.class.getName()
|
||||
)
|
||||
);
|
||||
|
||||
@Test
|
||||
public void testOrm1Support() {
|
||||
Triggerable triggerable = logInspection.watchForLogMessages( "HHH00196" );
|
||||
|
||||
Session s = openSession();
|
||||
Transaction tx = s.beginTransaction();
|
||||
Light light = new Light();
|
||||
light.name = "the light at the end of the tunnel";
|
||||
s.persist( light );
|
||||
s.flush();
|
||||
s.clear();
|
||||
|
||||
assertEquals( 1, s.getNamedQuery( "find.the.light" ).list().size() );
|
||||
tx.rollback();
|
||||
s.close();
|
||||
|
||||
assertFalse( triggerable.wasTriggered() );
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String[] getXmlFiles() {
|
||||
return new String[] { "org/hibernate/test/annotations/xml/ejb3/orm2.xml" };
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
/*
|
||||
* Hibernate, Relational Persistence for Idiomatic Java
|
||||
*
|
||||
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||||
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||||
*/
|
||||
package org.hibernate.test.annotations.xml.ejb3;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.UncheckedIOException;
|
||||
|
||||
import org.hibernate.boot.jaxb.spi.Binding;
|
||||
import org.hibernate.cfg.Configuration;
|
||||
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
|
||||
import org.hibernate.test.annotations.xml.ejb3.PreParsedOrmXmlTest.NonAnnotatedEntity;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
/**
|
||||
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.PreParsedOrmXmlTest}
|
||||
* for the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*
|
||||
* @author Emmanuel Bernard
|
||||
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
|
||||
*/
|
||||
@TestForIssue(jiraKey = "HHH-14530")
|
||||
public class LegacyPreParsedOrmXmlTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Override
|
||||
protected void addMappings(Configuration configuration) {
|
||||
super.addMappings( configuration );
|
||||
try (InputStream xmlStream = Thread.currentThread().getContextClassLoader()
|
||||
.getResourceAsStream( "org/hibernate/test/annotations/xml/ejb3/pre-parsed-orm.xml" )) {
|
||||
Binding<?> parsed = configuration.getXmlMappingBinderAccess().bind( xmlStream );
|
||||
configuration.addXmlMapping( parsed );
|
||||
}
|
||||
catch (IOException e) {
|
||||
throw new UncheckedIOException( e );
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPreParsedOrmXml() {
|
||||
// Just check that the entity can be persisted, which means the mapping file was taken into account
|
||||
NonAnnotatedEntity persistedEntity = new NonAnnotatedEntity( "someName" );
|
||||
inTransaction( s -> s.persist( persistedEntity ) );
|
||||
inTransaction( s -> {
|
||||
NonAnnotatedEntity retrievedEntity = s.find( NonAnnotatedEntity.class, persistedEntity.getId() );
|
||||
assertThat( retrievedEntity ).extracting( NonAnnotatedEntity::getName )
|
||||
.isEqualTo( persistedEntity.getName() );
|
||||
} );
|
||||
}
|
||||
}
|
||||
|
|
@ -8,6 +8,7 @@ package org.hibernate.test.annotations.xml.ejb3;
|
|||
|
||||
import org.hibernate.InvalidMappingException;
|
||||
import org.hibernate.boot.MetadataSources;
|
||||
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
|
||||
import org.hibernate.internal.util.xml.UnsupportedOrmXsdVersionException;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
|
|
@ -16,12 +17,13 @@ import org.junit.Test;
|
|||
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-6271")
|
||||
@TestForIssue(jiraKey = {"HHH-6271", "HHH-14529"})
|
||||
public class NonExistentOrmVersionTest extends BaseUnitTestCase {
|
||||
@Test
|
||||
public void testNonExistentOrmVersion() {
|
||||
// FIXME HHH-14529 configure the BootstrapServiceRegistry to use JAXB for orm.xml mappings
|
||||
try {
|
||||
new MetadataSources()
|
||||
new MetadataSources( new BootstrapServiceRegistryBuilder().build() )
|
||||
.addResource( "org/hibernate/test/annotations/xml/ejb3/orm5.xml" )
|
||||
.buildMetadata();
|
||||
fail( "Expecting failure due to unsupported xsd version" );
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ package org.hibernate.test.annotations.xml.ejb3;
|
|||
|
||||
import org.hibernate.Session;
|
||||
import org.hibernate.Transaction;
|
||||
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
|
||||
import org.hibernate.internal.CoreMessageLogger;
|
||||
import org.hibernate.internal.util.xml.ErrorLogger;
|
||||
|
||||
|
|
@ -23,9 +24,15 @@ import org.jboss.logging.Logger;
|
|||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-6271")
|
||||
@TestForIssue(jiraKey = {"HHH-6271", "HHH-14529"})
|
||||
public class OrmVersion1SupportedTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Override
|
||||
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
|
||||
// FIXME HHH-14529 configure the BootstrapServiceRegistry to use JAXB for orm.xml mappings
|
||||
super.prepareBootstrapRegistryBuilder( builder );
|
||||
}
|
||||
|
||||
@Rule
|
||||
public LoggerInspectionRule logInspection = new LoggerInspectionRule(
|
||||
Logger.getMessageLogger(
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ import java.io.InputStream;
|
|||
import java.io.UncheckedIOException;
|
||||
|
||||
import org.hibernate.boot.jaxb.spi.Binding;
|
||||
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
|
||||
import org.hibernate.cfg.Configuration;
|
||||
|
||||
import org.hibernate.testing.TestForIssue;
|
||||
|
|
@ -19,9 +20,15 @@ import org.junit.Test;
|
|||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
@TestForIssue(jiraKey = "HHH-14530")
|
||||
@TestForIssue(jiraKey = {"HHH-14530", "HHH-14529"})
|
||||
public class PreParsedOrmXmlTest extends BaseCoreFunctionalTestCase {
|
||||
|
||||
@Override
|
||||
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
|
||||
// FIXME HHH-14529 configure the BootstrapServiceRegistry to use JAXB for orm.xml mappings
|
||||
super.prepareBootstrapRegistryBuilder( builder );
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void addMappings(Configuration configuration) {
|
||||
super.addMappings( configuration );
|
||||
|
|
|
|||
Loading…
Reference in New Issue