puppet 3.7.3 → 3.7.4

data/spec/unit/functions/scanf_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the scanf function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  it 'scans a value and returns an array' do
+    expect(compile_to_catalog("$x = '42'.scanf('%i')[0] + 1; notify { \"test$x\": }")).to have_resource('Notify[test43]')
+  end
+
+  it 'scans a value and returns result of a code block' do
+    expect(compile_to_catalog("$x = '42'.scanf('%i')|$x|{$x[0]} + 1; notify { \"test$x\": }")).to have_resource('Notify[test43]')
+  end
+
+  it 'returns empty array if nothing was scanned' do
+    expect(compile_to_catalog("$x = 'no'.scanf('%i')[0]; notify { \"test${x}test\": }")).to have_resource('Notify[testtest]')
+  end
+
+  it 'produces result up to first unsuccessful scan' do
+    expect(compile_to_catalog("$x = '42 no'.scanf('%i'); notify { \"test${x[0]}${x[1]}test\": }")).to have_resource('Notify[test42test]')
+  end
+
+
+  it 'errors when not given enough arguments' do
+    expect do
+      compile_to_catalog("'42'.scanf()")
+    end.to raise_error(/.*expected.*scanf\(String data, String format, Callable block \{0,1\}\)/m)
+  end
+end

data/spec/unit/network/http/rack/rest_spec.rb

@@ -25,14 +25,17 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
     end
 
     let(:minimal_certificate) do
-        cert = OpenSSL::X509::Certificate.new
-        cert.version = 2
-        cert.serial = 0
-        cert.not_before = Time.now
-        cert.not_after = Time.now + 3600
-        cert.public_key = OpenSSL::PKey::RSA.new(512)
-        cert.subject = OpenSSL::X509::Name.parse("/CN=testing")
-        cert
+      key = OpenSSL::PKey::RSA.new(512)
+      signer = Puppet::SSL::CertificateSigner.new
+      cert = OpenSSL::X509::Certificate.new
+      cert.version = 2
+      cert.serial = 0
+      cert.not_before = Time.now
+      cert.not_after = Time.now + 3600
+      cert.public_key = key
+      cert.subject = OpenSSL::X509::Name.parse("/CN=testing")
+      signer.sign(cert, key)
+      cert
     end
 
     describe "#headers" do

data/spec/unit/network/http/webrick/rest_spec.rb

@@ -62,6 +62,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
       it "should set the status and body on the response when setting the response for a successful query" do
         @response.expects(:status=).with 200
         @response.expects(:body=).with "mybody"
+        @response.expects(:[]=).with('connection', 'close') if RUBY_VERSION[0,3] == '1.8'
 
         @handler.set_response(@response, "mybody", 200)
       end
@@ -74,6 +75,7 @@ describe Puppet::Network::HTTP::WEBrickREST do
         @response.expects(:[]=).with('content-length', 100)
         @response.expects(:status=).with 200
         @response.expects(:body=).with @file
+        @response.expects(:[]=).with('connection', 'close') if RUBY_VERSION[0,3] == '1.8'
 
         @handler.set_response(@response, @file, 200)
       end
@@ -81,9 +83,26 @@ describe Puppet::Network::HTTP::WEBrickREST do
       it "should set the status and message on the response when setting the response for a failed query" do
         @response.expects(:status=).with 400
         @response.expects(:body=).with "mybody"
+        @response.expects(:[]=).with('connection', 'close') if RUBY_VERSION[0,3] == '1.8'
 
         @handler.set_response(@response, "mybody", 400)
       end
