MentaContainer

Rev

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

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