facter 1.6.2 → 1.6.3

data/spec/unit/util/confine_spec.rb

@@ -8,133 +8,133 @@ require 'facter/util/values'
 include Facter::Util::Values
 
 describe Facter::Util::Confine do
-    it "should require a fact name" do
-        Facter::Util::Confine.new("yay", true).fact.should == "yay"
+  it "should require a fact name" do
+    Facter::Util::Confine.new("yay", true).fact.should == "yay"
+  end
+
+  it "should accept a value specified individually" do
+    Facter::Util::Confine.new("yay", "test").values.should == ["test"]
+  end
+
+  it "should accept multiple values specified at once" do
+    Facter::Util::Confine.new("yay", "test", "other").values.should == ["test", "other"]
+  end
+
+  it "should fail if no fact name is provided" do
+    lambda { Facter::Util::Confine.new(nil, :test) }.should raise_error(ArgumentError)
+  end
+
+  it "should fail if no values were provided" do
+    lambda { Facter::Util::Confine.new("yay") }.should raise_error(ArgumentError)
+  end
+
+  it "should have a method for testing whether it matches" do
+    Facter::Util::Confine.new("yay", :test).should respond_to(:true?)
+  end
+
+  describe "when evaluating" do
+    before do
+      @confine = Facter::Util::Confine.new("yay", "one", "two", "Four", :xy, true, 1, [3,4])
+      @fact = mock 'fact'
+      Facter.stubs(:[]).returns @fact
     end
 
-    it "should accept a value specified individually" do
-        Facter::Util::Confine.new("yay", "test").values.should == ["test"]
-    end
+    it "should return false if the fact does not exist" do
+      Facter.expects(:[]).with("yay").returns nil
 
-    it "should accept multiple values specified at once" do
-        Facter::Util::Confine.new("yay", "test", "other").values.should == ["test", "other"]
+      @confine.true?.should be_false
     end
 
-    it "should fail if no fact name is provided" do
-        lambda { Facter::Util::Confine.new(nil, :test) }.should raise_error(ArgumentError)
-    end
+    it "should use the returned fact to get the value" do
+      Facter.expects(:[]).with("yay").returns @fact
 
-    it "should fail if no values were provided" do
-        lambda { Facter::Util::Confine.new("yay") }.should raise_error(ArgumentError)
-    end
+      @fact.expects(:value).returns nil
 
-    it "should have a method for testing whether it matches" do
-        Facter::Util::Confine.new("yay", :test).should respond_to(:true?)
+      @confine.true?
     end
 
-    describe "when evaluating" do
-        before do
-            @confine = Facter::Util::Confine.new("yay", "one", "two", "Four", :xy, true, 1, [3,4])
-            @fact = mock 'fact'
-            Facter.stubs(:[]).returns @fact
-        end
-
-        it "should return false if the fact does not exist" do
-            Facter.expects(:[]).with("yay").returns nil
-
-            @confine.true?.should be_false
-        end
-
-        it "should use the returned fact to get the value" do
-            Facter.expects(:[]).with("yay").returns @fact
+    it "should return false if the fact has no value" do
+      @fact.stubs(:value).returns nil
 
-            @fact.expects(:value).returns nil
-
-            @confine.true?
-        end
-
-        it "should return false if the fact has no value" do
-            @fact.stubs(:value).returns nil
-
-            @confine.true?.should be_false
-        end
+      @confine.true?.should be_false
+    end
 
