puppet 4.1.0-x64-mingw32 → 4.2.0-x64-mingw32

data/spec/integration/application/apply_spec.rb

@@ -55,16 +55,17 @@ describe "apply" do
 
   it "applies a given file even when an ENC is configured", :if => !Puppet.features.microsoft_windows? do
     manifest = file_containing("manifest.pp", "notice('specific manifest applied')")
-    site_manifest = file_containing("site_manifest.pp", "notice('the site manifest was applied instead')")
-    enc = file_containing("enc_script", "#!/bin/sh\necho 'classes: []'")
-    File.chmod(0755, enc)
+    enc = script_containing('enc_script',
+      :windows => '@echo classes: []' + "\n" + '@echo environment: special',
+      :posix   => '#!/bin/sh' + "\n" + 'echo "classes: []"' + "\n" + 'echo "environment: special"')
+
+    Dir.mkdir(File.join(Puppet[:environmentpath], "special"), 0755)
 
     special = Puppet::Node::Environment.create(:special, [])
     Puppet.override(:current_environment => special) do
       Puppet[:environment] = 'special'
       Puppet[:node_terminus] = 'exec'
       Puppet[:external_nodes] = enc
-      Puppet[:manifest] = site_manifest
       puppet = Puppet::Application[:apply]
       puppet.stubs(:command_line).returns(stub('command_line', :args => [manifest]))
       expect { puppet.run_command }.to exit_with(0)
@@ -110,21 +111,25 @@ describe "apply" do
     end
   end
 
-  context "with a module" do
-    let(:modulepath) { tmpdir('modulepath') }
+  context "with a module in an environment" do
+    let(:envdir) { tmpdir('environments') }
+    let(:modulepath) { File.join(envdir, 'spec', 'modules') }
     let(:execute) { 'include amod' }
-    let(:args) { ['-e', execute, '--modulepath', modulepath] }
 
     before(:each) do
