puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/spec/unit/daemon_spec.rb

@@ -45,15 +45,24 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
   end
 
   describe "when setting signal traps" do
-    signals = {:INT => :stop, :TERM => :stop }
-    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}) unless Puppet.features.microsoft_windows?
-    signals.each do |signal, method|
-      it "should log and call #{method} when it receives #{signal}" do
-        Signal.expects(:trap).with(signal).yields
+    [:INT, :TERM].each do |signal|
+      it "logs a notice and exits when sent #{signal}" do
+        Signal.stubs(:trap).with(signal).yields
+        Puppet.expects(:notice).with("Caught #{signal}; exiting")
+        daemon.expects(:stop)
 
-        Puppet.expects(:notice)
+        daemon.set_signal_traps
+      end
+    end
+
+    {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
+      it "logs a notice and remembers to call #{method} when it receives #{signal}" do
+        Signal.stubs(:trap).with(signal).yields
+        Puppet.expects(:notice).with("Caught #{signal}; storing #{method}")
 
         daemon.set_signal_traps
+
+        expect(daemon.signals).to eq([method])
       end
     end
   end
@@ -176,7 +185,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should do nothing if the agent is running" do
-      agent.expects(:running?).returns true
+      agent.expects(:run).with({:splay => false}).raises Puppet::LockError, 'Failed to aquire lock'
+      Puppet.expects(:notice).with('Not triggering already-running agent')
 
       daemon.agent = agent
 
@@ -184,8 +194,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should run the agent if one is available and it is not running" do
-      agent.expects(:running?).returns false
       agent.expects(:run).with({:splay => false})
+      Puppet.expects(:notice).with('Not triggering already-running agent').never
 
       daemon.agent = agent
 

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -0,0 +1,201 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "when using a hiera data provider" do
+  include PuppetSpec::Compiler
+
+  # There is a fully configured 'sample' environment in fixtures at this location
+  let(:environmentpath) { parent_fixture('environments') }
+
+  let(:facts) { Puppet::Node::Facts.new("facts", {}) }
+
+  around(:each) do |example|
+    # Initialize settings to get a full compile as close as possible to a real
+    # environment load
+    Puppet.settings.initialize_global_settings
+    # Initialize loaders based on the environmentpath. It does not work to
+    # just set the setting environmentpath for some reason - this achieves the same:
+    # - first a loader is created, loading directory environments from the fixture (there is
+    # one environment, 'sample', which will be loaded since the node references this
+    # environment by name).
+    # - secondly, the created env loader is set as 'environments' in the puppet context.
+    #
+    loader = Puppet::Environments::Directories.new(environmentpath, [])
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  def compile_and_get_notifications(environment, code = nil)
+    compile(environment, code).resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+  end
+
+  def compile(environment, code = nil)
+    Puppet[:code] = code if code
+    node = Puppet::Node.new("testnode", :facts => facts, :environment => environment)
+    compiler = Puppet::Parser::Compiler.new(node)
+    block_given? ? compiler.compile() { |catalog| yield(compiler); catalog } : compiler.compile()
+  end
+
+  it 'uses default configuration for environment and module data' do
+    resources = compile_and_get_notifications('hiera_defaults')
+    expect(resources).to include('module data param_a is 100, param default is 200, env data param_c is 300')
+  end
+
+  it 'reads hiera.yaml in environment root and configures multiple json and yaml providers' do
+    resources = compile_and_get_notifications('hiera_env_config')
+    expect(resources).to include('env data param_a is 10, env data param_b is 20, env data param_c is 30, env data param_d is 40, env data param_e is 50')
+  end
+
+  it 'reads hiera.yaml in module root and configures multiple json and yaml providers' do
+    resources = compile_and_get_notifications('hiera_module_config')
+    expect(resources).to include('module data param_a is 100, module data param_b is 200, module data param_c is 300, module data param_d is 400, module data param_e is 500')
+  end
+
+  it 'does not perform merge of values declared in environment and module when resolving parameters' do
+    resources = compile_and_get_notifications('hiera_misc')
+    expect(resources).to include('env 1, ')
+  end
+
+  it 'performs hash merge of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(one::test::param, Hash[String,String], hash) notify{"${r[key1]}, ${r[key2]}":}')
+    expect(resources).to include('env 1, module 2')
+  end
+
+  it 'performs unique merge of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(one::array, Array[String], unique) notify{"${r}":}')
+    expect(resources.size).to eq(1)
+    expect(resources[0][1..-2].split(', ')).to contain_exactly('first', 'second', 'third', 'fourth')
+  end
+
+  it 'performs merge found in lookup_options in environment of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', 'include one::lopts_test')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('A, B, C, MA, MB, MC')
+  end
+
+  it 'performs merge found in lookup_options in module of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', 'include one::loptsm_test')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('A, B, C, MA, MB, MC')
+  end
+
+  it "can lookup the 'lookup_options' hash as a regular value" do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(lookup_options, Hash[String,Hash[String,String]], hash) notify{"${r[one::lopts_test::hash][merge]}":}')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('deep')
+  end
+
+  it 'does find unqualified keys in the environment' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(ukey1):}')
+    expect(resources).to include('Some value')
+  end
+
+  it 'does not find unqualified keys in the module' do
+    expect do
+      compile_and_get_notifications('hiera_misc', 'notify{lookup(ukey2):}')
+    end.to raise_error(Puppet::ParseError, /did not find a value for the name 'ukey2'/)
+  end
+
+  it 'can use interpolation lookup method "alias"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_alias):}')
+    expect(resources).to include('Value from interpolation with alias')
+  end
+
+  it 'can use interpolation lookup method "lookup"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_lookup):}')
+    expect(resources).to include('Value from interpolation with lookup')
+  end
+
+  it 'can use interpolation lookup method "hiera"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_hiera):}')
+    expect(resources).to include('Value from interpolation with hiera')
+  end
+
+  it 'can use interpolation lookup method "literal"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_literal):}')
+    expect(resources).to include('Value from interpolation with literal')
+  end
+
+  it 'can use interpolation lookup method "scope"' do
+    resources = compile_and_get_notifications('hiera_misc', '$target_scope = "with scope" notify{lookup(km_scope):}')
+    expect(resources).to include('Value from interpolation with scope')
+  end
+
+  it 'can use interpolation using default lookup method (scope)' do
+    resources = compile_and_get_notifications('hiera_misc', '$target_default = "with default" notify{lookup(km_default):}')
+    expect(resources).to include('Value from interpolation with default')
+  end
+
+  it 'performs lookup using qualified expressions in interpolation' do
+    resources = compile_and_get_notifications('hiera_misc', "$os = { name => 'Fedora' } notify{lookup(km_qualified):}")
+    expect(resources).to include('Value from qualified interpolation OS = Fedora')
+  end
+
+  it 'can have multiple interpolate expressions in one value' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_multi):}')
+    expect(resources).to include('cluster/%{::cluster}/%{role}')
+  end
+
+  it 'performs single quoted interpolation' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_sqalias):}')
+    expect(resources).to include('Value from interpolation with alias')
+  end
+
+  it 'traps endless interpolate recursion' do
+    expect do
+      compile_and_get_notifications('hiera_misc', '$r1 = "%{r2}" $r2 = "%{r1}" notify{lookup(recursive):}')
+    end.to raise_error(Puppet::DataBinding::RecursiveLookupError, /detected in \[recursive, r1, r2\]/)
+  end
+
+  it 'traps bad alias declarations' do
+    expect do
+      compile_and_get_notifications('hiera_misc', "$r1 = 'Alias within string %{alias(\"r2\")}' $r2 = '%{r1}' notify{lookup(recursive):}")
+    end.to raise_error(Puppet::DataBinding::LookupError, /'alias' interpolation is only permitted if the expression is equal to the entire string/)
+  end
+
+  it 'reports syntax errors for JSON files' do
+    expect do
+      compile_and_get_notifications('hiera_bad_syntax_json')
+    end.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse \(#{environmentpath}[^)]+\):/)
+  end
+
+  it 'reports syntax errors for YAML files' do
+    expect do
+      compile_and_get_notifications('hiera_bad_syntax_yaml')
+    end.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse \(#{environmentpath}[^)]+\):/)
+  end
+
+  describe 'when using explain' do
+    it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        value = Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "km_scope"
+  Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/hiera_misc/hiera.yaml"
+    Data Provider "common"
+      Path "#{environmentpath}/hiera_misc/data/common.yaml"
+        Original path: common
+        Interpolation on "Value from interpolation %{scope("target_scope")}"
+          Global Scope"
+            Found key: "target_scope" value: "with scope"
+        Found key: "km_scope" value: "Value from interpolation with scope"
+  Merged result: "Value from interpolation with scope"
+EOS
+      end
+    end
+  end
+  def parent_fixture(dir_name)
+    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
+  end
+
+  def resources_in(catalog)
+    catalog.resources.map(&:ref)
+  end
+
+end

data/spec/unit/file_bucket/dipper_spec.rb

@@ -72,6 +72,216 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
 
+  describe "when diffing on a local filebucket" do
+    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+      with_digest_algorithms do
+
+        it "should fail in an informative way when one or more checksum doesn't exists" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          wrong_checksum = "DEADBEEF"
+
+          # First checksum fails
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Invalid checksum #{wrong_checksum.inspect}")
+
+          file = make_tmp_file(plaintext)
+          @dipper.backup(file)
+
+          #Diff_with checksum fails
+          expect { @dipper.diff(checksum, wrong_checksum, nil, nil) }.to raise_error(RuntimeError, "could not find diff_with #{wrong_checksum}")
+        end
+
+        it "should properly diff files on the filebucket" do
+          file1 = make_tmp_file("OriginalContent")
+          file2 = make_tmp_file("ModifiedContent")
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          checksum1 = @dipper.backup(file1)
+          checksum2 = @dipper.backup(file2)
+
+          # Diff without the context
+          diff12 = `diff -uN #{file1} #{file2} | sed '1,2d'`
+          diff21 = `diff -uN #{file2} #{file1} | sed '1,2d'`
+
+          expect(@dipper.diff(checksum1, checksum2, nil, nil)).to include(diff12)
+          expect(@dipper.diff(checksum1, nil, nil, file2)).to include(diff12)
+          expect(@dipper.diff(nil, checksum2, file1, nil)).to include(diff12)
+          expect(@dipper.diff(nil, nil, file1, file2)).to include(diff12)
+          expect(@dipper.diff(checksum2, checksum1, nil, nil)).to include(diff21)
+          expect(@dipper.diff(checksum2, nil, nil, file1)).to include(diff21)
+          expect(@dipper.diff(nil, checksum1, file2, nil)).to include(diff21)
+          expect(@dipper.diff(nil, nil, file2, file1)).to include(diff21)
+
+        end
+      end
+      describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+        it "should fail in an informative way when trying to diff" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          wrong_checksum = "DEADBEEF"
+
+          # First checksum fails
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+
+          # Diff_with checksum fails
+          expect { @dipper.diff(checksum, wrong_checksum, nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+        end
+      end
+    end
+  end
+  it "should fail in an informative way when there are failures listing files on the server" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/unexistent/bucket")
+    Puppet::FileBucket::File.indirection.expects(:find).returns nil
+
+    expect { @dipper.list(nil, nil) }.to raise_error(Puppet::Error)
+  end
+
+  describe "listing files in local filebucket" do
+    with_digest_algorithms do
+      it "should list all files present" do
+        Puppet[:bucketdir] =  "/my/bucket"
+        file_bucket = tmpdir("bucket")
+
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+
+        onehour=60*60
+        twohours=onehour*2
+
+        #First File
+        file1 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file1).realpath
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file1)).to eq(checksum)
+        expected_list1_1 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        File.open(file1, 'w') {|f| f.write("Blahhhh")}
+        new_checksum = digest("Blahhhh")
+        expect(@dipper.backup(file1)).to eq(new_checksum)
+        expected_list1_2 = /#{new_checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        #Second File
+        content = "DummyFileWithNonSenseTextInIt"
+        file2 = make_tmp_file(content)
+        real_path = Pathname.new(file2).realpath
+        checksum = digest(content)
+        expect(@dipper.backup(file2)).to eq(checksum)
+        expected_list2 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        #Third file : Same as the first one with a different path
+        file3 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file3).realpath
+        checksum = digest(plaintext)
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file3)).to eq(checksum)
+        date = Time.now
+        expected_list3 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        result = @dipper.list(nil, nil)
+        expect(result).to match(expected_list1_1)
+        expect(result).to match(expected_list1_2)
+        expect(result).to match(expected_list2)
+        expect(result).to match(expected_list3)
+      end
+
+      it "should filter with the provided dates" do
+        Puppet[:bucketdir] =  "/my/bucket"
+        file_bucket = tmpdir("bucket")
+
+        twentyminutes=60*20
+        thirtyminutes=60*30
+        onehour=60*60
+        twohours=onehour*2
+        threehours=onehour*3
+
+        # First File created now
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+        file1 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file1).realpath
+
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file1)).to eq(checksum)
+        expected_list1 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        # Second File created an hour ago
+        content = "DummyFileWithNonSenseTextInIt"
+        file2 = make_tmp_file(content)
+        real_path = Pathname.new(file2).realpath
+        checksum = digest(content)
+        expect(@dipper.backup(file2)).to eq(checksum)
+
+        # Modify mtime of the second file to be an hour ago
+        onehourago = Time.now - onehour
+        bucketed_paths_file = Dir.glob("#{file_bucket}/**/#{checksum}/paths")
+        FileUtils.touch(bucketed_paths_file, :mtime => onehourago)
+        expected_list2 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        now = Time.now
+
+        #Future
+        expect(@dipper.list((now + threehours).strftime("%F %T"), nil )).to eq("")
+
+        #Epoch -> Future = Everything (Sorted (desc) by date)
+        expect(@dipper.list(nil, (now + twohours).strftime("%F %T"))).to match(expected_list1)
+        expect(@dipper.list(nil, (now + twohours).strftime("%F %T"))).to match(expected_list2)
+
+        #Now+1sec -> Future = Nothing
+        expect(@dipper.list((now + 1).strftime("%F %T"), (now + twohours).strftime("%F %T"))).to eq("")
+
+        #Now-30mins -> Now-20mins = Nothing
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), (now - twentyminutes).strftime("%F %T"))).to eq("")
+
+        #Now-2hours -> Now-30mins = Second file only
+        expect(@dipper.list((now - twohours).strftime("%F %T"), (now - thirtyminutes).strftime("%F %T"))).to match(expected_list2)
+        expect(@dipper.list((now - twohours).strftime("%F %T"), (now - thirtyminutes).strftime("%F %T"))).not_to match(expected_list1)
+
+        #Now-30minutes -> Now = First file only
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), now.strftime("%F %T"))).to match(expected_list1)
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), now.strftime("%F %T"))).not_to match(expected_list2)
+      end
+    end
+  end
+
+  describe "when diffing on a remote filebucket" do
+    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+      with_digest_algorithms do
+        it "should fail in an informative way when one or more checksum doesn't exists" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+          wrong_checksum = "DEADBEEF"
+
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns(nil)
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(Puppet::Error, "Failed to diff files")
+
+        end
+
+        it "should properly diff files on the filebucket" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns("Probably valid diff")
+
+          expect(@dipper.diff("checksum1", "checksum2", nil, nil)).to eq("Probably valid diff")
+        end
+      end
+    end
+
+    describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+      it "should fail in an informative way when trying to diff" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+        wrong_checksum = "DEADBEEF"
+
+        expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+
+        expect { @dipper.diff(wrong_checksum, nil, nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+      end
+    end
+  end
+
+  describe "listing files in remote filebucket" do
+    it "is not allowed" do
+      @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port=> "31337")
+
+      expect {
+        @dipper.list(nil, nil)
+      }.to raise_error(Puppet::Error, "Listing remote file buckets is not allowed")
+    end
+  end
+
   describe "backing up and retrieving local files" do
     with_digest_algorithms do
       it "should backup files to a local bucket" do
@@ -173,4 +383,3 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     end
   end
 end
-