puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/util/metric_spec.rb

@@ -8,80 +8,65 @@ describe Puppet::Util::Metric do
     @metric = Puppet::Util::Metric.new("foo")
   end
 
-  it "should be aliased to Puppet::Metric" do
-    Puppet::Util::Metric.should equal(Puppet::Metric)
-  end
-
-  [:type, :name, :value, :label, :basedir].each do |name|
+  [:type, :name, :value, :label].each do |name|
     it "should have a #{name} attribute" do
-      @metric.should respond_to(name)
-      @metric.should respond_to(name.to_s + "=")
+      expect(@metric).to respond_to(name)
+      expect(@metric).to respond_to(name.to_s + "=")
     end
   end
 
-  it "should default to the :rrdir as the basedir "do
-    rrddir = File.expand_path("myrrd")
-    Puppet[:rrddir] = rrddir
-    @metric.basedir.should == rrddir
-  end
-
-  it "should use any provided basedir" do
-    @metric.basedir = "foo"
-    @metric.basedir.should == "foo"
-  end
-
   it "should require a name at initialization" do
-    lambda { Puppet::Util::Metric.new }.should raise_error(ArgumentError)
+    expect { Puppet::Util::Metric.new }.to raise_error(ArgumentError)
   end
 
   it "should always convert its name to a string" do
-    Puppet::Util::Metric.new(:foo).name.should == "foo"
+    expect(Puppet::Util::Metric.new(:foo).name).to eq("foo")
   end
 
   it "should support a label" do
-    Puppet::Util::Metric.new("foo", "mylabel").label.should == "mylabel"
+    expect(Puppet::Util::Metric.new("foo", "mylabel").label).to eq("mylabel")
   end
 
   it "should autogenerate a label if none is provided" do
-    Puppet::Util::Metric.new("foo_bar").label.should == "Foo bar"
+    expect(Puppet::Util::Metric.new("foo_bar").label).to eq("Foo bar")
   end
 
   it "should have a method for adding values" do
-    @metric.should respond_to(:newvalue)
+    expect(@metric).to respond_to(:newvalue)
   end
 
   it "should have a method for returning values" do
-    @metric.should respond_to(:values)
+    expect(@metric).to respond_to(:values)
   end
 
   it "should require a name and value for its values" do
-    lambda { @metric.newvalue }.should raise_error(ArgumentError)
+    expect { @metric.newvalue }.to raise_error(ArgumentError)
   end
 
   it "should support a label for values" do
     @metric.newvalue("foo", 10, "label")
-    @metric.values[0][1].should == "label"
+    expect(@metric.values[0][1]).to eq("label")
   end
 
   it "should autogenerate value labels if none is provided" do
     @metric.newvalue("foo_bar", 10)
-    @metric.values[0][1].should == "Foo bar"
+    expect(@metric.values[0][1]).to eq("Foo bar")
   end
 
   it "should return its values sorted by label" do
     @metric.newvalue("foo", 10, "b")
     @metric.newvalue("bar", 10, "a")
 
-    @metric.values.should == [["bar", "a", 10], ["foo", "b", 10]]
+    expect(@metric.values).to eq([["bar", "a", 10], ["foo", "b", 10]])
   end
 
   it "should use an array indexer method to retrieve individual values" do
     @metric.newvalue("foo", 10)
-    @metric["foo"].should == 10
+    expect(@metric["foo"]).to eq(10)
   end
 
   it "should return nil if the named value cannot be found" do
-    @metric["foo"].should == 0
+    expect(@metric["foo"]).to eq(0)
   end
 
   it "should round trip through pson" do
@@ -91,8 +76,8 @@ describe Puppet::Util::Metric do
 
     tripped = Puppet::Util::Metric.from_data_hash(PSON.parse(metric.to_pson))
 
