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

data/spec/integration/parser/resource_expressions_spec.rb

@@ -167,15 +167,15 @@ describe "Puppet resource expressions" do
     produces("notify{title:}; Notify[title] { * => { message => set}}" => "Notify[title][message] == 'set'")
     produces("Notify { * => { message => set}}; notify{title:}"      => "Notify[title][message] == 'set'")
 
-    fails("notify { title: unknown => value }" => /Invalid parameter: 'unknown'/)
+    fails("notify { title: unknown => value }" => /no parameter named 'unknown'/)
 
     # this really needs to be a better error message.
-    fails("notify { title: * => { hash => value }, message => oops }" => /Invalid parameter: 'hash'/)
+    fails("notify { title: * => { hash => value }, message => oops }" => /no parameter named 'hash'/)
 
     # should this be a better error message?
-    fails("notify { title: message => oops, * => { hash => value } }" => /Invalid parameter: 'hash'/)
+    fails("notify { title: message => oops, * => { hash => value } }" => /no parameter named 'hash'/)
 
-    fails("notify { title: * => { unknown => value } }" => /Invalid parameter: 'unknown'/)
+    fails("notify { title: * => { unknown => value } }" => /no parameter named 'unknown'/)
     fails("
          $x = { mode => '0666' }
          $y = { owner => the_y }

data/spec/integration/parser/undef_param_spec.rb

@@ -78,7 +78,7 @@ describe "Parameter passing" do
   end
 
   it "errors when no parameter is provided and there is no default" do
-    expect_puppet_error(/^Must pass x to A\[a\].*/) do <<-MANIFEST
+    expect_puppet_error(/A\[a\]: expects a value for parameter 'x'/) do <<-MANIFEST
         define a($x) { notify { 'something': message => $x }}
         a {'a': }
     MANIFEST

data/spec/integration/resource/catalog_spec.rb

@@ -35,7 +35,7 @@ describe Puppet::Resource::Catalog do
       node.stub_everything
 
       Puppet::Node.indirection.expects(:find).returns(node)
-      compiler.expects(:compile).with(node).returns nil
+      compiler.expects(:compile).with(node, anything).returns nil
 
       expect(Puppet::Resource::Catalog.indirection.find("me")).to be_nil
     end

data/spec/integration/type/package_spec.rb

@@ -54,6 +54,7 @@ end
 
 describe Puppet::Type.type(:package), "when packages with the same name are sourced" do
   before :each do
+    Process.stubs(:euid).returns 0
     @provider = stub(
       'provider',
       :class           => Puppet::Type.type(:package).defaultprovider,
@@ -131,6 +132,7 @@ describe Puppet::Type.type(:package), 'logging package state transitions' do
   let(:provider) { stub('provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :validate_source => nil) }
 
   before :each do
+    Process.stubs(:euid).returns 0
     provider.stubs(:satisfies?).with([:purgeable]).returns(true)
     provider.class.stubs(:instances).returns([])
     provider.stubs(:install).returns nil

data/spec/integration/util/windows/security_spec.rb

@@ -238,6 +238,24 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
               expect(ace.mask).to eq(klass::FILE_ALL_ACCESS)
               expect(ace).not_to be_inherited
             end
+
+            if Puppet::FileSystem.directory?(path)
+              system_aces.each do |ace|
+                expect(ace).to be_object_inherit
+                expect(ace).to be_container_inherit
+              end
+
+              # it's critically important that this file be default created
+              # and that this file not have it's owner / group / mode set by winsec
+              nested_file = File.join(path, 'nested_file')
+              File.new(nested_file, 'w').close
+
+              system_aces = winsec.get_aces_for_path_by_sid(nested_file, sids[:system])
+              # even when SYSTEM is the owner (in CI), there should be an inherited SYSTEM
+              expect(system_aces.any? do |ace|
+                ace.mask == klass::FILE_ALL_ACCESS && ace.inherited?
+              end).to be_truthy
+            end
           end
 
           describe "for modes that require deny aces" do

data/spec/lib/matchers/include_in_order.rb

@@ -11,10 +11,10 @@ RSpec::Matchers.define :include_in_order do |*expected|
   end
 
   def failure_message
-    "expected #{@actual.inspect} to include#{expected_to_sentence} in order"
+    "expected #{@actual.inspect} to include#{expected} in order"
   end
 
   def failure_message_when_negated
-    "expected #{@actual.inspect} not to include#{expected_to_sentence} in order"
+    "expected #{@actual.inspect} not to include#{expected} in order"
   end
 end

data/spec/shared_behaviours/iterative_functions.rb

@@ -22,25 +22,25 @@ shared_examples_for 'all iterative functions argument checks' do |func|
   it 'raises an error when called with any parameters besides a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1) |$v| {  }
+        [1].#{func}(1,2) |$v,$y| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*arg count \{3\}/m)
+    end.to raise_error(Puppet::Error, /expects (?:between 1 and 2 arguments|1 argument), got 3/)
   end
 
   it 'raises an error when called without a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}()
+        [1].#{func}
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*arg count \{1\}/m)
+    end.to raise_error(Puppet::Error, /expects a block/)
   end
 
   it 'raises an error when called with something that is not a block' do
     expect do
       compile_to_catalog(<<-MANIFEST)
-        [1].#{func}(1)
+        [1].#{func}(1,2)
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*Callable.*actual(?!Callable\)).*/m)
+    end.to raise_error(Puppet::Error, /expects (?:between 1 and 2 arguments|1 argument), got 3/)
   end
 
   it 'raises an error when called with a block with too many required parameters' do
@@ -48,7 +48,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
       compile_to_catalog(<<-MANIFEST)
         [1].#{func}() |$v1, $v2, $v3| {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*Callable\[Any, Any, Any\]/m)
+    end.to raise_error(Puppet::Error, /block expects(?: between 1 and)? 2 arguments, got 3/)
   end
 
   it 'raises an error when called with a block with too few parameters' do
@@ -56,7 +56,7 @@ shared_examples_for 'all iterative functions argument checks' do |func|
       compile_to_catalog(<<-MANIFEST)
         [1].#{func}() | | {  }
       MANIFEST
-    end.to raise_error(Puppet::Error, /mis-matched arguments.*expected.*arg count \{2\}.*actual.*Callable\[0, 0\]/m)
+    end.to raise_error(Puppet::Error, /block expects(?: between 1 and)? 2 arguments, got none/)
   end
 
   it 'does not raise an error when called with a block with too many but optional arguments' do

data/spec/spec_helper.rb

@@ -43,6 +43,13 @@ Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
   require behaviour.relative_path_from(Pathname.new(dir))
 end
 
+require 'vcr'
+VCR.configure do |vcr|
+  vcr.cassette_library_dir = File.expand_path('vcr/cassettes', PuppetSpec::FIXTURE_DIR)
+  vcr.hook_into :webmock
+  vcr.configure_rspec_metadata!
+end
+
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 

data/spec/unit/agent/locker_spec.rb

@@ -58,17 +58,17 @@ describe Puppet::Agent::Locker do
     expect(@locker.lock { :result }).to eq(:result)
   end
 
-  it "should return nil when the lock method does not receive the lock" do
+  it "should raise LockError when the lock method does not receive the lock" do
     @locker.send(:lockfile).expects(:lock).returns false
 
-    expect(@locker.lock {}).to be_nil
+    expect { @locker.lock {} }.to raise_error(Puppet::LockError)
   end
 
   it "should not yield when the lock method does not receive the lock" do
     @locker.send(:lockfile).expects(:lock).returns false
 
     yielded = false
-    @locker.lock { yielded = true }
+    expect { @locker.lock { yielded = true } }.to raise_error(Puppet::LockError)
     expect(yielded).to be_falsey
   end
 
@@ -76,7 +76,7 @@ describe Puppet::Agent::Locker do
     @locker.send(:lockfile).expects(:lock).returns false
     @locker.send(:lockfile).expects(:unlock).never
 
-    @locker.lock {}
+    expect { @locker.lock {} }.to raise_error(Puppet::LockError)
   end
 
   it "should unlock after yielding upon obtaining a lock" do

data/spec/unit/agent_spec.rb

@@ -58,7 +58,6 @@ describe Puppet::Agent do
 
     client.expects(:run)
 
-    @agent.stubs(:running?).returns false
     @agent.stubs(:disabled?).returns false
     @agent.run
   end
@@ -75,7 +74,6 @@ describe Puppet::Agent do
   describe "when being run" do
     before do
       AgentTestClient.stubs(:lockfile_path).returns "/my/lock"
-      @agent.stubs(:running?).returns false
       @agent.stubs(:disabled?).returns false
     end
 
@@ -85,12 +83,6 @@ describe Puppet::Agent do
       @agent.run
     end
 
-    it "should do nothing if already running" do
-      @agent.expects(:running?).returns true
-      AgentTestClient.expects(:new).never
-      @agent.run
-    end
-
     it "should do nothing if disabled" do
       @agent.expects(:disabled?).returns(true)
       AgentTestClient.expects(:new).never

data/spec/unit/application/agent_spec.rb

@@ -197,6 +197,11 @@ describe Puppet::Application::Agent do
       Puppet.stubs(:settraps)
     end
 
+    it "should not run with extra arguments" do
+      @puppetd.command_line.stubs(:args).returns(%w{disable})
+      expect{@puppetd.setup}.to raise_error ArgumentError, /does not take parameters/
+    end
+
     describe "with --test" do
       it "should call setup_test" do
         @puppetd.options[:test] = true

data/spec/unit/application/apply_spec.rb

@@ -470,4 +470,12 @@ describe Puppet::Application::Apply do
       @apply.send(:apply_catalog, catalog)
     end
   end
+
+  it "should honor the catalog_cache_terminus setting" do
+    Puppet.settings[:catalog_cache_terminus] = "json"
+    Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:json)
+
+    @apply.initialize_app_defaults
+    @apply.setup
+  end
 end

