puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/parser/ast/casestatement_spec.rb

@@ -1,168 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::CaseStatement do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  describe "when evaluating" do
-
-    before :each do
-      @test = stub 'test'
-      @test.stubs(:safeevaluate).with(@scope).returns("value")
-
-      @option1 = Puppet::Parser::AST::CaseOpt.new({})
-      @option1.stubs(:eachopt)
-      @option1.stubs(:default?).returns false
-      @option2 = Puppet::Parser::AST::CaseOpt.new({})
-      @option2.stubs(:eachopt)
-      @option2.stubs(:default?).returns false
-
-      @options = Puppet::Parser::AST::ASTArray.new(:children => [@option1, @option2])
-
-      @casestmt = Puppet::Parser::AST::CaseStatement.new :test => @test, :options => @options
-    end
-
-    it "should evaluate test" do
-      @test.expects(:safeevaluate).with(@scope)
-
-      @casestmt.evaluate(@scope)
-    end
-
-    it "should scan each option" do
-      @casestmt.evaluate(@scope)
-    end
-
-    describe "when scanning options" do
-      before :each do
-        @opval1 = stub_everything 'opval1'
-        @option1.stubs(:eachopt).yields(@opval1)
-
-        @opval2 = stub_everything 'opval2'
-        @option2.stubs(:eachopt).yields(@opval2)
-      end
-
-      it "should evaluate each sub-option" do
-        @option1.expects(:eachopt)
-        @option2.expects(:eachopt)
-
-        @casestmt.evaluate(@scope)
-      end
-
-      it "should evaluate first matching option" do
-        @opval2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
-        @option2.expects(:safeevaluate).with(@scope)
-
-        @casestmt.evaluate(@scope)
-      end
-
-      it "should return the first matching evaluated option" do
-        @opval2.stubs(:evaluate_match).with { |*arg| arg[0] == "value" }.returns(true)
-        @option2.stubs(:safeevaluate).with(@scope).returns(:result)
-
-        @casestmt.evaluate(@scope).should == :result
-      end
-
-      it "should evaluate the default option if none matched" do
-        @option1.stubs(:default?).returns(true)
-        @option1.expects(:safeevaluate).with(@scope)
-
-        @casestmt.evaluate(@scope)
-      end
-
-      it "should return the default evaluated option if none matched" do
-        @option1.stubs(:default?).returns(true)
-        @option1.stubs(:safeevaluate).with(@scope).returns(:result)
-
-        @casestmt.evaluate(@scope).should == :result
-      end
-
-      it "should return nil if nothing matched" do
-        @casestmt.evaluate(@scope).should be_nil
-      end
-
-      it "should match and set scope ephemeral variables" do
-        @opval1.expects(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }
-
-        @casestmt.evaluate(@scope)
-      end
-
-      it "should evaluate this regex option if it matches" do
-        @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
-
-        @option1.expects(:safeevaluate).with(@scope)
-
-        @casestmt.evaluate(@scope)
-      end
-
-      it "should return this evaluated regex option if it matches" do
-        @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
-        @option1.stubs(:safeevaluate).with(@scope).returns(:result)
-
-        @casestmt.evaluate(@scope).should == :result
-      end
-
-      it "should unset scope ephemeral variables after option evaluation" do
-        @scope.stubs(:ephemeral_level).returns(:level)
-        @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
-        @option1.stubs(:safeevaluate).with(@scope).returns(:result)
-
-        @scope.expects(:unset_ephemeral_var).with(:level)
-
-        @casestmt.evaluate(@scope)
-      end
-
-      it "should not leak ephemeral variables even if evaluation fails" do
-        @scope.stubs(:ephemeral_level).returns(:level)
-        @opval1.stubs(:evaluate_match).with { |*arg| arg[0] == "value" and arg[1] == @scope }.returns(true)
-        @option1.stubs(:safeevaluate).with(@scope).raises
-
-        @scope.expects(:unset_ephemeral_var).with(:level)
-
-        lambda { @casestmt.evaluate(@scope) }.should raise_error
-      end
-    end
-
-  end
-
-  it "should match if any of the provided options evaluate as true" do
-    ast = nil
-    AST = Puppet::Parser::AST
-
-    tests = {
-      "one" => %w{a b c},
-      "two" => %w{e f g}
-    }
-    options = tests.collect do |result, values|
-      values = values.collect { |v| AST::Leaf.new :value => v }
-
-      AST::CaseOpt.new(
-        :value      => AST::ASTArray.new(:children => values),
-        :statements => AST::Leaf.new(:value => result)
-      )
-    end
-    options << AST::CaseOpt.new(
-      :value      => AST::Default.new(:value => "default"), 
-      :statements => AST::Leaf.new(:value => "default")
-    )
-
-    ast = nil
-    param = AST::Variable.new(:value => "testparam")
-    ast = AST::CaseStatement.new(:test => param, :options => options)
-
-    tests.each do |should, values|
-      values.each do |value|
-        node     = Puppet::Node.new('localhost')
-        compiler = Puppet::Parser::Compiler.new(node)
-        scope    = Puppet::Parser::Scope.new(compiler)
-        scope['testparam'] = value
-        result = ast.evaluate(scope)
-
-        result.should == should
-      end
-    end
-  end
-end