+
+      it "omits the 'Connection: close' header on ruby 1.9 and up", :if => RUBY_VERSION[0,3] != '1.8' do
+        @response.expects(:status=).with 200
+        @response.expects(:body=).with "mybody"
+        @response.expects(:[]=).with('connection', 'close').never
+
+        @handler.set_response(@response, "mybody", 200)
+      end
+
+      it "closes the connection on ruby 1.8", :if => RUBY_VERSION[0,3] == '1.8' do
+        @response.expects(:status=).with 200
+        @response.expects(:body=).with "mybody"
+        @response.expects(:[]=).with('connection', 'close')
+
+        @handler.set_response(@response, "mybody", 200)
+      end
     end
 
     describe "and determining the request parameters" do

data/spec/unit/parser/compiler_spec.rb

@@ -78,17 +78,6 @@ describe Puppet::Parser::Compiler do
     @scope.resource = @scope_resource
   end
 
-  it "should have a class method that compiles, converts, and returns a catalog" do
-    compiler = stub 'compiler'
-    Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
-    catalog = stub 'catalog'
-    compiler.expects(:compile).returns catalog
-    converted_catalog = stub 'converted_catalog'
-    catalog.expects(:to_resource).returns converted_catalog
-
-    Puppet::Parser::Compiler.compile(@node).should equal(converted_catalog)
-  end
-
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
     lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
@@ -117,22 +106,6 @@ describe Puppet::Parser::Compiler do
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
-  it "should clear the global caches before compile" do
-    compiler = stub 'compiler'
-    Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
-    catalog = stub 'catalog'
-    compiler.expects(:compile).returns catalog
-    catalog.expects(:to_resource)
-
-    $known_resource_types = "rspec"
-    $env_module_directories = "rspec"
-
-    Puppet::Parser::Compiler.compile(@node)
-
-    $known_resource_types = nil
-    $env_module_directories = nil
-  end
-
   describe "when initializing" do
 
     it "should set its node attribute" do

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -166,23 +166,23 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Hash Type
     #
