MentaContainer

Rev

Rev 41 | Rev 57 | 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;
7
 
8
public class MentaContainerTest {
20 soliveira 9
 
10
        @Test
11
        public void testSimpleGet() {
12
 
13
                Container c = new MentaContainer();
14
 
15
                c.ioc("myStr", String.class);
16
 
17
                Assert.assertEquals("", c.get("myStr"));
18
 
41 soliveira 19
                String s1 = c.get("myStr");
20 soliveira 20
 
41 soliveira 21
                String s2 = c.get("myStr");
20 soliveira 22
 
23
                Assert.assertTrue(s1 != s2);
24
 
25
                Assert.assertTrue(s1.equals(s2));
26
        }
27
 
28
        @Test
29
        public void testConstructorInit() {
30
 
31
                Container c = new MentaContainer();
32
 
33
                c.ioc("myStr", String.class).addInitValue("hello");
34
 
35
                Assert.assertEquals("hello", c.get("myStr"));
36
 
41 soliveira 37
                String s1 = c.get("myStr");
20 soliveira 38
 
41 soliveira 39
                String s2 = c.get("myStr");
20 soliveira 40
 
41
                Assert.assertTrue(s1 != s2);
42
 
43
                Assert.assertTrue(s1.equals(s2));
44
 
45
                c.ioc("anotherStr", String.class).addInitValue("hi");
46
 
41 soliveira 47
                String s3 = c.get("anotherStr");
20 soliveira 48
 
49
                Assert.assertTrue(s1 != s3);
50
 
51
                Assert.assertFalse(s1.equals(s3));
52
        }
53
 
54
        @Test
55
        public void testSingleton() {
56
 
57
                Container c = new MentaContainer();
58
 
59
                c.ioc("myStr", String.class, true).addInitValue("hello");
60
 
61
                Assert.assertEquals("hello", c.get("myStr"));
62
 
41 soliveira 63
                String s1 = c.get("myStr");
20 soliveira 64
 
41 soliveira 65
                String s2 = c.get("myStr");
20 soliveira 66
 
67
                Assert.assertTrue(s1 == s2);
68
 
69
                Assert.assertTrue(s1.equals(s2));
70
        }
71
 
26 soliveira 72
        public static interface MyDAO {
73
 
74
                public Object getSomething();
75
 
76
        }
77
 
27 soliveira 78
        public static class SomeDependency {
79
 
80
                private String name;
81
 
82
                public SomeDependency() { }
83
 
84
                public void setName(String name) {
85
                        this.name = name;
86
                }
87
 
88
                public String getName() {
89
                        return name;
90
                }
91
        }
92
 
26 soliveira 93
        public static class Connection {
94
 
95
                private final String name;
96
 
27 soliveira 97
                private SomeDependency dep;
98
 
26 soliveira 99
                public Connection(String name) {
100
                        this.name = name;
101
                }
102
 
103
                public String toString() {
104
                        return getClass().getName() + ": " + name;
105
                }
106
 
107
                public String getName() { return name; }
27 soliveira 108
 
109
                public void setMyDep(SomeDependency dep) { this.dep = dep; }
110
 
111
                public SomeDependency getMyDep() { return dep; }
26 soliveira 112
        }
113
 
27 soliveira 114
 
115
 
26 soliveira 116
        public static class JdbcMyDAO implements MyDAO {
117
 
118
                private Connection conn;
119
 
120
                public void setConn(Connection conn) { this.conn = conn; }
121
 
122
                public Connection getConn() { return conn; }
123
 
124
                public Object getSomething() {
125
 
28 soliveira 126
                        // use the connection to do something...
26 soliveira 127
 
28 soliveira 128
                        Assert.assertNotNull(conn); // it cannot be null!
129
 
130
                        // also test if the connection also received the myDep dependency...
131
 
132
                        Assert.assertNotNull(conn.getMyDep());
133
 
134
                        return conn.toString();
26 soliveira 135
                }
136
        }
137
 
28 soliveira 138
        private Container getConfiguredContainer() {
26 soliveira 139
 
140
                Container c = new MentaContainer();
141
 
142
                c.ioc("myDAO", JdbcMyDAO.class);
143
 
27 soliveira 144
                c.ioc("aDependency", SomeDependency.class, true /* singleton */).addProperty("name", "A super dependency!");
145
 
26 soliveira 146
                c.ioc("connection", Connection.class).addInitValue("A super JDBC connection!");
147
 
148
                c.autowire("conn" /* the property name that will receive the dependency */,
149
                                   Connection.class /* the type of the property that will receive the dependency */,
150
                                   "connection" /* the source inside the container */);
151
 
27 soliveira 152
                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 */,
154
                                   "aDependency" /* again this is the name of the bean/component inside the container */);
155
 
28 soliveira 156
                return c;
157
        }
158
 
159
        @Test
160
        public void testAutoWiring() {
161
 
162
                Container c = getConfiguredContainer();
163
 
41 soliveira 164
                MyDAO myDAO = c.get("myDAO");
26 soliveira 165
 
166
                // check implementation...
167
 
168
                Assert.assertEquals(JdbcMyDAO.class, myDAO.getClass());
169
 
170
                // check dependency...
171
 
172
                Connection conn = ((JdbcMyDAO) myDAO).getConn();
173
 
174
                Assert.assertNotNull(conn);
175
 
176
                Assert.assertEquals("A super JDBC connection!", conn.getName());
177
 
27 soliveira 178
                // check dependency of dependency...
179
 
180
                Assert.assertEquals(c.get("aDependency"), conn.getMyDep());
181
 
182
                Assert.assertTrue(c.get("aDependency") == conn.getMyDep()); // singleton!
183
 
184
                // check DAO can do its job...
185
 
26 soliveira 186
                Assert.assertNotNull(myDAO.getSomething());
187
        }
28 soliveira 188
 
189
        public static class SomeAction {
190
 
191
                private MyDAO myDAO = null;
192
 
193
                public void setMyDAO(MyDAO myDAO) {
194
 
195
                        this.myDAO = myDAO;
196
                }
197
 
198
                public MyDAO getMyDAO() { return myDAO; }
199
        }
200
 
40 soliveira 201
        public void testPopulate() {
28 soliveira 202
 
203
                Container c = getConfiguredContainer();
204
 
205
                SomeAction a = new SomeAction();
206
 
207
                c.populate(a); // great... properties of SomeAction were populated by container...
208
 
209
                // let's check if myDAO was injected...
210
 
211
                Assert.assertNotNull(a.getMyDAO());
212
 
213
                // also check if myDAO was corrected wired...
214
 
215
                Connection conn = ((JdbcMyDAO) a.getMyDAO()).getConn();
216
 
217
                Assert.assertNotNull(conn);
218
 
219
                // check if conn was also wired...
220
 
221
                Assert.assertNotNull(conn.getMyDep());
222
 
223
        }
4 soliveira 224
}