puppet 3.7.1-x64-mingw32 → 3.7.2-x64-mingw32

data/spec/unit/parser/resource/param_spec.rb

@@ -1,19 +1,13 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Parser::Resource::Param do
-  it "can be instantiated" do
-    Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo')
-  end
-
-  it "stores the source file" do
-    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :file => 'foo.pp')
-    param.file.should == 'foo.pp'
-  end
+  it "has readers for all of the attributes" do
+    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :file => 'foo.pp', :line => 42)
 
-  it "stores the line number" do
-    param = Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => 'foo', :line => 42)
-    param.line.should == 42
+    expect(param.name).to eq(:myparam)
+    expect(param.value).to eq('foo')
+    expect(param.file).to eq('foo.pp')
+    expect(param.line).to eq(42)
   end
 
   context "parameter validation" do
@@ -23,21 +17,15 @@ describe Puppet::Parser::Resource::Param do
       }.to raise_error(Puppet::Error, /name is a required option/)
     end
 
-    it "throws an error when instantiated without a value" do
-      expect {
-        Puppet::Parser::Resource::Param.new(:name => 'myparam')
-      }.to raise_error(Puppet::Error, /value is a required option/)
-    end
+    it "does not require a value" do
+      param = Puppet::Parser::Resource::Param.new(:name => 'myparam')
 
-    it "throws an error when instantiated with a nil value" do
-      expect {
-        Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => nil)
-      }.to raise_error(Puppet::Error, /value is a required option/)
+      expect(param.value).to be_nil
     end
 
     it "includes file/line context in errors" do
       expect {
-        Puppet::Parser::Resource::Param.new(:name => 'myparam', :value => nil, :file => 'foo.pp', :line => 42)
+        Puppet::Parser::Resource::Param.new(:file => 'foo.pp', :line => 42)
       }.to raise_error(Puppet::Error, /foo.pp:42/)
     end
   end

data/spec/unit/parser/resource_spec.rb

@@ -561,10 +561,6 @@ describe Puppet::Parser::Resource do
       @resource["foo"].should == "bar"
     end
 
-    it "should fail when provided a parameter name but no value" do
-      expect { @resource.set_parameter("myparam") }.to raise_error(ArgumentError)
-    end
-
     it "should allow parameters to be set to 'false'" do
       @resource.set_parameter("myparam", false)
       @resource["myparam"].should be_false

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

@@ -680,12 +680,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'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",
-      "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Fixnum',
-      "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Fixnum where String is expected',
-      "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Fixnum where String is expected',
+      "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
+      "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
+      "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
       "String[a]"                   => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String",
-      "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Fixnum where String or Regexp or Pattern-Type or Regexp-Type is expected',
-      "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Fixnum where String or Regexp is expected',
+      "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Integer where String or Regexp or Pattern-Type or Regexp-Type is expected',
+      "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Integer where String or Regexp is expected',
       "Regexp[a,b]"                 => 'A Regexp-Type[] accepts 1 argument. Got 2',
       "true[0]"                     => "Operator '[]' is not applicable to a Boolean",
       "1[0]"                        => "Operator '[]' is not applicable to an Integer",
@@ -963,6 +963,31 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect{parser.evaluate_string(scope, "assert_no_undef({undef => 1})")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({1 => undef})")}.to_not raise_error()
     end
+
+    context 'using the 3x function api' do
+      it 'can call a 3x function' do
+        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
+        parser.evaluate_string(scope, "bazinga(42)", __FILE__).should == 42
+      end
+
+      it 'maps :undef to empty string' do
+        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
+        parser.evaluate_string(scope, "$a = {} bazinga($a[nope])", __FILE__).should == ''
+        parser.evaluate_string(scope, "bazinga(undef)", __FILE__).should == ''
+      end
+
+      it 'does not map :undef to empty string in arrays' do
+        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
+        parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__).should == :undef
+        parser.evaluate_string(scope, "bazinga([undef])", __FILE__).should == :undef
+      end
+
+      it 'does not map :undef to empty string in hashes' do
+        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
+        parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__).should == :undef
+        parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__).should == :undef
+      end
+    end
   end
 
   context "When evaluator performs string interpolation" do

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

@@ -59,11 +59,6 @@ describe "egrammar parsing function calls" do
       dump(parse("$a = foo()")).should == "(= $a (call foo))"
     end
 