-    tripped.name.should == metric.name
-    tripped.label.should == metric.label
-    tripped.values.should == metric.values
+    expect(tripped.name).to eq(metric.name)
+    expect(tripped.label).to eq(metric.label)
+    expect(tripped.values).to eq(metric.values)
   end
 end

data/spec/unit/util/monkey_patches_spec.rb

@@ -7,110 +7,7 @@ require 'puppet/util/monkey_patches'
 describe Symbol do
   it "should return self from #intern" do
     symbol = :foo
-    symbol.should equal symbol.intern
-  end
-end
-
-
-describe "yaml deserialization" do
-  it "should call yaml_initialize when deserializing objects that have that method defined" do
-    class Puppet::TestYamlInitializeClass
-      attr_reader :foo
-
-      def yaml_initialize(tag, var)
-        var.should == {'foo' => 100}
-        instance_variables.should == []
-        @foo = 200
-      end
-    end
-
-    obj = YAML.load("--- !ruby/object:Puppet::TestYamlInitializeClass\n  foo: 100")
-    obj.foo.should == 200
-  end
-
-  it "should not call yaml_initialize if not defined" do
-    class Puppet::TestYamlNonInitializeClass
-      attr_reader :foo
-    end
-
-    obj = YAML.load("--- !ruby/object:Puppet::TestYamlNonInitializeClass\n  foo: 100")
-    obj.foo.should == 100
-  end
-end
-
-# In Ruby > 1.8.7 this is a builtin, otherwise we monkey patch the method in
-describe Array do
-  describe "#combination" do
-    it "should fail if wrong number of arguments given" do
-      expect { [1,2,3].combination() }.to raise_error(ArgumentError, /wrong number/)
-      expect { [1,2,3].combination(1,2) }.to raise_error(ArgumentError, /wrong number/)
-    end
-
-    it "should return an empty array if combo size than array size or negative" do
-      [1,2,3].combination(4).to_a.should == []
-      [1,2,3].combination(-1).to_a.should == []
-    end
-
-    it "should return an empty array with an empty array if combo size == 0" do
-      [1,2,3].combination(0).to_a.should == [[]]
-    end
-
-    it "should all provide all combinations of size passed in" do
-      [1,2,3,4].combination(1).to_a.should == [[1], [2], [3], [4]]
-      [1,2,3,4].combination(2).to_a.should == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
-      [1,2,3,4].combination(3).to_a.should == [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
-    end
-  end
-
-  describe "#count" do
-    it "should equal length" do
-      [].count.should == [].length
-      [1].count.should == [1].length
-    end
-  end
-
-  describe "#drop" do
-    it "should raise if asked to drop less than zero items" do
-      expect { [].drop(-1) }.to raise_error ArgumentError
-    end
-
-    it "should return the array when drop 0" do
-      [].drop(0).should == []
-      [1].drop(0).should == [1]
-      [1,2].drop(0).should == [1,2]
-    end
-
-    it "should return an empty array when dropping more items than the array" do
-      (1..10).each do |n|
-        [].drop(n).should == []
-        [1].drop(n).should == []
-      end
-    end
-
-    it "should drop the right number of items" do
-      [1,2,3].drop(0).should == [1,2,3]
-      [1,2,3].drop(1).should == [2,3]
-      [1,2,3].drop(2).should == [3]
-      [1,2,3].drop(3).should == []
-    end
-  end
-
-  describe "#respond_to?" do
-    it "should return true for a standard method (each)" do
-      [].respond_to?(:each).should be_true
-    end
-
-    it "should return false for to_hash" do
-      [].respond_to?(:to_hash).should be_false
-    end
-
-    it "should accept one argument" do
-      lambda { [].respond_to?(:each) }.should_not raise_error
-    end
-
-    it "should accept two arguments" do
-      lambda { [].respond_to?(:each, false) }.should_not raise_error
-    end
+    expect(symbol).to equal symbol.intern
   end
 end
 
@@ -120,34 +17,16 @@ describe IO do
   let(:file) { tmpfile('io-binary') }
   let(:content) { "\x01\x02\x03\x04" }
 
-  describe "::binread" do
-    it "should read in binary mode" do
-      File.open(file, 'wb') {|f| f.write(content) }
-      IO.binread(file).should == content
-    end
-
-    it "should read with a length and offset" do
-      offset = 1
-      length = 2
-      File.open(file, 'wb') {|f| f.write(content) }
-      IO.binread(file, length, offset).should == content[offset..length]
-    end
-
-    it "should raise an error if the file doesn't exist" do
-      expect { IO.binread('/path/does/not/exist') }.to raise_error(Errno::ENOENT)
-    end
-  end
-
   describe "::binwrite" do
     it "should write in binary mode" do
-      IO.binwrite(file, content).should == content.length
-      File.open(file, 'rb') {|f| f.read.should == content }
+      expect(IO.binwrite(file, content)).to eq(content.length)
+      File.open(file, 'rb') {|f| expect(f.read).to eq(content) }
     end
 
     (0..10).each do |offset|
       it "should write correctly using an offset of #{offset}" do
-        IO.binwrite(file, content, offset).should == content.length
-        File.open(file, 'rb') {|f| f.read.should == ("\x00" * offset) + content }
+        expect(IO.binwrite(file, content, offset)).to eq(content.length)
+        File.open(file, 'rb') {|f| expect(f.read).to eq(("\x00" * offset) + content) }
       end
     end
 
@@ -156,8 +35,8 @@ describe IO do
       before :each do IO.binwrite(file, input) end
 
       it "should truncate if no offset is given" do
-        IO.binwrite(file, "boo").should == 3
-        File.read(file).should == "boo"
+        expect(IO.binwrite(file, "boo")).to eq(3)
+        expect(File.read(file)).to eq("boo")
       end
 
       (0..10).each do |offset|
@@ -165,15 +44,15 @@ describe IO do
           expect = input.dup
           expect[offset, 3] = "BAM"
 
-          IO.binwrite(file, "BAM", offset).should == 3
-          File.read(file).should == expect
+          expect(IO.binwrite(file, "BAM", offset)).to eq(3)
+          expect(File.read(file)).to eq(expect)
         end
       end
 
       it "should pad with NULL bytes if writing past EOF without truncate" do
         expect = input + ("\x00" * 4) + "BAM"
-        IO.binwrite(file, "BAM", input.length + 4).should == 3
-        File.read(file).should == expect
+        expect(IO.binwrite(file, "BAM", input.length + 4)).to eq(3)
+        expect(File.read(file)).to eq(expect)
       end
     end
 
@@ -186,7 +65,7 @@ end
 describe Range do
   def do_test( range, other, expected )
     result = range.intersection(other)
-    result.should == expected
+    expect(result).to eq(expected)
   end
 
   it "should return expected ranges for iterable things" do
@@ -262,21 +141,21 @@ end
 
 describe OpenSSL::SSL::SSLContext do
   it 'disables SSLv2 via the SSLContext#options bitmask' do
-    (subject.options & OpenSSL::SSL::OP_NO_SSLv2).should == OpenSSL::SSL::OP_NO_SSLv2
+    expect(subject.options & OpenSSL::SSL::OP_NO_SSLv2).to eq(OpenSSL::SSL::OP_NO_SSLv2)
   end
 
   it 'disables SSLv3 via the SSLContext#options bitmask' do
-    (subject.options & OpenSSL::SSL::OP_NO_SSLv3).should == OpenSSL::SSL::OP_NO_SSLv3
+    expect(subject.options & OpenSSL::SSL::OP_NO_SSLv3).to eq(OpenSSL::SSL::OP_NO_SSLv3)
   end
 
   it 'explicitly disable SSLv2 ciphers using the ! prefix so they cannot be re-added' do
     cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    cipher_str.split(':').should include('!SSLv2')
+    expect(cipher_str.split(':')).to include('!SSLv2')
   end
 
   it 'does not exclude SSLv3 ciphers shared with TLSv1' do
     cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    cipher_str.split(':').should_not include('!SSLv3')
+    expect(cipher_str.split(':')).not_to include('!SSLv3')
   end
 
   it 'sets parameters on initialization' do
@@ -288,7 +167,7 @@ describe OpenSSL::SSL::SSLContext do
     ciphers = subject.ciphers.select do |name, version, bits, alg_bits|
       /SSLv2/.match(version)
     end
-    ciphers.should be_empty
+    expect(ciphers).to be_empty
   end
 end
 
@@ -335,6 +214,6 @@ end
 
 describe SecureRandom do
   it 'generates a properly formatted uuid' do
-    SecureRandom.uuid.should =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+    expect(SecureRandom.uuid).to match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)
   end
 end

