Download as
Browse Code »

Commit d9fb40ecbb45cae248410e25fab1ece302e64e4b

Authored by Ednara Oliveira
1 parent b181c1b4
Exists in master

Refatoração de testes unitários: QueryProxyTest e TypedQueryProxyTest

Showing 2 changed files with 411 additions and 358 deletions   Show diff stats
impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/QueryProxyTest.java
  Diff comments   View file @d9fb40e
  1 +/*
  2 + * Demoiselle Framework
  3 + * Copyright (C) 2010 SERPRO
  4 + * ----------------------------------------------------------------------------
  5 + * This file is part of Demoiselle Framework.
  6 + *
  7 + * Demoiselle Framework is free software; you can redistribute it and/or
  8 + * modify it under the terms of the GNU Lesser General Public License version 3
  9 + * as published by the Free Software Foundation.
  10 + *
  11 + * This program is distributed in the hope that it will be useful,
  12 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 + * GNU General Public License for more details.
  15 + *
  16 + * You should have received a copy of the GNU Lesser General Public License version 3
  17 + * along with this program; if not, see <http://www.gnu.org/licenses/>
  18 + * or write to the Free Software Foundation, Inc., 51 Franklin Street,
  19 + * Fifth Floor, Boston, MA 02110-1301, USA.
  20 + * ----------------------------------------------------------------------------
  21 + * Este arquivo é parte do Framework Demoiselle.
  22 + *
  23 + * O Framework Demoiselle é um software livre; você pode redistribuí-lo e/ou
  24 + * modificá-lo dentro dos termos da GNU LGPL versão 3 como publicada pela Fundação
  25 + * do Software Livre (FSF).
  26 + *
  27 + * Este programa é distribuído na esperança que possa ser útil, mas SEM NENHUMA
  28 + * GARANTIA; sem uma garantia implícita de ADEQUAÇÃO a qualquer MERCADO ou
  29 + * APLICAÇÃO EM PARTICULAR. Veja a Licença Pública Geral GNU/LGPL em português
  30 + * para maiores detalhes.
  31 + *
  32 + * Você deve ter recebido uma cópia da GNU LGPL versão 3, sob o título
  33 + * "LICENCA.txt", junto com esse programa. Se não, acesse <http://www.gnu.org/licenses/>
  34 + * ou escreva para a Fundação do Software Livre (FSF) Inc.,
  35 + * 51 Franklin St, Fifth Floor, Boston, MA 02111-1301, USA.
  36 + */
1 37 package br.gov.frameworkdemoiselle.internal.proxy;
2 38  
  39 +import static junit.framework.Assert.assertTrue;
  40 +import static org.easymock.EasyMock.expect;
  41 +import static org.junit.Assert.assertEquals;
  42 +import static org.powermock.api.easymock.PowerMock.replay;
  43 +import static org.powermock.api.easymock.PowerMock.verifyAll;
  44 +
  45 +import java.util.ArrayList;
  46 +import java.util.Calendar;
3 47 import java.util.Collections;
4 48 import java.util.Date;
5 49 import java.util.HashMap;
... ... @@ -10,15 +54,13 @@ import javax.persistence.EntityManager;
10 54 import javax.persistence.EntityManagerFactory;
11 55 import javax.persistence.FlushModeType;
12 56 import javax.persistence.LockModeType;
13   -import javax.persistence.NoResultException;
  57 +import javax.persistence.Parameter;
14 58 import javax.persistence.Persistence;
15 59 import javax.persistence.Query;
16 60 import javax.persistence.TemporalType;
17 61  
18 62 import org.easymock.EasyMock;
19   -import org.junit.Assert;
20 63 import org.junit.Before;
21   -import org.junit.Ignore;
22 64 import org.junit.Test;
23 65 import org.junit.runner.RunWith;
24 66 import org.powermock.api.easymock.PowerMock;
... ... @@ -32,224 +74,221 @@ import br.gov.frameworkdemoiselle.util.Beans;
32 74  
33 75 /**
34 76 * Test the proxied {@link Query} class, {@link QueryProxy}.
  77 + *
35 78 * @author 81986912515
36   - *
37 79 */
38   -@Ignore
39 80 @RunWith(PowerMockRunner.class)
40   -@PrepareForTest({Beans.class})
  81 +@PrepareForTest({ Beans.class })
