puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/network/authentication_spec.rb

@@ -1,104 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-load 'puppet/network/authentication.rb'
-
-class AuthenticationTest
-  include Puppet::Network::Authentication
-end
-
-describe Puppet::Network::Authentication do
-  subject     { AuthenticationTest.new }
-  let(:now)   { Time.now }
-  let(:cert)  { Puppet::SSL::Certificate.new('cert') }
-  let(:host)  { stub 'host', :certificate => cert }
-
-  # this is necessary since the logger is a class variable, and it needs to be stubbed
-  def reload_module
-    load 'puppet/network/authentication.rb'
-  end
-
-  describe "when warning about upcoming expirations" do
-    before do
-      Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-      Puppet::FileSystem.stubs(:exist?).returns(false)
-    end
-
-    it "should check the expiration of the CA certificate" do
-      ca = stub 'ca', :host => host
-      Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
-      Puppet::SSL::CertificateAuthority.stubs(:instance).returns(ca)
-      cert.expects(:near_expiration?).returns(false)
-      subject.warn_if_near_expiration
-    end
-
-    context "when examining the local host" do
-      before do
-        Puppet::SSL::Host.stubs(:localhost).returns(host)
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:hostcert]).returns(true)
-      end
-
-      it "should not load the localhost certificate if the local CA certificate is missing" do
-        # Redmine-21869: Infinite recursion occurs if CA cert is missing.
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:localcacert]).returns(false)
-        host.unstub(:certificate)
-        host.expects(:certificate).never
-        subject.warn_if_near_expiration
-      end
-
-      it "should check the expiration of the localhost certificate if the local CA certificate is present" do
-        Puppet::FileSystem.stubs(:exist?).with(Puppet[:localcacert]).returns(true)
-        cert.expects(:near_expiration?).returns(false)
-        subject.warn_if_near_expiration
-      end
-    end
-
-    it "should check the expiration of any certificates passed in as arguments" do
-      cert.expects(:near_expiration?).twice.returns(false)
-      subject.warn_if_near_expiration(cert, cert)
-    end
-
-    it "should accept instances of OpenSSL::X509::Certificate" do
-      raw_cert = stub 'cert'
-      raw_cert.stubs(:is_a?).with(OpenSSL::X509::Certificate).returns(true)
-      Puppet::SSL::Certificate.stubs(:from_instance).with(raw_cert).returns(cert)
-      cert.expects(:near_expiration?).returns(false)
-      subject.warn_if_near_expiration(raw_cert)
-    end
-
-    it "should use a rate-limited logger for expiration warnings that uses `runinterval` as its interval" do
-      Puppet::Util::Log::RateLimitedLogger.expects(:new).with(Puppet[:runinterval])
-      reload_module
-    end
-
-    context "in the logs" do
-      let(:logger) { stub 'logger' }
-
-      before do
-        Puppet::Util::Log::RateLimitedLogger.stubs(:new).returns(logger)
-        reload_module
-        cert.stubs(:near_expiration?).returns(true)
-        cert.stubs(:expiration).returns(now)
-        cert.stubs(:unmunged_name).returns('foo')
-      end
-
-      after(:all) do
-        reload_module
-      end
-
-      it "should log a warning if a certificate's expiration is near" do
-        logger.expects(:warning)
-        subject.warn_if_near_expiration(cert)
-      end
-
-      it "should use the certificate's unmunged name in the message" do
-        logger.expects(:warning).with { |message| message.include? 'foo' }
-        subject.warn_if_near_expiration(cert)
-      end
-
-      it "should show certificate's expiration date in the message using ISO 8601 format" do
-        logger.expects(:warning).with { |message| message.include? now.strftime('%Y-%m-%dT%H:%M:%S%Z') }
-        subject.warn_if_near_expiration(cert)
-      end
-    end
-  end
-end

data/spec/unit/network/http/api/v2_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP::API::V2 do
-  it "responds to unknown paths with a 404" do
-    response = Puppet::Network::HTTP::MemoryResponse.new
-    request = Puppet::Network::HTTP::Request.from_hash(:path => "/v2.0/unknown")
-
-    expect do
-      Puppet::Network::HTTP::API::V2.routes.process(request, response)
-    end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
-  end
-end

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

