puppet 3.8.7 → 4.0.0

data/spec/shared_behaviours/all_parsedfile_providers.rb

@@ -14,7 +14,7 @@ shared_examples_for "all parsedfile providers" do |provider, *files|
       oldlines = File.readlines(file)
       newlines = text.chomp.split "\n"
       oldlines.zip(newlines).each do |old, new|
-        new.gsub(/\s+/, '').should == old.chomp.gsub(/\s+/, '')
+        expect(new.gsub(/\s+/, '')).to eq(old.chomp.gsub(/\s+/, ''))
       end
     end
   end

data/spec/shared_behaviours/an_indirector_face.rb

@@ -1,6 +1,6 @@
 shared_examples_for "an indirector face" do
   [:find, :search, :save, :destroy, :info].each do |action|
-    it { should be_action action }
-    it { should respond_to action }
+    it { is_expected.to be_action action }
+    it { is_expected.to respond_to action }
   end
 end

data/spec/shared_behaviours/documentation_on_faces.rb

@@ -10,13 +10,13 @@ shared_examples_for "documentation on faces" do
   Attrs.each do |attr|
     it "should accept a #{attr}" do
       expect { subject.send("#{attr}=", "hello") }.not_to raise_error
-      subject.send(attr).should == "hello"
+      expect(subject.send(attr)).to eq("hello")
     end
 
     it "should accept a long (single line) value for #{attr}" do
       text = "I never know when to stop with the word banana" + ("na" * 1000)
       expect { subject.send("#{attr}=", text) }.to_not raise_error
-      subject.send(attr).should == text
+      expect(subject.send(attr)).to eq(text)
     end
   end
 
@@ -25,17 +25,17 @@ shared_examples_for "documentation on faces" do
     context "#{getter}" do
       it "should strip leading whitespace on a single line" do
         subject.send(setter, "  death to whitespace")
-        subject.send(getter).should == "death to whitespace"
+        expect(subject.send(getter)).to eq("death to whitespace")
       end
 
       it "should strip trailing whitespace on a single line" do
         subject.send(setter, "death to whitespace  ")
-        subject.send(getter).should == "death to whitespace"
+        expect(subject.send(getter)).to eq("death to whitespace")
       end
 
       it "should strip whitespace at both ends at once" do
         subject.send(setter, "  death to whitespace  ")
-        subject.send(getter).should == "death to whitespace"
+        expect(subject.send(getter)).to eq("death to whitespace")
       end
 
       multiline_text = "with\nnewlines"
@@ -43,12 +43,12 @@ shared_examples_for "documentation on faces" do
         it "should not accept multiline values" do
           expect { subject.send(setter, multiline_text) }.
             to raise_error ArgumentError, /#{getter} should be a single line/
-          subject.send(getter).should be_nil
+          expect(subject.send(getter)).to be_nil
         end
       else
         it "should accept multiline values" do
           expect { subject.send(setter, multiline_text) }.not_to raise_error
-          subject.send(getter).should == multiline_text
+          expect(subject.send(getter)).to eq(multiline_text)
         end
 
         [1, 2, 4, 7, 25].each do |length|
@@ -58,20 +58,20 @@ shared_examples_for "documentation on faces" do
             it "should strip leading whitespace on multiple lines" do
               text = "this\nis\the\final\outcome"
               subject.send(setter, text.gsub(/^/, indent))
-              subject.send(getter).should == text
+              expect(subject.send(getter)).to eq(text)
             end
 
             it "should not remove formatting whitespace, only global indent" do
               text = "this\n  is\n    the\n  ultimate\ntest"
               subject.send(setter, text.gsub(/^/, indent))
-              subject.send(getter).should == text
+              expect(subject.send(getter)).to eq(text)
             end
           end
         end
 
         it "should strip whitespace with a blank line" do
           subject.send(setter, "  this\n\n  should outdent")
-          subject.send(getter).should == "this\n\nshould outdent"
+          expect(subject.send(getter)).to eq("this\n\nshould outdent")
         end
       end
     end