data/spec/unit/parser/ast/collection_spec.rb

@@ -1,70 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::Collection do
-  before :each do
-    @mytype = Puppet::Resource::Type.new(:definition, "mytype")
-    @environment = Puppet::Node::Environment.create(:testing, [])
-    @environment.known_resource_types.add @mytype
-
-    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foonode", :environment => @environment))
-    @scope = Puppet::Parser::Scope.new(@compiler)
-
-    @overrides = stub_everything 'overrides'
-    @overrides.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
-  end
-
-  it "should evaluate its query" do
-    query = mock 'query'
-    collection = Puppet::Parser::AST::Collection.new :query => query, :form => :virtual
-    collection.type = 'mytype'
-
-    query.expects(:safeevaluate).with(@scope)
-
-    collection.evaluate(@scope)
-  end
-
-  it "should instantiate a Collector for this type" do
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test"
-    @test_type = Puppet::Resource::Type.new(:definition, "test")
-    @environment.known_resource_types.add @test_type
-
-    Puppet::Parser::Collector.expects(:new).with(@scope, "test", nil, nil, :virtual)
-
-    collection.evaluate(@scope)
-  end
-
-  it "should tell the compiler about this collector" do
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "mytype"
-    Puppet::Parser::Collector.stubs(:new).returns("whatever")
-
-    @compiler.expects(:add_collection).with("whatever")
-
-    collection.evaluate(@scope)
-  end
-
-  it "should evaluate overriden paramaters" do
-    collector = stub_everything 'collector'
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "mytype", :override => @overrides
-    Puppet::Parser::Collector.stubs(:new).returns(collector)
-
-    @overrides.expects(:safeevaluate).with(@scope)
-
-    collection.evaluate(@scope)
-  end
-
-  it "should tell the collector about overrides" do
-    collector = mock 'collector'
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "mytype", :override => @overrides
-    Puppet::Parser::Collector.stubs(:new).returns(collector)
-
-    collector.expects(:add_override)
-
-    collection.evaluate(@scope)
-  end
-
-  it "should fail when evaluating undefined resource types" do
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "bogus"
-    lambda { collection.evaluate(@scope) }.should raise_error "Resource type bogus doesn't exist"
-  end
-end

data/spec/unit/parser/ast/collexpr_spec.rb

