puppet 3.6.0 → 3.6.1

data/spec/unit/network/http/route_spec.rb

@@ -41,6 +41,22 @@ describe Puppet::Network::HTTP::Route do
       expect(res.body).to eq("used")
     end
 
+    it "processes DELETE requests" do
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).delete(respond("used"))
+
+      route.process(request("DELETE", "/vtest/foo"), res)
+
+      expect(res.body).to eq("used")
+    end
+
+    it "does something when it doesn't know the verb" do
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo})
+
+      expect do
+        route.process(request("UNKNOWN", "/vtest/foo"), res)
+      end.to raise_error(Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError, /UNKNOWN/)
+    end
+
     it "calls the method handlers in turn" do
       call_count = 0
       handler = lambda { |request, response| call_count += 1 }

data/spec/unit/parser/functions/epp_spec.rb

@@ -67,6 +67,21 @@ describe "the epp function" do
     eval_template("string was: <%= $string %>").should == "string was: the string value"
   end
 
+  describe 'when loading from modules' do
+    include PuppetSpec::Files
+    it 'an epp template is found' do
+      modules_dir = dir_containing('modules', {
+        'testmodule'  => {
+            'templates' => {
+              'the_x.epp' => 'The x is <%= $x %>'
+            }
+        }})
+      Puppet.override({:current_environment => (env = Puppet::Node::Environment.create(:testload, [ modules_dir ]))}, "test") do
+        node.environment = env
+        expect(scope.function_epp([ 'testmodule/the_x.epp', { 'x' => '3'} ])).to eql("The x is 3")
+      end
+    end
+  end
 
   def eval_template_with_args(content, args_hash)
     file_path = tmpdir('epp_spec_content')

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

@@ -320,6 +320,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect { evaluate(expr) }.to raise_error(/Illegal name/)
     end
 
+    it 'downcases capitalized class names' do
+      expr = fqr('Class')['My::Class']
+
+      expect(evaluate(expr)).to be_the_type(types.host_class('my::class'))
+    end
+
     it 'gives an error if no keys are given as argument' do
       expr = fqr('Class')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Class\[\] accepts 1 or more arguments. Got 0/)

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

@@ -811,6 +811,16 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       alt_results.include?(parse_result).should == true
     end
 
+    it 'should accept a variable with leading underscore when used directly' do
+      source = '$_x = 10; "$_x"'
+      expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
+    end
+
+    it 'should accept a variable with leading underscore when used as an expression' do
+      source = '$_x = 10; "${_x}"'
+      expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
+    end
+
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|

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

@@ -107,9 +107,17 @@ describe 'Lexer2' do
     end
   end
 
-  [ 'a-b', 'a--b', 'a-b-c'].each do |string|
+  [ 'a-b', 'a--b', 'a-b-c', '_x'].each do |string|
     it "should lex a BARE WORD STRING on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:STRING, string])
+      tokens_scanned_from(string).should match_tokens2([:WORD, string])
+    end
+  end
+
+  [ '_x::y', 'x::_y'].each do |string|
+    it "should consider the bare word '#{string}' to be a bad NAME" do
+      expect {
+        tokens_scanned_from(string)
+      }.to raise_error(/Illegal fully qualified name/)
     end
   end
 

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

@@ -26,7 +26,6 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
 
     it "should report absent packages" do
       rpm.raises(Puppet::ExecutionFailure, "couldn't find rpm")
-      rpm(rpm_args + ['--whatprovides']).raises(Puppet::ExecutionFailure, 'no package provides faff')
       pkg.property(:ensure).retrieve.should == :absent
     end
 

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

@@ -44,6 +44,13 @@ describe provider_class do
     Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], execute_options).returns(rpm_version).at_most_once
   end
 
+  describe 'provider features' do
+    it { should be_versionable }
+    it { should be_install_options }
+    it { should be_uninstall_options }
+    it { should be_virtual_packages }
+  end
+
   describe "self.instances" do
     describe "with a modern version of RPM" do
       it "includes all the modern flags" do
