puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/unit/settings/environment_conf_spec.rb

@@ -3,31 +3,47 @@ require 'puppet/settings/environment_conf.rb'
 
 describe Puppet::Settings::EnvironmentConf do
 
+  def setup_environment_conf(config, conf_hash)
+    conf_hash.each do |setting,value|
+      config.expects(:setting).with(setting).returns(
+        mock('setting', :value => value)
+      )
+    end
+  end
+
   context "with config" do
-    let(:config) { stub(:config) }
+    let(:config) { stub('config') }
     let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
 
     it "reads a modulepath from config and does not include global_module_path" do
-      config.expects(:setting).with(:modulepath).returns(
-        mock('setting', :value => '/some/modulepath')
-      )
+      setup_environment_conf(config, :modulepath => '/some/modulepath')
+
       expect(envconf.modulepath).to eq(File.expand_path('/some/modulepath'))
     end
 
     it "reads a manifest from config" do
-      config.expects(:setting).with(:manifest).returns(
-        mock('setting', :value => '/some/manifest')
-      )
+      setup_environment_conf(config, :manifest => '/some/manifest')
+
       expect(envconf.manifest).to eq(File.expand_path('/some/manifest'))
     end
 
     it "reads a config_version from config" do
-      config.expects(:setting).with(:config_version).returns(
-        mock('setting', :value => '/some/version.sh')
-      )
+      setup_environment_conf(config, :config_version => '/some/version.sh')
+
       expect(envconf.config_version).to eq(File.expand_path('/some/version.sh'))
     end
 
+    it "read an environment_timeout from config" do
+      setup_environment_conf(config, :environment_timeout => '3m')
+
+      expect(envconf.environment_timeout).to eq(180)
+    end
+
+    it "can retrieve raw settings" do
+      setup_environment_conf(config, :manifest => 'manifest.pp')
+
+      expect(envconf.raw_setting(:manifest)).to eq('manifest.pp')
+    end
   end
 
   context "without config" do
@@ -47,5 +63,56 @@ describe Puppet::Settings::EnvironmentConf do
     it "returns nothing for config_version when config has none" do
       expect(envconf.config_version).to be_nil
     end
+
+    it "returns a defult of 0 for environment_timeout when config has none" do
+      expect(envconf.environment_timeout).to eq(0)
+    end
+
+    it "can still retrieve raw setting" do
+      expect(envconf.raw_setting(:manifest)).to be_nil
+    end
+  end
+
+  describe "with disable_per_environment_manifest" do
+
+    let(:config) { stub('config') }
+    let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, ["/global/modulepath"]) }
+
+    context "set true" do
+
+      before(:each) do
+        Puppet[:default_manifest] = File.expand_path('/default/manifest')
+        Puppet[:disable_per_environment_manifest] = true
+      end
+
+      it "ignores environment.conf manifest" do
+        setup_environment_conf(config, :manifest => '/some/manifest.pp')
+
+        expect(envconf.manifest).to eq(File.expand_path('/default/manifest'))
+      end
+
+      it "logs error when environment.conf has manifest set" do
+        setup_environment_conf(config, :manifest => '/some/manifest.pp')
+
+        envconf.manifest
+        expect(@logs.first.to_s).to match(/disable_per_environment_manifest.*true.*environment.conf.*does not match the default_manifest/)
+      end
+
+      it "does not log an error when environment.conf does not have a manifest set" do
+        setup_environment_conf(config, :manifest => nil)
+
+        expect(envconf.manifest).to eq(File.expand_path('/default/manifest'))
+        expect(@logs).to be_empty
+      end
+    end
+
+    it "uses environment.conf when false" do
+      setup_environment_conf(config, :manifest => '/some/manifest.pp')
+
+      Puppet[:default_manifest] = File.expand_path('/default/manifest')
+      Puppet[:disable_per_environment_manifest] = false
+
+      expect(envconf.manifest).to eq(File.expand_path('/some/manifest.pp'))
+    end
   end
 end

