demoiselle / framework

Browse Code »

Commit 0cc2807702b0cccd2d252fab8087355166f34a23

Authored by Ednara Oliveira 2012-09-10 14:40:56 -0300

1 parent c9c67673

Exists in master

Refatoração dos testes unitários

Showing 3 changed files with 1056 additions and 1056 deletions Show diff stats

impl/core/src/test/java/br/gov/frameworkdemoiselle/internal/interceptor/ExceptionHandlerInterceptorTest.java

Diff comments View file @0cc2807

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	-// */
37	-//package br.gov.frameworkdemoiselle.internal.interceptor;
38	-//
39	-//import static org.easymock.EasyMock.expect;
40	-//import static org.easymock.EasyMock.verify;
41	-//import static org.junit.Assert.assertEquals;
42	-//import static org.junit.Assert.assertNull;
43	-//import static org.junit.Assert.assertTrue;
44	-//import static org.junit.Assert.fail;
45	-//import static org.powermock.api.easymock.PowerMock.mockStatic;
46	-//import static org.powermock.api.easymock.PowerMock.replay;
47	-//import static org.powermock.api.easymock.PowerMock.replayAll;
48	-//import static org.powermock.api.easymock.PowerMock.verifyAll;
49	-//
50	-//import java.util.Locale;
51	-//
52	-//import javax.interceptor.InvocationContext;
53	-//
54	-//import org.easymock.EasyMock;
55	-//import org.junit.Before;
56	-//import org.junit.Test;
57	-//import org.junit.runner.RunWith;
58	-//import org.powermock.api.easymock.PowerMock;
59	-//import org.powermock.core.classloader.annotations.PrepareForTest;
60	-//import org.powermock.modules.junit4.PowerMockRunner;
61	-//import org.slf4j.Logger;
62	-//
63	-//import br.gov.frameworkdemoiselle.DemoiselleException;
64	-//import br.gov.frameworkdemoiselle.exception.ExceptionHandler;
65	-//import br.gov.frameworkdemoiselle.internal.bootstrap.CoreBootstrap;
66	-//import br.gov.frameworkdemoiselle.util.ResourceBundle;
67	-//
68	-//@RunWith(PowerMockRunner.class)
69	-//@PrepareForTest(CoreBootstrap.class)
70	-//public class ExceptionHandlerInterceptorTest {
71	-//
72	-// private ExceptionHandlerInterceptor interceptor;
73	-//
74	-// private InvocationContext context;
75	-//
76	-// private Logger logger;
77	-//
78	-// private ResourceBundle bundle;
79	-//
80	-// class TestException extends DemoiselleException {
81	-//
82	-// private static final long serialVersionUID = 1L;
83	-//
84	-// public TestException(String message) {
85	-// super(message);
86	-// }
87	-// }
88	-//
89	-// class ClassWithMethodsAnnotatedWithExceptionHandler {
90	-//
91	-// int times = 0;
92	-//
93	-// @ExceptionHandler
94	-// public void methodWithExceptionHandlerAnotation(DemoiselleException cause) {
95	-// times++;
96	-// }
97	-//
98	-// @ExceptionHandler
99	-// public void methodWithExceptionHandlerAnotationAndGenericException(Exception cause) {
100	-// times++;
101	-// }
102	-//
103	-// }
104	-//
105	-// class ClassWithoutMethodsAnnotatedWithExceptionHandler {
106	-//
107	-// public void methodWithoutExceptionHandlerAnotation(DemoiselleException cause) {
108	-// }
109	-// }
110	-//
111	-// class ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException {
112	-//
113	-// int times = 0;
114	-//
115	-// @ExceptionHandler
116	-// public void methodWithExceptionHandlerAnotation(DemoiselleException cause) {
117	-// times++;
118	-// throw new RuntimeException();
119	-// }
120	-// }
121	-//
122	-// class ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler {
123	-//
124	-// @ExceptionHandler
125	-// public void methodWithExceptionHandlerAnotation() {
126	-// }
127	-//
128	-// }
129	-//
130	-// class ClassWithExceptionHandlerMethodThatRethrowException {
131	-//
132	-// int times = 0;
133	-//
134	-// @ExceptionHandler
135	-// public void methodThatRethrowException(TestException cause) {
136	-// times++;
137	-// throw cause;
138	-// }
139	-//
140	-// }
141	-//
142	-// @Before
143	-// public void setUp() throws Exception {
144	-// this.logger = PowerMock.createMock(Logger.class);
145	-// this.bundle = new ResourceBundle("demoiselle-core-bundle", Locale.getDefault());
146	-// this.logger.info(EasyMock.anyObject(String.class));
147	-// PowerMock.expectLastCall().anyTimes();
148	-// replay(this.logger);
149	-// this.interceptor = new ExceptionHandlerInterceptor(this.logger, this.bundle);
150	-// this.context = PowerMock.createMock(InvocationContext.class);
151	-// mockStatic(CoreBootstrap.class);
152	-// }
153	-//
154	-// @Test
155	-// public void manageSuccessfully() throws Throwable {
156	-// expect(this.context.proceed()).andReturn(null);
157	-// replay();
158	-// assertEquals(null, this.interceptor.manage(this.context));
159	-// verify();
160	-// }
161	-//
162	-// @Test
163	-// public void manageWithClassThatDoesNotContainHandleMethod() throws Exception {
164	-// ClassWithoutMethodsAnnotatedWithExceptionHandler classWithoutException = new ClassWithoutMethodsAnnotatedWithExceptionHandler();
165	-// expect(this.context.getTarget()).andReturn(classWithoutException);
166	-// expect(this.context.proceed()).andThrow(new DemoiselleException(""));
167	-// expect(CoreBootstrap.isAnnotatedType(ClassWithoutMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
168	-// replayAll(this.context, ClassWithoutMethodsAnnotatedWithExceptionHandler.class);
169	-//
170	-// try {
171	-// this.interceptor.manage(this.context);
172	-// fail();
173	-// } catch (DemoiselleException e) {
174	-// assertTrue(true);
175	-// }
176	-//
177	-// verifyAll();
178	-// }
179	-//
180	-// @Test
181	-// public void manageWithClassThatContainsHandleMethod() throws Exception {
182	-// ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
183	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
184	-// expect(this.context.proceed()).andThrow(new DemoiselleException(""));
185	-// expect(CoreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
186	-// replayAll(this.context, CoreBootstrap.class);
187	-//
188	-// assertNull(this.interceptor.manage(this.context));
189	-// assertEquals(1, classWithException.times);
190	-// verifyAll();
191	-// }
192	-//
193	-// @Test
194	-// public void manageWithClassThatContainsParentExceptionHandleMethod() throws Exception {
195	-// ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
196	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
197	-// expect(this.context.proceed()).andThrow(new DemoiselleException(""));
198	-// expect(CoreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
199	-// replayAll(this.context, CoreBootstrap.class);
200	-//
201	-// assertNull(this.interceptor.manage(this.context));
202	-// assertEquals(1, classWithException.times);
203	-// verifyAll();
204	-// }
205	-//
206	-// @Test
207	-// public void manageWithClassThatContainsHandleMethodWithDiferentException() throws Exception {
208	-// ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
209	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
210	-// expect(this.context.proceed()).andThrow(new TestException(""));
211	-// replay(this.context);
212	-// expect(CoreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
213	-// replayAll(this.context, CoreBootstrap.class);
214	-//
215	-// try {
216	-// this.interceptor.manage(this.context);
217	-// fail();
218	-// } catch (TestException e) {
219	-// assertEquals(0, classWithException.times);
220	-// }
221	-//
222	-// verify();
223	-// }
224	-//
225	-// @Test
226	-// public void manageWithClassThatContainsHandleMethodThatThrowsAnotherException() throws Exception {
227	-// ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException classWithException = new ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException();
228	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
229	-// expect(this.context.proceed()).andThrow(new DemoiselleException(""));
230	-// expect(CoreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException.class))
231	-// .andReturn(true);
232	-// replayAll(this.context, CoreBootstrap.class);
233	-//
234	-// try {
235	-// this.interceptor.manage(this.context);
236	-// fail();
237	-// } catch (RuntimeException e) {
238	-// assertEquals(1, classWithException.times);
239	-// }
240	-//
241	-// verifyAll();
242	-// }
243	-//
244	-// @Test
245	-// public void manageWithClassThatContainsHandleMethodsAndIsInvokedTwice() throws Exception {
246	-// ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
247	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
248	-// expect(this.context.proceed()).andThrow(new DemoiselleException(""));
249	-// expect(CoreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true)
250	-// .anyTimes();
251	-// replayAll(this.context, CoreBootstrap.class);
252	-//
253	-// assertNull(this.interceptor.manage(this.context));
254	-// assertEquals(1, classWithException.times);
255	-//
256	-// this.context = PowerMock.createMock(InvocationContext.class);
257	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
258	-// expect(this.context.proceed()).andThrow(new Exception(""));
259	-// replayAll(this.context, CoreBootstrap.class);
260	-//
261	-// assertNull(this.interceptor.manage(this.context));
262	-// assertEquals(2, classWithException.times);
263	-// verifyAll();
264	-//
265	-// }
266	-//
267	-// @Test
268	-// public void manageWithClassThatContainsHandleMethodWithoutParameter() throws Exception {
269	-// ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler classWithException = new ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler();
270	-// expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
271	-// expect(this.context.proceed()).andThrow(new DemoiselleException(""));
272	-// expect(CoreBootstrap.isAnnotatedType(ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler.class))
273	-// .andReturn(true);
274	-// replayAll(this.context, CoreBootstrap.class);
275	-//
276	-// try {
277	-// this.interceptor.manage(this.context);
278	-// fail();
279	-// } catch (DemoiselleException e) {
280	-// assertTrue(true);
281	-// }
282	-//
283	-// verifyAll();
284	-// }
285	-//
286	-// @Test
287	-// public void manageHandlerMethodThatRethrowExpectedException() throws Exception {
288	-// ClassWithExceptionHandlerMethodThatRethrowException testClass = new ClassWithExceptionHandlerMethodThatRethrowException();
289	-// expect(this.context.getTarget()).andReturn(testClass).anyTimes();
290	-// expect(this.context.proceed()).andThrow(new TestException(""));
291	-// expect(CoreBootstrap.isAnnotatedType(ClassWithExceptionHandlerMethodThatRethrowException.class))
292	-// .andReturn(true);
293	-// replayAll(this.context, CoreBootstrap.class);
294	-//
295	-// try {
296	-// this.interceptor.manage(this.context);
297	-// fail();
298	-// } catch (TestException e) {
299	-// assertEquals(1, testClass.times);
300	-// }
301	-//
302	-// verifyAll();
303	-// }
304	-//
305	-// /**
306	-// * Tests an exception handler when the class that contains the method is a proxy. This is the case when using
307	-// * injection.
308	-// *
309	-// * @throws Exception
310	-// */
311	-// @Test
312	-// public void manageHandlerMethodInsideProxyClass() throws Exception {
313	-// // creates a proxy class
314	-// ClassWithExceptionHandlerMethodThatRethrowException testClass = PowerMock
315	-// .createNicePartialMockForAllMethodsExcept(ClassWithExceptionHandlerMethodThatRethrowException.class,
316	-// "methodThatRethrowException");
317	-// expect(this.context.getTarget()).andReturn(testClass).anyTimes();
318	-// expect(this.context.proceed()).andThrow(new TestException(""));
319	-// expect(CoreBootstrap.isAnnotatedType(testClass.getClass())).andReturn(false);
320	-//
321	-// this.logger = PowerMock.createMock(Logger.class);
322	-// this.logger.info(EasyMock.anyObject(String.class));
323	-// this.logger.debug(EasyMock.anyObject(String.class));
324	-// replayAll(testClass, this.context, CoreBootstrap.class, logger);
325	-//
326	-// this.interceptor = new ExceptionHandlerInterceptor(this.logger, this.bundle);
327	-//
328	-// try {
329	-// this.interceptor.manage(this.context);
330	-// fail();
331	-// } catch (TestException e) {
332	-// assertEquals(1, testClass.times);
333	-// }
334	-// }
335	-//
336	-//}	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	+ */
		37	+package br.gov.frameworkdemoiselle.internal.interceptor;
		38	+
		39	+import static org.easymock.EasyMock.expect;
		40	+import static org.easymock.EasyMock.verify;
		41	+import static org.junit.Assert.assertEquals;
		42	+import static org.junit.Assert.assertNull;
		43	+import static org.junit.Assert.assertTrue;
		44	+import static org.junit.Assert.fail;
		45	+import static org.powermock.api.easymock.PowerMock.mockStatic;
		46	+import static org.powermock.api.easymock.PowerMock.replay;
		47	+import static org.powermock.api.easymock.PowerMock.replayAll;
		48	+import static org.powermock.api.easymock.PowerMock.verifyAll;
		49	+
		50	+import java.util.Locale;
		51	+
		52	+import javax.interceptor.InvocationContext;
		53	+
		54	+import org.easymock.EasyMock;
		55	+import org.junit.Before;
		56	+import org.junit.Test;
		57	+import org.junit.runner.RunWith;
		58	+import org.powermock.api.easymock.PowerMock;
		59	+import org.powermock.core.classloader.annotations.PrepareForTest;
		60	+import org.powermock.modules.junit4.PowerMockRunner;
		61	+import org.slf4j.Logger;
		62	+
		63	+import br.gov.frameworkdemoiselle.DemoiselleException;
		64	+import br.gov.frameworkdemoiselle.exception.ExceptionHandler;
		65	+import br.gov.frameworkdemoiselle.internal.bootstrap.CoreBootstrap;
		66	+import br.gov.frameworkdemoiselle.util.Beans;
		67	+import br.gov.frameworkdemoiselle.util.ResourceBundle;
		68	+
		69	+@RunWith(PowerMockRunner.class)
		70	+@PrepareForTest(Beans.class)
		71	+public class ExceptionHandlerInterceptorTest {
		72	+
		73	+ private ExceptionHandlerInterceptor interceptor;
		74	+
		75	+ private InvocationContext context;
		76	+
		77	+ private Logger logger;
		78	+
		79	+ private CoreBootstrap coreBootstrap;
		80	+
		81	+ class TestException extends DemoiselleException {
		82	+
		83	+ private static final long serialVersionUID = 1L;
		84	+
		85	+ public TestException(String message) {
		86	+ super(message);
		87	+ }
		88	+ }
		89	+
		90	+ class ClassWithMethodsAnnotatedWithExceptionHandler {
		91	+
		92	+ int times = 0;
		93	+
		94	+ @ExceptionHandler
		95	+ public void methodWithExceptionHandlerAnotation(DemoiselleException cause) {
		96	+ times++;
		97	+ }
		98	+
		99	+ @ExceptionHandler
		100	+ public void methodWithExceptionHandlerAnotationAndGenericException(Exception cause) {
		101	+ times++;
		102	+ }
		103	+
		104	+ }
		105	+
		106	+ class ClassWithoutMethodsAnnotatedWithExceptionHandler {
		107	+
		108	+ public void methodWithoutExceptionHandlerAnotation(DemoiselleException cause) {
		109	+ }
		110	+ }
		111	+
		112	+ class ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException {
		113	+
		114	+ int times = 0;
		115	+
		116	+ @ExceptionHandler
		117	+ public void methodWithExceptionHandlerAnotation(DemoiselleException cause) {
		118	+ times++;
		119	+ throw new RuntimeException();
		120	+ }
		121	+ }
		122	+
		123	+ class ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler {
		124	+
		125	+ @ExceptionHandler
		126	+ public void methodWithExceptionHandlerAnotation() {
		127	+ }
		128	+
		129	+ }
		130	+
		131	+ class ClassWithExceptionHandlerMethodThatRethrowException {
		132	+
		133	+ int times = 0;
		134	+
		135	+ @ExceptionHandler
		136	+ public void methodThatRethrowException(TestException cause) {
		137	+ times++;
		138	+ throw cause;
		139	+ }
		140	+
		141	+ }
		142	+
		143	+ @Before
		144	+ public void setUp() throws Exception {
		145	+
		146	+ this.interceptor = new ExceptionHandlerInterceptor();
		147	+ this.context = PowerMock.createMock(InvocationContext.class);
		148	+ this.coreBootstrap = PowerMock.createMock(CoreBootstrap.class);
		149	+
		150	+ mockStatic(Beans.class);
		151	+ expect(Beans.getReference(Locale.class)).andReturn(Locale.getDefault()).anyTimes();
		152	+ expect(Beans.getReference(CoreBootstrap.class)).andReturn(this.coreBootstrap).anyTimes();
		153	+
		154	+ }
		155	+
		156	+ @Test
		157	+ public void manageSuccessfully() throws Throwable {
		158	+ expect(this.context.proceed()).andReturn(null);
		159	+ replayAll();
		160	+ assertEquals(null, this.interceptor.manage(this.context));
		161	+ verify();
		162	+ }
		163	+
		164	+ @Test
		165	+ public void manageWithClassThatDoesNotContainHandleMethod() throws Exception {
		166	+ ClassWithoutMethodsAnnotatedWithExceptionHandler classWithoutException = new ClassWithoutMethodsAnnotatedWithExceptionHandler();
		167	+
		168	+ expect(this.context.getTarget()).andReturn(classWithoutException);
		169	+ expect(this.context.proceed()).andThrow(new DemoiselleException(""));
		170	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithoutMethodsAnnotatedWithExceptionHandler.class)).andReturn(
		171	+ true);
		172	+
		173	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		174	+
		175	+ try {
		176	+ this.interceptor.manage(this.context);
		177	+ fail();
		178	+ } catch (DemoiselleException e) {
		179	+ assertTrue(true);
		180	+ }
		181	+
		182	+ verifyAll();
		183	+ }
		184	+
		185	+ @Test
		186	+ public void manageWithClassThatContainsHandleMethod() throws Exception {
		187	+ ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
		188	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		189	+ expect(this.context.proceed()).andThrow(new DemoiselleException(""));
		190	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
		191	+
		192	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		193	+
		194	+ assertNull(this.interceptor.manage(this.context));
		195	+ assertEquals(1, classWithException.times);
		196	+ verifyAll();
		197	+ }
		198	+
		199	+ @Test
		200	+ public void manageWithClassThatContainsParentExceptionHandleMethod() throws Exception {
		201	+ ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
		202	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		203	+ expect(this.context.proceed()).andThrow(new DemoiselleException(""));
		204	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
		205	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		206	+
		207	+ assertNull(this.interceptor.manage(this.context));
		208	+ assertEquals(1, classWithException.times);
		209	+ verifyAll();
		210	+ }
		211	+
		212	+ @Test
		213	+ public void manageWithClassThatContainsHandleMethodWithDiferentException() throws Exception {
		214	+ ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
		215	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		216	+ expect(this.context.proceed()).andThrow(new TestException(""));
		217	+ replay(this.context);
		218	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true);
		219	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		220	+
		221	+ try {
		222	+ this.interceptor.manage(this.context);
		223	+ fail();
		224	+ } catch (TestException e) {
		225	+ assertEquals(0, classWithException.times);
		226	+ }
		227	+
		228	+ verify();
		229	+ }
		230	+
		231	+ @Test
		232	+ public void manageWithClassThatContainsHandleMethodThatThrowsAnotherException() throws Exception {
		233	+ ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException classWithException = new ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException();
		234	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		235	+ expect(this.context.proceed()).andThrow(new DemoiselleException(""));
		236	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandlerAndThrowException.class))
		237	+ .andReturn(true);
		238	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		239	+
		240	+ try {
		241	+ this.interceptor.manage(this.context);
		242	+ fail();
		243	+ } catch (RuntimeException e) {
		244	+ assertEquals(1, classWithException.times);
		245	+ }
		246	+
		247	+ verifyAll();
		248	+ }
		249	+
		250	+ @Test
		251	+ public void manageWithClassThatContainsHandleMethodsAndIsInvokedTwice() throws Exception {
		252	+ ClassWithMethodsAnnotatedWithExceptionHandler classWithException = new ClassWithMethodsAnnotatedWithExceptionHandler();
		253	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		254	+ expect(this.context.proceed()).andThrow(new DemoiselleException(""));
		255	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithMethodsAnnotatedWithExceptionHandler.class)).andReturn(true)
		256	+ .anyTimes();
		257	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		258	+
		259	+ assertNull(this.interceptor.manage(this.context));
		260	+ assertEquals(1, classWithException.times);
		261	+
		262	+ this.context = PowerMock.createMock(InvocationContext.class);
		263	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		264	+ expect(this.context.proceed()).andThrow(new Exception(""));
		265	+ replayAll(this.context);
		266	+
		267	+ assertNull(this.interceptor.manage(this.context));
		268	+ assertEquals(2, classWithException.times);
		269	+ verifyAll();
		270	+
		271	+ }
		272	+
		273	+ @Test
		274	+ public void manageWithClassThatContainsHandleMethodWithoutParameter() throws Exception {
		275	+ ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler classWithException = new ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler();
		276	+ expect(this.context.getTarget()).andReturn(classWithException).anyTimes();
		277	+ expect(this.context.proceed()).andThrow(new DemoiselleException(""));
		278	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithMethodWithoutParameterAnnotatedWithExceptionHandler.class))
		279	+ .andReturn(true);
		280	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		281	+
		282	+ try {
		283	+ this.interceptor.manage(this.context);
		284	+ fail();
		285	+ } catch (DemoiselleException e) {
		286	+ assertTrue(true);
		287	+ }
		288	+
		289	+ verifyAll();
		290	+ }
		291	+
		292	+ @Test
		293	+ public void manageHandlerMethodThatRethrowExpectedException() throws Exception {
		294	+ ClassWithExceptionHandlerMethodThatRethrowException testClass = new ClassWithExceptionHandlerMethodThatRethrowException();
		295	+ expect(this.context.getTarget()).andReturn(testClass).anyTimes();
		296	+ expect(this.context.proceed()).andThrow(new TestException(""));
		297	+ expect(this.coreBootstrap.isAnnotatedType(ClassWithExceptionHandlerMethodThatRethrowException.class))
		298	+ .andReturn(true);
		299	+ replayAll(this.context, this.coreBootstrap, Beans.class);
		300	+
		301	+ try {
		302	+ this.interceptor.manage(this.context);
		303	+ fail();
		304	+ } catch (TestException e) {
		305	+ assertEquals(1, testClass.times);
		306	+ }
		307	+
		308	+ verifyAll();
		309	+ }
		310	+
		311	+ /**
		312	+ * Tests an exception handler when the class that contains the method is a proxy. This is the case when using
		313	+ * injection.
		314	+ *
		315	+ * @throws Exception
		316	+ */
		317	+ @Test
		318	+ public void manageHandlerMethodInsideProxyClass() throws Exception {
		319	+ // creates a proxy class
		320	+ ClassWithExceptionHandlerMethodThatRethrowException testClass = PowerMock
		321	+ .createNicePartialMockForAllMethodsExcept(ClassWithExceptionHandlerMethodThatRethrowException.class,
		322	+ "methodThatRethrowException");
		323	+ expect(this.context.getTarget()).andReturn(testClass).anyTimes();
		324	+ expect(this.context.proceed()).andThrow(new TestException(""));
		325	+ expect(this.coreBootstrap.isAnnotatedType(testClass.getClass())).andReturn(false);
		326	+
		327	+ this.logger = PowerMock.createMock(Logger.class);
		328	+ this.logger.info(EasyMock.anyObject(String.class));
		329	+ this.logger.debug(EasyMock.anyObject(String.class));
		330	+ replayAll(testClass, this.context, this.coreBootstrap, logger, Beans.class);
		331	+
		332	+ this.interceptor = new ExceptionHandlerInterceptor();
		333	+
		334	+ try {
		335	+ this.interceptor.manage(this.context);
		336	+ fail();
		337	+ } catch (TestException e) {
		338	+ assertEquals(1, testClass.times);
		339	+ }
		340	+ }
		341	+
		342	+}