-    it 'produces a Hash[Scalar,String] from the expression Hash[String]' do
-      expr = fqr('Hash')[fqr('String')]
+    it 'produces a Hash[Scalar,String] from the expression Hash[Scalar, String]' do
+      expr = fqr('Hash')[fqr('Scalar'), fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
 
       # arguments are flattened
-      expr = fqr('Hash')[[fqr('String')]]
+      expr = fqr('Hash')[[fqr('Scalar'), fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
     end
 
-    it 'produces a Hash[String,String] from the expression Hash[String, String]' do
-      expr = fqr('Hash')[fqr('String'), fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.string))
+    it 'gives an error if only one type is specified ' do
+      expr = fqr('Hash')[fqr('String')]
+      expect {evaluate(expr)}.to raise_error(/accepts 2 to 4 arguments/)
     end
 
-    it 'produces a Hash[Scalar,String] from the expression Hash[Integer][String]' do
-      expr = fqr('Hash')[fqr('Integer')][fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
+    it 'produces a Hash[Scalar,String] from the expression Hash[Integer, Array][Integer, String]' do
+      expr = fqr('Hash')[fqr('Integer'), fqr('Array')][fqr('Integer'), fqr('String')]
+      expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.integer))
     end
 
     it "gives an error if parameter is not a type" do

data/spec/unit/pops/evaluator/comparison_ops_spec.rb

@@ -71,17 +71,23 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     context "of mixed value types" do
       it "1 == 1.0  == true"   do; evaluate(literal(1)     == literal(1.0)).should == true   ; end
       it "1 < 1.1   == true"   do; evaluate(literal(1)     <  literal(1.1)).should == true   ; end
-      it "'1' < 1.1 == true"   do; evaluate(literal('1')   <  literal(1.1)).should == true   ; end
       it "1.0 == 1  == true"   do; evaluate(literal(1.0)   == literal(1)).should == true     ; end
       it "1.0 < 2   == true"   do; evaluate(literal(1.0)   <  literal(2)).should == true     ; end
-      it "'1.0' < 1.1 == true" do; evaluate(literal('1.0') <  literal(1.1)).should == true   ; end
-
       it "'1.0' < 'a' == true" do; evaluate(literal('1.0') <  literal('a')).should == true   ; end
-      it "'1.0' < ''  == true" do; evaluate(literal('1.0') <  literal('')).should == true    ; end
-      it "'1.0' < ' ' == true" do; evaluate(literal('1.0') <  literal(' ')).should == true   ; end
+      it "'1.0' < ''  == true" do; evaluate(literal('1.0') <  literal('')).should == false   ; end
+      it "'1.0' < ' ' == true" do; evaluate(literal('1.0') <  literal(' ')).should == false   ; end
       it "'a' > '1.0' == true" do; evaluate(literal('a')   >  literal('1.0')).should == true ; end
     end
 
+    context "of unsupported mixed value types" do
+      it "'1' < 1.1 == true"   do
+        expect{ evaluate(literal('1') <  literal(1.1))}.to raise_error(/String < Float/)
+      end
+      it "'1.0' < 1.1 == true" do
+        expect{evaluate(literal('1.0') <  literal(1.1))}.to raise_error(/String < Float/)
+      end
+    end
+
     context "of regular expressions" do
       it "/.*/ == /.*/  == true"   do; evaluate(literal(/.*/) == literal(/.*/)).should == true   ; end
       it "/.*/ != /a.*/ == true"   do; evaluate(literal(/.*/).ne(literal(/a.*/))).should == true ; end
@@ -235,9 +241,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       evaluate(literal(15).in(literal([1,0xf,2]))).should == true
     end
 
-    it "should find numbers as strings" do
-      evaluate(literal(15).in(literal([1, '0xf',2]))).should == true
-      evaluate(literal('15').in(literal([1, 0xf,2]))).should == true
+    it "should not find numbers as strings" do
+      evaluate(literal(15).in(literal([1, '0xf',2]))).should == false
+      evaluate(literal('15').in(literal([1, 0xf,2]))).should == false
     end
 
     it "should not find numbers embedded in strings, nor digits in numbers" do

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -190,14 +190,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "2 >= 1"         => true,
       "1 == 1.0 "      => true,
       "1 < 1.1  "      => true,
-      "'1' < 1.1"      => true,
       "1.0 == 1 "      => true,
       "1.0 < 2  "      => true,
-      "1.0 < 'a'"      => true,
-      "'1.0' < 1.1"    => true,
       "'1.0' < 'a'"    => true,
-      "'1.0' < '' "    => true,
-      "'1.0' < ' '"    => true,
+      "'1.0' < '' "    => false,
+      "'1.0' < ' '"    => false,
       "'a' > '1.0'"    => true,
       "/.*/ == /.*/ "  => true,
       "/.*/ != /a.*/"  => true,
@@ -210,6 +207,21 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         end
       end
 
+   {
+     "a > 1" => /String > Integer/,
+     "a >= 1" => /String >= Integer/,
+     "a < 1" => /String < Integer/,
+     "a <= 1" => /String <= Integer/,
+     "1 > a" => /Integer > String/,
+     "1 >= a" => /Integer >= String/,
+     "1 < a" => /Integer < String/,
+     "1 <= a" => /Integer <= String/,
+   }.each do | source, error|
+     it "should not allow comparison of String and Number '#{source}'" do
+       expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error)
+     end
+   end
+
    {
       "'a' =~ /.*/"                     => true,
       "'a' =~ '.*'"                     => true,
@@ -271,8 +283,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "/xxx/ in {'aaaxxxbbb'=>1}"     => true,
       "/yyy/ in {'aaaxxxbbb'=>1}"     => false,
       "15 in [1, 0xf]"                => true,
-      "15 in [1, '0xf']"              => true,
-      "'15' in [1, 0xf]"              => true,
+      "15 in [1, '0xf']"              => false,
+      "'15' in [1, 0xf]"              => false,
       "15 in [1, 115]"                => false,
       "1 in [11, '111']"              => false,
       "'1' in [11, '111']"            => false,
@@ -676,7 +688,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "Hash[Integer, 0]"            => 'Hash-Type[] arguments must be types. Got Fixnum',
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
-      "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 1 to 4 arguments. Got 5',
+      "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",

data/spec/unit/pops/parser/parse_basic_expressions_spec.rb

@@ -163,6 +163,11 @@ describe "egrammar parsing basic expressions" do
     it "$a [1,2,3] == [1,2,3]" do
       dump(parse("$a = [1,2,3] == [1,2,3]")).should == "(= $a (== ([] 1 2 3) ([] 1 2 3)))"
     end
+
+    it "calculates the text length of an empty array" do
+      expect(parse("[]").current.body.length).to eq(2)
+      expect(parse("[ ]").current.body.length).to eq(3)
+    end
   end
 
   context "When parsing indexed access" do
@@ -221,6 +226,11 @@ describe "egrammar parsing basic expressions" do
     it "$a = {'a'=> 1, 'b'=>2} != {'x'=> 1, 'y'=>3}" do
       dump(parse("$a = {'a'=>1,'b'=>2} != {'a'=>1,'b'=>2}")).should == "(= $a (!= ({} ('a' 1) ('b' 2)) ({} ('a' 1) ('b' 2))))"
     end
+
+    it "calculates the text length of an empty hash" do
+      expect(parse("{}").current.body.length).to eq(2)
+      expect(parse("{ }").current.body.length).to eq(3)
+    end
   end
 
   context "When parsing the 'in' operator" do

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -71,6 +71,36 @@ describe "egrammar parsing heredoc" do
     ].join("\n")
   end
 
