puppet 3.8.7 → 4.0.0

data/spec/unit/indirector/ssl_file_spec.rb

@@ -40,12 +40,12 @@ describe Puppet::Indirector::SslFile do
 
   it "should return a nil collection directory if no directory setting has been provided" do
     @file_class.store_in nil
-    @file_class.collection_directory.should be_nil
+    expect(@file_class.collection_directory).to be_nil
   end
 
   it "should return a nil file location if no location has been provided" do
     @file_class.store_at nil
-    @file_class.file_location.should be_nil
+    expect(@file_class.file_location).to be_nil
   end
 
   it "should fail if no store directory or file location has been set" do
@@ -70,7 +70,7 @@ describe Puppet::Indirector::SslFile do
 
     it "should consider the file a ca file if the name is equal to what the SSL::Host class says is the CA name" do
       Puppet::SSL::Host.expects(:ca_name).returns "amaca"
-      @searcher.should be_ca("amaca")
+      expect(@searcher).to be_ca("amaca")
     end
 
     describe "when choosing the location for certificates" do
@@ -82,7 +82,7 @@ describe Puppet::Indirector::SslFile do
         Puppet[:cakey] = File.expand_path("/ca/file")
 
         @searcher.expects(:ca?).with(@cert.name).returns true
-        @searcher.path(@cert.name).should == Puppet[:cakey]
+        expect(@searcher.path(@cert.name)).to eq(Puppet[:cakey])
       end
 
       it "should set them at the file location if a file setting is available" do
@@ -91,11 +91,11 @@ describe Puppet::Indirector::SslFile do
 
         Puppet[:cacrl] = File.expand_path("/some/file")
 
-        @searcher.path(@cert.name).should == Puppet[:cacrl]
+        expect(@searcher.path(@cert.name)).to eq(Puppet[:cacrl])
       end
 
       it "should set them in the setting directory, with the certificate name plus '.pem', if a directory setting is available" do
