puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/interface/documentation_spec.rb

@@ -24,10 +24,10 @@ describe Puppet::Interface::TinyDocs do
       subject.options = [:foo, :bar]
     end
 
-    it { should respond_to :build_synopsis }
+    it { is_expected.to respond_to :build_synopsis }
 
     it "should put a space between options (#7828)" do
-      subject.build_synopsis('baz').should =~ /#{Regexp.quote('[--foo] [--bar]')}/
+      expect(subject.build_synopsis('baz')).to match(/#{Regexp.quote('[--foo] [--bar]')}/)
     end
   end
 end

data/spec/unit/interface/face_collection_spec.rb

@@ -30,8 +30,8 @@ describe Puppet::Interface::FaceCollection do
 
   after :all do
     # Restore global state
-    subject.instance_variable_set :@faces, @faces
-    subject.instance_variable_set :@loaded, @faces_loaded
+    described_class.instance_variable_set :@faces, @faces
+    described_class.instance_variable_set :@loaded, @faces_loaded
     $".delete_if { |path| path =~ /face\/.*\.rb$/ }
     @required.each { |path| $".push path unless $".include? path }
     Puppet::Util::Autoload.instance_variable_set(:@loaded, @loaded)
@@ -51,7 +51,7 @@ describe Puppet::Interface::FaceCollection do
     end
 
     it "should return the face with the given name" do
-      subject["foo", '0.0.1'].should == 10
+      expect(subject["foo", '0.0.1']).to eq(10)
     end
 
     it "should attempt to load the face if it isn't found" do
@@ -67,7 +67,7 @@ describe Puppet::Interface::FaceCollection do
 
     it "should return true if the face specified is registered" do
       subject.instance_variable_get("@faces")[:foo][SemVer.new('0.0.1')] = 10
-      subject["foo", '0.0.1'].should == 10
+      expect(subject["foo", '0.0.1']).to eq(10)
     end
 
     it "should attempt to require the face if it is not registered" do
@@ -75,19 +75,19 @@ describe Puppet::Interface::FaceCollection do
         subject.instance_variable_get("@faces")[:bar][SemVer.new('0.0.1')] = true
         file == 'puppet/face/bar'
       end
-      subject["bar", '0.0.1'].should be_true
+      expect(subject["bar", '0.0.1']).to be_truthy
     end
 
     it "should return false if the face is not registered" do
       subject.stubs(:require).returns(true)
-      subject["bar", '0.0.1'].should be_false
+      expect(subject["bar", '0.0.1']).to be_falsey
     end
 
     it "should return false if the face file itself is missing" do
       subject.stubs(:require).
         raises(LoadError, 'no such file to load -- puppet/face/bar').then.
         raises(LoadError, 'no such file to load -- puppet/face/0.0.1/bar')
-      subject["bar", '0.0.1'].should be_false
+      expect(subject["bar", '0.0.1']).to be_falsey
     end
 
     it "should register the version loaded by `:current` as `:current`" do
@@ -96,62 +96,62 @@ describe Puppet::Interface::FaceCollection do
         file == 'puppet/face/huzzah'
       end
       subject["huzzah", :current]
-      subject.instance_variable_get("@faces")[:huzzah][:current].should == :huzzah_face
+      expect(subject.instance_variable_get("@faces")[:huzzah][:current]).to eq(:huzzah_face)
     end
 
     context "with something on disk" do
       it "should register the version loaded from `puppet/face/{name}` as `:current`" do
-        subject["huzzah", '2.0.1'].should be
-        subject["huzzah", :current].should be
-        Puppet::Face[:huzzah, '2.0.1'].should == Puppet::Face[:huzzah, :current]
+        expect(subject["huzzah", '2.0.1']).to be
+        expect(subject["huzzah", :current]).to be
+        expect(Puppet::Face[:huzzah, '2.0.1']).to eq(Puppet::Face[:huzzah, :current])
       end
 
       it "should index :current when the code was pre-required" do
-        subject.instance_variable_get("@faces")[:huzzah].should_not be_key :current
+        expect(subject.instance_variable_get("@faces")[:huzzah]).not_to be_key :current
         require 'puppet/face/huzzah'
-        subject[:huzzah, :current].should be_true
+        expect(subject[:huzzah, :current]).to be_truthy
       end
     end
 
     it "should not cause an invalid face to be enumerated later" do
-      subject[:there_is_no_face, :current].should be_false
-      subject.faces.should_not include :there_is_no_face
+      expect(subject[:there_is_no_face, :current]).to be_falsey
+      expect(subject.faces).not_to include :there_is_no_face
     end
   end
 
   describe "::get_action_for_face" do
     it "should return an action on the current face" do
-      Puppet::Face::FaceCollection.get_action_for_face(:huzzah, :bar, :current).
-        should be_an_instance_of Puppet::Interface::Action
+      expect(Puppet::Face::FaceCollection.get_action_for_face(:huzzah, :bar, :current)).
+        to be_an_instance_of Puppet::Interface::Action
     end
 
     it "should return an action on an older version of a face" do
       action = Puppet::Face::FaceCollection.
         get_action_for_face(:huzzah, :obsolete, :current)
 
-      action.should be_an_instance_of Puppet::Interface::Action
-      action.face.version.should == SemVer.new('1.0.0')
+      expect(action).to be_an_instance_of Puppet::Interface::Action
+      expect(action.face.version).to eq(SemVer.new('1.0.0'))
     end
 
     it "should load the full older version of a face" do
       action = Puppet::Face::FaceCollection.
         get_action_for_face(:huzzah, :obsolete, :current)
 
-      action.face.version.should == SemVer.new('1.0.0')
-      action.face.should be_action :obsolete_in_core
+      expect(action.face.version).to eq(SemVer.new('1.0.0'))
+      expect(action.face).to be_action :obsolete_in_core
     end
 
     it "should not add obsolete actions to the current version" do
       action = Puppet::Face::FaceCollection.
         get_action_for_face(:huzzah, :obsolete, :current)
 
-      action.face.version.should == SemVer.new('1.0.0')
-      action.face.should be_action :obsolete_in_core
+      expect(action.face.version).to eq(SemVer.new('1.0.0'))
+      expect(action.face).to be_action :obsolete_in_core
 
       current = Puppet::Face[:huzzah, :current]
-      current.version.should == SemVer.new('2.0.1')
-      current.should_not be_action :obsolete_in_core
-      current.should_not be_action :obsolete
+      expect(current.version).to eq(SemVer.new('2.0.1'))
+      expect(current).not_to be_action :obsolete_in_core
+      expect(current).not_to be_action :obsolete
     end
   end
 
@@ -159,9 +159,9 @@ describe Puppet::Interface::FaceCollection do
     it "should store the face by name" do
       face = Puppet::Face.new(:my_face, '0.0.1')
       subject.register(face)
-      subject.instance_variable_get("@faces").should == {
+      expect(subject.instance_variable_get("@faces")).to eq({
         :my_face => { face.version => face }
-      }
+      })
     end
   end
 
@@ -181,7 +181,7 @@ describe Puppet::Interface::FaceCollection do
     valid.each do |input, expect|
       it "should map #{input.inspect} to #{expect.inspect}" do
         result = subject.underscorize(input)
-        result.should == expect
+        expect(result).to eq(expect)
       end
     end
 
@@ -203,10 +203,10 @@ describe Puppet::Interface::FaceCollection do
     end
 
     it "should not die if a face has a syntax error" do
-      subject.faces.should be_include :help
-      subject.faces.should_not be_include :syntax
-      @logs.should_not be_empty
-      @logs.first.message.should =~ /syntax error/
+      expect(subject.faces).to be_include :help
+      expect(subject.faces).not_to be_include :syntax
+      expect(@logs).not_to be_empty
+      expect(@logs.first.message).to match(/syntax error/)
     end
   end
 end

data/spec/unit/interface/option_builder_spec.rb

@@ -5,8 +5,8 @@ describe Puppet::Interface::OptionBuilder do
   let :face do Puppet::Interface.new(:option_builder_testing, '0.0.1') end
 
   it "should be able to construct an option without a block" do
-    Puppet::Interface::OptionBuilder.build(face, "--foo").
-      should be_an_instance_of Puppet::Interface::Option
+    expect(Puppet::Interface::OptionBuilder.build(face, "--foo")).
+      to be_an_instance_of Puppet::Interface::Option
   end
 
   Puppet.settings.each do |name, value|
@@ -22,7 +22,7 @@ describe Puppet::Interface::OptionBuilder do
       # This block deliberately left blank.
     end
 
-    option.should be_an_instance_of Puppet::Interface::Option
+    expect(option).to be_an_instance_of Puppet::Interface::Option
   end
 
   [:description, :summary].each do |doc|
@@ -31,8 +31,8 @@ describe Puppet::Interface::OptionBuilder do
       option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
         self.send doc, text
       end
-      option.should be_an_instance_of Puppet::Interface::Option
-      option.send(doc).should == text
+      expect(option).to be_an_instance_of Puppet::Interface::Option
+      expect(option.send(doc)).to eq(text)
     end
   end
 
@@ -41,7 +41,7 @@ describe Puppet::Interface::OptionBuilder do
       option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
         before_action do |a,b,c| :whatever end
       end
-      option.before_action.should be_an_instance_of UnboundMethod
+      expect(option.before_action).to be_an_instance_of UnboundMethod
     end
 
     it "should fail if the hook block takes too few arguments" do
@@ -72,14 +72,14 @@ describe Puppet::Interface::OptionBuilder do
       opt = Puppet::Interface::OptionBuilder.build(face, "--foo") do
         required
       end
-      opt.should be_required
+      expect(opt).to be_required
     end
 
     it "should support arguments to the required property" do
       opt = Puppet::Interface::OptionBuilder.build(face, "--foo") do
         required(false)
       end
-      opt.should_not be_required
+      expect(opt).not_to be_required
     end
     
   end

data/spec/unit/interface/option_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Interface::Option do
         input = base + postfix
         it "should map #{input.inspect} to #{expect.inspect}" do
           option = Puppet::Interface::Option.new(face, input)
-          option.name.should == expect
+          expect(option.name).to eq(expect)
         end
       end
     end
@@ -46,22 +46,22 @@ describe Puppet::Interface::Option do
 
   it "should infer the name from an optparse string" do
     option = Puppet::Interface::Option.new(face, "--foo")
-    option.name.should == :foo
+    expect(option.name).to eq(:foo)
   end
 
   it "should infer the name when multiple optparse string are given" do
     option = Puppet::Interface::Option.new(face, "--foo", "-f")
-    option.name.should == :foo
+    expect(option.name).to eq(:foo)
   end
 
   it "should prefer the first long option name over a short option name" do
     option = Puppet::Interface::Option.new(face, "-f", "--foo")
-    option.name.should == :foo
+    expect(option.name).to eq(:foo)
   end
 
   it "should create an instance when given a face and name" do
-    Puppet::Interface::Option.new(face, "--foo").
-      should be_instance_of Puppet::Interface::Option
+    expect(Puppet::Interface::Option.new(face, "--foo")).
+      to be_instance_of Puppet::Interface::Option
   end
 
   Puppet.settings.each do |name, value|
@@ -75,14 +75,14 @@ describe Puppet::Interface::Option do
   describe "#to_s" do
     it "should transform a symbol into a string" do
       option = Puppet::Interface::Option.new(face, "--foo")
-      option.name.should == :foo
-      option.to_s.should == "foo"
+      expect(option.name).to eq(:foo)
+      expect(option.to_s).to eq("foo")
     end
 
     it "should use - rather than _ to separate words in strings but not symbols" do
       option = Puppet::Interface::Option.new(face, "--foo-bar")
-      option.name.should == :foo_bar
-      option.to_s.should == "foo-bar"
+      expect(option.name).to eq(:foo_bar)
+      expect(option.to_s).to eq("foo-bar")
     end
   end
 
@@ -91,13 +91,13 @@ describe Puppet::Interface::Option do
       subject { Puppet::Interface::Option.new(face, "--foo") }
       let :proc do Proc.new do :from_proc end end
 
-      it { should respond_to "#{side}_action" }
-      it { should respond_to "#{side}_action=" }
+      it { is_expected.to respond_to "#{side}_action" }
+      it { is_expected.to respond_to "#{side}_action=" }
 
       it "should set the #{side}_action hook" do
-        subject.send("#{side}_action").should be_nil
+        expect(subject.send("#{side}_action")).to be_nil
         subject.send("#{side}_action=", proc)
-        subject.send("#{side}_action").should be_an_instance_of UnboundMethod
+        expect(subject.send("#{side}_action")).to be_an_instance_of UnboundMethod
       end
 
       data = [1, "foo", :foo, Object.new, method(:hash), method(:hash).unbind]
@@ -115,13 +115,13 @@ describe Puppet::Interface::Option do
 
     it "should work sanely if member variables are used for state" do
       subject.default = proc { @foo ||= 0; @foo += 1 }
-      subject.default.should == 1
-      subject.default.should == 2
-      subject.default.should == 3
+      expect(subject.default).to eq(1)
+      expect(subject.default).to eq(2)
+      expect(subject.default).to eq(3)
     end
 
     context "with no default" do
-      it { should_not be_has_default }
+      it { is_expected.not_to be_has_default }
       its :default do should be_nil end
 
       it "should set a proc as default" do
@@ -138,18 +138,18 @@ describe Puppet::Interface::Option do
     context "with a default" do
       before :each do subject.default = proc { [:foo] } end
 
-      it { should be_has_default }
+      it { is_expected.to be_has_default }
       its :default do should == [:foo] end
 
       it "should invoke the block every time" do
-        subject.default.object_id.should_not == subject.default.object_id
-        subject.default.should == subject.default
+        expect(subject.default.object_id).not_to eq(subject.default.object_id)
+        expect(subject.default).to eq(subject.default)
       end
 
       it "should allow replacing the default proc" do
-        subject.default.should == [:foo]
+        expect(subject.default).to eq([:foo])
         subject.default = proc { :bar }
-        subject.default.should == :bar
+        expect(subject.default).to eq(:bar)
       end
     end
   end

data/spec/unit/interface_spec.rb

@@ -40,8 +40,8 @@ describe Puppet::Interface do
       }.each do |input, expect|
         it "should match #{input.inspect} to #{expect.inspect}" do
           face = subject[:version_matching, input]