data/spec/unit/util/nagios_maker_spec.rb

@@ -15,13 +15,13 @@ describe Puppet::Util::NagiosMaker do
   end
 
   it "should be able to create a new nagios type" do
-    @module.should respond_to(:create_nagios_type)
+    expect(@module).to respond_to(:create_nagios_type)
   end
 
   it "should fail if it cannot find the named Naginator type" do
     Nagios::Base.stubs(:type).returns(nil)
 
-    lambda { @module.create_nagios_type(:no_such_type) }.should raise_error(Puppet::DevError)
+    expect { @module.create_nagios_type(:no_such_type) }.to raise_error(Puppet::DevError)
   end
 
   it "should create a new RAL type with the provided name prefixed with 'nagios_'" do

data/spec/unit/util/network_device/cisco/device_spec.rb

@@ -14,38 +14,38 @@ describe Puppet::Util::NetworkDevice::Cisco::Device do
   describe "when creating the device" do
     it "should find the enable password from the url" do
       cisco = Puppet::Util::NetworkDevice::Cisco::Device.new("telnet://user:password@localhost:23/?enable=enable_password")
-      cisco.enable_password.should == "enable_password"
+      expect(cisco.enable_password).to eq("enable_password")
     end
 
     describe "decoding the enable password" do
       it "should not parse a password if no query is given" do
         cisco = described_class.new("telnet://user:password@localhost:23")
