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 package br.gov.frameworkdemoiselle.internal.proxy; 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 import java.util.Collections; 47 import java.util.Collections;
4 import java.util.Date; 48 import java.util.Date;
5 import java.util.HashMap; 49 import java.util.HashMap;
@@ -10,15 +54,13 @@ import javax.persistence.EntityManager; @@ -10,15 +54,13 @@ import javax.persistence.EntityManager;
10 import javax.persistence.EntityManagerFactory; 54 import javax.persistence.EntityManagerFactory;
11 import javax.persistence.FlushModeType; 55 import javax.persistence.FlushModeType;
12 import javax.persistence.LockModeType; 56 import javax.persistence.LockModeType;
13 -import javax.persistence.NoResultException; 57 +import javax.persistence.Parameter;
14 import javax.persistence.Persistence; 58 import javax.persistence.Persistence;
15 import javax.persistence.Query; 59 import javax.persistence.Query;
16 import javax.persistence.TemporalType; 60 import javax.persistence.TemporalType;
17 61
18 import org.easymock.EasyMock; 62 import org.easymock.EasyMock;
19 -import org.junit.Assert;  
20 import org.junit.Before; 63 import org.junit.Before;
21 -import org.junit.Ignore;  
22 import org.junit.Test; 64 import org.junit.Test;
23 import org.junit.runner.RunWith; 65 import org.junit.runner.RunWith;
24 import org.powermock.api.easymock.PowerMock; 66 import org.powermock.api.easymock.PowerMock;
@@ -32,224 +74,221 @@ import br.gov.frameworkdemoiselle.util.Beans; @@ -32,224 +74,221 @@ import br.gov.frameworkdemoiselle.util.Beans;
32 74
33 /** 75 /**
34 * Test the proxied {@link Query} class, {@link QueryProxy}. 76 * Test the proxied {@link Query} class, {@link QueryProxy}.
  77 + *
35 * @author 81986912515 78 * @author 81986912515
36 - *  
37 */ 79 */
38 -@Ignore  
39 @RunWith(PowerMockRunner.class) 80 @RunWith(PowerMockRunner.class)
40 -@PrepareForTest({Beans.class}) 81 +@PrepareForTest({ Beans.class })
41 public class QueryProxyTest { 82 public class QueryProxyTest {
42 - 83 +
43 private EntityManager manager; 84 private EntityManager manager;
  85 +
44 private EntityManagerProducer producer; 86 private EntityManagerProducer producer;
45 - 87 +
  88 + private QueryProxy queryProxy;
  89 +
46 @Before 90 @Before
47 - public void setUp(){  
48 - 91 + public void setUp() {
  92 +
49 Map<String, Object> configOverrides = new HashMap<String, Object>(); 93 Map<String, Object> configOverrides = new HashMap<String, Object>();
50 configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence"); 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 configOverrides.put("hibernate.show_sql", "true"); 101 configOverrides.put("hibernate.show_sql", "true");
53 configOverrides.put("hibernate.hbm2ddl.auto", "create-drop"); 102 configOverrides.put("hibernate.hbm2ddl.auto", "create-drop");
54 - 103 +
55 EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides); 104 EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides);
56 EntityManager delegate = factory.createEntityManager(); 105 EntityManager delegate = factory.createEntityManager();
57 - 106 +
58 Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>()); 107 Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>());
59 cache.put("pu1", delegate); 108 cache.put("pu1", delegate);
60 - 109 +
61 producer = new EntityManagerProducer(); 110 producer = new EntityManagerProducer();
62 Whitebox.setInternalState(producer, "cache", cache); 111 Whitebox.setInternalState(producer, "cache", cache);
63 - 112 +
64 PowerMock.mockStatic(Beans.class); 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 PowerMock.replayAll(); 115 PowerMock.replayAll();
67 116
68 manager = new EntityManagerProxy("pu1"); 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 @Test 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 @Test 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 @Test 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 @Test 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 @Test 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 @Test 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 Date dateValue = new Date(); 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 @Test 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 @Test 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 package br.gov.frameworkdemoiselle.internal.proxy; 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 import java.util.Collections; 11 import java.util.Collections;
4 import java.util.Date; 12 import java.util.Date;
5 import java.util.HashMap; 13 import java.util.HashMap;
@@ -10,16 +18,14 @@ import javax.persistence.EntityManager; @@ -10,16 +18,14 @@ import javax.persistence.EntityManager;
10 import javax.persistence.EntityManagerFactory; 18 import javax.persistence.EntityManagerFactory;
11 import javax.persistence.FlushModeType; 19 import javax.persistence.FlushModeType;
12 import javax.persistence.LockModeType; 20 import javax.persistence.LockModeType;
13 -import javax.persistence.NoResultException; 21 +import javax.persistence.Parameter;
14 import javax.persistence.Persistence; 22 import javax.persistence.Persistence;
15 import javax.persistence.Query; 23 import javax.persistence.Query;
16 import javax.persistence.TemporalType; 24 import javax.persistence.TemporalType;
17 import javax.persistence.TypedQuery; 25 import javax.persistence.TypedQuery;
18 26
19 import org.easymock.EasyMock; 27 import org.easymock.EasyMock;
20 -import org.junit.Assert;  
21 import org.junit.Before; 28 import org.junit.Before;
22 -import org.junit.Ignore;  
23 import org.junit.Test; 29 import org.junit.Test;
24 import org.junit.runner.RunWith; 30 import org.junit.runner.RunWith;
25 import org.powermock.api.easymock.PowerMock; 31 import org.powermock.api.easymock.PowerMock;
@@ -33,212 +39,220 @@ import br.gov.frameworkdemoiselle.util.Beans; @@ -33,212 +39,220 @@ import br.gov.frameworkdemoiselle.util.Beans;
33 39
34 /** 40 /**
35 * Test the proxied {@link Query} class, {@link TypedQueryProxy}. 41 * Test the proxied {@link Query} class, {@link TypedQueryProxy}.
  42 + *
36 * @author 81986912515 43 * @author 81986912515
37 - * 44 + * @param <X>
38 */ 45 */
39 -@Ignore 46 +
  47 +@SuppressWarnings("rawtypes")