@@ -81,46 +81,46 @@ shared_examples_for "documentation on faces" do
     it "should return the set value if set after description" do
       subject.description = "hello\ngoodbye"
       subject.short_description = "whatever"
-      subject.short_description.should == "whatever"
+      expect(subject.short_description).to eq("whatever")
     end
 
     it "should return the set value if set before description" do
       subject.short_description = "whatever"
       subject.description = "hello\ngoodbye"
-      subject.short_description.should == "whatever"
+      expect(subject.short_description).to eq("whatever")
     end
 
     it "should return nothing if not set and no description" do
-      subject.short_description.should be_nil
+      expect(subject.short_description).to be_nil
     end
 
     it "should return the first paragraph of description if not set (where it is one line long)" do
       subject.description = "hello"
-      subject.short_description.should == subject.description
+      expect(subject.short_description).to eq(subject.description)
     end
 
     it "should return the first paragraph of description if not set (where there is no paragraph break)" do
       subject.description = "hello\ngoodbye"
-      subject.short_description.should == subject.description
+      expect(subject.short_description).to eq(subject.description)
     end
 
     it "should return the first paragraph of description if not set (where there is a paragraph break)" do
       subject.description = "hello\ngoodbye\n\nmore\ntext\nhere\n\nfinal\nparagraph"
-      subject.short_description.should == "hello\ngoodbye"
+      expect(subject.short_description).to eq("hello\ngoodbye")
     end
 
     it "should trim a very, very long first paragraph and add ellipsis" do
       line = "this is a very, very, very long long line full of text\n"
       subject.description = line * 20 + "\n\nwhatever, dude."
 
-      subject.short_description.should == (line * 5).chomp + ' [...]'
+      expect(subject.short_description).to eq((line * 5).chomp + ' [...]')
     end
 
     it "should trim a very very long only paragraph even if it is followed by a new paragraph" do
       line = "this is a very, very, very long long line full of text\n"
       subject.description = line * 20
 
-      subject.short_description.should == (line * 5).chomp + ' [...]'
+      expect(subject.short_description).to eq((line * 5).chomp + ' [...]')
     end
   end
 
@@ -131,9 +131,9 @@ shared_examples_for "documentation on faces" do
       it "should support multiple authors" do
 
         authors.each {|name| subject.author name }
-        subject.authors.should =~ authors
+        expect(subject.authors).to match_array(authors)
 
-        subject.author.should == authors.join("\n")
+        expect(subject.author).to eq(authors.join("\n"))
       end
 
       it "should reject author as an array" do
@@ -145,19 +145,19 @@ shared_examples_for "documentation on faces" do
     context "#author=" do
       it "should accept a single name" do
         subject.author = "Fred"
-        subject.author.should == "Fred"
+        expect(subject.author).to eq("Fred")
       end
 
       it "should accept an array of names" do
         subject.author = authors
-        subject.authors.should =~ authors
-        subject.author.should == authors.join("\n")
+        expect(subject.authors).to match_array(authors)
+        expect(subject.author).to eq(authors.join("\n"))
       end
 
       it "should not append when set multiple times" do
         subject.author = "Fred"
         subject.author = "John"
-        subject.author.should == "John"
+        expect(subject.author).to eq("John")
       end
 
       it "should reject arrays with embedded newlines" do
@@ -169,12 +169,12 @@ shared_examples_for "documentation on faces" do
 
   describe "#license" do
     it "should default to reserving rights" do
-      subject.license.should =~ /All Rights Reserved/
+      expect(subject.license).to match(/All Rights Reserved/)
     end
 
     it "should accept an arbitrary license string on the object" do
       subject.license = "foo"
-      subject.license.should == "foo"
+      expect(subject.license).to eq("foo")
     end
 
     it "should accept symbols to specify existing licenses..."