-        it "should return true if any of the provided values matches the fact's value" do
-            @fact.stubs(:value).returns "two"
+    it "should return true if any of the provided values matches the fact's value" do
+      @fact.stubs(:value).returns "two"
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided symbol values matches the fact's value" do
-            @fact.stubs(:value).returns :xy
+    it "should return true if any of the provided symbol values matches the fact's value" do
+      @fact.stubs(:value).returns :xy
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided integer values matches the fact's value" do
-            @fact.stubs(:value).returns 1
+    it "should return true if any of the provided integer values matches the fact's value" do
+      @fact.stubs(:value).returns 1
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided boolan values matches the fact's value" do
-            @fact.stubs(:value).returns true
+    it "should return true if any of the provided boolan values matches the fact's value" do
+      @fact.stubs(:value).returns true
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided array values matches the fact's value" do
-            @fact.stubs(:value).returns [3,4]
+    it "should return true if any of the provided array values matches the fact's value" do
+      @fact.stubs(:value).returns [3,4]
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided symbol values matches the fact's string value" do
-            @fact.stubs(:value).returns :one
+    it "should return true if any of the provided symbol values matches the fact's string value" do
+      @fact.stubs(:value).returns :one
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided string values matches case-insensitive the fact's value" do
-            @fact.stubs(:value).returns "four"
+    it "should return true if any of the provided string values matches case-insensitive the fact's value" do
+      @fact.stubs(:value).returns "four"
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided symbol values matches case-insensitive the fact's string value" do
-            @fact.stubs(:value).returns :four
+    it "should return true if any of the provided symbol values matches case-insensitive the fact's string value" do
+      @fact.stubs(:value).returns :four
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return true if any of the provided symbol values matches the fact's string value" do
-            @fact.stubs(:value).returns :Xy
+    it "should return true if any of the provided symbol values matches the fact's string value" do
+      @fact.stubs(:value).returns :Xy
 
-            @confine.true?.should be_true
-        end
+      @confine.true?.should be_true
+    end
 
-        it "should return false if none of the provided values matches the fact's value" do
-            @fact.stubs(:value).returns "three"
+    it "should return false if none of the provided values matches the fact's value" do
+      @fact.stubs(:value).returns "three"
 
-            @confine.true?.should be_false
-        end
+      @confine.true?.should be_false
+    end
 
-        it "should return false if none of the provided integer values matches the fact's value" do
-            @fact.stubs(:value).returns 2
+    it "should return false if none of the provided integer values matches the fact's value" do
+      @fact.stubs(:value).returns 2
 
-            @confine.true?.should be_false
-        end
+      @confine.true?.should be_false
+    end
 
-        it "should return false if none of the provided boolan values matches the fact's value" do
-            @fact.stubs(:value).returns false
+    it "should return false if none of the provided boolan values matches the fact's value" do
+      @fact.stubs(:value).returns false
 
-            @confine.true?.should be_false
-        end
+      @confine.true?.should be_false
+    end
 
-        it "should return false if none of the provided array values matches the fact's value" do
-            @fact.stubs(:value).returns [1,2]
+    it "should return false if none of the provided array values matches the fact's value" do
+      @fact.stubs(:value).returns [1,2]
 
-            @confine.true?.should be_false
-        end
+      @confine.true?.should be_false
     end
+  end
 end

data/spec/unit/util/fact_spec.rb

@@ -5,125 +5,125 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'facter/util/fact'
 
 describe Facter::Util::Fact do
-    it "should require a name" do
-        lambda { Facter::Util::Fact.new }.should raise_error(ArgumentError)
-    end
+  it "should require a name" do
+    lambda { Facter::Util::Fact.new }.should raise_error(ArgumentError)
+  end
 
-    it "should always downcase the name and convert it to a symbol" do
-        Facter::Util::Fact.new("YayNess").name.should == :yayness
-    end
+  it "should always downcase the name and convert it to a symbol" do
+    Facter::Util::Fact.new("YayNess").name.should == :yayness
+  end
 
-    it "should default to its name converted to a string as its ldapname" do
-        Facter::Util::Fact.new("YayNess").ldapname.should == "yayness"
-    end
+  it "should default to its name converted to a string as its ldapname" do
+    Facter::Util::Fact.new("YayNess").ldapname.should == "yayness"
+  end
 
