facter 2.1.0-x64-mingw32

data/spec/unit/util/fact_spec.rb

@@ -0,0 +1,142 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/fact'
+
+describe Facter::Util::Fact do
+
+  subject(:fact) { Facter::Util::Fact.new("yay") }
+
+  let(:resolution) { Facter::Util::Resolution.new("yay", fact) }
+
+  it "requires a name" do
+    expect { Facter::Util::Fact.new }.to raise_error(ArgumentError)
+  end
+
+  it "downcases and converts the name to a symbol" do
+    expect(Facter::Util::Fact.new("YayNess").name).to eq :yayness
+  end
+
+  it "issues a deprecation warning for use of ldapname" do
+    Facter.expects(:warnonce).with("ldapname is deprecated and will be removed in a future version")
+    Facter::Util::Fact.new("YayNess", :ldapname => "fooness")
+  end
+
+  describe "when adding resolution mechanisms using #add" do
+    it "delegates to #define_resolution with an anonymous resolution" do
+      subject.expects(:define_resolution).with(nil, {})
+      subject.add
+    end
+  end
+
+  describe "looking up resolutions by name" do
+    subject(:fact) { described_class.new('yay') }
+
+    it "returns nil if no such resolution exists" do
+      expect(fact.resolution('nope')).to be_nil
+    end
+
+    it "never returns anonymous resolutions" do
+      fact.add() { setcode { 'anonymous' } }
+
+      expect(fact.resolution(nil)).to be_nil
+    end
+  end
+
+  describe "adding resolution mechanisms by name" do
+
+    let(:res) do
+      stub 'resolution',
+        :name => 'named',
+        :set_options => nil,
+        :resolution_type => :simple
+    end
+
+    it "creates a new resolution if no such resolution exists" do
+      Facter::Util::Resolution.expects(:new).once.with('named', fact).returns(res)
+
+      fact.define_resolution('named')
+
+      expect(fact.resolution('named')).to eq res
+    end
+
+    it "creates a simple resolution when the type is nil" do
+      fact.define_resolution('named')
+      expect(fact.resolution('named')).to be_a_kind_of Facter::Util::Resolution
+    end
+
+    it "creates a simple resolution when the type is :simple" do
+      fact.define_resolution('named', :type => :simple)
+      expect(fact.resolution('named')).to be_a_kind_of Facter::Util::Resolution
+    end
+
+    it "creates an aggregate resolution when the type is :aggregate" do
+      fact.define_resolution('named', :type => :aggregate)
+      expect(fact.resolution('named')).to be_a_kind_of Facter::Core::Aggregate
+    end
+
+    it "raises an error if there is an existing resolution with a different type" do
+      pending "We need to stop rescuing all errors when instantiating resolutions"
+      fact.define_resolution('named')
+      expect {
+        fact.define_resolution('named', :type => :aggregate)
+      }.to raise_error(ArgumentError, /Cannot return resolution.*already defined as simple/)
+    end
+
+    it "returns existing resolutions by name" do
+      Facter::Util::Resolution.expects(:new).once.with('named', fact).returns(res)
+
+      fact.define_resolution('named')
+      fact.define_resolution('named')
+
+      expect(fact.resolution('named')).to eq res
+    end
+  end
+
+  describe "when returning a value" do
+    it "returns nil if there are no resolutions" do
+      Facter::Util::Fact.new("yay").value.should be_nil
+    end
+
+    it "prefers the highest weight resolution" do
+      fact.add { has_weight 1; setcode { "1" } }
+      fact.add { has_weight 2; setcode { "2" } }
+      fact.add { has_weight 0; setcode { "0" } }
+      expect(fact.value).to eq "2"
+    end
+
+    it "returns the first value returned by a resolution" do
+      fact.add { has_weight 1; setcode { "1" } }
+      fact.add { has_weight 2; setcode { nil } }
+      fact.add { has_weight 0; setcode { "0" } }
+      expect(fact.value).to eq "1"
+    end
+
+    it "skips unsuitable resolutions" do
+      fact.add { has_weight 1; setcode { "1" } }
+      fact.add do
+        def suitable?; false; end
+        has_weight 2
+        setcode { 2 }
+      end
+
+      expect(fact.value).to eq "1"
+    end
+  end
+
+  describe '#flush' do
+    subject do
+      Facter::Util::Fact.new(:foo)
+    end
+
+    it "invokes #flush on all resolutions" do
+      simple = subject.add(:type => :simple)
+      simple.expects(:flush)
+
+      aggregate = subject.add(:type => :aggregate)
+      aggregate.expects(:flush)
+
+      subject.flush
+    end
+  end
+end