@@ -1,160 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::ArithmeticOperator 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)
-    @one = stub 'lval', :safeevaluate => 1
-    @two = stub 'rval', :safeevaluate => 2
-  end
-
-  it "should evaluate both branches" do
-    lval = stub "lval"
-    lval.expects(:safeevaluate).with(@scope).returns(1)
-    rval = stub "rval"
-    rval.expects(:safeevaluate).with(@scope).returns(2)
-
-    operator = ast::ArithmeticOperator.new :rval => rval, :operator => "+", :lval => lval
-    operator.evaluate(@scope)
-  end
-
-  it "should fail for an unknown operator" do
-    lambda { operator = ast::ArithmeticOperator.new :lval => @one, :operator => "^", :rval => @two }.should raise_error
-  end
-
-  it "should call Puppet::Parser::Scope.number?" do
-    Puppet::Parser::Scope.expects(:number?).with(1).returns(1)
-    Puppet::Parser::Scope.expects(:number?).with(2).returns(2)
-
-    ast::ArithmeticOperator.new(:lval => @one, :operator => "+", :rval => @two).evaluate(@scope)
-  end
-
-
-  %w{ + - * / % << >>}.each do |op|
-    it "should call ruby Numeric '#{op}'" do
-      one = stub 'one'
-      two = stub 'two'
-      operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
-      Puppet::Parser::Scope.stubs(:number?).with(1).returns(one)
-      Puppet::Parser::Scope.stubs(:number?).with(2).returns(two)
-      one.expects(:send).with(op,two)
-      operator.evaluate(@scope)
-    end
-  end
-
-  it "should work even with numbers embedded in strings" do
-    two = stub 'two', :safeevaluate => "2"
-    one = stub 'one', :safeevaluate => "1"
-    operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
-    operator.evaluate(@scope).should == 3
-  end
-
-  it "should work even with floats" do
-    two = stub 'two', :safeevaluate => 2.53
-    one = stub 'one', :safeevaluate => 1.80
-    operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
-    operator.evaluate(@scope).should == 4.33
-  end
-
-  context "when applied to array" do
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-
-    it "+ should concatenate an array" do
-      one = stub 'one', :safeevaluate => [1,2,3]
-      two = stub 'two', :safeevaluate => [4,5]
-      operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-      operator.evaluate(@scope).should == [1,2,3,4,5]
-    end
-
-    it "<< should append array to an array" do
-      one = stub 'one', :safeevaluate => [1,2,3]
-      two = stub 'two', :safeevaluate => [4,5]
-      operator = ast::ArithmeticOperator.new :lval => one, :operator => "<<", :rval => two
-      operator.evaluate(@scope).should == [1,2,3, [4,5]]
-    end
-
-    it "<< should append object to an array" do
-      one = stub 'one', :safeevaluate => [1,2,3]
-      two = stub 'two', :safeevaluate => 'a b c'
-      operator = ast::ArithmeticOperator.new :lval => one, :operator => "<<", :rval => two
-      operator.evaluate(@scope).should == [1,2,3, 'a b c']
-    end
-
-    context "and input is invalid" do
-      it "should raise error for + if left is not an array" do
-        one = stub 'one', :safeevaluate => 4
-        two = stub 'two', :safeevaluate => [4,5]
-        operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-        lambda { operator.evaluate(@scope).should == [1,2,3,4,5] }.should raise_error(/left/)
-      end
-
-      it "should raise error for << if left is not an array" do
-        one = stub 'one', :safeevaluate => 4
-        two = stub 'two', :safeevaluate => [4,5]
-        operator = ast::ArithmeticOperator.new :lval => one, :operator => "<<", :rval => two
-        lambda { operator.evaluate(@scope).should == [1,2,3,4,5] }.should raise_error(/left/)
-      end
-
-      it "should raise error for + if right is not an array" do
-        one = stub 'one', :safeevaluate => [1,2]
-        two = stub 'two', :safeevaluate => 45
-        operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-        lambda { operator.evaluate(@scope).should == [1,2,3,4,5] }.should raise_error(/right/)
-      end
-
-      %w{ - * / % >>}.each do |op|
-        it "should raise error for '#{op}'" do
-          one = stub 'one', :safeevaluate => [1,2,3]
-          two = stub 'two', :safeevaluate => [4,5]
-          operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
-          lambda { operator.evaluate(@scope).should == [1,2,3,4,5] }.should raise_error
-        end
-      end
-    end
-
-    context "when applied to hash" do
-      before :each do
-        Puppet[:parser] = 'future'
-      end
-
-      it "+ should merge two hashes" do
-        one = stub 'one', :safeevaluate => {'a' => 1, 'b' => 2}
-        two = stub 'two', :safeevaluate => {'c' => 3 }
-        operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-        operator.evaluate(@scope).should == {'a' => 1, 'b' => 2, 'c' => 3}
-      end
-
-      context "and input is invalid" do
-        it "should raise error for + if left is not a hash" do
-          one = stub 'one', :safeevaluate => 4
-          two = stub 'two', :safeevaluate => {'a' => 1}
-          operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-          lambda { operator.evaluate(@scope).should == [1,2,3,4,5] }.should raise_error(/left/)
-        end
-
-        it "should raise error for + if right is not a hash" do
-          one = stub 'one', :safeevaluate => {'a' => 1}
-          two = stub 'two', :safeevaluate => 1
-          operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-          lambda { operator.evaluate(@scope).should == {'a'=>1, 1=>nil} }.should raise_error(/right/)
-        end
-
-        %w{ - * / % << >>}.each do |op|
-          it "should raise error for '#{op}'" do
-            one = stub 'one', :safeevaluate => {'a' => 1, 'b' => 2}
-            two = stub 'two', :safeevaluate => {'c' => 3 }
-            operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
-            lambda { operator.evaluate(@scope).should == [1,2,3,4,5] }.should raise_error
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::ASTArray do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it "should have a [] accessor" do
-    array = Puppet::Parser::AST::ASTArray.new :children => []
-    array.should respond_to(:[])
-  end
-
-  it "should evaluate all its children" do
-    item1 = stub "item1", :is_a? => true
-    item2 = stub "item2", :is_a? => true
-
-    item1.expects(:safeevaluate).with(@scope).returns(123)
-    item2.expects(:safeevaluate).with(@scope).returns(246)
-
-    operator = Puppet::Parser::AST::ASTArray.new :children => [item1,item2]
-    operator.evaluate(@scope)
-  end
-
-  it "should not flatten children coming from children ASTArray" do
-    item = Puppet::Parser::AST::String.new :value => 'foo'
-    inner_array = Puppet::Parser::AST::ASTArray.new :children => [item, item]
-    operator = Puppet::Parser::AST::ASTArray.new :children => [inner_array, inner_array]
-    operator.evaluate(@scope).should == [['foo', 'foo'], ['foo', 'foo']]
-  end
-
-  it "should not flatten the results of children evaluation" do
-    item = Puppet::Parser::AST::String.new :value => 'foo'
-    item.stubs(:evaluate).returns(['foo'])
-    operator = Puppet::Parser::AST::ASTArray.new :children => [item, item]
-    operator.evaluate(@scope).should == [['foo'], ['foo']]
-  end
-
-  it "should discard nil results from children evaluation" do
-    item1 = Puppet::Parser::AST::String.new :value => 'foo'
-    item2 = Puppet::Parser::AST::String.new :value => 'foo'
-    item2.stubs(:evaluate).returns(nil)
-    operator = Puppet::Parser::AST::ASTArray.new :children => [item1, item2]
-    operator.evaluate(@scope).should == ['foo']
-  end
-
-  it "should return a valid string with to_s" do
-    a = stub 'a', :is_a? => true, :to_s => "a"
-    b = stub 'b', :is_a? => true, :to_s => "b"
-    array = Puppet::Parser::AST::ASTArray.new :children => [a,b]
-
-    array.to_s.should == "[a, b]"
-  end
-end

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

