facter 2.1.0-x64-mingw32

data/spec/unit/gce/metadata_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'facter/gce/metadata'
+
+describe Facter::GCE::Metadata, :if => Facter.json? do
+
+  describe "contacting the metadata server" do
+    it "retries the request when a connection error is thrown" do
+      subject.stubs(:open).returns(stub(:read => '{"hello": "world"}'))
+      seq = sequence('open-uri seq')
+      Timeout.expects(:timeout).with(0.05).twice.in_sequence(seq).raises(Timeout::Error)
+      Timeout.expects(:timeout).with(0.05).once.in_sequence(seq).yields
+      expect(subject.fetch).to eq({'hello' => 'world'})
+    end
+
+    it "logs the exception when all retries failed" do
+      Timeout.expects(:timeout).with(0.05).times(3).raises(Timeout::Error)
+      Facter.expects(:log_exception).with(instance_of(Timeout::Error), instance_of(String))
+      expect(subject.fetch).to be_nil
+    end
+  end
+
+  describe "parsing the metadata response" do
+    let(:body) { my_fixture_read('metadata.json') }
+    before do
+      subject.stubs(:open).returns(stub(:read => body))
+    end
+
+    it "transforms hash values with the 'image' key" do
+      expect(subject.fetch['instance']['image']).to eq 'centos6'
+    end
+
+    it "transforms hash values with the 'machineType' key" do
+      expect(subject.fetch['instance']['machineType']).to eq 'n1-standard-1'
+    end
+
+    it "transforms hash values with the 'zone' key" do
+      expect(subject.fetch['instance']['zone']).to eq 'us-central1-b'
+    end
+
+    it "transforms hash values with the 'network' key" do
+      expect(subject.fetch['instance']['networkInterfaces'][0]['network']).to eq 'default'
+    end
+
+    it "splits up the elements of the 'sshKeys' value into an array" do
+      expect(subject.fetch['project']['attributes']['sshKeys'][0]).to match(/justin:ssh-rsa/)
+      expect(subject.fetch['project']['attributes']['sshKeys'][1]).to match(/adrien:ssh-rsa/)
+    end
+  end
+end

data/spec/unit/gce_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'facter/gce/metadata'
+
+describe "gce_metadata" do
+  let(:querier) { stub('GCE metadata querier') }
+
+  before do
+    Facter::GCE::Metadata.stubs(:new).returns querier
+    Facter.collection.internal_loader.load(:ec2)
+  end
+
+  subject { Facter.fact(:gce).resolution(:rest) }
+
+  it "is unsuitable when the virtual type is not gce" do
+    Facter.fact(:virtual).stubs(:value).returns 'kvm'
+    expect(subject).to_not be_suitable
+  end
+
+  it "is unsuitable when JSON is not available" do
+    Facter.stubs(:json?).returns false
+    expect(subject).to_not be_suitable
+  end
+
+  it "is suitable when both the virtual type is gce and JSON is available" do
+    Facter.fact(:virtual).stubs(:value).returns 'gce'
+    Facter.stubs(:json?).returns true
+    expect(subject).to be_suitable
+  end
+
+  it "resolves the fact by querying GCE metadata API" do
+    querier.expects(:fetch).returns({'hello' => 'world'})
+    expect(subject.value).to eq({'hello' => 'world'})
+  end
+end

data/spec/unit/hardwareisa_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "Hardwareisa fact" do
+  it "should match uname -p on Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Inky")
+
+    Facter.fact(:hardwareisa).value.should == "Inky"
+  end
+
+  it "should match uname -p on Darwin" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Blinky")
+
+    Facter.fact(:hardwareisa).value.should == "Blinky"
+  end
+
+  it "should match uname -p on SunOS" do
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Pinky")
+
+    Facter.fact(:hardwareisa).value.should == "Pinky"
+  end
+
+  it "should match uname -p on FreeBSD" do
+    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Clyde")
+
+    Facter.fact(:hardwareisa).value.should == "Clyde"
+  end
+
+  it "should match uname -m on HP-UX" do
+    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+    Facter::Core::Execution.stubs(:execute).with("uname -m", anything).returns("Pac-Man")
+
+    Facter.fact(:hardwareisa).value.should == "Pac-Man"
+  end
+end

