001: /*
002: * Copyright 2005-2007 The Kuali Foundation.
003: *
004: * Licensed under the Educational Community License, Version 1.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.opensource.org/licenses/ecl1.php
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.kuali.core.service;
017:
018: import static org.kuali.test.fixtures.AccountingLineFixture.LINE;
019:
020: import org.kuali.core.datadictionary.DataDictionaryBuilder;
021: import org.kuali.core.datadictionary.ValidationCompletionUtils;
022: import org.kuali.core.rule.event.ApproveDocumentEvent;
023: import org.kuali.core.rule.event.RouteDocumentEvent;
024: import org.kuali.core.rule.event.SaveDocumentEvent;
025: import org.kuali.core.service.mock.RuleMockDocument;
026: import org.kuali.core.util.GeneralLedgerPendingEntrySequenceHelper;
027: import org.kuali.core.util.ObjectUtils;
028: import org.kuali.kfs.bo.SourceAccountingLine;
029: import org.kuali.kfs.context.KualiTestBase;
030: import org.kuali.kfs.context.SpringContext;
031: import org.kuali.kfs.rule.event.AddAccountingLineEvent;
032: import org.kuali.kfs.rule.event.DeleteAccountingLineEvent;
033: import org.kuali.kfs.rule.event.GenerateGeneralLedgerPendingEntriesEvent;
034: import org.kuali.kfs.rule.event.ReviewAccountingLineEvent;
035: import org.kuali.kfs.rule.event.UpdateAccountingLineEvent;
036: import org.kuali.test.ConfigureContext;
037:
038: /**
039: * This class tests the KualiRuleService.
040: * <p>
041: * Testing applyRules( event ) has proven to be too strongly dependent on an actual document type, and business rule, and XML
042: * document which binds them together, to be really useful. Instead, we'll test each of the applyRules( rule, event ) methods which
043: * are called by applyRules( event ), since they do the actual work involved in applying a rule.
044: */
045: @ConfigureContext
046: public class KualiRuleServiceTest extends KualiTestBase {
047: private static final String NONE = "none";
048: private static final String ROUTE_DOCUMENT = "routeDoc";
049: private static final String APPROVE_DOCUMENT = "approveDoc";
050: private static final String SAVE_DOCUMENT = "saveDoc";
051: private static final String ADD_LINE = "addLine";
052: private static final String DELETE_LINE = "deleteLine";
053: private static final String UPDATE_LINE = "updateLine";
054: private static final String REVIEW_LINE = "reviewLine";
055: private static final String GENERATE_PENDING = "generatePending";
056: private static final String ADD_DOC_NOTE = "addDocNote";
057:
058: private static boolean entriesAdded = false;
059: private static KualiRuleService kualiRuleService;
060:
061: @Override
062: protected void setUp() throws Exception {
063: super .setUp();
064:
065: if (!entriesAdded) {
066: entriesAdded = true;
067: kualiRuleService = SpringContext
068: .getBean(KualiRuleService.class);
069: DataDictionaryBuilder ddb = new DataDictionaryBuilder(
070: SpringContext
071: .getBean(ValidationCompletionUtils.class));
072: ddb
073: .addUniqueEntries(
074: "classpath:org/kuali/core/service/mock/RuleMockDocument.xml",
075: true);
076: ddb.parseDocument("MockDocument", true);
077: }
078: }
079:
080: public void testApplyRules_approveDocument_nullEvent() {
081: boolean failedAsExpected = false;
082:
083: ApproveDocumentEvent event = null;
084: try {
085: kualiRuleService.applyRules(event);
086: } catch (IllegalArgumentException e) {
087: failedAsExpected = true;
088: }
089:
090: assertTrue(failedAsExpected);
091: }
092:
093: public void testApplyRules_approveDocument_nullDocument() {
094: boolean failedAsExpected = false;
095:
096: try {
097: ApproveDocumentEvent event = new ApproveDocumentEvent(null);
098:
099: kualiRuleService.applyRules(event);
100: } catch (RuntimeException e) {
101: failedAsExpected = true;
102: }
103:
104: assertTrue(failedAsExpected);
105: }
106:
107: public void testApplyRules_approveDocument_validRule_validDocument() {
108: RuleMockDocument d = new RuleMockDocument();
109: ApproveDocumentEvent event = new ApproveDocumentEvent(d);
110:
111: assertFalse(d.isProcessed());
112: assertEquals(NONE, d.getEventType());
113:
114: boolean success = kualiRuleService.applyRules(event);
115: assertTrue(success);
116:
117: assertTrue(d.isProcessed());
118: assertEquals(ROUTE_DOCUMENT, d.getPrevEventType());
119: assertEquals(APPROVE_DOCUMENT, d.getEventType());
120: }
121:
122: public void testApplyRules_approveDocument_validRule_validTransactionalDocument_noAccountingLines() {
123: RuleMockDocument t = new RuleMockDocument();
124: ApproveDocumentEvent event = new ApproveDocumentEvent(t);
125:
126: assertFalse(t.isProcessed());
127: assertEquals(NONE, t.getEventType());
128:
129: boolean success = kualiRuleService.applyRules(event);
130: assertTrue(success);
131:
132: assertTrue(t.isProcessed());
133: assertEquals(ROUTE_DOCUMENT, t.getPrevEventType());
134: assertEquals(APPROVE_DOCUMENT, t.getEventType());
135: }
136:
137: public void testApplyRules_routeDocument_validRule_validDocument() {
138: RuleMockDocument d = new RuleMockDocument();
139: RouteDocumentEvent event = new RouteDocumentEvent(d);
140:
141: assertFalse(d.isProcessed());
142: assertEquals(NONE, d.getEventType());
143:
144: boolean success = kualiRuleService.applyRules(event);
145: assertTrue(success);
146:
147: assertTrue(d.isProcessed());
148: assertEquals(SAVE_DOCUMENT, d.getPrevEventType());
149: assertEquals(ROUTE_DOCUMENT, d.getEventType());
150: }
151:
152: public void testApplyRules_routeDocument_validRule_validTransactionalDocument_noAccountingLines() {
153: RuleMockDocument t = new RuleMockDocument();
154: RouteDocumentEvent event = new RouteDocumentEvent(t);
155:
156: assertFalse(t.isProcessed());
157: assertEquals(NONE, t.getEventType());
158:
159: boolean success = kualiRuleService.applyRules(event);
160: assertTrue(success);
161:
162: assertTrue(t.isProcessed());
163: assertEquals(SAVE_DOCUMENT, t.getPrevEventType());
164: assertEquals(ROUTE_DOCUMENT, t.getEventType());
165: }
166:
167: public void testApplyRules_routeDocument_validRule_validTransactionalDocument_someAccountingLines()
168: throws Exception {
169: RuleMockDocument t = new RuleMockDocument();
170: t.addSourceAccountingLine(buildSourceLine("1"));
171:
172: RouteDocumentEvent event = new RouteDocumentEvent(t);
173:
174: assertFalse(t.isProcessed());
175: assertEquals(NONE, t.getEventType());
176:
177: boolean success = kualiRuleService.applyRules(event);
178: assertTrue(success);
179:
180: assertTrue(t.isProcessed());
181: assertEquals(SAVE_DOCUMENT, t.getPrevEventType());
182: assertEquals(ROUTE_DOCUMENT, t.getEventType());
183: }
184:
185: public void testApplyRules_saveDocument_validRule_validDocument() {
186: RuleMockDocument d = new RuleMockDocument();
187: SaveDocumentEvent event = new SaveDocumentEvent(d);
188:
189: assertFalse(d.isProcessed());
190: assertEquals(NONE, d.getEventType());
191:
192: boolean success = kualiRuleService.applyRules(event);
193: assertTrue(success);
194:
195: assertTrue(d.isProcessed());
196: assertEquals(NONE, d.getPrevEventType());
197: assertEquals(SAVE_DOCUMENT, d.getEventType());
198: }
199:
200: public void testApplyRules_saveDocument_validRule_validTransactionalDocument_noAccountingLines() {
201: RuleMockDocument t = new RuleMockDocument();
202: SaveDocumentEvent event = new SaveDocumentEvent(t);
203:
204: assertFalse(t.isProcessed());
205: assertEquals(NONE, t.getEventType());
206:
207: boolean success = kualiRuleService.applyRules(event);
208: assertTrue(success);
209:
210: assertTrue(t.isProcessed());
211: assertEquals(NONE, t.getPrevEventType());
212: assertEquals(SAVE_DOCUMENT, t.getEventType());
213: }
214:
215: public void testApplyRules_saveDocument_validRule_validTransactionalDocument_someAccountingLines()
216: throws Exception {
217: RuleMockDocument t = new RuleMockDocument();
218: t.addSourceAccountingLine(buildSourceLine("1"));
219:
220: SaveDocumentEvent event = new SaveDocumentEvent(t);
221:
222: assertFalse(t.isProcessed());
223: assertEquals(NONE, t.getEventType());
224:
225: boolean success = kualiRuleService.applyRules(event);
226: assertTrue(success);
227:
228: assertTrue(t.isProcessed());
229: assertEquals(ADD_LINE, t.getPrevEventType());
230: assertEquals(SAVE_DOCUMENT, t.getEventType());
231: }
232:
233: public void testApplyRules_addAccountingLine_validRule_nullDocument() {
234: boolean failedAsExpected = false;
235:
236: AddAccountingLineEvent event = new AddAccountingLineEvent(
237: "test", null, null);
238: try {
239: kualiRuleService.applyRules(event);
240: } catch (IllegalArgumentException e) {
241: failedAsExpected = true;
242: }
243:
244: assertTrue(failedAsExpected);
245: }
246:
247: public void testApplyRules_addAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
248: boolean failedAsExpected = false;
249:
250: AddAccountingLineEvent event = new AddAccountingLineEvent(
251: "test", new RuleMockDocument(), null);
252: try {
253: kualiRuleService.applyRules(event);
254: } catch (IllegalArgumentException e) {
255: failedAsExpected = true;
256: }
257:
258: assertTrue(failedAsExpected);
259: }
260:
261: public void testApplyRules_addAccountingLine_validRule_validTransactionalDocument_validAccountingLine()
262: throws Exception {
263: RuleMockDocument t = new RuleMockDocument();
264: SourceAccountingLine s = buildSourceLine("1");
265: t.addSourceAccountingLine(s);
266:
267: AddAccountingLineEvent event = new AddAccountingLineEvent(
268: "test", t, s);
269:
270: assertFalse(t.isProcessed());
271:
272: boolean success = kualiRuleService.applyRules(event);
273: assertTrue(success);
274:
275: assertTrue(t.isProcessed());
276: assertEquals(NONE, t.getPrevEventType());
277: assertEquals(ADD_LINE, t.getEventType());
278: }
279:
280: public void testApplyRules_deleteAccountingLine_validRule_nullDocument() {
281: boolean failedAsExpected = false;
282:
283: DeleteAccountingLineEvent event = new DeleteAccountingLineEvent(
284: "test", null, null, false);
285: try {
286: kualiRuleService.applyRules(event);
287: } catch (IllegalArgumentException e) {
288: failedAsExpected = true;
289: }
290:
291: assertTrue(failedAsExpected);
292: }
293:
294: public void testApplyRules_deleteAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
295: boolean failedAsExpected = false;
296:
297: DeleteAccountingLineEvent event = new DeleteAccountingLineEvent(
298: "test", new RuleMockDocument(), null, false);
299: try {
300: kualiRuleService.applyRules(event);
301: } catch (IllegalArgumentException e) {
302: failedAsExpected = true;
303: }
304:
305: assertTrue(failedAsExpected);
306: }
307:
308: public void testApplyRules_deleteAccountingLine_validRule_validTransactionalDocument_validAccountingLine()
309: throws Exception {
310: RuleMockDocument t = new RuleMockDocument();
311: SourceAccountingLine s = buildSourceLine("1");
312: t.addSourceAccountingLine(s);
313:
314: DeleteAccountingLineEvent event = new DeleteAccountingLineEvent(
315: "test", t, s, false);
316:
317: assertFalse(t.isProcessed());
318:
319: boolean success = kualiRuleService.applyRules(event);
320: assertTrue(success);
321:
322: assertTrue(t.isProcessed());
323: assertEquals(NONE, t.getPrevEventType());
324: assertEquals(DELETE_LINE, t.getEventType());
325: }
326:
327: public void testApplyRules_updateAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
328: boolean failedAsExpected = false;
329:
330: UpdateAccountingLineEvent event = new UpdateAccountingLineEvent(
331: "test", new RuleMockDocument(), null, null);
332: try {
333: kualiRuleService.applyRules(event);
334: } catch (IllegalArgumentException e) {
335: failedAsExpected = true;
336: }
337:
338: assertTrue(failedAsExpected);
339: }
340:
341: public void testApplyRules_updateAccountingLine_validRule_validTransactionalDocument_validAccountingLine_nullUpdatedAccountingLine()
342: throws Exception {
343: boolean failedAsExpected = false;
344:
345: RuleMockDocument t = new RuleMockDocument();
346: SourceAccountingLine s = buildSourceLine("1");
347: t.addSourceAccountingLine(s);
348:
349: UpdateAccountingLineEvent event = new UpdateAccountingLineEvent(
350: "test", t, s, null);
351:
352: try {
353: kualiRuleService.applyRules(event);
354: } catch (IllegalArgumentException e) {
355: failedAsExpected = true;
356: }
357:
358: assertTrue(failedAsExpected);
359: }
360:
361: public void testApplyRules_updateAccountingLine_validRule_validTransactionalDocument_validAccountingLines()
362: throws Exception {
363: RuleMockDocument t = new RuleMockDocument();
364: SourceAccountingLine s = buildSourceLine("1");
365: s.setOrganizationReferenceId("A");
366: t.addSourceAccountingLine(s);
367:
368: SourceAccountingLine updatedS = (SourceAccountingLine) ObjectUtils
369: .deepCopy(t.getSourceAccountingLine(0));
370: updatedS.setOrganizationReferenceId("B");
371:
372: UpdateAccountingLineEvent event = new UpdateAccountingLineEvent(
373: "test", t, s, updatedS);
374:
375: assertFalse(t.isProcessed());
376:
377: boolean success = kualiRuleService.applyRules(event);
378: assertTrue(success);
379:
380: assertTrue(t.isProcessed());
381: assertEquals(NONE, t.getPrevEventType());
382: assertEquals(UPDATE_LINE, t.getEventType());
383: }
384:
385: public void testApplyRules_reviewAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
386: boolean failedAsExpected = false;
387:
388: ReviewAccountingLineEvent event = new ReviewAccountingLineEvent(
389: "test", new RuleMockDocument(), null);
390: try {
391: kualiRuleService.applyRules(event);
392: } catch (IllegalArgumentException e) {
393: failedAsExpected = true;
394: }
395:
396: assertTrue(failedAsExpected);
397: }
398:
399: public void testApplyRules_reviewAccountingLine_validRule_validTransactionalDocument_validAccountingLine()
400: throws Exception {
401: RuleMockDocument t = new RuleMockDocument();
402: SourceAccountingLine s = buildSourceLine("1");
403: t.addSourceAccountingLine(s);
404:
405: ReviewAccountingLineEvent event = new ReviewAccountingLineEvent(
406: "test", t, s);
407:
408: assertFalse(t.isProcessed());
409:
410: boolean success = kualiRuleService.applyRules(event);
411: assertTrue(success);
412:
413: assertTrue(t.isProcessed());
414: assertEquals(NONE, t.getPrevEventType());
415: assertEquals(REVIEW_LINE, t.getEventType());
416: }
417:
418: public void testApplyRules_generateGeneralLedgerPendingEntries_validRule_nullTransactionalDocument_nullAccountingLine() {
419: boolean failedAsExpected = false;
420:
421: GenerateGeneralLedgerPendingEntriesEvent event = new GenerateGeneralLedgerPendingEntriesEvent(
422: null, null,
423: new GeneralLedgerPendingEntrySequenceHelper());
424: try {
425: kualiRuleService.applyRules(event);
426: } catch (IllegalArgumentException e) {
427: failedAsExpected = true;
428: }
429:
430: assertTrue(failedAsExpected);
431: }
432:
433: public void testApplyRules_generateGeneralLedgerPendingEntries_validRule_validTransactionalDocument_nullAccountingLine() {
434: boolean failedAsExpected = false;
435:
436: RuleMockDocument t = new RuleMockDocument();
437: GenerateGeneralLedgerPendingEntriesEvent event = new GenerateGeneralLedgerPendingEntriesEvent(
438: t, null, new GeneralLedgerPendingEntrySequenceHelper());
439:
440: try {
441: kualiRuleService.applyRules(event);
442: } catch (IllegalArgumentException e) {
443: failedAsExpected = true;
444: }
445:
446: assertTrue(failedAsExpected);
447: }
448:
449: public void testApplyRules_generateGeneralLedgerPendingEntries_validRule_validTransactionalDocument_validAccountingLine() {
450: RuleMockDocument t = new RuleMockDocument();
451: SourceAccountingLine s = new SourceAccountingLine();
452: SourceAccountingLine s2 = new SourceAccountingLine();
453: t.addSourceAccountingLine(s);
454: t.addSourceAccountingLine(s2);
455:
456: GenerateGeneralLedgerPendingEntriesEvent event = new GenerateGeneralLedgerPendingEntriesEvent(
457: t, s, new GeneralLedgerPendingEntrySequenceHelper());
458:
459: assertFalse(t.isProcessed());
460: assertTrue(kualiRuleService.applyRules(event));
461: assertTrue(t.isProcessed());
462: assertEquals(NONE, t.getPrevEventType());
463: assertEquals(GENERATE_PENDING, t.getEventType());
464: }
465:
466: // TODO: commenting thse out for now, need to analyze and see if it still makes sense with new notes"copied from document " +
467: // sourceDocumentHeaderId);
468: public void testApplyRules_addDocumentNote_validRule_nullDocument_nullDocumentNote() {
469: // boolean failedAsExpected = false;
470: //
471: // AddDocumentNoteEvent event = new AddDocumentNoteEvent(null, null);
472: // try {
473: // kualiRuleService.applyRules(event);
474: // }
475: // catch (IllegalArgumentException e) {
476: // failedAsExpected = true;
477: // }
478: //
479: // assertTrue(failedAsExpected);
480: }
481:
482: public void testApplyRules_addDocumentNote_validRule_validDocument_nullDocumentNote() {
483: // boolean failedAsExpected = false;
484: //
485: // MockTransactionalDocument d = new MockTransactionalDocument();
486: // DocumentNote n = null;
487: //
488: // AddDocumentNoteEvent event = new AddDocumentNoteEvent(d, n);
489: //
490: // try {
491: // kualiRuleService.applyRules(event);
492: // }
493: // catch (IllegalArgumentException e) {
494: // failedAsExpected = true;
495: // }
496: //
497: // assertTrue(failedAsExpected);
498: }
499:
500: public void testApplyRules_addDocumentNote_validRule_validDocument_validDocumentNote() {
501: // MockTransactionalDocument d = new MockTransactionalDocument();
502: // DocumentNote n = new DocumentNote();
503: // n.setFinancialDocumentNoteText("Test");
504: // d.getDocumentHeader().getNotes().add(n);
505: //
506: // AddDocumentNoteEvent event = new AddDocumentNoteEvent(d, n);
507: //
508: // assertFalse(d.isProcessed());
509: // assertTrue(kualiRuleService.applyRules(event));
510: // assertTrue(d.isProcessed());
511: // assertEquals(NONE, d.getPrevEventType());
512: // assertEquals(ADD_DOC_NOTE, d.getEventType());
513: }
514:
515: private SourceAccountingLine buildSourceLine(String documentHeaderId)
516: throws InstantiationException, IllegalAccessException {
517: SourceAccountingLine sourceLine = LINE
518: .createSourceAccountingLine();
519: return sourceLine;
520:
521: }
522: }
|