impl/core/src/test/java/br/gov/frameworkdemoiselle/internal/interceptor/RequiredPermissionInterceptorTest.java

Diff comments View file @0cc2807

1	-//package br.gov.frameworkdemoiselle.internal.interceptor;
2	-//
3	-//import static org.easymock.EasyMock.createMock;
4	-//import static org.easymock.EasyMock.expect;
5	-//import static org.easymock.EasyMock.expectLastCall;
6	-//import static org.junit.Assert.fail;
7	-//import static org.powermock.api.easymock.PowerMock.mockStatic;
8	-//import static org.powermock.api.easymock.PowerMock.replay;
9	-//
10	-//import java.util.Locale;
11	-//
12	-//import javax.enterprise.inject.Instance;
13	-//import javax.interceptor.InvocationContext;
14	-//
15	-//import org.junit.Before;
16	-//import org.junit.Test;
17	-//import org.junit.runner.RunWith;
18	-//import org.powermock.core.classloader.annotations.PrepareForTest;
19	-//import org.powermock.modules.junit4.PowerMockRunner;
20	-//import org.slf4j.Logger;
21	-//
22	-//import br.gov.frameworkdemoiselle.annotation.Name;
23	-//import br.gov.frameworkdemoiselle.internal.implementation.CoreBundle;
24	-//import br.gov.frameworkdemoiselle.security.NotLoggedInException;
25	-//import br.gov.frameworkdemoiselle.security.RequiredPermission;
26	-//import br.gov.frameworkdemoiselle.security.SecurityContext;
27	-//import br.gov.frameworkdemoiselle.security.SecurityException;
28	-//import br.gov.frameworkdemoiselle.security.User;
29	-//import br.gov.frameworkdemoiselle.util.ResourceBundle;
30	-//
31	-//@RunWith(PowerMockRunner.class)
32	-//@PrepareForTest(CoreBundle.class)
33	-//public class RequiredPermissionInterceptorTest {
34	-//
35	-// private RequiredPermissionInterceptor interceptor;
36	-//
37	-// private InvocationContext ic;
38	-//
39	-// private SecurityContext securityContext;
40	-//
41	-// class UnnamedClass {
42	-//
43	-// @RequiredPermission
44	-// public void requiredPermissionWithoutDeclaredResourceAndOperation() {
45	-// }
46	-//
47	-// @RequiredPermission(operation = "insert")
48	-// public void requiredPermissionWithDeclaredOperation() {
49	-// }
50	-//
51	-// @RequiredPermission(resource = "contact")
52	-// public void requiredPermissionWithDeclaredResource() {
53	-// }
54	-//
55	-// @RequiredPermission(resource = "contact", operation = "insert")
56	-// public void requiredPermissionWithDeclaredResourceAndOperation() {
57	-// }
58	-// }
59	-//
60	-// @Name("contact2")
61	-// class NamedClass {
62	-//
63	-// @RequiredPermission
64	-// public void requiredPermissionWithoutDeclaredResourceAndOperation() {
65	-// }
66	-//
67	-// @RequiredPermission(operation = "insert")
68	-// public void requiredPermissionWithDeclaredOperation() {
69	-// }
70	-//
71	-// @RequiredPermission(resource = "contact")
72	-// public void requiredPermissionWithDeclaredResource() {
73	-// }
74	-//
75	-// @RequiredPermission(resource = "contact", operation = "insert")
76	-// public void requiredPermissionWithDeclaredResourceAndOperation() {
77	-// }
78	-// }
79	-//
80	-// @Name("contact2")
81	-// class NamedClassWithNamedMethods {
82	-//
83	-// @Name("delete")
84	-// @RequiredPermission
85	-// public void requiredPermissionWithoutDeclaredResourceAndOperation() {
86	-// }
87	-//
88	-// @Name("delete")
89	-// @RequiredPermission(operation = "insert")
90	-// public void requiredPermissionWithDeclaredOperation() {
91	-// }
92	-//
93	-// @Name("delete")
94	-// @RequiredPermission(resource = "contact")
95	-// public void requiredPermissionWithDeclaredResource() {
96	-// }
97	-//
98	-// @Name("delete")
99	-// @RequiredPermission(resource = "contact", operation = "insert")
100	-// public void requiredPermissionWithDeclaredResourceAndOperation() {
101	-// }
102	-// }
103	-//
104	-// @RequiredPermission
105	-// class ClassAnnotedWithRequiredPermission {
106	-//
107	-// public void withoutRequiredPermissionAnnotation() {
108	-// }
109	-//
110	-// @RequiredPermission(operation = "insert")
111	-// public void requiredPermissionWithDeclaredOperation() {
112	-// }
113	-// }
114	-//
115	-// @Before
116	-// public void setUp() throws Exception {
117	-// @SuppressWarnings("unchecked")
118	-// Instance<SecurityContext> securityContextInstance = createMock(Instance.class);
119	-// Logger logger = createMock(Logger.class);
120	-//
121	-// ResourceBundle bundle = new ResourceBundle("demoiselle-core-bundle", Locale.getDefault());
122	-// User user = createMock(User.class);
123	-//
124	-// mockStatic(CoreBundle.class);
125	-// expect(CoreBundle.get()).andReturn(bundle);
126	-//
127	-// this.securityContext = createMock(SecurityContext.class);
128	-// this.ic = createMock(InvocationContext.class);
129	-//
130	-// expect(user.getId()).andReturn("UserName").anyTimes();
131	-// expect(this.securityContext.getUser()).andReturn(user).anyTimes();
132	-// expect(securityContextInstance.get()).andReturn(securityContext).anyTimes();
133	-// expect(this.ic.proceed()).andReturn(null);
134	-// replay(securityContextInstance, user, CoreBundle.class);
135	-//
136	-// this.interceptor = new RequiredPermissionInterceptor(securityContextInstance, bundle, logger);
137	-// }
138	-//
139	-// private void prepareMock(Object target, String methodName, String expectedResource, String expectedOperation,
140	-// boolean hasPermission, boolean isLoggedUser) throws Exception {
141	-//
142	-// expect(this.securityContext.isLoggedIn()).andReturn(isLoggedUser).anyTimes();
143	-//
144	-// this.securityContext.hasPermission(expectedResource, expectedOperation);
145	-//
146	-// if (isLoggedUser) {
147	-// expectLastCall().andReturn(hasPermission);
148	-// } else {
149	-// expectLastCall().andThrow(new NotLoggedInException(""));
150	-// }
151	-//
152	-// expect(this.ic.getTarget()).andReturn(target).anyTimes();
153	-// expect(this.ic.getMethod()).andReturn(target.getClass().getMethod(methodName)).anyTimes();
154	-// replay(this.ic, this.securityContext);
155	-// }
156	-//
157	-// /* Testing UnnamedClass */
158	-//
159	-// @Test
160	-// public void testManageUnnamedClassAtRequiredPermissionWithoutDeclaredResourceAndOperationMethod() throws Exception {
161	-// try {
162	-// Object target = new UnnamedClass();
163	-// String methodName = "requiredPermissionWithoutDeclaredResourceAndOperation";
164	-// String expectedResource = target.getClass().getSimpleName();
165	-// String expectedOperation = methodName;
166	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
167	-//
168	-// interceptor.manage(this.ic);
169	-// } catch (SecurityException cause) {
170	-// fail();
171	-// }
172	-// }
173	-//
174	-// @Test
175	-// public void testManageUnnamedClassAtRequiredPermissionWithDeclaredOperationMethod() throws Exception {
176	-// try {
177	-// Object target = new UnnamedClass();
178	-// String methodName = "requiredPermissionWithDeclaredOperation";
179	-// String expectedResource = target.getClass().getSimpleName();
180	-// String expectedOperation = "insert";
181	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
182	-//
183	-// interceptor.manage(this.ic);
184	-// } catch (SecurityException cause) {
185	-// fail();
186	-// }
187	-// }
188	-//
189	-// @Test
190	-// public void testManageUnnamedClassAtRequiredPermissionWithDeclaredResourceMethod() throws Exception {
191	-// try {
192	-// Object target = new UnnamedClass();
193	-// String methodName = "requiredPermissionWithDeclaredResource";
194	-// String expectedResource = "contact";
195	-// String expectedOperation = methodName;
196	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
197	-//
198	-// interceptor.manage(this.ic);
199	-// } catch (SecurityException cause) {
200	-// fail();
201	-// }
202	-// }
203	-//
204	-// @Test
205	-// public void testManageUnnamedClassAtRequiredPermissionWithDeclaredResourceAndOperation() throws Exception {
206	-// try {
207	-// Object target = new UnnamedClass();
208	-// String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
209	-// String expectedResource = "contact";
210	-// String expectedOperation = "insert";
211	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
212	-//
213	-// interceptor.manage(this.ic);
214	-// } catch (SecurityException cause) {
215	-// fail();
216	-// }
217	-// }
218	-//
219	-// /* Testing NamedClass */
220	-//
221	-// @Test
222	-// public void testManageNamedClassAtRequiredPermissionWithoutDeclaredResourceAndOperationMethod() throws Exception {
223	-// try {
224	-// Object target = new NamedClass();
225	-// String methodName = "requiredPermissionWithoutDeclaredResourceAndOperation";
226	-// String expectedResource = "contact2";
227	-// String expectedOperation = methodName;
228	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
229	-//
230	-// interceptor.manage(this.ic);
231	-// } catch (SecurityException cause) {
232	-// fail();
233	-// }
234	-// }
235	-//
236	-// @Test
237	-// public void testManageNamedClassAtRequiredPermissionWithDeclaredOperationMethod() throws Exception {
238	-// try {
239	-// Object target = new NamedClass();
240	-// String methodName = "requiredPermissionWithDeclaredOperation";
241	-// String expectedResource = "contact2";
242	-// String expectedOperation = "insert";
243	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
244	-//
245	-// interceptor.manage(this.ic);
246	-// } catch (SecurityException cause) {
247	-// fail();
248	-// }
249	-// }
250	-//
251	-// @Test
252	-// public void testManageNamedClassAtRequiredPermissionWithDeclaredResourceMethod() throws Exception {
253	-// try {
254	-// Object target = new NamedClass();
255	-// String methodName = "requiredPermissionWithDeclaredResource";
256	-// String expectedResource = "contact";
257	-// String expectedOperation = methodName;
258	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
259	-//
260	-// interceptor.manage(this.ic);
261	-// } catch (SecurityException cause) {
262	-// fail();
263	-// }
264	-// }
265	-//
266	-// @Test
267	-// public void testManageNamedClassAtRequiredPermissionWithDeclaredResourceAndOperation() throws Exception {
268	-// try {
269	-// Object target = new NamedClass();
270	-// String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
271	-// String expectedResource = "contact";
272	-// String expectedOperation = "insert";
273	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
274	-//
275	-// interceptor.manage(this.ic);
276	-// } catch (SecurityException cause) {
277	-// fail();
278	-// }
279	-// }
280	-//
281	-// /* Testing NamedClassWithNamedMethods */
282	-//
283	-// @Test
284	-// public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithoutDeclaredResourceAndOperationMethod()
285	-// throws Exception {
286	-// try {
287	-// Object target = new NamedClassWithNamedMethods();
288	-// String methodName = "requiredPermissionWithoutDeclaredResourceAndOperation";
289	-// String expectedResource = "contact2";
290	-// String expectedOperation = "delete";
291	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
292	-//
293	-// interceptor.manage(this.ic);
294	-// } catch (SecurityException cause) {
295	-// fail();
296	-// }
297	-// }
298	-//
299	-// @Test
300	-// public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithDeclaredOperationMethod() throws Exception {
301	-// try {
302	-// Object target = new NamedClassWithNamedMethods();
303	-// String methodName = "requiredPermissionWithDeclaredOperation";
304	-// String expectedResource = "contact2";
305	-// String expectedOperation = "insert";
306	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
307	-//
308	-// interceptor.manage(this.ic);
309	-// } catch (SecurityException cause) {
310	-// fail();
311	-// }
312	-// }
313	-//
314	-// @Test
315	-// public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithDeclaredResourceMethod() throws Exception {
316	-// try {
317	-// Object target = new NamedClassWithNamedMethods();
318	-// String methodName = "requiredPermissionWithDeclaredResource";
319	-// String expectedResource = "contact";
320	-// String expectedOperation = "delete";
321	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
322	-//
323	-// interceptor.manage(this.ic);
324	-// } catch (SecurityException cause) {
325	-// fail();
326	-// }
327	-// }
328	-//
329	-// @Test
330	-// public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithDeclaredResourceAndOperation()
331	-// throws Exception {
332	-// try {
333	-// Object target = new NamedClassWithNamedMethods();
334	-// String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
335	-// String expectedResource = "contact";
336	-// String expectedOperation = "insert";
337	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
338	-//
339	-// interceptor.manage(this.ic);
340	-// } catch (SecurityException cause) {
341	-// fail();
342	-// }
343	-// }
344	-//
345	-// /* Testing ClassAnnotedWithRequiredPermission */
346	-//
347	-// @Test
348	-// public void testManageClassAnnotedWithRequiredPermissionAtWithoutRequiredPermissionAnnotation() throws Exception {
349	-// try {
350	-// Object target = new ClassAnnotedWithRequiredPermission();
351	-// String methodName = "withoutRequiredPermissionAnnotation";
352	-// String expectedResource = target.getClass().getSimpleName();
353	-// String expectedOperation = methodName;
354	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
355	-//
356	-// interceptor.manage(this.ic);
357	-// } catch (SecurityException cause) {
358	-// fail();
359	-// }
360	-// }
361	-//
362	-// @Test
363	-// public void testManageClassAnnotedWithRequiredPermissionAtRequiredPermissionWithDeclaredOperation()
364	-// throws Exception {
365	-// try {
366	-// Object target = new ClassAnnotedWithRequiredPermission();
367	-// String methodName = "requiredPermissionWithDeclaredOperation";
368	-// String expectedResource = target.getClass().getSimpleName();
369	-// String expectedOperation = "insert";
370	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
371	-//
372	-// interceptor.manage(this.ic);
373	-// } catch (SecurityException cause) {
374	-// fail();
375	-// }
376	-// }
377	-//
378	-// /* Other tests */
379	-//
380	-// @Test
381	-// public void testManagePermissionNotAllowed() throws Exception {
382	-// try {
383	-// Object target = new UnnamedClass();
384	-// String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
385	-// String expectedResource = "contact";
386	-// String expectedOperation = "insert";
387	-// prepareMock(target, methodName, expectedResource, expectedOperation, false, true);
388	-//
389	-// interceptor.manage(this.ic);
390	-// fail();
391	-// } catch (SecurityException cause) {
392	-// }
393	-// }
394	-//
395	-// @Test
396	-// public void testUserNotLoggedIn() throws Exception {
397	-// try {
398	-// Object target = new UnnamedClass();
399	-// String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
400	-// String expectedResource = "contact";
401	-// String expectedOperation = "insert";
402	-// prepareMock(target, methodName, expectedResource, expectedOperation, true, false);
403	-//
404	-// interceptor.manage(this.ic);
405	-// fail();
406	-// } catch (SecurityException cause) {
407	-// }
408	-// }
409	-//
410	-//}	1	+package br.gov.frameworkdemoiselle.internal.interceptor;
		2	+
		3	+import static org.easymock.EasyMock.createMock;
		4	+import static org.easymock.EasyMock.expect;
		5	+import static org.easymock.EasyMock.expectLastCall;
		6	+import static org.junit.Assert.fail;
		7	+import static org.powermock.api.easymock.PowerMock.mockStatic;
		8	+import static org.powermock.api.easymock.PowerMock.replay;
		9	+
		10	+import java.util.Locale;
		11	+
		12	+import javax.enterprise.inject.Instance;
		13	+import javax.interceptor.InvocationContext;
		14	+
		15	+import org.junit.Before;
		16	+import org.junit.Test;
		17	+import org.junit.runner.RunWith;
		18	+import org.powermock.core.classloader.annotations.PrepareForTest;
		19	+import org.powermock.modules.junit4.PowerMockRunner;
		20	+
		21	+import br.gov.frameworkdemoiselle.annotation.Name;
		22	+import br.gov.frameworkdemoiselle.security.NotLoggedInException;
		23	+import br.gov.frameworkdemoiselle.security.RequiredPermission;
		24	+import br.gov.frameworkdemoiselle.security.SecurityContext;
		25	+import br.gov.frameworkdemoiselle.security.SecurityException;
		26	+import br.gov.frameworkdemoiselle.security.User;
		27	+import br.gov.frameworkdemoiselle.util.Beans;
		28	+
		29	+@RunWith(PowerMockRunner.class)
		30	+@PrepareForTest(Beans.class)
		31	+public class RequiredPermissionInterceptorTest {
		32	+
		33	+ private RequiredPermissionInterceptor interceptor;
		34	+
		35	+ private InvocationContext ic;
		36	+
		37	+ private SecurityContext securityContext;
		38	+
		39	+ class UnnamedClass {
		40	+
		41	+ @RequiredPermission
		42	+ public void requiredPermissionWithoutDeclaredResourceAndOperation() {
		43	+ }
		44	+
		45	+ @RequiredPermission(operation = "insert")
		46	+ public void requiredPermissionWithDeclaredOperation() {
		47	+ }
		48	+
		49	+ @RequiredPermission(resource = "contact")
		50	+ public void requiredPermissionWithDeclaredResource() {
		51	+ }
		52	+
		53	+ @RequiredPermission(resource = "contact", operation = "insert")
		54	+ public void requiredPermissionWithDeclaredResourceAndOperation() {
		55	+ }
		56	+ }
		57	+
		58	+ @Name("contact2")
		59	+ class NamedClass {
		60	+
		61	+ @RequiredPermission
		62	+ public void requiredPermissionWithoutDeclaredResourceAndOperation() {
		63	+ }
		64	+
		65	+ @RequiredPermission(operation = "insert")
		66	+ public void requiredPermissionWithDeclaredOperation() {
		67	+ }
		68	+
		69	+ @RequiredPermission(resource = "contact")
		70	+ public void requiredPermissionWithDeclaredResource() {
		71	+ }
		72	+
		73	+ @RequiredPermission(resource = "contact", operation = "insert")
		74	+ public void requiredPermissionWithDeclaredResourceAndOperation() {
		75	+ }
		76	+ }
		77	+
		78	+ @Name("contact2")
		79	+ class NamedClassWithNamedMethods {
		80	+
		81	+ @Name("delete")
		82	+ @RequiredPermission
		83	+ public void requiredPermissionWithoutDeclaredResourceAndOperation() {
		84	+ }
		85	+
		86	+ @Name("delete")
		87	+ @RequiredPermission(operation = "insert")
		88	+ public void requiredPermissionWithDeclaredOperation() {
		89	+ }
		90	+
		91	+ @Name("delete")
		92	+ @RequiredPermission(resource = "contact")
		93	+ public void requiredPermissionWithDeclaredResource() {
		94	+ }
		95	+
		96	+ @Name("delete")
		97	+ @RequiredPermission(resource = "contact", operation = "insert")
		98	+ public void requiredPermissionWithDeclaredResourceAndOperation() {
		99	+ }
		100	+ }
		101	+
		102	+ @RequiredPermission
		103	+ class ClassAnnotedWithRequiredPermission {
		104	+
		105	+ public void withoutRequiredPermissionAnnotation() {
		106	+ }
		107	+
		108	+ @RequiredPermission(operation = "insert")
		109	+ public void requiredPermissionWithDeclaredOperation() {
		110	+ }
		111	+ }
		112	+
		113	+ @Before
		114	+ public void setUp() throws Exception {
		115	+ @SuppressWarnings("unchecked")
		116	+ Instance<SecurityContext> securityContextInstance = createMock(Instance.class);
		117	+
		118	+ User user = createMock(User.class);
		119	+
		120	+ this.securityContext = createMock(SecurityContext.class);
		121	+ this.ic = createMock(InvocationContext.class);
		122	+
		123	+ mockStatic(Beans.class);
		124	+ expect(Beans.getReference(Locale.class)).andReturn(Locale.getDefault());
		125	+ expect(Beans.getReference(SecurityContext.class)).andReturn(this.securityContext);
		126	+
		127	+ expect(user.getId()).andReturn("UserName").anyTimes();
		128	+ expect(this.securityContext.getUser()).andReturn(user).anyTimes();
		129	+ expect(securityContextInstance.get()).andReturn(securityContext).anyTimes();
		130	+ expect(this.ic.proceed()).andReturn(null);
		131	+ replay(securityContextInstance, user, Beans.class);
		132	+
		133	+ this.interceptor = new RequiredPermissionInterceptor();
		134	+ }
		135	+
		136	+ private void prepareMock(Object target, String methodName, String expectedResource, String expectedOperation,
		137	+ boolean hasPermission, boolean isLoggedUser) throws Exception {
		138	+
		139	+ expect(this.securityContext.isLoggedIn()).andReturn(isLoggedUser).anyTimes();
		140	+
		141	+ this.securityContext.hasPermission(expectedResource, expectedOperation);
		142	+
		143	+ if (isLoggedUser) {
		144	+ expectLastCall().andReturn(hasPermission);
		145	+ } else {
		146	+ expectLastCall().andThrow(new NotLoggedInException(""));
		147	+ }
		148	+
		149	+ expect(this.ic.getTarget()).andReturn(target).anyTimes();
		150	+ expect(this.ic.getMethod()).andReturn(target.getClass().getMethod(methodName)).anyTimes();
		151	+ replay(this.ic, this.securityContext);
		152	+ }
		153	+
		154	+ /* Testing UnnamedClass */
		155	+
		156	+ @Test
		157	+ public void testManageUnnamedClassAtRequiredPermissionWithoutDeclaredResourceAndOperationMethod() throws Exception {
		158	+ try {
		159	+ Object target = new UnnamedClass();
		160	+ String methodName = "requiredPermissionWithoutDeclaredResourceAndOperation";
		161	+ String expectedResource = target.getClass().getSimpleName();
		162	+ String expectedOperation = methodName;
		163	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		164	+
		165	+ interceptor.manage(this.ic);
		166	+ } catch (SecurityException cause) {
		167	+ fail();
		168	+ }
		169	+ }
		170	+
		171	+ @Test
		172	+ public void testManageUnnamedClassAtRequiredPermissionWithDeclaredOperationMethod() throws Exception {
		173	+ try {
		174	+ Object target = new UnnamedClass();
		175	+ String methodName = "requiredPermissionWithDeclaredOperation";
		176	+ String expectedResource = target.getClass().getSimpleName();
		177	+ String expectedOperation = "insert";
		178	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		179	+
		180	+ interceptor.manage(this.ic);
		181	+ } catch (SecurityException cause) {
		182	+ fail();
		183	+ }
		184	+ }
		185	+
		186	+ @Test
		187	+ public void testManageUnnamedClassAtRequiredPermissionWithDeclaredResourceMethod() throws Exception {
		188	+ try {
		189	+ Object target = new UnnamedClass();
		190	+ String methodName = "requiredPermissionWithDeclaredResource";
		191	+ String expectedResource = "contact";
		192	+ String expectedOperation = methodName;
		193	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		194	+
		195	+ interceptor.manage(this.ic);
		196	+ } catch (SecurityException cause) {
		197	+ fail();
		198	+ }
		199	+ }
		200	+
		201	+ @Test
		202	+ public void testManageUnnamedClassAtRequiredPermissionWithDeclaredResourceAndOperation() throws Exception {
		203	+ try {
		204	+ Object target = new UnnamedClass();
		205	+ String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
		206	+ String expectedResource = "contact";
		207	+ String expectedOperation = "insert";
		208	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		209	+
		210	+ interceptor.manage(this.ic);
		211	+ } catch (SecurityException cause) {
		212	+ fail();
		213	+ }
		214	+ }
		215	+
		216	+ /* Testing NamedClass */
		217	+
		218	+ @Test
		219	+ public void testManageNamedClassAtRequiredPermissionWithoutDeclaredResourceAndOperationMethod() throws Exception {
		220	+ try {
		221	+ Object target = new NamedClass();
		222	+ String methodName = "requiredPermissionWithoutDeclaredResourceAndOperation";
		223	+ String expectedResource = "contact2";
		224	+ String expectedOperation = methodName;
		225	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		226	+
		227	+ interceptor.manage(this.ic);
		228	+ } catch (SecurityException cause) {
		229	+ fail();
		230	+ }
		231	+ }
		232	+
		233	+ @Test
		234	+ public void testManageNamedClassAtRequiredPermissionWithDeclaredOperationMethod() throws Exception {
		235	+ try {
		236	+ Object target = new NamedClass();
		237	+ String methodName = "requiredPermissionWithDeclaredOperation";
		238	+ String expectedResource = "contact2";
		239	+ String expectedOperation = "insert";
		240	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		241	+
		242	+ interceptor.manage(this.ic);
		243	+ } catch (SecurityException cause) {
		244	+ fail();
		245	+ }
		246	+ }
		247	+
		248	+ @Test
		249	+ public void testManageNamedClassAtRequiredPermissionWithDeclaredResourceMethod() throws Exception {
		250	+ try {
		251	+ Object target = new NamedClass();
		252	+ String methodName = "requiredPermissionWithDeclaredResource";
		253	+ String expectedResource = "contact";
		254	+ String expectedOperation = methodName;
		255	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		256	+
		257	+ interceptor.manage(this.ic);
		258	+ } catch (SecurityException cause) {
		259	+ fail();
		260	+ }
		261	+ }
		262	+
		263	+ @Test
		264	+ public void testManageNamedClassAtRequiredPermissionWithDeclaredResourceAndOperation() throws Exception {
		265	+ try {
		266	+ Object target = new NamedClass();
		267	+ String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
		268	+ String expectedResource = "contact";
		269	+ String expectedOperation = "insert";
		270	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		271	+
		272	+ interceptor.manage(this.ic);
		273	+ } catch (SecurityException cause) {
		274	+ fail();
		275	+ }
		276	+ }
		277	+
		278	+ /* Testing NamedClassWithNamedMethods */
		279	+
		280	+ @Test
		281	+ public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithoutDeclaredResourceAndOperationMethod()
		282	+ throws Exception {
		283	+ try {
		284	+ Object target = new NamedClassWithNamedMethods();
		285	+ String methodName = "requiredPermissionWithoutDeclaredResourceAndOperation";
		286	+ String expectedResource = "contact2";
		287	+ String expectedOperation = "delete";
		288	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		289	+
		290	+ interceptor.manage(this.ic);
		291	+ } catch (SecurityException cause) {
		292	+ fail();
		293	+ }
		294	+ }
		295	+
		296	+ @Test
		297	+ public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithDeclaredOperationMethod() throws Exception {
		298	+ try {
		299	+ Object target = new NamedClassWithNamedMethods();
		300	+ String methodName = "requiredPermissionWithDeclaredOperation";
		301	+ String expectedResource = "contact2";
		302	+ String expectedOperation = "insert";
		303	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		304	+
		305	+ interceptor.manage(this.ic);
		306	+ } catch (SecurityException cause) {
		307	+ fail();
		308	+ }
		309	+ }
		310	+
		311	+ @Test
		312	+ public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithDeclaredResourceMethod() throws Exception {
		313	+ try {
		314	+ Object target = new NamedClassWithNamedMethods();
		315	+ String methodName = "requiredPermissionWithDeclaredResource";
		316	+ String expectedResource = "contact";
		317	+ String expectedOperation = "delete";
		318	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		319	+
		320	+ interceptor.manage(this.ic);
		321	+ } catch (SecurityException cause) {
		322	+ fail();
		323	+ }
		324	+ }
		325	+
		326	+ @Test
		327	+ public void testManageNamedClassWithNamedMethodsAtRequiredPermissionWithDeclaredResourceAndOperation()
		328	+ throws Exception {
		329	+ try {
		330	+ Object target = new NamedClassWithNamedMethods();
		331	+ String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
		332	+ String expectedResource = "contact";
		333	+ String expectedOperation = "insert";
		334	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		335	+
		336	+ interceptor.manage(this.ic);
		337	+ } catch (SecurityException cause) {
		338	+ fail();
		339	+ }
		340	+ }
		341	+
		342	+ /* Testing ClassAnnotedWithRequiredPermission */
		343	+
		344	+ @Test
		345	+ public void testManageClassAnnotedWithRequiredPermissionAtWithoutRequiredPermissionAnnotation() throws Exception {
		346	+ try {
		347	+ Object target = new ClassAnnotedWithRequiredPermission();
		348	+ String methodName = "withoutRequiredPermissionAnnotation";
		349	+ String expectedResource = target.getClass().getSimpleName();
		350	+ String expectedOperation = methodName;
		351	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		352	+
		353	+ interceptor.manage(this.ic);
		354	+ } catch (SecurityException cause) {
		355	+ fail();
		356	+ }
		357	+ }
		358	+
		359	+ @Test
		360	+ public void testManageClassAnnotedWithRequiredPermissionAtRequiredPermissionWithDeclaredOperation()
		361	+ throws Exception {
		362	+ try {
		363	+ Object target = new ClassAnnotedWithRequiredPermission();
		364	+ String methodName = "requiredPermissionWithDeclaredOperation";
		365	+ String expectedResource = target.getClass().getSimpleName();
		366	+ String expectedOperation = "insert";
		367	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, true);
		368	+
		369	+ interceptor.manage(this.ic);
		370	+ } catch (SecurityException cause) {
		371	+ fail();
		372	+ }
		373	+ }
		374	+
		375	+ /* Other tests */
		376	+
		377	+ @Test
		378	+ public void testManagePermissionNotAllowed() throws Exception {
		379	+ try {
		380	+ Object target = new UnnamedClass();
		381	+ String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
		382	+ String expectedResource = "contact";
		383	+ String expectedOperation = "insert";
		384	+ prepareMock(target, methodName, expectedResource, expectedOperation, false, true);
		385	+
		386	+ interceptor.manage(this.ic);
		387	+ fail();
		388	+ } catch (SecurityException cause) {
		389	+ }
		390	+ }
		391	+
		392	+ @Test
		393	+ public void testUserNotLoggedIn() throws Exception {
		394	+ try {
		395	+ Object target = new UnnamedClass();
		396	+ String methodName = "requiredPermissionWithDeclaredResourceAndOperation";
		397	+ String expectedResource = "contact";
		398	+ String expectedOperation = "insert";
		399	+ prepareMock(target, methodName, expectedResource, expectedOperation, true, false);
		400	+
		401	+ interceptor.manage(this.ic);
		402	+ fail();
		403	+ } catch (SecurityException cause) {
		404	+ }
		405	+ }
		406	+
		407	+}