-    it "should allow specifying the ldap name at initialization" do
-        Facter::Util::Fact.new("YayNess", :ldapname => "fooness").ldapname.should == "fooness"
-    end
+  it "should allow specifying the ldap name at initialization" do
+    Facter::Util::Fact.new("YayNess", :ldapname => "fooness").ldapname.should == "fooness"
+  end
+
+  it "should fail if an unknown option is provided" do
+    lambda { Facter::Util::Fact.new('yay', :foo => :bar) }.should raise_error(ArgumentError)
+  end
+
+  it "should have a method for adding resolution mechanisms" do
+    Facter::Util::Fact.new("yay").should respond_to(:add)
+  end
+
+  describe "when adding resolution mechanisms" do
+    before do
+      @fact = Facter::Util::Fact.new("yay")
+
+      @resolution = mock 'resolution'
+      @resolution.stub_everything
 
-    it "should fail if an unknown option is provided" do
-        lambda { Facter::Util::Fact.new('yay', :foo => :bar) }.should raise_error(ArgumentError)
     end
 
-    it "should have a method for adding resolution mechanisms" do
-        Facter::Util::Fact.new("yay").should respond_to(:add)
+    it "should fail if no block is given" do
+      lambda { @fact.add }.should raise_error(ArgumentError)
     end
 
-    describe "when adding resolution mechanisms" do
-        before do
-            @fact = Facter::Util::Fact.new("yay")
+    it "should create a new resolution instance" do
+      Facter::Util::Resolution.expects(:new).returns @resolution
+
+      @fact.add { }
+    end
 
-            @resolution = mock 'resolution'
-            @resolution.stub_everything
+    it "should instance_eval the passed block on the new resolution" do
+      @resolution.expects(:instance_eval)
 
-        end
+      Facter::Util::Resolution.stubs(:new).returns @resolution
 
-        it "should fail if no block is given" do
-            lambda { @fact.add }.should raise_error(ArgumentError)
-        end
+      @fact.add { }
+    end
 
-        it "should create a new resolution instance" do
-            Facter::Util::Resolution.expects(:new).returns @resolution
+    it "should re-sort the resolutions by weight, so the most restricted resolutions are first" do
+      r1 = stub 'r1', :weight => 1
+      r2 = stub 'r2', :weight => 2
+      r3 = stub 'r3', :weight => 0
+      Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
+      @fact.add { }
+      @fact.add { }
+      @fact.add { }
 
-            @fact.add { }
-        end
+      @fact.instance_variable_get("@resolves").should == [r2, r1, r3]
+    end
+  end
 
-        it "should instance_eval the passed block on the new resolution" do
-            @resolution.expects(:instance_eval)
+  it "should be able to return a value" do
+    Facter::Util::Fact.new("yay").should respond_to(:value)
+  end
 
-            Facter::Util::Resolution.stubs(:new).returns @resolution
+  describe "when returning a value" do
+    before do
+      @fact = Facter::Util::Fact.new("yay")
+    end
 
-            @fact.add { }
-        end
+    it "should return nil if there are no resolutions" do
+      Facter::Util::Fact.new("yay").value.should be_nil
+    end
 
-        it "should re-sort the resolutions by weight, so the most restricted resolutions are first" do
-            r1 = stub 'r1', :weight => 1
-            r2 = stub 'r2', :weight => 2
-            r3 = stub 'r3', :weight => 0
-            Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
-            @fact.add { }
-            @fact.add { }
-            @fact.add { }
+    it "should return the first value returned by a resolution" do
+      r1 = stub 'r1', :weight => 2, :value => nil, :suitable? => true
+      r2 = stub 'r2', :weight => 1, :value => "yay", :suitable? => true
+      r3 = stub 'r3', :weight => 0, :value => "foo", :suitable? => true
+      Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
+      @fact.add { }
+      @fact.add { }
+      @fact.add { }
 
-            @fact.instance_variable_get("@resolves").should == [r2, r1, r3]
-        end
+      @fact.value.should == "yay"
     end
 
-    it "should be able to return a value" do
-        Facter::Util::Fact.new("yay").should respond_to(:value)
+    it "should short-cut returning the value once one is found" do
+      r1 = stub 'r1', :weight => 2, :value => "foo", :suitable? => true
+      r2 = stub 'r2', :weight => 1, :suitable? => true # would fail if 'value' were asked for
+      Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
+      @fact.add { }
+      @fact.add { }
+
+      @fact.value
     end
 