data/spec/unit/application/filebucket_spec.rb

@@ -21,7 +21,15 @@ describe Puppet::Application::Filebucket do
     expect(@filebucket).to respond_to(:restore)
   end
 
-  [:bucket, :debug, :local, :remote, :verbose].each do |option|
+  it "should declare a diff command" do
+    expect(@filebucket).to respond_to(:diff)
+  end
+
+  it "should declare a list command" do
+    expect(@filebucket).to respond_to(:list)
+  end
+
+  [:bucket, :debug, :local, :remote, :verbose, :fromdate, :todate].each do |option|
     it "should declare handle_#{option} method" do
       expect(@filebucket).to respond_to("handle_#{option}".to_sym)
     end
@@ -201,6 +209,84 @@ describe Puppet::Application::Filebucket do
       end
     end
 
+    describe "the command diff" do
+      it "should call the client diff method with 2 given checksums" do
+        md5a="DEADBEEF"
+        md5b="BEEF"
+        Puppet::FileSystem.stubs(:exist?).returns(false)
+        @filebucket.stubs(:args).returns([md5a, md5b])
+
+        @client.expects(:diff).with(md5a,md5b, nil, nil)
+
+        @filebucket.diff
+      end
+
+      it "should call the clien diff with a path if the second argument is a file" do
+        md5a="DEADBEEF"
+        md5b="BEEF"
+        Puppet::FileSystem.stubs(:exist?).with(md5a).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(md5b).returns(true)
+        @filebucket.stubs(:args).returns([md5a, md5b])
+
+        @client.expects(:diff).with(md5a, nil, nil, md5b)
+
+        @filebucket.diff
+      end
+
+      it "should call the clien diff with a path if the first argument is a file" do
+        md5a="DEADBEEF"
+        md5b="BEEF"
+        Puppet::FileSystem.stubs(:exist?).with(md5a).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(md5b).returns(false)
+        @filebucket.stubs(:args).returns([md5a, md5b])
+
+        @client.expects(:diff).with(nil, md5b, md5a, nil)
+
+        @filebucket.diff
+      end
+
+      it "should call the clien diff with paths if the both arguments are files" do
+        md5a="DEADBEEF"
+        md5b="BEEF"
+        Puppet::FileSystem.stubs(:exist?).with(md5a).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(md5b).returns(true)
+        @filebucket.stubs(:args).returns([md5a, md5b])
+
+        @client.expects(:diff).with(nil, nil, md5a, md5b)
+
+        @filebucket.diff
+      end
+
+      it "should fail if only one checksum is given" do
+        md5a="DEADBEEF"
+        @filebucket.stubs(:args).returns([md5a])
+
+        expect { @filebucket.diff }.to raise_error Puppet::Error
+      end
+    end
+    describe "the command list" do
+      it "should call the client list method with nil dates" do
+        @client.expects(:list).with(nil, nil)
+
+        @filebucket.list
+      end
+      it "should call the client list method with the given dates" do
+        # 3 Hours ago
+        threehours = 60*60*3
+        fromdate = (Time.now - threehours).strftime("%F %T")
+        # 1 Hour ago
+        onehour = 60*60
+        todate = (Time.now - onehour).strftime("%F %T")
+
+        @filebucket.options.stubs(:[]).with(:fromdate).returns(fromdate)
+        @filebucket.options.stubs(:[]).with(:todate).returns(todate)
+
+        @client.expects(:list).with(fromdate, todate)
+
+        @filebucket.list
+      end
+    end
+
   end
 
 