-      dir_contained_in(modulepath, {
-        "amod" => {
-          "manifests" => {
-            "init.pp" => "class amod{ notice('amod class included') }"
+      dir_contained_in(envdir, {
+        "spec" => {
+          "modules" => {
+            "amod" => {
+              "manifests" => {
+                "init.pp" => "class amod{ notice('amod class included') }"
+              }
+            }
           }
         }
       })
 
-      Puppet[:environmentpath] = dir_containing("environments", { Puppet[:environment] => {} })
+      Puppet[:environmentpath] = envdir
     end
 
     def init_cli_args_and_apply_app(args, execute)
@@ -134,31 +139,68 @@ describe "apply" do
       return puppet
     end
 
-    it "looks in --modulepath even when the default directory environment exists" do
-      apply = init_cli_args_and_apply_app(args, execute)
+    context "given the --modulepath option" do
+      let(:args) { ['-e', execute, '--modulepath', modulepath] }
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('amod class included')
-    end
+      it "looks in --modulepath even when the default directory environment exists" do
+        apply = init_cli_args_and_apply_app(args, execute)
 
-    it "looks in --modulepath even when given a specific directory --environment" do
-      args << '--environment' << 'production'
-      apply = init_cli_args_and_apply_app(args, execute)
+        expect do
+          expect { apply.run }.to exit_with(0)
+        end.to have_printed('amod class included')
+      end
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('amod class included')
+      it "looks in --modulepath even when given a specific directory --environment" do
+        args << '--environment' << 'production'
+        apply = init_cli_args_and_apply_app(args, execute)
+
+        expect do
+          expect { apply.run }.to exit_with(0)
+        end.to have_printed('amod class included')
+      end
+
+      it "looks in --modulepath when given multiple paths in --modulepath" do
+        args = ['-e', execute, '--modulepath', [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)]
+        apply = init_cli_args_and_apply_app(args, execute)
+
+        expect do
+          expect { apply.run }.to exit_with(0)
+        end.to have_printed('amod class included')
+      end
     end
 
-    it "looks in --modulepath when given multiple paths in --modulepath" do
-      args = ['-e', execute, '--modulepath', [tmpdir('notmodulepath'), modulepath].join(File::PATH_SEPARATOR)]
-      apply = init_cli_args_and_apply_app(args, execute)
+    # When executing an ENC script, output cannot be captured using
+    # expect { }.to have_printed(...)
+    # External node script execution will fail, likely due to the tampering
+    # with the basic file descriptors.
+    # Workaround: Define a log destination and merely inspect logs.
+    context "with an ENC" do
+      let(:logdest) { tmpfile('logdest') }
+      let(:args) { ['-e', execute, '--logdest', logdest ] }
+      let(:enc) do
+        script_containing('enc_script',
+          :windows => '@echo environment: spec',
+          :posix   => '#!/bin/sh' + "\n" + 'echo "environment: spec"')
+      end
 
-      expect do
+      before :each do
+        Puppet[:node_terminus] = 'exec'
+        Puppet[:external_nodes] = enc
+      end
+
+      it "should use the environment that the ENC mandates" do
+        apply = init_cli_args_and_apply_app(args, execute)
         expect { apply.run }.to exit_with(0)
-      end.to have_printed('amod class included')
+        expect(@logs.map(&:to_s)).to include('amod class included')
+      end
+
+      it "should prefer the ENC environment over the configured one and emit a warning" do
+        apply = init_cli_args_and_apply_app(args + [ '--environment', 'production' ], execute)
+        expect { apply.run }.to exit_with(0)
+        logs = @logs.map(&:to_s)
+        expect(logs).to include('amod class included')
+        expect(logs).to include(match(/doesn't match server specified environment/))
+      end
     end
   end
-
 end

data/spec/integration/indirector/facts/facter_spec.rb

@@ -78,4 +78,42 @@ describe Puppet::Node::Facts::Facter do
                              Puppet::Node.indirection.find('foo'))
     expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
   end
+
+  it "the agent_specified_environment fact is nil when not set" do
+    expect do
+      compile_to_catalog('notify { $::agent_specified_environment: }',
+                         Puppet::Node.indirection.find('foo'))
+    end.to raise_error(Puppet::PreformattedError)
+  end
+
+  it "adds the agent_specified_environment fact when set in puppet.conf" do
+    FileUtils.mkdir_p(Puppet[:confdir])
+    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
+      f.puts("environment=bar")
+    end
+
+    Puppet.initialize_settings
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[bar]")).to be
+  end
+
+  it "adds the agent_specified_environment fact when set via command-line" do
+    Puppet.initialize_settings(['--environment', 'bar'])
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[bar]")).to be
+  end
+
+  it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
+    FileUtils.mkdir_p(Puppet[:confdir])
+    File.open(File.join(Puppet[:confdir], 'puppet.conf'), 'w') do |f|
+      f.puts("environment=bar")
+    end
+
+    Puppet.initialize_settings(['--environment', 'baz'])
+    cat = compile_to_catalog('notify { $::agent_specified_environment: }',
+                             Puppet::Node.indirection.find('foo'))
+    expect(cat.resource("Notify[baz]")).to be
+  end
 end

data/spec/integration/parser/scope_spec.rb

@@ -34,7 +34,6 @@ describe "Two step scoping for variables" do
         MANIFEST
       end.to raise_error(/The operator '-=' is no longer supported/)
     end
-  end
 
     it "issues error about built-in variable when reassigning to name" do
         enc_node = Puppet::Node.new("the_node", { :parameters => {  } })
@@ -112,7 +111,26 @@ describe "Two step scoping for variables" do
           class bar inherits bar_bamama {
             notify { 'something': message => inline_template("<%= @var %>"), }
           }
-      MANIFEST
+        MANIFEST
+      end
+    end
+
+    describe 'handles 3.x/4.x functions' do
+      it 'can call a 3.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("fqdn_rand", [30]).to_i <= 30 ? "yes" : "no" %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
+
+      it 'it can call a 4.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("with", ["yes"]) { |x| x } %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
     end
   end
 

data/spec/integration/provider/mount_spec.rb

@@ -22,9 +22,9 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
     Facter.stubs(:value).with(:hostname).returns('some_host')
     Facter.stubs(:value).with(:domain).returns('some_domain')
-    Facter.stubs(:value).with(:kernel).returns('Darwin')
-    Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
-    Facter.stubs(:value).with(:osfamily).returns('Darwin')
+    Facter.stubs(:value).with(:kernel).returns('Linux')
+    Facter.stubs(:value).with(:operatingsystem).returns('RedHat')
+    Facter.stubs(:value).with(:osfamily).returns('RedHat')
     Puppet::Util::ExecutionStub.set do |command, options|
       case command[0]
       when %r{/s?bin/mount}
@@ -35,24 +35,7 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
             ''
           end
         else
-          expect(command.length).to eq(4)
-          expect(command[1]).to eq('-o')
-
-          # update is a special option, used on bsd's
-          # strip it out and track as a local bool here
-          update = false
-          tmp_options = command[2].split(",")
-
-          if tmp_options.include?("update")
-            update = true
-            tmp_options.delete("update")
-          end
-          @current_options = tmp_options.join(",")
-
-          if !update
-            expect(@mounted).to eq(false) # verify that we don't try to call "mount" redundantly
-          end
-          expect(command[3]).to eq('/Volumes/foo_disk')
+          expect(command.last).to eq('/Volumes/foo_disk')
           @current_device = check_fstab(true)
           @mounted = true
           ''
@@ -123,27 +106,31 @@ describe "mount provider (integration)", :unless => Puppet.features.microsoft_wi
             end
             expected_fstab_data = (ensure_setting != :absent)
             describe "When setting ensure => #{ensure_setting}" do
-              ["local", "journaled"].each do |options_setting|
-                describe "When setting options => #{options_setting}" do
+              ["local", "journaled", "", nil].each do |options_setting|
+                describe "When setting options => '#{options_setting}'" do
                   it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
                     if family == "Solaris"
                       skip("Solaris: The mock :operatingsystem value does not get changed in lib/puppet/provider/mount/parsed.rb")
                     else
-                      @desired_options = options_setting
-                      run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
-                      expect(@mounted).to eq(expected_final_state)
-                      if expected_fstab_data
-                        expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
+                      if options_setting && options_setting.empty?
+                        expect { run_in_catalog(:ensure=>ensure_setting, :options => options_setting) }.to raise_error Puppet::ResourceError
                       else
-                        expect(check_fstab(expected_fstab_data)).to eq(nil)
-                      end
-                      if @mounted
-                        if ![:defined, :present].include?(ensure_setting)
-                          expect(@current_options).to eq(@desired_options)
-                        elsif initial_fstab_entry
-                          expect(@current_options).to eq(@desired_options)
+                        if options_setting
+                          @desired_options = options_setting
+                          run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
+                        else
+                          if initial_fstab_entry
+                            @desired_options = @current_options
+                          else
+                            @desired_options = 'defaults'
+                          end
+                          run_in_catalog(:ensure=>ensure_setting)
+                        end
+                        expect(@mounted).to eq(expected_final_state)
+                        if expected_fstab_data
+                          expect(check_fstab(expected_fstab_data)).to eq("/dev/disk1s1")
                         else
-                          expect(@current_options).to eq('local') #Workaround for #6645
+                          expect(check_fstab(expected_fstab_data)).to eq(nil)
                         end
                       end
                     end

data/spec/integration/transaction_spec.rb

@@ -352,10 +352,49 @@ describe Puppet::Transaction do
     )
 
     catalog = mk_catalog(exec, file1, file2)
-    catalog.apply
+    transaction = catalog.apply
 
     expect(Puppet::FileSystem.exist?(file1[:path])).to be_falsey
     expect(Puppet::FileSystem.exist?(file2[:path])).to be_falsey
+
+    expect(transaction.resource_status(file1).skipped).to be_truthy
+    expect(transaction.resource_status(file2).skipped).to be_truthy
+
+    expect(transaction.resource_status(file1).failed_dependencies).to eq([exec])
+    expect(transaction.resource_status(file2).failed_dependencies).to eq([exec])
+  end
+
+  it "on failure, skips dynamically-generated dependents" do
+    exec = Puppet::Type.type(:exec).new(
+      :command => "#{File.expand_path('/bin/mkdir')} /this/path/cannot/possibly/exist",
+      :title => "mkdir"
+    )
+
+    tmp = tmpfile("dir1")
+    FileUtils.mkdir_p(tmp)
+    FileUtils.mkdir_p(File.join(tmp, "foo"))
+
+    purge_dir = Puppet::Type.type(:file).new(
+      :title => "dir1",
+      :path => tmp,
+      :require => exec,
+      :ensure => :directory,
+      :recurse => true,
+      :purge => true
+    )
+
+    catalog = mk_catalog(exec, purge_dir)
+    txn = catalog.apply
+
+    expect(txn.resource_status(purge_dir).skipped).to be_truthy
+
+    children = catalog.relationship_graph.direct_dependents_of(purge_dir)
+
+    children.each do |child|
+      expect(txn.resource_status(child).skipped).to be_truthy
+    end
+
+    expect(Puppet::FileSystem.exist?(File.join(tmp, "foo"))).to be_truthy
   end
 
   it "should not trigger subscribing resources on failure" do

data/spec/integration/type/file_spec.rb

@@ -716,6 +716,42 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       end
     end
 
+    it "should not recursively manage files set to be ignored" do
+      srcdir = tmpfile("ignore_vs_recurse_1")
+      dstdir = tmpfile("ignore_vs_recurse_2")
+
+      FileUtils.mkdir_p(srcdir)
+      FileUtils.mkdir_p(dstdir)
+      
+      srcfile = File.join(srcdir, "file.src")
+      cpyfile = File.join(dstdir, "file.src")
+      ignfile = File.join(srcdir, "file.ign")
+      
+      File.open(srcfile, "w") { |f| f.puts "don't ignore me" }
+      File.open(ignfile, "w") { |f| f.puts "you better ignore me" }
+
+
+      catalog.add_resource described_class.new(
+                             :name => srcdir,
+                             :ensure => 'directory',
+                             :mode => '0755',)
+      
+      catalog.add_resource described_class.new(
+                             :name => dstdir,
+                             :ensure => 'directory',
+                             :mode => "755",
+                             :source => srcdir,
+                             :recurse => true,
+                             :ignore => '*.ign',)
+      
+      catalog.apply
+      expect(Puppet::FileSystem.exist?(srcdir)).to be_truthy
+      expect(Puppet::FileSystem.exist?(dstdir)).to be_truthy
+      expect(File.read(srcfile).strip).to eq("don't ignore me")
+      expect(File.read(cpyfile).strip).to eq("don't ignore me")
+      expect(Puppet::FileSystem.exist?("#{dstdir}/file.ign")).to be_falsey
+    end
+
     it "should not recursively manage files managed by a more specific explicit file" do
       dir = tmpfile("recursion_vs_explicit_1")
 

data/spec/integration/type/package_spec.rb

@@ -125,3 +125,68 @@ describe Puppet::Type.type(:package), "when packages with the same name are sour
   end
 end
 
+describe Puppet::Type.type(:package), 'logging package state transitions' do
+
+  let(:catalog) { Puppet::Resource::Catalog.new }
+  let(:provider) { stub('provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :validate_source => nil) }
+
+  before :each do
+    provider.stubs(:satisfies?).with([:purgeable]).returns(true)
+    provider.class.stubs(:instances).returns([])
+    provider.stubs(:install).returns nil
+    provider.stubs(:uninstall).returns nil
+    provider.stubs(:purge).returns nil
+    Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(provider)
+  end
+
+  after :each do
+    Puppet::Type.type(:package).defaultprovider = nil
+  end
+
+  # Map of old state -> {new state -> change}
+  states = {
+    # 'installed' transitions to 'removed' or 'purged'
+    :installed => {
+      :installed => nil,
+      :absent    => 'removed',
+      :purged    => 'purged'
+    },
+    # 'absent' transitions to 'created' or 'purged'
+    :absent => {
+      :installed => 'created',
+      :absent    => nil,
+      :purged    => 'purged'
+    },
+    # 'purged' transitions to 'created'
+    :purged => {
+      :installed => 'created',
+      :absent    => nil,
+      :purged    => nil
+    }
+  }
+
+  states.each do |old, new_states|
+    describe "#{old} package" do
+
+      before :each do
+        provider.stubs(:properties).returns(:ensure => old)
+      end
+
+      new_states.each do |new, status|
+        it "ensure => #{new} should log #{status ? status : 'nothing'}" do
+          catalog.add_resource(described_class.new(:name => 'yay', :ensure => new))
+          catalog.apply
+
+          logs = catalog.apply.report.logs
+          if status
+            expect(logs.first.source).to eq("/Package[yay]/ensure")
+            expect(logs.first.message).to eq(status)
+          else
+            expect(logs.first).to be_nil
+          end
+        end
+      end
+    end
+  end
+end
+