puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device'
@@ -6,7 +5,7 @@ require 'puppet/util/network_device/cisco/facts'
 
 describe Puppet::Util::NetworkDevice::Cisco::Facts do
   before(:each) do
-    @transport = stub_everything 'transport'
+    @transport = double('transport')
     @facts = Puppet::Util::NetworkDevice::Cisco::Facts.new(@transport)
   end
 
@@ -18,7 +17,7 @@ describe Puppet::Util::NetworkDevice::Cisco::Facts do
     "cisco WS-C2950T-24 (RC32300) processor (revision R0) with 19959K bytes of memory." => {:hardwaremodel=>"WS-C2950T-24", :memorysize => "19959K", :processor => "RC32300", :hardwarerevision => "R0" }
   }.each do |ver, expected|
     it "should parse show ver output for hardware device facts" do
-      @transport.stubs(:command).with("sh ver").returns(<<eos)
+      allow(@transport).to receive(:command).with("sh ver").and_return(<<eos)
 Switch>sh ver
 #{ver}
 Switch>
@@ -36,7 +35,7 @@ eos
 "c2950 uptime is 2 years, 20 weeks, 6 minutes" => { :hostname => "c2950", :uptime=>"2 years, 20 weeks, 6 minutes", :uptime_seconds=>75168360, :uptime_days=>870 }
   }.each do |ver, expected|
     it "should parse show ver output for device uptime facts" do
-      @transport.stubs(:command).with("sh ver").returns(<<eos)
+      allow(@transport).to receive(:command).with("sh ver").and_return(<<eos)
 Switch>sh ver
 #{ver}
 Switch>
@@ -53,7 +52,7 @@ eos
 "Cisco IOS Software, 1841 Software (C1841-ADVSECURITYK9-M), Version 12.4(24)T4, RELEASE SOFTWARE (fc2)" =>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(24)T4", :operatingsystemmajrelease => "12.4T", :operatingsystemfeature => "ADVSECURITYK9"},
   }.each do |ver, expected|
     it "should parse show ver output for device software version facts" do
-      @transport.stubs(:command).with("sh ver").returns(<<eos)
+      allow(@transport).to receive(:command).with("sh ver").and_return(<<eos)
 Switch>sh ver
 #{ver}
 Switch>

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device'
@@ -6,7 +5,7 @@ require 'puppet/util/network_device/cisco/interface'
 
 describe Puppet::Util::NetworkDevice::Cisco::Interface do
   before(:each) do
-    @transport = stub_everything 'transport'
+    @transport = double('transport', command: nil)
     @interface = Puppet::Util::NetworkDevice::Cisco::Interface.new("FastEthernet0/1",@transport)
   end
 
@@ -16,72 +15,82 @@ describe Puppet::Util::NetworkDevice::Cisco::Interface do
 
   describe "when updating the physical device" do
     it "should enter global configuration mode" do
-      @transport.expects(:command).with("conf t")
+      expect(@transport).to receive(:command).with("conf t")
       @interface.update
     end
 
     it "should enter interface configuration mode" do
-      @transport.expects(:command).with("interface FastEthernet0/1")
+      expect(@transport).to receive(:command).with("interface FastEthernet0/1")
       @interface.update
     end
 
     it "should 'execute' all differing properties" do
-      @interface.expects(:execute).with(:description, "b")
-      @interface.expects(:execute).with(:mode, :access).never
+      expect(@interface).to receive(:execute).with(:description, "b")
+      expect(@interface).not_to receive(:execute).with(:mode, :access)
       @interface.update({ :description => "a", :mode => :access }, { :description => "b", :mode => :access })
     end
 
     it "should execute in cisco ios defined order" do
-      speed = states('speed').starts_as('notset')
-      @interface.expects(:execute).with(:speed, :auto).then(speed.is('set'))
-      @interface.expects(:execute).with(:duplex, :auto).when(speed.is('set'))
+      set_speed = false
+      set_duplex = false
+      allow(@interface).to receive(:execute) do |*args|
+        if set_speed
+          expect(args).to eq([:duplex, :auto])
+          set_duplex = true
+        else
+          expect(args).to eq([:speed, :auto])
+          set_speed = true
+        end
+      end
+
       @interface.update({ :duplex => :half, :speed => "10" }, { :duplex => :auto, :speed => :auto  })
+      expect(set_speed).to eq(true)
+      expect(set_duplex).to eq(true)
     end
 
     it "should execute absent properties with a no prefix" do
-      @interface.expects(:execute).with(:description, "a", "no ")
+      expect(@interface).to receive(:execute).with(:description, "a", "no ")
       @interface.update({ :description => "a"}, { })
     end
 
     it "should exit twice" do
