KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > scriptella > driver > ldap > LdifScriptTest


1 /*
2  * Copyright 2006-2007 The Scriptella Project Team.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 package scriptella.driver.ldap;
17
18 import scriptella.AbstractTestCase;
19 import scriptella.driver.ldap.ldif.Entry;
20 import scriptella.driver.ldap.ldif.LdifReader;
21 import scriptella.spi.MockParametersCallbacks;
22 import scriptella.util.ProxyAdapter;
23
24 import javax.naming.CompoundName JavaDoc;
25 import javax.naming.InvalidNameException JavaDoc;
26 import javax.naming.Name JavaDoc;
27 import javax.naming.NamingException JavaDoc;
28 import javax.naming.directory.Attributes JavaDoc;
29 import javax.naming.directory.BasicAttribute JavaDoc;
30 import javax.naming.directory.BasicAttributes JavaDoc;
31 import javax.naming.directory.DirContext JavaDoc;
32 import javax.naming.directory.ModificationItem JavaDoc;
33 import java.io.Reader JavaDoc;
34 import java.io.StringReader JavaDoc;
35
36 /**
37  * Tests for {@link LdifScript}.
38  *
39  * @author Fyodor Kupolov
40  * @version 1.0
41  */

42 public class LdifScriptTest extends AbstractTestCase {
43     private boolean modified;
44
45     protected void setUp() throws Exception JavaDoc {
46         super.setUp();
47         modified=false;
48     }
49
50     public void testGetRelativeDN() throws NamingException JavaDoc {
51         String JavaDoc rootDn = "dc=airius, dc=com";
52         String JavaDoc rDn = "ou=PD Accountants, ou=Product Development, dc=airius, dc=com";
53         Name JavaDoc actual = LdifScript.getRelativeDN(rootDn, rDn);
54         Name JavaDoc expected = newName("ou=PD Accountants, ou=Product Development");
55         assertEquals(expected, actual);
56         //DirContext is boound to a root
57
rootDn = "";
58         rDn = "dc=com";
59         actual = LdifScript.getRelativeDN(rootDn, rDn);
60         expected = newName("dc=com");
61         assertEquals(expected, actual);
62         //rDn doesn't belong to DirContext
63
rootDn = "dc=com";
64         rDn = "ou=test";
65         try {
66             LdifScript.getRelativeDN(rootDn, rDn);
67             fail("getRelativeDN works only when rootDn is a part of rDn");
68         } catch (NamingException JavaDoc e) {
69             //OK
70
}
71     }
72
73     /**
74      * Tests changetype: moddn
75      */

76     public void testModifyModdn() throws NamingException JavaDoc {
77         final Entry e = readEntry(
78                 "# Rename an entry and move all of its children to a new location in\n" +
79                 "# the directory tree (only implemented by LDAPv3 servers).\n" +
80                 "dn: ou=PD Accountants, ou=Product Development, dc=airius, dc=com\n" +
81                 "changetype: moddn\n" +
82                 "newrdn: ou=Product Development Accountants\n" +
83                 "deleteoldrdn: 0\n" +
84                 "newsuperior: ou=Accounting, dc=airius, dc=com\n");
85         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
86             //do not delete old rdn
87
public void addToEnvironment(String JavaDoc p, Object JavaDoc v) {
88                 assertEquals("java.naming.ldap.deleteRDN", p);
89                 assertEquals("false", v);
90             }
91
92             public void removeFromEnvironment(String JavaDoc s) {
93             }
94
95
96             public String JavaDoc getNameInNamespace() {
97                 return "";
98             }
99
100             public void rename(Name JavaDoc oldName, Name JavaDoc newName) throws InvalidNameException JavaDoc {
101                 assertEquals(newName("ou=PD Accountants, ou=Product Development, dc=airius, dc=com"), oldName);
102                 assertEquals(newName("ou=Product Development Accountants, ou=Accounting, dc=airius, dc=com"), newName);
103                 modified=true;
104             }
105
106         }.getProxy();
107         LdifScript.modify(mock, e);
108         assertTrue("DirContext was not modified", modified);
109     }
110
111     /**
112      * Tests changetype: modrdn
113      */