41 82 public class QueryProxyTest {
42   -
  83 +
43 84 private EntityManager manager;
  85 +
44 86 private EntityManagerProducer producer;
45   -
  87 +
  88 + private QueryProxy queryProxy;
  89 +
46 90 @Before
47   - public void setUp(){
48   -
  91 + public void setUp() {
  92 +
49 93 Map<String, Object> configOverrides = new HashMap<String, Object>();
50 94 configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence");
51   - configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:hsql:.");
  95 +
  96 + configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:mem:.");
  97 + configOverrides.put("javax.persistence.jdbc.driver", "org.hsqldb.jdbcDriver");
  98 + configOverrides.put("javax.persistence.jdbc.user", "sa");
  99 + configOverrides.put("javax.persistence.jdbc.password", "");
  100 +
52 101 configOverrides.put("hibernate.show_sql", "true");
53 102 configOverrides.put("hibernate.hbm2ddl.auto", "create-drop");
54   -
  103 +
55 104 EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides);
56 105 EntityManager delegate = factory.createEntityManager();
57   -
  106 +
58 107 Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>());
59 108 cache.put("pu1", delegate);
60   -
  109 +
61 110 producer = new EntityManagerProducer();
62 111 Whitebox.setInternalState(producer, "cache", cache);
63   -
  112 +
64 113 PowerMock.mockStatic(Beans.class);
65   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(12);
  114 + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).anyTimes();
66 115 PowerMock.replayAll();
67 116  
68 117 manager = new EntityManagerProxy("pu1");
69   -
70   - manager.getTransaction().begin();
71   - manager.createQuery("delete from Client").executeUpdate();
72   -
73   - Client client = new Client();
74   - client.setName("Cliente 1");
75   - client.setBirthDate(new Date());
76   - manager.persist(client);
77   -
78   - client = new Client();
79   - client.setName("Cliente 2");
80   - client.setBirthDate(new Date());
81   - manager.persist(client);
82   -
83   - client = new Client();
84   - client.setName("Cliente 3");
85   - client.setBirthDate(new Date());
86   - manager.persist(client);
87   -
88   - manager.flush();
89   - manager.getTransaction().commit();
90   - manager.clear();
91   -
92   - PowerMock.resetAll();
93 118 }
94   -
95   - private QueryProxy getQueryProxy(String jpql,Object... params){
96   - Query q = manager.createQuery(jpql);
97   - if (!(q instanceof QueryProxy)){
98   - Assert.fail("Query não é instância de QueryProxy");
99   - }
100   -
101   - if (params!=null){
102   - int count = 1;
103   - for (Object param : params){
104   - q.setParameter(count++, param);
105   - }
106   - }
107   -
108   - return (QueryProxy)q;
109   - }
110   -
  119 +