@@ -277,12 +284,11 @@ describe provider_class do
       Puppet.expects(:debug).never
       expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format]
       Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
-      Puppet::Util::Execution.expects(:execute).with(expected_args + ["--whatprovides"], execute_options).raises Puppet::ExecutionFailure.new("no package provides #{resource_name}")
       expect(provider.query).to be_nil
     end
 
     it "parses virtual package" do
-      #Puppet.expects(:debug).never
+      provider.resource[:allow_virtual] = true
       expected_args = ["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format]
       Puppet::Util::Execution.expects(:execute).with(expected_args, execute_options).raises Puppet::ExecutionFailure.new("package #{resource_name} is not installed")
       Puppet::Util::Execution.expects(:execute).with(expected_args + ["--whatprovides"], execute_options).returns "myresource 0 1.2.3.4 5.el4 noarch\n"

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

@@ -27,6 +27,12 @@ describe provider_class do
     provider.stubs(:get).with(:arch).returns 'i386'
   end
 
+  describe 'provider features' do
+    it { should be_versionable }
+    it { should be_install_options }
+    it { should be_virtual_packages }
+  end
+
   # provider should repond to the following methods
    [:install, :latest, :update, :purge, :install_options].each do |method|
      it "should have a(n) #{method}" do
@@ -43,7 +49,8 @@ describe provider_class do
 
     it 'should call yum install for :installed' do
       resource.stubs(:should).with(:ensure).returns :installed
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, 'mypackage')
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name)
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
       provider.install
     end
 
@@ -53,18 +60,20 @@ describe provider_class do
     end
 
     it 'should be able to set version' do
-      resource[:ensure] = '1.2'
-
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, 'mypackage-1.2')
-      provider.stubs(:query).returns :ensure => '1.2'
+      version = '1.2'
+      resource[:ensure] = version
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name)
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}")
+      provider.stubs(:query).returns :ensure => version
       provider.install
     end
 
     it 'should be able to downgrade' do
+      current_version = '1.2'
+      version = '1.0'
       resource[:ensure] = '1.0'
-
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :downgrade, 'mypackage-1.0')
-      provider.stubs(:query).returns(:ensure => '1.2').then.returns(:ensure => '1.0')
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :downgrade, "#{name}-#{version}")
+      provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
       provider.install
     end
 
@@ -72,14 +81,22 @@ describe provider_class do
       resource[:ensure] = :installed
       resource[:install_options] = ['-t', {'-x' => 'expackage'}]
 
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, 'mypackage')
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, name)
+      provider.install
+    end
+
+    it 'allow virtual packages' do
+      resource[:ensure] = :installed
+      resource[:allow_virtual] = true
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name).never
+      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
       provider.install
     end
   end
 
   describe 'when uninstalling' do
     it 'should use erase to purge' do
-      provider.expects(:yum).with('-y', :erase, 'mypackage')
+      provider.expects(:yum).with('-y', :erase, name)
       provider.purge
     end
   end
@@ -97,7 +114,7 @@ describe provider_class do
       ]
       provider.stubs(:properties).returns({:ensure => '3.4.5'})
 
-      described_class.expects(:latest_package_version).with('mypackage', ['contrib', 'centosplus'], [])
+      described_class.expects(:latest_package_version).with(name, ['contrib', 'centosplus'], [])
       provider.latest
     end
 
@@ -108,13 +125,13 @@ describe provider_class do
       ]
       provider.stubs(:properties).returns({:ensure => '3.4.5'})
 
-      described_class.expects(:latest_package_version).with('mypackage', [], ['updates', 'centosplus'])
+      described_class.expects(:latest_package_version).with(name, [], ['updates', 'centosplus'])
       provider.latest
     end
 
     describe 'and a newer version is not available' do
       before :each do
-        described_class.stubs(:latest_package_version).with('mypackage', [], []).returns nil
+        described_class.stubs(:latest_package_version).with(name, [], []).returns nil
       end
 
       it 'raises an error the package is not installed' do