40 @RunWith(PowerMockRunner.class) 48 @RunWith(PowerMockRunner.class)
41 -@PrepareForTest({Beans.class}) 49 +@PrepareForTest({ Beans.class })
42 public class TypedQueryProxyTest { 50 public class TypedQueryProxyTest {
43 - 51 +
44 private EntityManager manager; 52 private EntityManager manager;
  53 +
45 private EntityManagerProducer producer; 54 private EntityManagerProducer producer;
46 - 55 +
  56 + private TypedQueryProxy typedQueryProxy;
  57 +
47 @Before 58 @Before
48 - public void setUp(){  
49 - 59 + public void setUp() {
  60 +
50 Map<String, Object> configOverrides = new HashMap<String, Object>(); 61 Map<String, Object> configOverrides = new HashMap<String, Object>();
51 configOverrides.put("javax.persistence.provider", "org.hibernate.ejb.HibernatePersistence"); 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 configOverrides.put("hibernate.show_sql", "true"); 69 configOverrides.put("hibernate.show_sql", "true");
54 configOverrides.put("hibernate.hbm2ddl.auto", "create-drop"); 70 configOverrides.put("hibernate.hbm2ddl.auto", "create-drop");
55 - 71 +
56 EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides); 72 EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu1", configOverrides);
57 EntityManager delegate = factory.createEntityManager(); 73 EntityManager delegate = factory.createEntityManager();
58 - 74 +
59 Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>()); 75 Map<String, EntityManager> cache = Collections.synchronizedMap(new HashMap<String, EntityManager>());
60 cache.put("pu1", delegate); 76 cache.put("pu1", delegate);
61 - 77 +
62 producer = new EntityManagerProducer(); 78 producer = new EntityManagerProducer();
63 Whitebox.setInternalState(producer, "cache", cache); 79 Whitebox.setInternalState(producer, "cache", cache);
64 - 80 +
65 PowerMock.mockStatic(Beans.class); 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 PowerMock.replayAll(); 83 PowerMock.replayAll();
68 84
69 manager = new EntityManagerProxy("pu1"); 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 @Test 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 @Test 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 @Test 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 @Test 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 @Test 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 Date dateValue = new Date(); 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 @Test 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 @Test 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 }