-    #    # For regular grammar where a bare word can not be a "statement"
-    #    it "$a = foo bar # illegal, must have parentheses" do
-    #      expect { dump(parse("$a = foo bar"))}.to raise_error(Puppet::ParseError)
-    #    end
-
     # For egrammar where a bare word can be a "statement"
     it "$a = foo bar # illegal, must have parentheses" do
       dump(parse("$a = foo bar")).should == "(block\n  (= $a foo)\n  bar\n)"
@@ -101,4 +96,24 @@ describe "egrammar parsing function calls" do
         ].join("\n")
     end
   end
+
+  context "When parsing an illegal argument list" do
+    it "raises an error if argument list is not for a call" do
+      expect do
+        parse("$a  = 10, 3")
+      end.to raise_error(/illegal comma/)
+    end
+
+    it "raises an error if argument list is for a potential call not allowed without parentheses" do
+      expect do
+        parse("foo 10, 3")
+      end.to raise_error(/attempt to pass argument list to the function 'foo' which cannot be called without parentheses/)
+    end
+
+    it "does no raise an error for an argument list to an allowed call" do
+      expect do
+        parse("notice 10, 3")
+      end.to_not raise_error()
+    end
+  end
 end

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

@@ -10,6 +10,9 @@ describe 'The type calculator' do
    t.to = to
    t
   end
+  def constrained_t(t, from, to)
+    Puppet::Pops::Types::TypeFactory.constrain_size(t, from, to)
+  end
 
   def pattern_t(*patterns)
     Puppet::Pops::Types::TypeFactory.pattern(*patterns)
@@ -827,6 +830,21 @@ describe 'The type calculator' do
         calculator.assignable?(pattern, variant_t(string_t('a'), string_t('b'))).should == true
       end
 
+      it 'pattern representing all patterns should accept any pattern' do
+        calculator.assignable?(pattern_t(), pattern_t('a')).should == true
+        calculator.assignable?(pattern_t(), pattern_t()).should == true
+      end
+
+      it 'pattern representing all patterns should accept any enum' do
+        calculator.assignable?(pattern_t(), enum_t('a')).should == true
+        calculator.assignable?(pattern_t(), enum_t()).should == true
+      end
+
+      it 'pattern representing all patterns should accept any string' do
+        calculator.assignable?(pattern_t(), string_t('a')).should == true
+        calculator.assignable?(pattern_t(), string_t()).should == true
+      end
+
     end
 
     context 'when dealing with enums' do
@@ -842,12 +860,51 @@ describe 'The type calculator' do
         calculator.assignable?(enum_t('a', 'b'), enum_t('c')).should == false
       end
 
+      it 'non parameterized enum accepts any other enum but not the reverse' do
+        calculator.assignable?(enum_t(), enum_t('a')).should == true
+        calculator.assignable?(enum_t('a'), enum_t()).should == false
+      end
+
       it 'enum should accept a variant where all variants are acceptable' do
         enum = enum_t('a', 'b')
         calculator.assignable?(enum, variant_t(string_t('a'), string_t('b'))).should == true
       end
     end
 
+    context 'when dealing with string and enum combinations' do
+      it 'should accept assigning any enum to unrestricted string' do
+        calculator.assignable?(string_t(), enum_t('blue')).should == true
+        calculator.assignable?(string_t(), enum_t('blue', 'red')).should == true
+      end
+
+      it 'should not accept assigning longer enum value to size restricted string' do
+        calculator.assignable?(constrained_t(string_t(),2,2), enum_t('a','blue')).should == false
+      end
+
+      it 'should accept assigning any string to empty enum' do
+        calculator.assignable?(enum_t(), string_t()).should == true
+      end
+
+      it 'should accept assigning empty enum to any string' do
+        calculator.assignable?(string_t(), enum_t()).should == true
+      end
+
+      it 'should not accept assigning empty enum to size constrained string' do
+        calculator.assignable?(constrained_t(string_t(),2,2), enum_t()).should == false
+      end
+    end
+
+    context 'when dealing with string/pattern/enum combinations' do
+      it 'any string is equal to any enum is equal to any pattern' do
+        calculator.assignable?(string_t(), enum_t()).should == true
+        calculator.assignable?(string_t(), pattern_t()).should == true
+        calculator.assignable?(enum_t(), string_t()).should == true
+        calculator.assignable?(enum_t(), pattern_t()).should == true
+        calculator.assignable?(pattern_t(), string_t()).should == true
+        calculator.assignable?(pattern_t(), enum_t()).should == true
+      end
+    end
+
     context 'when dealing with tuples' do
       it 'matches empty tuples' do
         tuple1 = tuple_t()