data/spec/unit/hardwaremodel_spec.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "Hardwaremodel fact" do
+  it "should match uname -m by default" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Core::Execution.stubs(:execute).with("uname -m", anything).returns("Inky")
+
+    Facter.fact(:hardwaremodel).value.should == "Inky"
+  end
+
+  describe "on Windows" do
+    require 'facter/util/wmi'
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("windows")
+    end
+
+    it "should detect i486" do
+      cpu = mock('cpu', :Architecture => 0)
+      cpu.expects(:Level).returns(4).twice
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i486"
+    end
+
+    it "should detect i686" do
+      cpu = mock('cpu', :Architecture => 0, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+
+    it "should detect x64" do
+      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 64, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "x64"
+    end
+
+    it "(#16948) reports i686 when a 32 bit OS is running on a 64 bit CPU" do
+      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 32, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+
+    it "(#20989) should report i686 when a 32 bit OS is running on a 64 bit CPU and when level is greater than 6 (and not something like i1586)" do
+      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 32, :Level => 15)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+  end
+end

data/spec/unit/hostname_spec.rb

@@ -0,0 +1,40 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "Hostname facts" do
+
+  describe "on linux" do
+    before do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+      Facter.fact(:kernelrelease).stubs(:value).returns("2.6")
+    end
+
+    it "should use the hostname command" do
+      Facter::Core::Execution.expects(:execute).with('hostname').at_least_once
+      Facter.fact(:hostname).value.should be_nil
+    end
+
+    it "should use hostname as the fact if unqualified" do
+      Facter::Core::Execution.stubs(:execute).with('hostname').returns('host1')
+      Facter.fact(:hostname).value.should == "host1"
+    end
+
+    it "should truncate the domain name if qualified" do
+      Facter::Core::Execution.stubs(:execute).with('hostname').returns('host1.example.com')
+      Facter.fact(:hostname).value.should == "host1"
+    end
+  end
+
+  describe "on darwin release R7" do
+    before do
+      Facter.fact(:kernel).stubs(:value).returns("Darwin")
+      Facter.fact(:kernelrelease).stubs(:value).returns("R7")
+    end
+
+    it "should use scutil to get the hostname" do
+      Facter::Core::Execution.expects(:execute).with('/usr/sbin/scutil --get LocalHostName', anything).returns("host1")
+      Facter.fact(:hostname).value.should == "host1"
+    end
+  end
+end

data/spec/unit/id_spec.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "id fact" do
+  include FacterSpec::ConfigHelper
+
+  kernel = [ 'Linux', 'Darwin', 'windows', 'FreeBSD', 'OpenBSD', 'NetBSD', 'AIX', 'HP-UX' ]
+
+  kernel.each do |k|
+    describe "with kernel reported as #{k}" do
+      it "should return the current user" do
+        given_a_configuration_of(:is_windows => k == 'windows')
+        Facter.fact(:kernel).stubs(:value).returns(k)
+        Facter::Core::Execution.expects(:execute).once.with('whoami', anything).returns 'bar'
+
+        Facter.fact(:id).value.should == 'bar'
+      end
+    end
+  end
+
+  it "should return the current user on Solaris" do
+    given_a_configuration_of(:is_windows => false)
+    Facter.fact(:kernel).stubs(:value).returns 'SunOS'
+    Facter::Core::Execution.expects(:execute).once.with('/usr/xpg4/bin/id -un', anything).returns 'bar'
+
+    Facter.fact(:id).value.should == 'bar'
+  end
+end

data/spec/unit/interfaces_spec.rb