data/spec/unit/util/file_read_spec.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby
+
+require 'facter/util/file_read'
+require 'spec_helper'
+
+describe Facter::Util::FileRead do
+  let(:issue) { "Ubuntu 10.04.4 LTS \\n \\l\n\n" }
+
+  it "reads a file" do
+    File.expects(:read).with("/etc/issue").returns(issue)
+    Facter::Util::FileRead.read("/etc/issue").should == issue
+  end
+
+  it "returns nil if the file cannot be accessed" do
+    File.stubs(:read).with("/etc/issue").raises(Errno::EACCES.new("/etc/issue"))
+    Facter::Util::FileRead.read("/etc/issue").should be_nil
+  end
+
+  it "returns nil if the file does not exist" do
+    File.stubs(:read).with("/etc/issue").raises(Errno::ENOENT.new("/etc/issue"))
+    Facter::Util::FileRead.read("/etc/issue").should be_nil
+  end
+
+  it "logs a message when handing exceptions" do
+    File.stubs(:read).with("/etc/issue").raises(Errno::EACCES.new("/etc/issue"))
+    Facter.expects(:debug).with("Could not read /etc/issue: Permission denied - /etc/issue")
+    Facter::Util::FileRead.read("/etc/issue")
+  end
+end

data/spec/unit/util/formatter_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'facter/util/formatter'
+
+describe Facter::Util::Formatter do
+  describe "formatting as json" do
+    it "formats the text as json when json is available", :if => Facter.json? do
+      JSON.expects(:pretty_generate).with({"hello" => "world"}).returns(%Q({"hello": "world"}))
+      expect(described_class.format_json({"hello" => "world"})).to eq %Q({"hello": "world"})
+    end
+
+    it "raises an error when JSON is not available" do
+      Facter.stubs(:json?).returns false
+      expect {
+        described_class.format_json({"hello" => "world"})
+      }.to raise_error(/'json' library is not present/)
+    end
+  end
+
+  describe "formatting as yaml" do
+    it "dumps the text as YAML" do
+      expect(described_class.format_yaml({"hello" => "world"})).to match(/hello: world/)
+    end
+  end
+
+  describe "formatting as plaintext" do
+    it "formats a single string value without quotes" do
+      expect(described_class.format_plaintext({"foo" => "bar"})).to eq "bar"
+    end
+
+    it "formats a structured value with #inspect" do
+      value = ["bar"]
+      value.expects(:inspect).returns %Q(["bar"])
+      hash = {"foo" => value, "baz" => "quux"}
+      expect(described_class.format_plaintext(hash)).to match(%Q([bar]))
+    end
+    it "formats multiple string values as key/value pairs" do
+      hash = {"foo" => "bar", "baz" => "quux"}
+      expect(described_class.format_plaintext(hash)).to match(/foo => bar/)
+      expect(described_class.format_plaintext(hash)).to match(/baz => quux/)
+    end
+
+    it "formats multiple structured values with #inspect" do
+      value = ["bar"]
+      value.expects(:inspect).twice.returns %Q(["bar"])
+      hash = {"foo" => value, "baz" => "quux"}
+      expect(described_class.format_plaintext(hash)).to match(/foo => \["bar"\]/)
+      expect(described_class.format_plaintext(hash)).to match(/baz => quux/)
+    end
+  end
+end

