View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.validator.routines;
18  
19  import static org.junit.Assert.*;
20  
21  import java.util.ArrayList;
22  import java.util.List;
23  
24  import org.apache.commons.validator.routines.DomainValidator.ArrayType;
25  import org.junit.Test;
26  import org.junit.runner.RunWith;
27  
28  import org.bitstrings.test.junit.runner.ClassLoaderPerTestRunner;
29  
30  /**
31   * Startup Tests for the DomainValidator.
32   *
33   * @version $Revision$
34   */
35  @RunWith( ClassLoaderPerTestRunner.class )
36  public class DomainValidatorStartupTest {
37  
38      @Test(expected = IllegalArgumentException.class)
39      public void testUpdateBaseArrayCC() {
40          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_RO, new String[]{"com"});
41      }
42  
43      @Test(expected = IllegalArgumentException.class)
44      public void testUpdateBaseArrayGeneric() {
45          DomainValidator.updateTLDOverride(ArrayType.GENERIC_RO, new String[]{"com"});
46      }
47  
48      @Test(expected = IllegalArgumentException.class)
49      public void testUpdateBaseArrayInfra() {
50          DomainValidator.updateTLDOverride(ArrayType.INFRASTRUCTURE_RO, new String[]{"com"});
51      }
52  
53      @Test(expected = IllegalArgumentException.class)
54      public void testUpdateBaseArrayLocal() {
55          DomainValidator.updateTLDOverride(ArrayType.LOCAL_RO, new String[]{"com"});
56      }
57  
58      @Test
59      public void testUpdateCountryCode1a() {
60          DomainValidator validator = DomainValidator.getInstance();
61          assertFalse(validator.isValidCountryCodeTld("com")); // cannot be valid
62      }
63  
64      @Test
65      public void testUpdateCountryCode1b() {
66          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, new String[]{"com"});
67          DomainValidator validator = DomainValidator.getInstance();
68          assertTrue(validator.isValidCountryCodeTld("com")); // it is now!
69      }
70  
71      @Test
72      public void testUpdateCountryCode2() {
73          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, new String[]{"com"});
74          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"com"});
75          DomainValidator validator = DomainValidator.getInstance();
76          assertFalse(validator.isValidCountryCodeTld("com")); // show that minus overrides the rest
77      }
78  
79      @Test
80      public void testUpdateCountryCode3a() { // show ch is valid
81          DomainValidator validator = DomainValidator.getInstance();
82          assertTrue(validator.isValidCountryCodeTld("ch"));
83      }
84  
85      @Test
86      public void testUpdateCountryCode3b() { // show ch can be made invalid
87          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"ch"});
88          DomainValidator validator = DomainValidator.getInstance();
89          assertFalse(validator.isValidCountryCodeTld("ch"));
90      }
91  
92      @Test
93      public void testUpdateCountryCode3c() { // show ch can be made valid again by replacing the CC array
94          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"ch"});
95          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"xx"});
96          DomainValidator validator = DomainValidator.getInstance();
97          assertTrue(validator.isValidCountryCodeTld("ch"));
98      }
99  
100     @Test
101     public void testUpdateGeneric1() {
102         DomainValidator validator = DomainValidator.getInstance();
103         assertFalse(validator.isValidGenericTld("ch")); // cannot be valid
104     }
105 
106     @Test
107     public void testUpdateGeneric2() {
108         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
109         DomainValidator validator = DomainValidator.getInstance();
110         assertTrue(validator.isValidGenericTld("ch")); // it is now!
111     }
112 
113     @Test
114     public void testUpdateGeneric3() {
115         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
116         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"ch"});
117         DomainValidator validator = DomainValidator.getInstance();
118         assertFalse(validator.isValidGenericTld("ch")); // show that minus overrides the rest
119         assertTrue(validator.isValidGenericTld("com"));
120     }
121 
122     @Test
123     public void testUpdateGeneric4() {
124         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
125         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"ch"});
126         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"com"});
127         DomainValidator validator = DomainValidator.getInstance();
128         assertFalse(validator.isValidGenericTld("com"));
129     }
130 
131     @Test
132     public void testUpdateGeneric5() {
133         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
134         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"ch"});
135         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"com"});
136         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"xx"}); // change the minus list
137         DomainValidator validator = DomainValidator.getInstance();
138         assertTrue(validator.isValidGenericTld("com"));
139     }
140 
141     @Test
142     public void testVALIDATOR_412a() {
143         DomainValidator validator = DomainValidator.getInstance();
144         assertFalse(validator.isValidGenericTld("local"));
145         assertFalse(validator.isValid("abc.local"));
146         assertFalse(validator.isValidGenericTld("pvt"));
147         assertFalse(validator.isValid("abc.pvt"));
148     }
149 
150     @Test
151     public void testVALIDATOR_412b() {
152         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"local", "pvt"});
153         DomainValidator validator = DomainValidator.getInstance();
154         assertTrue(validator.isValidGenericTld("local"));
155         assertTrue(validator.isValid("abc.local"));
156         assertTrue(validator.isValidGenericTld("pvt"));
157         assertTrue(validator.isValid("abc.pvt"));
158     }
159 
160     @Test
161     public void testVALIDATOR_412c() {
162         DomainValidator validator = DomainValidator.getInstance(true);
163         assertFalse(validator.isValidLocalTld("local"));
164         assertFalse(validator.isValid("abc.local"));
165         assertFalse(validator.isValidLocalTld("pvt"));
166         assertFalse(validator.isValid("abc.pvt"));
167     }
168 
169     @Test
170     public void testVALIDATOR_412d() {
171         DomainValidator.updateTLDOverride(ArrayType.LOCAL_PLUS, new String[]{"local", "pvt"});
172         DomainValidator validator = DomainValidator.getInstance(true);
173         assertTrue(validator.isValidLocalTld("local"));
174         assertTrue(validator.isValidLocalTld("pvt"));
175         assertTrue(validator.isValid("abc.local"));
176         assertTrue(validator.isValid("abc.pvt"));
177     }
178 
179     @Test
180     public void testCannotUpdate() {
181         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"}); // OK
182         DomainValidator dv = DomainValidator.getInstance();
183         assertNotNull(dv);
184         try {
185             DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"ch"});
186             fail("Expected IllegalStateException");
187         } catch (IllegalStateException ise) {
188             // expected
189         }
190     }
191 
192     @Test
193     public void testInstanceOverride() { // Show that the instance picks up static values
194         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"gp"});
195         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, new String[]{"com"});
196         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, new String[]{"cp"});
197         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, new String[]{"ch"});
198         DomainValidator validator = DomainValidator.getInstance(false);
199         assertTrue(validator.isValidGenericTld("gp"));
200         assertFalse(validator.isValidGenericTld("com"));
201         assertTrue(validator.isValidCountryCodeTld("cp"));
202         assertFalse(validator.isValidCountryCodeTld("ch"));
203 
204         // show we can override them for a new instance
205         List<DomainValidator.Item> items = new ArrayList<>();
206         items.add(new DomainValidator.Item(ArrayType.GENERIC_MINUS,new String[]{""}));
207         items.add(new DomainValidator.Item(ArrayType.COUNTRY_CODE_MINUS,new String[]{""}));
208         validator = DomainValidator.getInstance(false, items);
209         assertTrue(validator.isValidGenericTld("gp"));
210         assertTrue(validator.isValidGenericTld("com")); // Should be true again
211         assertTrue(validator.isValidCountryCodeTld("cp"));
212         assertTrue(validator.isValidCountryCodeTld("ch")); // Should be true again
213 
214         // Show the class overrides are unaffected
215         validator = DomainValidator.getInstance(false);
216         assertTrue(validator.isValidGenericTld("gp"));
217         assertFalse(validator.isValidGenericTld("com"));
218         assertTrue(validator.isValidCountryCodeTld("cp"));
219         assertFalse(validator.isValidCountryCodeTld("ch"));
220     }
221 }