@@ -0,0 +1,57 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'shared_formats/parses'
+require 'facter/util/ip'
+
+shared_examples_for "interface netmask and mtu from ifconfig output" do |platform, interface, netmask, mtu, fixture|
+  it "should be correct on #{platform} for interface #{interface}" do
+    Facter::Util::IP.stubs(:exec_ifconfig).returns(my_fixture_read(fixture))
+    Facter::Util::IP.stubs(:get_output_for_interface_and_label).
+      returns(my_fixture_read("#{fixture}.#{interface}"))
+    Facter.collection.internal_loader.load(:interfaces)
+
+    Facter.fact("netmask_#{interface}".intern).value.should eq(netmask)
+    Facter.fact("mtu_#{interface}".intern).value.should eq(mtu)
+  end
+end
+
+describe "Per Interface IP facts" do
+  it "should replace the ':' in an interface list with '_'" do
+    # So we look supported
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+
+    Facter::Util::IP.stubs(:get_interfaces).returns %w{eth0:1 eth1:2}
+    Facter.fact(:interfaces).value.should == %{eth0_1,eth1_2}
+  end
+
+  it "should replace non-alphanumerics in an interface list with '_'" do
+    Facter.fact(:kernel).stubs(:value).returns("windows")
+
+    Facter::Util::IP.stubs(:get_interfaces).returns ["Local Area Connection", "Loopback \"Pseudo-Interface\" (#1)"]
+    Facter.fact(:interfaces).value.should == %{Local_Area_Connection,Loopback__Pseudo_Interface____1_}
+  end
+
+  it "should properly format a mac address" do
+    Facter::Util::IP.stubs(:get_interfaces).returns ["net0"]
+    Facter::Util::IP.stubs(:get_interface_value).returns "0:12:34:56:78:90"
+
+    Facter.collection.internal_loader.load(:interfaces)
+
+    fact = Facter.fact("macaddress_net0".intern)
+    fact.value.should eq("00:12:34:56:78:90")
+  end
+end
+
+describe "Netmask and MTU handling on Linux" do
+  before :each do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+  end
+
+  example_behavior_for "interface netmask and mtu from ifconfig output",
+    "Archlinux (net-tools 1.60)", "em1",
+    "255.255.255.0", "1500", "ifconfig_net_tools_1.60.txt"
+  example_behavior_for "interface netmask and mtu from ifconfig output",
+    "Archlinux (net-tools 1.60)", "lo",
+    "255.0.0.0", "16436", "ifconfig_net_tools_1.60.txt"
+end

data/spec/unit/ipaddress6_spec.rb