@@ -1057,6 +1114,10 @@ describe 'The type calculator' do
       calculator.instance?(Puppet::Pops::Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => 'Symbol'), :undef).should == true
     end
 
+    it "should consider :undef to be instance of an Optional type" do
+      calculator.instance?(Puppet::Pops::Types::POptionalType.new(), :undef).should == true
+    end
+
     it 'should not consider undef to be an instance of any other type than Any, NilType and Data' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,

data/spec/unit/provider/package/pkg_spec.rb

@@ -70,6 +70,10 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
         provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
       end
+      it "should work correctly for ensure latest on solaris 11 in the presence of a certificate expiration warning" do
+        described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
+        provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
+      end
       it "should work correctly for ensure latest on solaris 11(known UFOXI)" do
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0

data/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb

@@ -142,14 +142,14 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'type'         => { 'days_interval' => 2 },
           })
 
-          resource.provider.trigger.should == {
+          resource.provider.trigger.should == [{
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'daily',
             'every'      => '2',
             'enabled'    => true,
             'index'      => 0,
-          }
+          }]
         end
 
         it 'should handle a single weekly trigger' do
@@ -171,7 +171,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             }
           })
 
-          resource.provider.trigger.should == {
+          resource.provider.trigger.should == [{
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'weekly',
@@ -179,7 +179,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'on'         => ['sun', 'mon', 'wed', 'fri'],
             'enabled'    => true,
             'index'      => 0,
-          }
+          }]
         end
 
         it 'should handle a single monthly date-based trigger' do
@@ -204,7 +204,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             }
           })
 
-          resource.provider.trigger.should == {
+          resource.provider.trigger.should == [{
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'monthly',
@@ -212,7 +212,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'on'         => [1, 3, 5, 15, 'last'],
             'enabled'    => true,
             'index'      => 0,
-          }
+          }]
         end
 
         it 'should handle a single monthly day-of-week-based trigger' do
@@ -240,7 +240,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             }
           })
 
-          resource.provider.trigger.should == {
+          resource.provider.trigger.should == [{
             'start_date'       => '2011-9-12',
             'start_time'       => '13:20',
             'schedule'         => 'monthly',
@@ -249,7 +249,7 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'day_of_week'      => ['sun', 'mon', 'wed', 'fri'],
             'enabled'          => true,
             'index'            => 0,
-          }
+          }]
         end
 
         it 'should handle a single one-time trigger' do
@@ -263,13 +263,13 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
             'flags'        => 0,
           })
 
-          resource.provider.trigger.should == {
+          resource.provider.trigger.should == [{
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 0,
-          }
+          }]
         end
       end
 
@@ -536,18 +536,18 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
         'index'      => 0,
       }
 
-      resource.provider.trigger.should == mock_task_trigger
-      resource.provider.trigger.should == mock_task_trigger
+      resource.provider.trigger.should == [mock_task_trigger]
+      resource.provider.trigger.should == [mock_task_trigger]
 
       resource.provider.clear_task
 
-      resource.provider.trigger.should == {
+      resource.provider.trigger.should == [{
         'start_date' => '2012-11-14',
         'start_time' => '15:22',
         'schedule'   => 'once',
         'enabled'    => true,
         'index'      => 0,
-      }
+      }]
     end
   end
 
@@ -635,6 +635,30 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
   describe '#triggers_same?' do
     let(:provider) { described_class.new(:name => 'foobar', :command => 'C:\Windows\System32\notepad.exe') }
 