@@ -133,7 +150,7 @@ describe provider_class do
     describe 'and a newer version is available' do
       let(:latest_version) do
         {
-          :name     => 'mypackage',
+          :name     => name,
           :epoch    => '1',
           :version  => '2.3.4',
           :release  => '5',
@@ -142,7 +159,7 @@ describe provider_class do
       end
 
       it 'includes the epoch in the version string' do
-        described_class.stubs(:latest_package_version).with('mypackage', [], []).returns(latest_version)
+        described_class.stubs(:latest_package_version).with(name, [], []).returns(latest_version)
         provider.latest.should == '1:2.3.4-5'
       end
     end
@@ -154,7 +171,7 @@ describe provider_class do
 
     let(:mypackage_version) do
       {
-        :name     => 'mypackage',
+        :name     => name,
         :epoch    => '1',
         :version  => '2.3.4',
         :release  => '5',
@@ -164,7 +181,7 @@ describe provider_class do
 
     let(:mypackage_newerversion) do
       {
-        :name     => 'mypackage',
+        :name     => name,
         :epoch    => '1',
         :version  => '4.5.6',
         :release  => '7',
@@ -172,12 +189,12 @@ describe provider_class do
       }
     end
 
-    let(:latest_versions) { {'mypackage' => [mypackage_version]} }
-    let(:enabled_versions) { {'mypackage' => [mypackage_newerversion]} }
+    let(:latest_versions) { {name => [mypackage_version]} }
+    let(:enabled_versions) { {name => [mypackage_newerversion]} }
 
     it "returns the version hash if the package was found" do
       described_class.expects(:fetch_latest_versions).with([], []).once.returns(latest_versions)
-      version = described_class.latest_package_version('mypackage', [], [])
+      version = described_class.latest_package_version(name, [], [])
       expect(version).to eq(mypackage_version)
     end
 
@@ -191,7 +208,7 @@ describe provider_class do
       described_class.expects(:fetch_latest_versions).with([], []).once.returns(latest_versions)
 
       2.times {
-        version = described_class.latest_package_version('mypackage', [], [])
+        version = described_class.latest_package_version(name, [], [])
         expect(version).to eq mypackage_version
       }
     end
@@ -201,12 +218,12 @@ describe provider_class do
       described_class.expects(:fetch_latest_versions).with(['enabled'], ['disabled']).once.returns(enabled_versions)
 
       2.times {
-        version = described_class.latest_package_version('mypackage', [], [])
+        version = described_class.latest_package_version(name, [], [])
         expect(version).to eq mypackage_version
       }
 
       2.times {
-        version = described_class.latest_package_version('mypackage', ['enabled'], ['disabled'])
+        version = described_class.latest_package_version(name, ['enabled'], ['disabled'])
         expect(version).to eq(mypackage_newerversion)
       }
     end

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

@@ -47,6 +47,7 @@ describe provider_class do
   describe "when installing with zypper version >= 1.0" do
     it "should use a command-line with versioned package'" do
       @resource.stubs(:should).with(:ensure).returns "1.2.3-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "1.2.8"
 
       @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
@@ -56,8 +57,9 @@ describe provider_class do
 
     it "should use a command-line without versioned package" do
       @resource.stubs(:should).with(:ensure).returns :latest
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "1.2.8"
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', 'mypackage')
       @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
@@ -66,6 +68,7 @@ describe provider_class do
   describe "when installing with zypper version = 0.6.104" do
     it "should use a command-line with versioned package'" do
       @resource.stubs(:should).with(:ensure).returns "1.2.3-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "0.6.104"
 
       @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
@@ -75,8 +78,9 @@ describe provider_class do
 
     it "should use a command-line without versioned package" do
       @resource.stubs(:should).with(:ensure).returns :latest
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "0.6.104"
-      @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
+      @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', 'mypackage')
       @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
@@ -85,6 +89,7 @@ describe provider_class do
   describe "when installing with zypper version = 0.6.13" do
     it "should use a command-line with versioned package'" do
       @resource.stubs(:should).with(:ensure).returns "1.2.3-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "0.6.13"
 
       @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage-1.2.3-4.5.6')
@@ -94,8 +99,9 @@ describe provider_class do
 
     it "should use a command-line without versioned package" do
       @resource.stubs(:should).with(:ensure).returns :latest
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "0.6.13"
-      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
+      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', '--name', 'mypackage')
       @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
@@ -118,11 +124,21 @@ describe provider_class do
     end
   end
 
+  it "should install a virtual package" do
+    @resource.stubs(:should).with(:ensure).returns :installed
+    @resource.stubs(:allow_virtual?).returns true
+    @provider.stubs(:zypper_version).returns "0.6.13"
+    @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
+    @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
+    @provider.install
+  end
+
   describe "when installing with zypper install options" do
     it "should install the package without checking keys" do
       @resource.stubs(:[]).with(:name).returns "php5"
       @resource.stubs(:[]).with(:install_options).returns ['--no-gpg-check', {'-p' => '/vagrant/files/localrepo/'}]
       @resource.stubs(:should).with(:ensure).returns "5.4.10-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
       @provider.stubs(:zypper_version).returns "1.2.8"
 
       @provider.expects(:zypper).with('--quiet', :install,
@@ -135,9 +151,10 @@ describe provider_class do
       @resource.stubs(:[]).with(:name).returns 'vim'
       @resource.stubs(:[]).with(:install_options).returns([{ '--a' => 'foo', '--b' => '"quoted bar"' }])
       @resource.stubs(:should).with(:ensure).returns :present
+      @resource.stubs(:allow_virtual?).returns false
 
       @provider.stubs(:zypper_version).returns '1.2.8'
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a=foo', '--b="quoted bar"', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', '--a=foo', '--b="quoted bar"', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
@@ -146,9 +163,10 @@ describe provider_class do
       @resource.stubs(:[]).with(:name).returns 'vim'
       @resource.stubs(:[]).with(:install_options).returns([['--a', '--b', '--c']])
       @resource.stubs(:should).with(:ensure).returns :present
+      @resource.stubs(:allow_virtual?).returns false
 
       @provider.stubs(:zypper_version).returns '1.2.8'
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a', '--b', '--c', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', '--a', '--b', '--c', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
@@ -157,9 +175,10 @@ describe provider_class do
       @resource.stubs(:[]).with(:name).returns 'vim'
       @resource.stubs(:[]).with(:install_options).returns(['--a --b --c'])
       @resource.stubs(:should).with(:ensure).returns :present
+      @resource.stubs(:allow_virtual?).returns false
 
       @provider.stubs(:zypper_version).returns '1.2.8'
-      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a --b --c', 'vim')
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', '--a --b --c', 'vim')
       @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end

data/spec/unit/ssl/host_spec.rb

@@ -511,7 +511,7 @@ describe Puppet::SSL::Host do
     end
 
     it "should find the CA certificate if it does not have a certificate" do
-      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
+      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME, :fail_on_404 => true).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.stubs(:find).with("myname").returns @cert
       @host.certificate
     end
@@ -519,13 +519,13 @@ describe Puppet::SSL::Host do
     it "should not find the CA certificate if it is the CA host" do
       @host.expects(:ca?).returns true
       Puppet::SSL::Certificate.indirection.stubs(:find)
-      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).never
+      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME, :fail_on_404 => true).never
 
       @host.certificate
     end
 
     it "should return nil if it cannot find a CA certificate" do
-      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns nil
+      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME, :fail_on_404 => true).returns nil
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").never
 
       @host.certificate.should be_nil
@@ -545,13 +545,13 @@ describe Puppet::SSL::Host do
     end
 
     it "should find the certificate in the Certificate class and return the Puppet certificate instance" do
-      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
+      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME, :fail_on_404 => true).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").returns @cert
       @host.certificate.should equal(@cert)
     end
 
     it "should return any previously found certificate" do
-      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME).returns mock("cacert")
+      Puppet::SSL::Certificate.indirection.expects(:find).with(Puppet::SSL::CA_NAME, :fail_on_404 => true).returns mock("cacert")
       Puppet::SSL::Certificate.indirection.expects(:find).with("myname").returns(@cert).once
 
       @host.certificate.should equal(@cert)