@@ -189,45 +189,45 @@ shared_examples_for "documentation on faces" do
     [1997, "1997"].each do |year|
       it "should accept an entity name and a #{year.class.name} year" do
         subject.copyright("me", year)
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /#{year}/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/#{year}/)
       end
 
       it "should accept multiple entity names and a #{year.class.name} year" do
         subject.copyright ["me", "you"], year
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /#{year}/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/\byou\b/)
+        expect(subject.copyright).to match(/#{year}/)
       end
     end
 
     ["1997-2003", "1997 - 2003", 1997..2003].each do |range|
       it "should accept a #{range.class.name} range of years" do
         subject.copyright("me", range)
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /1997-2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/1997-2003/)
       end
 
       it "should accept a #{range.class.name} range of years" do
         subject.copyright ["me", "you"], range
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /1997-2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/\byou\b/)
+        expect(subject.copyright).to match(/1997-2003/)
       end
     end
 
     [[1997, 2003], ["1997", 2003], ["1997", "2003"]].each do |input|
       it "should accept the set of years #{input.inspect} in an array" do
         subject.copyright "me", input
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /1997, 2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/1997, 2003/)
       end
 
       it "should accept the set of years #{input.inspect} in an array" do
         subject.copyright ["me", "you"], input
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /1997, 2003/
+        expect(subject.copyright).to match(/\bme\b/)
+        expect(subject.copyright).to match(/\byou\b/)
+        expect(subject.copyright).to match(/1997, 2003/)
       end
     end
 
@@ -239,8 +239,8 @@ shared_examples_for "documentation on faces" do
     it "should accept complex copyright years" do
       years = [1997, 1999, 2000..2002, 2005].reverse
       subject.copyright "me", years
-      subject.copyright.should =~ /\bme\b/
-      subject.copyright.should =~ /1997, 1999, 2000-2002, 2005/
+      expect(subject.copyright).to match(/\bme\b/)
+      expect(subject.copyright).to match(/1997, 1999, 2000-2002, 2005/)
     end
   end
 
@@ -248,15 +248,15 @@ shared_examples_for "documentation on faces" do
   [:name, :options, :synopsis].each do |attr|
     describe "##{attr}" do
       it "should not allow you to set #{attr}" do
-        subject.should_not respond_to :"#{attr}="
+        expect(subject).not_to respond_to :"#{attr}="
       end
 
       it "should have a #{attr}" do
-        subject.send(attr).should_not be_nil
+        expect(subject.send(attr)).not_to be_nil
       end
 
       it "'s #{attr} should not be empty..." do
-        subject.send(attr).should_not == ''
+        expect(subject.send(attr)).not_to eq('')
       end
     end
   end

data/spec/shared_behaviours/file_server_terminus.rb

@@ -36,6 +36,6 @@ shared_examples_for "Puppet::Indirector::FileServerTerminus" do
 
     path = File.join(@path, "myfile")
 
-    @terminus.find(@request).should be_instance_of(@test_class)
+    expect(@terminus.find(@request)).to be_instance_of(@test_class)
   end
 end

data/spec/shared_behaviours/hiera_indirections.rb

@@ -28,18 +28,18 @@ shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
   end
 
   it "should be the default data_binding terminus" do
-    Puppet.settings[:data_binding_terminus].should == :hiera
+    expect(Puppet.settings[:data_binding_terminus]).to eq(:hiera)
   end
 
   it "should raise an error if we don't have the hiera feature" do
     Puppet.features.expects(:hiera?).returns(false)
-    lambda { test_klass.new }.should raise_error RuntimeError,
+    expect { test_klass.new }.to raise_error RuntimeError,
       "Hiera terminus not supported without hiera library"
   end
 
   describe "the behavior of the hiera_config method", :if => Puppet.features.hiera? do
     it "should override the logger and set it to puppet" do
-      test_klass.hiera_config[:logger].should == "puppet"
+      expect(test_klass.hiera_config[:logger]).to eq("puppet")
     end
 
     context "when the Hiera configuration file does not exist" do