@@ -1,98 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::ASTHash do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  it "should have a merge functionality" do
-    hash = Puppet::Parser::AST::ASTHash.new(:value => {})
-    hash.should respond_to(:merge)
-  end
-
-  it "should be able to merge 2 AST hashes" do
-    hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b" })
-
-    hash.merge(Puppet::Parser::AST::ASTHash.new(:value => {"c" => "d"}))
-
-    hash.value.should == { "a" => "b", "c" => "d" }
-  end
-
-  it "should be able to merge with a ruby Hash" do
-    hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b" })
-
-    hash.merge({"c" => "d"})
-
-    hash.value.should == { "a" => "b", "c" => "d" }
-  end
-
-  it "should evaluate each hash value" do
-    key1 = stub "key1"
-    value1 = stub "value1"
-    key2 = stub "key2"
-    value2 = stub "value2"
-
-    value1.expects(:safeevaluate).with(@scope).returns("b")
-    value2.expects(:safeevaluate).with(@scope).returns("d")
-
-    operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
-    operator.evaluate(@scope)
-  end
-
-  it "should evaluate the hash keys if they are AST instances" do
-    key1 = stub "key1"
-    value1 = stub "value1", :safeevaluate => "one"
-    key2 = stub "key2"
-    value2 = stub "value2", :safeevaluate => "two"
-
-    key1.expects(:safeevaluate).with(@scope).returns("1")
-    key2.expects(:safeevaluate).with(@scope).returns("2")
-
-    operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
-    hash = operator.evaluate(@scope)
-    hash["1"].should == "one"
-    hash["2"].should == "two"
-  end
-
-  it "should evaluate the hash keys if they are not AST instances" do
-    key1 = "1"
-    value1 = stub "value1", :safeevaluate => "one"
-    key2 = "2"
-    value2 = stub "value2", :safeevaluate => "two"
-
-    operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
-    hash = operator.evaluate(@scope)
-    hash["1"].should == "one"
-    hash["2"].should == "two"
-  end
-
-  it "should return an evaluated hash" do
-    key1 = stub "key1"
-    value1 = stub "value1", :safeevaluate => "b"
-    key2 = stub "key2"
-    value2 = stub "value2", :safeevaluate => "d"
-
-    operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
-    operator.evaluate(@scope).should == { key1 => "b", key2 => "d" }
-  end
-
-  describe "when being initialized without arguments" do
-    it "should evaluate to an empty hash" do
-      hash = Puppet::Parser::AST::ASTHash.new({})
-      hash.evaluate(@scope).should == {}
-    end
-
-    it "should support merging" do
-      hash = Puppet::Parser::AST::ASTHash.new({})
-      hash.merge({"a" => "b"}).should == {"a" => "b"}
-    end
-  end
-
-  it "should return a valid string with to_s" do
-    hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b", "c" => "d" })
-    ["{a => b, c => d}", "{c => d, a => b}"].should be_include hash.to_s
-  end
-end

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

