* ModeShape (http://www.modeshape.org)

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*       http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

*

*/

    private TypeSystem typeSystem;

    private BasicSqlQueryParser parser;

    @Before

    public void beforeEach() {

        typeSystem = new ExecutionContext().getValueFactories().getTypeSystem();

        parser = new BasicSqlQueryParser();

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseQuery

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseNominalQueries() {

        parse("SELECT * FROM tableA");

        parse("SELECT column1 FROM tableA");

        parse("SELECT tableA.column1 FROM tableA");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA INNER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA OUTER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA LEFT OUTER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA RIGHT OUTER JOIN tableB ON tableA.id = tableB.id");

    }

    @Test

    public void shouldParseQueriesWithNonSqlColumnNames() {

        parse("SELECT * FROM [dna:tableA]");

        parse("SELECT [jcr:column1] FROM [dna:tableA]");

        parse("SELECT 'jcr:column1' FROM 'dna:tableA'");

        parse("SELECT \"jcr:column1\" FROM \"dna:tableA\"");

    }

    @FixFor( "MODE-869" )

    @Test

    public void shouldParseQueriesWithSubqueries() {

        parse("SELECT * FROM tableA WHERE PATH() LIKE (SELECT path FROM tableB)");

        parse("SELECT * FROM tableA WHERE PATH() LIKE (SELECT path FROM tableB) AND tableA.propX = 'foo'");

        parse("SELECT * FROM tableA WHERE PATH() LIKE (((SELECT path FROM tableB)))");

        parse("SELECT * FROM tableA WHERE PATH() LIKE (SELECT path FROM tableB WHERE prop < 2)");

        parse("SELECT * FROM tableA WHERE PATH() IN (SELECT path FROM tableB) AND tableA.propX = 'foo'");

        parse("SELECT * FROM tableA WHERE PATH() NOT IN (SELECT path FROM tableB) AND tableA.propX = 'foo'");

    }

    @Test

    public void shouldParseQueriesSelectingFromAllTables() {

        parse("SELECT * FROM __AllTables__");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseQueriesWithNoFromClause() {

        parse("SELECT 'jcr:column1'");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseQueriesWithIncompleteFromClause() {

        parse("SELECT 'jcr:column1' FROM  ");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseQueriesWithUnmatchedSingleQuoteCharacters() {

        parse("SELECT 'jcr:column1' FROM \"dna:tableA'");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseQueriesWithUnmatchedDoubleQuoteCharacters() {

        parse("SELECT \"jcr:column1' FROM \"dna:tableA\"");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseQueriesWithUnmatchedBracketQuoteCharacters() {

        parse("SELECT [jcr:column1' FROM [dna:tableA]");

    }

    @Test

    public void shouldParseQueriesWithSelectStar() {

        parse("SELECT * FROM tableA");

        parse("SELECT tableA.* FROM tableA");

        parse("SELECT tableA.column1, tableB.* FROM tableA JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.*, tableB.column2 FROM tableA JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.*, tableB.* FROM tableA JOIN tableB ON tableA.id = tableB.id");

    }

    @Test

    public void shouldParseQueriesWithAllKindsOfJoins() {

        parse("SELECT tableA.column1, tableB.column2 FROM tableA JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA INNER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA OUTER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA LEFT OUTER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA RIGHT OUTER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA FULL OUTER JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT tableA.column1, tableB.column2 FROM tableA CROSS JOIN tableB ON tableA.id = tableB.id");

    }

    @Test

    public void shouldParseQueriesWithMultipleJoins() {

        parse("SELECT * FROM tableA JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT * FROM tableA JOIN tableB ON tableA.id = tableB.id JOIN tableC ON tableA.id2 = tableC.id2");

    }

    @Test

    public void shouldParseQueriesWithEquiJoinCriteria() {

        parse("SELECT tableA.column1, tableB.column2 FROM tableA JOIN tableB ON tableA.id = tableB.id");

        parse("SELECT * FROM tableA JOIN tableB ON tableA.id = tableB.id JOIN tableC ON tableA.id2 = tableC.id2");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseEquiJoinCriteriaMissingPropertyName() {

        parse("SELECT tableA.column1, tableB.column2 FROM tableA JOIN tableB ON tableA = tableB.id");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseEquiJoinCriteriaMissingTableName() {

        parse("SELECT tableA.column1, tableB.column2 FROM tableA JOIN tableB ON column1 = tableB.id");

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseEquiJoinCriteriaMissingEquals() {

        parse("SELECT tableA.column1, tableB.column2 FROM tableA JOIN tableB ON column1 tableB.id");

    }

    @Test

    public void shouldParseQueriesOnMultpleLines() {

        parse("SELECT * \nFROM tableA");

        parse("SELECT \ncolumn1 \nFROM tableA");

        parse("SELECT \ntableA.column1 \nFROM\n tableA");

        parse("SELECT tableA.\ncolumn1, \ntableB.column2 \nFROM tableA JOIN \ntableB ON tableA.id \n= tableB.\nid");

    }

    @Test

    public void shouldParseQueriesThatUseDifferentCaseForKeywords() {

        parse("select * from tableA");

        parse("SeLeCt * from tableA");

        parse("select column1 from tableA");

        parse("select tableA.column1 from tableA");

        parse("select tableA.column1, tableB.column2 from tableA join tableB on tableA.id = tableB.id");

    }

    @Test

    public void shouldParseUnionQueries() {

        parse("SELECT * FROM tableA UNION SELECT * FROM tableB");

        parse("SELECT * FROM tableA UNION ALL SELECT * FROM tableB");

        parse("SELECT * FROM tableA UNION SELECT * FROM tableB UNION SELECT * FROM tableC");

        parse("SELECT * FROM tableA UNION ALL SELECT * FROM tableB UNION SELECT * FROM tableC");

    }

    @Test

    public void shouldParseIntersectQueries() {

        parse("SELECT * FROM tableA INTERSECT SELECT * FROM tableB");

        parse("SELECT * FROM tableA INTERSECT ALL SELECT * FROM tableB");

        parse("SELECT * FROM tableA INTERSECT SELECT * FROM tableB INTERSECT SELECT * FROM tableC");

        parse("SELECT * FROM tableA INTERSECT ALL SELECT * FROM tableB INTERSECT ALL SELECT * FROM tableC");

    }

    @Test

    public void shouldParseExceptQueries() {

        parse("SELECT * FROM tableA EXCEPT SELECT * FROM tableB");

        parse("SELECT * FROM tableA EXCEPT ALL SELECT * FROM tableB");

        parse("SELECT * FROM tableA EXCEPT SELECT * FROM tableB EXCEPT SELECT * FROM tableC");

        parse("SELECT * FROM tableA EXCEPT ALL SELECT * FROM tableB EXCEPT ALL SELECT * FROM tableC");

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseSetQuery

    // ----------------------------------------------------------------------------------------------------------------

    // ----------------------------------------------------------------------------------------------------------------

    // parseSelect

    // ----------------------------------------------------------------------------------------------------------------

    // ----------------------------------------------------------------------------------------------------------------

    // parseFrom

    // ----------------------------------------------------------------------------------------------------------------

    // ----------------------------------------------------------------------------------------------------------------

    // parseJoinCondition

    // ----------------------------------------------------------------------------------------------------------------

    // ----------------------------------------------------------------------------------------------------------------

    // parseWhere

    // ----------------------------------------------------------------------------------------------------------------

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithValidExpressions() {

        assertParseConstraint("ISSAMENODE('/a/b')");

        assertParseConstraint("ISSAMENODE('/a/b') AND NOT(ISCHILDNODE('/parent'))");

        assertParseConstraint("ISSAMENODE('/a/b') AND (NOT(ISCHILDNODE('/parent')))");

        assertParseConstraint("ISSAMENODE('/a/b') AND (NOT(tableA.id < 1234)))");

    }

    protected void assertParseConstraint( String expression ) {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        parser.parseConstraint(tokens(expression), typeSystem, selector);

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - between

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithValidBetweenExpressionUsing() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("tableA.id BETWEEN 'lower' AND 'upper'"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(Between.class)));

        Between between = (Between)constraint;

        assertThat(between.isLowerBoundIncluded(), is(true));

        assertThat(between.isUpperBoundIncluded(), is(true));

        assertThat(between.getOperand(), is(instanceOf(PropertyValue.class)));

        PropertyValue operand = (PropertyValue)between.getOperand();

        assertThat(operand.selectorName(), is(selector.name()));

        assertThat(operand.getPropertyName(), is("id"));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat((Literal)between.getLowerBound(), is(literal("lower")));

        assertThat((Literal)between.getUpperBound(), is(literal("upper")));

    }

    @Test

    public void shouldParseConstraintFromStringWithValidBetweenExpressionUsingExclusiveAndExclusive() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("tableA.id BETWEEN 'lower' EXCLUSIVE AND 'upper' EXCLUSIVE"),

                                                       typeSystem,

                                                       selector);

        assertThat(constraint, is(instanceOf(Between.class)));

        Between between = (Between)constraint;

        assertThat(between.isLowerBoundIncluded(), is(false));

        assertThat(between.isUpperBoundIncluded(), is(false));

        assertThat(between.getOperand(), is(instanceOf(PropertyValue.class)));

        PropertyValue operand = (PropertyValue)between.getOperand();

        assertThat(operand.selectorName(), is(selector.name()));

        assertThat(operand.getPropertyName(), is("id"));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat((Literal)between.getLowerBound(), is(literal("lower")));

        assertThat((Literal)between.getUpperBound(), is(literal("upper")));

    }

    @Test

    public void shouldParseConstraintFromStringWithValidBetweenExpressionUsingInclusiveAndExclusive() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("tableA.id BETWEEN 'lower' AND 'upper' EXCLUSIVE"),

                                                       typeSystem,

                                                       selector);

        assertThat(constraint, is(instanceOf(Between.class)));

        Between between = (Between)constraint;

        assertThat(between.isLowerBoundIncluded(), is(true));

        assertThat(between.isUpperBoundIncluded(), is(false));

        assertThat(between.getOperand(), is(instanceOf(PropertyValue.class)));

        PropertyValue operand = (PropertyValue)between.getOperand();

        assertThat(operand.selectorName(), is(selector.name()));

        assertThat(operand.getPropertyName(), is("id"));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat((Literal)between.getLowerBound(), is(literal("lower")));

        assertThat((Literal)between.getUpperBound(), is(literal("upper")));

    }

    @Test

    public void shouldParseConstraintFromStringWithValidBetweenExpressionUsingExclusiveAndInclusive() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("tableA.id BETWEEN 'lower' EXCLUSIVE AND 'upper'"),

                                                       typeSystem,

                                                       selector);

        assertThat(constraint, is(instanceOf(Between.class)));

        Between between = (Between)constraint;

        assertThat(between.isLowerBoundIncluded(), is(false));

        assertThat(between.isUpperBoundIncluded(), is(true));

        assertThat(between.getOperand(), is(instanceOf(PropertyValue.class)));

        PropertyValue operand = (PropertyValue)between.getOperand();

        assertThat(operand.selectorName(), is(selector.name()));

        assertThat(operand.getPropertyName(), is("id"));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat((Literal)between.getLowerBound(), is(literal("lower")));

        assertThat((Literal)between.getUpperBound(), is(literal("upper")));

    }

    @Test

    public void shouldParseConstraintFromStringWithValidNotBetweenExpression() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("tableA.id NOT BETWEEN 'lower' AND 'upper'"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(Not.class)));

        constraint = ((Not)constraint).getConstraint();

        assertThat(constraint, is(instanceOf(Between.class)));

        Between between = (Between)constraint;

        assertThat(between.isLowerBoundIncluded(), is(true));

        assertThat(between.isUpperBoundIncluded(), is(true));

        assertThat(between.getOperand(), is(instanceOf(PropertyValue.class)));

        PropertyValue operand = (PropertyValue)between.getOperand();

        assertThat(operand.selectorName(), is(selector.name()));

        assertThat(operand.getPropertyName(), is("id"));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat(between.getLowerBound(), is(instanceOf(Literal.class)));

        assertThat((Literal)between.getLowerBound(), is(literal("lower")));

        assertThat((Literal)between.getUpperBound(), is(literal("upper")));

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - parentheses

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithOuterParentheses() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("( ISSAMENODE('/a/b') )"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)constraint;

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b"));

    }

    @Test

    public void shouldParseConstraintFromStringWithMultipleOuterParentheses() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("((( ISSAMENODE('/a/b') )))"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)constraint;

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b"));

    }

    @Test

    public void shouldParseConstraintFromStringWithParenthesesAndConjunctionAndDisjunctions() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("ISSAMENODE('/a/b') OR (ISSAMENODE('/c/d') AND ISSAMENODE('/e/f'))"),

                                                       typeSystem,

                                                       selector);

        assertThat(constraint, is(instanceOf(Or.class)));

        Or or = (Or)constraint;

        assertThat(or.left(), is(instanceOf(SameNode.class)));

        SameNode first = (SameNode)or.left();

        assertThat(first.selectorName(), is(selectorName("tableA")));

        assertThat(first.getPath(), is("/a/b"));

        assertThat(or.right(), is(instanceOf(And.class)));

        And and = (And)or.right();

        assertThat(and.left(), is(instanceOf(SameNode.class)));

        SameNode second = (SameNode)and.left();

        assertThat(second.selectorName(), is(selectorName("tableA")));

        assertThat(second.getPath(), is("/c/d"));

        assertThat(and.right(), is(instanceOf(SameNode.class)));

        SameNode third = (SameNode)and.right();

        assertThat(third.selectorName(), is(selectorName("tableA")));

        assertThat(third.getPath(), is("/e/f"));

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - AND

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithAndExpressionWithNoParentheses() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("ISSAMENODE('/a/b/c') AND CONTAINS(p1,term1)"),

                                                       typeSystem,

                                                       selector);

        assertThat(constraint, is(instanceOf(And.class)));

        And and = (And)constraint;

        assertThat(and.left(), is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)and.left();

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b/c"));

        assertThat(and.right(), is(instanceOf(FullTextSearch.class)));

        FullTextSearch search = (FullTextSearch)and.right();

        assertThat(search.selectorName(), is(selectorName("tableA")));

        assertThat(search.getPropertyName(), is("p1"));

        assertThat(search.fullTextSearchExpression(), is("term1"));

    }

    @Test

    public void shouldParseConstraintFromStringWithMultipleAndExpressions() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("ISSAMENODE('/a/b/c') AND CONTAINS(p1,term1) AND CONTAINS(p2,term2)"),

                                                       typeSystem,

                                                       selector);

        assertThat(constraint, is(instanceOf(And.class)));

        And and = (And)constraint;

        assertThat(and.left(), is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)and.left();

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b/c"));

        assertThat(and.right(), is(instanceOf(And.class)));

        And secondAnd = (And)and.right();

        assertThat(secondAnd.left(), is(instanceOf(FullTextSearch.class)));

        FullTextSearch search1 = (FullTextSearch)secondAnd.left();

        assertThat(search1.selectorName(), is(selectorName("tableA")));

        assertThat(search1.getPropertyName(), is("p1"));

        assertThat(search1.fullTextSearchExpression(), is("term1"));

        assertThat(secondAnd.right(), is(instanceOf(FullTextSearch.class)));

        FullTextSearch search2 = (FullTextSearch)secondAnd.right();

        assertThat(search2.selectorName(), is(selectorName("tableA")));

        assertThat(search2.getPropertyName(), is("p2"));

        assertThat(search2.fullTextSearchExpression(), is("term2"));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithAndExpressionWithNoSecondConstraint() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        parser.parseConstraint(tokens("ISSAMENODE('/a/b/c') AND WHAT THE HECK IS THIS"), typeSystem, selector);

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - OR

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithOrExpressionWithNoParentheses() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("ISSAMENODE('/a/b/c') OR CONTAINS(p1,term1)"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(Or.class)));

        Or or = (Or)constraint;

        assertThat(or.left(), is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)or.left();

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b/c"));

        assertThat(or.right(), is(instanceOf(FullTextSearch.class)));

        FullTextSearch search = (FullTextSearch)or.right();

        assertThat(search.selectorName(), is(selectorName("tableA")));

        assertThat(search.getPropertyName(), is("p1"));

        assertThat(search.fullTextSearchExpression(), is("term1"));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithOrExpressionWithNoSecondConstraint() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        parser.parseConstraint(tokens("ISSAMENODE('/a/b/c') OR WHAT THE HECK IS THIS"), typeSystem, selector);

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - NOT

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithNotSameNodeExpression() {

        Constraint constraint = parser.parseConstraint(tokens("NOT(ISSAMENODE(tableA,'/a/b/c'))"), typeSystem, mock(Source.class));

        assertThat(constraint, is(instanceOf(Not.class)));

        Not not = (Not)constraint;

        assertThat(not.getConstraint(), is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)not.getConstraint();

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b/c"));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithNotConstraintWithOutOpeningParenthesis() {

        parser.parseConstraint(tokens("NOT CONTAINS(propertyA 'term1 term2 -term3')"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithNotConstraintWithOutClosingParenthesis() {

        parser.parseConstraint(tokens("NOT( CONTAINS(propertyA 'term1 term2 -term3') BLAH"), typeSystem, mock(Source.class));

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - CONTAINS

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithIsContainsExpressionWithPropertyAndNoSelectorNameOnlyIfThereIsOneSelectorSource() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("CONTAINS(propertyA,'term1 term2 -term3')"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(FullTextSearch.class)));

        FullTextSearch search = (FullTextSearch)constraint;

        assertThat(search.selectorName(), is(selectorName("tableA")));

        assertThat(search.getPropertyName(), is("propertyA"));

        assertThat(search.fullTextSearchExpression(), is("term1 term2 -term3"));

    }

    @Test

    public void shouldParseConstraintFromStringWithIsContainsExpressionWithSelectorNameAndProperty() {

        Constraint constraint = parser.parseConstraint(tokens("CONTAINS(tableA.propertyA,'term1 term2 -term3')"),

                                                       typeSystem,

                                                       mock(Source.class));

        assertThat(constraint, is(instanceOf(FullTextSearch.class)));

        FullTextSearch search = (FullTextSearch)constraint;

        assertThat(search.selectorName(), is(selectorName("tableA")));

        assertThat(search.getPropertyName(), is("propertyA"));

        assertThat(search.fullTextSearchExpression(), is("term1 term2 -term3"));

    }

    @Test

    public void shouldParseConstraintFromStringWithIsContainsExpressionWithSelectorNameAndAnyProperty() {

        Constraint constraint = parser.parseConstraint(tokens("CONTAINS(tableA.*,'term1 term2 -term3')"),

                                                       typeSystem,

                                                       mock(Source.class));

        assertThat(constraint, is(instanceOf(FullTextSearch.class)));

        FullTextSearch search = (FullTextSearch)constraint;

        assertThat(search.selectorName(), is(selectorName("tableA")));

        assertThat(search.getPropertyName(), is(nullValue()));

        assertThat(search.fullTextSearchExpression(), is("term1 term2 -term3"));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithContainsExpressionWithNoCommaAfterSelectorName() {

        parser.parseConstraint(tokens("CONTAINS(propertyA 'term1 term2 -term3')"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithContainsExpressionWithNoClosingParenthesis() {

        parser.parseConstraint(tokens("CONTAINS(propertyA,'term1 term2 -term3' OTHER"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithContainsExpressionWithNoOpeningParenthesis() {

        parser.parseConstraint(tokens("CONTAINS propertyA,'term1 term2 -term3')"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithContainsExpressionWithNoSelectorNameIfSourceIsNotSelector() {

        parser.parseConstraint(tokens("CONTAINS(propertyA,'term1 term2 -term3')"), typeSystem, mock(Join.class));

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - ISSAMENODE

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithIsSameNodeExpressionWithPathOnlyIfThereIsOneSelectorSource() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("ISSAMENODE('/a/b/c')"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)constraint;

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b/c"));

    }

    @Test

    public void shouldParseConstraintFromStringWithIsSameNodeExpressionWithSelectorNameAndPath() {

        Constraint constraint = parser.parseConstraint(tokens("ISSAMENODE(tableA,'/a/b/c')"), typeSystem, mock(Source.class));

        assertThat(constraint, is(instanceOf(SameNode.class)));

        SameNode same = (SameNode)constraint;

        assertThat(same.selectorName(), is(selectorName("tableA")));

        assertThat(same.getPath(), is("/a/b/c"));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsSameNodeExpressionWithNoCommaAfterSelectorName() {

        parser.parseConstraint(tokens("ISSAMENODE(tableA '/a/b/c')"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsSameNodeExpressionWithNoClosingParenthesis() {

        parser.parseConstraint(tokens("ISSAMENODE(tableA,'/a/b/c' AND"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsSameNodeExpressionWithNoOpeningParenthesis() {

        parser.parseConstraint(tokens("ISSAMENODE tableA,'/a/b/c')"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsSameNodeExpressionWithNoSelectorNameIfSourceIsNotSelector() {

        parser.parseConstraint(tokens("ISSAMENODE('/a/b/c')"), typeSystem, mock(Join.class));

    }

    // ----------------------------------------------------------------------------------------------------------------

    // parseConstraint - ISCHILDNODE

    // ----------------------------------------------------------------------------------------------------------------

    @Test

    public void shouldParseConstraintFromStringWithIsChildNodeExpressionWithPathOnlyIfThereIsOneSelectorSource() {

        NamedSelector selector = new NamedSelector(selectorName("tableA"));

        Constraint constraint = parser.parseConstraint(tokens("ISCHILDNODE('/a/b/c')"), typeSystem, selector);

        assertThat(constraint, is(instanceOf(ChildNode.class)));

        ChildNode child = (ChildNode)constraint;

        assertThat(child.selectorName(), is(selectorName("tableA")));

        assertThat(child.getParentPath(), is("/a/b/c"));

    }

    @Test

    public void shouldParseConstraintFromStringWithIsChildNodeExpressionWithSelectorNameAndPath() {

        Constraint constraint = parser.parseConstraint(tokens("ISCHILDNODE(tableA,'/a/b/c')"), typeSystem, mock(Source.class));

        assertThat(constraint, is(instanceOf(ChildNode.class)));

        ChildNode child = (ChildNode)constraint;

        assertThat(child.selectorName(), is(selectorName("tableA")));

        assertThat(child.getParentPath(), is("/a/b/c"));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsChildNodeExpressionWithNoCommaAfterSelectorName() {

        parser.parseConstraint(tokens("ISCHILDNODE(tableA '/a/b/c')"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsChildNodeExpressionWithNoClosingParenthesis() {

        parser.parseConstraint(tokens("ISCHILDNODE(tableA,'/a/b/c' AND"), typeSystem, mock(Source.class));

    }

    @Test( expected = ParsingException.class )

    public void shouldFailToParseConstraintFromStringWithIsChildNodeExpressionWithNoOpeningParenthesis() {

        parser.parseConstraint(tokens("ISCHILDNODE tableA,'/a/b/c')"), typeSystem, mock(Source.class));

    }