1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.shiro.guice.web;
20  
21  import com.google.inject.Inject;
22  import com.google.inject.Injector;
23  import com.google.inject.Key;
24  import com.google.inject.name.Named;
25  import com.google.inject.name.Names;
26  import com.google.inject.spi.Dependency;
27  import org.junit.Test;
28  
29  import java.lang.reflect.Constructor;
30  import java.lang.reflect.Field;
31  import java.lang.reflect.Method;
32  import java.util.concurrent.atomic.AtomicBoolean;
33  
34  import static org.easymock.EasyMock.*;
35  import static org.junit.Assert.*;
36  
37  public class AbstractInjectionProviderTest {
38  
39      @Test
40      public void testGet() throws Exception {
41          Injector mockInjector = createMock(Injector.class);
42  
43          Object c1 = new Object();
44          Object c2 = new Object();
45          final AtomicBoolean postProcessCalled = new AtomicBoolean(false);
46  
47          expect(mockInjector.getInstance(keyC1)).andReturn(c1);
48          expect(mockInjector.getInstance(keyC2)).andReturn(c2);
49          mockInjector.injectMembers(anyObject(SomeInjectedClass.class));
50  
51          replay(mockInjector);
52  
53          AbstractInjectionProvider<SomeInjectedClass> underTest =
54                  new AbstractInjectionProvider<SomeInjectedClass>(Key.get(SomeInjectedClass.class)) {
55                      @Override
56                      protected SomeInjectedClass postProcess(SomeInjectedClass someInjectedClass) {
57                          postProcessCalled.set(true);
58                          return super.postProcess(someInjectedClass);
59                      }
60                  };
61  
62          underTest.injector = mockInjector;
63  
64          SomeInjectedClass got = underTest.get();
65  
66          assertEquals("Wrong parameter passed to constructor (index 0).", c1, got.c1);
67          assertEquals("Wrong parameter passed to constructor (index 1).", c2, got.c2);
68  
69          assertTrue("postProcess method was not called.", postProcessCalled.get());
70  
71          verify(mockInjector);
72      }
73  
74      @Test
75      public void testGetDependencies() throws Exception {
76          AbstractInjectionProvider<SomeInjectedClass> underTest =
77                  new AbstractInjectionProvider<SomeInjectedClass>(Key.get(SomeInjectedClass.class));
78  
79          boolean foundC1 = false;
80          boolean foundC2 = false;
81          boolean foundV1 = false;
82          boolean foundV2 = false;
83          boolean foundF1 = false;
84  
85          for (Dependency<?> dependency : underTest.getDependencies()) {
86              if (dependency.getInjectionPoint().getMember() instanceof Constructor) {
87                  if (dependency.getParameterIndex() == 0 && dependency.getKey().equals(keyC1)) {
88                      foundC1 = true;
89                  } else if (dependency.getParameterIndex() == 1 && dependency.getKey().equals(keyC2)) {
90                      foundC2 = true;
91                  } else {
92                      fail("Did not expect constructor dependency with key " + dependency.getKey() + " at parameter index " + dependency.getParameterIndex());
93                  }
94              } else if (dependency.getInjectionPoint().getMember() instanceof Method) {
95                  if (dependency.getKey().equals(keyV1)) {
96                      foundV1 = true;
97                  } else if (dependency.getKey().equals(keyV2)) {
98                      foundV2 = true;
99                  } else {
100                     fail("Did not expect method dependency with key " + dependency.getKey());
101                 }
102             } else if (dependency.getInjectionPoint().getMember() instanceof Field) {
103                 if (dependency.getKey().equals(keyF1)) {
104                     foundF1 = true;
105                 } else {
106                     fail("Did not expect field dependency with key " + dependency.getKey());
107                 }
108             } else {
109                 fail("Did not expect dependency with key " + dependency.getKey());
110             }
111         }
112 
113         assertTrue("Did not find dependency C1", foundC1);
114         assertTrue("Did not find dependency C2", foundC2);
115         assertTrue("Did not find dependency V1", foundV1);
116         assertTrue("Did not find dependency V2", foundV2);
117         assertTrue("Did not find dependency F1", foundF1);
118     }
119 
120     static Key keyC1 = Key.get(Object.class, Names.named("constructor1"));
121     static Key keyC2 = Key.get(Object.class, Names.named("constructor2"));
122     static Key keyV1 = Key.get(Object.class, Names.named("val1"));
123     static Key keyV2 = Key.get(Object.class, Names.named("val2"));
124     static Key keyF1 = Key.get(Object.class, Names.named("field1"));
125 
126 
127     static class SomeInjectedClass {
128 
129         @Inject
130         @Named("field1")
131         private Object field;
132         private Object c1;
133         private Object c2;
134 
135         @Inject
136         public SomeInjectedClass(@Named("constructor1") Object c1, @Named("constructor2") Object c2) {
137 
138             this.c1 = c1;
139             this.c2 = c2;
140         }
141 
142         @Inject
143         public void setVal1(@Named("val1") Object v1) {
144 
145         }
146 
147         @Inject
148         public void setVal2(@Named("val2") Object v2) {
149 
150         }
151     }
152 }