data/spec/unit/settings/file_setting_spec.rb

@@ -129,7 +129,7 @@ describe Puppet::Settings::FileSetting do
       @settings = mock 'settings'
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
       @file.stubs(:create_files?).returns true
-      @settings.stubs(:value).with(:myfile).returns @basepath
+      @settings.stubs(:value).with(:myfile, nil, false).returns @basepath
     end
 
     it "should return :file as its type" do
@@ -146,19 +146,20 @@ describe Puppet::Settings::FileSetting do
     it "should manage existent files even if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
+      Puppet::FileSystem.stubs(:exist?)
       Puppet::FileSystem.expects(:exist?).with(@basepath).returns true
       @file.to_resource.should be_instance_of(Puppet::Resource)
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
-        @settings.stubs(:value).with(:myfile).returns "/dev/file"
+        @settings.stubs(:value).with(:myfile, nil, false).returns "/dev/file"
         @file.to_resource.should be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
-      @settings.stubs(:value).with(:myfile).returns :foo
+      @settings.stubs(:value).with(:myfile, nil, false).returns :foo
       @file.to_resource.should be_nil
     end
 
@@ -169,7 +170,7 @@ describe Puppet::Settings::FileSetting do
     end
 
     it "should fully qualified returned files if necessary (#795)" do
-      @settings.stubs(:value).with(:myfile).returns "myfile"
+      @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
       path = File.expand_path('myfile')
       @file.to_resource.title.should == path
     end

data/spec/unit/settings/priority_setting_spec.rb

@@ -53,10 +53,10 @@ describe Puppet::Settings::PrioritySetting do
     describe "on a Windows-like platform it", :if => Puppet::Util::Platform.windows? do
       it "parses high, normal, low, and idle priorities" do
         {
-          'high'   => Process::HIGH_PRIORITY_CLASS,
-          'normal' => Process::NORMAL_PRIORITY_CLASS,
-          'low'    => Process::BELOW_NORMAL_PRIORITY_CLASS,
-          'idle'   => Process::IDLE_PRIORITY_CLASS
+          'high'   => Puppet::Util::Windows::Process::HIGH_PRIORITY_CLASS,
+          'normal' => Puppet::Util::Windows::Process::NORMAL_PRIORITY_CLASS,
+          'low'    => Puppet::Util::Windows::Process::BELOW_NORMAL_PRIORITY_CLASS,
+          'idle'   => Puppet::Util::Windows::Process::IDLE_PRIORITY_CLASS
         }.each do |value, converted_value|
           setting.munge(value).should == converted_value
         end

data/spec/unit/settings_spec.rb

@@ -1359,6 +1359,44 @@ describe Puppet::Settings do
       end
     end
 
+    describe "adding default directory environment to the catalog" do
+      let(:tmpenv) { tmpdir("envs") }
+      let(:default_path) { "#{tmpenv}/environments" }
+      before(:each) do
+        @settings.define_settings :main,
+          :environment     => { :default => "production", :desc => "env"},
+          :environmentpath => { :type => :path, :default => default_path, :desc => "envpath"}
+      end
+
+      it "adds if environmentpath exists" do
+        envpath = "#{tmpenv}/custom_envpath"
+        @settings[:environmentpath] = envpath
+        Dir.mkdir(envpath)
+        catalog = @settings.to_catalog
+        expect(catalog.resource_keys).to include(["File", "#{envpath}/production"])
+      end
+
+      it "adds the first directory of environmentpath" do
+        envdir = "#{tmpenv}/custom_envpath"
+        envpath = "#{envdir}#{File::PATH_SEPARATOR}/some/other/envdir"
+        @settings[:environmentpath] = envpath
+        Dir.mkdir(envdir)
+        catalog = @settings.to_catalog
+        expect(catalog.resource_keys).to include(["File", "#{envdir}/production"])
+      end
+
+      it "handles a non-existent environmentpath" do
+        catalog = @settings.to_catalog
+        expect(catalog.resource_keys).to be_empty
+      end
+
+      it "handles a default environmentpath" do
+        Dir.mkdir(default_path)
+        catalog = @settings.to_catalog
+        expect(catalog.resource_keys).to include(["File", "#{default_path}/production"])
+      end
+    end
+
     describe "when adding users and groups to the catalog" do
       before do
         Puppet.features.stubs(:root?).returns true