-        cisco.enable_password.should be_nil
+        expect(cisco.enable_password).to be_nil
       end
 
       it "should not parse a password if no enable param is given" do
         cisco = described_class.new("telnet://user:password@localhost:23/?notenable=notapassword")
-        cisco.enable_password.should be_nil
+        expect(cisco.enable_password).to be_nil
       end
       it "should decode sharps" do
         cisco = described_class.new("telnet://user:password@localhost:23/?enable=enable_password%23with_a_sharp")
-        cisco.enable_password.should == "enable_password#with_a_sharp"
+        expect(cisco.enable_password).to eq("enable_password#with_a_sharp")
       end
 
       it "should decode spaces" do
         cisco = described_class.new("telnet://user:password@localhost:23/?enable=enable_password%20with_a_space")
-        cisco.enable_password.should == "enable_password with_a_space"
+        expect(cisco.enable_password).to eq("enable_password with_a_space")
       end
 
       it "should only use the query parameter" do
         cisco = described_class.new("telnet://enable=:password@localhost:23/?enable=enable_password&notenable=notapassword")
-        cisco.enable_password.should == "enable_password"
+        expect(cisco.enable_password).to eq("enable_password")
       end
     end
 
     it "should find the enable password from the options" do
       cisco = Puppet::Util::NetworkDevice::Cisco::Device.new("telnet://user:password@localhost:23/?enable=enable_password", :enable_password => "mypass")
-      cisco.enable_password.should == "mypass"
+      expect(cisco.enable_password).to eq("mypass")
     end
 
     it "should find the debug mode from the options" do