+  it "parses with escaped newlines without preceding whitespace" do
+    src = <<-CODE
+    @(END/L)
+    First Line\\
+     Second Line
+    |- END
+    CODE
+    parse(src)
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated 'First Line Second Line')",
+      ")"
+    ].join("\n")
+  end
+
+  it "parses with escaped newlines with proper margin" do
+    src = <<-CODE
+    @(END/L)
+     First Line\\
+      Second Line
+    |- END
+    CODE
+    parse(src)
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated ' First Line  Second Line')",
+      ")"
+    ].join("\n")
+  end
+
   it "parses interpolated heredoc expression with false start on $" do
     src = <<-CODE
     @("END")

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -568,6 +568,24 @@ describe 'The type calculator' do
       end
     end
 
+    context 'for Variant, such that' do
+      it 'it is assignable to a type if all contained types are assignable to that type' do
+        v = variant_t(range_t(10, 12),range_t(14, 20))
+        v.should be_assignable_to(integer_t)
+        v.should be_assignable_to(range_t(10, 20))
+
+        # test that both types are assignable to one of the variants OK
+        v.should be_assignable_to(variant_t(range_t(10, 20), range_t(30, 40)))
+
+        # test where each type is assignable to different types in a variant is OK
+        v.should be_assignable_to(variant_t(range_t(10, 13), range_t(14, 40)))
+
+        # not acceptable
+        v.should_not be_assignable_to(range_t(0, 4))
+        v.should_not be_assignable_to(string_t)
+      end
+    end
+
     context "for Scalar, such that" do
       it "all scalars are assignable to Scalar" do
         t = Puppet::Pops::Types::PScalarType.new()

data/spec/unit/pops/types/type_parser_spec.rb

@@ -63,7 +63,7 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it "interprets a parameterized Hash[t] as a Hash of Scalar to t" do
-    expect(parser.parse("Hash[Integer]")).to be_the_type(types.hash_of(types.integer))
+    expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
   it "parses a parameterized type into the type object" do
@@ -129,7 +129,7 @@ describe Puppet::Pops::Types::TypeParser do
 
   it "rejects an collection spec with the wrong number of parameters" do
     expect { parser.parse("Array[Integer, 1,2,3]") }.to raise_the_parameter_error("Array", "1 to 3", 4)
