MentaContainer

Rev

Rev 44 | Rev 58 | 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
 
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);
128
        }
20 soliveira 129
 
26 soliveira 130
        public static interface MyDAO {
131
 
132
                public Object getSomething();
133
 
134
        }
135
 
27 soliveira 136
        public static class SomeDependency {
137
 
138
                private String name;
139
 
140
                public SomeDependency() { }
141
 
142
                public void setName(String name) {
143
                        this.name = name;
144
                }
145
 
146
                public String getName() {
147
                        return name;
148
                }
149
        }
150
 
26 soliveira 151
        public static class Connection {
152
 
153
                private final String name;
154
 
27 soliveira 155
                private SomeDependency dep;
156
 
26 soliveira 157
                public Connection(String name) {
158
                        this.name = name;
159
                }
160
 
161
                public String toString() {
162
                        return getClass().getName() + ": " + name;
163
                }
164
 
165
                public String getName() { return name; }
27 soliveira 166
 
167
                public void setMyDep(SomeDependency dep) { this.dep = dep; }
168
 
169
                public SomeDependency getMyDep() { return dep; }
26 soliveira 170
        }
171
 
27 soliveira 172
 
173
 
26 soliveira 174
        public static class JdbcMyDAO implements MyDAO {
175
 
176
                private Connection conn;
177
 
178
                public void setConn(Connection conn) { this.conn = conn; }
179
 
180
                public Connection getConn() { return conn; }
181
 
182
                public Object getSomething() {
183
 
28 soliveira 184
                        // use the connection to do something...
26 soliveira 185
 
28 soliveira 186
                        Assert.assertNotNull(conn); // it cannot be null!
187
 
188
                        // also test if the connection also received the myDep dependency...
189
 
190
                        Assert.assertNotNull(conn.getMyDep());
191
 
192
                        return conn.toString();
26 soliveira 193
                }
194
        }
195
 
28 soliveira 196
        private Container getConfiguredContainer() {
26 soliveira 197
 
198
                Container c = new MentaContainer();
199
 
200
                c.ioc("myDAO", JdbcMyDAO.class);
201
 
57 soliveira 202
                c.ioc("aDependency", SomeDependency.class, Scope.SINGLETON).addProperty("name", "A super dependency!");
27 soliveira 203
 
26 soliveira 204
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
205
 
206
                c.autowire("conn" /* the property name that will receive the dependency */,
207
                                   Connection.class /* the type of the property that will receive the dependency */,
208
                                   "connection" /* the source inside the container */);
209
 
27 soliveira 210
                c.autowire("myDep" /* notice this is the setter of the Connection class */,
211
                                   SomeDependency.class /* the type - it could be an interface for better decoupling */,
212
                                   "aDependency" /* again this is the name of the bean/component inside the container */);
213
 
28 soliveira 214
                return c;
215
        }
216
 
217
        @Test
218
        public void testAutoWiring() {
219
 
220
                Container c = getConfiguredContainer();
221
 
41 soliveira 222
                MyDAO myDAO = c.get("myDAO");
26 soliveira 223
 
224
                // check implementation...
225
 
226
                Assert.assertEquals(JdbcMyDAO.class, myDAO.getClass());
227
 
228
                // check dependency...
229
 
230
                Connection conn = ((JdbcMyDAO) myDAO).getConn();
231
 
232
                Assert.assertNotNull(conn);
233
 
234
                Assert.assertEquals("A super JDBC connection!", conn.getName());
235
 
27 soliveira 236
                // check dependency of dependency...
237
 
238
                Assert.assertEquals(c.get("aDependency"), conn.getMyDep());
239
 
240
                Assert.assertTrue(c.get("aDependency") == conn.getMyDep()); // singleton!
241
 
242
                // check DAO can do its job...
243
 
26 soliveira 244
                Assert.assertNotNull(myDAO.getSomething());
245
        }
28 soliveira 246
 
247
        public static class SomeAction {
248
 
249
                private MyDAO myDAO = null;
250
 
251
                public void setMyDAO(MyDAO myDAO) {
252
 
253
                        this.myDAO = myDAO;
254
                }
255
 
256
                public MyDAO getMyDAO() { return myDAO; }
257
        }
258
 
40 soliveira 259
        public void testPopulate() {
28 soliveira 260
 
261
                Container c = getConfiguredContainer();
262
 
263
                SomeAction a = new SomeAction();
264
 
265
                c.populate(a); // great... properties of SomeAction were populated by container...
266
 
267
                // let's check if myDAO was injected...
268
 
269
                Assert.assertNotNull(a.getMyDAO());
270
 
271
                // also check if myDAO was corrected wired...
272
 
273
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConn();
274
 
275
                Assert.assertNotNull(conn);
276
 
277
                // check if conn was also wired...
278
 
279
                Assert.assertNotNull(conn.getMyDep());
280
 
281
        }
4 soliveira 282
}