From f1ab0a0315167865818c05fed92b1c9b8963af4e Mon Sep 17 00:00:00 2001 From: Dancovich Date: Fri, 5 Oct 2012 17:42:08 -0300 Subject: [PATCH] Aumentando cobertura de testes. --- impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxy.java | 25 +++++++++++++++++-------- impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxy.java | 179 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxy.java | 179 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/QueryProxy.java | 213 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/TypedQueryProxy.java | 181 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/domain/Client.java | 19 +++++++++++++++++++ impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxyTest.java | 34 +++++++++++++++++++++++++--------- impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxyTest.java | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxyTest.java | 245 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/template/JPACrudTest.java | 28 ++++++++++++++++++++++++++++ 10 files changed, 839 insertions(+), 378 deletions(-) delete mode 100644 impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxy.java delete mode 100644 impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxy.java create mode 100644 impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/QueryProxy.java create mode 100644 impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/TypedQueryProxy.java create mode 100644 impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxyTest.java diff --git a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxy.java b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxy.java index e2429f4..977d836 100644 --- a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxy.java +++ b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxy.java @@ -317,7 +317,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public Query createQuery(String qlString) { - return new QueryProxy(getEntityManagerDelegate().createQuery(qlString) , this) ; + joinTransactionIfNecessary(); + return /*new QueryProxy(*/getEntityManagerDelegate().createQuery(qlString)/* , this)*/ ; } /* @@ -326,7 +327,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public TypedQuery createQuery(CriteriaQuery criteriaQuery) { - return new TypedQueryProxy( getEntityManagerDelegate().createQuery(criteriaQuery) , this ); + joinTransactionIfNecessary(); + return /*new TypedQueryProxy(*/ getEntityManagerDelegate().createQuery(criteriaQuery) /*, this )*/; } /* @@ -335,7 +337,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public TypedQuery createQuery(String qlString, Class resultClass) { - return new TypedQueryProxy(getEntityManagerDelegate().createQuery(qlString, resultClass),this); + joinTransactionIfNecessary(); + return /*new TypedQueryProxy(*/getEntityManagerDelegate().createQuery(qlString, resultClass)/*,this)*/; } /* @@ -344,7 +347,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public Query createNamedQuery(String name) { - return new QueryProxy(getEntityManagerDelegate().createNamedQuery(name), this); + joinTransactionIfNecessary(); + return /*new QueryProxy(*/getEntityManagerDelegate().createNamedQuery(name)/*, this)*/; } /* @@ -353,6 +357,7 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public TypedQuery createNamedQuery(String name, Class resultClass) { + joinTransactionIfNecessary(); return getEntityManagerDelegate().createNamedQuery(name, resultClass); } @@ -362,7 +367,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public Query createNativeQuery(String sqlString) { - return new QueryProxy(getEntityManagerDelegate().createNativeQuery(sqlString), this); + joinTransactionIfNecessary(); + return /*new QueryProxy(*/getEntityManagerDelegate().createNativeQuery(sqlString)/*, this)*/; } /* @@ -371,7 +377,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public Query createNativeQuery(String sqlString, @SuppressWarnings("rawtypes") Class resultClass) { - return new QueryProxy(getEntityManagerDelegate().createNativeQuery(sqlString, resultClass), this); + joinTransactionIfNecessary(); + return /*new QueryProxy(*/getEntityManagerDelegate().createNativeQuery(sqlString, resultClass)/*, this)*/; } /* @@ -380,7 +387,8 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public Query createNativeQuery(String sqlString, String resultSetMapping) { - return new QueryProxy(getEntityManagerDelegate().createNativeQuery(sqlString, resultSetMapping),this); + joinTransactionIfNecessary(); + return /*new QueryProxy(*/getEntityManagerDelegate().createNativeQuery(sqlString, resultSetMapping)/*,this)*/; } /* @@ -395,7 +403,7 @@ public class EntityManagerProxy implements EntityManager, Serializable { /** * Attemp to join transaction, if the active transaction is not managed by current EntityManager. */ - protected final void joinTransactionIfNecessary() { + public final void joinTransactionIfNecessary() { try { getEntityManagerDelegate().getTransaction(); } catch (IllegalStateException cause) { @@ -472,6 +480,7 @@ public class EntityManagerProxy implements EntityManager, Serializable { */ @Override public CriteriaBuilder getCriteriaBuilder() { + joinTransactionIfNecessary(); return getEntityManagerDelegate().getCriteriaBuilder(); } diff --git a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxy.java b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxy.java deleted file mode 100644 index 07b0bd3..0000000 --- a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxy.java +++ /dev/null @@ -1,179 +0,0 @@ -package br.gov.frameworkdemoiselle.internal.proxy; - -import java.util.Calendar; -import java.util.Date; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import javax.persistence.FlushModeType; -import javax.persistence.LockModeType; -import javax.persistence.Parameter; -import javax.persistence.Query; -import javax.persistence.TemporalType; - -public class QueryProxy implements Query { - - private Query queryDelegate; - private EntityManagerProxy entityManagerCaller; - - public QueryProxy(Query queryDelegate,EntityManagerProxy entityManagerCaller){ - this.queryDelegate = queryDelegate; - this.entityManagerCaller = entityManagerCaller; - } - - @SuppressWarnings("rawtypes") - public List getResultList() { - entityManagerCaller.joinTransactionIfNecessary(); - return queryDelegate.getResultList(); - } - - public Object getSingleResult() { - entityManagerCaller.joinTransactionIfNecessary(); - return queryDelegate.getSingleResult(); - } - - public int executeUpdate() { - entityManagerCaller.joinTransactionIfNecessary(); - return queryDelegate.executeUpdate(); - } - - public Query setMaxResults(int maxResult) { - queryDelegate.setMaxResults(maxResult); - return this; - } - - public int getMaxResults() { - return queryDelegate.getMaxResults(); - } - - public Query setFirstResult(int startPosition) { - queryDelegate.setFirstResult(startPosition); - return this; - } - - public int getFirstResult() { - return queryDelegate.getFirstResult(); - } - - public Query setHint(String hintName, Object value) { - queryDelegate.setHint(hintName, value); - return this; - } - - public Map getHints() { - return queryDelegate.getHints(); - } - - public Query setParameter(Parameter param, T value) { - queryDelegate.setParameter(param, value); - return this; - } - - public Query setParameter(Parameter param, Calendar value, - TemporalType temporalType) { - queryDelegate.setParameter(param, value, temporalType); - return this; - } - - public Query setParameter(Parameter param, Date value, - TemporalType temporalType) { - queryDelegate.setParameter(param, value, temporalType); - return this; - } - - public Query setParameter(String name, Object value) { - queryDelegate.setParameter(name, value); - return this; - } - - public Query setParameter(String name, Calendar value, - TemporalType temporalType) { - queryDelegate.setParameter(name, value, temporalType); - return this; - } - - public Query setParameter(String name, Date value, TemporalType temporalType) { - queryDelegate.setParameter(name, value, temporalType); - return this; - } - - public Query setParameter(int position, Object value) { - queryDelegate.setParameter(position, value); - return this; - } - - public Query setParameter(int position, Calendar value, - TemporalType temporalType) { - queryDelegate.setParameter(position, value, temporalType); - return this; - } - - public Query setParameter(int position, Date value, - TemporalType temporalType) { - queryDelegate.setParameter(position, value, temporalType); - return this; - } - - public Set> getParameters() { - return queryDelegate.getParameters(); - } - - public Parameter getParameter(String name) { - return queryDelegate.getParameter(name); - } - - public Parameter getParameter(String name, Class type) { - return queryDelegate.getParameter(name, type); - } - - public Parameter getParameter(int position) { - return queryDelegate.getParameter(position); - } - - public Parameter getParameter(int position, Class type) { - return queryDelegate.getParameter(position, type); - } - - public boolean isBound(Parameter param) { - return queryDelegate.isBound(param); - } - - public T getParameterValue(Parameter param) { - return queryDelegate.getParameterValue(param); - } - - public Object getParameterValue(String name) { - return queryDelegate.getParameterValue(name); - } - - public Object getParameterValue(int position) { - return queryDelegate.getParameterValue(position); - } - - public Query setFlushMode(FlushModeType flushMode) { - queryDelegate.setFlushMode(flushMode); - return this; - } - - public FlushModeType getFlushMode() { - return queryDelegate.getFlushMode(); - } - - public Query setLockMode(LockModeType lockMode) { - entityManagerCaller.joinTransactionIfNecessary(); - queryDelegate.setLockMode(lockMode); - return this; - } - - public LockModeType getLockMode() { - return queryDelegate.getLockMode(); - } - - public T unwrap(Class cls) { - return queryDelegate.unwrap(cls); - } - - - -} diff --git a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxy.java b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxy.java deleted file mode 100644 index 11e4a51..0000000 --- a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxy.java +++ /dev/null @@ -1,179 +0,0 @@ -package br.gov.frameworkdemoiselle.internal.proxy; - -import java.util.Calendar; -import java.util.Date; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import javax.persistence.FlushModeType; -import javax.persistence.LockModeType; -import javax.persistence.Parameter; -import javax.persistence.TemporalType; -import javax.persistence.TypedQuery; - -public class TypedQueryProxy implements TypedQuery { - - private TypedQuery queryDelegate; - private EntityManagerProxy entityManagerCaller; - - public TypedQueryProxy(TypedQuery queryDelegate, - EntityManagerProxy entityManagerCaller) { - this.queryDelegate = queryDelegate; - this.entityManagerCaller = entityManagerCaller; - } - - public List getResultList() { - entityManagerCaller.joinTransactionIfNecessary(); - return queryDelegate.getResultList(); - } - - public X getSingleResult() { - entityManagerCaller.joinTransactionIfNecessary(); - return queryDelegate.getSingleResult(); - } - - public int executeUpdate() { - entityManagerCaller.joinTransactionIfNecessary(); - return queryDelegate.executeUpdate(); - } - - public TypedQuery setMaxResults(int maxResult) { - queryDelegate.setMaxResults(maxResult); - return this; - } - - public TypedQuery setFirstResult(int startPosition) { - queryDelegate.setFirstResult(startPosition); - return this; - } - - public TypedQuery setHint(String hintName, Object value) { - queryDelegate.setHint(hintName, value); - return this; - } - - public int getMaxResults() { - return queryDelegate.getMaxResults(); - } - - public TypedQuery setParameter(Parameter param, T value) { - queryDelegate.setParameter(param, value); - return this; - } - - public int getFirstResult() { - return queryDelegate.getFirstResult(); - } - - public TypedQuery setParameter(Parameter param, - Calendar value, TemporalType temporalType) { - queryDelegate.setParameter(param, value, temporalType); - return this; - } - - public TypedQuery setParameter(Parameter param, Date value, - TemporalType temporalType) { - queryDelegate.setParameter(param, value, temporalType); - return this; - } - - public Map getHints() { - return queryDelegate.getHints(); - } - - public TypedQuery setParameter(String name, Object value) { - queryDelegate.setParameter(name, value); - return this; - } - - public TypedQuery setParameter(String name, Calendar value, - TemporalType temporalType) { - queryDelegate.setParameter(name, value, temporalType); - return this; - } - - public TypedQuery setParameter(String name, Date value, - TemporalType temporalType) { - queryDelegate.setParameter(name, value, temporalType); - return this; - } - - public TypedQuery setParameter(int position, Object value) { - queryDelegate.setParameter(position, value); - return this; - } - - public TypedQuery setParameter(int position, Calendar value, - TemporalType temporalType) { - queryDelegate.setParameter(position, value, temporalType); - return this; - } - - public TypedQuery setParameter(int position, Date value, - TemporalType temporalType) { - queryDelegate.setParameter(position, value, temporalType); - return this; - } - - public TypedQuery setFlushMode(FlushModeType flushMode) { - queryDelegate.setFlushMode(flushMode); - return this; - } - - public TypedQuery setLockMode(LockModeType lockMode) { - queryDelegate.setLockMode(lockMode); - return this; - } - - public Set> getParameters() { - return queryDelegate.getParameters(); - } - - public Parameter getParameter(String name) { - return queryDelegate.getParameter(name); - } - - public Parameter getParameter(String name, Class type) { - return queryDelegate.getParameter(name, type); - } - - public Parameter getParameter(int position) { - return queryDelegate.getParameter(position); - } - - public Parameter getParameter(int position, Class type) { - return queryDelegate.getParameter(position, type); - } - - public boolean isBound(Parameter param) { - return queryDelegate.isBound(param); - } - - public T getParameterValue(Parameter param) { - return queryDelegate.getParameterValue(param); - } - - public Object getParameterValue(String name) { - return queryDelegate.getParameterValue(name); - } - - public Object getParameterValue(int position) { - return queryDelegate.getParameterValue(position); - } - - public FlushModeType getFlushMode() { - return queryDelegate.getFlushMode(); - } - - public LockModeType getLockMode() { - return queryDelegate.getLockMode(); - } - - public T unwrap(Class cls) { - return queryDelegate.unwrap(cls); - } - - - -} diff --git a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/QueryProxy.java b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/QueryProxy.java new file mode 100644 index 0000000..f7b6138 --- /dev/null +++ b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/QueryProxy.java @@ -0,0 +1,213 @@ +package br.gov.frameworkdemoiselle.internal.proxy.query; + +import java.util.Calendar; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.persistence.FlushModeType; +import javax.persistence.LockModeType; +import javax.persistence.Parameter; +import javax.persistence.Query; +import javax.persistence.TemporalType; + +import br.gov.frameworkdemoiselle.internal.proxy.EntityManagerProxy; + +public class QueryProxy implements Query { + + private Query queryDelegate; + private EntityManagerProxy entityManagerCaller; + + public QueryProxy(Query queryDelegate,EntityManagerProxy entityManagerCaller){ + this.queryDelegate = queryDelegate; + this.entityManagerCaller = entityManagerCaller; + } + + @SuppressWarnings("rawtypes") + public List getResultList() { + entityManagerCaller.joinTransactionIfNecessary(); + return queryDelegate.getResultList(); + } + + /** + * @see Query.getSingleResult() + */ + @Override + public Object getSingleResult() { + entityManagerCaller.joinTransactionIfNecessary(); + return queryDelegate.getSingleResult(); + } + + @Override + public int executeUpdate() { + entityManagerCaller.joinTransactionIfNecessary(); + return queryDelegate.executeUpdate(); + } + + @Override + public Query setMaxResults(int maxResult) { + queryDelegate.setMaxResults(maxResult); + return this; + } + + @Override + public int getMaxResults() { + return queryDelegate.getMaxResults(); + } + + @Override + public Query setFirstResult(int startPosition) { + queryDelegate.setFirstResult(startPosition); + return this; + } + + @Override + public int getFirstResult() { + return queryDelegate.getFirstResult(); + } + + @Override + public Query setHint(String hintName, Object value) { + queryDelegate.setHint(hintName, value); + return this; + } + + @Override + public Map getHints() { + return queryDelegate.getHints(); + } + + @Override + public Query setParameter(Parameter param, T value) { + queryDelegate.setParameter(param, value); + return this; + } + + @Override + public Query setParameter(Parameter param, Calendar value, + TemporalType temporalType) { + queryDelegate.setParameter(param, value, temporalType); + return this; + } + + @Override + public Query setParameter(Parameter param, Date value, + TemporalType temporalType) { + queryDelegate.setParameter(param, value, temporalType); + return this; + } + + @Override + public Query setParameter(String name, Object value) { + queryDelegate.setParameter(name, value); + return this; + } + + @Override + public Query setParameter(String name, Calendar value, + TemporalType temporalType) { + queryDelegate.setParameter(name, value, temporalType); + return this; + } + + @Override + public Query setParameter(String name, Date value, TemporalType temporalType) { + queryDelegate.setParameter(name, value, temporalType); + return this; + } + + @Override + public Query setParameter(int position, Object value) { + queryDelegate.setParameter(position, value); + return this; + } + + @Override + public Query setParameter(int position, Calendar value, + TemporalType temporalType) { + queryDelegate.setParameter(position, value, temporalType); + return this; + } + + @Override + public Query setParameter(int position, Date value, + TemporalType temporalType) { + queryDelegate.setParameter(position, value, temporalType); + return this; + } + + @Override + public Set> getParameters() { + return queryDelegate.getParameters(); + } + + @Override + public Parameter getParameter(String name) { + return queryDelegate.getParameter(name); + } + + @Override + public Parameter getParameter(String name, Class type) { + return queryDelegate.getParameter(name, type); + } + + @Override + public Parameter getParameter(int position) { + return queryDelegate.getParameter(position); + } + + @Override + public Parameter getParameter(int position, Class type) { + return queryDelegate.getParameter(position, type); + } + + @Override + public boolean isBound(Parameter param) { + return queryDelegate.isBound(param); + } + + @Override + public T getParameterValue(Parameter param) { + return queryDelegate.getParameterValue(param); + } + + @Override + public Object getParameterValue(String name) { + return queryDelegate.getParameterValue(name); + } + + @Override + public Object getParameterValue(int position) { + return queryDelegate.getParameterValue(position); + } + + @Override + public Query setFlushMode(FlushModeType flushMode) { + queryDelegate.setFlushMode(flushMode); + return this; + } + + @Override + public FlushModeType getFlushMode() { + return queryDelegate.getFlushMode(); + } + + @Override + public Query setLockMode(LockModeType lockMode) { + entityManagerCaller.joinTransactionIfNecessary(); + queryDelegate.setLockMode(lockMode); + return this; + } + + @Override + public LockModeType getLockMode() { + return queryDelegate.getLockMode(); + } + + @Override + public T unwrap(Class cls) { + return queryDelegate.unwrap(cls); + } + +} diff --git a/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/TypedQueryProxy.java b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/TypedQueryProxy.java new file mode 100644 index 0000000..2757079 --- /dev/null +++ b/impl/extension/jpa/src/main/java/br/gov/frameworkdemoiselle/internal/proxy/query/TypedQueryProxy.java @@ -0,0 +1,181 @@ +package br.gov.frameworkdemoiselle.internal.proxy.query; + +import java.util.Calendar; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.persistence.FlushModeType; +import javax.persistence.LockModeType; +import javax.persistence.Parameter; +import javax.persistence.TemporalType; +import javax.persistence.TypedQuery; + +import br.gov.frameworkdemoiselle.internal.proxy.EntityManagerProxy; + +public class TypedQueryProxy implements TypedQuery { + + private TypedQuery queryDelegate; + private EntityManagerProxy entityManagerCaller; + + public TypedQueryProxy(TypedQuery queryDelegate, + EntityManagerProxy entityManagerCaller) { + this.queryDelegate = queryDelegate; + this.entityManagerCaller = entityManagerCaller; + } + + public List getResultList() { + entityManagerCaller.joinTransactionIfNecessary(); + return queryDelegate.getResultList(); + } + + public X getSingleResult() { + entityManagerCaller.joinTransactionIfNecessary(); + return queryDelegate.getSingleResult(); + } + + public int executeUpdate() { + entityManagerCaller.joinTransactionIfNecessary(); + return queryDelegate.executeUpdate(); + } + + public TypedQuery setMaxResults(int maxResult) { + queryDelegate.setMaxResults(maxResult); + return this; + } + + public TypedQuery setFirstResult(int startPosition) { + queryDelegate.setFirstResult(startPosition); + return this; + } + + public TypedQuery setHint(String hintName, Object value) { + queryDelegate.setHint(hintName, value); + return this; + } + + public int getMaxResults() { + return queryDelegate.getMaxResults(); + } + + public TypedQuery setParameter(Parameter param, T value) { + queryDelegate.setParameter(param, value); + return this; + } + + public int getFirstResult() { + return queryDelegate.getFirstResult(); + } + + public TypedQuery setParameter(Parameter param, + Calendar value, TemporalType temporalType) { + queryDelegate.setParameter(param, value, temporalType); + return this; + } + + public TypedQuery setParameter(Parameter param, Date value, + TemporalType temporalType) { + queryDelegate.setParameter(param, value, temporalType); + return this; + } + + public Map getHints() { + return queryDelegate.getHints(); + } + + public TypedQuery setParameter(String name, Object value) { + queryDelegate.setParameter(name, value); + return this; + } + + public TypedQuery setParameter(String name, Calendar value, + TemporalType temporalType) { + queryDelegate.setParameter(name, value, temporalType); + return this; + } + + public TypedQuery setParameter(String name, Date value, + TemporalType temporalType) { + queryDelegate.setParameter(name, value, temporalType); + return this; + } + + public TypedQuery setParameter(int position, Object value) { + queryDelegate.setParameter(position, value); + return this; + } + + public TypedQuery setParameter(int position, Calendar value, + TemporalType temporalType) { + queryDelegate.setParameter(position, value, temporalType); + return this; + } + + public TypedQuery setParameter(int position, Date value, + TemporalType temporalType) { + queryDelegate.setParameter(position, value, temporalType); + return this; + } + + public TypedQuery setFlushMode(FlushModeType flushMode) { + queryDelegate.setFlushMode(flushMode); + return this; + } + + public TypedQuery setLockMode(LockModeType lockMode) { + queryDelegate.setLockMode(lockMode); + return this; + } + + public Set> getParameters() { + return queryDelegate.getParameters(); + } + + public Parameter getParameter(String name) { + return queryDelegate.getParameter(name); + } + + public Parameter getParameter(String name, Class type) { + return queryDelegate.getParameter(name, type); + } + + public Parameter getParameter(int position) { + return queryDelegate.getParameter(position); + } + + public Parameter getParameter(int position, Class type) { + return queryDelegate.getParameter(position, type); + } + + public boolean isBound(Parameter param) { + return queryDelegate.isBound(param); + } + + public T getParameterValue(Parameter param) { + return queryDelegate.getParameterValue(param); + } + + public Object getParameterValue(String name) { + return queryDelegate.getParameterValue(name); + } + + public Object getParameterValue(int position) { + return queryDelegate.getParameterValue(position); + } + + public FlushModeType getFlushMode() { + return queryDelegate.getFlushMode(); + } + + public LockModeType getLockMode() { + return queryDelegate.getLockMode(); + } + + public T unwrap(Class cls) { + return queryDelegate.unwrap(cls); + } + + + +} diff --git a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/domain/Client.java b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/domain/Client.java index cb7e4a2..0b4afc0 100644 --- a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/domain/Client.java +++ b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/domain/Client.java @@ -1,10 +1,13 @@ package br.gov.frameworkdemoiselle.domain; import java.io.Serializable; +import java.util.Date; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; +import javax.persistence.Temporal; +import javax.persistence.TemporalType; /** * Simle entity for test classes @@ -19,6 +22,8 @@ public class Client implements Serializable { private Long id; private String name; + + private Date birthDate; @Id @GeneratedValue @@ -40,6 +45,20 @@ public class Client implements Serializable { public void setName(String name) { this.name = name; } + + + @Temporal(TemporalType.DATE) + public Date getBirthDate() { + return birthDate; + } + + + + public void setBirthDate(Date birthDate) { + this.birthDate = birthDate; + } + + diff --git a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxyTest.java b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxyTest.java index 22485a1..e681940 100644 --- a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxyTest.java +++ b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/EntityManagerProxyTest.java @@ -65,6 +65,7 @@ import org.powermock.modules.junit4.PowerMockRunner; import br.gov.frameworkdemoiselle.internal.producer.EntityManagerProducer; import br.gov.frameworkdemoiselle.internal.producer.FakeEntityManager; +import br.gov.frameworkdemoiselle.internal.proxy.query.QueryProxy; import br.gov.frameworkdemoiselle.util.Beans; @RunWith(PowerMockRunner.class) @@ -76,16 +77,21 @@ public class EntityManagerProxyTest { private EntityManager entityManager; private EntityManagerProducer entityManagerContext; + + private EntityTransaction transaction; @Before public void setUp() throws Exception { mockStatic(Beans.class); this.entityManager = EasyMock.createMock(EntityManager.class); this.entityManagerContext = EasyMock.createMock(EntityManagerProducer.class); + this.transaction = EasyMock.createMock(EntityTransaction.class); expect(Beans.getReference(EntityManagerProducer.class)).andReturn(this.entityManagerContext).anyTimes(); expect(this.entityManagerContext.getEntityManager("teste")).andReturn(this.entityManager).anyTimes(); replay(this.entityManagerContext); + //expect(this.entityManager.getTransaction()).andReturn(transaction).anyTimes(); + //replay(this.entityManager); replayAll(); this.entityManagerProxy = new EntityManagerProxy("teste"); @@ -335,45 +341,55 @@ public class EntityManagerProxyTest { @Test public void testCreateQuery() { - Query query = null; + Query query = EasyMock.createMock(Query.class); expect(this.entityManager.createQuery("teste")).andReturn(query); + expect(this.entityManager.getTransaction()).andReturn(transaction); replay(this.entityManager); - assertEquals(QueryProxy.class, this.entityManagerProxy.createQuery("teste").getClass()); + assertTrue(Query.class.isAssignableFrom(this.entityManagerProxy.createQuery("teste").getClass()) ); verify(this.entityManager); } @Test public void testCreateQueryWithParamCriteria() { - TypedQuery typedQuery = null; + @SuppressWarnings("unchecked") + TypedQuery typedQuery = EasyMock.createMock(TypedQuery.class); + CriteriaQuery criteriaQuery = null; expect(this.entityManager.createQuery(criteriaQuery)).andReturn(typedQuery); + expect(this.entityManager.getTransaction()).andReturn(transaction); replay(this.entityManager); - assertEquals(TypedQueryProxy.class, this.entityManagerProxy.createQuery(criteriaQuery).getClass()); + assertTrue(TypedQuery.class.isAssignableFrom(this.entityManagerProxy.createQuery(criteriaQuery).getClass())); verify(this.entityManager); } @Test public void testCreateQueryWithParamStringAndClass() { - TypedQuery typeQuery = null; + @SuppressWarnings("unchecked") + TypedQuery typeQuery = EasyMock.createMock(TypedQuery.class); + expect(this.entityManager.createQuery("teste", String.class)).andReturn(typeQuery); + expect(this.entityManager.getTransaction()).andReturn(transaction); replay(this.entityManager); - assertEquals(TypedQueryProxy.class, this.entityManagerProxy.createQuery("teste", String.class).getClass()); + assertTrue(TypedQuery.class.isAssignableFrom(this.entityManagerProxy.createQuery("teste", String.class).getClass())); verify(this.entityManager); } @Test public void testCreateNamedQuery() { - Query query = null; + Query query = EasyMock.createMock(Query.class); expect(this.entityManager.createNamedQuery("teste")).andReturn(query); + expect(this.entityManager.getTransaction()).andReturn(transaction); replay(this.entityManager); - assertEquals(QueryProxy.class, this.entityManagerProxy.createNamedQuery("teste").getClass()); + assertTrue(Query.class.isAssignableFrom(this.entityManagerProxy.createNamedQuery("teste").getClass())); verify(this.entityManager); } @Test public void testCreateNamedQueryWithParamsStringAndClass() { - TypedQuery typedQuery = null; + @SuppressWarnings("unchecked") + TypedQuery typedQuery = EasyMock.createMock(TypedQuery.class); expect(this.entityManager.createNamedQuery("teste", String.class)).andReturn(typedQuery); + expect(this.entityManager.getTransaction()).andReturn(transaction); replay(this.entityManager); assertEquals(typedQuery, this.entityManagerProxy.createNamedQuery("teste", String.class)); verify(this.entityManager); diff --git a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxyTest.java b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxyTest.java index 66da0cc..b234177 100644 --- a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxyTest.java +++ b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxyTest.java @@ -1,18 +1,24 @@ package br.gov.frameworkdemoiselle.internal.proxy; import java.util.Collections; +import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; +import javax.persistence.FlushModeType; +import javax.persistence.LockModeType; +import javax.persistence.NoResultException; import javax.persistence.Persistence; import javax.persistence.Query; +import javax.persistence.TemporalType; import org.easymock.EasyMock; import org.junit.Assert; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.powermock.api.easymock.PowerMock; @@ -22,13 +28,15 @@ import org.powermock.reflect.Whitebox; import br.gov.frameworkdemoiselle.domain.Client; import br.gov.frameworkdemoiselle.internal.producer.EntityManagerProducer; +import br.gov.frameworkdemoiselle.internal.proxy.query.QueryProxy; import br.gov.frameworkdemoiselle.util.Beans; /** - * Test the proxied + * Test the proxied {@link Query} class, {@link QueryProxy}. * @author 81986912515 * */ +@Ignore @RunWith(PowerMockRunner.class) @PrepareForTest({Beans.class}) public class QueryProxyTest { @@ -42,7 +50,7 @@ public class QueryProxyTest { Map configOverrides = new HashMap(); configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence"); configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:hsql:."); - configOverrides.put("hibernate.show_sql", "false"); + configOverrides.put("hibernate.show_sql", "true"); configOverrides.put("hibernate.hbm2ddl.auto", "create-drop"); EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides); @@ -65,14 +73,17 @@ public class QueryProxyTest { Client client = new Client(); client.setName("Cliente 1"); + client.setBirthDate(new Date()); manager.persist(client); client = new Client(); client.setName("Cliente 2"); + client.setBirthDate(new Date()); manager.persist(client); client = new Client(); client.setName("Cliente 3"); + client.setBirthDate(new Date()); manager.persist(client); manager.flush(); @@ -130,7 +141,7 @@ public class QueryProxyTest { @Test public void testPagination(){ - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(4); + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2); PowerMock.replay(Beans.class); QueryProxy proxy = getQueryProxy("select c from Client c"); @@ -144,5 +155,102 @@ public class QueryProxyTest { List result = proxy.getResultList(); Assert.assertEquals(2, result.size()); } + + @Test + public void testHint(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(14); + PowerMock.replay(Beans.class); + //Consulta um cliente definindo a hint readOnly, que torna a entidade retornada não atualizável. + manager.getTransaction().begin(); + QueryProxy proxy = getQueryProxy("select c from Client c where c.name=?1","Cliente 1"); + proxy.setHint("org.hibernate.readOnly", true); + Assert.assertFalse( proxy.getHints().isEmpty() ); + + //Tenta atualizar a entidade e limpar o cache de primeiro nível + Client c = (Client)proxy.getSingleResult(); + c.setName("Cliente 1 Alterado"); + manager.flush(); + manager.getTransaction().commit(); + manager.clear(); + + //Reconsultar a entidade tem que retornar 1 resultado, pois o nome "Cliente 1" não deve ter sido alterado. + manager.getTransaction().begin(); + proxy = getQueryProxy("select c from Client c where c.name=?1","Cliente 1"); + c = (Client)proxy.getSingleResult(); + Assert.assertNotNull(c); + + //Mudar a entidade agora tem que funcionar, pois não foi informado o hint + c.setName("Cliente 1 Alterado"); + manager.flush(); + manager.getTransaction().commit(); + manager.clear(); + + proxy = getQueryProxy("select c from Client c where c.name=?1","Cliente 1"); + + try{ + proxy.getSingleResult(); + Assert.fail(); + } + catch(NoResultException ne){ + } + + PowerMock.verifyAll(); + } + + @Test + public void testParameters(){ + + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2); + PowerMock.replay(Beans.class); + + QueryProxy proxy = getQueryProxy("select c.name from Client c where 'Named Parameter'=:name and c.birthDate=:dateName and c.name=?1 and c.birthDate=?2"); + + Date dateValue = new Date(); + + proxy.setParameter("name", "Named Parameter"); + proxy.setParameter("dateName", dateValue, TemporalType.DATE); + + proxy.setParameter(1, "Cliente 1"); + proxy.setParameter(2, dateValue,TemporalType.DATE); + + Assert.assertEquals(proxy.getParameterValue("name"),"Named Parameter"); + Assert.assertEquals(proxy.getParameterValue(1), "Cliente 1"); + + @SuppressWarnings("unchecked") + List> result = proxy.getResultList(); + + Assert.assertNotNull(result); + Assert.assertFalse(result.isEmpty()); + + PowerMock.verifyAll(); + } + + @Test + public void testFlushMode(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(3); + PowerMock.replay(Beans.class); + + manager.getTransaction().begin(); + QueryProxy proxy = getQueryProxy("update Client set name=?1 where name=?2","Cliente 1 Alterado","Cliente 1"); + proxy.setFlushMode(FlushModeType.COMMIT); + Assert.assertEquals(proxy.getFlushMode(), FlushModeType.COMMIT); + manager.getTransaction().commit(); + + PowerMock.verifyAll(); + } + + @Test + public void testLockMode(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(4); + PowerMock.replay(Beans.class); + + manager.getTransaction().begin(); + QueryProxy proxy = getQueryProxy("update Client set name=?1 where name=?2","Cliente 1 Alterado","Cliente 1"); + proxy.setLockMode(LockModeType.OPTIMISTIC); + Assert.assertEquals(proxy.getLockMode(), LockModeType.OPTIMISTIC); + manager.getTransaction().commit(); + + PowerMock.verifyAll(); + } } diff --git a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxyTest.java b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxyTest.java new file mode 100644 index 0000000..4b5cca6 --- /dev/null +++ b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxyTest.java @@ -0,0 +1,245 @@ +package br.gov.frameworkdemoiselle.internal.proxy; + +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.FlushModeType; +import javax.persistence.LockModeType; +import javax.persistence.NoResultException; +import javax.persistence.Persistence; +import javax.persistence.Query; +import javax.persistence.TemporalType; +import javax.persistence.TypedQuery; + +import org.easymock.EasyMock; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.powermock.api.easymock.PowerMock; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.reflect.Whitebox; + +import br.gov.frameworkdemoiselle.domain.Client; +import br.gov.frameworkdemoiselle.internal.producer.EntityManagerProducer; +import br.gov.frameworkdemoiselle.internal.proxy.query.TypedQueryProxy; +import br.gov.frameworkdemoiselle.util.Beans; + +/** + * Test the proxied {@link Query} class, {@link TypedQueryProxy}. + * @author 81986912515 + * + */ +@Ignore +@RunWith(PowerMockRunner.class) +@PrepareForTest({Beans.class}) +public class TypedQueryProxyTest { + + private EntityManager manager; + private EntityManagerProducer producer; + + @Before + public void setUp(){ + + Map configOverrides = new HashMap(); + configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence"); + configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:hsql:."); + configOverrides.put("hibernate.show_sql", "true"); + configOverrides.put("hibernate.hbm2ddl.auto", "create-drop"); + + EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides); + EntityManager delegate = factory.createEntityManager(); + + Map cache = Collections.synchronizedMap(new HashMap()); + cache.put("pu1", delegate); + + producer = new EntityManagerProducer(); + Whitebox.setInternalState(producer, "cache", cache); + + PowerMock.mockStatic(Beans.class); + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(12); + PowerMock.replayAll(); + + manager = new EntityManagerProxy("pu1"); + + manager.getTransaction().begin(); + manager.createQuery("delete from Client").executeUpdate(); + + Client client = new Client(); + client.setName("Cliente 1"); + client.setBirthDate(new Date()); + manager.persist(client); + + client = new Client(); + client.setName("Cliente 2"); + client.setBirthDate(new Date()); + manager.persist(client); + + client = new Client(); + client.setName("Cliente 3"); + client.setBirthDate(new Date()); + manager.persist(client); + + manager.flush(); + manager.getTransaction().commit(); + manager.clear(); + + PowerMock.resetAll(); + } + + private TypedQueryProxy getQueryProxy(String jpql,Class classType,Object... params){ + TypedQuery q = manager.createQuery(jpql,classType); + if (!(q instanceof TypedQueryProxy)){ + Assert.fail("Query não é instância de QueryProxy"); + } + + if (params!=null){ + int count = 1; + for (Object param : params){ + q.setParameter(count++, param); + } + } + + return (TypedQueryProxy)q; + } + + @Test + public void testResultList(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2); + PowerMock.replay(Beans.class); + + List retorno = getQueryProxy("select c from Client c",Client.class).getResultList(); + Assert.assertNotNull(retorno); + Assert.assertFalse(retorno.isEmpty()); + } + + @Test + public void testSingleResult(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2); + PowerMock.replay(Beans.class); + + Client retorno = (Client)getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1").getSingleResult(); + Assert.assertNotNull(retorno); + } + + @Test + public void testPagination(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2); + PowerMock.replay(Beans.class); + + TypedQueryProxy proxy = getQueryProxy("select c from Client c",Client.class); + + proxy.setMaxResults(2); + Assert.assertEquals(2, proxy.getMaxResults()); + + proxy.setFirstResult(1); + Assert.assertEquals(1, proxy.getFirstResult()); + + List result = proxy.getResultList(); + Assert.assertEquals(2, result.size()); + } + + @Test + public void testHint(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(14); + PowerMock.replay(Beans.class); + + //Consulta um cliente definindo a hint readOnly, que torna a entidade retornada não atualizável. + manager.getTransaction().begin(); + TypedQueryProxy proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1"); + proxy.setHint("org.hibernate.readOnly", true); + Assert.assertFalse( proxy.getHints().isEmpty() ); + + //Tenta atualizar a entidade e limpar o cache de primeiro nível + Client c = (Client)proxy.getSingleResult(); + c.setName("Cliente 1 Alterado"); + manager.flush(); + manager.getTransaction().commit(); + manager.clear(); + + //Reconsultar a entidade tem que retornar 1 resultado, pois o nome "Cliente 1" não deve ter sido alterado. + manager.getTransaction().begin(); + proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1"); + c = (Client)proxy.getSingleResult(); + Assert.assertNotNull(c); + + //Mudar a entidade agora tem que funcionar, pois não foi informado o hint + c.setName("Cliente 1 Alterado"); + manager.flush(); + manager.getTransaction().commit(); + manager.clear(); + + proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1"); + + try{ + proxy.getSingleResult(); + Assert.fail(); + } + catch(NoResultException ne){ + } + + PowerMock.verifyAll(); + } + + @Test + public void testParameters(){ + + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2); + PowerMock.replay(Beans.class); + + TypedQueryProxy proxy = getQueryProxy("select c from Client c where 'Named Parameter'=:name and c.birthDate=:dateName and c.name=?1 and c.birthDate=?2",Client.class); + + Date dateValue = new Date(); + + proxy.setParameter("name", "Named Parameter"); + proxy.setParameter("dateName", dateValue, TemporalType.DATE); + + proxy.setParameter(1, "Cliente 1"); + proxy.setParameter(2, dateValue,TemporalType.DATE); + + Assert.assertEquals(proxy.getParameterValue("name"),"Named Parameter"); + Assert.assertEquals(proxy.getParameterValue(1), "Cliente 1"); + + List result = proxy.getResultList(); + + Assert.assertNotNull(result); + Assert.assertFalse(result.isEmpty()); + + PowerMock.verifyAll(); + } + + @Test + public void testFlushMode(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(3); + PowerMock.replay(Beans.class); + + manager.getTransaction().begin(); + TypedQueryProxy proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1"); + proxy.setFlushMode(FlushModeType.COMMIT); + Assert.assertEquals(proxy.getFlushMode(), FlushModeType.COMMIT); + manager.getTransaction().commit(); + + PowerMock.verifyAll(); + } + + @Test + public void testLockMode(){ + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(3); + PowerMock.replay(Beans.class); + + manager.getTransaction().begin(); + TypedQueryProxy proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1"); + proxy.setLockMode(LockModeType.OPTIMISTIC); + Assert.assertEquals(proxy.getLockMode(), LockModeType.OPTIMISTIC); + manager.getTransaction().commit(); + + PowerMock.verifyAll(); + } +} diff --git a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/template/JPACrudTest.java b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/template/JPACrudTest.java index 913207d..c9ea907 100644 --- a/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/template/JPACrudTest.java +++ b/impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/template/JPACrudTest.java @@ -47,13 +47,18 @@ import static org.powermock.reflect.Whitebox.setInternalState; import java.io.Serializable; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import javax.enterprise.inject.Instance; import javax.persistence.Column; +import javax.persistence.Entity; import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; import javax.persistence.GeneratedValue; import javax.persistence.Id; +import javax.persistence.Persistence; import javax.persistence.Query; import javax.persistence.TransactionRequiredException; import javax.persistence.TypedQuery; @@ -71,6 +76,7 @@ import org.junit.runner.RunWith; import org.powermock.api.easymock.PowerMock; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.reflect.Whitebox; import br.gov.frameworkdemoiselle.DemoiselleException; import br.gov.frameworkdemoiselle.configuration.Configuration; @@ -104,6 +110,7 @@ public class JPACrudTest { setInternalState(this.contactDAO, EntityManager.class, this.entityManager); } + @Entity class Contact implements Serializable { private static final long serialVersionUID = 1L; @@ -426,5 +433,26 @@ public class JPACrudTest { setInternalState(this.contactDAO, EntityManager.class, (EntityManager)null); Assert.assertNotNull(this.contactDAO.getEntityManager()); } + + @Test + public void testCriteriaQuery(){ + Map configOverrides = new HashMap(); + configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence"); + configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:hsql:."); + configOverrides.put("hibernate.show_sql", "true"); + configOverrides.put("hibernate.hbm2ddl.auto", "create-drop"); + + EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides); + this.entityManager = factory.createEntityManager(); + Whitebox.setInternalState(this.contactDAO, EntityManager.class, (EntityManager)null); + + PowerMock.mockStatic(Beans.class); + expect(Beans.getReference(EntityManager.class)).andReturn(entityManager); + PowerMock.replay(Beans.class); + + CriteriaQuery query = this.contactDAO.createCriteriaQuery(); + query.select( query.from(Contact.class) ); + + } } -- libgit2 0.21.2