-    expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "1 to 4", 5)
+    expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "2 to 4", 5)
   end
 
   it "interprets anything that is not a built in type to be a resource type" do

data/spec/unit/provider/service/redhat_spec.rb

@@ -55,7 +55,8 @@ describe provider_class, :as_platform => :posix do
     end
   end
 
-  it "(#15797) should use 'on' when calling enable" do
+  it "should use '--add' and 'on' when calling enable" do
+    provider_class.expects(:chkconfig).with("--add", @resource[:name])
     provider_class.expects(:chkconfig).with(@resource[:name], :on)
     @provider.enable
   end

data/spec/unit/type/cron_spec.rb

@@ -307,33 +307,33 @@ describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows?
       end
 
       it "should support valid months as words" do
-        expect { described_class.new(:name => 'foo', :month => 'January') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'February') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'March') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'April') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'May') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'June') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'July') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'August') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'September') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'October') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'November') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'December') }.to_not raise_error
+        expect( described_class.new(:name => 'foo', :month => 'January')[:month]   ).to eq(['1'])
+        expect( described_class.new(:name => 'foo', :month => 'February')[:month]  ).to eq(['2'])
+        expect( described_class.new(:name => 'foo', :month => 'March')[:month]     ).to eq(['3'])
+        expect( described_class.new(:name => 'foo', :month => 'April')[:month]     ).to eq(['4'])
+        expect( described_class.new(:name => 'foo', :month => 'May')[:month]       ).to eq(['5'])
+        expect( described_class.new(:name => 'foo', :month => 'June')[:month]      ).to eq(['6'])
+        expect( described_class.new(:name => 'foo', :month => 'July')[:month]      ).to eq(['7'])
+        expect( described_class.new(:name => 'foo', :month => 'August')[:month]    ).to eq(['8'])
+        expect( described_class.new(:name => 'foo', :month => 'September')[:month] ).to eq(['9'])
+        expect( described_class.new(:name => 'foo', :month => 'October')[:month]   ).to eq(['10'])
+        expect( described_class.new(:name => 'foo', :month => 'November')[:month]  ).to eq(['11'])
+        expect( described_class.new(:name => 'foo', :month => 'December')[:month]  ).to eq(['12'])
       end
 
       it "should support valid months as words (3 character short version)" do
-        expect { described_class.new(:name => 'foo', :month => 'Jan') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Feb') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Mar') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Apr') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'May') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Jun') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Jul') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Aug') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Sep') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Oct') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Nov') }.to_not raise_error
-        expect { described_class.new(:name => 'foo', :month => 'Dec') }.to_not raise_error
+        expect( described_class.new(:name => 'foo', :month => 'Jan')[:month] ).to eq(['1'])
+        expect( described_class.new(:name => 'foo', :month => 'Feb')[:month] ).to eq(['2'])
+        expect( described_class.new(:name => 'foo', :month => 'Mar')[:month] ).to eq(['3'])
+        expect( described_class.new(:name => 'foo', :month => 'Apr')[:month] ).to eq(['4'])
+        expect( described_class.new(:name => 'foo', :month => 'May')[:month] ).to eq(['5'])
+        expect( described_class.new(:name => 'foo', :month => 'Jun')[:month] ).to eq(['6'])
+        expect( described_class.new(:name => 'foo', :month => 'Jul')[:month] ).to eq(['7'])
+        expect( described_class.new(:name => 'foo', :month => 'Aug')[:month] ).to eq(['8'])
+        expect( described_class.new(:name => 'foo', :month => 'Sep')[:month] ).to eq(['9'])
+        expect( described_class.new(:name => 'foo', :month => 'Oct')[:month] ).to eq(['10'])
+        expect( described_class.new(:name => 'foo', :month => 'Nov')[:month] ).to eq(['11'])
+        expect( described_class.new(:name => 'foo', :month => 'Dec')[:month] ).to eq(['12'])
       end
 
       it "should not support numeric values out of range" do