-        @searcher.path(@cert.name).should == @certpath
+        expect(@searcher.path(@cert.name)).to eq(@certpath)
       end
 
       ['../foo', '..\\foo', './../foo', '.\\..\\foo',
@@ -125,7 +125,7 @@ describe Puppet::Indirector::SslFile do
           Dir.expects(:entries).with(@path).returns([])
           Puppet::FileSystem.expects(:exist?).with(@certpath).returns(false)
 
-          @searcher.find(@request).should be_nil
+          expect(@searcher.find(@request)).to be_nil
         end
       end
 
@@ -144,7 +144,7 @@ describe Puppet::Indirector::SslFile do
             model.expects(:new).with("myname").returns cert
             cert.expects(:read).with(@certpath)
 
-            @searcher.find(@request).should equal(cert)
+            expect(@searcher.find(@request)).to equal(cert)
           end
         end
 
@@ -197,13 +197,13 @@ describe Puppet::Indirector::SslFile do
 
       it "should fail if the directory is absent" do
         FileTest.expects(:directory?).with(File.dirname(@certpath)).returns false
-        lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
+        expect { @searcher.save(@request) }.to raise_error(Puppet::Error)
       end
 
       it "should fail if the directory is not writeable" do
         FileTest.stubs(:directory?).returns true
         FileTest.expects(:writable?).with(File.dirname(@certpath)).returns false
-        lambda { @searcher.save(@request) }.should raise_error(Puppet::Error)
+        expect { @searcher.save(@request) }.to raise_error(Puppet::Error)
       end
 
       it "should save to the path the output of converting the certificate to a string" do
@@ -260,7 +260,7 @@ describe Puppet::Indirector::SslFile do
         end
 
         it "should return false" do
-          @searcher.destroy(@request).should be_false
+          expect(@searcher.destroy(@request)).to be_falsey
         end
       end
 
@@ -300,7 +300,7 @@ describe Puppet::Indirector::SslFile do
         model.expects(:new).with("two").returns two
         two.expects(:read).with(two_path)
 
-        @searcher.search(@request).should == [one, two]
+        expect(@searcher.search(@request)).to eq([one, two])
       end
 
       it "should raise an exception if any file is unreadable" do
@@ -321,7 +321,7 @@ describe Puppet::Indirector::SslFile do
 
         model.expects(:new).never
 
-        @searcher.search(@request).should == []
+        expect(@searcher.search(@request)).to eq([])
       end
     end
   end

data/spec/unit/indirector/status/rest_spec.rb

@@ -5,6 +5,6 @@ require 'puppet/indirector/status/rest'
 
 describe Puppet::Indirector::Status::Rest do
   it "should be a subclass of Puppet::Indirector::REST" do
-    Puppet::Indirector::Status::Rest.superclass.should equal(Puppet::Indirector::REST)
+    expect(Puppet::Indirector::Status::Rest.superclass).to equal(Puppet::Indirector::REST)
   end
 end

data/spec/unit/indirector/terminus_spec.rb

@@ -30,35 +30,35 @@ describe Puppet::Indirector::Terminus do
   let :model          do Puppet::AbstractConcept end
 
   it "should provide a method for setting terminus class documentation" do
-    terminus_class.should respond_to(:desc)
+    expect(terminus_class).to respond_to(:desc)
   end
 
   it "should support a class-level name attribute" do
-    terminus_class.should respond_to(:name)
+    expect(terminus_class).to respond_to(:name)
   end
 
   it "should support a class-level indirection attribute" do
-    terminus_class.should respond_to(:indirection)
+    expect(terminus_class).to respond_to(:indirection)
   end
 
   it "should support a class-level terminus-type attribute" do
-    terminus_class.should respond_to(:terminus_type)
+    expect(terminus_class).to respond_to(:terminus_type)
   end
 
   it "should support a class-level model attribute" do
-    terminus_class.should respond_to(:model)
+    expect(terminus_class).to respond_to(:model)
   end
 
   it "should accept indirection instances as its indirection" do
     # The test is that this shouldn't raise, and should preserve the object
     # instance exactly, hence "equal", not just "==".
     terminus_class.indirection = indirection
-    terminus_class.indirection.should equal indirection
+    expect(terminus_class.indirection).to equal indirection
   end
 
   it "should look up indirection instances when only a name has been provided" do
     terminus_class.indirection = :abstract_concept
-    terminus_class.indirection.should equal indirection
+    expect(terminus_class.indirection).to equal indirection
   end
 
   it "should fail when provided a name that does not resolve to an indirection" do
@@ -67,36 +67,36 @@ describe Puppet::Indirector::Terminus do
     }.to raise_error(ArgumentError, /Could not find indirection instance/)
 
     # We should still have the default indirection.
-    terminus_class.indirection.should equal indirection
+    expect(terminus_class.indirection).to equal indirection
   end
 
   describe "when a terminus instance" do
     it "should return the class's name as its name" do
-      terminus.name.should == :freedom
+      expect(terminus.name).to eq(:freedom)
     end
 
     it "should return the class's indirection as its indirection" do
-      terminus.indirection.should equal indirection
+      expect(terminus.indirection).to equal indirection
     end
 
     it "should set the instances's type to the abstract terminus type's name" do
-      terminus.terminus_type.should == :code
+      expect(terminus.terminus_type).to eq(:code)
     end
 
     it "should set the instances's model to the indirection's model" do
-      terminus.model.should equal indirection.model
+      expect(terminus.model).to equal indirection.model
     end
   end
 
   describe "when managing terminus classes" do
     it "should provide a method for registering terminus classes" do
-      Puppet::Indirector::Terminus.should respond_to(:register_terminus_class)
+      expect(Puppet::Indirector::Terminus).to respond_to(:register_terminus_class)
     end
 
     it "should provide a method for returning terminus classes by name and type" do
       terminus = stub 'terminus_type', :name => :abstract, :indirection_name => :whatever
       Puppet::Indirector::Terminus.register_terminus_class(terminus)
