001: package org.drools.integrationtests;
002:
003: import java.io.InputStreamReader;
004: import java.util.ArrayList;
005: import java.util.List;
006:
007: import junit.framework.TestCase;
008:
009: import org.drools.Cheese;
010: import org.drools.FactHandle;
011: import org.drools.RuleBase;
012: import org.drools.RuleBaseConfiguration;
013: import org.drools.RuleBaseFactory;
014: import org.drools.StatefulSession;
015: import org.drools.compiler.PackageBuilder;
016: import org.drools.concurrent.Future;
017: import org.drools.rule.Package;
018:
019: public class StatefulSessionTest extends TestCase {
020: final List list = new ArrayList();
021:
022: protected RuleBase getRuleBase() throws Exception {
023:
024: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, null);
025: }
026:
027: protected RuleBase getRuleBase(final RuleBaseConfiguration config)
028: throws Exception {
029:
030: return RuleBaseFactory.newRuleBase(RuleBase.RETEOO, config);
031: }
032:
033: public void testSingleObjectAssert() throws Exception {
034: StatefulSession session = getSession();
035:
036: final Cheese stilton = new Cheese("stilton", 5);
037:
038: Future futureAssert = session.asyncInsert(stilton);
039: Future futureFireAllRules = session.asyncFireAllRules();
040:
041: int i = 0;
042: while (!futureFireAllRules.isDone()) {
043: Thread.sleep(100);
044: if (i++ > 5) {
045: fail("Future should have finished by now");
046: }
047: }
048:
049: assertTrue(futureAssert.getObject() instanceof FactHandle);
050: assertEquals("stilton", list.get(0));
051:
052: }
053:
054: public void testArrayObjectAssert() throws Exception {
055: StatefulSession session = getSession();
056:
057: final Cheese stilton = new Cheese("stilton", 5);
058:
059: Future futureAssert = session
060: .asyncInsert(new Object[] { stilton });
061: Future futureFireAllRules = session.asyncFireAllRules();
062:
063: int i = 0;
064: while (!futureFireAllRules.isDone()) {
065: Thread.sleep(100);
066: if (i++ > 5) {
067: fail("Future should have finished by now");
068: }
069: }
070:
071: assertTrue(futureAssert.getObject() instanceof List);
072: assertTrue(((List) futureAssert.getObject()).get(0) instanceof FactHandle);
073:
074: assertEquals("stilton", list.get(0));
075: }
076:
077: public void testCollectionObjectAssert() throws Exception {
078: StatefulSession session = getSession();
079:
080: final Cheese stilton = new Cheese("stilton", 5);
081:
082: List collection = new ArrayList();
083: collection.add(stilton);
084: Future futureAssert = session.asyncInsert(collection);
085:
086: Future futureFireAllRules = session.asyncFireAllRules();
087: int i = 0;
088: while (!futureFireAllRules.isDone()) {
089: Thread.sleep(100);
090: if (i++ > 5) {
091: fail("Future should have finished by now");
092: }
093: }
094:
095: assertTrue(futureAssert.getObject() instanceof List);
096: assertTrue(((List) futureAssert.getObject()).get(0) instanceof FactHandle);
097:
098: assertEquals("stilton", list.get(0));
099: }
100:
101: public void testHasExceptionSingleAssert() throws Exception {
102:
103: StatefulSession session = getExceptionSession();
104:
105: final Cheese brie = new Cheese("brie", 12);
106:
107: Future futureAssert = session.asyncInsert(brie);
108:
109: Future futureFireAllRules = session.asyncFireAllRules();
110: int i = 0;
111: while (!futureFireAllRules.isDone()) {
112: Thread.sleep(100);
113: if (i++ > 5) {
114: fail("Future should have finished by now");
115: }
116: }
117:
118: assertTrue(futureAssert.getObject() instanceof FactHandle);
119: assertTrue(futureFireAllRules.exceptionThrown());
120: assertTrue(futureFireAllRules.getException() instanceof Exception);
121: }
122:
123: public void testHasExceptionArrayAssert() throws Exception {
124:
125: StatefulSession session = getExceptionSession();
126:
127: final Cheese brie = new Cheese("brie", 12);
128:
129: Future futureAssert = session
130: .asyncInsert(new Object[] { brie });
131: Future futureFireAllRules = session.asyncFireAllRules();
132:
133: int i = 0;
134: while (!futureFireAllRules.isDone()) {
135: Thread.sleep(100);
136: if (i++ > 5) {
137: fail("Future should have finished by now");
138: }
139: }
140:
141: assertTrue(futureAssert.getObject() instanceof List);
142: assertTrue(((List) futureAssert.getObject()).get(0) instanceof FactHandle);
143: assertTrue(futureFireAllRules.getException() instanceof Exception);
144: }
145:
146: public void testHasExceptionCollectionAssert() throws Exception {
147:
148: StatefulSession session = getExceptionSession();
149:
150: final Cheese brie = new Cheese("brie", 12);
151:
152: List collection = new ArrayList();
153: collection.add(brie);
154: Future futureAssert = session.asyncInsert(collection);
155: Future futureFireAllRules = session.asyncFireAllRules();
156:
157: int i = 0;
158: while (!futureFireAllRules.isDone()) {
159: Thread.sleep(100);
160: if (i++ > 5) {
161: fail("Future should have finished by now");
162: }
163: }
164:
165: assertTrue(futureAssert.getObject() instanceof List);
166: assertTrue(((List) futureAssert.getObject()).get(0) instanceof FactHandle);
167: assertTrue(futureFireAllRules.getException() instanceof Exception);
168: }
169:
170: public void testSequentialException() {
171: RuleBaseConfiguration config = new RuleBaseConfiguration();
172: config.setSequential(true);
173: RuleBase ruleBase = RuleBaseFactory.newRuleBase(config);
174:
175: try {
176: ruleBase.newStatefulSession();
177: fail("cannot have a stateful session with sequential set to true");
178: } catch (Exception e) {
179:
180: }
181: }
182:
183: private StatefulSession getExceptionSession() throws Exception {
184: final PackageBuilder builder = new PackageBuilder();
185: builder.addPackageFromDrl(new InputStreamReader(getClass()
186: .getResourceAsStream("test_ConsequenceException.drl")));
187: final Package pkg = builder.getPackage();
188:
189: final RuleBase ruleBase = getRuleBase();
190: ruleBase.addPackage(pkg);
191: return ruleBase.newStatefulSession();
192: }
193:
194: private StatefulSession getSession() throws Exception {
195: final PackageBuilder builder = new PackageBuilder();
196: builder.addPackageFromDrl(new InputStreamReader(getClass()
197: .getResourceAsStream("literal_rule_test.drl")));
198: final Package pkg = builder.getPackage();
199:
200: final RuleBase ruleBase = getRuleBase();
201: ruleBase.addPackage(pkg);
202: final StatefulSession session = ruleBase.newStatefulSession();
203:
204: session.setGlobal("list", this.list);
205: return session;
206: }
207: }
|