-      @transport.expects(:command).with("exit").twice
+      expect(@transport).to receive(:command).with("exit").twice
       @interface.update
     end
   end
 
   describe "when executing commands" do
     it "should execute string commands directly" do
-      @transport.expects(:command).with("speed auto")
+      expect(@transport).to receive(:command).with("speed auto")
       @interface.execute(:speed, :auto)
     end
 
     it "should execute string commands with the given prefix" do
-      @transport.expects(:command).with("no speed auto")
+      expect(@transport).to receive(:command).with("no speed auto")
       @interface.execute(:speed, :auto, "no ")
     end
 
     it "should stop at executing the first command that works for array" do
-      @transport.expects(:command).with("channel-group 1").yields("% Invalid command")
-      @transport.expects(:command).with("port group 1")
+      expect(@transport).to receive(:command).with("channel-group 1").and_yield("% Invalid command")
+      expect(@transport).to receive(:command).with("port group 1")
       @interface.execute(:etherchannel, "1")
     end
 
     it "should execute the block for block commands" do
-      @transport.expects(:command).with("ip address 192.168.0.1 255.255.255.0")
+      expect(@transport).to receive(:command).with("ip address 192.168.0.1 255.255.255.0")
       @interface.execute(:ipaddress, [[24, IPAddr.new('192.168.0.1'), nil]])
     end
 
     it "should execute the block for block commands" do
-      @transport.expects(:command).with("ipv6 address fe08::/76 link-local")
+      expect(@transport).to receive(:command).with("ipv6 address fe08::/76 link-local")
       @interface.execute(:ipaddress, [[76, IPAddr.new('fe08::'), 'link-local']])
     end
-
   end
 
   describe "when sending commands to the device" do
     it "should detect errors" do
-      Puppet.expects(:err)
-      @transport.stubs(:command).yields("% Invalid Command")
+      expect(Puppet).to receive(:err)
+      allow(@transport).to receive(:command).and_yield("% Invalid Command")
       @interface.command("sh ver")
     end
   end

data/spec/unit/util/network_device/config_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device/config'

data/spec/unit/util/network_device/ipcalc_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device/ipcalc'

data/spec/unit/util/network_device/transport/base_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device/transport/base'
@@ -13,28 +12,28 @@ describe Puppet::Util::NetworkDevice::Transport::Base do
 
   describe "when sending commands" do
     it "should send the command to the telnet session" do
-      @transport.expects(:send).with("line")
+      expect(@transport).to receive(:send).with("line")
       @transport.command("line")
     end
 
     it "should expect an output matching the given prompt" do
-      @transport.expects(:expect).with(/prompt/)
+      expect(@transport).to receive(:expect).with(/prompt/)
       @transport.command("line", :prompt => /prompt/)
     end
 
     it "should expect an output matching the default prompt" do
       @transport.default_prompt = /defprompt/
-      @transport.expects(:expect).with(/defprompt/)
+      expect(@transport).to receive(:expect).with(/defprompt/)
       @transport.command("line")
     end
 
     it "should yield telnet output to the given block" do
-      @transport.expects(:expect).yields("output")
+      expect(@transport).to receive(:expect).and_yield("output")
       @transport.command("line") { |out| expect(out).to eq("output") }
     end
 
     it "should return telnet output to the caller" do
-      @transport.expects(:expect).returns("output")
+      expect(@transport).to receive(:expect).and_return("output")
       expect(@transport.command("line")).to eq("output")
     end
   end

data/spec/unit/util/network_device/transport/ssh_spec.rb

@@ -1,10 +1,8 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device/transport/ssh'
 
 describe Puppet::Util::NetworkDevice::Transport::Ssh, :if => Puppet.features.ssh? do
-
   before(:each) do
     @transport = Puppet::Util::NetworkDevice::Transport::Ssh.new()
   end
@@ -14,7 +12,12 @@ describe Puppet::Util::NetworkDevice::Transport::Ssh, :if => Puppet.features.ssh
   end
 
   it "should connect to the given host and port" do
-    Net::SSH.expects(:start).with { |host, user, args| host == "localhost" && args[:port] == 22 }.returns stub_everything
+    ssh_connection = double(
+      "ssh connection",
+      open_channel: nil,
+      loop: nil,
+    )
+    expect(Net::SSH).to receive(:start).with("localhost", anything, hash_including(port: 22)).and_return(ssh_connection)
     @transport.host = "localhost"
     @transport.port = 22
 
@@ -22,7 +25,12 @@ describe Puppet::Util::NetworkDevice::Transport::Ssh, :if => Puppet.features.ssh
   end
 
   it "should connect using the given username and password" do