@@ -1,120 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::CollExpr do
-
-  ast = Puppet::Parser::AST
-
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  describe "when evaluating with two operands" do
-    before :each do
-      @test1 = mock 'test1'
-      @test1.expects(:safeevaluate).with(@scope).returns("test1")
-      @test2 = mock 'test2'
-      @test2.expects(:safeevaluate).with(@scope).returns("test2")
-    end
-
-    it "should evaluate both" do
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "==")
-      collexpr.evaluate(@scope)
-    end
-
-    it "should produce a data and code representation of the expression" do
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "==")
-      result = collexpr.evaluate(@scope)
-      result[0].should == ["test1", "==", "test2"]
-      result[1].should be_an_instance_of(Proc)
-    end
-
-    it "should propagate expression type and form to child if expression themselves" do
-      [@test1, @test2].each do |t|
-        t.expects(:is_a?).returns(true)
-        t.expects(:form).returns(false)
-        t.expects(:type).returns(false)
-        t.expects(:type=)
-        t.expects(:form=)
-      end
-
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==", :form => true, :type => true)
-      result = collexpr.evaluate(@scope)
-    end
-
-    describe "and when evaluating the produced code" do
-      before :each do
-        @resource = mock 'resource'
-        @resource.expects(:[]).with("test1").at_least(1).returns("test2")
-      end
-
-      it "should evaluate like the original expression for ==" do
-        collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "==")
-        collexpr.evaluate(@scope)[1].call(@resource).should === (@resource["test1"] == "test2")
-      end
-
-      it "should evaluate like the original expression for !=" do
-        collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "!=")
-        collexpr.evaluate(@scope)[1].call(@resource).should === (@resource["test1"] != "test2")
-      end
-    end
-
-    it "should work if this is an exported collection containing parenthesis" do
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2,
-                                   :oper => "==", :parens => true, :form => :exported)
-      match, code = collexpr.evaluate(@scope)
-      match.should == ["test1", "==", "test2"]
-      @logs.should be_empty     # no warnings emitted
-    end
-
-    %w{and or}.each do |op|
-      it "should parse / eval if this is an exported collection with #{op} operator" do
-        collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2,
-                                     :oper => op, :form => :exported)
-        match, code = collexpr.evaluate(@scope)
-        match.should == ["test1", op, "test2"]
-      end
-    end
-  end
-
-  describe "when evaluating with tags" do
-    before :each do
-      @tag = stub 'tag', :safeevaluate => 'tag'
-      @value = stub 'value', :safeevaluate => 'value'
-
-      @resource = stub 'resource'
-      @resource.stubs(:tagged?).with("value").returns(true)
-    end
-
-    it "should produce a data representation of the expression" do
-      collexpr = ast::CollExpr.new(:test1 => @tag, :test2 => @value, :oper=>"==")
-      result = collexpr.evaluate(@scope)
-      result[0].should == ["tag", "==", "value"]
-    end
-
-    it "should inspect resource tags if the query term is on tags" do
-      collexpr = ast::CollExpr.new(:test1 => @tag, :test2 => @value, :oper => "==")
-      collexpr.evaluate(@scope)[1].call(@resource).should be_true
-    end
-  end
-
-  [:exported,:virtual].each do |mode|
-  it "should check for array member equality if resource parameter is an array for == in mode #{mode}" do
-    array = mock 'array', :safeevaluate => "array"
-    test1 = mock 'test1'
-    test1.expects(:safeevaluate).with(@scope).returns("test1")
-
-    resource = mock 'resource'
-    resource.expects(:[]).with("array").at_least(1).returns(["test1","test2","test3"])
-    collexpr = ast::CollExpr.new(:test1 => array, :test2 => test1, :oper => "==", :form => mode)
-    collexpr.evaluate(@scope)[1].call(resource).should be_true
-  end
-  end
-
-  it "should raise an error for invalid operator" do
-    lambda { collexpr = ast::CollExpr.new(:oper=>">") }.should raise_error
-  end
-
-end

data/spec/unit/parser/ast/comparison_operator_spec.rb