-          face.should be
-          face.version.should == expect
+          expect(face).to be
+          expect(face.version).to eq(expect)
         end
       end
 
@@ -57,7 +57,7 @@ describe Puppet::Interface do
   describe "#define" do
     it "should register the face" do
       face  = subject.define(:face_test_register, '0.0.1')
-      face.should == subject[:face_test_register, '0.0.1']
+      expect(face).to eq(subject[:face_test_register, '0.0.1'])
     end
 
     it "should load actions" do
@@ -70,8 +70,8 @@ describe Puppet::Interface do
     end
 
     it "should support summary builder and accessor methods" do
-      subject.new(:foo, '1.0.0').should respond_to(:summary).with(0).arguments
-      subject.new(:foo, '1.0.0').should respond_to(:summary=).with(1).arguments
+      expect(subject.new(:foo, '1.0.0')).to respond_to(:summary).with(0).arguments
+      expect(subject.new(:foo, '1.0.0')).to respond_to(:summary=).with(1).arguments
     end
 
     # Required documentation methods...
@@ -86,7 +86,7 @@ describe Puppet::Interface do
         face = subject.new(:builder, '1.0.0') do
           self.send(attr, value)
         end
-        face.send(attr).should == value
+        expect(face.send(attr)).to eq(value)
       end
     end
   end
