MentaContainer

Rev

Rev 58 | Rev 70 | 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;
64 soliveira 6
import org.mentacontainer.Clearable;
7
import org.mentacontainer.Component;
4 soliveira 8
import org.mentacontainer.Container;
57 soliveira 9
import org.mentacontainer.Scope;
4 soliveira 10
 
11
public class MentaContainerTest {
20 soliveira 12
 
13
        @Test
14
        public void testSimpleGet() {
15
 
16
                Container c = new MentaContainer();
17
 
18
                c.ioc("myStr", String.class);
19
 
20
                Assert.assertEquals("", c.get("myStr"));
21
 
41 soliveira 22
                String s1 = c.get("myStr");
20 soliveira 23
 
41 soliveira 24
                String s2 = c.get("myStr");
20 soliveira 25
 
26
                Assert.assertTrue(s1 != s2);
27
 
28
                Assert.assertTrue(s1.equals(s2));
29
        }
30
 
31
        @Test
32
        public void testConstructorInit() {
33
 
34
                Container c = new MentaContainer();
35
 
36
                c.ioc("myStr", String.class).addInitValue("hello");
37
 
38
                Assert.assertEquals("hello", c.get("myStr"));
39
 
41 soliveira 40
                String s1 = c.get("myStr");
20 soliveira 41
 
41 soliveira 42
                String s2 = c.get("myStr");
20 soliveira 43
 
44
                Assert.assertTrue(s1 != s2);
45
 
46
                Assert.assertTrue(s1.equals(s2));
47
 
48
                c.ioc("anotherStr", String.class).addInitValue("hi");
49
 
41 soliveira 50
                String s3 = c.get("anotherStr");
20 soliveira 51
 
52
                Assert.assertTrue(s1 != s3);
53
 
54
                Assert.assertFalse(s1.equals(s3));
55
        }
56
 
57
        @Test
58
        public void testSingleton() {
59
 
60
                Container c = new MentaContainer();
61
 
57 soliveira 62
                c.ioc("myStr", String.class, Scope.SINGLETON).addInitValue("hello");
20 soliveira 63
 
64
                Assert.assertEquals("hello", c.get("myStr"));
65
 
41 soliveira 66
                String s1 = c.get("myStr");
20 soliveira 67
 
41 soliveira 68
                String s2 = c.get("myStr");
20 soliveira 69
 
70
                Assert.assertTrue(s1 == s2);
71
 
72
                Assert.assertTrue(s1.equals(s2));
73
        }
57 soliveira 74
 
58 soliveira 75
        @Test
76
        public void testCheckAndClear() {
77
 
78
                Container c = new MentaContainer();
79
 
80
                c.ioc("myStr", String.class, Scope.SINGLETON).addInitValue("hello");
81
 
82
                Assert.assertEquals(false, c.check("myStr"));
83
 
84
                String s1 = c.get("myStr");
85
 
86
                Assert.assertEquals(true, c.check("myStr"));
87
 
88
                String s2 = c.get("myStr");
89
 
90
                Assert.assertTrue(s1 == s2);
91
 
92
                c.clear(Scope.SINGLETON);
93
 
94
                Assert.assertEquals(false, c.check("myStr"));
95
 
96
                String s3 = c.get("myStr");
97
 
98
                Assert.assertTrue(s3 != s2);
99
        }
100
 
57 soliveira 101
        private static class MyThread extends Thread {
102
 
103
                private final Container c;
104
                private final String key;
105
                private String value = null;
106
 
107
                public MyThread(Container c, String key) {
108
                        super();
109
                        this.c = c;
110
                        this.key = key;
111
                }
112
 
113
                @Override
114
                public void run() {
115
 
116
                        for(int i = 0; i < 50; i++) {
117
 
118
                                String v = c.get(key);
119
 
120
                                if (this.value != null) {
121
 
122
                                        Assert.assertTrue(this.value == v);
123
 
124
                                }
125
 
126
                                this.value = v;
127
                        }
128
                }
129
 
130
                public String getValue() { return value; }
131
        }
132
 
133
        @Test
134
        public void testThreadLocal() throws Exception {
135
 
136
                final Container c = new MentaContainer();
137
 
138
                c.ioc("myStr", String.class, Scope.THREAD).addInitValue("saoj");
139
 
140
                String s1 = c.get("myStr");
141
 
142
                MyThread t1 = new MyThread(c, "myStr");
143
                MyThread t2 = new MyThread(c, "myStr");
144
 
145
                t1.start();
146
                t2.start();
147
 
148
                t1.join();
149
                t2.join();
150
 
151
                String s2 = t1.getValue();
152
                String s3 = t2.getValue();
153
 
154
                Assert.assertTrue(s1 != s2);
155
                Assert.assertTrue(s2 != s3);
156
        }
20 soliveira 157
 
26 soliveira 158
        public static interface MyDAO {
159
 
160
                public Object getSomething();
161
 
162
        }
163
 
27 soliveira 164
        public static class SomeDependency {
165
 
166
                private String name;
167
 
168
                public SomeDependency() { }
169
 
170
                public void setName(String name) {
171
                        this.name = name;
172
                }
173
 
174
                public String getName() {
175
                        return name;
176
                }
177
        }
178
 
26 soliveira 179
        public static class Connection {
180
 
181
                private final String name;
182
 
27 soliveira 183
                private SomeDependency dep;
184
 
26 soliveira 185
                public Connection(String name) {
186
                        this.name = name;
187
                }
188
 
189
                public String toString() {
190
                        return getClass().getName() + ": " + name;
191
                }
192
 
193
                public String getName() { return name; }
27 soliveira 194
 
195
                public void setMyDep(SomeDependency dep) { this.dep = dep; }
196
 
197
                public SomeDependency getMyDep() { return dep; }
26 soliveira 198
        }
199
 
27 soliveira 200
 
201
 
26 soliveira 202
        public static class JdbcMyDAO implements MyDAO {
203
 
204
                private Connection conn;
205
 
206
                public void setConn(Connection conn) { this.conn = conn; }
207
 
208
                public Connection getConn() { return conn; }
209
 
210
                public Object getSomething() {
211
 
28 soliveira 212
                        // use the connection to do something...
26 soliveira 213
 
28 soliveira 214
                        Assert.assertNotNull(conn); // it cannot be null!
215
 
216
                        // also test if the connection also received the myDep dependency...
217
 
218
                        Assert.assertNotNull(conn.getMyDep());
219
 
220
                        return conn.toString();
26 soliveira 221
                }
222
        }
223
 
28 soliveira 224
        private Container getConfiguredContainer() {
26 soliveira 225
 
226
                Container c = new MentaContainer();
227
 
228
                c.ioc("myDAO", JdbcMyDAO.class);
229
 
57 soliveira 230
                c.ioc("aDependency", SomeDependency.class, Scope.SINGLETON).addProperty("name", "A super dependency!");
27 soliveira 231
 
26 soliveira 232
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
233
 
234
                c.autowire("conn" /* the property name that will receive the dependency */,
235
                                   Connection.class /* the type of the property that will receive the dependency */,
236
                                   "connection" /* the source inside the container */);
237
 
27 soliveira 238
                c.autowire("myDep" /* notice this is the setter of the Connection class */,
239
                                   SomeDependency.class /* the type - it could be an interface for better decoupling */,
240
                                   "aDependency" /* again this is the name of the bean/component inside the container */);
241
 
28 soliveira 242
                return c;
243
        }
244
 
245
        @Test
246
        public void testAutoWiring() {
247
 
248
                Container c = getConfiguredContainer();
249
 
41 soliveira 250
                MyDAO myDAO = c.get("myDAO");
26 soliveira 251
 
252
                // check implementation...
253
 
254
                Assert.assertEquals(JdbcMyDAO.class, myDAO.getClass());
255
 
256
                // check dependency...
257
 
258
                Connection conn = ((JdbcMyDAO) myDAO).getConn();
259
 
260
                Assert.assertNotNull(conn);
261
 
262
                Assert.assertEquals("A super JDBC connection!", conn.getName());
263
 
27 soliveira 264
                // check dependency of dependency...
265
 
266
                Assert.assertEquals(c.get("aDependency"), conn.getMyDep());
267
 
268
                Assert.assertTrue(c.get("aDependency") == conn.getMyDep()); // singleton!
269
 
270
                // check DAO can do its job...
271
 
26 soliveira 272
                Assert.assertNotNull(myDAO.getSomething());
273
        }
28 soliveira 274
 
275
        public static class SomeAction {
276
 
277
                private MyDAO myDAO = null;
278
 
279
                public void setMyDAO(MyDAO myDAO) {
280
 
281
                        this.myDAO = myDAO;
282
                }
283
 
284
                public MyDAO getMyDAO() { return myDAO; }
285
        }
286
 
64 soliveira 287
        @Test
40 soliveira 288
        public void testPopulate() {
28 soliveira 289
 
290
                Container c = getConfiguredContainer();
291
 
292
                SomeAction a = new SomeAction();
293
 
294
                c.populate(a); // great... properties of SomeAction were populated by container...
295
 
296
                // let's check if myDAO was injected...
297
 
298
                Assert.assertNotNull(a.getMyDAO());
299
 
300
                // also check if myDAO was corrected wired...
301
 
302
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConn();
303
 
304
                Assert.assertNotNull(conn);
305
 
306
                // check if conn was also wired...
307
 
308
                Assert.assertNotNull(conn.getMyDep());
64 soliveira 309
        }
310
 
311
        private static class SomeObject {
28 soliveira 312
 
64 soliveira 313
                private boolean cleared = false;
314
 
315
                public void clear() { this.cleared = true; }
316
 
317
                public boolean isCleared() { return cleared; }
28 soliveira 318
        }
64 soliveira 319
 
320
        private static class SomeComponent implements Component, Clearable<SomeObject> {
321
 
322
                public <T> T getInstance() {
323
 
324
                        return (T) new SomeObject();
325
                }
326
 
327
                public void onCleared(SomeObject obj) {
328
 
329
                        obj.clear();
330
                }
331
        }
332
 
333
        @Test
334
        public void testClearable() {
335
 
336
                Container c = new MentaContainer();
337
 
338
                c.ioc("o", new SomeComponent(), Scope.SINGLETON);
339
 
340
                SomeObject o = c.get("o");
341
 
342
                c.clear(Scope.SINGLETON);
343
 
344
                Assert.assertEquals(true, o.isCleared());
345
 
346
                c.ioc("o", new SomeComponent(), Scope.THREAD);
347
 
348
                o = c.get("o");
349
 
350
                c.clear(Scope.SINGLETON);
351
 
352
                Assert.assertEquals(false, o.isCleared());
353
 
354
                c.clear(Scope.THREAD);
355
 
356
                Assert.assertEquals(true, o.isCleared());
357
 
358
                c.ioc("o", new SomeComponent(), Scope.NONE);
359
 
360
                o = c.get("o");
361
 
362
                o = c.clear("o");
363
 
364
                Assert.assertNull(o);
365
 
366
                c.ioc("o", new SomeComponent(), Scope.THREAD);
367
 
368
                o = c.clear("o");
369
 
370
                Assert.assertNull(o);
371
 
372
                o = c.get("o");
373
 
374
                o = c.clear("o");
375
 
376
                Assert.assertEquals(true, o.isCleared());
377
        }
378
 
4 soliveira 379
}