001: package org.drools.integrationtests;
002:
003: import java.io.InputStreamReader;
004: import java.io.Reader;
005: import java.util.ArrayList;
006: import java.util.List;
007:
008: import junit.framework.Assert;
009: import junit.framework.TestCase;
010:
011: import org.drools.Cheese;
012: import org.drools.FactA;
013: import org.drools.FactB;
014: import org.drools.Person;
015: import org.drools.PersonInterface;
016: import org.drools.Precondition;
017: import org.drools.RuleBase;
018: import org.drools.RuleBaseConfiguration;
019: import org.drools.RuleBaseFactory;
020: import org.drools.WorkingMemory;
021: import org.drools.compiler.PackageBuilder;
022: import org.drools.rule.Package;
023:
024: public class DynamicRulesTest extends TestCase {
025: protected RuleBase getRuleBase() throws Exception {
026:
027: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, null);
028: }
029:
030: protected RuleBase getRuleBase(final RuleBaseConfiguration config)
031: throws Exception {
032:
033: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, config);
034: }
035:
036: public void testDynamicRuleAdditions() throws Exception {
037: Reader reader = new InputStreamReader(getClass()
038: .getResourceAsStream("test_Dynamic1.drl"));
039:
040: PackageBuilder builder = new PackageBuilder();
041: builder.addPackageFromDrl(reader);
042: final Package pkg1 = builder.getPackage();
043:
044: final RuleBase ruleBase = getRuleBase();
045: ruleBase.addPackage(pkg1);
046: final WorkingMemory workingMemory = ruleBase
047: .newStatefulSession();
048: workingMemory.setGlobal("total", new Integer(0));
049:
050: final List list = new ArrayList();
051: workingMemory.setGlobal("list", list);
052:
053: // Adding person in advance. There is no Person() object
054: // type node in memory yet, but the rule engine is supposed
055: // to handle that correctly
056: final PersonInterface bob = new Person("bob", "stilton");
057: bob.setStatus("Not evaluated");
058: workingMemory.insert(bob);
059:
060: final Cheese stilton = new Cheese("stilton", 5);
061: workingMemory.insert(stilton);
062:
063: final Cheese cheddar = new Cheese("cheddar", 5);
064: workingMemory.insert(cheddar);
065: workingMemory.fireAllRules();
066:
067: assertEquals(1, list.size());
068:
069: assertEquals("stilton", list.get(0));
070:
071: reader = new InputStreamReader(getClass().getResourceAsStream(
072: "test_Dynamic2.drl"));
073: builder = new PackageBuilder();
074: builder.addPackageFromDrl(reader);
075: final Package pkg2 = builder.getPackage();
076: ruleBase.addPackage(pkg2);
077:
078: assertEquals(3, list.size());
079:
080: assertEquals("stilton", list.get(0));
081:
082: assertTrue("cheddar".equals(list.get(1))
083: || "cheddar".equals(list.get(2)));
084:
085: assertTrue("stilton".equals(list.get(1))
086: || "stilton".equals(list.get(2)));
087:
088: list.clear();
089:
090: reader = new InputStreamReader(getClass().getResourceAsStream(
091: "test_Dynamic3.drl"));
092: builder = new PackageBuilder();
093: builder.addPackageFromDrl(reader);
094: final Package pkg3 = builder.getPackage();
095: ruleBase.addPackage(pkg3);
096:
097: // Package 3 has a rule working on Person instances.
098: // As we added person instance in advance, rule should fire now
099: workingMemory.fireAllRules();
100:
101: Assert.assertEquals(
102: "Rule from package 3 should have been fired",
103: "match Person ok", bob.getStatus());
104:
105: assertEquals(1, list.size());
106:
107: assertEquals(bob, list.get(0));
108:
109: reader = new InputStreamReader(getClass().getResourceAsStream(
110: "test_Dynamic4.drl"));
111: builder = new PackageBuilder();
112: builder.addPackageFromDrl(reader);
113: final Package pkg4 = builder.getPackage();
114: ruleBase.addPackage(pkg4);
115:
116: Assert.assertEquals(
117: "Rule from package 4 should have been fired",
118: "Who likes Stilton ok", bob.getStatus());
119:
120: assertEquals(2, list.size());
121:
122: assertEquals(bob, list.get(1));
123:
124: }
125:
126: public void testDynamicRuleRemovals() throws Exception {
127:
128: final PackageBuilder builder = new PackageBuilder();
129: builder.addPackageFromDrl(new InputStreamReader(getClass()
130: .getResourceAsStream("test_Dynamic1.drl")));
131: builder.addPackageFromDrl(new InputStreamReader(getClass()
132: .getResourceAsStream("test_Dynamic3.drl")));
133: builder.addPackageFromDrl(new InputStreamReader(getClass()
134: .getResourceAsStream("test_Dynamic4.drl")));
135: final Package pkg = builder.getPackage();
136:
137: org.drools.reteoo.ReteooRuleBase reteooRuleBase = null;
138: // org.drools.leaps.LeapsRuleBase leapsRuleBase = null;
139: final RuleBase ruleBase = getRuleBase();
140: reteooRuleBase = (org.drools.reteoo.ReteooRuleBase) ruleBase;
141: ruleBase.addPackage(pkg);
142: final PackageBuilder builder2 = new PackageBuilder();
143: builder2.addPackageFromDrl(new InputStreamReader(getClass()
144: .getResourceAsStream("test_Dynamic2.drl")));
145: ruleBase.addPackage(builder2.getPackage());
146:
147: final WorkingMemory workingMemory = ruleBase
148: .newStatefulSession();
149:
150: final List list = new ArrayList();
151: workingMemory.setGlobal("list", list);
152:
153: final PersonInterface bob = new Person("bob", "stilton");
154: bob.setStatus("Not evaluated");
155: workingMemory.insert(bob);
156:
157: final Cheese stilton1 = new Cheese("stilton", 5);
158: workingMemory.insert(stilton1);
159:
160: final Cheese stilton2 = new Cheese("stilton", 3);
161: workingMemory.insert(stilton2);
162:
163: final Cheese stilton3 = new Cheese("stilton", 1);
164: workingMemory.insert(stilton3);
165:
166: final Cheese cheddar = new Cheese("cheddar", 5);
167: workingMemory.insert(cheddar);
168:
169: assertEquals(15,
170: workingMemory.getAgenda().getActivations().length);
171:
172: reteooRuleBase.removeRule("org.drools.test",
173: "Who likes Stilton");
174: assertEquals(12,
175: workingMemory.getAgenda().getActivations().length);
176:
177: reteooRuleBase.removeRule("org.drools.test", "like cheese");
178:
179: // reteooRuleBase.removeRule( "org.drools.test",
180: // "like cheese2" );
181:
182: final Cheese muzzarela = new Cheese("muzzarela", 5);
183: assertEquals(8,
184: workingMemory.getAgenda().getActivations().length);
185:
186: workingMemory.insert(muzzarela);
187:
188: assertEquals(9,
189: workingMemory.getAgenda().getActivations().length);
190:
191: reteooRuleBase.removePackage("org.drools.test");
192:
193: assertEquals(0,
194: workingMemory.getAgenda().getActivations().length);
195: }
196:
197: public void testDynamicRuleRemovalsUnusedWorkingMemory()
198: throws Exception {
199:
200: final PackageBuilder builder = new PackageBuilder();
201: builder.addPackageFromDrl(new InputStreamReader(getClass()
202: .getResourceAsStream("test_Dynamic1.drl")));
203: builder.addPackageFromDrl(new InputStreamReader(getClass()
204: .getResourceAsStream("test_Dynamic2.drl")));
205: builder.addPackageFromDrl(new InputStreamReader(getClass()
206: .getResourceAsStream("test_Dynamic3.drl")));
207: builder.addPackageFromDrl(new InputStreamReader(getClass()
208: .getResourceAsStream("test_Dynamic4.drl")));
209: final Package pkg = builder.getPackage();
210:
211: org.drools.reteoo.ReteooRuleBase reteooRuleBase = null;
212:
213: final RuleBase ruleBase = getRuleBase();
214: reteooRuleBase = (org.drools.reteoo.ReteooRuleBase) ruleBase;
215:
216: ruleBase.addPackage(pkg);
217:
218: final WorkingMemory workingMemory = ruleBase
219: .newStatefulSession();
220:
221: if (reteooRuleBase != null) {
222: assertEquals(1, reteooRuleBase.getPackages().length);
223: assertEquals(5,
224: reteooRuleBase.getPackages()[0].getRules().length);
225:
226: reteooRuleBase.removeRule("org.drools.test",
227: "Who likes Stilton");
228: assertEquals(4,
229: reteooRuleBase.getPackages()[0].getRules().length);
230:
231: reteooRuleBase.removeRule("org.drools.test", "like cheese");
232: assertEquals(3,
233: reteooRuleBase.getPackages()[0].getRules().length);
234:
235: reteooRuleBase.removePackage("org.drools.test");
236: assertEquals(0, reteooRuleBase.getPackages().length);
237: }
238: }
239:
240: public void testDynamicFunction() throws Exception {
241: PackageBuilder builder = new PackageBuilder();
242: builder.addPackageFromDrl(new InputStreamReader(getClass()
243: .getResourceAsStream("test_DynamicFunction1.drl")));
244: final Package pkg = builder.getPackage();
245:
246: final RuleBase ruleBase = getRuleBase();
247: ruleBase.addPackage(pkg);
248: final WorkingMemory workingMemory = ruleBase
249: .newStatefulSession();
250:
251: final List list = new ArrayList();
252: workingMemory.setGlobal("list", list);
253:
254: final Cheese stilton = new Cheese("stilton", 5);
255: workingMemory.insert(stilton);
256:
257: workingMemory.fireAllRules();
258:
259: assertEquals(new Integer(5), list.get(0));
260:
261: // Check a function can be removed from a package.
262: // Once removed any efforts to use it should throw an Exception
263: ruleBase.removeFunction("org.drools.test", "addFive");
264:
265: final Cheese cheddar = new Cheese("cheddar", 5);
266: workingMemory.insert(cheddar);
267:
268: try {
269: workingMemory.fireAllRules();
270: fail("Function should have been removed and NoClassDefFoundError thrown from the Consequence");
271: } catch (final NoClassDefFoundError e) {
272: }
273:
274: // Check a new function can be added to replace an old function
275: builder = new PackageBuilder();
276: builder.addPackageFromDrl(new InputStreamReader(getClass()
277: .getResourceAsStream("test_DynamicFunction2.drl")));
278:
279: ruleBase.addPackage(builder.getPackage());
280:
281: final Cheese brie = new Cheese("brie", 5);
282: workingMemory.insert(brie);
283:
284: workingMemory.fireAllRules();
285:
286: assertEquals(new Integer(6), list.get(1));
287:
288: builder = new PackageBuilder();
289: builder.addPackageFromDrl(new InputStreamReader(getClass()
290: .getResourceAsStream("test_DynamicFunction3.drl")));
291:
292: ruleBase.addPackage(builder.getPackage());
293:
294: final Cheese feta = new Cheese("feta", 5);
295: workingMemory.insert(feta);
296:
297: workingMemory.fireAllRules();
298:
299: assertEquals(new Integer(5), list.get(2));
300: }
301:
302: public void testRemovePackage() throws Exception {
303: final PackageBuilder builder = new PackageBuilder();
304: builder.addPackageFromDrl(new InputStreamReader(getClass()
305: .getResourceAsStream("test_RemovePackage.drl")));
306:
307: final RuleBase ruleBase = getRuleBase();
308: final String packageName = builder.getPackage().getName();
309: ruleBase.addPackage(builder.getPackage());
310:
311: final WorkingMemory workingMemory = ruleBase
312: .newStatefulSession();
313:
314: workingMemory.insert(new Precondition("genericcode",
315: "genericvalue"));
316: workingMemory.fireAllRules();
317:
318: final RuleBase ruleBaseWM = workingMemory.getRuleBase();
319: ruleBaseWM.removePackage(packageName);
320: final PackageBuilder builder1 = new PackageBuilder();
321: builder1.addPackageFromDrl(new InputStreamReader(getClass()
322: .getResourceAsStream("test_RemovePackage.drl")));
323: ruleBaseWM.addPackage(builder1.getPackage());
324: workingMemory.fireAllRules();
325:
326: ruleBaseWM.removePackage(packageName);
327: ruleBaseWM.addPackage(builder1.getPackage());
328:
329: ruleBaseWM.removePackage(packageName);
330: ruleBaseWM.addPackage(builder1.getPackage());
331: }
332:
333: public void testDynamicRules() throws Exception {
334: final RuleBase ruleBase = getRuleBase();
335: final WorkingMemory workingMemory = ruleBase
336: .newStatefulSession();
337: final Cheese a = new Cheese("stilton", 10);
338: final Cheese b = new Cheese("stilton", 15);
339: final Cheese c = new Cheese("stilton", 20);
340: workingMemory.insert(a);
341: workingMemory.insert(b);
342: workingMemory.insert(c);
343:
344: final PackageBuilder builder = new PackageBuilder();
345: builder.addPackageFromDrl(new InputStreamReader(getClass()
346: .getResourceAsStream("test_DynamicRules.drl")));
347: final Package pkg = builder.getPackage();
348: ruleBase.addPackage(pkg);
349:
350: workingMemory.fireAllRules();
351: }
352:
353: public void testDynamicRules2() throws Exception {
354: final RuleBase ruleBase = getRuleBase();
355: final WorkingMemory workingMemory = ruleBase
356: .newStatefulSession();
357:
358: // Assert some simple facts
359: final FactA a = new FactA("hello", new Integer(1), new Float(
360: 3.14));
361: final FactB b = new FactB("hello", new Integer(2), new Float(
362: 6.28));
363: workingMemory.insert(a);
364: workingMemory.insert(b);
365:
366: final PackageBuilder builder = new PackageBuilder();
367: builder.addPackageFromDrl(new InputStreamReader(getClass()
368: .getResourceAsStream("test_DynamicRules2.drl")));
369: final Package pkg = builder.getPackage();
370: ruleBase.addPackage(pkg);
371:
372: workingMemory.fireAllRules();
373: }
374:
375: public void testRuleBaseAddRemove() throws Exception {
376: RuleBase ruleBase = RuleBaseFactory.newRuleBase();
377:
378: //add and remove
379: PackageBuilder builder = new PackageBuilder();
380: builder.addPackageFromDrl(new InputStreamReader(getClass()
381: .getResourceAsStream("test_Dynamic1.drl")));
382: Package pkg = builder.getPackage();
383: ruleBase.addPackage(pkg);
384: ruleBase.removePackage(pkg.getName());
385:
386: //add and remove again
387: builder = new PackageBuilder();
388: builder.addPackageFromDrl(new InputStreamReader(getClass()
389: .getResourceAsStream("test_Dynamic1.drl")));
390: pkg = builder.getPackage();
391: ruleBase.addPackage(pkg);
392: ruleBase.removePackage(pkg.getName());
393: }
394:
395: }
|