public void Build_CrossJoinWithUsinngBranch_ThrowsException()
        {
            JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches);

            joinBuilder.AddMainExpr(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));
            joinBuilder.AddBranch("ds", ModelResolvers.ExprResolver());
            joinBuilder.AddBranch("using", ModelResolvers.ExprResolver());
            joinBuilder.Branches["main"].OperatorDefinition.Keyword = "cross";

            Assert.ThrowsAny <VtlOperatorError>(() => { joinBuilder.Build(); });
        }
        public void AddBranch_Expr_AddsBranch()
        {
            JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches);
            IExpression expr        = ModelResolvers.ExprResolver();

            Assert.False(joinBuilder.Branches.ContainsKey("branch"));

            joinBuilder.AddBranch("branch", expr);

            Assert.True(joinBuilder.Branches.ContainsKey("branch"));
            Assert.Equal(expr, joinBuilder.Branches["branch"]);
            Assert.False(joinBuilder.IsCleared);
        }
        public void Build_WrongBranchesCombination_ThrowsException(params string[] branches)
        {
            JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches);

            joinBuilder.AddMainExpr(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));

            foreach (string branch in branches)
            {
                joinBuilder.AddBranch(branch, TestExprFactory.GetExpression("opt", ExpressionFactoryNameTarget.OperatorSymbol));
            }

            Assert.ThrowsAny <VtlOperatorError>(() => { joinBuilder.Build(); });
        }
        public void Clear_ClearsBranches()
        {
            JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches);
            IExpression expr1       = ModelResolvers.ExprResolver();
            IExpression expr2       = ModelResolvers.ExprResolver();
            IExpression expr3       = ModelResolvers.ExprResolver();

            Assert.False(joinBuilder.Branches.ContainsKey("branch1"));
            Assert.False(joinBuilder.Branches.ContainsKey("branch2"));
            Assert.False(joinBuilder.Branches.ContainsKey("branch3"));

            joinBuilder.AddBranch("branch1", expr1);
            joinBuilder.AddBranch("branch2", expr2);
            joinBuilder.AddBranch("branch3", expr3);

            Assert.False(joinBuilder.IsCleared);

            joinBuilder.Clear();

            Assert.False(joinBuilder.Branches.ContainsKey("branch1"));
            Assert.False(joinBuilder.Branches.ContainsKey("branch2"));
            Assert.False(joinBuilder.Branches.ContainsKey("branch3"));
            Assert.True(joinBuilder.IsCleared);
        }
        public void Build_CorrectBranches_JoinExpr(params string[] branches)
        {
            JoinBuilder joinBuilder = new JoinBuilder(ModelResolvers.JoinExprResolver, this.joinBranches);

            joinBuilder.AddMainExpr(TestExprFactory.GetExpression("join", ExpressionFactoryNameTarget.OperatorSymbol));

            Assert.Empty(joinBuilder.Branches["main"].OperandsCollection);

            foreach (string branch in branches)
            {
                joinBuilder.AddBranch(branch, TestExprFactory.GetExpression("opt", ExpressionFactoryNameTarget.OperatorSymbol));
            }

            IJoinExpression result = joinBuilder.Build();

            Assert.Equal(branches.Length, joinBuilder.Branches["main"].OperandsCollection.Count);
            Assert.Equal(branches.Length, result.OperandsCollection.Count);

            foreach (string branch in branches)
            {
                Assert.True(joinBuilder.Branches["main"].Operands.ContainsKey(branch));
                Assert.True(result.Operands.ContainsKey(branch));
            }
        }