-      Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract).should equal(terminus)
+      expect(Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract)).to equal(terminus)
     end
 
     it "should set up autoloading for any terminus class types requested" do
@@ -203,11 +203,11 @@ describe Puppet::Indirector::Terminus do
     end
 
     it "should set the name of the abstract subclass to be its class constant" do
-      subclass.name.should == :test_terminus_type
+      expect(subclass.name).to eq(:test_terminus_type)
     end
 
     it "should mark abstract terminus types as such" do
-      subclass.should be_abstract_terminus
+      expect(subclass).to be_abstract_terminus
     end
 
     it "should not allow instances of abstract subclasses to be created" do
@@ -218,7 +218,7 @@ describe Puppet::Indirector::Terminus do
   describe "when listing terminus classes" do
     it "should list the terminus files available to load" do
       Puppet::Util::Autoload.any_instance.stubs(:files_to_load).returns ["/foo/bar/baz", "/max/runs/marathon"]
-      Puppet::Indirector::Terminus.terminus_classes('my_stuff').should == [:baz, :marathon]
+      expect(Puppet::Indirector::Terminus.terminus_classes('my_stuff')).to eq([:baz, :marathon])
     end
   end
 

data/spec/unit/indirector/yaml_spec.rb

@@ -39,37 +39,37 @@ describe Puppet::Indirector::Yaml do
     it "should use the server_datadir if the run_mode is master" do
       Puppet.run_mode.stubs(:master?).returns true
       Puppet[:yamldir] = serverdir