+    it "should not mutate triggers" do
+      current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
+      current.freeze
+
+      desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
+      desired.freeze
+
+      expect(provider).to be_triggers_same(current, desired)
+    end
+
+    it "ignores 'index' in current trigger" do
+      current = {'index' => 0, 'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
+      desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
+
+      expect(provider).to be_triggers_same(current, desired)
+    end
+
+    it "ignores 'enabled' in current triggger" do
+      current = {'enabled' => true, 'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
+      desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
+
+      expect(provider).to be_triggers_same(current, desired)
+    end
+
     it "should not consider a disabled 'current' trigger to be the same" do
       current = {'schedule' => 'once', 'enabled' => false}
       desired = {'schedule' => 'once'}
@@ -649,6 +673,15 @@ describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if
       provider.should_not be_triggers_same(current, desired)
     end
 
+    describe 'start_date' do
+      it "considers triggers to be equal when start_date is not specified in the 'desired' trigger" do
+        current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
+        desired = {'schedule' => 'daily', 'start_time' => '15:30', 'every' => 3}
+
+        provider.should be_triggers_same(current, desired)
+      end
+    end
+
     describe 'comparing daily triggers' do
       it "should consider 'desired' triggers not specifying 'every' to have the same value as the 'current' trigger" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -136,6 +136,21 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
     end
   end
 
+  describe "prefetch_hook" do
+    let(:path) { '/path/to/keyfile' }
+    let(:input) do
+      { :type        => 'rsa',
+        :key         => 'KEYDATA',
+        :name        => '',
+        :record_type => :parsed,
+        :target      => path,
+      }
+    end
+    it "adds an indexed name to unnamed resources" do
+      @provider_class.prefetch_hook([input])[0][:name].should =~ /^#{path}:unnamed-\d+/
+    end
+  end
+
 end
 
 describe provider_class, :unless => Puppet.features.microsoft_windows? do

data/spec/unit/type/user_spec.rb

@@ -501,6 +501,11 @@ describe Puppet::Type.type(:user) do
           names = resources.collect { |res| res.name }
           names.should_not include("keyname3")
         end
+        it "should generate names for unnamed keys" do
+          names = resources.collect { |res| res.name }
+          fixture_path = File.join(my_fixture_dir, 'authorized_keys')
+          names.should include("#{fixture_path}:unnamed-1")
+        end
         it "should each have a value for the user property" do
           resources.map { |res|
             res[:user]

data/spec/unit/util/autoload_spec.rb

@@ -5,10 +5,10 @@ require 'puppet/util/autoload'
 
 describe Puppet::Util::Autoload do
   include PuppetSpec::Files
+
   before do
     @autoload = Puppet::Util::Autoload.new("foo", "tmp")
 
-    @autoload.stubs(:eachdir).yields make_absolute("/my/dir")
     @loaded = {}
     @autoload.class.stubs(:loaded).returns(@loaded)
   end
@@ -17,25 +17,44 @@ describe Puppet::Util::Autoload do
     before :each do
       ## modulepath/libdir can't be used until after app settings are initialized, so we need to simulate that:
       Puppet.settings.expects(:app_defaults_initialized?).returns(true).at_least_once
-
-      @dira = File.expand_path('/a')
-      @dirb = File.expand_path('/b')
-      @dirc = File.expand_path('/c')
     end
 
     it "should collect all of the lib directories that exist in the current environment's module path" do
-      environment = Puppet::Node::Environment.create(:foo, [@dira, @dirb, @dirc])
-      Dir.expects(:entries).with(@dira).returns %w{. .. one two}
-      Dir.expects(:entries).with(@dirb).returns %w{. .. one two}
+      dira = dir_containing('dir_a', {
+        "one" => {},
+        "two" => { "lib" => {} }
+      })
 
-      Puppet::FileSystem.expects(:directory?).with(@dira).returns true
-      Puppet::FileSystem.expects(:directory?).with(@dirb).returns true
-      Puppet::FileSystem.expects(:directory?).with(@dirc).returns false
+      dirb = dir_containing('dir_a', {
+        "one" => {},
+        "two" => { "lib" => {} }
+      })
 
-      FileTest.expects(:directory?).with(regexp_matches(%r{two/lib})).times(2).returns true
-      FileTest.expects(:directory?).with(regexp_matches(%r{one/lib})).times(2).returns false
+      environment = Puppet::Node::Environment.create(:foo, [dira, dirb])
+
+      @autoload.class.module_directories(environment).should == ["#{dira}/two/lib", "#{dirb}/two/lib"]
+    end
+
+    it "ignores missing module directories" do
+      environment = Puppet::Node::Environment.create(:foo, [File.expand_path('does/not/exist')])
+
+      @autoload.class.module_directories(environment).should be_empty
+    end
 
-      @autoload.class.module_directories(environment).should == ["#{@dira}/two/lib", "#{@dirb}/two/lib"]
+    it "ignores the configured environment when it doesn't exist" do
+      Puppet[:environment] = 'nonexistent'
+
+      Puppet.override({ :environments => Puppet::Environments::Static.new() }) do
+        @autoload.class.module_directories(nil).should be_empty
+      end
+    end
+
+    it "uses the configured environment when no environment is given" do
+      Puppet[:environment] = 'nonexistent'
+
+      Puppet.override({ :environments => Puppet::Environments::Static.new() }) do
+        @autoload.class.module_directories(nil).should be_empty
+      end
     end
 
     it "should include the module directories, the Puppet libdir, and all of the Ruby load directories" do