@Test
public void shouldHaveBestRuleSetJoinAlgorithmToMergeIfConditionIsNotDescendantNode() {

    PlanNode join = new PlanNode(Type.JOIN, selector("Parent"), selector("Child"));
    PlanNode parentSource = new PlanNode(Type.SOURCE, join, selector("Parent"));
    PlanNode childSource = new PlanNode(Type.SOURCE, join, selector("Child"));
    // Set the join type and condition ...
    JoinCondition joinCondition = new ChildNodeJoinCondition(selector("Parent"), selector("Child"));
    join.setProperty(Property.JOIN_CONDITION, joinCondition);
    join.setProperty(Property.JOIN_TYPE, JoinType.INNER);
    // Execute the rule ...
    PlanNode result = bestRule.execute(context, join, new LinkedList<OptimizerRule>());
    assertThat(result, is(sameInstance(join)));
    assertThat(join.getProperty(Property.JOIN_TYPE, JoinType.class), is(JoinType.INNER));
    assertThat(join.getProperty(Property.JOIN_ALGORITHM, JoinAlgorithm.class), is(JoinAlgorithm.MERGE));
    assertThat(join.getProperty(Property.JOIN_CONDITION, JoinCondition.class), is(sameInstance(joinCondition)));
    PlanNode leftDup = join.getFirstChild();
    assertThat(leftDup.getType(), is(Type.DUP_REMOVE));
    assertSelectors(leftDup, "Parent");
    PlanNode leftSort = leftDup.getFirstChild();
    assertThat(leftSort.getType(), is(Type.SORT));
    assertSortOrderBy(leftSort, "Parent");
    assertSelectors(leftSort, "Parent");
    assertChildren(leftDup, leftSort);
    assertChildren(leftSort, parentSource);
    PlanNode rightDup = join.getLastChild();
    assertThat(rightDup.getType(), is(Type.DUP_REMOVE));
    assertSelectors(rightDup, "Child");
    PlanNode rightSort = rightDup.getLastChild();
    assertThat(rightSort.getType(), is(Type.SORT));
    assertSortOrderBy(rightSort, "Child");
    assertSelectors(rightSort, "Child");
    assertChildren(rightDup, rightSort);
    assertChildren(rightSort, childSource);
    assertChildren(join, leftDup, rightDup);
}