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.hamcrest.MatcherAssert.assertThat;
20  import static org.hamcrest.core.Is.is;
21  import static org.hamcrest.core.IsEqual.equalTo;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertNotNull;
24  import static org.junit.Assert.assertThrows;
25  import static org.junit.Assert.assertTrue;
26  import static org.junit.Assert.fail;
27  
28  import java.util.ArrayList;
29  import java.util.List;
30  
31  import org.apache.commons.validator.routines.DomainValidator.ArrayType;
32  import org.bitstrings.test.junit.runner.ClassLoaderPerTestRunner;
33  import org.junit.Test;
34  import org.junit.runner.RunWith;
35  
36  /**
37   * Startup Tests for the DomainValidator.
38   *
39   * TODO Port to JUnit 5.
40   */
41  @RunWith(ClassLoaderPerTestRunner.class)
42  public class DomainValidatorStartupTest {
43  
44      @Test
45      public void testCannotUpdate() {
46          DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch"); // OK
47          final DomainValidator dv = DomainValidator.getInstance();
48          assertNotNull(dv);
49          try {
50              DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
51              fail("Expected IllegalStateException");
52          } catch (final IllegalStateException ise) {
53              // expected
54          }
55      }
56  
57      @Test
58      public void testInstanceOverride() { // Show that the instance picks up static values
59          DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "gp");
60          DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "com");
61          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, "cp");
62          DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "ch");
63          DomainValidator validator = DomainValidator.getInstance(false);
64          assertTrue(validator.isValidGenericTld("gp"));
65          assertFalse(validator.isValidGenericTld("com"));
66          assertTrue(validator.isValidCountryCodeTld("cp"));
67          assertFalse(validator.isValidCountryCodeTld("ch"));
68  
69          // show we can override them for a new instance
70          final List<DomainValidator.Item> items = new ArrayList<>();
71          items.add(new DomainValidator.Item(ArrayType.GENERIC_MINUS, ""));
72          items.add(new DomainValidator.Item(ArrayType.COUNTRY_CODE_MINUS, ""));
73          validator = DomainValidator.getInstance(false, items);
74          assertTrue(validator.isValidGenericTld("gp"));
75          assertTrue(validator.isValidGenericTld("com")); // Should be true again
76          assertTrue(validator.isValidCountryCodeTld("cp"));
77          assertTrue(validator.isValidCountryCodeTld("ch")); // Should be true again
78  
79          // Show the class overrides are unaffected
80          validator = DomainValidator.getInstance(false);
81          assertTrue(validator.isValidGenericTld("gp"));
82          assertFalse(validator.isValidGenericTld("com"));
83          assertTrue(validator.isValidCountryCodeTld("cp"));
84          assertFalse(validator.isValidCountryCodeTld("ch"));
85      }
86  
87      @Test
88      public void testUpdateBaseArrayCC() {
89          final IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
90                  () -> DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_RO, "com"));
91          assertThat(thrown.getMessage(), is(equalTo("Cannot update the table: COUNTRY_CODE_RO")));
92      }
93  
94      @Test
95      public void testUpdateBaseArrayGeneric() {
96          final IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
97                  () -> DomainValidator.updateTLDOverride(ArrayType.GENERIC_RO, "com"));
98          assertThat(thrown.getMessage(), is(equalTo("Cannot update the table: GENERIC_RO")));
99      }
100 
101     @Test
102     public void testUpdateBaseArrayInfra() {
103         final IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
104                 () -> DomainValidator.updateTLDOverride(ArrayType.INFRASTRUCTURE_RO, "com"));
105         assertThat(thrown.getMessage(), is(equalTo("Cannot update the table: INFRASTRUCTURE_RO")));
106     }
107 
108     @Test
109     public void testUpdateBaseArrayLocal() {
110         final IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
111                 () -> DomainValidator.updateTLDOverride(ArrayType.LOCAL_RO, "com"));
112         assertThat(thrown.getMessage(), is(equalTo("Cannot update the table: LOCAL_RO")));
113     }
114 
115     @Test
116     public void testUpdateCountryCode1a() {
117         final DomainValidator validator = DomainValidator.getInstance();
118         assertFalse(validator.isValidCountryCodeTld("com")); // cannot be valid
119     }
120 
121     @Test
122     public void testUpdateCountryCode1b() {
123         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, "com");
124         final DomainValidator validator = DomainValidator.getInstance();
125         assertTrue(validator.isValidCountryCodeTld("com")); // it is now!
126     }
127 
128     @Test
129     public void testUpdateCountryCode2() {
130         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_PLUS, "com");
131         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "com");
132         final DomainValidator validator = DomainValidator.getInstance();
133         assertFalse(validator.isValidCountryCodeTld("com")); // show that minus overrides the rest
134     }
135 
136     @Test
137     public void testUpdateCountryCode3a() { // show ch is valid
138         final DomainValidator validator = DomainValidator.getInstance();
139         assertTrue(validator.isValidCountryCodeTld("ch"));
140     }
141 
142     @Test
143     public void testUpdateCountryCode3b() { // show ch can be made invalid
144         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "ch");
145         final DomainValidator validator = DomainValidator.getInstance();
146         assertFalse(validator.isValidCountryCodeTld("ch"));
147     }
148 
149     @Test
150     public void testUpdateCountryCode3c() { // show ch can be made valid again by replacing the CC array
151         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "ch");
152         DomainValidator.updateTLDOverride(ArrayType.COUNTRY_CODE_MINUS, "xx");
153         final DomainValidator validator = DomainValidator.getInstance();
154         assertTrue(validator.isValidCountryCodeTld("ch"));
155     }
156 
157     @Test
158     public void testUpdateGeneric1() {
159         final DomainValidator validator = DomainValidator.getInstance();
160         assertFalse(validator.isValidGenericTld("ch")); // cannot be valid
161     }
162 
163     @Test
164     public void testUpdateGeneric2() {
165         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
166         final DomainValidator validator = DomainValidator.getInstance();
167         assertTrue(validator.isValidGenericTld("ch")); // it is now!
168     }
169 
170     @Test
171     public void testUpdateGeneric3() {
172         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
173         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "ch");
174         final DomainValidator validator = DomainValidator.getInstance();
175         assertFalse(validator.isValidGenericTld("ch")); // show that minus overrides the rest
176         assertTrue(validator.isValidGenericTld("com"));
177     }
178 
179     @Test
180     public void testUpdateGeneric4() {
181         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
182         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "ch");
183         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "com");
184         final DomainValidator validator = DomainValidator.getInstance();
185         assertFalse(validator.isValidGenericTld("com"));
186     }
187 
188     @Test
189     public void testUpdateGeneric5() {
190         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "ch");
191         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "ch");
192         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "com");
193         DomainValidator.updateTLDOverride(ArrayType.GENERIC_MINUS, "xx"); // change the minus list
194         final DomainValidator validator = DomainValidator.getInstance();
195         assertTrue(validator.isValidGenericTld("com"));
196     }
197 
198     @Test
199     public void testValidator412a() {
200         final DomainValidator validator = DomainValidator.getInstance();
201         assertFalse(validator.isValidGenericTld("local"));
202         assertFalse(validator.isValid("abc.local"));
203         assertFalse(validator.isValidGenericTld("pvt"));
204         assertFalse(validator.isValid("abc.pvt"));
205     }
206 
207     @Test
208     public void testValidator412b() {
209         DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, "local", "pvt");
210         final DomainValidator validator = DomainValidator.getInstance();
211         assertTrue(validator.isValidGenericTld("local"));
212         assertTrue(validator.isValid("abc.local"));
213         assertTrue(validator.isValidGenericTld("pvt"));
214         assertTrue(validator.isValid("abc.pvt"));
215     }
216 
217     @Test
218     public void testValidator412c() {
219         final DomainValidator validator = DomainValidator.getInstance(true);
220         assertFalse(validator.isValidLocalTld("local"));
221         assertFalse(validator.isValid("abc.local"));
222         assertFalse(validator.isValidLocalTld("pvt"));
223         assertFalse(validator.isValid("abc.pvt"));
224     }
225 
226     @Test
227     public void testValidator412d() {
228         DomainValidator.updateTLDOverride(ArrayType.LOCAL_PLUS, "local", "pvt");
229         final DomainValidator validator = DomainValidator.getInstance(true);
230         assertTrue(validator.isValidLocalTld("local"));
231         assertTrue(validator.isValidLocalTld("pvt"));
232         assertTrue(validator.isValid("abc.local"));
233         assertTrue(validator.isValid("abc.pvt"));
234     }
235 }