114     public void testModifyModrdn() throws NamingException JavaDoc {
115         final Entry e = readEntry(
116                 "# Rename an entry and move all of its children to a new location in\n" +
117                 "# the directory tree (only implemented by LDAPv3 servers).\n" +
118                 "dn: ou=PD Accountants, dc=com\n" +
119                 "changetype: modrdn\n" +
120                 "newrdn: ou=Accountants\n" +
121                 "deleteoldrdn: 1\n");
122         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
123             //Delete old rdn
124
public void addToEnvironment(String JavaDoc p, Object JavaDoc v) {
125                 assertEquals("java.naming.ldap.deleteRDN", p);
126                 assertEquals("true", v);
127             }
128
129             public void removeFromEnvironment(String JavaDoc s) {
130             }
131
132             public String JavaDoc getNameInNamespace() {
133                 return "";
134             }
135
136             public void rename(Name JavaDoc oldName, Name JavaDoc newName) throws InvalidNameException JavaDoc {
137                 assertEquals(newName("ou=PD Accountants, dc=com"), oldName);
138                 assertEquals(newName("ou=Accountants, dc=com"), newName);
139                 modified=true;
140             }
141
142         }.getProxy();
143         LdifScript.modify(mock, e);
144         assertTrue("DirContext was not modified", modified);
145     }
146
147     /**
148      * Tests add entry
149      *
150      */

151     public void testModifyAdd() throws NamingException JavaDoc {
152         final Entry e = readEntry(
153                         "dn: cn=ldap,dc=scriptella\n" +
154                         "cn: ldap\n" +
155                         "objectClass: top\n" +
156                         "objectClass: driver\n" +
157                         "envVars:");
158         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
159             public String JavaDoc getNameInNamespace() {
160                 return "dc=scriptella";
161             }
162
163             public DirContext JavaDoc createSubcontext(Name JavaDoc name, Attributes JavaDoc attrs) throws InvalidNameException JavaDoc {
164                 assertEquals(newName("cn=ldap"), name);
165                 BasicAttributes JavaDoc exp = new BasicAttributes JavaDoc(true);
166                 exp.put("cn", "ldap");
167                 final BasicAttribute JavaDoc oc = new BasicAttribute JavaDoc("objectClass");
168                 oc.add("top");
169                 oc.add("driver");
170                 exp.put(oc);
171                 exp.put("envVars", null);
172                 assertEquals(exp, attrs);
173                 modified=true;
174                 return null;
175             }
176
177         }.getProxy();
178         LdifScript.modify(mock, e);
179         assertTrue("DirContext was not modified", modified);
180     }
181
182     /**
183      * Tests entry removing
184      */

185     public void testDelete() throws NamingException JavaDoc {
186         final Entry e = readEntry(
187                         "dn: cn=ldap,dc=scriptella\n" +
188                         "changetype: delete\n");
189         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
190             public String JavaDoc getNameInNamespace() {
191                 return "dc=scriptella";
192             }
193
194             public void destroySubcontext(Name JavaDoc name) throws NamingException JavaDoc {
195                 assertEquals(newName("cn=ldap"), name);
196                 modified=true;
197             }
198
199         }.getProxy();
200         LdifScript.modify(mock, e);
201         assertTrue("DirContext was not modified", modified);
202     }
203
204
205     /**
206      * Tests changetype: modify
207      */

