1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.shiro.guice;
20
21 import com.google.inject.Guice;
22 import com.google.inject.Inject;
23 import com.google.inject.Injector;
24 import com.google.inject.Provides;
25 import com.google.inject.binder.AnnotatedBindingBuilder;
26 import org.apache.shiro.SecurityUtils;
27 import org.apache.shiro.authc.AuthenticationInfo;
28 import org.apache.shiro.authc.AuthenticationToken;
29 import org.apache.shiro.authc.SimpleAuthenticationInfo;
30 import org.apache.shiro.env.Environment;
31 import org.apache.shiro.mgt.DefaultSecurityManager;
32 import org.apache.shiro.mgt.SecurityManager;
33 import org.apache.shiro.realm.Realm;
34 import org.apache.shiro.session.mgt.DefaultSessionManager;
35 import org.apache.shiro.session.mgt.SessionManager;
36 import org.apache.shiro.subject.Subject;
37 import org.apache.shiro.util.Destroyable;
38 import org.junit.Test;
39
40 import java.util.Collection;
41
42 import static org.easymock.EasyMock.*;
43 import static org.junit.Assert.assertNotNull;
44 import static org.junit.Assert.assertTrue;
45
46 public class ShiroModuleTest {
47
48 @Test
49 public void basicInstantiation() {
50
51 final MockRealm mockRealm = createMock(MockRealm.class);
52
53 Injector injector = Guice.createInjector(new ShiroModule() {
54 @Override
55 protected void configureShiro() {
56 bindRealm().to(MockRealm.class);
57 }
58
59 @Provides
60 public MockRealm createRealm() {
61 return mockRealm;
62 }
63 });
64 SecurityManager securityManager = injector.getInstance(SecurityManager.class);
65 assertNotNull(securityManager);
66 }
67
68 @Test
69 public void testConfigure() {
70 final MockRealm mockRealm = createMock(MockRealm.class);
71 AuthenticationToken authToken = createMock(AuthenticationToken.class);
72 AuthenticationInfo info = new SimpleAuthenticationInfo("mockUser", "password", "mockRealm");
73
74 expect(mockRealm.supports(authToken)).andReturn(true);
75 expect(mockRealm.getAuthenticationInfo(authToken)).andReturn(info);
76
77 replay(mockRealm);
78
79 Injector injector = Guice.createInjector(new ShiroModule() {
80 @Override
81 protected void configureShiro() {
82 bindRealm().to(MockRealm.class);
83 }
84
85 @Provides
86 public MockRealm createRealm() {
87 return mockRealm;
88 }
89 });
90 SecurityManager securityManager = injector.getInstance(SecurityManager.class);
91 assertNotNull(securityManager);
92 SecurityUtils.setSecurityManager(securityManager);
93
94 final Subject subject = new Subject.Builder(securityManager).buildSubject();
95 securityManager.login(subject, authToken);
96
97 verify(mockRealm);
98 }
99
100 @Test
101 public void testBindSecurityManager() {
102 final MockRealm mockRealm = createMock(MockRealm.class);
103
104 Injector injector = Guice.createInjector(new ShiroModule() {
105 @Override
106 protected void configureShiro() {
107 bindRealm().to(MockRealm.class);
108 }
109
110 @Provides
111 public MockRealm createRealm() {
112 return mockRealm;
113 }
114
115 @Override
116 protected void bindSecurityManager(AnnotatedBindingBuilder<? super SecurityManager> bind) {
117 bind.to(MyDefaultSecurityManager.class);
118 }
119 });
120 SecurityManager securityManager = injector.getInstance(SecurityManager.class);
121 assertNotNull(securityManager);
122 assertTrue(securityManager instanceof MyDefaultSecurityManager);
123 }
124
125 @Test
126 public void testBindSessionManager() {
127 final MockRealm mockRealm = createMock(MockRealm.class);
128
129 Injector injector = Guice.createInjector(new ShiroModule() {
130 @Override
131 protected void configureShiro() {
132 bindRealm().to(MockRealm.class);
133 }
134
135 @Provides
136 public MockRealm createRealm() {
137 return mockRealm;
138 }
139
140 @Override
141 protected void bindSessionManager(AnnotatedBindingBuilder<SessionManager> bind) {
142 bind.to(MyDefaultSessionManager.class);
143 }
144 });
145 DefaultSecurityManager securityManager = (DefaultSecurityManager) injector.getInstance(SecurityManager.class);
146 assertNotNull(securityManager);
147 assertNotNull(securityManager.getSessionManager());
148 assertTrue(securityManager.getSessionManager() instanceof MyDefaultSessionManager);
149 }
150
151 @Test
152 public void testBindEnvironment() {
153 final MockRealm mockRealm = createMock(MockRealm.class);
154
155 Injector injector = Guice.createInjector(new ShiroModule() {
156 @Override
157 protected void configureShiro() {
158 bindRealm().to(MockRealm.class);
159 expose(Environment.class);
160 }
161
162 @Provides
163 public MockRealm createRealm() {
164 return mockRealm;
165 }
166
167 @Override
168 protected void bindEnvironment(AnnotatedBindingBuilder<Environment> bind) {
169 bind.to(MyEnvironment.class);
170 }
171 });
172 Environment environment = injector.getInstance(Environment.class);
173 assertNotNull(environment);
174 assertTrue(environment instanceof MyEnvironment);
175 }
176
177 @Test
178 public void testDestroy() throws Exception {
179 final MockRealm mockRealm = createMock(MockRealm.class);
180 final MyDestroyable myDestroyable = createMock(MyDestroyable.class);
181
182 myDestroyable.destroy();
183
184 replay(myDestroyable);
185
186 final ShiroModule shiroModule = new ShiroModule() {
187 @Override
188 protected void configureShiro() {
189 bindRealm().to(MockRealm.class);
190 bind(MyDestroyable.class).toInstance(myDestroyable);
191 expose(MyDestroyable.class);
192 }
193
194 @Provides
195 public MockRealm createRealm() {
196 return mockRealm;
197 }
198
199 };
200 Injector injector = Guice.createInjector(shiroModule);
201 injector.getInstance(MyDestroyable.class);
202 shiroModule.destroy();
203
204 verify(myDestroyable);
205 }
206
207 public static interface MockRealm extends Realm {
208
209 }
210
211 public static class MyDefaultSecurityManager extends DefaultSecurityManager {
212 @Inject
213 public MyDefaultSecurityManager(Collection<Realm> realms) {
214 super(realms);
215 }
216 }
217
218 public static class MyDefaultSessionManager extends DefaultSessionManager {
219 }
220
221 public static class MyEnvironment extends GuiceEnvironment {
222 @Inject
223 public MyEnvironment(SecurityManager securityManager) {
224 super(securityManager);
225 }
226 }
227
228 public static interface MyDestroyable extends Destroyable {
229 }
230 }