@@ -1,118 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::ComparisonOperator do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-
-    @one = Puppet::Parser::AST::Leaf.new(:value => "1")
-    @two = Puppet::Parser::AST::Leaf.new(:value => "2")
-
-    @lval = Puppet::Parser::AST::Leaf.new(:value => "one")
-    @rval = Puppet::Parser::AST::Leaf.new(:value => "two")
-  end
-
-  it "should evaluate both values" do
-    @lval.expects(:safeevaluate).with(@scope)
-    @rval.expects(:safeevaluate).with(@scope)
-
-    operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
-    operator.evaluate(@scope)
-  end
-
-  it "should convert the arguments to numbers if they are numbers in string" do
-    Puppet::Parser::Scope.expects(:number?).with("1").returns(1)
-    Puppet::Parser::Scope.expects(:number?).with("2").returns(2)
-
-    operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "==", :rval => @two
-    operator.evaluate(@scope)
-  end
-
-  %w{< > <= >=}.each do |oper|
-    it "should use string comparison #{oper} if operands are strings" do
-      operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => oper, :rval => @rval
-      operator.evaluate(@scope).should == "one".send(oper,"two")
-    end
-  end
-
-  describe "with string comparison" do
-    it "should use matching" do
-      @rval.expects(:evaluate_match).with("one", @scope)
-
-      operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
-      operator.evaluate(@scope)
-    end
-
-    it "should return true for :undef to '' equality" do
-      astundef = Puppet::Parser::AST::Leaf.new(:value => :undef)
-      empty = Puppet::Parser::AST::Leaf.new(:value => '')
-
-      operator = Puppet::Parser::AST::ComparisonOperator.new :lval => astundef, :operator => "==", :rval => empty
-      operator.evaluate(@scope).should be_true
-    end
-
-    [true, false].each do |result|
-      it "should return #{(result).inspect} with '==' when matching return #{result.inspect}" do
-        @rval.expects(:evaluate_match).with("one", @scope).returns result
-
-        operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
-        operator.evaluate(@scope).should == result
-      end
-
-      it "should return #{(!result).inspect} with '!=' when matching return #{result.inspect}" do
-        @rval.expects(:evaluate_match).with("one", @scope).returns result
-
-        operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "!=", :rval => @rval
-        operator.evaluate(@scope).should == !result
-      end
-    end
-  end
-
-  it "should fail with arguments of different types" do
-    operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => ">", :rval => @rval
-    lambda { operator.evaluate(@scope) }.should raise_error(ArgumentError)
-  end
-
-  it "should fail for an unknown operator" do
-    lambda { operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "or", :rval => @two }.should raise_error
-  end
-
-  %w{< > <= >= ==}.each do |oper|
-    it "should return the result of using '#{oper}' to compare the left and right sides" do
-      operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => oper, :rval => @two
-
-      operator.evaluate(@scope).should == 1.send(oper,2)
-    end
-  end
-
-  it "should return the result of using '!=' to compare the left and right sides" do
-    operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => '!=', :rval => @two
-
-    operator.evaluate(@scope).should == true
-  end
-
-  it "should work for variables too" do
-    one = Puppet::Parser::AST::Variable.new( :value => "one" )
-    two = Puppet::Parser::AST::Variable.new( :value => "two" )
-
-    one.expects(:safeevaluate).with(@scope).returns(1)
-    two.expects(:safeevaluate).with(@scope).returns(2)
-
-    operator = Puppet::Parser::AST::ComparisonOperator.new :lval => one, :operator => "<", :rval => two
-    operator.evaluate(@scope).should == true
-  end
-
-  # see ticket #1759
-  %w{< > <= >=}.each do |oper|
-    it "should return the correct result of using '#{oper}' to compare 10 and 9" do
-      ten = Puppet::Parser::AST::Leaf.new(:value => "10")
-      nine = Puppet::Parser::AST::Leaf.new(:value => "9")
-      operator = Puppet::Parser::AST::ComparisonOperator.new :lval => ten, :operator => oper, :rval => nine
-
-      operator.evaluate(@scope).should == 10.send(oper,9)
-    end
-  end
-
-end