-    describe "when returning a value" do
-        before do
-            @fact = Facter::Util::Fact.new("yay")
-        end
-
-        it "should return nil if there are no resolutions" do
-            Facter::Util::Fact.new("yay").value.should be_nil
-        end
-
-        it "should return the first value returned by a resolution" do
-            r1 = stub 'r1', :weight => 2, :value => nil, :suitable? => true
-            r2 = stub 'r2', :weight => 1, :value => "yay", :suitable? => true
-            r3 = stub 'r3', :weight => 0, :value => "foo", :suitable? => true
-            Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
-            @fact.add { }
-            @fact.add { }
-            @fact.add { }
-
-            @fact.value.should == "yay"
-        end
-
-        it "should short-cut returning the value once one is found" do
-            r1 = stub 'r1', :weight => 2, :value => "foo", :suitable? => true
-            r2 = stub 'r2', :weight => 1, :suitable? => true # would fail if 'value' were asked for
-            Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
-            @fact.add { }
-            @fact.add { }
-
-            @fact.value
-        end
-
-        it "should skip unsuitable resolutions" do
-            r1 = stub 'r1', :weight => 2, :suitable? => false # would fail if 'value' were asked for'
-            r2 = stub 'r2', :weight => 1, :value => "yay", :suitable? => true
-            Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
-            @fact.add { }
-            @fact.add { }
-
-            @fact.value.should == "yay"
-        end
-
-        it "should return nil if the value is the empty string" do
-            r1 = stub 'r1', :suitable? => true, :value => ""
-            Facter::Util::Resolution.expects(:new).returns r1
-            @fact.add { }
-
-            @fact.value.should be_nil
-        end
+    it "should skip unsuitable resolutions" do
+      r1 = stub 'r1', :weight => 2, :suitable? => false # would fail if 'value' were asked for'
+      r2 = stub 'r2', :weight => 1, :value => "yay", :suitable? => true
+      Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
+      @fact.add { }
+      @fact.add { }
+
+      @fact.value.should == "yay"
     end
 
-    it "should have a method for flushing the cached fact" do
-        Facter::Util::Fact.new(:foo).should respond_to(:flush)
+    it "should return nil if the value is the empty string" do
+      r1 = stub 'r1', :suitable? => true, :value => ""
+      Facter::Util::Resolution.expects(:new).returns r1
+      @fact.add { }
+
+      @fact.value.should be_nil
     end
+  end
+
+  it "should have a method for flushing the cached fact" do
+    Facter::Util::Fact.new(:foo).should respond_to(:flush)
+  end
 end

data/spec/unit/util/ip_spec.rb

@@ -5,295 +5,295 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'facter/util/ip'
 
 describe Facter::Util::IP do