@@ -1468,14 +1506,14 @@ describe Puppet::Settings do
           :maindir => { :type => :directory, :default => make_absolute("/maindir"), :desc => "a" },
           :seconddir => { :type => :directory, :default => make_absolute("/seconddir"), :desc => "a"}
       @settings.define_settings :main, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
-      @settings.define_settings :other, :otherdir => {:type => :directory, :default => make_absolute("/otherdir"), :desc => "a", :owner => "service", :group => "service", :mode => 0755}
+      @settings.define_settings :other, :otherdir => {:type => :directory, :default => make_absolute("/otherdir"), :desc => "a", :owner => "service", :group => "service", :mode => '0755'}
       @settings.define_settings :third, :thirddir => { :type => :directory, :default => make_absolute("/thirddir"), :desc => "b"}
-      @settings.define_settings :files, :myfile => {:type => :file, :default => make_absolute("/myfile"), :desc => "a", :mode => 0755}
+      @settings.define_settings :files, :myfile => {:type => :file, :default => make_absolute("/myfile"), :desc => "a", :mode => '0755'}
     end
 
     it "should provide a method that creates directories with the correct modes" do
       Puppet::Util::SUIDManager.expects(:asuser).with("suser", "sgroup").yields
-      Dir.expects(:mkdir).with(make_absolute("/otherdir"), 0755)
+      Dir.expects(:mkdir).with(make_absolute("/otherdir"), '0755')
       @settings.mkdir(:otherdir)
     end
 

data/spec/unit/ssl/certificate_authority_spec.rb

@@ -7,7 +7,6 @@ require 'puppet/ssl/certificate_authority'
 describe Puppet::SSL::CertificateAuthority do
   after do
     Puppet::SSL::CertificateAuthority.instance_variable_set(:@singleton_instance, nil)
-    Puppet.settings.clearused
   end
 
   def stub_ca_host
@@ -937,12 +936,36 @@ describe Puppet::SSL::CertificateAuthority do
         cert = stub 'cert', :content => real_cert
         Puppet::SSL::Certificate.indirection.expects(:find).with("host").returns nil
 
-        @ca.inventory.expects(:serial).with("host").returns 16
+        @ca.inventory.expects(:serials).with("host").returns [16]
 
         @ca.crl.expects(:revoke).with { |serial, key| serial == 16 }
         @ca.revoke('host')
       end
 
+      it "should revoke all serials matching a name" do
+        real_cert = stub 'real_cert', :serial => 15
+        cert = stub 'cert', :content => real_cert
+        Puppet::SSL::Certificate.indirection.expects(:find).with("host").returns nil
+
+        @ca.inventory.expects(:serials).with("host").returns [16, 20, 25]
+
+        @ca.crl.expects(:revoke).with { |serial, key| serial == 16 }
+        @ca.crl.expects(:revoke).with { |serial, key| serial == 20 }
+        @ca.crl.expects(:revoke).with { |serial, key| serial == 25 }
+        @ca.revoke('host')
+      end
+
+      it "should raise an error if no certificate match" do
+        real_cert = stub 'real_cert', :serial => 15
+        cert = stub 'cert', :content => real_cert
+        Puppet::SSL::Certificate.indirection.expects(:find).with("host").returns nil
+
+        @ca.inventory.expects(:serials).with("host").returns []
+
+        @ca.crl.expects(:revoke).never
+        expect { @ca.revoke('host') }.to raise_error
+      end
+
       context "revocation by serial number (#16798)" do
         it "revokes when given a lower case hexadecimal formatted string" do
           @ca.crl.expects(:revoke).with { |serial, key| serial == 15 }