@@ -108,21 +108,16 @@ describe Puppet::Interface do
         end
       end
 
-      face.something.should == "foo"
+      expect(face.something).to eq("foo")
     end
   end
 
   it "should have a name" do
-    subject.new(:me, '0.0.1').name.should == :me
+    expect(subject.new(:me, '0.0.1').name).to eq(:me)
   end
 
   it "should stringify with its own name" do
-    subject.new(:me, '0.0.1').to_s.should =~ /\bme\b/
-  end
-
-  # Why?
-  it "should create a class-level autoloader" do
-    subject.autoloader.should be_instance_of(Puppet::Util::Autoload)
+    expect(subject.new(:me, '0.0.1').to_s).to match(/\bme\b/)
   end
 
   it "should try to require faces that are not known" do
@@ -185,7 +180,7 @@ describe Puppet::Interface do
           option "--quux"
         end
       end
-      face.options.should =~ [:foo, :bar]
+      expect(face.options).to match_array([:foo, :bar])
     end
 
     it "should fail when a face option duplicates an action option" do
@@ -206,15 +201,15 @@ describe Puppet::Interface do
         action :bar do when_invoked {|_| true } ; option "--quux" end
       end
 
-      face.get_action(:foo).options.should =~ [:quux]
-      face.get_action(:bar).options.should =~ [:quux]
+      expect(face.get_action(:foo).options).to match_array([:quux])
+      expect(face.get_action(:bar).options).to match_array([:quux])
     end
 
     it "should only list options and not aliases" do
       face = subject.new(:face_options, '0.0.1') do
         option "--bar", "-b", "--foo-bar"
       end