data/spec/unit/util/ip/windows_spec.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'facter/util/ip/windows'
+
+describe Facter::Util::IP::Windows do
+  before :each do
+    Facter.fact(:kernel).stubs(:value).returns('windows')
+  end
+
+  describe ".to_s" do
+    let(:to_s) { described_class.to_s }
+
+    it { to_s.should eq 'windows' }
+  end
+
+  describe ".convert_netmask_from_hex?" do
+    let :convert_netmask_from_hex? do
+      described_class.convert_netmask_from_hex?
+    end
+
+    it { convert_netmask_from_hex?.should be false }
+  end
+
+  describe ".bonding_master" do
+    let(:bonding_master) { described_class.bonding_master('eth0') }
+
+    pending("porting to Windows") do
+      it { bonding_master.should be_nil }
+    end
+  end
+
+  describe ".interfaces" do
+    let(:name)       { 'Local Area Connection' }
+    let(:index)      { 7 }
+    let(:nic_config) { mock('nic_config', :Index => index) }
+    let(:nic)        { stub('nic', :NetConnectionId => name ) }
+    let(:nic_empty_NetConnectionId)        { stub('nic', :NetConnectionId => '' ) }
+    let(:nic_nil_NetConnectionId)        { stub('nic', :NetConnectionId => nil ) }
+    let(:wmi_query) {"SELECT * FROM Win32_NetworkAdapter WHERE Index = #{index} AND NetEnabled = TRUE"}
+
+    it "should return an array of only connected interfaces" do
+      Facter::Util::WMI.expects(:execquery).with(Facter::Util::IP::Windows::WMI_IP_INFO_QUERY).
+        returns([nic_config])
+      Facter::Util::WMI.expects(:execquery).with(wmi_query).
+        returns([nic])
+
+      described_class.interfaces.should == [name]
+    end
+
+    it "should not return an interface with an empty NetConnectionId" do
+      Facter::Util::WMI.expects(:execquery).with(Facter::Util::IP::Windows::WMI_IP_INFO_QUERY).
+        returns([nic_config])
+      Facter::Util::WMI.expects(:execquery).with(wmi_query).
+        returns([nic_empty_NetConnectionId])
+
+      described_class.interfaces.should == []
+    end
+
+    it "should not return an interface with a nil NetConnectionId" do
+      Facter::Util::WMI.expects(:execquery).with(Facter::Util::IP::Windows::WMI_IP_INFO_QUERY).
+        returns([nic_config])
+      Facter::Util::WMI.expects(:execquery).with(wmi_query).
+        returns([nic_nil_NetConnectionId])
+
+      described_class.interfaces.should == []
+    end
+
+    context "when the adapter configuration is enabled but the underlying adapter is not enabled" do
+      it "should not return an interface" do
+        Facter::Util::WMI.expects(:execquery).with(Facter::Util::IP::Windows::WMI_IP_INFO_QUERY).
+          returns([nic_config])
+        Facter::Util::WMI.expects(:execquery).with(wmi_query).
+          returns([])
+
+        described_class.interfaces.should == []
+      end
+    end
+  end
+end

data/spec/unit/util/ip_spec.rb