data/spec/unit/ssl/inventory_spec.rb

@@ -133,5 +133,18 @@ describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? d
         @inventory.serial("me").should == 15
       end
     end
+
+    describe "and finding all serial numbers" do
+      it "should return nil if the inventory file is missing" do
+        Puppet::FileSystem.expects(:exist?).with(cert_inventory).returns false
+        @inventory.serials(:whatever).should be_empty
+      end
+
+      it "should return the all the serial numbers from the lines matching the provided name" do
+        File.expects(:readlines).with(cert_inventory).returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n", "0x002 blah blah /CN=me\n"]
+
+        @inventory.serials("me").should == [15, 2]
+      end
+    end
   end
 end

data/spec/unit/ssl/validator_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'puppet/ssl'
-require 'puppet/ssl/configuration'
 
 describe Puppet::SSL::Validator::DefaultValidator do
   let(:ssl_context) do

data/spec/unit/transaction/resource_harness_spec.rb

@@ -352,6 +352,70 @@ describe Puppet::Transaction::ResourceHarness do
         event.status.should != 'failure'
       end
     end
+
+    it "should not ignore microseconds when auditing a file's mtime" do
+      test_file = tmpfile('foo')
+      File.open(test_file, 'w').close
+      resource = Puppet::Type.type(:file).new :path => test_file, :audit => ['mtime'], :backup => false
+
+      # construct a property hash with nanosecond resolution as would be
+      # found on an ext4 file system
+      time_with_nsec_resolution = Time.at(1000, 123456.999)
+      current_from_filesystem    = {:mtime => time_with_nsec_resolution}
+
+      # construct a property hash with a 1 microsecond difference from above
+      time_with_usec_resolution = Time.at(1000, 123457.000)
+      historical_from_state_yaml = {:mtime => time_with_usec_resolution}
+
+      # set up the sequence of stubs; yeah, this is pretty
+      # brittle, so this might need to be adjusted if the
+      # resource_harness logic changes
+      resource.expects(:retrieve).returns(current_from_filesystem)
+      Puppet::Util::Storage.stubs(:cache).with(resource).
+        returns(historical_from_state_yaml).then.
+        returns(current_from_filesystem).then.
+        returns(current_from_filesystem)
+
+      # there should be an audit change recorded, since the two
+      # timestamps differ by at least 1 microsecond
+      status = @harness.evaluate(resource)
+      status.events.should_not be_empty
+      status.events.each do |event|
+        event.message.should =~ /audit change: previously recorded/
+      end
+    end
+
+    it "should ignore nanoseconds when auditing a file's mtime" do
+      test_file = tmpfile('foo')
+      File.open(test_file, 'w').close
+      resource = Puppet::Type.type(:file).new :path => test_file, :audit => ['mtime'], :backup => false
+
+      # construct a property hash with nanosecond resolution as would be
+      # found on an ext4 file system
+      time_with_nsec_resolution = Time.at(1000, 123456.789)
+      current_from_filesystem    = {:mtime => time_with_nsec_resolution}
+
+      # construct a property hash with the same timestamp as above,
+      # truncated to microseconds, as would be read back from state.yaml
+      time_with_usec_resolution = Time.at(1000, 123456.000)
+      historical_from_state_yaml = {:mtime => time_with_usec_resolution}
+
+      # set up the sequence of stubs; yeah, this is pretty
+      # brittle, so this might need to be adjusted if the
+      # resource_harness logic changes
+      resource.expects(:retrieve).returns(current_from_filesystem)
+      Puppet::Util::Storage.stubs(:cache).with(resource).
+        returns(historical_from_state_yaml).then.
+        returns(current_from_filesystem).then.
+        returns(current_from_filesystem)
+
+      # there should be no audit change recorded, despite the
+      # slight difference in the two timestamps
+      status = @harness.evaluate(resource)
+      status.events.each do |event|
+        event.message.should_not =~ /audit change: previously recorded/
+      end
+    end
   end
 
   describe "when applying changes" do