@@ -58,7 +58,7 @@ shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
       it "should only configure the logger and set it to puppet" do
         Puppet.expects(:warning).with(
          "Config file #{path} not found, using Hiera defaults")
-        test_klass.hiera_config.should == { :logger => 'puppet' }
+        expect(test_klass.hiera_config).to eq({ :logger => 'puppet' })
       end
     end
   end
@@ -68,26 +68,26 @@ shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
     let(:data_binder) { test_klass.new }
 
     it "should support looking up an integer" do
-      data_binder.find(request("integer")).should == 3000
+      expect(data_binder.find(request("integer"))).to eq(3000)
     end
 
     it "should support looking up a string" do
-      data_binder.find(request("string")).should == 'apache'
+      expect(data_binder.find(request("string"))).to eq('apache')
     end
 
     it "should support looking up an array" do
-      data_binder.find(request("array")).should == [
+      expect(data_binder.find(request("array"))).to eq([
         '0.ntp.puppetlabs.com',
         '1.ntp.puppetlabs.com',
-      ]
+      ])
     end
 
     it "should support looking up a hash" do
-      data_binder.find(request("hash")).should == {
+      expect(data_binder.find(request("hash"))).to eq({
         'user'  => 'Hightower',
         'group' => 'admin',
         'mode'  => '0644'
-      }
+      })
     end
 
     it "raises a data binding error if hiera cannot parse the yaml data" do

data/spec/shared_behaviours/iterative_functions.rb

@@ -5,7 +5,7 @@ shared_examples_for 'all iterative functions hash handling' do |func|
       {a=>1}.#{func} |$v| { notify { "${v[0]} ${v[1]}": } }
     MANIFEST
 
-    catalog.resource(:notify, "a 1").should_not be_nil
+    expect(catalog.resource(:notify, "a 1")).not_to be_nil
   end
 end
 

data/spec/shared_behaviours/memory_terminus.rb

@@ -1,11 +1,11 @@
 shared_examples_for "A Memory Terminus" do
   it "should find no instances by default" do
-    @searcher.find(@request).should be_nil
+    expect(@searcher.find(@request)).to be_nil
   end
 
   it "should be able to find instances that were previously saved" do
     @searcher.save(@request)
-    @searcher.find(@request).should equal(@instance)
+    expect(@searcher.find(@request)).to equal(@instance)
   end
 
   it "should replace existing saved instances when a new instance with the same name is saved" do
@@ -13,16 +13,16 @@ shared_examples_for "A Memory Terminus" do
     two = stub 'second', :name => @name
     trequest = stub 'request', :key => @name, :instance => two
     @searcher.save(trequest)
-    @searcher.find(@request).should equal(two)
+    expect(@searcher.find(@request)).to equal(two)
   end
 
   it "should be able to remove previously saved instances" do
     @searcher.save(@request)
     @searcher.destroy(@request)
-    @searcher.find(@request).should be_nil
+    expect(@searcher.find(@request)).to be_nil
   end
 
   it "should fail when asked to destroy an instance that does not exist" do
-    proc { @searcher.destroy(@request) }.should raise_error(ArgumentError)
+    expect { @searcher.destroy(@request) }.to raise_error(ArgumentError)
   end
 end

data/spec/shared_behaviours/path_parameters.rb

@@ -49,7 +49,7 @@ shared_examples_for "all pathname parameters with arrays" do |win32|
               to raise_error Puppet::Error, /fully qualified/
           else
             instance = instance(data)
-            instance[@param].should == data
+            expect(instance[@param]).to eq(data)
           end
         end
 
@@ -59,7 +59,7 @@ shared_examples_for "all pathname parameters with arrays" do |win32|
               to raise_error Puppet::Error, /fully qualified/
           else
             instance = instance(data + data)
-            instance[@param].should == (data + data)
+            expect(instance[@param]).to eq(data + data)
           end
         end
       end
@@ -87,7 +87,7 @@ shared_examples_for "all path parameters" do |param, options|
     @param = param
   end
 
