1 /*
2 * Copyright 2005-2008 The Kuali Foundation
3 *
4 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
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 org.kuali.rice.kns.service;
17
18 import org.junit.Test;
19 import org.kuali.rice.kns.rule.event.ApproveDocumentEvent;
20 import org.kuali.test.KNSTestCase;
21
22 /**
23 * This class tests the KualiRuleService.
24 * <p>
25 * Testing applyRules( event ) has proven to be too strongly dependent on an actual document type, and business rule, and XML
26 * document which binds them together, to be really useful. Instead, we'll test each of the applyRules( rule, event ) methods which
27 * are called by applyRules( event ), since they do the actual work involved in applying a rule.
28 */
29 public class KualiRuleServiceTest extends KNSTestCase {
30 private static boolean entriesAdded = false;
31 private static KualiRuleService kualiRuleService;
32
33 @Override
34 public void setUp() throws Exception {
35 super.setUp();
36
37 if (!entriesAdded) {
38 entriesAdded = true;
39 kualiRuleService = KNSServiceLocator.getKualiRuleService();
40 }
41 }
42
43 @Test public void testApplyRules_approveDocument_nullEvent() {
44 boolean failedAsExpected = false;
45
46 ApproveDocumentEvent event = null;
47 try {
48 kualiRuleService.applyRules(event);
49 }
50 catch (IllegalArgumentException e) {
51 failedAsExpected = true;
52 }
53
54 assertTrue(failedAsExpected);
55 }
56
57 @Test public void testApplyRules_approveDocument_nullDocument() {
58 boolean failedAsExpected = false;
59
60 try {
61 ApproveDocumentEvent event = new ApproveDocumentEvent(null);
62
63 kualiRuleService.applyRules(event);
64 }
65 catch (RuntimeException e) {
66 failedAsExpected = true;
67 }
68
69 assertTrue(failedAsExpected);
70 }
71
72 // private static final String NONE = "none";
73 // private static final String ROUTE_DOCUMENT = "routeDoc";
74 // private static final String APPROVE_DOCUMENT = "approveDoc";
75 // private static final String SAVE_DOCUMENT = "saveDoc";
76 // private static final String ADD_LINE = "addLine";
77 // private static final String DELETE_LINE = "deleteLine";
78 // private static final String UPDATE_LINE = "updateLine";
79 // private static final String REVIEW_LINE = "reviewLine";
80 //
81 // @Test public void testApplyRules_approveDocument_validRule_validDocument() {
82 // RuleMockDocument d = new RuleMockDocument();
83 // ApproveDocumentEvent event = new ApproveDocumentEvent(d);
84 //
85 //
86 // assertFalse(d.isProcessed());
87 // assertEquals(NONE, d.getEventType());
88 //
89 // boolean success = kualiRuleService.applyRules(event);
90 // assertTrue(success);
91 //
92 // assertTrue(d.isProcessed());
93 // assertEquals(ROUTE_DOCUMENT, d.getPrevEventType());
94 // assertEquals(APPROVE_DOCUMENT, d.getEventType());
95 // }
96 //
97 // @Test public void testApplyRules_approveDocument_validRule_validTransactionalDocument_noAccountingLines() {
98 // RuleMockDocument t = new RuleMockDocument();
99 // ApproveDocumentEvent event = new ApproveDocumentEvent(t);
100 //
101 //
102 // assertFalse(t.isProcessed());
103 // assertEquals(NONE, t.getEventType());
104 //
105 // boolean success = kualiRuleService.applyRules(event);
106 // assertTrue(success);
107 //
108 // assertTrue(t.isProcessed());
109 // assertEquals(ROUTE_DOCUMENT, t.getPrevEventType());
110 // assertEquals(APPROVE_DOCUMENT, t.getEventType());
111 // }
112 //
113 // @Test public void testApplyRules_routeDocument_validRule_validDocument() {
114 // RuleMockDocument d = new RuleMockDocument();
115 // RouteDocumentEvent event = new RouteDocumentEvent(d);
116 //
117 //
118 // assertFalse(d.isProcessed());
119 // assertEquals(NONE, d.getEventType());
120 //
121 // boolean success = kualiRuleService.applyRules(event);
122 // assertTrue(success);
123 //
124 // assertTrue(d.isProcessed());
125 // assertEquals(SAVE_DOCUMENT, d.getPrevEventType());
126 // assertEquals(ROUTE_DOCUMENT, d.getEventType());
127 // }
128 //
129 // @Test public void testApplyRules_routeDocument_validRule_validTransactionalDocument_noAccountingLines() {
130 // RuleMockDocument t = new RuleMockDocument();
131 // RouteDocumentEvent event = new RouteDocumentEvent(t);
132 //
133 //
134 // assertFalse(t.isProcessed());
135 // assertEquals(NONE, t.getEventType());
136 //
137 // boolean success = kualiRuleService.applyRules(event);
138 // assertTrue(success);
139 //
140 // assertTrue(t.isProcessed());
141 // assertEquals(SAVE_DOCUMENT, t.getPrevEventType());
142 // assertEquals(ROUTE_DOCUMENT, t.getEventType());
143 // }
144 //
145 // @Test public void testApplyRules_routeDocument_validRule_validTransactionalDocument_someAccountingLines() throws Exception {
146 // RuleMockDocument t = new RuleMockDocument();
147 // t.addSourceAccountingLine(buildSourceLine("1"));
148 //
149 // RouteDocumentEvent event = new RouteDocumentEvent(t);
150 //
151 //
152 // assertFalse(t.isProcessed());
153 // assertEquals(NONE, t.getEventType());
154 //
155 // boolean success = kualiRuleService.applyRules(event);
156 // assertTrue(success);
157 //
158 // assertTrue(t.isProcessed());
159 // assertEquals(SAVE_DOCUMENT, t.getPrevEventType());
160 // assertEquals(ROUTE_DOCUMENT, t.getEventType());
161 // }
162 //
163 // @Test public void testApplyRules_saveDocument_validRule_validDocument() {
164 // RuleMockDocument d = new RuleMockDocument();
165 // SaveDocumentEvent event = new SaveDocumentEvent(d);
166 //
167 //
168 // assertFalse(d.isProcessed());
169 // assertEquals(NONE, d.getEventType());
170 //
171 // boolean success = kualiRuleService.applyRules(event);
172 // assertTrue(success);
173 //
174 // assertTrue(d.isProcessed());
175 // assertEquals(NONE, d.getPrevEventType());
176 // assertEquals(SAVE_DOCUMENT, d.getEventType());
177 // }
178 //
179 // @Test public void testApplyRules_saveDocument_validRule_validTransactionalDocument_noAccountingLines() {
180 // RuleMockDocument t = new RuleMockDocument();
181 // SaveDocumentEvent event = new SaveDocumentEvent(t);
182 //
183 //
184 // assertFalse(t.isProcessed());
185 // assertEquals(NONE, t.getEventType());
186 //
187 // boolean success = kualiRuleService.applyRules(event);
188 // assertTrue(success);
189 //
190 // assertTrue(t.isProcessed());
191 // assertEquals(NONE, t.getPrevEventType());
192 // assertEquals(SAVE_DOCUMENT, t.getEventType());
193 // }
194 //
195 // @Test public void testApplyRules_saveDocument_validRule_validTransactionalDocument_someAccountingLines() throws Exception {
196 // RuleMockDocument t = new RuleMockDocument();
197 // t.addSourceAccountingLine(buildSourceLine("1"));
198 //
199 // SaveDocumentEvent event = new SaveDocumentEvent(t);
200 //
201 //
202 // assertFalse(t.isProcessed());
203 // assertEquals(NONE, t.getEventType());
204 //
205 // boolean success = kualiRuleService.applyRules(event);
206 // assertTrue(success);
207 //
208 // assertTrue(t.isProcessed());
209 // assertEquals(ADD_LINE, t.getPrevEventType());
210 // assertEquals(SAVE_DOCUMENT, t.getEventType());
211 // }
212 //
213 // @Test public void testApplyRules_addAccountingLine_validRule_nullDocument() {
214 // boolean failedAsExpected = false;
215 //
216 // AddAccountingLineEvent event = new AddAccountingLineEvent("test", null, null);
217 // try {
218 // kualiRuleService.applyRules(event);
219 // }
220 // catch (IllegalArgumentException e) {
221 // failedAsExpected = true;
222 // }
223 //
224 // assertTrue(failedAsExpected);
225 // }
226 //
227 // @Test public void testApplyRules_addAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
228 // boolean failedAsExpected = false;
229 //
230 // AddAccountingLineEvent event = new AddAccountingLineEvent("test", new RuleMockDocument(), null);
231 // try {
232 // kualiRuleService.applyRules(event);
233 // }
234 // catch (IllegalArgumentException e) {
235 // failedAsExpected = true;
236 // }
237 //
238 // assertTrue(failedAsExpected);
239 // }
240 //
241 // @Test public void testApplyRules_addAccountingLine_validRule_validTransactionalDocument_validAccountingLine() throws Exception {
242 // RuleMockDocument t = new RuleMockDocument();
243 // SourceAccountingLine s = buildSourceLine("1");
244 // t.addSourceAccountingLine(s);
245 //
246 // AddAccountingLineEvent event = new AddAccountingLineEvent("test", t, s);
247 //
248 // assertFalse(t.isProcessed());
249 //
250 // boolean success = kualiRuleService.applyRules(event);
251 // assertTrue(success);
252 //
253 // assertTrue(t.isProcessed());
254 // assertEquals(NONE, t.getPrevEventType());
255 // assertEquals(ADD_LINE, t.getEventType());
256 // }
257 //
258 // @Test public void testApplyRules_deleteAccountingLine_validRule_nullDocument() {
259 // boolean failedAsExpected = false;
260 //
261 // DeleteAccountingLineEvent event = new DeleteAccountingLineEvent("test", null, null, false);
262 // try {
263 // kualiRuleService.applyRules(event);
264 // }
265 // catch (IllegalArgumentException e) {
266 // failedAsExpected = true;
267 // }
268 //
269 // assertTrue(failedAsExpected);
270 // }
271 //
272 // @Test public void testApplyRules_deleteAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
273 // boolean failedAsExpected = false;
274 //
275 // DeleteAccountingLineEvent event = new DeleteAccountingLineEvent("test", new RuleMockDocument(), null, false);
276 // try {
277 // kualiRuleService.applyRules(event);
278 // }
279 // catch (IllegalArgumentException e) {
280 // failedAsExpected = true;
281 // }
282 //
283 // assertTrue(failedAsExpected);
284 // }
285 //
286 // @Test public void testApplyRules_deleteAccountingLine_validRule_validTransactionalDocument_validAccountingLine() throws Exception {
287 // RuleMockDocument t = new RuleMockDocument();
288 // SourceAccountingLine s = buildSourceLine("1");
289 // t.addSourceAccountingLine(s);
290 //
291 // DeleteAccountingLineEvent event = new DeleteAccountingLineEvent("test", t, s, false);
292 //
293 // assertFalse(t.isProcessed());
294 //
295 // boolean success = kualiRuleService.applyRules(event);
296 // assertTrue(success);
297 //
298 // assertTrue(t.isProcessed());
299 // assertEquals(NONE, t.getPrevEventType());
300 // assertEquals(DELETE_LINE, t.getEventType());
301 // }
302 //
303 //
304 // @Test public void testApplyRules_updateAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
305 // boolean failedAsExpected = false;
306 //
307 // UpdateAccountingLineEvent event = new UpdateAccountingLineEvent("test", new RuleMockDocument(), null, null);
308 // try {
309 // kualiRuleService.applyRules(event);
310 // }
311 // catch (IllegalArgumentException e) {
312 // failedAsExpected = true;
313 // }
314 //
315 // assertTrue(failedAsExpected);
316 // }
317 //
318 // @Test public void testApplyRules_updateAccountingLine_validRule_validTransactionalDocument_validAccountingLine_nullUpdatedAccountingLine() throws Exception {
319 // boolean failedAsExpected = false;
320 //
321 // RuleMockDocument t = new RuleMockDocument();
322 // SourceAccountingLine s = buildSourceLine("1");
323 // t.addSourceAccountingLine(s);
324 //
325 // UpdateAccountingLineEvent event = new UpdateAccountingLineEvent("test", t, s, null);
326 //
327 // try {
328 // kualiRuleService.applyRules(event);
329 // }
330 // catch (IllegalArgumentException e) {
331 // failedAsExpected = true;
332 // }
333 //
334 // assertTrue(failedAsExpected);
335 // }
336 //
337 // @Test public void testApplyRules_updateAccountingLine_validRule_validTransactionalDocument_validAccountingLines() throws Exception {
338 // RuleMockDocument t = new RuleMockDocument();
339 // SourceAccountingLine s = buildSourceLine("1");
340 // s.setOrganizationReferenceId("A");
341 // t.addSourceAccountingLine(s);
342 //
343 // SourceAccountingLine updatedS = (SourceAccountingLine) ObjectUtils.deepCopy(t.getSourceAccountingLine(0));
344 // updatedS.setOrganizationReferenceId("B");
345 //
346 // UpdateAccountingLineEvent event = new UpdateAccountingLineEvent("test", t, s, updatedS);
347 //
348 // assertFalse(t.isProcessed());
349 //
350 // boolean success = kualiRuleService.applyRules(event);
351 // assertTrue(success);
352 //
353 // assertTrue(t.isProcessed());
354 // assertEquals(NONE, t.getPrevEventType());
355 // assertEquals(UPDATE_LINE, t.getEventType());
356 // }
357 //
358 // @Test public void testApplyRules_reviewAccountingLine_validRule_validTransactionalDocument_nullAccountingLine() {
359 // boolean failedAsExpected = false;
360 //
361 // ReviewAccountingLineEvent event = new ReviewAccountingLineEvent("test", new RuleMockDocument(), null);
362 // try {
363 // kualiRuleService.applyRules(event);
364 // }
365 // catch (IllegalArgumentException e) {
366 // failedAsExpected = true;
367 // }
368 //
369 // assertTrue(failedAsExpected);
370 // }
371 //
372 // @Test public void testApplyRules_reviewAccountingLine_validRule_validTransactionalDocument_validAccountingLine() throws Exception {
373 // RuleMockDocument t = new RuleMockDocument();
374 // SourceAccountingLine s = buildSourceLine("1");
375 // t.addSourceAccountingLine(s);
376 //
377 // ReviewAccountingLineEvent event = new ReviewAccountingLineEvent("test", t, s);
378 //
379 // assertFalse(t.isProcessed());
380 //
381 // boolean success = kualiRuleService.applyRules(event);
382 // assertTrue(success);
383 //
384 // assertTrue(t.isProcessed());
385 // assertEquals(NONE, t.getPrevEventType());
386 // assertEquals(REVIEW_LINE, t.getEventType());
387 // }
388 //
389 // // TODO: commenting thse out for now, need to analyze and see if it still makes sense with new notes"copied from document " +
390 // // sourceDocumentHeaderId);
391 // @Test public void testApplyRules_addDocumentNote_validRule_nullDocument_nullDocumentNote() {
392 // // boolean failedAsExpected = false;
393 // //
394 // // AddDocumentNoteEvent event = new AddDocumentNoteEvent(null, null);
395 // // try {
396 // // kualiRuleService.applyRules(event);
397 // // }
398 // // catch (IllegalArgumentException e) {
399 // // failedAsExpected = true;
400 // // }
401 // //
402 // // assertTrue(failedAsExpected);
403 // }
404 //
405 // @Test public void testApplyRules_addDocumentNote_validRule_validDocument_nullDocumentNote() {
406 // // boolean failedAsExpected = false;
407 // //
408 // // MockTransactionalDocument d = new MockTransactionalDocument();
409 // // DocumentNote n = null;
410 // //
411 // // AddDocumentNoteEvent event = new AddDocumentNoteEvent(d, n);
412 // //
413 // // try {
414 // // kualiRuleService.applyRules(event);
415 // // }
416 // // catch (IllegalArgumentException e) {
417 // // failedAsExpected = true;
418 // // }
419 // //
420 // // assertTrue(failedAsExpected);
421 // }
422 //
423 // @Test public void testApplyRules_addDocumentNote_validRule_validDocument_validDocumentNote() {
424 // // MockTransactionalDocument d = new MockTransactionalDocument();
425 // // DocumentNote n = new DocumentNote();
426 // // n.setFinancialDocumentNoteText("Test");
427 // // d.getDocumentHeader().getNotes().add(n);
428 // //
429 // // AddDocumentNoteEvent event = new AddDocumentNoteEvent(d, n);
430 // //
431 // // assertFalse(d.isProcessed());
432 // // assertTrue(kualiRuleService.applyRules(event));
433 // // assertTrue(d.isProcessed());
434 // // assertEquals(NONE, d.getPrevEventType());
435 // // assertEquals(ADD_DOC_NOTE, d.getEventType());
436 // }
437 //
438 // private SourceAccountingLine buildSourceLine(String documentHeaderId) throws InstantiationException, IllegalAccessException {
439 // SourceAccountingLine sourceLine = LINE.createSourceAccountingLine();
440 // return sourceLine;
441 //
442 // }
443 }