111 120 @Test
112   - public void testResultList(){
113   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
114   - PowerMock.replay(Beans.class);
115   -
116   - List<?> retorno = getQueryProxy("select c from Client c").getResultList();
117   - Assert.assertNotNull(retorno);
118   - Assert.assertFalse(retorno.isEmpty());
  121 + public void testGetResultList() {
  122 + Query queryDelegate = PowerMock.createMock(Query.class);
  123 + List<String> result = new ArrayList<String>();
  124 + result.add("x");
  125 + EasyMock.expect(queryDelegate.getResultList()).andReturn(result).anyTimes();
  126 +
  127 + replay(queryDelegate);
  128 +
  129 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  130 + queryProxy.getResultList();
  131 + assertEquals(queryProxy.getResultList().size(), queryDelegate.getResultList().size());
  132 +
  133 + verifyAll();
119 134 }
120   -
  135 +
121 136 @Test
122   - public void testSingleResult(){
123   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
124   - PowerMock.replay(Beans.class);
125   -
126   - Client retorno = (Client)getQueryProxy("select c from Client c where c.name=?1","Cliente 1").getSingleResult();
127   - Assert.assertNotNull(retorno);
  137 + public void testSingleResult() {
  138 + Query queryDelegate = PowerMock.createMock(Query.class);
  139 + String result = "Resultado";
  140 + EasyMock.expect(queryDelegate.getSingleResult()).andReturn(result).anyTimes();
  141 +
  142 + replay(queryDelegate);
  143 +
  144 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  145 + assertEquals(queryProxy.getSingleResult(), queryDelegate.getSingleResult());
  146 +
  147 + verifyAll();
128 148 }
129   -
  149 +
130 150 @Test
131   - public void testExecuteUpdate(){
132   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(4);
133   - PowerMock.replay(Beans.class);
134   -
135   - manager.getTransaction().begin();
136   - int linesAffected = getQueryProxy("update Client set name=?1 where name=?2","Novo Cliente","Cliente 1").executeUpdate();
137   - manager.getTransaction().commit();
138   - Assert.assertEquals(1, linesAffected);
  151 + public void testExecuteUpdate() {
  152 + Query queryDelegate = PowerMock.createMock(Query.class);
  153 + EasyMock.expect(queryDelegate.executeUpdate()).andReturn(1).anyTimes();
  154 +
  155 + replay(queryDelegate);
  156 +
  157 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  158 + assertEquals(queryProxy.executeUpdate(), 1);
  159 +
  160 + verifyAll();
139 161 }
140   -
  162 +
141 163 @Test
142   - public void testPagination(){
143   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
144   - PowerMock.replay(Beans.class);
145   -
146   - QueryProxy proxy = getQueryProxy("select c from Client c");
147   -
148   - proxy.setMaxResults(2);
149   - Assert.assertEquals(2, proxy.getMaxResults());
150   -
151   - proxy.setFirstResult(1);
152   - Assert.assertEquals(1, proxy.getFirstResult());
153   -
154   - List<?> result = proxy.getResultList();
155   - Assert.assertEquals(2, result.size());
  164 + public void testPagination() {
  165 + Query queryDelegate = PowerMock.createMock(Query.class);
  166 + expect(queryDelegate.getMaxResults()).andReturn(4).times(2);
  167 + expect(queryDelegate.getFirstResult()).andReturn(2).times(2);
  168 + expect(queryDelegate.setMaxResults(EasyMock.anyInt())).andReturn(queryDelegate);
  169 + expect(queryDelegate.setFirstResult(EasyMock.anyInt())).andReturn(queryDelegate);
  170 + replay(queryDelegate);
  171 +
  172 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  173 + queryProxy.setMaxResults(4);
  174 + queryProxy.setFirstResult(2);
  175 + assertEquals(queryProxy.getMaxResults(), queryDelegate.getMaxResults());
  176 + assertEquals(queryProxy.getFirstResult(), queryDelegate.getFirstResult());
  177 +
  178 + verifyAll();
156 179 }
157   -
  180 +
158 181 @Test
159   - public void testHint(){
160   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(14);
161   - PowerMock.replay(Beans.class);
162   -
163   - //Consulta um cliente definindo a hint readOnly, que torna a entidade retornada não atualizável.
164   - manager.getTransaction().begin();
165   - QueryProxy proxy = getQueryProxy("select c from Client c where c.name=?1","Cliente 1");
166   - proxy.setHint("org.hibernate.readOnly", true);
167   - Assert.assertFalse( proxy.getHints().isEmpty() );
168   -
169   - //Tenta atualizar a entidade e limpar o cache de primeiro nível
170   - Client c = (Client)proxy.getSingleResult();
171   - c.setName("Cliente 1 Alterado");
172   - manager.flush();
173   - manager.getTransaction().commit();
174   - manager.clear();
175   -
176   - //Reconsultar a entidade tem que retornar 1 resultado, pois o nome "Cliente 1" não deve ter sido alterado.
177   - manager.getTransaction().begin();
178   - proxy = getQueryProxy("select c from Client c where c.name=?1","Cliente 1");
179   - c = (Client)proxy.getSingleResult();
180   - Assert.assertNotNull(c);
181   -
182   - //Mudar a entidade agora tem que funcionar, pois não foi informado o hint
183   - c.setName("Cliente 1 Alterado");
184   - manager.flush();
185   - manager.getTransaction().commit();
186   - manager.clear();
187   -
188   - proxy = getQueryProxy("select c from Client c where c.name=?1","Cliente 1");
189   -
190   - try{
191   - proxy.getSingleResult();
192   - Assert.fail();
193   - }
194   - catch(NoResultException ne){
195   - }
196   -
197   - PowerMock.verifyAll();
  182 + public void testHint() {
  183 + Query queryDelegate = PowerMock.createMock(Query.class);
  184 + Map<String, Object> map = new HashMap<String, Object>();
  185 + Client client = new Client();
  186 + map.put("1", client);
  187 + expect(queryDelegate.getHints()).andReturn(map).times(2);
  188 + expect(queryDelegate.setHint(EasyMock.anyObject(String.class), EasyMock.anyObject())).andReturn(queryDelegate);
  189 + replay(queryDelegate);
  190 +
  191 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  192 + queryProxy.setHint("1", client);
  193 + assertEquals(queryProxy.getHints(), queryDelegate.getHints());
  194 +
  195 + verifyAll();
198 196 }
199   -
  197 +
  198 + @SuppressWarnings({ "unused", "rawtypes", "unchecked" })
200 199 @Test
201   - public void testParameters(){
202   -
203   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
204   - PowerMock.replay(Beans.class);
205   -
206   - 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");
207   -
  200 + public void testParameters() {
  201 + Query queryDelegate = PowerMock.createMock(Query.class);
208 202 Date dateValue = new Date();
209   -
210   - proxy.setParameter("name", "Named Parameter");
211   - proxy.setParameter("dateName", dateValue, TemporalType.DATE);
212   -
213   - proxy.setParameter(1, "Cliente 1");
214   - proxy.setParameter(2, dateValue,TemporalType.DATE);
215   -
216   - Assert.assertEquals(proxy.getParameterValue("name"),"Named Parameter");
217   - Assert.assertEquals(proxy.getParameterValue(1), "Cliente 1");
218   -
219   - @SuppressWarnings("unchecked")
220   - List<Map<String, Object>> result = proxy.getResultList();
221   -
222   - Assert.assertNotNull(result);
223   - Assert.assertFalse(result.isEmpty());
224   -
225   - PowerMock.verifyAll();
  203 + Calendar calendar = PowerMock.createMock(Calendar.class);
  204 + Class<Date> type = Date.class;
  205 + Parameter parameter = PowerMock.createMock(Parameter.class);
  206 +
  207 + expect(queryDelegate.setParameter(EasyMock.anyObject(String.class), EasyMock.anyObject(String.class)))
  208 + .andReturn(queryDelegate);
  209 + expect(queryDelegate.getParameterValue(EasyMock.anyObject(String.class))).andReturn("Named Parameter")
  210 + .anyTimes();
  211 + expect(queryDelegate.setParameter(EasyMock.anyInt(), EasyMock.anyObject(String.class)))
  212 + .andReturn(queryDelegate);
  213 + expect(queryDelegate.getParameterValue(EasyMock.anyInt())).andReturn("Client").anyTimes();
  214 + expect(
  215 + queryDelegate.setParameter(EasyMock.anyObject(String.class), EasyMock.anyObject(Date.class),
  216 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  217 + expect(
  218 + queryDelegate.setParameter(EasyMock.anyInt(), EasyMock.anyObject(Date.class),
  219 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  220 + expect(queryDelegate.setParameter(EasyMock.anyObject(Parameter.class), EasyMock.anyObject())).andReturn(
  221 + queryDelegate);
  222 + expect(queryDelegate.getParameterValue(EasyMock.anyObject(Parameter.class))).andReturn(parameter).anyTimes();
  223 + expect(
  224 + queryDelegate.setParameter(EasyMock.anyObject(String.class), EasyMock.anyObject(Calendar.class),
  225 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  226 + expect(
  227 + queryDelegate.setParameter(EasyMock.anyInt(), EasyMock.anyObject(Calendar.class),
  228 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  229 +
  230 + replay(queryDelegate, parameter, calendar);
  231 +
  232 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  233 + queryProxy.setParameter("name", "Named Parameter");
  234 + assertEquals(queryProxy.getParameterValue("name"), queryDelegate.getParameterValue("name"));
  235 + queryProxy.setParameter(1, "Client");
  236 + assertEquals(queryProxy.getParameterValue("1"), queryDelegate.getParameterValue("1"));
  237 + queryProxy.setParameter("dateName", dateValue, TemporalType.DATE);
  238 + queryProxy.setParameter(2, dateValue, TemporalType.DATE);
  239 + queryProxy.setParameter(parameter, "X");
  240 + queryProxy.getParameterValue(parameter);
  241 + assertEquals(queryProxy.getParameterValue(parameter), parameter);
  242 + queryProxy.setParameter("dateName", calendar, TemporalType.DATE);
  243 + queryProxy.setParameter(2, calendar, TemporalType.DATE);
  244 +
  245 + verifyAll();
  246 + }
  247 +
  248 + @SuppressWarnings("rawtypes")
  249 + @Test
  250 + public void testIsBound() {
  251 + Query queryDelegate = PowerMock.createMock(Query.class);
  252 + Parameter parameter = PowerMock.createMock(Parameter.class);
  253 + expect(queryDelegate.isBound(EasyMock.anyObject(Parameter.class))).andReturn(true);
  254 +
  255 + replay(queryDelegate, parameter);
  256 +
  257 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  258 + assertTrue(queryProxy.isBound(parameter));
  259 +
  260 + verifyAll();
226 261 }
227   -
  262 +
228 263 @Test
229   - public void testFlushMode(){
230   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(3);
231   - PowerMock.replay(Beans.class);
232   -
233   - manager.getTransaction().begin();
234   - QueryProxy proxy = getQueryProxy("update Client set name=?1 where name=?2","Cliente 1 Alterado","Cliente 1");
235   - proxy.setFlushMode(FlushModeType.COMMIT);
236   - Assert.assertEquals(proxy.getFlushMode(), FlushModeType.COMMIT);
237   - manager.getTransaction().commit();
238   -
239   - PowerMock.verifyAll();
  264 + public void testFlushMode() {
  265 + Query queryDelegate = PowerMock.createMock(Query.class);
  266 + FlushModeType flushModeType = FlushModeType.AUTO;
  267 +
  268 + expect(queryDelegate.setFlushMode(FlushModeType.AUTO)).andReturn(queryDelegate);
  269 + expect(queryDelegate.getFlushMode()).andReturn(flushModeType).anyTimes();
  270 +
  271 + replay(queryDelegate);
  272 +
  273 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  274 + queryProxy.setFlushMode(FlushModeType.AUTO);
  275 + assertEquals(queryProxy.getFlushMode(), queryDelegate.getFlushMode());
  276 + verifyAll();
240 277 }
241   -
  278 +
242 279 @Test
243   - public void testLockMode(){
244   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(4);
245   - PowerMock.replay(Beans.class);
246   -
247   - manager.getTransaction().begin();
248   - QueryProxy proxy = getQueryProxy("update Client set name=?1 where name=?2","Cliente 1 Alterado","Cliente 1");
249   - proxy.setLockMode(LockModeType.OPTIMISTIC);
250   - Assert.assertEquals(proxy.getLockMode(), LockModeType.OPTIMISTIC);
251   - manager.getTransaction().commit();
252   -
253   - PowerMock.verifyAll();
  280 + public void testLockMode() {
  281 + Query queryDelegate = PowerMock.createMock(Query.class);
  282 + LockModeType lockModeType = LockModeType.OPTIMISTIC;
  283 +
  284 + expect(queryDelegate.setLockMode(lockModeType)).andReturn(queryDelegate);
  285 + expect(queryDelegate.getLockMode()).andReturn(lockModeType).anyTimes();
  286 +
  287 + replay(queryDelegate);
  288 +
  289 + queryProxy = new QueryProxy(queryDelegate, (EntityManagerProxy) manager);
  290 + queryProxy.setLockMode(lockModeType);
  291 + assertEquals(queryProxy.getLockMode(), queryDelegate.getLockMode());
  292 + verifyAll();
254 293 }
255 294 }
... ...
impl/extension/jpa/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/TypedQueryProxyTest.java
  Diff comments   View file @d9fb40e
1 1 package br.gov.frameworkdemoiselle.internal.proxy;
2 2  
  3 +import static junit.framework.Assert.assertTrue;
  4 +import static org.easymock.EasyMock.expect;
  5 +import static org.junit.Assert.assertEquals;
  6 +import static org.powermock.api.easymock.PowerMock.replay;
  7 +import static org.powermock.api.easymock.PowerMock.verifyAll;
  8 +
  9 +import java.util.ArrayList;
  10 +import java.util.Calendar;
3 11 import java.util.Collections;
4 12 import java.util.Date;
5 13 import java.util.HashMap;
... ... @@ -10,16 +18,14 @@ import javax.persistence.EntityManager;
10 18 import javax.persistence.EntityManagerFactory;
11 19 import javax.persistence.FlushModeType;
12 20 import javax.persistence.LockModeType;
13   -import javax.persistence.NoResultException;
  21 +import javax.persistence.Parameter;
14 22 import javax.persistence.Persistence;
15 23 import javax.persistence.Query;
16 24 import javax.persistence.TemporalType;
17 25 import javax.persistence.TypedQuery;
18 26  
19 27 import org.easymock.EasyMock;
20   -import org.junit.Assert;
21 28 import org.junit.Before;
22   -import org.junit.Ignore;
23 29 import org.junit.Test;
24 30 import org.junit.runner.RunWith;
25 31 import org.powermock.api.easymock.PowerMock;
... ... @@ -33,212 +39,220 @@ import br.gov.frameworkdemoiselle.util.Beans;
33 39  
34 40 /**
35 41 * Test the proxied {@link Query} class, {@link TypedQueryProxy}.
  42 + *
36 43 * @author 81986912515
37   - *
  44 + * @param <X>
38 45 */
39   -@Ignore
  46 +
  47 +@SuppressWarnings("rawtypes")
40 48 @RunWith(PowerMockRunner.class)
41   -@PrepareForTest({Beans.class})
  49 +@PrepareForTest({ Beans.class })
42 50 public class TypedQueryProxyTest {
43   -
  51 +
44 52 private EntityManager manager;
  53 +
45 54 private EntityManagerProducer producer;
46   -
  55 +
  56 + private TypedQueryProxy typedQueryProxy;
  57 +
47 58 @Before
48   - public void setUp(){
49   -
  59 + public void setUp() {
  60 +
50 61 Map<String, Object> configOverrides = new HashMap<String, Object>();
51 62 configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence");
52   - configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:hsql:.");
  63 +
  64 + configOverrides.put("javax.persistence.jdbc.url", "jdbc:hsqldb:mem:.");
  65 + configOverrides.put("javax.persistence.jdbc.driver", "org.hsqldb.jdbcDriver");
  66 + configOverrides.put("javax.persistence.jdbc.user", "sa");
  67 + configOverrides.put("javax.persistence.jdbc.password", "");
  68 +
53 69 configOverrides.put("hibernate.show_sql", "true");
54 70 configOverrides.put("hibernate.hbm2ddl.auto", "create-drop");
55   -
  71 +
56 72 EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides);
57 73 EntityManager delegate = factory.createEntityManager();
58   -
  74 +
59 75 Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>());
60 76 cache.put("pu1", delegate);
61   -
  77 +
62 78 producer = new EntityManagerProducer();
63 79 Whitebox.setInternalState(producer, "cache", cache);
64   -
  80 +
65 81 PowerMock.mockStatic(Beans.class);
66   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(12);
  82 + EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).anyTimes();
67 83 PowerMock.replayAll();
68 84  
69 85 manager = new EntityManagerProxy("pu1");
70   -
71   - manager.getTransaction().begin();
72   - manager.createQuery("delete from Client").executeUpdate();
73   -
74   - Client client = new Client();
75   - client.setName("Cliente 1");
76   - client.setBirthDate(new Date());
77   - manager.persist(client);
78   -
79   - client = new Client();
80   - client.setName("Cliente 2");
81   - client.setBirthDate(new Date());
82   - manager.persist(client);
83   -
84   - client = new Client();
85   - client.setName("Cliente 3");
86   - client.setBirthDate(new Date());
87   - manager.persist(client);
88   -
89   - manager.flush();
90   - manager.getTransaction().commit();
91   - manager.clear();
92   -
93   - PowerMock.resetAll();
94   - }
95   -
96   - private <T> TypedQueryProxy<T> getQueryProxy(String jpql,Class<T> classType,Object... params){
97   - TypedQuery<T> q = manager.createQuery(jpql,classType);
98   - if (!(q instanceof TypedQueryProxy)){
99   - Assert.fail("Query não é instância de QueryProxy");
100   - }
101   -
102   - if (params!=null){
103   - int count = 1;
104   - for (Object param : params){
105   - q.setParameter(count++, param);
106   - }
107   - }
108   -
109   - return (TypedQueryProxy<T>)q;
  86 +
  87 + // PowerMock.resetAll();
110 88 }
111   -
  89 +
  90 + @SuppressWarnings("unchecked")
112 91 @Test
113   - public void testResultList(){
114   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
115   - PowerMock.replay(Beans.class);
116   -
117   - List<?> retorno = getQueryProxy("select c from Client c",Client.class).getResultList();
118   - Assert.assertNotNull(retorno);
119   - Assert.assertFalse(retorno.isEmpty());
  92 + public void testResultList() {
  93 +
  94 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  95 + List<String> result = new ArrayList<String>();
  96 + result.add("x");
  97 + EasyMock.expect(queryDelegate.getResultList()).andReturn(result).anyTimes();
  98 +
  99 + replay(queryDelegate);
  100 +
  101 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  102 + assertEquals(typedQueryProxy.getResultList().size(), queryDelegate.getResultList().size());
  103 +
  104 + verifyAll();
120 105 }
121   -
  106 +
  107 + @SuppressWarnings("unchecked")
122 108 @Test
123   - public void testSingleResult(){
124   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
125   - PowerMock.replay(Beans.class);
126   -
127   - Client retorno = (Client)getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1").getSingleResult();
128   - Assert.assertNotNull(retorno);
  109 + public void testSingleResult() {
  110 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  111 + String result = "Resultado";
  112 + EasyMock.expect(queryDelegate.getSingleResult()).andReturn(result).anyTimes();
  113 +
  114 + replay(queryDelegate);
  115 +
  116 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  117 + assertEquals(typedQueryProxy.getSingleResult(), queryDelegate.getSingleResult());
  118 +
  119 + verifyAll();
129 120 }
130   -
  121 +
  122 + @SuppressWarnings("unchecked")
131 123 @Test
132   - public void testPagination(){
133   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
134   - PowerMock.replay(Beans.class);
135   -
136   - TypedQueryProxy<Client> proxy = getQueryProxy("select c from Client c",Client.class);
137   -
138   - proxy.setMaxResults(2);
139   - Assert.assertEquals(2, proxy.getMaxResults());
140   -
141   - proxy.setFirstResult(1);
142   - Assert.assertEquals(1, proxy.getFirstResult());
143   -
144   - List<?> result = proxy.getResultList();
145   - Assert.assertEquals(2, result.size());
  124 + public void testPagination() {
  125 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  126 + expect(queryDelegate.getMaxResults()).andReturn(4).times(2);
  127 + expect(queryDelegate.getFirstResult()).andReturn(2).times(2);
  128 + expect(queryDelegate.setMaxResults(EasyMock.anyInt())).andReturn(queryDelegate);
  129 + expect(queryDelegate.setFirstResult(EasyMock.anyInt())).andReturn(queryDelegate);
  130 + replay(queryDelegate);
  131 +
  132 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  133 + typedQueryProxy.setMaxResults(4);
  134 + typedQueryProxy.setFirstResult(2);
  135 + assertEquals(typedQueryProxy.getMaxResults(), queryDelegate.getMaxResults());
  136 + assertEquals(typedQueryProxy.getFirstResult(), queryDelegate.getFirstResult());
  137 +
  138 + verifyAll();
146 139 }
147   -
  140 +
  141 + @SuppressWarnings("unchecked")
148 142 @Test
149   - public void testHint(){
150   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(14);
151   - PowerMock.replay(Beans.class);
152   -
153   - //Consulta um cliente definindo a hint readOnly, que torna a entidade retornada não atualizável.
154   - manager.getTransaction().begin();
155   - TypedQueryProxy<Client> proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1");
156   - proxy.setHint("org.hibernate.readOnly", true);
157   - Assert.assertFalse( proxy.getHints().isEmpty() );
158   -
159   - //Tenta atualizar a entidade e limpar o cache de primeiro nível
160   - Client c = (Client)proxy.getSingleResult();
161   - c.setName("Cliente 1 Alterado");
162   - manager.flush();
163   - manager.getTransaction().commit();
164   - manager.clear();
165   -
166   - //Reconsultar a entidade tem que retornar 1 resultado, pois o nome "Cliente 1" não deve ter sido alterado.
167   - manager.getTransaction().begin();
168   - proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1");
169   - c = (Client)proxy.getSingleResult();
170   - Assert.assertNotNull(c);
171   -
172   - //Mudar a entidade agora tem que funcionar, pois não foi informado o hint
173   - c.setName("Cliente 1 Alterado");
174   - manager.flush();
175   - manager.getTransaction().commit();
176   - manager.clear();
177   -
178   - proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1");
179   -
180   - try{
181   - proxy.getSingleResult();
182   - Assert.fail();
183   - }
184   - catch(NoResultException ne){
185   - }
186   -
187   - PowerMock.verifyAll();
  143 + public void testHint() {
  144 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  145 + Map<String, Object> map = new HashMap<String, Object>();
  146 + Client client = new Client();
  147 + map.put("1", client);
  148 + expect(queryDelegate.getHints()).andReturn(map).times(2);
  149 + expect(queryDelegate.setHint(EasyMock.anyObject(String.class), EasyMock.anyObject())).andReturn(queryDelegate);
  150 + replay(queryDelegate);
  151 +
  152 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  153 + typedQueryProxy.setHint("1", client);
  154 + assertEquals(typedQueryProxy.getHints(), queryDelegate.getHints());
  155 +
  156 + verifyAll();
188 157 }
189   -
  158 +
  159 + @SuppressWarnings({ "unchecked", "unused" })
190 160 @Test
191   - public void testParameters(){
192   -
193   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(2);
194   - PowerMock.replay(Beans.class);
195   -
196   - TypedQueryProxy<Client> 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);
197   -
  161 + public void testParameters() {
  162 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
198 163 Date dateValue = new Date();
199   -
200   - proxy.setParameter("name", "Named Parameter");
201   - proxy.setParameter("dateName", dateValue, TemporalType.DATE);
202   -
203   - proxy.setParameter(1, "Cliente 1");
204   - proxy.setParameter(2, dateValue,TemporalType.DATE);
205   -
206   - Assert.assertEquals(proxy.getParameterValue("name"),"Named Parameter");
207   - Assert.assertEquals(proxy.getParameterValue(1), "Cliente 1");
208   -
209   - List<Client> result = proxy.getResultList();
210   -
211   - Assert.assertNotNull(result);
212   - Assert.assertFalse(result.isEmpty());
213   -
214   - PowerMock.verifyAll();
  164 + Calendar calendar = PowerMock.createMock(Calendar.class);
  165 + Class<Date> type = Date.class;
  166 + Parameter parameter = PowerMock.createMock(Parameter.class);
  167 +
  168 + expect(queryDelegate.setParameter(EasyMock.anyObject(String.class), EasyMock.anyObject(String.class)))
  169 + .andReturn(queryDelegate);
  170 + expect(queryDelegate.getParameterValue(EasyMock.anyObject(String.class))).andReturn("Named Parameter")
  171 + .anyTimes();
  172 + expect(queryDelegate.setParameter(EasyMock.anyInt(), EasyMock.anyObject(String.class)))
  173 + .andReturn(queryDelegate);
  174 + expect(queryDelegate.getParameterValue(EasyMock.anyInt())).andReturn("Client").anyTimes();
  175 + expect(
  176 + queryDelegate.setParameter(EasyMock.anyObject(String.class), EasyMock.anyObject(Date.class),
  177 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  178 + expect(
  179 + queryDelegate.setParameter(EasyMock.anyInt(), EasyMock.anyObject(Date.class),
  180 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  181 + expect(queryDelegate.setParameter(EasyMock.anyObject(Parameter.class), EasyMock.anyObject())).andReturn(
  182 + queryDelegate);
  183 + expect(queryDelegate.getParameterValue(EasyMock.anyObject(Parameter.class))).andReturn(parameter).anyTimes();
  184 + expect(
  185 + queryDelegate.setParameter(EasyMock.anyObject(String.class), EasyMock.anyObject(Calendar.class),
  186 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  187 + expect(
  188 + queryDelegate.setParameter(EasyMock.anyInt(), EasyMock.anyObject(Calendar.class),
  189 + EasyMock.anyObject(TemporalType.class))).andReturn(queryDelegate);
  190 +
  191 + replay(queryDelegate, parameter, calendar);
  192 +
  193 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  194 + typedQueryProxy.setParameter("name", "Named Parameter");
  195 + assertEquals(typedQueryProxy.getParameterValue("name"), queryDelegate.getParameterValue("name"));
  196 + typedQueryProxy.setParameter(1, "Client");
  197 + assertEquals(typedQueryProxy.getParameterValue("1"), queryDelegate.getParameterValue("1"));
  198 + typedQueryProxy.setParameter("dateName", dateValue, TemporalType.DATE);
  199 + typedQueryProxy.setParameter(2, dateValue, TemporalType.DATE);
  200 + typedQueryProxy.setParameter(parameter, "X");
  201 + typedQueryProxy.getParameterValue(parameter);
  202 + assertEquals(typedQueryProxy.getParameterValue(parameter), parameter);
  203 + typedQueryProxy.setParameter("dateName", calendar, TemporalType.DATE);
  204 + typedQueryProxy.setParameter(2, calendar, TemporalType.DATE);
  205 +
  206 + verifyAll();
  207 + }
  208 +
  209 + @SuppressWarnings("unchecked")
  210 + @Test
  211 + public void testIsBound() {
  212 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  213 + Parameter parameter = PowerMock.createMock(Parameter.class);
  214 + expect(queryDelegate.isBound(EasyMock.anyObject(Parameter.class))).andReturn(true);
  215 +
  216 + replay(queryDelegate, parameter);
  217 +
  218 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  219 + assertTrue(typedQueryProxy.isBound(parameter));
  220 +
  221 + verifyAll();
215 222 }
216   -
  223 +
  224 + @SuppressWarnings("unchecked")
217 225 @Test
218   - public void testFlushMode(){
219   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(3);
220   - PowerMock.replay(Beans.class);
221   -
222   - manager.getTransaction().begin();
223   - TypedQueryProxy<Client> proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1");
224   - proxy.setFlushMode(FlushModeType.COMMIT);
225   - Assert.assertEquals(proxy.getFlushMode(), FlushModeType.COMMIT);
226   - manager.getTransaction().commit();
227   -
228   - PowerMock.verifyAll();
  226 + public void testFlushMode() {
  227 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  228 + FlushModeType flushModeType = FlushModeType.AUTO;
  229 +
  230 + expect(queryDelegate.setFlushMode(FlushModeType.AUTO)).andReturn(queryDelegate);
  231 + expect(queryDelegate.getFlushMode()).andReturn(flushModeType).anyTimes();
  232 +
  233 + replay(queryDelegate);
  234 +
  235 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  236 + typedQueryProxy.setFlushMode(FlushModeType.AUTO);
  237 + assertEquals(typedQueryProxy.getFlushMode(), queryDelegate.getFlushMode());
  238 + verifyAll();
229 239 }
230   -
  240 +
  241 + @SuppressWarnings("unchecked")
231 242 @Test
232   - public void testLockMode(){
233   - EasyMock.expect(Beans.getReference(EntityManagerProducer.class)).andReturn(producer).times(3);
234   - PowerMock.replay(Beans.class);
235   -
236   - manager.getTransaction().begin();
237   - TypedQueryProxy<Client> proxy = getQueryProxy("select c from Client c where c.name=?1",Client.class,"Cliente 1");
238   - proxy.setLockMode(LockModeType.OPTIMISTIC);
239   - Assert.assertEquals(proxy.getLockMode(), LockModeType.OPTIMISTIC);
240   - manager.getTransaction().commit();
241   -
242   - PowerMock.verifyAll();
  243 + public void testLockMode() {
  244 + TypedQuery queryDelegate = PowerMock.createMock(TypedQuery.class);
  245 + LockModeType lockModeType = LockModeType.OPTIMISTIC;
  246 +
  247 + expect(queryDelegate.setLockMode(lockModeType)).andReturn(queryDelegate);
  248 + expect(queryDelegate.getLockMode()).andReturn(lockModeType).anyTimes();
  249 +
  250 + replay(queryDelegate);
  251 +
  252 + typedQueryProxy = new TypedQueryProxy(queryDelegate, (EntityManagerProxy) manager);
  253 + typedQueryProxy.setLockMode(lockModeType);
  254 + assertEquals(typedQueryProxy.getLockMode(), queryDelegate.getLockMode());
  255 + verifyAll();
243 256 }
  257 +
244 258 }
... ...