@@ -1,54 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe Puppet::Parser::AST::BooleanOperator 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)
-    @true_ast = ast::Boolean.new( :value => true)
-    @false_ast = ast::Boolean.new( :value => false)
-  end
-
-  it "should evaluate left operand inconditionally" do
-    lval = stub "lval"
-    lval.expects(:safeevaluate).with(@scope).returns("true")
-    rval = stub "rval", :safeevaluate => false
-    rval.expects(:safeevaluate).never
-
-    operator = ast::BooleanOperator.new :rval => rval, :operator => "or", :lval => lval
-    operator.evaluate(@scope)
-  end
-
-  it "should evaluate right 'and' operand only if left operand is true" do
-    lval = stub "lval", :safeevaluate => true
-    rval = stub "rval", :safeevaluate => false
-    rval.expects(:safeevaluate).with(@scope).returns(false)
-    operator = ast::BooleanOperator.new :rval => rval, :operator => "and", :lval => lval
-    operator.evaluate(@scope)
-  end
-
-  it "should evaluate right 'or' operand only if left operand is false" do
-    lval = stub "lval", :safeevaluate => false
-    rval = stub "rval", :safeevaluate => false
-    rval.expects(:safeevaluate).with(@scope).returns(false)
-    operator = ast::BooleanOperator.new :rval => rval, :operator => "or", :lval => lval
-    operator.evaluate(@scope)
-  end
-
-  it "should return true for false OR true" do
-    ast::BooleanOperator.new(:rval => @true_ast, :operator => "or", :lval => @false_ast).evaluate(@scope).should be_true
-  end
-
-  it "should return false for true AND false" do
-    ast::BooleanOperator.new(:rval => @true_ast, :operator => "and", :lval => @false_ast ).evaluate(@scope).should be_false
-  end
-
-  it "should return true for true AND true" do
-    ast::BooleanOperator.new(:rval => @true_ast, :operator => "and", :lval => @true_ast ).evaluate(@scope).should be_true
-  end
-
-end