View Javadoc
1   /*
2    * The Kuali Financial System, a comprehensive financial management system for higher education.
3    * 
4    * Copyright 2005-2014 The Kuali Foundation
5    * 
6    * This program is free software: you can redistribute it and/or modify
7    * it under the terms of the GNU Affero General Public License as
8    * published by the Free Software Foundation, either version 3 of the
9    * License, or (at your option) any later version.
10   * 
11   * This program is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU Affero General Public License for more details.
15   * 
16   * You should have received a copy of the GNU Affero General Public License
17   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18   */
19  package org.kuali.kfs.sys.businessobject;
20  
21  import java.sql.Date;
22  
23  import org.kuali.kfs.coa.businessobject.Account;
24  import org.kuali.kfs.sys.ConfigureContext;
25  import org.kuali.kfs.sys.context.KualiTestBase;
26  
27  /**
28   * This class tests AccountingLineOverride.
29   */
30  @ConfigureContext
31  public class AccountingLineOverrideTest extends KualiTestBase {
32      private static final AccountingLineOverride EXPIRED = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.EXPIRED_ACCOUNT);
33      private static final AccountingLineOverride NONE = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.NONE);
34      private static final AccountingLineOverride EXPIRED_AND_NON_FRINGE = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED);
35      private static final AccountingLineOverride NON_FRINGE = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.NON_FRINGE_ACCOUNT_USED);
36  
37      public void testValueOf_String_none() {
38          AccountingLineOverride expired = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.NONE);
39          assertEquals(AccountingLineOverride.CODE.NONE, expired.getCode());
40          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
41          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
42      }
43  
44      public void testValueOf_String_expiredAccount() {
45          AccountingLineOverride expired = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.EXPIRED_ACCOUNT);
46          assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT, expired.getCode());
47          assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
48          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
49      }
50  
51      public void testValueOf_String_nonBudgetedObject() {
52          AccountingLineOverride expired = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.NON_BUDGETED_OBJECT);
53          assertEquals(AccountingLineOverride.CODE.NON_BUDGETED_OBJECT, expired.getCode());
54          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
55          assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_BUDGETED_OBJECT));
56      }
57  
58      public void testValueOf_String_double() {
59          AccountingLineOverride expired = AccountingLineOverride.valueOf(AccountingLineOverride.CODE.EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED);
60          assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED, expired.getCode());
61          assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
62          assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
63          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_BUDGETED_OBJECT));
64      }
65  
66      public void testValueOf_String_invalid() {
67          try {
68              AccountingLineOverride.valueOf("foo");
69              fail("got invalid code");
70          }
71          catch (IllegalArgumentException e) {
72              // good
73          }
74      }
75  
76      public void testValueOf_String_null() {
77          try {
78              AccountingLineOverride.valueOf((String) null);
79              fail("got null code");
80          }
81          catch (IllegalArgumentException e) {
82              // good
83          }
84      }
85  
86      public void testValueOf_IntegerArray_none() {
87          AccountingLineOverride expired = AccountingLineOverride.valueOf(new Integer[] {});
88          assertEquals(AccountingLineOverride.CODE.NONE, expired.getCode());
89          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
90          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
91      }
92  
93      public void testValueOf_IntegerArray_expiredAccount() {
94          AccountingLineOverride expired = AccountingLineOverride.valueOf(new Integer[] { AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT });
95          assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT, expired.getCode());
96          assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
97          assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
98      }
99  
100     public void testValueOf_IntegerArray_double() {
101         AccountingLineOverride expired = AccountingLineOverride.valueOf(new Integer[] { AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT, AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED });
102         assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED, expired.getCode());
103         assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
104         assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
105         assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_BUDGETED_OBJECT));
106     }
107 
108     public void testValueOf_IntegerArray_doubleReverse() {
109         AccountingLineOverride expired = AccountingLineOverride.valueOf(new Integer[] { AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED, AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT });
110         assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT_AND_NON_FRINGE_ACCOUNT_USED, expired.getCode());
111         assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT));
112         assertEquals(true, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED));
113         assertEquals(false, expired.hasComponent(AccountingLineOverride.COMPONENT.NON_BUDGETED_OBJECT));
114     }
115 
116     public void testValueOf_IntegerArray_invalid() {
117         try {
118             AccountingLineOverride.valueOf(new Integer[] { AccountingLineOverride.COMPONENT.NON_BUDGETED_OBJECT, AccountingLineOverride.COMPONENT.NON_FRINGE_ACCOUNT_USED });
119             fail("got invalid components");
120         }
121         catch (IllegalArgumentException e) {
122             // good
123         }
124     }
125 
126     public void testValueOf_IntegerArray_null() {
127         try {
128             AccountingLineOverride.valueOf((Integer[]) null);
129             fail("got null components");
130         }
131         catch (NullPointerException e) {
132             // good
133         }
134     }
135 
136     public void testIsValidCode_valid() {
137         assertEquals(true, AccountingLineOverride.isValidCode(AccountingLineOverride.CODE.EXPIRED_ACCOUNT_AND_NON_BUDGETED_OBJECT));
138     }
139 
140     public void testIsValidCode_invalid() {
141         assertEquals(false, AccountingLineOverride.isValidCode("foo"));
142     }
143 
144     public void testIsValidCode_empty() {
145         assertEquals(true, AccountingLineOverride.isValidCode(""));
146     }
147 
148     public void testIsValidCode_blank() {
149         assertEquals(false, AccountingLineOverride.isValidCode(" "));
150     }
151 
152     public void testIsValidCode_null() {
153         assertEquals(false, AccountingLineOverride.isValidCode(null));
154     }
155 
156     public void testIsValidComponentSet_valid() {
157         assertEquals(true, AccountingLineOverride.isValidComponentSet(new Integer[] { AccountingLineOverride.COMPONENT.EXPIRED_ACCOUNT, AccountingLineOverride.COMPONENT.NON_BUDGETED_OBJECT }));
158     }
159 
160     public void testIsValidComponentSet_invalid() {
161         assertEquals(false, AccountingLineOverride.isValidComponentSet(new Integer[] { new Integer(4) }));
162     }
163 
164     public void testIsValidComponentSet_empty() {
165         assertEquals(true, AccountingLineOverride.isValidComponentSet(new Integer[] {}));
166     }
167 
168     public void testIsValidComponentSet_null() {
169         try {
170             AccountingLineOverride.isValidComponentSet(null);
171             fail("null valid check didn't throw an exception");
172         }
173         catch (NullPointerException e) {
174             // good
175         }
176     }
177 
178     public void testMask_expiredToNone() {
179         assertSame(NONE, EXPIRED.mask(NONE));
180     }
181 
182     public void testMask_noneToExpired() {
183         assertSame(NONE, NONE.mask(EXPIRED));
184     }
185 
186     public void testMask_expiredAndNonFringeToExpired() {
187         assertSame(EXPIRED, EXPIRED_AND_NON_FRINGE.mask(EXPIRED));
188     }
189 
190     public void testMask_nonFringeToExpired() {
191         assertSame(NONE, NON_FRINGE.mask(EXPIRED));
192     }
193 
194     public void testPopulateFromInput_none() {
195         AccountingLine line = new SourceAccountingLine();
196         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
197         AccountingLineOverride.populateFromInput(line);
198         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
199     }
200 
201     public void testPopulateFromInput_expiredAccount() {
202         AccountingLine line = new SourceAccountingLine();
203         line.setAccountExpiredOverride(true);
204         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
205         AccountingLineOverride.populateFromInput(line);
206         assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT, line.getOverrideCode());
207     }
208 
209     public void testPopulateFromInput_nonBudgetedObject() {
210         AccountingLine line = new SourceAccountingLine();
211         line.setObjectBudgetOverride(true);
212         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
213         AccountingLineOverride.populateFromInput(line);
214         assertEquals(AccountingLineOverride.CODE.NON_BUDGETED_OBJECT, line.getOverrideCode());
215     }
216 
217     public void testProcessForOutput_none() {
218         AccountingLine line = new SourceAccountingLine();
219         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
220         assertEquals(false, line.getAccountExpiredOverride());
221         assertEquals(false, line.getAccountExpiredOverrideNeeded());
222         AccountingLineOverride.processForOutput(null,line);
223         assertEquals(false, line.getAccountExpiredOverride());
224         assertEquals(false, line.getAccountExpiredOverrideNeeded());
225         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
226     }
227 
228     @SuppressWarnings("deprecation")
229     public void testProcessForOutput_unexpired() {
230         AccountingLine line = new SourceAccountingLine();
231         line.setAccount(getUnexpiredAccount());
232         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
233         assertEquals(false, line.getAccountExpiredOverride());
234         assertEquals(false, line.getAccountExpiredOverrideNeeded());
235         AccountingLineOverride.processForOutput(null,line);
236         assertEquals(false, line.getAccountExpiredOverride());
237         assertEquals(false, line.getAccountExpiredOverrideNeeded());
238         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
239     }
240 
241     @SuppressWarnings("deprecation")
242     public void testProcessForOutput_expired() {
243         AccountingLine line = new SourceAccountingLine();
244         line.setOverrideCode(AccountingLineOverride.CODE.EXPIRED_ACCOUNT);
245         Account expiredAccount = getExpiredAccount();
246         line.setAccount(expiredAccount);
247         line.setChartOfAccountsCode(expiredAccount.getChartOfAccountsCode());
248         line.setAccountNumber(expiredAccount.getAccountNumber());
249         assertEquals(false, line.getAccountExpiredOverride());
250         assertEquals(false, line.getAccountExpiredOverrideNeeded());
251         AccountingLineOverride.processForOutput(null,line);
252         assertEquals(true, line.getAccountExpiredOverride());
253         assertEquals(true, line.getAccountExpiredOverrideNeeded());
254         assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT, line.getOverrideCode());
255     }
256 
257     @SuppressWarnings("deprecation")
258     public void testProcessForOutput_nonBudgetedObject() {
259         AccountingLine line = new SourceAccountingLine();
260         Account closedAccount = getClosedAccount();
261         line.setAccount(closedAccount);
262         line.setChartOfAccountsCode(closedAccount.getChartOfAccountsCode());
263         line.setAccountNumber(closedAccount.getAccountNumber());
264         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
265         assertEquals(false, line.getAccountExpiredOverride());
266         assertEquals(false, line.getAccountExpiredOverrideNeeded());
267         AccountingLineOverride.processForOutput(null,line);
268         assertEquals(false, line.getAccountExpiredOverride());
269         assertEquals(false, line.getAccountExpiredOverrideNeeded());
270         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
271     }
272 
273     @SuppressWarnings("deprecation")
274     public void testProcessForOutput_alreadyExpired() {
275         AccountingLine line = new SourceAccountingLine();
276         line.setOverrideCode(AccountingLineOverride.CODE.EXPIRED_ACCOUNT);
277         Account expiredAccount = getExpiredAccount();
278         line.setAccount(expiredAccount);
279         line.setChartOfAccountsCode(expiredAccount.getChartOfAccountsCode());
280         line.setAccountNumber(expiredAccount.getAccountNumber());
281         line.setAccountExpiredOverride(true);
282         line.setAccountExpiredOverrideNeeded(true);
283         AccountingLineOverride.processForOutput(null,line);
284         assertEquals(true, line.getAccountExpiredOverride());
285         assertEquals(true, line.getAccountExpiredOverrideNeeded());
286         assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT, line.getOverrideCode());
287     }
288 
289     @SuppressWarnings("deprecation")
290     public void testProcessForOutput_becomingExpired() {
291         AccountingLine line = new SourceAccountingLine();
292         Account expiredAccount = getExpiredAccount();
293         line.setAccount(expiredAccount);
294         line.setChartOfAccountsCode(expiredAccount.getChartOfAccountsCode());
295         line.setAccountNumber(expiredAccount.getAccountNumber());
296         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
297         assertEquals(false, line.getAccountExpiredOverride());
298         assertEquals(false, line.getAccountExpiredOverrideNeeded());
299         AccountingLineOverride.processForOutput(null,line);
300         assertEquals(false, line.getAccountExpiredOverride());
301         assertEquals(true, line.getAccountExpiredOverrideNeeded());
302         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
303     }
304 
305     @SuppressWarnings("deprecation")
306     public void testProcessForOutput_becomingUnexpired() {
307         AccountingLine line = new SourceAccountingLine();
308         line.setOverrideCode(AccountingLineOverride.CODE.EXPIRED_ACCOUNT);
309         line.setAccount(getUnexpiredAccount());
310         line.setAccountExpiredOverride(true);
311         line.setAccountExpiredOverrideNeeded(true);
312         AccountingLineOverride.processForOutput(null,line);
313         assertEquals(true, line.getAccountExpiredOverride());
314         assertEquals(false, line.getAccountExpiredOverrideNeeded());
315         assertEquals(AccountingLineOverride.CODE.EXPIRED_ACCOUNT, line.getOverrideCode());
316     }
317 
318     @SuppressWarnings("deprecation")
319     public void testProcessForOutput_becomingClosed() {
320         AccountingLine line = new SourceAccountingLine();
321         Account closedAccount = getClosedAccount();
322         line.setAccount(closedAccount);
323         line.setChartOfAccountsCode(closedAccount.getChartOfAccountsCode());
324         line.setAccountNumber(closedAccount.getAccountNumber());
325         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
326         assertEquals(false, line.getAccountExpiredOverride());
327         assertEquals(false, line.getAccountExpiredOverrideNeeded());
328         AccountingLineOverride.processForOutput(null,line);
329         assertEquals(false, line.getAccountExpiredOverride());
330         assertEquals(false, line.getAccountExpiredOverrideNeeded());
331         assertEquals(AccountingLineOverride.CODE.NONE, line.getOverrideCode());
332     }
333 
334     private Account getClosedAccount() {
335         Account account = getExpiredAccount();
336         account.setActive(false);
337         return account;
338     }
339 
340     private Account getExpiredAccount() {
341         Account account = new Account();
342         account.setChartOfAccountsCode("BL");
343         account.setAccountNumber("9999999");
344         account.setAccountExpirationDate(new Date(42)); // this account expired near the beginning of the era (1970)
345         return account;
346     }
347 
348     private Account getUnexpiredAccount() {
349         Account account = new Account();
350         account.setAccountExpirationDate(new Date(Long.MAX_VALUE / 2)); // this account expires far in the future
351         return account;
352     }
353 }