-      @store.path(:me).should =~ /^#{serverdir}/
+      expect(@store.path(:me)).to match(/^#{serverdir}/)
     end
 
     it "should use the client yamldir if the run_mode is not master" do
       Puppet.run_mode.stubs(:master?).returns false
       Puppet[:clientyamldir] = clientdir
-      @store.path(:me).should =~ /^#{clientdir}/
+      expect(@store.path(:me)).to match(/^#{clientdir}/)
     end
 
     it "should use the extension if one is specified" do
       Puppet.run_mode.stubs(:master?).returns true
       Puppet[:yamldir] = serverdir
-      @store.path(:me,'.farfignewton').should =~ %r{\.farfignewton$}
+      expect(@store.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
     end
 
     it "should assume an extension of .yaml if none is specified" do
       Puppet.run_mode.stubs(:master?).returns true
       Puppet[:yamldir] = serverdir
-      @store.path(:me).should =~ %r{\.yaml$}
+      expect(@store.path(:me)).to match(%r{\.yaml$})
     end
 
     it "should store all files in a single file root set in the Puppet defaults" do
-      @store.path(:me).should =~ %r{^#{@dir}}
+      expect(@store.path(:me)).to match(%r{^#{@dir}})
     end
 
     it "should use the terminus name for choosing the subdirectory" do
-      @store.path(:me).should =~ %r{^#{@dir}/my_yaml}
+      expect(@store.path(:me)).to match(%r{^#{@dir}/my_yaml})
     end
 
     it "should use the object's name to determine the file name" do
-      @store.path(:me).should =~ %r{me.yaml$}
+      expect(@store.path(:me)).to match(%r{me.yaml$})
     end
 
     ['../foo', '..\\foo', './../foo', '.\\..\\foo',
@@ -90,7 +90,7 @@ describe Puppet::Indirector::Yaml do
   describe "when storing objects as YAML" do
     it "should only store objects that respond to :name" do
       @request.stubs(:instance).returns Object.new
-      proc { @store.save(@request) }.should raise_error(ArgumentError)
+      expect { @store.save(@request) }.to raise_error(ArgumentError)
     end
   end
 
@@ -98,7 +98,7 @@ describe Puppet::Indirector::Yaml do
     it "should read YAML in from disk and convert it to Ruby objects" do
       @store.save(Puppet::Indirector::Request.new(:my_yaml, :save, "testing", @subject))
 
-      @store.find(Puppet::Indirector::Request.new(:my_yaml, :find, "testing", nil)).name.should == :me
+      expect(@store.find(Puppet::Indirector::Request.new(:my_yaml, :find, "testing", nil)).name).to eq(:me)
     end
 
     it "should fail coherently when the stored YAML is invalid" do
@@ -124,7 +124,7 @@ describe Puppet::Indirector::Yaml do
       Dir.expects(:glob).with(:glob).returns(%w{one.yaml two.yaml})
       YAML.expects(:load_file).with("one.yaml").returns @one;
       YAML.expects(:load_file).with("two.yaml").returns @two;
-      @store.search(@request).should == [@one, @two]
+      expect(@store.search(@request)).to eq([@one, @two])
     end
 
     it "should return an array containing a single instance of fact when globbing 'one*'" do
@@ -133,14 +133,14 @@ describe Puppet::Indirector::Yaml do
       @store.expects(:path).with(@request.key,'').returns :glob
       Dir.expects(:glob).with(:glob).returns(%w{one.yaml})
       YAML.expects(:load_file).with("one.yaml").returns @one;
-      @store.search(@request).should == [@one]
+      expect(@store.search(@request)).to eq([@one])
     end
 
     it "should return an empty array when the glob doesn't match anything" do
       @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
       @store.expects(:path).with(@request.key,'').returns :glob
       Dir.expects(:glob).with(:glob).returns []
-      @store.search(@request).should == []
+      expect(@store.search(@request)).to eq([])
     end
 
     describe "when destroying" do

data/spec/unit/indirector_spec.rb

@@ -25,8 +25,8 @@ describe Puppet::Indirector, "when configuring routes" do
 
     Puppet::Indirector.configure_routes(routes)
 
-    Puppet::Node.indirection.terminus_class.should == "exec"
-    Puppet::Node.indirection.cache_class.should    == "plain"
+    expect(Puppet::Node.indirection.terminus_class).to eq("exec")
+    expect(Puppet::Node.indirection.cache_class).to    eq("plain")
   end
 
   it "should fail when given an invalid indirection" do
@@ -71,7 +71,7 @@ describe Puppet::Indirector, " when available to a model" do
   end
 
   it "should provide a way for the model to register an indirection under a name" do
-    @thingie.should respond_to(:indirects)
+    expect(@thingie).to respond_to(:indirects)
   end
 end
 
@@ -98,7 +98,7 @@ describe Puppet::Indirector, "when registering an indirection" do
 
   it "should create an indirection instance to manage each indirecting model" do
     @indirection = @thingie.indirects(:test)
-    @indirection.should be_instance_of(Puppet::Indirector::Indirection)
+    expect(@indirection).to be_instance_of(Puppet::Indirector::Indirection)
   end
 
   it "should not allow a model to register under multiple names" do
@@ -109,7 +109,7 @@ describe Puppet::Indirector, "when registering an indirection" do
 
   it "should make the indirection available via an accessor" do
     @indirection = @thingie.indirects :first
-    @thingie.indirection.should equal(@indirection)
+    expect(@thingie.indirection).to equal(@indirection)
   end
 
   it "should pass any provided options to the indirection during initialization" do
@@ -120,7 +120,7 @@ describe Puppet::Indirector, "when registering an indirection" do
 
   it "should extend the class to handle serialization" do
     @indirection = @thingie.indirects :first
-    @thingie.should respond_to(:convert_from)
+    expect(@thingie).to respond_to(:convert_from)
   end
 
   after do
@@ -141,7 +141,7 @@ describe Puppet::Indirector, "when redirecting a model" do
   end
 
   it "should include the Envelope module in the model" do
-    @thingie.ancestors.should be_include(Puppet::Indirector::Envelope)
+    expect(@thingie.ancestors).to be_include(Puppet::Indirector::Envelope)
   end
 
   after do

data/spec/unit/interface/action_builder_spec.rb

@@ -10,8 +10,8 @@ describe Puppet::Interface::ActionBuilder do
     action = Puppet::Interface::ActionBuilder.build(face, :foo) do
       when_invoked do |options| true end
     end
-    action.should be_a(Puppet::Interface::Action)
-    action.name.should == :foo
+    expect(action).to be_a(Puppet::Interface::Action)
+    expect(action.name).to eq(:foo)
   end
 
   it "should define a method on the face which invokes the action" do
@@ -19,7 +19,7 @@ describe Puppet::Interface::ActionBuilder do
       action(:foo) { when_invoked { |options| "invoked the method" } }
     end
 
-    face.foo.should == "invoked the method"
+    expect(face.foo).to eq("invoked the method")
   end
 
   it "should require a block" do
@@ -41,7 +41,7 @@ describe Puppet::Interface::ActionBuilder do
         when_invoked do |options| true end
         method = self.method(:option)
       end
-      method.should be_an_instance_of Method
+      expect(method).to be_an_instance_of Method
     end
 
     it "should define an option without a block" do
@@ -49,7 +49,7 @@ describe Puppet::Interface::ActionBuilder do
         when_invoked do |options| true end
         option "--bar"
       end
-      action.should be_option :bar
+      expect(action).to be_option :bar
     end
 
     it "should accept an empty block" do
@@ -59,7 +59,7 @@ describe Puppet::Interface::ActionBuilder do
           # This space left deliberately blank.
         end
       end
-      action.should be_option :bar
+      expect(action).to be_option :bar
     end
   end
 
@@ -69,7 +69,7 @@ describe Puppet::Interface::ActionBuilder do
         when_invoked do |options| true end
         summary "this is some text"
       end
-      action.summary.should == "this is some text"
+      expect(action.summary).to eq("this is some text")
     end
   end
 
@@ -79,14 +79,14 @@ describe Puppet::Interface::ActionBuilder do
         when_invoked do |options| true end
         default
       end
-      action.default.should be_true
+      expect(action.default).to be_truthy
     end
 
     it "should not be default by, er, default. *cough*" do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
       end
-      action.default.should be_false
+      expect(action.default).to be_falsey
     end
   end
 
@@ -144,7 +144,7 @@ describe Puppet::Interface::ActionBuilder do
         when_invoked do |options| true end
         when_rendering :json do |a| true end
       end
-      action.when_rendering(:json).should be_an_instance_of Method
+      expect(action.when_rendering(:json)).to be_an_instance_of Method
     end
 
     it "should fail if you try to set the same rendering twice" do
@@ -163,8 +163,8 @@ describe Puppet::Interface::ActionBuilder do
         when_rendering :json do |a| true end
         when_rendering :yaml do |a| true end
       end
-      action.when_rendering(:json).should be_an_instance_of Method
-      action.when_rendering(:yaml).should be_an_instance_of Method
+      expect(action.when_rendering(:json)).to be_an_instance_of Method
+      expect(action.when_rendering(:yaml)).to be_an_instance_of Method
     end
 
     it "should be bound to the face when called" do
@@ -172,7 +172,7 @@ describe Puppet::Interface::ActionBuilder do
         when_invoked do |options| true end
         when_rendering :json do |a| self end
       end
-      action.when_rendering(:json).call(true).should == face
+      expect(action.when_rendering(:json).call(true)).to eq(face)
     end
   end
 
@@ -181,7 +181,7 @@ describe Puppet::Interface::ActionBuilder do
       action = Puppet::Interface::ActionBuilder.build(face, :foo) do
         when_invoked do |options| true end
       end
-      action.render_as.should be_nil
+      expect(action.render_as).to be_nil
     end
 
     it "should fail if not rendering format is given" do
@@ -199,7 +199,7 @@ describe Puppet::Interface::ActionBuilder do
           when_invoked do |options| true end
           render_as name
         end
-        action.render_as.should == name
+        expect(action.render_as).to eq(name)
       end
     end