@@ -0,0 +1,161 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/ip'
+
+def ifconfig_fixture(filename)
+  File.read(fixtures('ifconfig', filename))
+end
+
+describe "The IPv6 address fact" do
+  include FacterSpec::ConfigHelper
+
+  before do
+    given_a_configuration_of(:is_windows => false)
+  end
+
+  it "should return ipaddress6 information for Darwin" do
+    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Darwin')
+    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
+    Facter::Util::IP.stubs(:exec_ifconfig).with(["-a"]).
+      returns(ifconfig_fixture('darwin_ifconfig_all_with_multiple_interfaces'))
+
+    Facter.value(:ipaddress6).should == "2610:10:20:209:223:32ff:fed5:ee34"
+  end
+
+  it "should return ipaddress6 information for Linux" do
+    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Linux')
+    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
+    Facter::Util::IP.stubs(:exec_ifconfig).with(["2>/dev/null"]).
+      returns(ifconfig_fixture('linux_ifconfig_all_with_multiple_interfaces'))
+
+    Facter.value(:ipaddress6).should == "2610:10:20:209:212:3fff:febe:2201"
+  end
+
+  it "should return ipaddress6 information for Linux with recent net-tools" do
+      Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Linux')
+      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
+      Facter::Util::IP.stubs(:exec_ifconfig).with(["2>/dev/null"]).
+        returns(ifconfig_fixture('ifconfig_net_tools_1.60.txt'))
+
+      Facter.value(:ipaddress6).should == "2610:10:20:209:212:3fff:febe:2201"
+    end
+
+  it "should return ipaddress6 information for Solaris" do
+    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('SunOS')
+    Facter::Util::IP.stubs(:get_ifconfig).returns("/usr/sbin/ifconfig")
+    Facter::Util::IP.stubs(:exec_ifconfig).with(["-a"]).
+      returns(ifconfig_fixture('sunos_ifconfig_all_with_multiple_interfaces'))
+
+    Facter.value(:ipaddress6).should == "2610:10:20:209:203:baff:fe27:a7c"
+  end
+
+  context "on Windows" do
+    require 'facter/util/wmi'
+    require 'facter/util/registry'
+    require 'facter/util/ip/windows'
+    require 'facter_spec/windows_network'
+
+    include FacterSpec::WindowsNetwork
+
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns(:windows)
+      Facter::Util::Registry.stubs(:hklm_read).returns(nic_bindings)
+      given_a_configuration_of(:is_windows => true)
+    end
+
+    it "should do what when VPN is turned on?"
+
+    context "when you have no active network adapter" do
+      it "should return nil if there are no active (or any) network adapters" do
+        Facter::Util::WMI.expects(:execquery).with(Facter::Util::IP::Windows::WMI_IP_INFO_QUERY).returns([])
+
+        Facter.value(:ipaddress6).should == nil
+      end
+    end
+
+    it "should return nil if the system doesn't have ipv6 installed", :if => Facter::Util::Config.is_windows? do
+      Facter::Util::Resolution.any_instance.expects(:warn).never
+      Facter::Util::Registry.stubs(:hklm_read).raises(Win32::Registry::Error, 2)
+
+      Facter.value(:ipaddress6).should == nil
+    end
+
+    context "when you have one network adapter" do
+      it "should return empty if ipv6 is not on" do
+        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
+        nic.expects(:IPAddress).returns([ipAddress1])
+        Facter::Util::WMI.expects(:execquery).returns([nic])
+
+        Facter.value(:ipaddress6).should == nil
+      end
+
+      it "should return the ipv6 address properly" do
+        Facter::Util::WMI.expects(:execquery).returns([given_a_valid_windows_nic_with_ipv4_and_ipv6])
+
+        Facter.value(:ipaddress6).should == ipv6Address0
+      end
+
+      it "should return the first ipv6 address if there is more than one (multi-homing)" do
+        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
+        nic.expects(:IPAddress).returns([ipAddress0, ipv6Address0,ipv6Address1])
+        Facter::Util::WMI.expects(:execquery).returns([nic])
+
+        Facter.value(:ipaddress6).should == ipv6Address0
+      end
+
+      it "should return return nil if the ipv6 address is link local" do
+        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
+        nic.expects(:IPAddress).returns([ipAddress0, ipv6LinkLocal])
+        Facter::Util::WMI.expects(:execquery).returns([nic])
+
+        Facter.value(:ipaddress6).should == nil
+      end
+    end
+
+    context "when you have more than one network adapter" do
+      it "should return empty if ipv6 is not on" do
+        nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+        nics[:nic0].expects(:IPAddress).returns([ipAddress0])
+        nics[:nic1].expects(:IPAddress).returns([ipAddress1])
+        Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+        Facter.value(:ipaddress6).should == nil
+      end
+
+      it "should return the ipv6 of the adapter with the lowest IP connection metric (best connection)" do
+        nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+        nics[:nic1].expects(:IPConnectionMetric).returns(5)
+        Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+        Facter.value(:ipaddress6).should == ipv6Address1
+      end
+
+      it "should return the ipv6 of the adapter with the lowest IP connection metric (best connection) that has ipv6 enabled" do
+        nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+        nics[:nic1].expects(:IPConnectionMetric).returns(5)
+        nics[:nic1].expects(:IPAddress).returns([ipAddress1])
+        Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+        Facter.value(:ipaddress6).should == ipv6Address0
+      end
+
+      context "when the IP connection metric is the same" do
+        it "should return the ipv6 of the adapter with the lowest binding order" do
+          nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+          Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+          Facter.value(:ipaddress6).should == ipv6Address0
+        end
+
+        it "should return the ipv6 of the adapter with the lowest binding order even if the adapter is not first" do
+          nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+          Facter::Util::Registry.stubs(:hklm_read).returns(["\\Device\\#{settingId1}", "\\Device\\#{settingId0}" ])
+          Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+          Facter.value(:ipaddress6).should == ipv6Address1
+        end
+      end
+    end
+  end
+end