Examples of org.drools.StatelessSession

org.drools.StatelessSession
This represents a working memory session where state is not kept between invocations. This is typically used for "decision services" where the rules are provided all the data in one hit, and a conclusion reached by the engine. (there is no accumulation of facts/knowledge - each invocation is on a fresh session). Each created StatelessSession can be call execute() any number of times, in a stateless manner however the GlobalResolver, unless set each time, is shared between each execute() method call. Care should be used when using the async versions of the methods, consult the javadoc for the specific information.

        }
    }


    @Test
    public void testLiteralRestrictionsIncompatibilityImpossibleRange() throws Exception {
        StatelessSession session = getStatelessSession(this.getClass().getResourceAsStream("Restrictions.drl"));


        session.setAgendaFilter(new RuleNameMatchesAgendaFilter("Incompatible LiteralRestrictions with ranges in pattern possibility, impossible range"));


        Collection<Object> data = new ArrayList<Object>();


        Pattern pattern1 = VerifierComponentMockFactory.createPattern1();
        Pattern pattern2 = VerifierComponentMockFactory.createPattern2();


        /*
         * Working pair
         */
        LiteralRestriction r1 = LiteralRestriction.createRestriction(pattern1,
                "10");
        r1.setOperator(Operator.GREATER);
        r1.setFieldPath("0");
        r1.setOrderNumber(0);


        LiteralRestriction r2 = LiteralRestriction.createRestriction(pattern1,
                "10");
        r2.setOperator(Operator.LESS);
        r2.setFieldPath("0");
        r2.setOrderNumber(1);


        /*
         * Pair that doesn't work.
         */
        LiteralRestriction r3 = LiteralRestriction.createRestriction(pattern2,
                "1");
        r3.setOperator(Operator.GREATER_OR_EQUAL);
        r3.setFieldPath("1");
        r3.setOrderNumber(0);


        LiteralRestriction r4 = LiteralRestriction.createRestriction(pattern2,
                "");
        r4.setOperator(Operator.EQUAL);
        r4.setFieldPath("1");
        r4.setOrderNumber(1);


        data.add(r1);
        data.add(r2);
        data.add(r3);
        data.add(r4);


        StatelessSessionResult sessionResult = session.executeWithResults(data);


        Map<Cause, Set<Cause>> map = createIncompatibilityMap(VerifierComponentType.RESTRICTION,
                sessionResult.iterateObjects());


        assertTrue((TestBaseOld.causeMapContains(map,

View Full Code Here

        }
    }


    @Test
    public void testVariableRestrictionsIncompatibilityImpossibleRange() throws Exception {
        StatelessSession session = getStatelessSession(this.getClass().getResourceAsStream("Restrictions.drl"));


        session.setAgendaFilter(new RuleNameMatchesAgendaFilter("Incoherent VariableRestrictions in pattern possibility, impossible range"));


        Collection<Object> data = new ArrayList<Object>();


        VerifierRule rule = VerifierComponentMockFactory.createRule1();


        ObjectType objectType = new ObjectType();
        objectType.setFullName("org.test.Person");


        Pattern pattern1 = VerifierComponentMockFactory.createPattern1();
        Pattern pattern2 = VerifierComponentMockFactory.createPattern2();


        /*
         * Working pair
         */
        PatternVariable variable1 = new PatternVariable(rule);
        variable1.setParentPath("0");
        variable1.setParentType(VerifierComponentType.FIELD);
        variable1.setOrderNumber(11);


        VariableRestriction r1 = new VariableRestriction(pattern1);
        r1.setOperator(Operator.GREATER);
        r1.setFieldPath("0");
        r1.setVariable(variable1);
        r1.setOrderNumber(0);


        VariableRestriction r2 = new VariableRestriction(pattern1);
        r2.setOperator(Operator.LESS);
        r2.setFieldPath("0");
        r2.setVariable(variable1);
        r2.setOrderNumber(1);


        /*
         * Pair that doesn't work.
         */
        PatternVariable variable2 = new PatternVariable(rule);
        variable2.setParentPath("1");
        variable2.setParentType(VerifierComponentType.FIELD);
        variable2.setOrderNumber(10);


        VariableRestriction r3 = new VariableRestriction(pattern2);
        r3.setOperator(Operator.GREATER_OR_EQUAL);
        r3.setFieldPath("1");
        r3.setVariable(variable2);
        r3.setOrderNumber(0);


        VariableRestriction r4 = new VariableRestriction(pattern2);
        r4.setOperator(Operator.EQUAL);
        r4.setFieldPath("1");
        r4.setVariable(variable2);
        r4.setOrderNumber(1);


        data.add(r1);
        data.add(r2);
        data.add(r3);
        data.add(r4);


        StatelessSessionResult sessionResult = session.executeWithResults(data);


        Map<Cause, Set<Cause>> map = createIncompatibilityMap(VerifierComponentType.RESTRICTION,
                sessionResult.iterateObjects());


        assertTrue((TestBaseOld.causeMapContains(map,

View Full Code Here


public class IncompatibilityPatternsTest extends IncompatibilityBase {


    @Test
    public void testPatternsPossibilitiesIncompatibility() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Patterns.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incompatible Patterns" ) );


        Collection<Object> data = new ArrayList<Object>();


        Pattern pattern1 = VerifierComponentMockFactory.createPattern1();
        Pattern pattern2 = VerifierComponentMockFactory.createPattern2();


        /*
         * Working pair
         */
        SubPattern pp1 = new SubPattern( pattern1,
                                         0 );
        SubPattern pp2 = new SubPattern( pattern2,
                                         0 );


        Restriction r1 = LiteralRestriction.createRestriction( pattern1,
                                                               "" );
        pp1.add( r1 );


        Restriction r2 = LiteralRestriction.createRestriction( pattern2,
                                                               "" );
        pp2.add( r2 );


        Restriction r3 = LiteralRestriction.createRestriction( pattern1,
                                                               "" );
        pp1.add( r3 );


        Restriction r4 = LiteralRestriction.createRestriction( pattern2,
                                                               "" );
        pp2.add( r4 );


        Incompatibility o1 = new Incompatibility( r1,
                                                  r2 );
        Incompatibility o2 = new Incompatibility( r3,
                                                  r4 );


        Pattern pattern3 = VerifierComponentMockFactory.createPattern( 3 );
        Pattern pattern4 = VerifierComponentMockFactory.createPattern( 4 );
        /*
         * Another working pair.
         */
        SubPattern pp3 = new SubPattern( pattern3,
                                         0 );
        SubPattern pp4 = new SubPattern( pattern4,
                                         0 );


        Restriction r5 = LiteralRestriction.createRestriction( pattern3,
                                                               "" );
        pp3.add( r5 );


        Restriction r6 = LiteralRestriction.createRestriction( pattern4,
                                                               "" );
        pp4.add( r6 );


        Restriction r7 = LiteralRestriction.createRestriction( pattern3,
                                                               "" );
        pp3.add( r7 );


        Restriction r8 = LiteralRestriction.createRestriction( pattern4,
                                                               "" );
        pp4.add( r8 );


        Incompatibility o3 = new Incompatibility( r5,
                                                  r6 );


        data.add( r1 );
        data.add( r2 );
        data.add( r3 );
        data.add( r4 );
        data.add( r5 );
        data.add( r6 );
        data.add( r7 );
        data.add( r8 );
        data.add( pp1 );
        data.add( pp2 );
        data.add( pp3 );
        data.add( pp4 );
        data.add( o1 );
        data.add( o2 );
        data.add( o3 );


        StatelessSessionResult sessionResult = session.executeWithResults( data );


        Map<Cause, Set<Cause>> map = createIncompatibilityMap( VerifierComponentType.SUB_PATTERN,
                                                               sessionResult.iterateObjects() );


        assertTrue( (TestBaseOld.causeMapContains(map,

View Full Code Here


    }


    @Test
    public void testIncoherentLiteralRestrictionsInSubPattern() throws Exception {
        StatelessSession session = getStatelessSession( getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions in pattern possibility" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

        }
    }


    @Test
    public void testIncoherentLiteralRestrictionsInSubPatternImpossibleRanges() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible ranges" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

        }
    }


    @Test
    public void testIncoherentLiteralRestrictionsInSubPatternImpossibleEqualityLess() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality less or equal" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

        }
    }


    @Test
    public void testIncoherentLiteralRestrictionsInSubPatternImpossibleEqualityGreater() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible equality greater" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

        }
    }


    @Test
    public void testIncoherentLiteralRestrictionsInSubPatternImpossibleRange() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent LiteralRestrictions with ranges in pattern possibility, impossible range" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

        }
    }


    @Test
    public void testIncoherentVariableRestrictionsInSubPattern() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent VariableRestrictions in pattern possibility" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

        }
    }


    @Test
    public void testIncoherentVariableRestrictionsInSubPatternImpossibleRange() throws Exception {
        StatelessSession session = getStatelessSession( this.getClass().getResourceAsStream( "Restrictions.drl" ) );


        session.setAgendaFilter( new RuleNameMatchesAgendaFilter( "Incoherent VariableRestrictions in pattern possibility, impossible range" ) );


        VerifierReport result = VerifierReportFactory.newVerifierReport();
        Collection< ? extends Object> testData = getTestData( this.getClass().getResourceAsStream( "RestrictionsTest.drl" ),
                                                              result.getVerifierData() );


        session.setGlobal( "result",
                           result );


        session.executeWithResults( testData );


        Iterator<VerifierMessageBase> iter = result.getBySeverity( Severity.ERROR ).iterator();


        Set<String> rulesThatHadErrors = new HashSet<String>();
        while ( iter.hasNext() ) {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.drools.StatelessSession

org.drools.analytics.RangeCheckCleanTest

org.drools.analytics.RangeCheckDatesTest

org.drools.analytics.RangeCheckDoublesTest

org.drools.analytics.RangeCheckIntegersTest

org.drools.analytics.RedundancyTest

org.drools.analytics.SubsumptantPossibilitiesRuleTest

org.drools.guvnor.server.RepositoryPackageServiceTest

org.drools.guvnor.server.selector.RuleBasedSelector

org.drools.guvnor.server.ServiceImplementationTest

org.drools.integrationtests.AccumulateTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.