1   /*
2    * Copyright 2006-2010 the original author or authors.
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 net.sourceforge.domian.specification;
17  
18  
19  import java.util.Date;
20  
21  import static org.junit.Assert.assertEquals;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertTrue;
24  import static org.junit.Assert.fail;
25  import org.junit.Test;
26  
27  import net.sourceforge.domian.test.domain.Customer;
28  import static net.sourceforge.domian.test.domain.Customer.Gender.MALE;
29  import net.sourceforge.domian.test.domain.Order;
30  import static net.sourceforge.domian.test.domain.Testdata.maleCustomer;
31  import static net.sourceforge.domian.test.domain.Testdata.thirtyYearsAgo;
32  import static net.sourceforge.domian.test.domain.Testdata.yesterday;
33  
34  
35  public class EqualSpecificationTest {
36  
37      Customer entity = new Customer(1001L, yesterday).gender(MALE).name("John");
38      Customer differentEntity = new Customer(1001L, yesterday).gender(MALE).name("John");
39  
40      @Test
41      public void shouldNotAcceptNullAsValue() {
42          try {
43              new EqualSpecification<Object>(null);
44              fail("Should have thrown exception");
45  
46          } catch (IllegalArgumentException e) {
47              String expectedMessage = "Value parameter cannot be null";
48              assertEquals(expectedMessage, e.getMessage());
49          }
50      }
51  
52  
53      @Test
54      public void testEqualSpecification_Raw_1() {
55          Specification rawEqToInt23 = new EqualSpecification(23);
56  
57          assertFalse(rawEqToInt23.isSatisfiedBy(null));
58          assertFalse(rawEqToInt23.isSatisfiedBy(22));
59          assertFalse(rawEqToInt23.isSatisfiedBy(new Integer("00022")));
60          assertTrue(rawEqToInt23.isSatisfiedBy(23));
61          assertTrue(rawEqToInt23.isSatisfiedBy(new Integer("0023")));
62          assertFalse(rawEqToInt23.isSatisfiedBy(24));
63          assertFalse(rawEqToInt23.isSatisfiedBy(new Integer("00002300")));
64  
65          assertFalse(rawEqToInt23.isSatisfiedBy("Yo!"));
66          assertFalse(rawEqToInt23.isSatisfiedBy(new Date()));
67          assertFalse(rawEqToInt23.isSatisfiedBy(new Customer(1001L, yesterday).gender(MALE).name("John")));
68      }
69  
70  
71      @Test
72      public void testEqualSpecification_Raw_2() {
73          Specification rawEqToInt23 = new EqualSpecification<Integer>(23);
74  
75          assertFalse(rawEqToInt23.isSatisfiedBy(null));
76          assertFalse(rawEqToInt23.isSatisfiedBy(22));
77          assertFalse(rawEqToInt23.isSatisfiedBy(new Integer("00022")));
78          assertTrue(rawEqToInt23.isSatisfiedBy(23));
79          assertTrue(rawEqToInt23.isSatisfiedBy(new Integer("0023")));
80          assertFalse(rawEqToInt23.isSatisfiedBy(24));
81          assertFalse(rawEqToInt23.isSatisfiedBy(new Integer("00002300")));
82  
83          assertFalse(rawEqToInt23.isSatisfiedBy("Yo!"));
84          assertFalse(rawEqToInt23.isSatisfiedBy(new Date()));
85          assertFalse(rawEqToInt23.isSatisfiedBy(maleCustomer));
86      }
87  
88  
89      @Test
90      public void testEqualSpecification_HalfWayTyped() {
91          Specification<Integer> rawEqToInt23 = new EqualSpecification(23);
92  
93          assertFalse(rawEqToInt23.isSatisfiedBy(null));
94          assertFalse(rawEqToInt23.isSatisfiedBy(22));
95          assertFalse(rawEqToInt23.isSatisfiedBy(new Integer("00022")));
96          assertTrue(rawEqToInt23.isSatisfiedBy(23));
97          assertTrue(rawEqToInt23.isSatisfiedBy(new Integer("0023")));
98          assertFalse(rawEqToInt23.isSatisfiedBy(24));
99          assertFalse(rawEqToInt23.isSatisfiedBy(new Integer("00002300")));
100     }
101 
102 
103     @Test
104     public void testEqualSpecification_Long() {
105         Specification<Long> rawEqToLong23 = new EqualSpecification<Long>(23L);
106 
107         assertFalse(rawEqToLong23.isSatisfiedBy(null));
108         assertFalse(rawEqToLong23.isSatisfiedBy(22L));
109         assertFalse(rawEqToLong23.isSatisfiedBy(new Long("00022")));
110         assertTrue(rawEqToLong23.isSatisfiedBy(23L));
111         assertTrue(rawEqToLong23.isSatisfiedBy(new Long("0023")));
112         assertFalse(rawEqToLong23.isSatisfiedBy(24L));
113         assertFalse(rawEqToLong23.isSatisfiedBy(new Long("00002300")));
114     }
115 
116 
117     @Test
118     public void testEqualSpecification_String() {
119         Specification<String> spec = new EqualSpecification<String>("Hey Chica!");
120 
121         assertFalse(spec.isSatisfiedBy(null));
122         assertFalse(spec.isSatisfiedBy(""));
123         assertFalse(spec.isSatisfiedBy("         "));
124         assertFalse(spec.isSatisfiedBy("Hey Chico!"));
125         assertTrue(spec.isSatisfiedBy("Hey Chica!"));
126         assertFalse(spec.isSatisfiedBy("hey Chica!"));
127         assertFalse(spec.isSatisfiedBy("Hey chica!"));
128     }
129 
130 
131     @Test
132     public void testEqualSpecification_Date() {
133         Specification<Date> spec = new EqualSpecification<Date>(thirtyYearsAgo);
134 
135         assertFalse(spec.isSatisfiedBy(null));
136         assertFalse(spec.isSatisfiedBy(new Date()));
137         assertTrue(spec.isSatisfiedBy(thirtyYearsAgo));
138     }
139 
140 
141     @Test
142     public void testEqualSpecification_Entity_Raw_1() {
143         Specification spec = new EqualSpecification(entity);
144         assertFalse(spec.isSatisfiedBy(null));
145         assertTrue(spec.isSatisfiedBy(entity));
146         assertFalse(spec.isSatisfiedBy(differentEntity));
147         /* No, deactivated - it screws up misc Collection stuff
148         try {
149             assertFalse(spec.isSatisfiedBy(new Order()));
150             fail("Should have thrown exception");
151         } catch (IllegalArgumentException e) {
152             assertEquals("Illegal entity equal() usage: net.sourceforge.domian.test.domain.Customer.equals(net.sourceforge.domian.test.domain.Order)",
153                          e.getMessage());
154         }*/
155         /* Reverted back to this, plus a System.err warning */
156         assertFalse(spec.isSatisfiedBy(new Order()));
157     }
158 
159 
160     @Test
161     public void testEqualSpecification_Entity_Raw_2() {
162         Specification spec = new EqualSpecification<Customer>(entity);
163         assertFalse(spec.isSatisfiedBy(null));
164         assertTrue(spec.isSatisfiedBy(entity));
165         assertFalse(spec.isSatisfiedBy(differentEntity));
166         /* No, deactivated - it screws up misc Collection stuff
167         try {
168             assertFalse(spec.isSatisfiedBy(new Order()));
169             fail("Should have thrown exception");
170         } catch (IllegalArgumentException e) {
171             assertEquals("Illegal entity equal() usage: net.sourceforge.domian.test.domain.Customer.equals(net.sourceforge.domian.test.domain.Order)",
172                          e.getMessage());
173         }*/
174         /* Reverted back to this, plus a System.err warning */
175         assertFalse(spec.isSatisfiedBy(new Order()));
176 
177         Specification<Customer> spec3 = new EqualSpecification(entity);
178         assertFalse(spec3.isSatisfiedBy(null));
179         assertTrue(spec3.isSatisfiedBy(entity));
180         assertFalse(spec3.isSatisfiedBy(differentEntity));
181     }
182 
183 
184     @Test
185     public void testEqualSpecification_Entity_HafWayTyped() {
186         Specification<Customer> spec3 = new EqualSpecification(entity);
187         assertFalse(spec3.isSatisfiedBy(null));
188         assertTrue(spec3.isSatisfiedBy(entity));
189         assertFalse(spec3.isSatisfiedBy(differentEntity));
190     }
191 
192 
193     @Test
194     public void testEqualSpecification_Entity() {
195         Specification<Customer> spec = new EqualSpecification<Customer>(entity);
196 
197         assertFalse(spec.isSatisfiedBy(null));
198         assertTrue(spec.isSatisfiedBy(entity));
199         assertFalse(spec.isSatisfiedBy(differentEntity));
200     }
201 }