-    Net::SSH.expects(:start).with { |host, user, args| user == "user" && args[:password] == "pass" }.returns stub_everything
+    ssh_connection = double(
+      "ssh connection",
+      open_channel: nil,
+      loop: nil,
+    )
+    expect(Net::SSH).to receive(:start).with(anything, "user", hash_including(password: "pass")).and_return(ssh_connection)
     @transport.user = "user"
     @transport.password = "pass"
 
@@ -30,7 +38,7 @@ describe Puppet::Util::NetworkDevice::Transport::Ssh, :if => Puppet.features.ssh
   end
 
   it "should raise a Puppet::Error when encountering an authentication failure" do
-    Net::SSH.expects(:start).raises Net::SSH::AuthenticationFailed
+    expect(Net::SSH).to receive(:start).and_raise(Net::SSH::AuthenticationFailed)
     @transport.host = "localhost"
     @transport.user = "user"
 
@@ -39,180 +47,206 @@ describe Puppet::Util::NetworkDevice::Transport::Ssh, :if => Puppet.features.ssh
 
   describe "when connected" do
     before(:each) do
-      @ssh = stub_everything 'ssh'
-      @channel = stub_everything 'channel'
-      Net::SSH.stubs(:start).returns @ssh
-      @ssh.stubs(:open_channel).yields(@channel)
-      @transport.stubs(:expect)
+      @ssh = double(
+        'ssh',
+        loop: nil,
+      )
+      @channel = double(
+        'channel',
+        request_pty: nil,
+        send_channel_request: nil,
+        on_close: nil,
+        on_extended_data: nil,
+        on_data: nil,
+      )
+      allow(Net::SSH).to receive(:start).and_return(@ssh)
+      allow(@ssh).to receive(:open_channel).and_yield(@channel)
+      allow(@transport).to receive(:expect)
     end
 
     it "should open a channel" do
-      @ssh.expects(:open_channel)
+      expect(@ssh).to receive(:open_channel)
 
       @transport.connect
     end
 
     it "should request a pty" do
-      @channel.expects(:request_pty)
+      expect(@channel).to receive(:request_pty)
 
       @transport.connect
     end
 
     it "should create a shell channel" do
-      @channel.expects(:send_channel_request).with("shell")
+      expect(@channel).to receive(:send_channel_request).with("shell")
       @transport.connect
     end
 
     it "should raise an error if shell channel creation fails" do
-      @channel.expects(:send_channel_request).with("shell").yields(@channel, false)
+      expect(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, false)
       expect { @transport.connect }.to raise_error(RuntimeError, /failed to open ssh shell channel/)
     end
 
     it "should register an on_data and on_extended_data callback" do