data/spec/unit/application/lookup_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+require 'puppet/application/lookup'
+require 'puppet/pops/lookup'
+
+describe Puppet::Application::Lookup do
+
+  context "when running with incorrect command line options" do
+    let (:lookup) { Puppet::Application[:lookup] }
+
+    it "errors if no keys are given via the command line" do
+      lookup.options[:node] = 'dantooine.local'
+      expected_error = "No keys were given to lookup."
+
+      expect { lookup.run_command }.to raise_error(RuntimeError, expected_error)
+    end
+
+    it "does not allow deep merge options if '--merge' was not set to deep" do
+      lookup.options[:node] = 'dantooine.local'
+      lookup.options[:merge_hash_arrays] = true
+      lookup.options[:merge] = 'hash'
+      lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
+
+      expected_error = "The options --knock-out-prefix, --sort-merged-arrays, --unpack-arrays, and --merge-hash-arrays are only available with '--merge deep'\nRun 'puppet lookup --help' for more details"
+
+      expect { lookup.run_command }.to raise_error(RuntimeError, expected_error)
+    end
+  end
+
+  context "when running with correct command line options" do
+    let (:lookup) { Puppet::Application[:lookup] }
+
+    it "calls the lookup method with the correct arguments" do
+      lookup.options[:node] = 'dantooine.local'
+      lookup.options[:render_as] = :s;
+      lookup.options[:merge_hash_arrays] = true
+      lookup.options[:merge] = 'deep'
+      lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
+      lookup.stubs(:generate_scope).yields('scope')
+
+      expected_merge = { "strategy" => "deep", "sort_merge_arrays" => false, "merge_hash_arrays" => true }
+
+      (Puppet::Pops::Lookup).expects(:lookup).with(['atton', 'kreia'], nil, nil, false, expected_merge, anything).returns('rand')
+
+      expect { lookup.run_command }.to output("rand\n").to_stdout
+    end
+
+    it "prints the value found by lookup" do
+      lookup.options[:node] = 'dantooine.local'
+      lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
+      lookup.stubs(:generate_scope).yields('scope')
+
+      Puppet::Pops::Lookup.stubs(:lookup).returns('rand')
+
+      expect { lookup.run_command }.to output("--- rand\n...\n").to_stdout
+    end
+  end
+
+
+  context 'when asked to explain' do
+    let (:lookup) { Puppet::Application[:lookup] }
+
+    # There is a fully configured 'sample' environment in fixtures at this location
+    let(:environmentpath) { File.absolute_path(File.join(my_fixture_dir(), '../environments')) }
+
+    let(:facts) { Puppet::Node::Facts.new("facts", {}) }
+
+    let(:node) { Puppet::Node.new("testnode", :facts => facts, :environment => environment) }
+
+    let(:expected_json_hash) { {
+      'type' => 'merge',
+      'merge' => 'first',
+      'event' => 'result',
+      'value' => 'This is A',
+      'branches' => [
+      { 'key' => 'a',
+        'event' => 'not_found',
+        'type' => 'global',
+        'name' => 'hiera'
+      },
+      {
+        'type' => 'data_provider',
+        'name' => 'Hiera Data Provider, version 4',
+        'configuration_path' => "#{environmentpath}/production/hiera.yaml",
+        'branches' => [
+        {
+          'name' => 'common',
+          'type' => 'data_provider',
+          'branches' => [
+          {
+            'key' => 'a',
+            'value' => 'This is A',
+            'event' => 'found',
+            'type' => 'path',
+            'original_path' => 'common',
+            'path' => "#{environmentpath}/production/data/common.yaml",
+          }]
+        }]
+      }]
+    } }
+
+    let(:expected_yaml_hash) { {
+      :type => :merge,
+      :merge => :first,
+      :event => :result,
+      :value => 'This is A',
+      :branches => [
+      { :key => 'a',
+        :event => :not_found,
+        :type => :global,
+        :name => :hiera
+      },
+      {
+        :type => :data_provider,
+        :name => 'Hiera Data Provider, version 4',
+        :configuration_path => "#{environmentpath}/production/hiera.yaml",
+        :branches => [
+        {
+          :type => :data_provider,
+          :name => 'common',
+          :branches => [
+          {
+            :key => 'a',
+            :value => 'This is A',
+            :event => :found,
+            :type => :path,
+            :original_path => 'common',
+            :path => "#{environmentpath}/production/data/common.yaml",
+          }]
+       }]
+      }]
+    } }
+
+    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
+      loader = Puppet::Environments::Directories.new(environmentpath, [])
+      Puppet.override(:environments => loader) do
+        example.run
+      end
+    end
+
+    it 'produces human readable text by default' do
+      lookup.options[:node] = Puppet::Node.new("testnode", :facts => facts, :environment => 'production')
+      lookup.options[:explain] = true
+      lookup.command_line.stubs(:args).returns(['a'])
+      expect { lookup.run_command }.to output(<<-EXPLANATION).to_stdout
+Merge strategy first
+  Data Binding "hiera"
+    No such key: "a"
+  Data Provider "Hiera Data Provider, version 4"
+    ConfigurationPath "#{environmentpath}/production/hiera.yaml"
+    Data Provider "common"
+      Path "#{environmentpath}/production/data/common.yaml"
+        Original path: common
+        Found key: "a" value: "This is A"
+  Merged result: "This is A"
+      EXPLANATION
+    end
+
+    it 'can produce a yaml explanation' do
+      lookup.options[:node] = Puppet::Node.new("testnode", :facts => facts, :environment => 'production')
+      lookup.options[:explain] = true
+      lookup.options[:render_as] = :yaml
+      lookup.command_line.stubs(:args).returns(['a'])
+      save_stdout = $stdout
+      output = nil
+      begin
+        $stdout = StringIO.new
+        lookup.run_command
+        output = $stdout.string
+      ensure
+        $stdout = save_stdout
+      end
+      expect(YAML.load(output)).to eq(expected_yaml_hash)
+    end
+
+    it 'can produce a json explanation' do
+      lookup.options[:node] = Puppet::Node.new("testnode", :facts => facts, :environment => 'production')
+      lookup.options[:explain] = true
+      lookup.options[:render_as] = :json
+      lookup.command_line.stubs(:args).returns(['a'])
+      save_stdout = $stdout
+      output = nil
+      begin
+        $stdout = StringIO.new
+        lookup.run_command
+        output = $stdout.string
+      ensure
+        $stdout = save_stdout
+      end
+      expect(JSON.parse(output)).to eq(expected_json_hash)
+    end
+  end
+end