MentaContainer

Rev

Rev 141 | Rev 146 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4 soliveira 1
package org.mentacontainer.impl;
2
 
3
import junit.framework.Assert;
4
 
5
import org.junit.Test;
6
import org.mentacontainer.Container;
57 soliveira 7
import org.mentacontainer.Scope;
4 soliveira 8
 
9
public class MentaContainerTest {
20 soliveira 10
 
11
        @Test
12
        public void testSimpleGet() {
13
 
14
                Container c = new MentaContainer();
15
 
16
                c.ioc("myStr", String.class);
17
 
18
                Assert.assertEquals("", c.get("myStr"));
19
 
41 soliveira 20
                String s1 = c.get("myStr");
20 soliveira 21
 
41 soliveira 22
                String s2 = c.get("myStr");
20 soliveira 23
 
24
                Assert.assertTrue(s1 != s2);
25
 
26
                Assert.assertTrue(s1.equals(s2));
27
        }
28
 
29
        @Test
30
        public void testConstructorInit() {
31
 
32
                Container c = new MentaContainer();
33
 
34
                c.ioc("myStr", String.class).addInitValue("hello");
35
 
36
                Assert.assertEquals("hello", c.get("myStr"));
37
 
41 soliveira 38
                String s1 = c.get("myStr");
20 soliveira 39
 
41 soliveira 40
                String s2 = c.get("myStr");
20 soliveira 41
 
42
                Assert.assertTrue(s1 != s2);
43
 
44
                Assert.assertTrue(s1.equals(s2));
45
 
46
                c.ioc("anotherStr", String.class).addInitValue("hi");
47
 
41 soliveira 48
                String s3 = c.get("anotherStr");
20 soliveira 49
 
50
                Assert.assertTrue(s1 != s3);
51
 
52
                Assert.assertFalse(s1.equals(s3));
53
        }
54
 
55
        @Test
56
        public void testSingleton() {
57
 
58
                Container c = new MentaContainer();
59
 
57 soliveira 60
                c.ioc("myStr", String.class, Scope.SINGLETON).addInitValue("hello");
20 soliveira 61
 
62
                Assert.assertEquals("hello", c.get("myStr"));
63
 
41 soliveira 64
                String s1 = c.get("myStr");
20 soliveira 65
 
41 soliveira 66
                String s2 = c.get("myStr");
20 soliveira 67
 
68
                Assert.assertTrue(s1 == s2);
69
 
70
                Assert.assertTrue(s1.equals(s2));
71
        }
57 soliveira 72
 
58 soliveira 73
        @Test
74
        public void testCheckAndClear() {
75
 
76
                Container c = new MentaContainer();
77
 
78
                c.ioc("myStr", String.class, Scope.SINGLETON).addInitValue("hello");
79
 
80
                Assert.assertEquals(false, c.check("myStr"));
81
 
82
                String s1 = c.get("myStr");
83
 
84
                Assert.assertEquals(true, c.check("myStr"));
85
 
86
                String s2 = c.get("myStr");
87
 
88
                Assert.assertTrue(s1 == s2);
89
 
90
                c.clear(Scope.SINGLETON);
91
 
92
                Assert.assertEquals(false, c.check("myStr"));
93
 
94
                String s3 = c.get("myStr");
95
 
96
                Assert.assertTrue(s3 != s2);
97
        }
98
 
57 soliveira 99
        private static class MyThread extends Thread {
100
 
101
                private final Container c;
102
                private final String key;
103
                private String value = null;
104
 
105
                public MyThread(Container c, String key) {
106
                        super();
107
                        this.c = c;
108
                        this.key = key;
109
                }
110
 
111
                @Override
112
                public void run() {
113
 
114
                        for(int i = 0; i < 50; i++) {
115
 
116
                                String v = c.get(key);
117
 
118
                                if (this.value != null) {
119
 
120
                                        Assert.assertTrue(this.value == v);
121
 
122
                                }
123
 
124
                                this.value = v;
125
                        }
126
                }
127
 
128
                public String getValue() { return value; }
129
        }
130
 
131
        @Test
70 soliveira 132
        public void testScopes() {
133
 
134
                Container c = new MentaContainer();
135
 
136
                // if you don't provide a scope the Scope is NONE
137
                // meaning a new instance is created on every
95 soliveira 138
                // request for the bean
70 soliveira 139
 
140
                c.ioc("myString", String.class).addInitValue("saoj");
141
 
142
                String s1 = c.get("myString");
143
                String s2 = c.get("myString");
144
 
145
                Assert.assertTrue(s1 != s2);
146
 
147
                // then you can use SINGLETON
148
                // always get the same instance no matter what
149
 
150
                c.ioc("myString", String.class, Scope.SINGLETON).addInitValue("saoj");
151
 
152
                s1 = c.get("myString");
153
                s2 = c.get("myString");
154
 
155
                Assert.assertTrue(s1 == s2);
156
 
157
                // then you can use THREAD
158
                // each thread will get a different instance
159
 
160
                c.ioc("myString", String.class, Scope.THREAD).addInitValue("saoj");
161
 
162
                s1 = c.get("myString");
163
                s2 = c.get("myString");
164
 
165
                Assert.assertTrue(s1 == s2); // same thread
166
        }
167
 
168
        @Test
57 soliveira 169
        public void testThreadLocal() throws Exception {
170
 
171
                final Container c = new MentaContainer();
172
 
173
                c.ioc("myStr", String.class, Scope.THREAD).addInitValue("saoj");
174
 
175
                String s1 = c.get("myStr");
176
 
177
                MyThread t1 = new MyThread(c, "myStr");
178
                MyThread t2 = new MyThread(c, "myStr");
179
 
180
                t1.start();
181
                t2.start();
182
 
183
                t1.join();
184
                t2.join();
185
 
186
                String s2 = t1.getValue();
187
                String s3 = t2.getValue();
188
 
189
                Assert.assertTrue(s1 != s2);
190
                Assert.assertTrue(s2 != s3);
191
        }
20 soliveira 192
 
26 soliveira 193
        public static interface MyDAO {
194
 
195
                public Object getSomething();
196
 
197
        }
198
 
27 soliveira 199
        public static class SomeDependency {
200
 
201
                private String name;
202
 
203
                public SomeDependency() { }
204
 
205
                public void setName(String name) {
206
                        this.name = name;
207
                }
208
 
209
                public String getName() {
210
                        return name;
211
                }
212
        }
213
 
26 soliveira 214
        public static class Connection {
215
 
216
                private final String name;
217
 
27 soliveira 218
                private SomeDependency dep;
219
 
26 soliveira 220
                public Connection(String name) {
221
                        this.name = name;
222
                }
223
 
84 soliveira 224
                @Override
26 soliveira 225
                public String toString() {
226
                        return getClass().getName() + ": " + name;
227
                }
228
 
229
                public String getName() { return name; }
27 soliveira 230
 
231
                public void setMyDep(SomeDependency dep) { this.dep = dep; }
232
 
233
                public SomeDependency getMyDep() { return dep; }
26 soliveira 234
        }
235
 
27 soliveira 236
 
237
 
26 soliveira 238
        public static class JdbcMyDAO implements MyDAO {
239
 
240
                private Connection conn;
241
 
101 soliveira 242
                public void setConnection(Connection conn) { this.conn = conn; }
26 soliveira 243
 
101 soliveira 244
                public Connection getConnection() { return conn; }
26 soliveira 245
 
84 soliveira 246
                @Override
26 soliveira 247
                public Object getSomething() {
248
 
28 soliveira 249
                        // use the connection to do something...
26 soliveira 250
 
28 soliveira 251
                        Assert.assertNotNull(conn); // it cannot be null!
252
 
253
                        // also test if the connection also received the myDep dependency...
254
 
255
                        Assert.assertNotNull(conn.getMyDep());
256
 
257
                        return conn.toString();
26 soliveira 258
                }
259
        }
260
 
28 soliveira 261
        private Container getConfiguredContainer() {
26 soliveira 262
 
263
                Container c = new MentaContainer();
264
 
265
                c.ioc("myDAO", JdbcMyDAO.class);
266
 
91 soliveira 267
                c.ioc("aDependency", SomeDependency.class, Scope.SINGLETON).addPropertyValue("name", "A super dependency!");
27 soliveira 268
 
26 soliveira 269
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
270
 
101 soliveira 271
                c.autowire("connection");
26 soliveira 272
 
101 soliveira 273
                c.autowire("aDependency", "myDep");
27 soliveira 274
 
28 soliveira 275
                return c;
276
        }
277
 
278
        @Test
279
        public void testAutoWiring() {
280
 
281
                Container c = getConfiguredContainer();
282
 
41 soliveira 283
                MyDAO myDAO = c.get("myDAO");
26 soliveira 284
 
285
                // check implementation...
286
 
287
                Assert.assertEquals(JdbcMyDAO.class, myDAO.getClass());
288
 
289
                // check dependency...
290
 
101 soliveira 291
                Connection conn = ((JdbcMyDAO) myDAO).getConnection();
26 soliveira 292
 
293
                Assert.assertNotNull(conn);
294
 
295
                Assert.assertEquals("A super JDBC connection!", conn.getName());
296
 
27 soliveira 297
                // check dependency of dependency...
298
 
299
                Assert.assertEquals(c.get("aDependency"), conn.getMyDep());
300
 
301
                Assert.assertTrue(c.get("aDependency") == conn.getMyDep()); // singleton!
302
 
303
                // check DAO can do its job...
304
 
26 soliveira 305
                Assert.assertNotNull(myDAO.getSomething());
306
        }
28 soliveira 307
 
115 soliveira 308
        public static class MyObject1 {
309
 
310
        }
311
 
312
        public static class MyObject2 {
313
 
314
        }
315
 
316
        public static class MyObject3 {
317
 
318
                public MyObject3(MyObject2 o2, MyObject1 o1) {
319
 
320
                }
321
        }
322
 
323
        private Container getConfiguredContainer2() {
324
 
325
                Container c = new MentaContainer();
326
 
327
                c.ioc("myObj1", MyObject1.class);
328
                c.ioc("myObj2", MyObject2.class);
329
                c.ioc("myObj3", MyObject3.class);
330
 
331
                c.autowire("myObj1");
332
                c.autowire("myObj2");
333
 
334
                return c;
335
        }
336
 
337
        @Test
338
        public void testAutoWiringWithTwoConstructors() {
339
 
340
                Container c = getConfiguredContainer2();
341
 
342
                MyObject3 obj3 = c.get("myObj3");
343
 
344
                Assert.assertNotNull(obj3);
345
        }
346
 
28 soliveira 347
        public static class SomeAction {
348
 
349
                private MyDAO myDAO = null;
350
 
351
                public void setMyDAO(MyDAO myDAO) {
352
 
353
                        this.myDAO = myDAO;
354
                }
355
 
356
                public MyDAO getMyDAO() { return myDAO; }
357
        }
358
 
64 soliveira 359
        @Test
40 soliveira 360
        public void testPopulate() {
28 soliveira 361
 
362
                Container c = getConfiguredContainer();
363
 
364
                SomeAction a = new SomeAction();
365
 
103 soliveira 366
                c.inject(a); // great... properties of SomeAction were populated by container...
28 soliveira 367
 
368
                // let's check if myDAO was injected...
369
 
370
                Assert.assertNotNull(a.getMyDAO());
371
 
372
                // also check if myDAO was corrected wired...
373
 
101 soliveira 374
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConnection();
28 soliveira 375
 
376
                Assert.assertNotNull(conn);
377
 
378
                // check if conn was also wired...
379
 
380
                Assert.assertNotNull(conn.getMyDep());
64 soliveira 381
        }
382
 
103 soliveira 383
        public static class SomeAction2 {
384
 
385
                private final MyDAO myDAO;
386
 
387
                public SomeAction2(MyDAO myDAO) {
388
                        this.myDAO = myDAO;
389
                }
390
 
391
                public MyDAO getMyDAO() { return myDAO; }
392
 
393
        }
394
 
395
        @Test
396
        public void testConstructorDependency() {
397
 
398
                Container c = new MentaContainer();
399
 
400
                c.ioc("myDAO", JdbcMyDAO.class);
401
 
402
                c.ioc("aDependency", SomeDependency.class, Scope.SINGLETON).addPropertyValue("name", "A super dependency!");
403
 
404
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
405
 
406
                c.autowire("connection");
407
 
408
                c.autowire("aDependency", "myDep");
409
 
139 soliveira 410
                c.ioc("someAction2", SomeAction2.class).addConstructorDependency("myDAO");
103 soliveira 411
 
412
                SomeAction2 action = c.get("someAction2");
413
 
414
                Assert.assertNotNull(action.getMyDAO());
415
        }
416
 
417
        @Test
418
        public void testConstruct() {
419
 
420
                Container c = getConfiguredContainer();
421
 
422
                SomeAction2 a =  c.construct(SomeAction2.class);
423
                // let's check if myDAO was injected...
424
 
425
                Assert.assertNotNull(a.getMyDAO());
426
 
427
                // also check if myDAO was corrected wired...
428
 
429
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConnection();
430
 
431
                Assert.assertNotNull(conn);
432
 
433
                // check if conn was also wired...
434
 
435
                Assert.assertNotNull(conn.getMyDep());
436
        }
4 soliveira 437
}