-    before :each do
-        Facter::Util::Config.stubs(:is_windows?).returns(false)
-    end
-
-    [:freebsd, :linux, :netbsd, :openbsd, :sunos, :darwin, :"hp-ux", :"gnu/kfreebsd", :windows].each do |platform|
-        it "should be supported on #{platform}" do
-            Facter::Util::Config.stubs(:is_windows?).returns(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
+  before :each do
+    Facter::Util::Config.stubs(:is_windows?).returns(false)
+  end
+
+  [:freebsd, :linux, :netbsd, :openbsd, :sunos, :darwin, :"hp-ux", :"gnu/kfreebsd", :windows].each do |platform|
+    it "should be supported on #{platform}" do
+      Facter::Util::Config.stubs(:is_windows?).returns(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
+    sample_output_file = File.dirname(__FILE__) + '/../data/linux_ifconfig_all_with_single_interface'
+    linux_ifconfig = File.read(sample_output_file)
+    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
+    sample_output_file = File.dirname(__FILE__) + '/../data/darwin_ifconfig_all_with_multiple_interfaces'
+    darwin_ifconfig = File.read(sample_output_file)
+    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
+    sample_output_file = File.dirname(__FILE__) + '/../data/solaris_ifconfig_all_with_multiple_interfaces'
+    solaris_ifconfig = File.read(sample_output_file)
+    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 three interfaces on HP-UX with three interfaces multiply reporting" do
+    sample_output_file = File.dirname(__FILE__) + '/../data/hpux_netstat_all_interfaces'
+    hpux_netstat = File.read(sample_output_file)
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(hpux_netstat)
+    Facter::Util::IP.get_interfaces().should == ["lan1", "lan0", "lo0"]
+  end
+
+  it "should return a list of six interfaces on a GNU/kFreeBSD with six interfaces" do
+    sample_output_file = File.dirname(__FILE__) + '/../data/debian_kfreebsd_ifconfig'
+    kfreebsd_ifconfig = File.read(sample_output_file)
+    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")
+    sample_output_file = File.dirname(__FILE__) + '/../data/windows_netsh_all_interfaces'
+    windows_netsh = File.read(sample_output_file)
+    Facter::Util::IP.stubs(:get_all_interface_output).returns(windows_netsh)
+    Facter::Util::IP.get_interfaces().should == ["Loopback Pseudo-Interface 1", "Local Area Connection", "Teredo Tunneling Pseudo-Interface"]
+  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 value for a specific interface" do
+    Facter::Util::IP.should respond_to(:get_interface_value)
+  end
 
-    it "should return a list with a single interface and the loopback interface on Linux with a single interface" do
-        sample_output_file = File.dirname(__FILE__) + '/../data/linux_ifconfig_all_with_single_interface'
-        linux_ifconfig = File.read(sample_output_file)
-        Facter::Util::IP.stubs(:get_all_interface_output).returns(linux_ifconfig)
-        Facter::Util::IP.get_interfaces().should == ["eth0", "lo"]
-    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 a list two interfaces on Darwin with two interfaces" do
-        sample_output_file = File.dirname(__FILE__) + '/../data/darwin_ifconfig_all_with_multiple_interfaces'
-        darwin_ifconfig = File.read(sample_output_file)
-        Facter::Util::IP.stubs(:get_all_interface_output).returns(darwin_ifconfig)
-        Facter::Util::IP.get_interfaces().should == ["lo0", "en0"]
-    end
+  it "should return ipaddress information for Solaris" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
+    solaris_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return a list two interfaces on Solaris with two interfaces multiply reporting" do
-        sample_output_file = File.dirname(__FILE__) + '/../data/solaris_ifconfig_all_with_multiple_interfaces'
-        solaris_ifconfig = File.read(sample_output_file)
-        Facter::Util::IP.stubs(:get_all_interface_output).returns(solaris_ifconfig)
-        Facter::Util::IP.get_interfaces().should == ["lo0", "e1000g0"]
-    end
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
 
-    it "should return a list three interfaces on HP-UX with three interfaces multiply reporting" do
-        sample_output_file = File.dirname(__FILE__) + '/../data/hpux_netstat_all_interfaces'
-        hpux_netstat = File.read(sample_output_file)
-        Facter::Util::IP.stubs(:get_all_interface_output).returns(hpux_netstat)
-        Facter::Util::IP.get_interfaces().should == ["lan1", "lan0", "lo0"]
-    end
+    Facter::Util::IP.get_interface_value("e1000g0", "ipaddress").should == "172.16.15.138"
+  end
 
-    it "should return a list of six interfaces on a GNU/kFreeBSD with six interfaces" do
-        sample_output_file = File.dirname(__FILE__) + '/../data/debian_kfreebsd_ifconfig'
-        kfreebsd_ifconfig = File.read(sample_output_file)
-        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 netmask information for Solaris" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
+    solaris_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return a list of only connected interfaces on Windows" do
-        Facter.fact(:kernel).stubs(:value).returns("windows")
-        sample_output_file = File.dirname(__FILE__) + '/../data/windows_netsh_all_interfaces'
-        windows_netsh = File.read(sample_output_file)
-        Facter::Util::IP.stubs(:get_all_interface_output).returns(windows_netsh)
-        Facter::Util::IP.get_interfaces().should == ["Loopback Pseudo-Interface 1", "Local Area Connection", "Teredo Tunneling Pseudo-Interface"]
-    end
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
 
-    it "should return a value for a specific interface" do
-        Facter::Util::IP.should respond_to(:get_interface_value)
-    end
+    Facter::Util::IP.get_interface_value("e1000g0", "netmask").should == "255.255.255.0"
+  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 calculated network information for Solaris" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
+    solaris_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return ipaddress information for Solaris" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
-        solaris_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.stubs(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
 
-        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_network_value("e1000g0").should == "172.16.15.0"
+  end
 
-        Facter::Util::IP.get_interface_value("e1000g0", "ipaddress").should == "172.16.15.138"
-    end
+  it "should return ipaddress information for HP-UX" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
+    hpux_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return netmask information for Solaris" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
-        solaris_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("HP-UX")
 
-        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("lan0", "ipaddress").should == "168.24.80.71"
+  end
 
-        Facter::Util::IP.get_interface_value("e1000g0", "netmask").should == "255.255.255.0"
-    end
+  it "should return macaddress information for HP-UX" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
+    hpux_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return calculated network information for Solaris" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
-        solaris_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("HP-UX")
 
-        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_interface_value("lan0", "macaddress").should == "00:13:21:BD:9C:B7"
+  end
 
-        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
+    sample_output_file = File.dirname(__FILE__) + "/../data/debian_kfreebsd_ifconfig"
+    kfreebsd_ifconfig = File.read(sample_output_file)
 
-    it "should return ipaddress information for HP-UX" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
-        hpux_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("em0").returns(kfreebsd_ifconfig)
+    Facter.stubs(:value).with(:kernel).returns("GNU/kFreeBSD")
 
-        Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+    Facter::Util::IP.get_interface_value("em0", "macaddress").should == "0:11:a:59:67:90"
+  end
 
-        Facter::Util::IP.get_interface_value("lan0", "ipaddress").should == "168.24.80.71"
-    end
+  it "should return netmask information for HP-UX" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
+    hpux_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return macaddress information for HP-UX" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
-        hpux_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("HP-UX")
 
-        Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+    Facter::Util::IP.get_interface_value("lan0", "netmask").should == "255.255.255.0"
+  end
 
-        Facter::Util::IP.get_interface_value("lan0", "macaddress").should == "00:13:21:BD:9C:B7"
-    end
+  it "should return calculated network information for HP-UX" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
+    hpux_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return macaddress with leading zeros stripped off for GNU/kFreeBSD" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/debian_kfreebsd_ifconfig"
-        kfreebsd_ifconfig = File.read(sample_output_file)
+    Facter::Util::IP.stubs(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("HP-UX")
 
-        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_network_value("lan0").should == "168.24.80.0"
+  end
 
-        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
+    sample_output_file = File.dirname(__FILE__) + "/../data/6.0-STABLE_FreeBSD_ifconfig"
+    ifconfig_interface = File.read(sample_output_file)
 
-    it "should return netmask information for HP-UX" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
-        hpux_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("fxp0").returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("FreeBSD")
 
-        Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+    Facter::Util::IP.get_interface_value("fxp0", "macaddress").should == "00:0e:0c:68:67:7c"
+  end
 
-        Facter::Util::IP.get_interface_value("lan0", "netmask").should == "255.255.255.0"
-    end
+  it "should return macaddress information for OS X" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/Mac_OS_X_10.5.5_ifconfig"
+    ifconfig_interface = File.read(sample_output_file)
 
-    it "should return calculated network information for HP-UX" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
-        hpux_ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("en1").returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Darwin")
 
-        Facter::Util::IP.stubs(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+    Facter::Util::IP.get_interface_value("en1", "macaddress").should == "00:1b:63:ae:02:66"
+  end
 
-        Facter::Util::IP.get_network_value("lan0").should == "168.24.80.0"
-    end
+  it "should return all interfaces correctly on OS X" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/Mac_OS_X_10.5.5_ifconfig"
+    ifconfig_interface = File.read(sample_output_file)
 
-    it "should return interface information for FreeBSD supported via an alias" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/6.0-STABLE_FreeBSD_ifconfig"
-        ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_all_interface_output).returns(ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("Darwin")
 
-        Facter::Util::IP.expects(:get_single_interface_output).with("fxp0").returns(ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("FreeBSD")
+    Facter::Util::IP.get_interfaces().should == ["lo0", "gif0", "stf0", "en0", "fw0", "en1", "vmnet8", "vmnet1"]
+  end
 
-        Facter::Util::IP.get_interface_value("fxp0", "macaddress").should == "00:0e:0c:68:67:7c"
-    end
+  it "should return a human readable netmask on Solaris" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
+    solaris_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return macaddress information for OS X" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/Mac_OS_X_10.5.5_ifconfig"
-        ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("SunOS")
 
-        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("e1000g0", "netmask").should == "255.255.255.0"
+  end
 
-        Facter::Util::IP.get_interface_value("en1", "macaddress").should == "00:1b:63:ae:02:66"
-    end
+  it "should return a human readable netmask on HP-UX" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
+    hpux_ifconfig_interface = File.read(sample_output_file)
 
-    it "should return all interfaces correctly on OS X" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/Mac_OS_X_10.5.5_ifconfig"
-        ifconfig_interface = File.read(sample_output_file)
+    Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
+    Facter.stubs(:value).with(:kernel).returns("HP-UX")
 
-        Facter::Util::IP.expects(:get_all_interface_output).returns(ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("Darwin")
+    Facter::Util::IP.get_interface_value("lan0", "netmask").should == "255.255.255.0"
+  end
 
-        Facter::Util::IP.get_interfaces().should == ["lo0", "gif0", "stf0", "en0", "fw0", "en1", "vmnet8", "vmnet1"]
-    end
+  it "should return a human readable netmask on Darwin" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/darwin_ifconfig_single_interface"
 
-    it "should return a human readable netmask on Solaris" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/solaris_ifconfig_single_interface"
-        solaris_ifconfig_interface = File.read(sample_output_file)
+    darwin_ifconfig_interface = File.read(sample_output_file)
 
-        Facter::Util::IP.expects(:get_single_interface_output).with("e1000g0").returns(solaris_ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("SunOS")
+    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("e1000g0", "netmask").should == "255.255.255.0"
-    end
+    Facter::Util::IP.get_interface_value("en1", "netmask").should == "255.255.255.0"
+  end
 
-    it "should return a human readable netmask on HP-UX" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/hpux_ifconfig_single_interface"
-        hpux_ifconfig_interface = File.read(sample_output_file)
+  it "should return a human readable netmask on GNU/kFreeBSD" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/debian_kfreebsd_ifconfig"
 
-        Facter::Util::IP.expects(:get_single_interface_output).with("lan0").returns(hpux_ifconfig_interface)
-        Facter.stubs(:value).with(:kernel).returns("HP-UX")
+    kfreebsd_ifconfig = File.read(sample_output_file)
 
-        Facter::Util::IP.get_interface_value("lan0", "netmask").should == "255.255.255.0"
-    end
+    Facter::Util::IP.expects(:get_single_interface_output).with("em1").returns(kfreebsd_ifconfig)
+    Facter.stubs(:value).with(:kernel).returns("GNU/kFreeBSD")
 
-    it "should return a human readable netmask on Darwin" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/darwin_ifconfig_single_interface"
+    Facter::Util::IP.get_interface_value("em1", "netmask").should == "255.255.255.0"
+  end
 
-        darwin_ifconfig_interface = File.read(sample_output_file)
+  it "should not get bonding master on interface aliases" do
+    Facter.stubs(:value).with(:kernel).returns("Linux")
 
-        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_bonding_master("eth0:1").should be_nil
+  end
 
-        Facter::Util::IP.get_interface_value("en1", "netmask").should == "255.255.255.0"
+  [: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
 
-    it "should return a human readable netmask on GNU/kFreeBSD" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/debian_kfreebsd_ifconfig"
-
-        kfreebsd_ifconfig = File.read(sample_output_file)
-
-        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"
+  [: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 not get bonding master on interface aliases" do
-        Facter.stubs(:value).with(:kernel).returns("Linux")
+  it "should return an arp address on Linux" do
+    Facter.stubs(:value).with(:kernel).returns("Linux")
 
-        Facter::Util::IP.get_bonding_master("eth0:1").should be_nil
-    end
+    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
 
-    [: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
+  describe "on Windows" do
+    before :each do
+      Facter.stubs(:value).with(:kernel).returns("windows")
     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 ipaddress information" do
+      sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface"
+      windows_netsh = File.read(sample_output_file)
 
-    it "should return an arp address on Linux" do
-        Facter.stubs(:value).with(:kernel).returns("Linux")
+      Facter::Util::IP.expects(:get_output_for_interface_and_label).with("Local Area Connection", "ipaddress").returns(windows_netsh)
 
-        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"
+      Facter::Util::IP.get_interface_value("Local Area Connection", "ipaddress").should == "172.16.138.216"
     end
 
-    describe "on Windows" do
-        before :each do
-            Facter.stubs(:value).with(:kernel).returns("windows")
-        end
-
-        it "should return ipaddress information" do
-            sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface"
-            windows_netsh = File.read(sample_output_file)
+    it "should return a human readable netmask" do
+      sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface"
+      windows_netsh = File.read(sample_output_file)
 
-            Facter::Util::IP.expects(:get_output_for_interface_and_label).with("Local Area Connection", "ipaddress").returns(windows_netsh)
+      Facter::Util::IP.expects(:get_output_for_interface_and_label).with("Local Area Connection", "netmask").returns(windows_netsh)
 
-            Facter::Util::IP.get_interface_value("Local Area Connection", "ipaddress").should == "172.16.138.216"
-        end
-
-        it "should return a human readable netmask" do
-            sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface"
-            windows_netsh = File.read(sample_output_file)
-
-            Facter::Util::IP.expects(:get_output_for_interface_and_label).with("Local Area Connection", "netmask").returns(windows_netsh)
-
-            Facter::Util::IP.get_interface_value("Local Area Connection", "netmask").should == "255.255.255.0"
-        end
+      Facter::Util::IP.get_interface_value("Local Area Connection", "netmask").should == "255.255.255.0"
+    end
 
-        it "should return network information" do
-            sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface"
-            windows_netsh = File.read(sample_output_file)
+    it "should return network information" do
+      sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface"
+      windows_netsh = File.read(sample_output_file)
 
-            Facter::Util::IP.stubs(:get_output_for_interface_and_label).with("Local Area Connection", "ipaddress").returns(windows_netsh)
-            Facter::Util::IP.stubs(:get_output_for_interface_and_label).with("Local Area Connection", "netmask").returns(windows_netsh)
+      Facter::Util::IP.stubs(:get_output_for_interface_and_label).with("Local Area Connection", "ipaddress").returns(windows_netsh)
+      Facter::Util::IP.stubs(:get_output_for_interface_and_label).with("Local Area Connection", "netmask").returns(windows_netsh)
 
-            Facter::Util::IP.get_network_value("Local Area Connection").should == "172.16.138.0"
-        end
+      Facter::Util::IP.get_network_value("Local Area Connection").should == "172.16.138.0"
+    end
 
-        it "should return ipaddress6 information" do
-            sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface6"
-            windows_netsh = File.read(sample_output_file)
+    it "should return ipaddress6 information" do
+      sample_output_file = File.dirname(__FILE__) + "/../data/windows_netsh_single_interface6"
+      windows_netsh = File.read(sample_output_file)
 
-            Facter::Util::IP.expects(:get_output_for_interface_and_label).with("Teredo Tunneling Pseudo-Interface", "ipaddress6").returns(windows_netsh)
+      Facter::Util::IP.expects(:get_output_for_interface_and_label).with("Teredo Tunneling Pseudo-Interface", "ipaddress6").returns(windows_netsh)
 
-            Facter::Util::IP.get_interface_value("Teredo Tunneling Pseudo-Interface", "ipaddress6").should == "2001:0:4137:9e76:2087:77a:53ef:7527"
-        end
+      Facter::Util::IP.get_interface_value("Teredo Tunneling Pseudo-Interface", "ipaddress6").should == "2001:0:4137:9e76:2087:77a:53ef:7527"
     end
+  end
 end