-  describe "on a Unix-like platform it", :as_platform => :posix do
+  describe "on a Unix-like platform it", :if => Puppet.features.posix? do
     if array then
       it_should_behave_like "all pathname parameters with arrays", false
     end
@@ -95,7 +95,7 @@ shared_examples_for "all path parameters" do |param, options|
     it "should accept a fully qualified path" do
       path = File.join('', 'foo')
       instance = instance(path)
-      instance[@param].should == path
+      expect(instance[@param]).to eq(path)
     end
 
     it "should give a useful error when the path is not absolute" do
@@ -115,7 +115,7 @@ shared_examples_for "all path parameters" do |param, options|
     end
   end
 
-  describe "on a Windows-like platform it", :as_platform => :windows do
+  describe "on a Windows-like platform it", :if => Puppet.features.microsoft_windows? do
     if array then
       it_should_behave_like "all pathname parameters with arrays", true
     end
@@ -134,7 +134,7 @@ shared_examples_for "all path parameters" do |param, options|
     it "also accepts Unix style path separators" do
       path = 'C:/Program Files'
       instance = instance(path)
-      instance[@param].should == path
+      expect(instance[@param]).to eq(path)
     end
 
     { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
@@ -142,7 +142,7 @@ shared_examples_for "all path parameters" do |param, options|
         it "should accept drive letter '#{drive}' with #{style} path separators " do
           path = "#{drive}:#{slash}Program Files"
           instance = instance(path)
-          instance[@param].should == path
+          expect(instance[@param]).to eq(path)
         end
       end
     end
@@ -153,7 +153,7 @@ shared_examples_for "all path parameters" do |param, options|
     }.each do |name, path|
       it "should accept #{name} as absolute" do
         instance = instance(path)
-        instance[@param].should == path
+        expect(instance[@param]).to eq(path)
       end
     end
   end

data/spec/shared_behaviours/store_configs_terminus.rb

@@ -7,15 +7,15 @@ shared_examples_for "a StoreConfigs terminus" do
   api = [:find, :search, :save, :destroy, :head]
 
   api.each do |name|
-    it { should respond_to name }
+    it { is_expected.to respond_to(name) }
   end
 
   it "should fail if an invalid backend is configured" do
     Puppet[:storeconfigs_backend] = "synergy"
-    expect { subject }.to raise_error ArgumentError, /could not find terminus synergy/i
+    expect { subject }.to raise_error(ArgumentError, /could not find terminus synergy/i)
   end
 
   it "should wrap the declared backend" do
-    subject.target.class.name.should == :store_configs_testing
+    expect(subject.target.class.name).to eq(:store_configs_testing)
   end
 end

data/spec/shared_behaviours/things_that_declare_options.rb

@@ -2,7 +2,7 @@
 shared_examples_for "things that declare options" do
   it "should support options without arguments" do
     thing = add_options_to { option "--bar" }
-    thing.should be_option :bar
+    expect(thing).to be_option :bar
   end
 
   it "should support options with an empty block" do
@@ -11,14 +11,14 @@ shared_examples_for "things that declare options" do
         # this section deliberately left blank
       end
     end
-    thing.should be
-    thing.should be_option :foo
+    expect(thing).to be
+    expect(thing).to be_option :foo
   end
 
   { "--foo=" => :foo }.each do |input, option|
     it "should accept #{name.inspect}" do
       thing = add_options_to { option input }
-      thing.should be_option option
+      expect(thing).to be_option option
     end
   end
 
@@ -32,7 +32,7 @@ shared_examples_for "things that declare options" do
       end
     end
 
-    thing.get_option(:foo).description.should == text
+    expect(thing.get_option(:foo).description).to eq(text)
   end
 
   it "should list all the options" do
@@ -43,7 +43,7 @@ shared_examples_for "things that declare options" do
       option "-f"
       option "--baz"
     end
-    thing.options.should == [:foo, :bar, :quux, :f, :baz]
+    expect(thing.options).to eq([:foo, :bar, :quux, :f, :baz])
   end
 
   it "should detect conflicts in long options" do
