puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/network_device'
-require 'puppet/util/network_device/cisco/facts'
-
-describe Puppet::Util::NetworkDevice::Cisco::Facts do
-  before(:each) do
-    @transport = double('transport')
-    @facts = Puppet::Util::NetworkDevice::Cisco::Facts.new(@transport)
-  end
-
-  {
-    "cisco WS-C2924C-XL (PowerPC403GA) processor (revision 0x11) with 8192K/1024K bytes of memory." => {:hardwaremodel => "WS-C2924C-XL", :memorysize => "8192K", :processor => "PowerPC403GA", :hardwarerevision => "0x11" },
-    "Cisco 1841 (revision 5.0) with 355328K/37888K bytes of memory." => {:hardwaremodel=>"1841", :memorysize => "355328K", :hardwarerevision => "5.0" },
-    "Cisco 877 (MPC8272) processor (revision 0x200) with 118784K/12288K bytes of memory." => {:hardwaremodel=>"877", :memorysize => "118784K", :processor => "MPC8272", :hardwarerevision => "0x200" },
-    "cisco WS-C2960G-48TC-L (PowerPC405) processor (revision C0) with 61440K/4088K bytes of memory." => {:hardwaremodel=>"WS-C2960G-48TC-L", :memorysize => "61440K", :processor => "PowerPC405", :hardwarerevision => "C0" },
-    "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
-      allow(@transport).to receive(:command).with("sh ver").and_return(<<eos)
-Switch>sh ver
-#{ver}
-Switch>
-eos
-      expect(@facts.parse_show_ver).to eq(expected)
-    end
-  end
-
-  {
-"Switch uptime is 1 year, 12 weeks, 6 days, 22 hours, 32 minutes" => { :hostname => "Switch", :uptime => "1 year, 12 weeks, 6 days, 22 hours, 32 minutes", :uptime_seconds => 39393120, :uptime_days => 455 },
-"c2950 uptime is 3 weeks, 1 day, 23 hours, 36 minutes" => { :hostname => "c2950", :uptime => "3 weeks, 1 day, 23 hours, 36 minutes", :uptime_days => 22, :uptime_seconds =>  1985760},
-"router uptime is 5 weeks, 1 day, 3 hours, 30 minutes" => { :hostname => "router", :uptime => "5 weeks, 1 day, 3 hours, 30 minutes", :uptime_days => 36, :uptime_seconds => 3123000 },
-"c2950 uptime is 1 minute" => { :hostname => "c2950", :uptime => "1 minute", :uptime_days => 0, :uptime_seconds => 60 },
-"c2950 uptime is 20 weeks, 6 minutes" => { :hostname => "c2950", :uptime=>"20 weeks, 6 minutes", :uptime_seconds=>12096360, :uptime_days=>140 },
-"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
-      allow(@transport).to receive(:command).with("sh ver").and_return(<<eos)
-Switch>sh ver
-#{ver}
-Switch>
-eos
-      expect(@facts.parse_show_ver).to eq(expected)
-    end
-  end
-
-  {
-"IOS (tm) C2900XL Software (C2900XL-C3H2S-M), Version 12.0(5)WC10, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.0(5)WC10", :operatingsystemmajrelease => "12.0WC", :operatingsystemfeature => "C3H2S"},
-"IOS (tm) C2950 Software (C2950-I6K2L2Q4-M), Version 12.1(22)EA8a, RELEASE SOFTWARE (fc1)"=> { :operatingsystem => "IOS", :operatingsystemrelease => "12.1(22)EA8a", :operatingsystemmajrelease => "12.1EA", :operatingsystemfeature => "I6K2L2Q4"},
-"Cisco IOS Software, C2960 Software (C2960-LANBASEK9-M), Version 12.2(44)SE, RELEASE SOFTWARE (fc1)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.2(44)SE", :operatingsystemmajrelease => "12.2SE", :operatingsystemfeature => "LANBASEK9"},
-"Cisco IOS Software, C870 Software (C870-ADVIPSERVICESK9-M), Version 12.4(11)XJ4, RELEASE SOFTWARE (fc2)"=>{ :operatingsystem => "IOS", :operatingsystemrelease => "12.4(11)XJ4", :operatingsystemmajrelease => "12.4XJ", :operatingsystemfeature => "ADVIPSERVICESK9"},
-"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
-      allow(@transport).to receive(:command).with("sh ver").and_return(<<eos)
-Switch>sh ver
-#{ver}
-Switch>
-eos
-      expect(@facts.parse_show_ver).to eq(expected)
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/network_device'
-require 'puppet/util/network_device/cisco/interface'
-
-describe Puppet::Util::NetworkDevice::Cisco::Interface do
-  before(:each) do
-    @transport = double('transport', command: nil)
-    @interface = Puppet::Util::NetworkDevice::Cisco::Interface.new("FastEthernet0/1",@transport)
-  end
-
-  it "should include IPCalc" do
-    @interface.class.include?(Puppet::Util::NetworkDevice::IPCalc)
-  end
-
-  describe "when updating the physical device" do
-    it "should enter global configuration mode" do
-      expect(@transport).to receive(:command).with("conf t")
-      @interface.update
-    end
-
-    it "should enter interface configuration mode" do
-      expect(@transport).to receive(:command).with("interface FastEthernet0/1")
-      @interface.update
-    end
-
-    it "should 'execute' all differing properties" do
-      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
-      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
-      expect(@interface).to receive(:execute).with(:description, "a", "no ")
-      @interface.update({ :description => "a"}, { })
-    end
-
-    it "should exit twice" do
-      expect(@transport).to receive(:command).with("exit").twice
-      @interface.update
-    end
-  end
-
-  describe "when executing commands" do
-    it "should execute string commands directly" do
-      expect(@transport).to receive(:command).with("speed auto")
-      @interface.execute(:speed, :auto)
-    end
-
-    it "should execute string commands with the given prefix" do
-      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
-      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
-      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
-      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
-      expect(Puppet).to receive(:err)
-      allow(@transport).to receive(:command).and_yield("% Invalid Command")
-      @interface.command("sh ver")
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/network_device/ipcalc'
-
-describe Puppet::Util::NetworkDevice::IPCalc do
-  class TestIPCalc
-    include Puppet::Util::NetworkDevice::IPCalc
-  end
-
-  before(:each) do
-    @ipcalc = TestIPCalc.new
-  end
-
-  describe "when parsing ip/prefix" do
-    it "should parse ipv4 without prefixes" do
-      expect(@ipcalc.parse('127.0.0.1')).to eq([32,IPAddr.new('127.0.0.1')])
-    end
-
-    it "should parse ipv4 with prefixes" do
-      expect(@ipcalc.parse('127.0.1.2/8')).to eq([8,IPAddr.new('127.0.1.2')])
-    end
-
-    it "should parse ipv6 without prefixes" do
-      expect(@ipcalc.parse('FE80::21A:2FFF:FE30:ECF0')).to eq([128,IPAddr.new('FE80::21A:2FFF:FE30:ECF0')])
-    end
-
-    it "should parse ipv6 with prefixes" do
-      expect(@ipcalc.parse('FE80::21A:2FFF:FE30:ECF0/56')).to eq([56,IPAddr.new('FE80::21A:2FFF:FE30:ECF0')])
-    end
-  end
-
-  describe "when building netmask" do
-    it "should produce the correct ipv4 netmask from prefix length" do
-      expect(@ipcalc.netmask(Socket::AF_INET, 27)).to eq(IPAddr.new('255.255.255.224'))
-    end
-
-    it "should produce the correct ipv6 netmask from prefix length" do
-      expect(@ipcalc.netmask(Socket::AF_INET6, 56)).to eq(IPAddr.new('ffff:ffff:ffff:ff00::0'))
-    end
-  end
-
-  describe "when building wildmask" do
-    it "should produce the correct ipv4 wildmask from prefix length" do
-      expect(@ipcalc.wildmask(Socket::AF_INET, 27)).to eq(IPAddr.new('0.0.0.31'))
-    end
-
-    it "should produce the correct ipv6 wildmask from prefix length" do
-      expect(@ipcalc.wildmask(Socket::AF_INET6, 126)).to eq(IPAddr.new('::3'))
-    end
-  end
-
-  describe "when computing prefix length from netmask" do
-    it "should produce the correct ipv4 prefix length" do
-      expect(@ipcalc.prefix_length(IPAddr.new('255.255.255.224'))).to eq(27)
-    end
-
-    it "should produce the correct ipv6 prefix length" do
-      expect(@ipcalc.prefix_length(IPAddr.new('fffe::0'))).to eq(15)
-    end
-  end
-end

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

@@ -1,252 +0,0 @@
-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
-
-  it "should handle login through the transport" do
-    expect(@transport).to be_handles_login
-  end
-
-  it "should connect to the given host and port" do
-    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
-
-    @transport.connect
-  end
-
-  it "should connect using the given username and password" do
-    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"
-
-    @transport.connect
-  end
-
-  it "should raise a Puppet::Error when encountering an authentication failure" do
-    expect(Net::SSH).to receive(:start).and_raise(Net::SSH::AuthenticationFailed)
-    @transport.host = "localhost"
-    @transport.user = "user"
-
-    expect { @transport.connect }.to raise_error Puppet::Error
-  end
-
-  describe "when connected" do
-    before(:each) do
-      @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
-      expect(@ssh).to receive(:open_channel)
-
-      @transport.connect
-    end
-
-    it "should request a pty" do
-      expect(@channel).to receive(:request_pty)
-
-      @transport.connect
-    end
-
-    it "should create a shell channel" do
-      expect(@channel).to receive(:send_channel_request).with("shell")
-      @transport.connect
-    end
-
-    it "should raise an error if shell channel creation fails" do
-      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
-      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
-      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
-      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
-      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
-      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
-      expect(@ssh).to receive(:loop)
-      @transport.connect
-    end
-  end
-
-  describe "when closing" do
-    before(:each) do
-      @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
-      expect(@channel).to receive(:close)
-      @transport.close
-    end
-
-    it "should close the ssh session" do
-      expect(@ssh).to receive(:close)
-      @transport.close
-    end
-  end
-
-  describe "when sending commands" do
-    before(:each) do
-      @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
-      expect(@channel).to receive(:send_data).with("data\n")
-      @transport.command("data")
-    end
-
-    it "should expect the default prompt afterward" do
-      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
-      expect(@transport).to receive(:expect).with("myprompt")
-      @transport.command("data", :prompt => "myprompt")
-    end
-
-    it "should yield the buffer output to given block" do
-      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
-      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 = 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
-      allow(IO).to receive(:select)
-      @transport.buf = "output"
-      expect(@transport).to receive(:process_ssh)
-      @transport.expect(/output/)
-    end
-
-    it "should return the output" do
-      allow(IO).to receive(:select)
-      @transport.buf = "output"
-      allow(@transport).to receive(:process_ssh)
-      expect(@transport.expect(/output/)).to eq("output")
-    end
-
-    it "should return the output" do
-      allow(IO).to receive(:select)
-      @transport.buf = "output"
-      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 = ''
-        expect(@connection).to receive(:process).and_raise(EOFError)
-        @transport.process_ssh
-      end
-    end
-  end
-end