208     public void testModify() throws NamingException JavaDoc {
209         final Entry e = readEntry(
210                 "dn: cn=ldap, dc=scriptella\n" +
211                 "changetype: modify\n" +
212                 "add: postaladdress\n" +
213                 "postaladdress: 123 Anystreet\n" +
214                 "-\n" +
215                 "delete: description\n" +
216                 "-\n" +
217                 "replace: phone\n" +
218                 "phone: 1234\n" +
219                 "phone: 5678\n" +
220                 "-\n" +
221                 "delete: fax\n" +
222                 "fax: 1111\n");
223
224         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
225             public String JavaDoc getNameInNamespace() {
226                 return "";
227             }
228             public void modifyAttributes(Name JavaDoc name, ModificationItem JavaDoc[] mods) throws InvalidNameException JavaDoc {
229                 assertEquals(newName("cn=ldap, dc=scriptella"), name);
230                 ModificationItem JavaDoc[] expected = new ModificationItem JavaDoc[4];
231                 expected[0]=new ModificationItem JavaDoc(DirContext.ADD_ATTRIBUTE,
232                         new BasicAttribute JavaDoc("postaladdress", "123 Anystreet"));
233                 expected[1]=new ModificationItem JavaDoc(DirContext.REMOVE_ATTRIBUTE,
234                         new BasicAttribute JavaDoc("description", null));
235                 BasicAttribute JavaDoc phone = new BasicAttribute JavaDoc("phone");
236                 phone.add("1234");phone.add("5678");
237                 expected[2]=new ModificationItem JavaDoc(DirContext.REPLACE_ATTRIBUTE,
238                         phone);
239                 expected[3]=new ModificationItem JavaDoc(DirContext.REMOVE_ATTRIBUTE,
240                         new BasicAttribute JavaDoc("fax", "1111"));
241                 for (int i = 0; i < expected.length; i++) {
242                     assertEquals(expected[i].getAttribute(), mods[i].getAttribute());
243                     assertEquals(expected[i].getModificationOp(), mods[i].getModificationOp());
244                 }
245                 modified=true;
246             }
247
248         }.getProxy();
249         LdifScript.modify(mock, e);
250         assertTrue("DirContext was not modified", modified);
251     }
252
253     /**
254      * Tests if substituted data goes to LDAP.
255      */

256     public void testExecute() {
257         Reader ldif = new StringReader JavaDoc(
258                 "# Rename an entry and move all of its children to a new location in\n" +
259                 "# the directory tree (only implemented by LDAPv3 servers).\n" +
260                 "dn: ou=$test, dc=scriptella\n" +
261                 "ou: $test\n");
262
263         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
264             public String JavaDoc getNameInNamespace() {
265                 return "dc=scriptella";
266             }
267
268             public DirContext JavaDoc createSubcontext(Name JavaDoc name, Attributes JavaDoc attrs) throws InvalidNameException JavaDoc {
269                 assertEquals(newName("ou=*test*"), name);
270                 BasicAttributes JavaDoc exp = new BasicAttributes JavaDoc(true);
271                 exp.put("ou", "*test*");
272                 assertEquals(exp, attrs);
273                 modified=true;
274                 return null;
275             }
276
277         }.getProxy();
278         LdifScript ls = new LdifScript(new LdapConnection());
279         ls.execute(ldif, mock, MockParametersCallbacks.SIMPLE);
280
281         assertTrue("DirContext was not modified", modified);
282     }
283
284     /**
285      * Tests error handling
286      */

287     public void testErrorHadnling() throws NamingException JavaDoc {
288         String JavaDoc ldif = "dn: cn=ldap,dc=scriptella\n" +
289                 "changetype: delete\n";
290         Reader reader = new StringReader JavaDoc(ldif);
291         DirContext JavaDoc mock = new ProxyAdapter<DirContext JavaDoc>(DirContext JavaDoc.class) {
292             public String JavaDoc getNameInNamespace() {
293                 return "dc=scriptella";
294             }
295
296             public void destroySubcontext(Name JavaDoc name) throws NamingException JavaDoc {
297                 throw new NamingException JavaDoc("Failure");
298             }
299         }.getProxy();
300         try {
301             LdifScript ls = new LdifScript(new LdapConnection());
302             ls.execute(reader, mock, MockParametersCallbacks.UNSUPPORTED);
303
304         } catch (LdapProviderException e) {
305             Throwable JavaDoc ne = e.getNativeException();
306             assertEquals(NamingException JavaDoc.class, ne.getClass());
307             assertEquals("Failure", ne.getMessage());
308             assertEquals(ldif, e.getErrorStatement());
309         }
310     }
311
312
313     /**
314      * @param s ldif
315      * @return entry from ldif
316      */

317     private static Entry readEntry(String JavaDoc s) {
318         LdifReader lr = new LdifReader(new StringReader JavaDoc(s));
319         return lr.next();
320     }
321
322     private static Name JavaDoc newName(String JavaDoc name) throws InvalidNameException JavaDoc {
323         return new CompoundName JavaDoc(name, LdifScript.DN_SYNTAX);
324     }
325 }
326
Popular Tags