MentaContainer

Rev

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

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