@@ -133,7 +133,7 @@ describe Puppet::Util::NetworkDevice::Cisco::Device do
     describe "when entering enable password" do
       it "should raise an error if no enable password has been set" do
         @cisco.enable_password = nil
-        lambda{ @cisco.enable }.should raise_error
+        expect{ @cisco.enable }.to raise_error
       end
 
       it "should send the enable command and expect an enable prompt" do
@@ -165,7 +165,7 @@ Switch#
 eos
 
       @cisco.find_capabilities
-      @cisco.should_not be_support_vlan_brief
+      expect(@cisco).not_to be_support_vlan_brief
     end
   end
 
@@ -183,7 +183,7 @@ eos
     "VLAN99" => "VLAN99"
   }.each do |input,expected|
     it "should canonicalize #{input} to #{expected}" do
-      @cisco.canonalize_ifname(input).should == expected
+      expect(@cisco.canonalize_ifname(input)).to eq(expected)
     end
   end
 
@@ -213,27 +213,27 @@ eos
     it "should parse interface output" do
       @cisco.expects(:parse_interface).returns({ :ensure => :present })
 
-      @cisco.interface("FastEthernet0/1").should == { :ensure => :present }
+      expect(@cisco.interface("FastEthernet0/1")).to eq({ :ensure => :present })
     end
 
     it "should parse trunking and merge results" do
       @cisco.stubs(:parse_interface).returns({ :ensure => :present })
       @cisco.expects(:parse_trunking).returns({ :native_vlan => "100" })
 
-      @cisco.interface("FastEthernet0/1").should == { :ensure => :present, :native_vlan => "100" }
+      expect(@cisco.interface("FastEthernet0/1")).to eq({ :ensure => :present, :native_vlan => "100" })
     end
 
     it "should return an absent interface if parse_interface returns nothing" do
       @cisco.stubs(:parse_interface).returns({})
 
-      @cisco.interface("FastEthernet0/1").should == { :ensure => :absent }
+      expect(@cisco.interface("FastEthernet0/1")).to eq({ :ensure => :absent })
     end
 
     it "should parse ip address information and merge results" do
       @cisco.stubs(:parse_interface).returns({ :ensure => :present })
       @cisco.expects(:parse_interface_config).returns({ :ipaddress => [24,IPAddr.new('192.168.0.24'), nil] })
 
-      @cisco.interface("FastEthernet0/1").should == { :ensure => :present, :ipaddress => [24,IPAddr.new('192.168.0.24'), nil] }
+      expect(@cisco.interface("FastEthernet0/1")).to eq({ :ensure => :present, :ipaddress => [24,IPAddr.new('192.168.0.24'), nil] })
     end
 
     it "should parse the sh interface command" do
@@ -266,7 +266,7 @@ FastEthernet0/1 is down, line protocol is down
 Switch#
 eos
 
-      @cisco.parse_interface("FastEthernet0/1").should == { :ensure => :absent, :duplex => :auto, :speed => :auto }
+      expect(@cisco.parse_interface("FastEthernet0/1")).to eq({ :ensure => :absent, :duplex => :auto, :speed => :auto })
     end
 
     it "should be able to parse the sh vlan brief command output" do
@@ -285,7 +285,7 @@ VLAN Name                             Status    Ports
 Switch#
 eos
 