data/spec/unit/transaction_spec.rb

@@ -37,7 +37,8 @@ describe Puppet::Transaction do
   # This will basically only ever be used during testing.
   it "should automatically create resource statuses if asked for a non-existent status" do
     resource = Puppet::Type.type(:notify).new :title => "foobar"
-    @transaction.resource_status(resource).should be_instance_of(Puppet::Resource::Status)
+    transaction = transaction_with_resource(resource)
+    transaction.resource_status(resource).should be_instance_of(Puppet::Resource::Status)
   end
 
   it "should add provided resource statuses to its report" do
@@ -72,15 +73,15 @@ describe Puppet::Transaction do
 
   describe "when initializing" do
     it "should create an event manager" do
-      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
-      @transaction.event_manager.should be_instance_of(Puppet::Transaction::EventManager)
-      @transaction.event_manager.transaction.should equal(@transaction)
+      transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
+      transaction.event_manager.should be_instance_of(Puppet::Transaction::EventManager)
+      transaction.event_manager.transaction.should equal(transaction)
     end
 
     it "should create a resource harness" do
-      @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
-      @transaction.resource_harness.should be_instance_of(Puppet::Transaction::ResourceHarness)
-      @transaction.resource_harness.transaction.should equal(@transaction)
+      transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new, nil, nil)
+      transaction.resource_harness.should be_instance_of(Puppet::Transaction::ResourceHarness)
+      transaction.resource_harness.transaction.should equal(transaction)
     end
 
     it "should set retrieval time on the report" do
@@ -95,29 +96,25 @@ describe Puppet::Transaction do
   end
 
   describe "when evaluating a resource" do
-    before do
-      @catalog = Puppet::Resource::Catalog.new
-      @resource = Puppet::Type.type(:file).new :path => @basepath
-      @catalog.add_resource(@resource)
-
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
-      @transaction.stubs(:skip?).returns false
-    end
+    let(:resource) { Puppet::Type.type(:file).new :path => @basepath }
 
     it "should process events" do
-      @transaction.event_manager.expects(:process_events).with(@resource)
+      transaction = transaction_with_resource(resource)
 
-      @transaction.evaluate
+      transaction.expects(:skip?).with(resource).returns false
+      transaction.event_manager.expects(:process_events).with(resource)
+
+      transaction.evaluate
     end
 
     describe "and the resource should be skipped" do
-      before do
-        @transaction.expects(:skip?).with(@resource).returns true
-      end
-
       it "should mark the resource's status as skipped" do
-        @transaction.evaluate
-        @transaction.resource_status(@resource).should be_skipped
+        transaction = transaction_with_resource(resource)
+
+        transaction.expects(:skip?).with(resource).returns true
+
+        transaction.evaluate
+        transaction.resource_status(resource).should be_skipped
       end
     end
   end
@@ -288,6 +285,9 @@ describe Puppet::Transaction do
     before :each do
       catalog.add_resource generator
       generator.stubs(:generate).returns generated
+      # avoid crude failures because of nil resources that result
+      # from implicit containment and lacking containers
+      catalog.stubs(:container_of).returns generator
     end
 
     it "should call 'generate' on all created resources" do
@@ -313,6 +313,31 @@ describe Puppet::Transaction do
     end
   end
 