@@ -103,7 +103,7 @@ shared_examples_for "things that declare options" do
     expect do
       thing = add_options_to do option "--foo=[baz]", "--bar=[baz]" end
       [:foo, :bar].each do |name|
-        thing.should be_option name
+        expect(thing).to be_option name
       end
     end.to raise_error(ArgumentError, /optional arguments are not supported/)
   end
@@ -111,12 +111,12 @@ shared_examples_for "things that declare options" do
   describe "#takes_argument?" do
     it "should detect an argument being absent" do
       thing = add_options_to do option "--foo" end
-      thing.get_option(:foo).should_not be_takes_argument
+      expect(thing.get_option(:foo)).not_to be_takes_argument
     end
     ["=FOO", " FOO"].each do |input|
       it "should detect an argument given #{input.inspect}" do
         thing = add_options_to do option "--foo#{input}" end
-        thing.get_option(:foo).should be_takes_argument
+        expect(thing.get_option(:foo)).to be_takes_argument
       end
     end
   end
@@ -124,15 +124,15 @@ shared_examples_for "things that declare options" do
   describe "#optional_argument?" do
     it "should be false if no argument is present" do
       option = add_options_to do option "--foo" end.get_option(:foo)
-      option.should_not be_takes_argument
-      option.should_not be_optional_argument
+      expect(option).not_to be_takes_argument
+      expect(option).not_to be_optional_argument
     end
 
     ["=FOO", " FOO"].each do |input|
       it "should be false if the argument is mandatory (like #{input.inspect})" do
         option = add_options_to do option "--foo#{input}" end.get_option(:foo)
-      option.should be_takes_argument
-      option.should_not be_optional_argument
+      expect(option).to be_takes_argument
+      expect(option).not_to be_optional_argument
       end
     end
 
@@ -140,8 +140,8 @@ shared_examples_for "things that declare options" do
       it "should fail if the argument is optional (like #{input.inspect})" do
         expect do
           option = add_options_to do option "--foo#{input}" end.get_option(:foo)
-          option.should be_takes_argument
-          option.should be_optional_argument
+          expect(option).to be_takes_argument
+          expect(option).to be_optional_argument
         end.to raise_error(ArgumentError, /optional arguments are not supported/)
       end
     end
@@ -150,7 +150,7 @@ shared_examples_for "things that declare options" do
   describe "#default_to" do
     it "should not have a default value by default" do
       option = add_options_to do option "--foo" end.get_option(:foo)
-      option.should_not be_has_default
+      expect(option).not_to be_has_default
     end
 
     it "should accept a block for the default value" do
@@ -162,7 +162,7 @@ shared_examples_for "things that declare options" do
         end
       end.get_option(:foo)
 
-      option.should be_has_default
+      expect(option).to be_has_default
     end
 
     it "should invoke the block when asked for the default value" do
@@ -175,9 +175,9 @@ shared_examples_for "things that declare options" do
         end
       end.get_option(:foo)
 
-      option.should be_has_default
-      option.default.should be_true
-      invoked.should be_true
+      expect(option).to be_has_default
+      expect(option.default).to be_truthy
+      expect(invoked).to be_truthy
     end
 
     it "should return the value of the block when asked for the default" do
@@ -189,8 +189,8 @@ shared_examples_for "things that declare options" do
         end
       end.get_option(:foo)
 
-      option.should be_has_default
-      option.default.should == 12
+      expect(option).to be_has_default
+      expect(option.default).to eq(12)
     end
 
     it "should invoke the block every time the default is requested" do
@@ -206,9 +206,9 @@ shared_examples_for "things that declare options" do
       second = option.default.object_id
       third  = option.default.object_id
 
-      first.should_not == second
-      first.should_not == third
-      second.should_not == third
+      expect(first).not_to eq(second)
+      expect(first).not_to eq(third)
+      expect(second).not_to eq(third)
     end
 
     it "should fail if the option has a default and is required" do