-      @cisco.parse_vlans.should == {"100"=>{:status=>"active", :interfaces=>["FastEthernet0/1", "FastEthernet0/2"], :description=>"management", :name=>"100"}, "1"=>{:status=>"active", :interfaces=>["FastEthernet0/3", "FastEthernet0/4", "FastEthernet0/5", "FastEthernet0/6", "FastEthernet0/7", "FastEthernet0/8", "FastEthernet0/9", "FastEthernet0/10", "FastEthernet0/11", "FastEthernet0/12", "FastEthernet0/13", "FastEthernet0/14", "FastEthernet0/15", "FastEthernet0/16", "FastEthernet0/17", "FastEthernet0/18", "FastEthernet0/23", "FastEthernet0/24"], :description=>"default", :name=>"1"}, "10"=>{:status=>"active", :interfaces=>[], :description=>"VLAN0010", :name=>"10"}}
+      expect(@cisco.parse_vlans).to eq({"100"=>{:status=>"active", :interfaces=>["FastEthernet0/1", "FastEthernet0/2"], :description=>"management", :name=>"100"}, "1"=>{:status=>"active", :interfaces=>["FastEthernet0/3", "FastEthernet0/4", "FastEthernet0/5", "FastEthernet0/6", "FastEthernet0/7", "FastEthernet0/8", "FastEthernet0/9", "FastEthernet0/10", "FastEthernet0/11", "FastEthernet0/12", "FastEthernet0/13", "FastEthernet0/14", "FastEthernet0/15", "FastEthernet0/16", "FastEthernet0/17", "FastEthernet0/18", "FastEthernet0/23", "FastEthernet0/24"], :description=>"default", :name=>"1"}, "10"=>{:status=>"active", :interfaces=>[], :description=>"VLAN0010", :name=>"10"}})
     end
 
     it "should parse trunk switchport information" do
@@ -312,7 +312,7 @@ Self Loopback: No
 Switch#
 eos
 
-      @cisco.parse_trunking("FastEthernet0/21").should == { :mode => :trunk, :encapsulation => :dot1q, :allowed_trunk_vlans=>:all, }
+      expect(@cisco.parse_trunking("FastEthernet0/21")).to eq({ :mode => :trunk, :encapsulation => :dot1q, :allowed_trunk_vlans=>:all, })
     end
 
     it "should parse trunk switchport information with allowed vlans" do
@@ -350,7 +350,7 @@ Appliance trust: none
 c2960#
 eos
 
-      @cisco.parse_trunking("GigabitEthernet 0/1").should == { :mode => :trunk, :encapsulation => :dot1q, :allowed_trunk_vlans=>"1,99", }
+      expect(@cisco.parse_trunking("GigabitEthernet 0/1")).to eq({ :mode => :trunk, :encapsulation => :dot1q, :allowed_trunk_vlans=>"1,99", })
     end
 
     it "should parse access switchport information" do
@@ -376,7 +376,7 @@ Self Loopback: No
 Switch#
 eos
 
-      @cisco.parse_trunking("FastEthernet0/1").should == { :mode => :access, :native_vlan => "100" }
+      expect(@cisco.parse_trunking("FastEthernet0/1")).to eq({ :mode => :access, :native_vlan => "100" })
     end
 
     it "should parse ip addresses" do
@@ -407,9 +407,9 @@ end
 
 router#
 eos
-      @cisco.parse_interface_config("Vlan 1").should == {:ipaddress=>[[24, IPAddr.new('192.168.0.24'), 'secondary'],
+      expect(@cisco.parse_interface_config("Vlan 1")).to eq({:ipaddress=>[[24, IPAddr.new('192.168.0.24'), 'secondary'],
                                                                       [24, IPAddr.new('192.168.0.1'), nil],
-                                                                      [64, IPAddr.new('2001:07a8:71c1::'), "eui-64"]]}
+                                                                      [64, IPAddr.new('2001:07a8:71c1::'), "eui-64"]]})
     end
 
     it "should parse etherchannel membership" do
@@ -426,7 +426,7 @@ end
 
 c2960#
 eos
-      @cisco.parse_interface_config("Gi0/17").should == {:etherchannel=>"1"}
+      expect(@cisco.parse_interface_config("Gi0/17")).to eq({:etherchannel=>"1"})
     end
   end
 
@@ -437,7 +437,7 @@ eos
 
       facts.expects(:retrieve).returns(:facts)
 
-      @cisco.facts.should == :facts
+      expect(@cisco.facts).to eq(:facts)
     end
   end