impl/core/src/test/java/br/gov/frameworkdemoiselle/internal/interceptor/RequiredRoleInterceptorTest.java

Diff comments View file @0cc2807

1	-//package br.gov.frameworkdemoiselle.internal.interceptor;
2	-//
3	-//import static org.easymock.EasyMock.expect;
4	-//import static org.junit.Assert.fail;
5	-//import static org.powermock.api.easymock.PowerMock.mockStatic;
6	-//import static org.powermock.api.easymock.PowerMock.replay;
7	-//
8	-//import java.util.Locale;
9	-//
10	-//import javax.enterprise.inject.Instance;
11	-//import javax.interceptor.InvocationContext;
12	-//
13	-//import org.easymock.EasyMock;
14	-//import org.junit.Before;
15	-//import org.junit.Test;
16	-//import org.junit.runner.RunWith;
17	-//import org.powermock.core.classloader.annotations.PrepareForTest;
18	-//import org.powermock.modules.junit4.PowerMockRunner;
19	-//import org.slf4j.Logger;
20	-//
21	-//import br.gov.frameworkdemoiselle.internal.implementation.CoreBundle;
22	-//import br.gov.frameworkdemoiselle.security.AuthorizationException;
23	-//import br.gov.frameworkdemoiselle.security.NotLoggedInException;
24	-//import br.gov.frameworkdemoiselle.security.RequiredRole;
25	-//import br.gov.frameworkdemoiselle.security.SecurityContext;
26	-//import br.gov.frameworkdemoiselle.security.User;
27	-//import br.gov.frameworkdemoiselle.util.ResourceBundle;
28	-//
29	-//@RunWith(PowerMockRunner.class)
30	-//@PrepareForTest(CoreBundle.class)
31	-//public class RequiredRoleInterceptorTest {
32	-//
33	-// private RequiredRoleInterceptor interceptor;
34	-//
35	-// private InvocationContext ic;
36	-//
37	-// private SecurityContext securityContext;
38	-//
39	-// class ClassNotAnnoted {
40	-//
41	-// @RequiredRole("simpleRoleName")
42	-// public void requiredRoleWithSingleRole() {
43	-// }
44	-//
45	-// @RequiredRole({ "firstRole", "secondRole", "thirdRole", "fourthRole", "fifthRole" })
46	-// public void requiredRoleWithArrayOfRoles() {
47	-// }
48	-//
49	-// @RequiredRole({ "firstRole, secondRole" })
50	-// public void requiredRoleWithArrayOfSingleRoleComma() {
51	-// }
52	-//
53	-// @RequiredRole("firstRole, secondRole")
54	-// public void requiredRoleWithSingleRoleComma() {
55	-// }
56	-//
57	-// @RequiredRole("")
58	-// public void requiredRoleWithEmptyValue() {
59	-// }
60	-//
61	-// @RequiredRole({})
62	-// public void requiredRoleWithEmptyArray() {
63	-// }
64	-//
65	-// @RequiredRole({ "" })
66	-// public void requiredRoleWithArrayOfEmptyString() {
67	-// }
68	-//
69	-// public void methodNotAnnoted() {
70	-// }
71	-// }
72	-//
73	-// @RequiredRole("classRole")
74	-// class ClassAnnotedWithRequiredRole {
75	-//
76	-// public void withoutRole() {
77	-// }
78	-//
79	-// @RequiredRole("simpleRoleName")
80	-// public void requiredRoleWithSingleRole() {
81	-// }
82	-// }
83	-//
84	-// @Before
85	-// public void setUp() throws Exception {
86	-//
87	-// @SuppressWarnings("unchecked")
88	-// Instance<SecurityContext> securityContextInstance = EasyMock.createMock(Instance.class);
89	-// ResourceBundle bundle = new ResourceBundle("demoiselle-core-bundle", Locale.getDefault());
90	-// Logger logger = EasyMock.createMock(Logger.class);
91	-// User user = EasyMock.createMock(User.class);
92	-//
93	-// this.securityContext = EasyMock.createMock(SecurityContext.class);
94	-// this.ic = EasyMock.createMock(InvocationContext.class);
95	-//
96	-// mockStatic(CoreBundle.class);
97	-// expect(CoreBundle.get()).andReturn(bundle);
98	-//
99	-// expect(user.getId()).andReturn("UserName").anyTimes();
100	-// expect(this.securityContext.getUser()).andReturn(user).anyTimes();
101	-// expect(securityContextInstance.get()).andReturn(securityContext).anyTimes();
102	-// expect(this.ic.proceed()).andReturn(null);
103	-// replay(securityContextInstance, user, CoreBundle.class);
104	-//
105	-// this.interceptor = new RequiredRoleInterceptor(securityContextInstance, bundle, logger);
106	-// }
107	-//
108	-// private void prepareMock(Object target, String methodName, String[] expectedRoles, boolean hasHole,
109	-// boolean isLoggedUser) throws Exception {
110	-//
111	-// expect(this.securityContext.isLoggedIn()).andReturn(isLoggedUser).anyTimes();
112	-//
113	-// for (String role : expectedRoles) {
114	-// this.securityContext.hasRole(role);
115	-// if (isLoggedUser) {
116	-// EasyMock.expectLastCall().andReturn(hasHole);
117	-// } else {
118	-// EasyMock.expectLastCall().andThrow(new NotLoggedInException(""));
119	-// }
120	-// }
121	-//
122	-// expect(this.ic.getTarget()).andReturn(target).anyTimes();
123	-// expect(this.ic.getMethod()).andReturn(target.getClass().getMethod(methodName)).anyTimes();
124	-// replay(this.ic, this.securityContext);
125	-// }
126	-//
127	-// /*
128	-// * Testing ClassNotAnnoted
129	-// */
130	-// @Test
131	-// public void testManageClassNotAnnotedAtRequiredRoleWithSingleRole() throws Exception {
132	-// Object target = new ClassNotAnnoted();
133	-// String methodName = "requiredRoleWithSingleRole";
134	-// String[] expectedRoles = { "simpleRoleName" };
135	-// prepareMock(target, methodName, expectedRoles, true, true);
136	-//
137	-// interceptor.manage(this.ic);
138	-// }
139	-//
140	-// @Test
141	-// public void testManageClassNotAnnotedAtRequiredRoleWithArrayOfRoles() throws Exception {
142	-// Object target = new ClassNotAnnoted();
143	-// String methodName = "requiredRoleWithArrayOfRoles";
144	-// String[] expectedRoles = { "firstRole", "secondRole", "thirdRole", "fourthRole", "fifthRole" };
145	-// prepareMock(target, methodName, expectedRoles, true, true);
146	-//
147	-// interceptor.manage(this.ic);
148	-// }
149	-//
150	-// @Test
151	-// public void testManageClassNotAnnotedAtRequiredRoleWithArrayOfSingleRoleComma() throws Exception {
152	-// Object target = new ClassNotAnnoted();
153	-// String methodName = "requiredRoleWithArrayOfSingleRoleComma";
154	-// String[] expectedRoles = { "firstRole, secondRole" };
155	-// prepareMock(target, methodName, expectedRoles, true, true);
156	-//
157	-// interceptor.manage(this.ic);
158	-// }
159	-//
160	-// @Test
161	-// public void testManageClassNotAnnotedAtRequiredRoleWithSingleRoleComma() throws Exception {
162	-// Object target = new ClassNotAnnoted();
163	-// String methodName = "requiredRoleWithSingleRoleComma";
164	-// String[] expectedRoles = { "firstRole, secondRole" };
165	-// prepareMock(target, methodName, expectedRoles, true, true);
166	-//
167	-// interceptor.manage(this.ic);
168	-// }
169	-//
170	-// @Test
171	-// public void testManageClassNotAnnotedAtRequiredRoleWithEmptyValue() throws Exception {
172	-// try {
173	-// Object target = new ClassNotAnnoted();
174	-// String methodName = "requiredRoleWithEmptyValue";
175	-// String[] expectedRoles = { "" };
176	-// prepareMock(target, methodName, expectedRoles, false, true);
177	-//
178	-// interceptor.manage(this.ic);
179	-// fail();
180	-// } catch (AuthorizationException cause) {
181	-// }
182	-// }
183	-//
184	-// @Test
185	-// public void testManageClassNotAnnotedAtRequiredRoleWithEmptyArray() throws Exception {
186	-// try {
187	-// Object target = new ClassNotAnnoted();
188	-// String methodName = "requiredRoleWithEmptyArray";
189	-// String[] expectedRoles = { "" };
190	-// prepareMock(target, methodName, expectedRoles, false, true);
191	-//
192	-// interceptor.manage(this.ic);
193	-// fail();
194	-// } catch (AuthorizationException cause) {
195	-// }
196	-// }
197	-//
198	-// @Test
199	-// public void testManageClassNotAnnotedAtRequiredRoleWithArrayOfEmptyString() throws Exception {
200	-// try {
201	-// Object target = new ClassNotAnnoted();
202	-// String methodName = "requiredRoleWithArrayOfEmptyString";
203	-// String[] expectedRoles = { "" };
204	-// prepareMock(target, methodName, expectedRoles, false, true);
205	-//
206	-// interceptor.manage(this.ic);
207	-// fail();
208	-// } catch (AuthorizationException cause) {
209	-// }
210	-// }
211	-//
212	-// @Test
213	-// public void testManageClassNotAnnotedAtMethodNotAnnoted() throws Exception {
214	-// try {
215	-// Object target = new ClassNotAnnoted();
216	-// String methodName = "methodNotAnnoted";
217	-// String[] expectedRoles = { "" };
218	-// prepareMock(target, methodName, expectedRoles, false, true);
219	-//
220	-// interceptor.manage(this.ic);
221	-// fail();
222	-// } catch (AuthorizationException cause) {
223	-// }
224	-// }
225	-//
226	-// /*
227	-// * Testing ClassAnnoted
228	-// */
229	-// @Test
230	-// public void testManageClassAnnotedWithRequiredRoleAtWithoutRole() throws Exception {
231	-// Object target = new ClassAnnotedWithRequiredRole();
232	-// String methodName = "withoutRole";
233	-// String[] expectedRoles = { "classRole" };
234	-// prepareMock(target, methodName, expectedRoles, true, true);
235	-//
236	-// interceptor.manage(this.ic);
237	-// }
238	-//
239	-// @Test
240	-// public void testManageClassAnnotedWithRequiredRoleAtRequiredRoleWithSingleRole() throws Exception {
241	-// Object target = new ClassAnnotedWithRequiredRole();
242	-// String methodName = "requiredRoleWithSingleRole";
243	-// String[] expectedRoles = { "simpleRoleName" };
244	-// prepareMock(target, methodName, expectedRoles, true, true);
245	-//
246	-// interceptor.manage(this.ic);
247	-// }
248	-//
249	-// /*
250	-// * Other tests
251	-// */
252	-//
253	-// @Test
254	-// public void testDoesNotHaveSingleRole() throws Exception {
255	-// try {
256	-// Object target = new ClassNotAnnoted();
257	-// String methodName = "requiredRoleWithSingleRole";
258	-// String[] expectedRoles = { "simpleRoleName" };
259	-// prepareMock(target, methodName, expectedRoles, false, true);
260	-//
261	-// interceptor.manage(this.ic);
262	-// fail();
263	-// } catch (AuthorizationException cause) {
264	-// }
265	-// }
266	-//
267	-// @Test
268	-// public void testUserNotLoggedIn() throws Exception {
269	-// try {
270	-// Object target = new ClassNotAnnoted();
271	-// String methodName = "requiredRoleWithSingleRole";
272	-// String[] expectedRoles = { "simpleRoleName" };
273	-// prepareMock(target, methodName, expectedRoles, true, false);
274	-//
275	-// interceptor.manage(this.ic);
276	-// fail();
277	-// } catch (NotLoggedInException cause) {
278	-// }
279	-// }
280	-//
281	-// @Test
282	-// public void testDoesNotHaveOneOrMoreRolesOfArray() throws Exception {
283	-// Object target = new ClassNotAnnoted();
284	-// String methodName = "requiredRoleWithArrayOfRoles";
285	-// String[] expectedRoles = { "thirdRole", "fourthRole", "fifthRole" };
286	-//
287	-// expect(this.securityContext.hasRole("firstRole")).andReturn(false);
288	-// expect(this.securityContext.hasRole("secondRole")).andReturn(false);
289	-//
290	-// prepareMock(target, methodName, expectedRoles, true, true);
291	-//
292	-// interceptor.manage(this.ic);
293	-// }
294	-//
295	-// @Test
296	-// public void testHasMoreRolesThenArray() throws Exception {
297	-// Object target = new ClassNotAnnoted();
298	-// String methodName = "requiredRoleWithArrayOfRoles";
299	-// String[] expectedRoles = { "thirdRole", "fourthRole", "fifthRole" };
300	-//
301	-// expect(this.securityContext.hasRole("firstRole")).andReturn(false);
302	-// expect(this.securityContext.hasRole("secondRole")).andReturn(false);
303	-// expect(this.securityContext.hasRole("sixthRole")).andReturn(true);
304	-//
305	-// prepareMock(target, methodName, expectedRoles, true, true);
306	-//
307	-// interceptor.manage(this.ic);
308	-// }
309	-//
310	-//}	1	+package br.gov.frameworkdemoiselle.internal.interceptor;
		2	+
		3	+import static org.easymock.EasyMock.expect;
		4	+import static org.junit.Assert.fail;
		5	+import static org.powermock.api.easymock.PowerMock.mockStatic;
		6	+import static org.powermock.api.easymock.PowerMock.replay;
		7	+
		8	+import java.util.Locale;
		9	+
		10	+import javax.enterprise.inject.Instance;
		11	+import javax.interceptor.InvocationContext;
		12	+
		13	+import org.easymock.EasyMock;
		14	+import org.junit.Before;
		15	+import org.junit.Test;
		16	+import org.junit.runner.RunWith;
		17	+import org.powermock.core.classloader.annotations.PrepareForTest;
		18	+import org.powermock.modules.junit4.PowerMockRunner;
		19	+
		20	+import br.gov.frameworkdemoiselle.security.AuthorizationException;
		21	+import br.gov.frameworkdemoiselle.security.NotLoggedInException;
		22	+import br.gov.frameworkdemoiselle.security.RequiredRole;
		23	+import br.gov.frameworkdemoiselle.security.SecurityContext;
		24	+import br.gov.frameworkdemoiselle.security.User;
		25	+import br.gov.frameworkdemoiselle.util.Beans;
		26	+
		27	+@RunWith(PowerMockRunner.class)
		28	+@PrepareForTest(Beans.class)
		29	+public class RequiredRoleInterceptorTest {
		30	+
		31	+ private RequiredRoleInterceptor interceptor;
		32	+
		33	+ private InvocationContext ic;
		34	+
		35	+ private SecurityContext securityContext;
		36	+
		37	+ class ClassNotAnnoted {
		38	+
		39	+ @RequiredRole("simpleRoleName")
		40	+ public void requiredRoleWithSingleRole() {
		41	+ }
		42	+
		43	+ @RequiredRole({ "firstRole", "secondRole", "thirdRole", "fourthRole", "fifthRole" })
		44	+ public void requiredRoleWithArrayOfRoles() {
		45	+ }
		46	+
		47	+ @RequiredRole({ "firstRole, secondRole" })
		48	+ public void requiredRoleWithArrayOfSingleRoleComma() {
		49	+ }
		50	+
		51	+ @RequiredRole("firstRole, secondRole")
		52	+ public void requiredRoleWithSingleRoleComma() {
		53	+ }
		54	+
		55	+ @RequiredRole("")
		56	+ public void requiredRoleWithEmptyValue() {
		57	+ }
		58	+
		59	+ @RequiredRole({})
		60	+ public void requiredRoleWithEmptyArray() {
		61	+ }
		62	+
		63	+ @RequiredRole({ "" })
		64	+ public void requiredRoleWithArrayOfEmptyString() {
		65	+ }
		66	+
		67	+ public void methodNotAnnoted() {
		68	+ }
		69	+ }
		70	+
		71	+ @RequiredRole("classRole")
		72	+ class ClassAnnotedWithRequiredRole {
		73	+
		74	+ public void withoutRole() {
		75	+ }
		76	+
		77	+ @RequiredRole("simpleRoleName")
		78	+ public void requiredRoleWithSingleRole() {
		79	+ }
		80	+ }
		81	+
		82	+ @Before
		83	+ public void setUp() throws Exception {
		84	+
		85	+ @SuppressWarnings("unchecked")
		86	+ Instance<SecurityContext> securityContextInstance = EasyMock.createMock(Instance.class);
		87	+ User user = EasyMock.createMock(User.class);
		88	+
		89	+ this.securityContext = EasyMock.createMock(SecurityContext.class);
		90	+ this.ic = EasyMock.createMock(InvocationContext.class);
		91	+
		92	+ mockStatic(Beans.class);
		93	+ expect(Beans.getReference(Locale.class)).andReturn(Locale.getDefault());
		94	+ expect(Beans.getReference(SecurityContext.class)).andReturn(this.securityContext);
		95	+
		96	+ expect(user.getId()).andReturn("UserName").anyTimes();
		97	+ expect(this.securityContext.getUser()).andReturn(user).anyTimes();
		98	+ expect(securityContextInstance.get()).andReturn(securityContext).anyTimes();
		99	+ expect(this.ic.proceed()).andReturn(null);
		100	+ replay(securityContextInstance, user, Beans.class);
		101	+
		102	+ this.interceptor = new RequiredRoleInterceptor();
		103	+ }
		104	+
		105	+ private void prepareMock(Object target, String methodName, String[] expectedRoles, boolean hasHole,
		106	+ boolean isLoggedUser) throws Exception {
		107	+
		108	+ expect(this.securityContext.isLoggedIn()).andReturn(isLoggedUser).anyTimes();
		109	+
		110	+ for (String role : expectedRoles) {
		111	+ this.securityContext.hasRole(role);
		112	+ if (isLoggedUser) {
		113	+ EasyMock.expectLastCall().andReturn(hasHole);
		114	+ } else {
		115	+ EasyMock.expectLastCall().andThrow(new NotLoggedInException(""));
		116	+ }
		117	+ }
		118	+
		119	+ expect(this.ic.getTarget()).andReturn(target).anyTimes();
		120	+ expect(this.ic.getMethod()).andReturn(target.getClass().getMethod(methodName)).anyTimes();
		121	+ replay(this.ic, this.securityContext);
		122	+ }
		123	+
		124	+ /*
		125	+ * Testing ClassNotAnnoted
		126	+ */
		127	+ @Test
		128	+ public void testManageClassNotAnnotedAtRequiredRoleWithSingleRole() throws Exception {
		129	+ Object target = new ClassNotAnnoted();
		130	+ String methodName = "requiredRoleWithSingleRole";
		131	+ String[] expectedRoles = { "simpleRoleName" };
		132	+ prepareMock(target, methodName, expectedRoles, true, true);
		133	+
		134	+ interceptor.manage(this.ic);
		135	+ }
		136	+
		137	+ @Test
		138	+ public void testManageClassNotAnnotedAtRequiredRoleWithArrayOfRoles() throws Exception {
		139	+ Object target = new ClassNotAnnoted();
		140	+ String methodName = "requiredRoleWithArrayOfRoles";
		141	+ String[] expectedRoles = { "firstRole", "secondRole", "thirdRole", "fourthRole", "fifthRole" };
		142	+ prepareMock(target, methodName, expectedRoles, true, true);
		143	+
		144	+ interceptor.manage(this.ic);
		145	+ }
		146	+
		147	+ @Test
		148	+ public void testManageClassNotAnnotedAtRequiredRoleWithArrayOfSingleRoleComma() throws Exception {
		149	+ Object target = new ClassNotAnnoted();
		150	+ String methodName = "requiredRoleWithArrayOfSingleRoleComma";
		151	+ String[] expectedRoles = { "firstRole, secondRole" };
		152	+ prepareMock(target, methodName, expectedRoles, true, true);
		153	+
		154	+ interceptor.manage(this.ic);
		155	+ }
		156	+
		157	+ @Test
		158	+ public void testManageClassNotAnnotedAtRequiredRoleWithSingleRoleComma() throws Exception {
		159	+ Object target = new ClassNotAnnoted();
		160	+ String methodName = "requiredRoleWithSingleRoleComma";
		161	+ String[] expectedRoles = { "firstRole, secondRole" };
		162	+ prepareMock(target, methodName, expectedRoles, true, true);
		163	+
		164	+ interceptor.manage(this.ic);
		165	+ }
		166	+
		167	+ @Test
		168	+ public void testManageClassNotAnnotedAtRequiredRoleWithEmptyValue() throws Exception {
		169	+ try {
		170	+ Object target = new ClassNotAnnoted();
		171	+ String methodName = "requiredRoleWithEmptyValue";
		172	+ String[] expectedRoles = { "" };
		173	+ prepareMock(target, methodName, expectedRoles, false, true);
		174	+
		175	+ interceptor.manage(this.ic);
		176	+ fail();
		177	+ } catch (AuthorizationException cause) {
		178	+ }
		179	+ }
		180	+
		181	+ @Test
		182	+ public void testManageClassNotAnnotedAtRequiredRoleWithEmptyArray() throws Exception {
		183	+ try {
		184	+ Object target = new ClassNotAnnoted();
		185	+ String methodName = "requiredRoleWithEmptyArray";
		186	+ String[] expectedRoles = { "" };
		187	+ prepareMock(target, methodName, expectedRoles, false, true);
		188	+
		189	+ interceptor.manage(this.ic);
		190	+ fail();
		191	+ } catch (AuthorizationException cause) {
		192	+ }
		193	+ }
		194	+
		195	+ @Test
		196	+ public void testManageClassNotAnnotedAtRequiredRoleWithArrayOfEmptyString() throws Exception {
		197	+ try {
		198	+ Object target = new ClassNotAnnoted();
		199	+ String methodName = "requiredRoleWithArrayOfEmptyString";
		200	+ String[] expectedRoles = { "" };
		201	+ prepareMock(target, methodName, expectedRoles, false, true);
		202	+
		203	+ interceptor.manage(this.ic);
		204	+ fail();
		205	+ } catch (AuthorizationException cause) {
		206	+ }
		207	+ }
		208	+
		209	+ @Test
		210	+ public void testManageClassNotAnnotedAtMethodNotAnnoted() throws Exception {
		211	+ try {
		212	+ Object target = new ClassNotAnnoted();
		213	+ String methodName = "methodNotAnnoted";
		214	+ String[] expectedRoles = { "" };
		215	+ prepareMock(target, methodName, expectedRoles, false, true);
		216	+
		217	+ interceptor.manage(this.ic);
		218	+ fail();
		219	+ } catch (AuthorizationException cause) {
		220	+ }
		221	+ }
		222	+
		223	+ /*
		224	+ * Testing ClassAnnoted
		225	+ */
		226	+ @Test
		227	+ public void testManageClassAnnotedWithRequiredRoleAtWithoutRole() throws Exception {
		228	+ Object target = new ClassAnnotedWithRequiredRole();
		229	+ String methodName = "withoutRole";
		230	+ String[] expectedRoles = { "classRole" };
		231	+ prepareMock(target, methodName, expectedRoles, true, true);
		232	+
		233	+ interceptor.manage(this.ic);
		234	+ }
		235	+
		236	+ @Test
		237	+ public void testManageClassAnnotedWithRequiredRoleAtRequiredRoleWithSingleRole() throws Exception {
		238	+ Object target = new ClassAnnotedWithRequiredRole();
		239	+ String methodName = "requiredRoleWithSingleRole";
		240	+ String[] expectedRoles = { "simpleRoleName" };
		241	+ prepareMock(target, methodName, expectedRoles, true, true);
		242	+
		243	+ interceptor.manage(this.ic);
		244	+ }
		245	+
		246	+ /*
		247	+ * Other tests
		248	+ */
		249	+
		250	+ @Test
		251	+ public void testDoesNotHaveSingleRole() throws Exception {
		252	+ try {
		253	+ Object target = new ClassNotAnnoted();
		254	+ String methodName = "requiredRoleWithSingleRole";
		255	+ String[] expectedRoles = { "simpleRoleName" };
		256	+ prepareMock(target, methodName, expectedRoles, false, true);
		257	+
		258	+ interceptor.manage(this.ic);
		259	+ fail();
		260	+ } catch (AuthorizationException cause) {
		261	+ }
		262	+ }
		263	+
		264	+ @Test
		265	+ public void testUserNotLoggedIn() throws Exception {
		266	+ try {
		267	+ Object target = new ClassNotAnnoted();
		268	+ String methodName = "requiredRoleWithSingleRole";
		269	+ String[] expectedRoles = { "simpleRoleName" };
		270	+ prepareMock(target, methodName, expectedRoles, true, false);
		271	+
		272	+ interceptor.manage(this.ic);
		273	+ fail();
		274	+ } catch (NotLoggedInException cause) {
		275	+ }
		276	+ }
		277	+
		278	+ @Test
		279	+ public void testDoesNotHaveOneOrMoreRolesOfArray() throws Exception {
		280	+ Object target = new ClassNotAnnoted();
		281	+ String methodName = "requiredRoleWithArrayOfRoles";
		282	+ String[] expectedRoles = { "thirdRole", "fourthRole", "fifthRole" };
		283	+
		284	+ expect(this.securityContext.hasRole("firstRole")).andReturn(false);
		285	+ expect(this.securityContext.hasRole("secondRole")).andReturn(false);
		286	+
		287	+ prepareMock(target, methodName, expectedRoles, true, true);
		288	+
		289	+ interceptor.manage(this.ic);
		290	+ }
		291	+
		292	+ @Test
		293	+ public void testHasMoreRolesThenArray() throws Exception {
		294	+ Object target = new ClassNotAnnoted();
		295	+ String methodName = "requiredRoleWithArrayOfRoles";
		296	+ String[] expectedRoles = { "thirdRole", "fourthRole", "fifthRole" };
		297	+
		298	+ expect(this.securityContext.hasRole("firstRole")).andReturn(false);
		299	+ expect(this.securityContext.hasRole("secondRole")).andReturn(false);
		300	+ expect(this.securityContext.hasRole("sixthRole")).andReturn(true);
		301	+
		302	+ prepareMock(target, methodName, expectedRoles, true, true);
		303	+
		304	+ interceptor.manage(this.ic);
		305	+ }
		306	+
		307	+}