-      @channel.expects(:send_channel_request).with("shell").yields(@channel, true)
-      @channel.expects(:on_data)
-      @channel.expects(:on_extended_data)
+      expect(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      expect(@channel).to receive(:on_data)
+      expect(@channel).to receive(:on_extended_data)
       @transport.connect
     end
 
     it "should accumulate data to the buffer on data" do
-      @channel.expects(:send_channel_request).with("shell").yields(@channel, true)
-      @channel.expects(:on_data).yields(@channel, "data")
+      expect(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      expect(@channel).to receive(:on_data).and_yield(@channel, "data")
 
       @transport.connect
       expect(@transport.buf).to eq("data")
     end
 
     it "should accumulate data to the buffer on extended data" do
-      @channel.expects(:send_channel_request).with("shell").yields(@channel, true)
-      @channel.expects(:on_extended_data).yields(@channel, 1, "data")
+      expect(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      expect(@channel).to receive(:on_extended_data).and_yield(@channel, 1, "data")
 
       @transport.connect
       expect(@transport.buf).to eq("data")
     end
 
     it "should mark eof on close" do
-      @channel.expects(:send_channel_request).with("shell").yields(@channel, true)
-      @channel.expects(:on_close).yields(@channel)
+      expect(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      expect(@channel).to receive(:on_close).and_yield()
 
       @transport.connect
       expect(@transport).to be_eof
     end
 
     it "should expect output to conform to the default prompt" do
-      @channel.expects(:send_channel_request).with("shell").yields(@channel, true)
-      @transport.expects(:default_prompt).returns("prompt")
-      @transport.expects(:expect).with("prompt")
+      expect(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      expect(@transport).to receive(:default_prompt).and_return("prompt")
+      expect(@transport).to receive(:expect).with("prompt")
       @transport.connect
     end
 
     it "should start the ssh loop" do
-      @ssh.expects(:loop)
+      expect(@ssh).to receive(:loop)
       @transport.connect
     end
   end
 
   describe "when closing" do
     before(:each) do
-      @ssh = stub_everything 'ssh'
-      @channel = stub_everything 'channel'
-      Net::SSH.stubs(:start).returns @ssh
-      @ssh.stubs(:open_channel).yields(@channel)
-      @channel.stubs(:send_channel_request).with("shell").yields(@channel, true)
-      @transport.stubs(:expect)
+      @ssh = double('ssh', close: nil)
+      @channel = double(
+        'channel',
+        request_pty: nil,
+        on_data: nil,
+        on_extended_data: nil,
+        on_close: nil,
+        close: nil,
+      )
+      allow(Net::SSH).to receive(:start).and_return(@ssh)
+      allow(@ssh).to receive(:open_channel).and_yield(@channel)
+      allow(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      allow(@transport).to receive(:expect)
       @transport.connect
     end
 
     it "should close the channel" do
-      @channel.expects(:close)
+      expect(@channel).to receive(:close)
       @transport.close
     end
 
     it "should close the ssh session" do
-      @ssh.expects(:close)
+      expect(@ssh).to receive(:close)
       @transport.close
     end
   end
 
   describe "when sending commands" do
     before(:each) do
-      @ssh = stub_everything 'ssh'
-      @channel = stub_everything 'channel'
-      Net::SSH.stubs(:start).returns @ssh
-      @ssh.stubs(:open_channel).yields(@channel)
-      @channel.stubs(:send_channel_request).with("shell").yields(@channel, true)
-      @transport.stubs(:expect)
+      @ssh = double('ssh')
+      @channel = double(
+        'channel',
+        request_pty: nil,
+        on_data: nil,
+        on_extended_data: nil,
+        on_close: nil,
+        send_data: nil,
+      )
+      allow(Net::SSH).to receive(:start).and_return(@ssh)
+      allow(@ssh).to receive(:open_channel).and_yield(@channel)
+      allow(@channel).to receive(:send_channel_request).with("shell").and_yield(@channel, true)
+      allow(@transport).to receive(:expect)
       @transport.connect
     end
 
     it "should send data to the ssh channel" do
-      @channel.expects(:send_data).with("data\n")
+      expect(@channel).to receive(:send_data).with("data\n")
       @transport.command("data")
     end
 
     it "should expect the default prompt afterward" do
-      @transport.expects(:default_prompt).returns("prompt")
-      @transport.expects(:expect).with("prompt")
+      expect(@transport).to receive(:default_prompt).and_return("prompt")
+      expect(@transport).to receive(:expect).with("prompt")
       @transport.command("data")
     end
 
     it "should expect the given prompt" do
-      @transport.expects(:expect).with("myprompt")
+      expect(@transport).to receive(:expect).with("myprompt")
       @transport.command("data", :prompt => "myprompt")
     end
 
     it "should yield the buffer output to given block" do
-      @transport.expects(:expect).yields("output")
+      expect(@transport).to receive(:expect).and_yield("output")
       @transport.command("data") do |out|
         expect(out).to eq("output")
       end
     end
 
     it "should return buffer output" do
-      @transport.expects(:expect).returns("output")
+      expect(@transport).to receive(:expect).and_return("output")
       expect(@transport.command("data")).to eq("output")
     end
   end
 
   describe "when expecting output" do
     before(:each) do
-      @connection = stub_everything 'connection'
-      @socket = stub_everything 'socket'
-      transport = stub 'transport', :socket => @socket
-      @ssh = stub_everything 'ssh', :transport => transport
-      @channel = stub_everything 'channel', :connection => @connection
+      @connection = double('connection')
+      @socket = double(
+        'socket',
+        :closed? => nil,
+      )
+      transport = double('transport', :socket => @socket)
+      @ssh = double('ssh', :transport => transport)
+      @channel = double('channel', :connection => @connection)
       @transport.ssh = @ssh
       @transport.channel = @channel
     end
 
     it "should process the ssh event loop" do
-      IO.stubs(:select)
+      allow(IO).to receive(:select)
       @transport.buf = "output"
-      @transport.expects(:process_ssh)
+      expect(@transport).to receive(:process_ssh)
       @transport.expect(/output/)
     end
 
     it "should return the output" do
-      IO.stubs(:select)
+      allow(IO).to receive(:select)
       @transport.buf = "output"
-      @transport.stubs(:process_ssh)
+      allow(@transport).to receive(:process_ssh)
       expect(@transport.expect(/output/)).to eq("output")
     end
 
     it "should return the output" do
-      IO.stubs(:select)
+      allow(IO).to receive(:select)
       @transport.buf = "output"
-      @transport.stubs(:process_ssh)
+      allow(@transport).to receive(:process_ssh)
       expect(@transport.expect(/output/)).to eq("output")
     end
 
     describe "when processing the ssh loop" do
       it "should advance one tick in the ssh event loop and exit on eof" do
         @transport.buf = ''
-        @connection.expects(:process).then.raises(EOFError)
+        expect(@connection).to receive(:process).and_raise(EOFError)
         @transport.process_ssh
       end
     end
   end
-
 end