+  describe "when performing pre-run checks" do
+    let(:resource) { Puppet::Type.type(:notify).new(:title => "spec") }
+    let(:transaction) { transaction_with_resource(resource) }
+    let(:spec_exception) { 'spec-exception' }
+
+    it "should invoke each resource's hook and apply the catalog after no failures" do
+      resource.expects(:pre_run_check)
+
+      transaction.evaluate
+    end
+
+    it "should abort the transaction on failure" do
+      resource.expects(:pre_run_check).raises(Puppet::Error, spec_exception)
+
+      expect { transaction.evaluate }.to raise_error(Puppet::Error, /Some pre-run checks failed/)
+    end
+
+    it "should log the resource-specific exception" do
+      resource.expects(:pre_run_check).raises(Puppet::Error, spec_exception)
+      resource.expects(:log_exception).with(responds_with(:message, spec_exception))
+
+      expect { transaction.evaluate }.to raise_error(Puppet::Error)
+    end
+  end
+
   describe "when skipping a resource" do
     before :each do
       @resource = Puppet::Type.type(:notify).new :name => "foo"
@@ -478,44 +503,70 @@ describe Puppet::Transaction do
   end
 
   describe "during teardown" do
+    let(:catalog) { Puppet::Resource::Catalog.new }
+    let(:transaction) do
+      Puppet::Transaction.new(catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+    end
+
+    let(:teardown_type) do
+      Puppet::Type.newtype(:teardown_test) do
+        newparam(:name) {}
+      end
+    end
+
     before :each do
-      @catalog = Puppet::Resource::Catalog.new
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
+      teardown_type.provide(:teardown_provider) do
+        class << self
+          attr_reader :result
+
+          def post_resource_eval
+            @result = 'passed'
+          end
+        end
+      end
     end
 
     it "should call ::post_resource_eval on provider classes that support it" do
-      @resource = Puppet::Type.type(:notify).new :title => "foo"
-      @catalog.add_resource @resource
+      resource = teardown_type.new(:title => "foo", :provider => :teardown_provider)
 
-      # 'expects' will cause 'respond_to?(:post_resource_eval)' to return true
-      @resource.provider.class.expects(:post_resource_eval)
-      @transaction.evaluate
+      transaction = transaction_with_resource(resource)
+      transaction.evaluate
+
+      expect(resource.provider.class.result).to eq('passed')
     end
 
     it "should call ::post_resource_eval even if other providers' ::post_resource_eval fails" do
-      @resource3 = Puppet::Type.type(:user).new :title => "bloo"
-      @resource3.provider.class.stubs(:post_resource_eval).raises
-      @resource4 = Puppet::Type.type(:notify).new :title => "blob"
-      @resource4.provider.class.stubs(:post_resource_eval).raises
-      @catalog.add_resource @resource3
-      @catalog.add_resource @resource4
-
-      # ruby's Set does not guarantee ordering, so both resource3 and resource4
-      # need to expect post_resource_eval, rather than just the 'first' one.
-      @resource3.provider.class.expects(:post_resource_eval)
-      @resource4.provider.class.expects(:post_resource_eval)
+      teardown_type.provide(:always_fails) do
+        class << self
+          attr_reader :result
+
+          def post_resource_eval
+            @result = 'failed'
+            raise Puppet::Error, "This provider always fails"
+          end
+        end
+      end
 
-      @transaction.evaluate
+      good_resource = teardown_type.new(:title => "bloo", :provider => :teardown_provider)
+      bad_resource  = teardown_type.new(:title => "blob", :provider => :always_fails)
+
+      catalog.add_resource(bad_resource)
+      catalog.add_resource(good_resource)
+
+      transaction.evaluate
+
+      expect(good_resource.provider.class.result).to eq('passed')
+      expect(bad_resource.provider.class.result).to eq('failed')
     end
 
     it "should call ::post_resource_eval even if one of the resources fails" do
-      @resource3 = Puppet::Type.type(:notify).new :title => "bloo"
-      @resource3.stubs(:retrieve_resource).raises
-      @catalog.add_resource @resource3
+      resource = teardown_type.new(:title => "foo", :provider => :teardown_provider)
+      resource.stubs(:retrieve_resource).raises
+      catalog.add_resource resource
 
-      @resource3.provider.class.expects(:post_resource_eval)
+      resource.provider.class.expects(:post_resource_eval)
 
-      @transaction.evaluate
+      transaction.evaluate
     end
   end