@@ -0,0 +1,467 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/ip'
+
+describe Facter::Util::IP do
+  include FacterSpec::ConfigHelper
+
+  before :each do
+    given_a_configuration_of(:is_windows => false)
+  end
+
+  [:freebsd, :linux, :netbsd, :openbsd, :sunos, :darwin, :"hp-ux", :"gnu/kfreebsd", :windows].each do |platform|
+    it "should be supported on #{platform}" do
+      given_a_configuration_of(:is_windows => platform == :windows)
+      Facter::Util::IP.supported_platforms.should be_include(platform)
+    end
+  end
+
+  it "should return a list of interfaces" do
+    Facter::Util::IP.should respond_to(:get_interfaces)
+  end
+
+  it "should return an empty list of interfaces on an unknown kernel" do
+    Facter.stubs(:value).returns("UnknownKernel")
+    Facter::Util::IP.get_interfaces().should == []
+  end
+
+  it "should return a list with a single interface and the loopback interface on Linux with a single interface" do
+    linux_ifconfig = my_fixture_read("linux_ifconfig_all_with_single_interface")
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(linux_ifconfig)
+    Facter::Util::IP.get_interfaces().should == ["eth0", "lo"]
+  end
+
+  it "should return a list two interfaces on Darwin with two interfaces" do
+    darwin_ifconfig = my_fixture_read("darwin_ifconfig_all_with_multiple_interfaces")
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(darwin_ifconfig)
+    Facter::Util::IP.get_interfaces().should == ["lo0", "en0"]
+  end
+
+  it "should return a list two interfaces on Solaris with two interfaces multiply reporting" do
+    solaris_ifconfig = my_fixture_read("solaris_ifconfig_all_with_multiple_interfaces")
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(solaris_ifconfig)
+    Facter::Util::IP.get_interfaces().should == ["lo0", "e1000g0"]
+  end
+
+  it "should return a list of six interfaces on a GNU/kFreeBSD with six interfaces" do
+    kfreebsd_ifconfig = my_fixture_read("debian_kfreebsd_ifconfig")
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(kfreebsd_ifconfig)
+    Facter::Util::IP.get_interfaces().should == ["em0", "em1", "bge0", "bge1", "lo0", "vlan0"]
+  end
+
+  it "should return a list of only connected interfaces on Windows" do
+    Facter.fact(:kernel).stubs(:value).returns("windows")
+
+    Facter::Util::IP::Windows.expects(:interfaces).returns(["Loopback Pseudo-Interface 1", "Local Area Connection", "Teredo Tunneling Pseudo-Interface"])
+    Facter::Util::IP.get_interfaces().should == ["Loopback Pseudo-Interface 1", "Local Area Connection", "Teredo Tunneling Pseudo-Interface"]
+  end
+
+  it "should return a value for a specific interface" do
+    Facter::Util::IP.should respond_to(:get_interface_value)
+  end
+
+  it "should not return interface information for unsupported platforms" do
+    Facter.stubs(:value).with(:kernel).returns("bleah")
+    Facter::Util::IP.get_interface_value("e1000g0", "netmask").should == []
+  end
+
+  it "should return ipaddress information for Solaris" do
+    solaris_ifconfig_interface = my_fixture_read("solaris_ifconfig_single_interface")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
+
+    Facter::Util::IP.get_interface_value("e1000g0", "ipaddress").should == "172.16.15.138"
+  end
+
+  it "should return netmask information for Solaris" do
+    solaris_ifconfig_interface = my_fixture_read("solaris_ifconfig_single_interface")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
+
+    Facter::Util::IP.get_interface_value("e1000g0", "netmask").should == "255.255.255.0"
+  end
+
+  it "should return calculated network information for Solaris" do
+    solaris_ifconfig_interface = my_fixture_read("solaris_ifconfig_single_interface")
+
+    Facter::Util::IP.stubs(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
+
+    Facter::Util::IP.get_network_value("e1000g0").should == "172.16.15.0"
+  end
+
+  it "should return macaddress with leading zeros stripped off for GNU/kFreeBSD" do
+    kfreebsd_ifconfig = my_fixture_read("debian_kfreebsd_ifconfig")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("em0").returns(kfreebsd_ifconfig)
+    Facter.stubs(:value).with(:kernel).returns("GNU/kFreeBSD")
+
+    Facter::Util::IP.get_interface_value("em0", "macaddress").should == "0:11:a:59:67:90"
+  end
+
+  it "should return interface information for FreeBSD supported via an alias" do
+    ifconfig_interface = my_fixture_read("6.0-STABLE_FreeBSD_ifconfig")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("fxp0").returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("FreeBSD")
+
+    Facter::Util::IP.get_interface_value("fxp0", "macaddress").should == "00:0e:0c:68:67:7c"
+  end
+
+  it "should return macaddress information for OS X" do
+    ifconfig_interface = my_fixture_read("Mac_OS_X_10.5.5_ifconfig")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("en1").returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Darwin")
+
+    Facter::Util::IP.get_interface_value("en1", "macaddress").should == "00:1b:63:ae:02:66"
+  end
+
+  it "should return all interfaces correctly on OS X" do
+    ifconfig_interface = my_fixture_read("Mac_OS_X_10.5.5_ifconfig")
+
+    Facter::Util::IP.expects(:get_all_interface_output).returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Darwin")
+
+    Facter::Util::IP.get_interfaces().should == ["lo0", "gif0", "stf0", "en0", "fw0", "en1", "vmnet8", "vmnet1"]
+  end
+
+  it "should return a human readable netmask on Solaris" do
+    solaris_ifconfig_interface = my_fixture_read("solaris_ifconfig_single_interface")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
+
+    Facter::Util::IP.get_interface_value("e1000g0", "netmask").should == "255.255.255.0"
+  end
+
+  it "should return a human readable netmask on Darwin" do
+    darwin_ifconfig_interface = my_fixture_read("darwin_ifconfig_single_interface")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("en1").returns(darwin_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Darwin")
+
+    Facter::Util::IP.get_interface_value("en1", "netmask").should == "255.255.255.0"
+  end
+
+  it "should return a human readable netmask on GNU/kFreeBSD" do
+    kfreebsd_ifconfig = my_fixture_read("debian_kfreebsd_ifconfig")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("em1").returns(kfreebsd_ifconfig)
+    Facter.stubs(:value).with(:kernel).returns("GNU/kFreeBSD")
+
+    Facter::Util::IP.get_interface_value("em1", "netmask").should == "255.255.255.0"
+  end
+
+  it "should return correct macaddress information for infiniband on Linux" do
+    correct_ifconfig_interface = my_fixture_read("linux_get_single_interface_ib0")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("ib0").returns(correct_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Linux")
+
+    Facter::Util::IP.get_interface_value("ib0", "macaddress").should == "80:00:00:4a:fe:80:00:00:00:00:00:00:00:02:c9:03:00:43:27:21"
+  end
+
+  it "should replace the incorrect macaddress with the correct macaddress in ifconfig for infiniband on Linux" do
+    ifconfig_interface = my_fixture_read("linux_ifconfig_ib0")
+    correct_ifconfig_interface = my_fixture_read("linux_get_single_interface_ib0")
+
+    Facter::Util::IP.expects(:get_infiniband_macaddress).with("ib0").returns("80:00:00:4a:fe:80:00:00:00:00:00:00:00:02:c9:03:00:43:27:21")
+    Facter::Util::IP.expects(:ifconfig_interface).with("ib0").returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Linux")
+
+    Facter::Util::IP.get_single_interface_output("ib0").should == correct_ifconfig_interface
+  end
+
+  it "should return fake macaddress information for infiniband on Linux when neither sysfs or /sbin/ip are available" do
+    ifconfig_interface = my_fixture_read("linux_ifconfig_ib0")
+
+    File.expects(:exists?).with("/sys/class/net/ib0/address").returns(false)
+    File.expects(:exists?).with("/sbin/ip").returns(false)
+    Facter::Util::IP.expects(:ifconfig_interface).with("ib0").returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Linux")
+
+    Facter::Util::IP.get_interface_value("ib0", "macaddress").should == "FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF"
+  end
+
+  it "should not get bonding master on interface aliases" do
+    Facter.stubs(:value).with(:kernel).returns("Linux")
+
+    Facter::Util::IP.get_bonding_master("eth0:1").should be_nil
+  end
+
+  [:freebsd, :netbsd, :openbsd, :sunos, :darwin, :"hp-ux"].each do |platform|
+    it "should require conversion from hex on #{platform}" do
+      Facter::Util::IP.convert_from_hex?(platform).should == true
+    end
+  end
+
+  [:windows].each do |platform|
+    it "should not require conversion from hex on #{platform}" do
+      Facter::Util::IP.convert_from_hex?(platform).should be_false
+    end
+  end
+
+  it "should return an arp address on Linux" do
+    Facter.stubs(:value).with(:kernel).returns("Linux")
+
+    Facter::Util::IP.expects(:get_arp_value).with("eth0").returns("00:00:0c:9f:f0:04")
+    Facter::Util::IP.get_arp_value("eth0").should == "00:00:0c:9f:f0:04"
+  end
+
+  it "should return mtu information on Linux" do
+    linux_ifconfig = my_fixture_read("linux_ifconfig_all_with_single_interface")
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(linux_ifconfig)
+    Facter::Util::IP.stubs(:get_single_interface_output).with("eth0").
+      returns(my_fixture_read("linux_get_single_interface_eth0"))
+    Facter::Util::IP.stubs(:get_single_interface_output).with("lo").
+      returns(my_fixture_read("linux_get_single_interface_lo"))
+    Facter.stubs(:value).with(:kernel).returns("Linux")
+
+    Facter::Util::IP.get_interface_value("eth0", "mtu").should == "1500"
+    Facter::Util::IP.get_interface_value("lo", "mtu").should == "16436"
+  end
+
+  it "should return mtu information on Darwin" do
+    darwin_ifconfig_interface = my_fixture_read("darwin_ifconfig_single_interface")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("en1").returns(darwin_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Darwin")
+
+    Facter::Util::IP.get_interface_value("en1", "mtu").should == "1500"
+  end
+
+  it "should return mtu information for Solaris" do
+    solaris_ifconfig_interface = my_fixture_read("solaris_ifconfig_single_interface")
+
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
+
+    Facter::Util::IP.get_interface_value("e1000g0", "mtu").should == "1500"
+  end
+
+  # (#17487) - tests for HP-UX.
+  # some fake data for testing robustness of regexps.
+  def self.fake_netstat_in_examples
+    examples = []
+    examples << ["Header row\na line with none in it\na line without\nanother line without\n",
+                 "a line without\nanother line without\n"]
+    examples << ["Header row\na line without\na line with none in it\nanother line with none\nanother line without\n",
+                 "a line without\nanother line without\n"]
+    examples << ["Header row\na line with * asterisks *\na line with none in it\nanother line without\n",
+                 "a line with  asterisks \nanother line without\n"]
+    examples << ["a line with none none none in it\na line with none in it\na line without\nanother line without\n",
+                 "another line without\n"]
+    examples
+  end
+
+  fake_netstat_in_examples.each_with_index do |example, i|
+    input, expected_output = example
+    it "should pass regexp test on fake netstat input example #{i}" do
+      Facter.stubs(:value).with(:kernel).returns("HP-UX")
+      Facter::Util::IP.stubs(:hpux_netstat_in).returns(input)
+      Facter::Util::IP.get_all_interface_output().should == expected_output
+    end
+  end
+
+  # and some real data for exhaustive tests.
+  def self.hpux_examples
+    examples = []
+    examples << ["HP-UX 11.11",
+                   ["lan1",              "lan0",              "lo0"      ],
+                   ["1500",              "1500",              "4136"     ],
+                   ["10.1.1.6",          "192.168.3.10",      "127.0.0.1"],
+                   ["255.255.255.0",     "255.255.255.0",     "255.0.0.0"],
+                   ["00:10:79:7B:5C:DE", "00:30:7F:0C:79:DC", nil        ],
+                   [my_fixture_read("hpux_1111_ifconfig_lan1"),
+                      my_fixture_read("hpux_1111_ifconfig_lan0"),
+                        my_fixture_read("hpux_1111_ifconfig_lo0")],
+                           my_fixture_read("hpux_1111_netstat_in"),
+                           my_fixture_read("hpux_1111_lanscan")]
+
+    examples << ["HP-UX 11.31",
+                   ["lan1",              "lan0",              "lo0"      ],
+                   ["1500",              "1500",              "4136"     ],
+                   ["10.1.54.36",        "192.168.30.152",    "127.0.0.1"],
+                   ["255.255.255.0",     "255.255.255.0",     "255.0.0.0"],
+                   ["00:17:FD:2D:2A:57", "00:12:31:7D:62:09", nil        ],
+                   [my_fixture_read("hpux_1131_ifconfig_lan1"),
+                      my_fixture_read("hpux_1131_ifconfig_lan0"),
+                        my_fixture_read("hpux_1131_ifconfig_lo0")],
+                           my_fixture_read("hpux_1131_netstat_in"),
+                           my_fixture_read("hpux_1131_lanscan")]
+
+    examples << ["HP-UX 11.31 with an asterisk after a NIC that has an address",
+                   ["lan1",              "lan0",              "lo0"      ],
+                   ["1500",              "1500",              "4136"     ],
+                   ["10.10.0.5",         "192.168.3.9",       "127.0.0.1"],
+                   ["255.255.255.0",     "255.255.255.0",     "255.0.0.0"],
+                   ["00:10:79:7B:BE:46", "00:30:5D:06:26:B2", nil        ],
+                   [my_fixture_read("hpux_1131_asterisk_ifconfig_lan1"),
+                      my_fixture_read("hpux_1131_asterisk_ifconfig_lan0"),
+                        my_fixture_read("hpux_1131_asterisk_ifconfig_lo0")],
+                           my_fixture_read("hpux_1131_asterisk_netstat_in"),
+                           my_fixture_read("hpux_1131_asterisk_lanscan")]
+
+    examples << ["HP-UX 11.31 with NIC bonding and one virtual NIC",
+                   ["lan4:1",        "lan1",              "lo0",       "lan4"             ],
+                   ["1500",          "1500",              "4136",      "1500"             ],
+                   ["192.168.1.197", "192.168.30.32",     "127.0.0.1", "192.168.32.75"    ],
+                   ["255.255.255.0", "255.255.255.0",     "255.0.0.0", "255.255.255.0"    ],
+                   [nil,             "00:12:81:9E:48:DE", nil,         "00:12:81:9E:4A:7E"],
+                   [my_fixture_read("hpux_1131_nic_bonding_ifconfig_lan4_1"),
+                      my_fixture_read("hpux_1131_nic_bonding_ifconfig_lan1"),
+                        my_fixture_read("hpux_1131_nic_bonding_ifconfig_lo0"),
+                          my_fixture_read("hpux_1131_nic_bonding_ifconfig_lan4")],
+                           my_fixture_read("hpux_1131_nic_bonding_netstat_in"),
+                           my_fixture_read("hpux_1131_nic_bonding_lanscan")]
+    examples
+  end
+
+  hpux_examples.each do |example|
+    description, array_of_expected_ifs, array_of_expected_mtus,
+      array_of_expected_ips, array_of_expected_netmasks,
+        array_of_expected_macs, array_of_ifconfig_fixtures,
+           netstat_in_fixture, lanscan_fixture = example
+
+    it "should return a list three interfaces on #{description}" do
+      Facter.stubs(:value).with(:kernel).returns("HP-UX")
+      Facter::Util::IP.stubs(:hpux_netstat_in).returns(netstat_in_fixture)
+      Facter::Util::IP.get_interfaces().should == array_of_expected_ifs
+    end
+
+    array_of_expected_ifs.each_with_index do |nic, i|
+      ifconfig_fixture = array_of_ifconfig_fixtures[i]
+      expected_mtu = array_of_expected_mtus[i]
+      expected_ip = array_of_expected_ips[i]
+      expected_netmask = array_of_expected_netmasks[i]
+      expected_mac = array_of_expected_macs[i]
+
+      # (#17808) These tests fail because MTU facts haven't been implemented for HP-UX.
+      #it "should return MTU #{expected_mtu} on #{nic} for #{description} example" do
+      #  Facter.stubs(:value).with(:kernel).returns("HP-UX")
+      #  Facter::Util::IP.stubs(:hpux_netstat_in).returns(netstat_in_fixture)
+      #  Facter::Util::IP.stubs(:hpux_lanscan).returns(lanscan_fixture)
+      #  Facter::Util::IP.stubs(:hpux_ifconfig_interface).with(nic).returns(ifconfig_fixture)
+      #  Facter::Util::IP.get_interface_value(nic, "mtu").should == expected_mtu
+      #end
+
+      it "should return IP #{expected_ip} on #{nic} for #{description} example" do
+        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+        Facter::Util::IP.stubs(:hpux_lanscan).returns(lanscan_fixture)
+        Facter::Util::IP.stubs(:hpux_ifconfig_interface).with(nic).returns(ifconfig_fixture)
+        Facter::Util::IP.get_interface_value(nic, "ipaddress").should == expected_ip
+      end
+
+      it "should return netmask #{expected_netmask} on #{nic} for #{description} example" do
+        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+        Facter::Util::IP.stubs(:hpux_lanscan).returns(lanscan_fixture)
+        Facter::Util::IP.stubs(:hpux_ifconfig_interface).with(nic).returns(ifconfig_fixture)
+        Facter::Util::IP.get_interface_value(nic, "netmask").should == expected_netmask
+      end
+
+      it "should return MAC address #{expected_mac} on #{nic} for #{description} example" do
+        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+        Facter::Util::IP.stubs(:hpux_lanscan).returns(lanscan_fixture)
+        Facter::Util::IP.stubs(:hpux_ifconfig_interface).with(nic).returns(ifconfig_fixture)
+        Facter::Util::IP.get_interface_value(nic, "macaddress").should == expected_mac
+      end
+    end
+  end
+
+  describe "on Windows" do
+    require 'facter/util/ip/windows'
+
+    before :each do
+      Facter.stubs(:value).with(:kernel).returns("windows")
+    end
+
+    it "should return ipaddress information" do
+      Facter::Util::IP::Windows.expects(:value_for_interface_and_label).with("Local Area Connection", "ipaddress").returns('172.16.138.216')
+
+      Facter::Util::IP.get_interface_value("Local Area Connection", "ipaddress").should == "172.16.138.216"
+    end
+
+    it "should return network information" do
+      Facter::Util::IP::Windows.expects(:value_for_interface_and_label).with("Local Area Connection", "ipaddress").returns('172.16.138.216')
+      Facter::Util::IP::Windows.expects(:value_for_interface_and_label).with("Local Area Connection", "netmask").returns('255.255.255.0')
+
+      Facter::Util::IP.get_network_value("Local Area Connection").should == "172.16.138.0"
+    end
+
+    it "should return ipaddress6 information" do
+      Facter::Util::IP::Windows.expects(:value_for_interface_and_label).with("Local Area Connection", "ipaddress6").returns("2001:0:4137:9e76:2087:77a:53ef:7527")
+
+      Facter::Util::IP.get_interface_value("Local Area Connection", "ipaddress6").should == "2001:0:4137:9e76:2087:77a:53ef:7527"
+    end
+  end
+
+  describe "exec_ifconfig" do
+    it "uses get_ifconfig" do
+      Facter::Core::Execution.stubs(:exec)
+
+      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig").once
+
+      Facter::Util::IP.exec_ifconfig
+    end
+
+    it "support additional arguments" do
+      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
+
+      Facter::Core::Execution.stubs(:exec).with("/sbin/ifconfig -a")
+
+      Facter::Util::IP.exec_ifconfig(["-a"])
+    end
+
+    it "joins multiple arguments correctly" do
+      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
+
+      Facter::Core::Execution.stubs(:exec).with("/sbin/ifconfig -a -e -i -j")
+
+      Facter::Util::IP.exec_ifconfig(["-a","-e","-i","-j"])
+    end
+  end
+  describe "get_ifconfig" do
+    it "assigns /sbin/ifconfig if it is executable" do
+      File.stubs(:executable?).returns(false)
+      File.stubs(:executable?).with("/sbin/ifconfig").returns(true)
+      Facter::Util::IP.get_ifconfig.should eq("/sbin/ifconfig")
+    end
+    it "assigns /usr/sbin/ifconfig if it is executable" do
+      File.stubs(:executable?).returns(false)
+      File.stubs(:executable?).with("/usr/sbin/ifconfig").returns(true)
+      Facter::Util::IP.get_ifconfig.should eq("/usr/sbin/ifconfig")
+    end
+    it "assigns /bin/ifconfig if it is executable" do
+      File.stubs(:executable?).returns(false)
+      File.stubs(:executable?).with("/bin/ifconfig").returns(true)
+      Facter::Util::IP.get_ifconfig.should eq("/bin/ifconfig")
+    end
+  end
+
+  context "with bonded ethernet interfaces on Linux" do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+    end
+
+    describe "Facter::Util::Ip.get_interface_value" do
+      before :each do
+        Facter::Util::IP.stubs(:read_proc_net_bonding).
+          with("/proc/net/bonding/bond0").
+          returns(my_fixture_read("linux_2_6_35_proc_net_bonding_bond0"))
+
+        Facter::Util::IP.stubs(:get_bonding_master).returns("bond0")
+      end
+
+      it 'provides the real device macaddress for eth0' do
+        Facter::Util::IP.get_interface_value("eth0", "macaddress").should == "00:11:22:33:44:55"
+      end
+      it 'provides the real device macaddress for eth1' do
+        Facter::Util::IP.get_interface_value("eth1", "macaddress").should == "00:11:22:33:44:56"
+      end
+    end
+  end
+end