MentaContainer

Rev

Rev 44 | Rev 58 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 44 Rev 57
1
package org.mentacontainer.impl;
1
package org.mentacontainer.impl;
2
2
3
import junit.framework.Assert;
3
import junit.framework.Assert;
4
4
5
import org.junit.Test;
5
import org.junit.Test;
6
import org.mentacontainer.Container;
6
import org.mentacontainer.Container;
-
 
7
import org.mentacontainer.Scope;
7
8
8
public class MentaContainerTest {
9
public class MentaContainerTest {
9
10
10
        @Test
11
        @Test
11
        public void testSimpleGet() {
12
        public void testSimpleGet() {
12
13
13
                Container c = new MentaContainer();
14
                Container c = new MentaContainer();
14
15
15
                c.ioc("myStr", String.class);
16
                c.ioc("myStr", String.class);
16
17
17
                Assert.assertEquals("", c.get("myStr"));
18
                Assert.assertEquals("", c.get("myStr"));
18
19
19
                String s1 = c.get("myStr");
20
                String s1 = c.get("myStr");
20
21
21
                String s2 = c.get("myStr");
22
                String s2 = c.get("myStr");
22
23
23
                Assert.assertTrue(s1 != s2);
24
                Assert.assertTrue(s1 != s2);
24
25
25
                Assert.assertTrue(s1.equals(s2));
26
                Assert.assertTrue(s1.equals(s2));
26
        }
27
        }
27
28
28
        @Test
29
        @Test
29
        public void testConstructorInit() {
30
        public void testConstructorInit() {
30
31
31
                Container c = new MentaContainer();
32
                Container c = new MentaContainer();
32
33
33
                c.ioc("myStr", String.class).addInitValue("hello");
34
                c.ioc("myStr", String.class).addInitValue("hello");
34
35
35
                Assert.assertEquals("hello", c.get("myStr"));
36
                Assert.assertEquals("hello", c.get("myStr"));
36
37
37
                String s1 = c.get("myStr");
38
                String s1 = c.get("myStr");
38
39
39
                String s2 = c.get("myStr");
40
                String s2 = c.get("myStr");
40
41
41
                Assert.assertTrue(s1 != s2);
42
                Assert.assertTrue(s1 != s2);
42
43
43
                Assert.assertTrue(s1.equals(s2));
44
                Assert.assertTrue(s1.equals(s2));
44
45
45
                c.ioc("anotherStr", String.class).addInitValue("hi");
46
                c.ioc("anotherStr", String.class).addInitValue("hi");
46
47
47
                String s3 = c.get("anotherStr");
48
                String s3 = c.get("anotherStr");
48
49
49
                Assert.assertTrue(s1 != s3);
50
                Assert.assertTrue(s1 != s3);
50
51
51
                Assert.assertFalse(s1.equals(s3));
52
                Assert.assertFalse(s1.equals(s3));
52
        }
53
        }
53
54
54
        @Test
55
        @Test
55
        public void testSingleton() {
56
        public void testSingleton() {
56
57
57
                Container c = new MentaContainer();
58
                Container c = new MentaContainer();
58
59
59
                c.ioc("myStr", String.class, true).addInitValue("hello");
-
 
-
 
60
                c.ioc("myStr", String.class, Scope.SINGLETON).addInitValue("hello");
60
61
61
                Assert.assertEquals("hello", c.get("myStr"));
62
                Assert.assertEquals("hello", c.get("myStr"));
62
63
63
                String s1 = c.get("myStr");
64
                String s1 = c.get("myStr");
64
65
65
                String s2 = c.get("myStr");
66
                String s2 = c.get("myStr");
66
67
67
                Assert.assertTrue(s1 == s2);
68
                Assert.assertTrue(s1 == s2);
68
69
69
                Assert.assertTrue(s1.equals(s2));
70
                Assert.assertTrue(s1.equals(s2));
-
 
71
        }
-
 
72
       
-
 
73
        private static class MyThread extends Thread {
-
 
74
               
-
 
75
                private final Container c;
-
 
76
                private final String key;
-
 
77
                private String value = null;
-
 
78
               
-
 
79
                public MyThread(Container c, String key) {
-
 
80
                        super();
-
 
81
                        this.c = c;
-
 
82
                        this.key = key;
-
 
83
                }
-
 
84
               
-
 
85
                @Override
-
 
86
                public void run() {
-
 
87
                       
-
 
88
                        for(int i = 0; i < 50; i++) {
-
 
89
                       
-
 
90
                                String v = c.get(key);
-
 
91
                               
-
 
92
                                if (this.value != null) {
-
 
93
                                       
-
 
94
                                        Assert.assertTrue(this.value == v);
-
 
95
                                       
-
 
96
                                }
-
 
97
                                       
-
 
98
                                this.value = v;
-
 
99
                        }
-
 
100
                }
-
 
101
               
-
 
102
                public String getValue() { return value; }
-
 
103
        }
-
 
104
       
-
 
105
        @Test
-
 
106
        public void testThreadLocal() throws Exception {
-
 
107
               
-
 
108
                final Container c = new MentaContainer();
-
 
109
               
-
 
110
                c.ioc("myStr", String.class, Scope.THREAD).addInitValue("saoj");
-
 
111
               
-
 
112
                String s1 = c.get("myStr");
-
 
113
               
-
 
114
                MyThread t1 = new MyThread(c, "myStr");
-
 
115
                MyThread t2 = new MyThread(c, "myStr");
-
 
116
               
-
 
117
                t1.start();
-
 
118
                t2.start();
-
 
119
               
-
 
120
                t1.join();
-
 
121
                t2.join();
-
 
122
               
-
 
123
                String s2 = t1.getValue();
-
 
124
                String s3 = t2.getValue();
-
 
125
               
-
 
126
                Assert.assertTrue(s1 != s2);
-
 
127
                Assert.assertTrue(s2 != s3);
70
        }
128
        }
71
129
72
        public static interface MyDAO {
130
        public static interface MyDAO {
73
               
131
               
74
                public Object getSomething();
132
                public Object getSomething();
75
               
133
               
76
        }
134
        }
77
       
135
       
78
        public static class SomeDependency {
136
        public static class SomeDependency {
79
               
137
               
80
                private String name;
138
                private String name;
81
               
139
               
82
                public SomeDependency() { }
140
                public SomeDependency() { }
83
               
141
               
84
                public void setName(String name) {
142
                public void setName(String name) {
85
                        this.name = name;
143
                        this.name = name;
86
                }
144
                }
87
               
145
               
88
                public String getName() {
146
                public String getName() {
89
                        return name;
147
                        return name;
90
                }
148
                }
91
        }
149
        }
92
       
150
       
93
        public static class Connection {
151
        public static class Connection {
94
               
152
               
95
                private final String name;
153
                private final String name;
96
               
154
               
97
                private SomeDependency dep;
155
                private SomeDependency dep;
98
               
156
               
99
                public Connection(String name) {
157
                public Connection(String name) {
100
                        this.name = name;
158
                        this.name = name;
101
                }
159
                }
102
               
160
               
103
                public String toString() {
161
                public String toString() {
104
                        return getClass().getName() + ": " + name;
162
                        return getClass().getName() + ": " + name;
105
                }
163
                }
106
               
164
               
107
                public String getName() { return name; }
165
                public String getName() { return name; }
108
               
166
               
109
                public void setMyDep(SomeDependency dep) { this.dep = dep; }
167
                public void setMyDep(SomeDependency dep) { this.dep = dep; }
110
               
168
               
111
                public SomeDependency getMyDep() { return dep; }
169
                public SomeDependency getMyDep() { return dep; }
112
        }
170
        }
113
       
171
       
114
       
172
       
115
       
173
       
116
        public static class JdbcMyDAO implements MyDAO {
174
        public static class JdbcMyDAO implements MyDAO {
117
               
175
               
118
                private Connection conn;
176
                private Connection conn;
119
               
177
               
120
                public void setConn(Connection conn) { this.conn = conn; }
178
                public void setConn(Connection conn) { this.conn = conn; }
121
               
179
               
122
                public Connection getConn() { return conn; }
180
                public Connection getConn() { return conn; }
123
               
181
               
124
                public Object getSomething() {
182
                public Object getSomething() {
125
                       
183
                       
126
                        // use the connection to do something...
184
                        // use the connection to do something...
127
                       
185
                       
128
                        Assert.assertNotNull(conn); // it cannot be null!
186
                        Assert.assertNotNull(conn); // it cannot be null!
129
                       
187
                       
130
                        // also test if the connection also received the myDep dependency...
188
                        // also test if the connection also received the myDep dependency...
131
                       
189
                       
132
                        Assert.assertNotNull(conn.getMyDep());
190
                        Assert.assertNotNull(conn.getMyDep());
133
                       
191
                       
134
                        return conn.toString();
192
                        return conn.toString();
135
                }
193
                }
136
        }
194
        }
137
       
195
       
138
        private Container getConfiguredContainer() {
196
        private Container getConfiguredContainer() {
139
               
197
               
140
                Container c = new MentaContainer();
198
                Container c = new MentaContainer();
141
               
199
               
142
                c.ioc("myDAO", JdbcMyDAO.class);
200
                c.ioc("myDAO", JdbcMyDAO.class);
143
               
201
               
144
                c.ioc("aDependency", SomeDependency.class, true /* singleton */).addProperty("name", "A super dependency!");
-
 
-
 
202
                c.ioc("aDependency", SomeDependency.class, Scope.SINGLETON).addProperty("name", "A super dependency!");
145
               
203
               
146
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
204
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
147
               
205
               
148
                c.autowire("conn" /* the property name that will receive the dependency */,
206
                c.autowire("conn" /* the property name that will receive the dependency */,
149
                                   Connection.class /* the type of the property that will receive the dependency */,
207
                                   Connection.class /* the type of the property that will receive the dependency */,
150
                                   "connection" /* the source inside the container */);
208
                                   "connection" /* the source inside the container */);
151
               
209
               
152
                c.autowire("myDep" /* notice this is the setter of the Connection class */,
210
                c.autowire("myDep" /* notice this is the setter of the Connection class */,
153
                                   SomeDependency.class /* the type - it could be an interface for better decoupling */,
211
                                   SomeDependency.class /* the type - it could be an interface for better decoupling */,
154
                                   "aDependency" /* again this is the name of the bean/component inside the container */);
212
                                   "aDependency" /* again this is the name of the bean/component inside the container */);
155
               
213
               
156
                return c;
214
                return c;
157
        }
215
        }
158
       
216
       
159
        @Test
217
        @Test
160
        public void testAutoWiring() {
218
        public void testAutoWiring() {
161
               
219
               
162
                Container c = getConfiguredContainer();
220
                Container c = getConfiguredContainer();
163
               
221
               
164
                MyDAO myDAO = c.get("myDAO");
222
                MyDAO myDAO = c.get("myDAO");
165
               
223
               
166
                // check implementation...
224
                // check implementation...
167
               
225
               
168
                Assert.assertEquals(JdbcMyDAO.class, myDAO.getClass());
226
                Assert.assertEquals(JdbcMyDAO.class, myDAO.getClass());
169
               
227
               
170
                // check dependency...
228
                // check dependency...
171
               
229
               
172
                Connection conn = ((JdbcMyDAO) myDAO).getConn();
230
                Connection conn = ((JdbcMyDAO) myDAO).getConn();
173
               
231
               
174
                Assert.assertNotNull(conn);
232
                Assert.assertNotNull(conn);
175
               
233
               
176
                Assert.assertEquals("A super JDBC connection!", conn.getName());
234
                Assert.assertEquals("A super JDBC connection!", conn.getName());
177
               
235
               
178
                // check dependency of dependency...
236
                // check dependency of dependency...
179
               
237
               
180
                Assert.assertEquals(c.get("aDependency"), conn.getMyDep());
238
                Assert.assertEquals(c.get("aDependency"), conn.getMyDep());
181
               
239
               
182
                Assert.assertTrue(c.get("aDependency") == conn.getMyDep()); // singleton!
240
                Assert.assertTrue(c.get("aDependency") == conn.getMyDep()); // singleton!
183
               
241
               
184
                // check DAO can do its job...
242
                // check DAO can do its job...
185
               
243
               
186
                Assert.assertNotNull(myDAO.getSomething());
244
                Assert.assertNotNull(myDAO.getSomething());
187
        }
245
        }
188
       
246
       
189
        public static class SomeAction {
247
        public static class SomeAction {
190
               
248
               
191
                private MyDAO myDAO = null;
249
                private MyDAO myDAO = null;
192
               
250
               
193
                public void setMyDAO(MyDAO myDAO) {
251
                public void setMyDAO(MyDAO myDAO) {
194
                       
252
                       
195
                        this.myDAO = myDAO;
253
                        this.myDAO = myDAO;
196
                }
254
                }
197
               
255
               
198
                public MyDAO getMyDAO() { return myDAO; }
256
                public MyDAO getMyDAO() { return myDAO; }
199
        }
257
        }
200
       
258
       
201
        public void testPopulate() {
259
        public void testPopulate() {
202
               
260
               
203
                Container c = getConfiguredContainer();
261
                Container c = getConfiguredContainer();
204
               
262
               
205
                SomeAction a = new SomeAction();
263
                SomeAction a = new SomeAction();
206
               
264
               
207
                c.populate(a); // great... properties of SomeAction were populated by container...
265
                c.populate(a); // great... properties of SomeAction were populated by container...
208
               
266
               
209
                // let's check if myDAO was injected...
267
                // let's check if myDAO was injected...
210
               
268
               
211
                Assert.assertNotNull(a.getMyDAO());
269
                Assert.assertNotNull(a.getMyDAO());
212
               
270
               
213
                // also check if myDAO was corrected wired...
271
                // also check if myDAO was corrected wired...
214
               
272
               
215
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConn();
273
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConn();
216
               
274
               
217
                Assert.assertNotNull(conn);
275
                Assert.assertNotNull(conn);
218
               
276
               
219
                // check if conn was also wired...
277
                // check if conn was also wired...
220
               
278
               
221
                Assert.assertNotNull(conn.getMyDep());
279
                Assert.assertNotNull(conn.getMyDep());
222
               
280
               
223
        }
281
        }
224
}
282
}