-      face.options.should =~ [:bar]
+      expect(face.options).to match_array([:bar])
     end
 
   end
@@ -236,29 +231,29 @@ describe Puppet::Interface do
 
     describe "#options" do
       it "should list inherited options" do
-        face.options.should =~ [:inherited, :local]
+        expect(face.options).to match_array([:inherited, :local])
       end
 
       it "should see all options on face actions" do
-        face.get_action(:face_action).options.should =~ [:inherited, :local]
+        expect(face.get_action(:face_action).options).to match_array([:inherited, :local])
       end
 
       it "should see all options on inherited actions accessed on the subclass" do
-        face.get_action(:parent_action).options.should =~ [:inherited, :local]
+        expect(face.get_action(:parent_action).options).to match_array([:inherited, :local])
       end
 
       it "should not see subclass actions on the parent class" do
-        parent.options.should =~ [:inherited]
+        expect(parent.options).to match_array([:inherited])
       end
 
       it "should not see subclass actions on actions accessed on the parent class" do
-        parent.get_action(:parent_action).options.should =~ [:inherited]
+        expect(parent.get_action(:parent_action).options).to match_array([:inherited])
       end
     end
 
     describe "#get_option" do
       it "should return an inherited option object" do
-        face.get_option(:inherited).should be_an_instance_of subject::Option
+        expect(face.get_option(:inherited)).to be_an_instance_of subject::Option
       end
     end
   end