facter 2.0.1.rc1-universal-darwin

data/spec/unit/ps_spec.rb

@@ -0,0 +1,42 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "ps facts" do
+
+  it "should return busybox style ps www on OpenWrt" do
+    Facter.fact(:operatingsystem).stubs(:value).returns 'OpenWrt'
+    Facter.fact(:ps).value.should == 'ps www'
+  end
+
+  [
+    'FreeBSD',
+    'NetBSD',
+    'OpenBSD',
+    'Darwin',
+    'DragonFly'
+  ].each do |os|
+    it "should return unix style ps on operatingsystem #{os}" do
+      Facter.fact(:operatingsystem).stubs(:value).returns os
+      Facter.fact(:ps).value.should == 'ps auxwww'
+    end
+  end
+
+  # Other Linux Distros should return a ps -ef
+  [
+    'RedHat',
+    'Debian',
+  ].each do |os|
+    it "should return gnu/linux style ps -ef on operatingsystem #{os}" do
+      Facter.fact(:operatingsystem).stubs(:value).returns os
+      Facter.fact(:ps).value.should == 'ps -ef'
+    end
+  end
+
+  it "should return tasklist.exe on Windows" do
+    Facter.fact(:operatingsystem).stubs(:value).returns 'windows'
+    Facter.fact(:ps).value.should == 'tasklist.exe'
+  end
+
+end
+

data/spec/unit/selinux_spec.rb

@@ -0,0 +1,114 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "SELinux facts" do
+  describe "should detect if SELinux is enabled" do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+    end
+
+    it "and return true with default /selinux" do
+      mounts_does_not_exist
+
+      File.stubs(:read).with("/proc/self/attr/current").returns("notkernel")
+      FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
+      File.expects(:read).with("/proc/self/attr/current").returns("kernel")
+
+      FileTest.expects(:exists?).with("/selinux/enforce").returns true
+
+      Facter.fact(:selinux).value.should == "true"
+    end
+
+    it "and return true with selinuxfs path from /proc" do
+      selinux_root = "/sys/fs/selinux"
+      mounts_contains("selinuxfs #{selinux_root} selinuxfs rw,relatime 0 0")
+
+      FileTest.expects(:exists?).with("#{selinux_root}/enforce").returns true
+
+      FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
+      File.expects(:read).with("/proc/self/attr/current").returns("kernel")
+
+      Facter.fact(:selinux).value.should == "true"
+    end
+
+    it "and return true with multiple selinuxfs mounts from /proc" do
+      selinux_root = "/sys/fs/selinux"
+      mounts_contains(
+        "selinuxfs #{selinux_root} selinuxfs rw,relatime 0 0",
+        "selinuxfs /var/tmp/imgcreate-R2wmE6/install_root/sys/fs/selinux selinuxfs rw,relatime 0 0"
+      )
+
+      FileTest.expects(:exists?).with("#{selinux_root}/enforce").returns true
+
+      FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
+      File.expects(:read).with("/proc/self/attr/current").returns("kernel")
+
+      Facter.fact(:selinux).value.should == "true"
+    end
+  end
+
+  describe "when selinux is present" do
+    before :each do
+      Facter.fact(:selinux).stubs(:value).returns("true")
+    end
+
+    it "should return true if SELinux policy enabled" do
+      mounts_does_not_exist
+
+      FileTest.expects(:exists?).with("/selinux/enforce").returns true
+      File.expects(:read).with("/selinux/enforce").returns("1")
+
+      Facter.fact(:selinux_enforced).value.should == "true"
+    end
+
+    it "should return an SELinux policy version" do
+      mounts_does_not_exist
+
+      FileTest.expects(:exists?).with("/selinux/policyvers").returns true
+      File.expects(:read).with("/selinux/policyvers").returns("1")
+
+      Facter.fact(:selinux_policyversion).value.should == "1"
+    end
+
+    it "it should return 'unknown' SELinux policy version if /selinux/policyvers doesn't exist" do
+      mounts_does_not_exist
+
+      FileTest.expects(:exists?).with("/selinux/policyvers").returns false
+
+      Facter.fact(:selinux_policyversion).value.should == "unknown"
+    end
+
+    it "should return the SELinux current mode" do
+      sestatus_is(my_fixture_read("selinux_sestatus"))
+
+      Facter.fact(:selinux_current_mode).value.should == "permissive"
+    end
+
+    it "should return the SELinux mode from the configuration file" do
+      sestatus_is(my_fixture_read("selinux_sestatus"))
+
+      Facter.fact(:selinux_config_mode).value.should == "permissive"
+    end
+
+    it "should return the SELinux configuration file policy" do
+      sestatus_is(my_fixture_read("selinux_sestatus"))
+
+      Facter.fact(:selinux_config_policy).value.should == "targeted"
+    end
+  end
+
+  def sestatus_is(status)
+    Facter::Core::Execution.stubs(:exec).with('/usr/sbin/sestatus').returns(status)
+  end
+
+  def mounts_does_not_exist
+    FileTest.stubs(:exists?).with("/proc/self/mounts").returns false
+  end
+
+  def mounts_contains(*lines)
+    FileTest.expects(:exists?).with("/proc/self/mounts").returns true
+    Facter::Core::Execution.expects(:exec).with("cat /proc/self/mounts").returns(lines.join("\n"))
+  end
+
+end

data/spec/unit/ssh_spec.rb

@@ -0,0 +1,77 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/ssh'
+require 'pathname'
+
+describe "SSH fact" do
+
+  dirs = [  '/etc/ssh',
+    '/usr/local/etc/ssh',
+    '/etc',
+    '/usr/local/etc',
+    '/etc/opt/ssh',
+  ]
+
+  before :each do
+    # We need these facts loaded, but they belong to a file with a
+    # different name, so load the file explicitly.
+    Facter.collection.internal_loader.load(:ssh)
+  end
+
+  # fingerprints extracted from ssh-keygen -r '' -f /etc/ssh/ssh_host_dsa_key.pub
+  { 'SSHRSAKey' => [ 'ssh_host_rsa_key.pub' , "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDrs+KtR8hjasELsyCiiBplUeIi77hEHzTSQt1ALG7N4IgtMg27ZAcq0tl2/O9ZarQuClc903pgionbM9Q98CtAIoqgJwdtsor7ETRmzwrcY/mvI7ne51UzQy4Eh9WrplfpNyg+EVO0FUC7mBcay6JY30QKasePp+g4MkwK5cuTzOCzd9up9KELonlH7tTm2L0YI4HhZugwVoTFulCAZvPICxSk1B/fEKyGSZVfY/UxZNqg9g2Wyvq5u40xQ5eO882UwhB3w4IbmRnPKcyotAcqOJxA7hToMKtEmFct+vjHE8T37w8axE/1X9mdvy8IZbkEBL1cupqqb8a8vU1QTg1z", "SSHFP 1 1 1e4f163a1747d0d1a08a29972c9b5d94ee5705d0\nSSHFP 1 2 4e834c91e423d6085ed6dfb880a59e2f1b04f17c1dc17da07708af67c5ab6045" ],
+    'SSHDSAKey' => [ 'ssh_host_dsa_key.pub' , "ssh-dss AAAAB3NzaC1kc3MAAACBAKjmRez14aZT6OKhHrsw19s7u30AdghwHFQbtC+L781YjJ3UV0/WQoZ8NaDL4ovuvW23RuO49tsqSNcVHg+PtRiN2iTVAS2h55TFhaPKhTs+i0NH3p3Ze8LNSYuz8uK7a+nTxysz47GYTHiE1ke8KXe5wGKDO1TO/MUgpDbwx72LAAAAFQD9yMJCnZMiKzA7J1RNkwvgCyBKSQAAAIAtWBAsuRM0F2fdCe+F/JmgyryQmRIT5vP8E1ww3t3ywdLHklN7UMkaEKBW/TN/jj1JOGXtZ2v5XI+0VNoNKD/7dnCGzNViRT/jjfyVi6l5UMg4Q52Gv0RXJoBJpxNqFOU2niSsy8hioyE39W6LJYWJtQozGpH/KKgkCSvxBn5hlAAAAIB1yo/YD0kQICOO0KE+UMMaKtV7FwyedFJsxsWYwZfHXGwWskf0d2+lPhd9qwdbmSvySE8Qrlvu+W+X8AipwGkItSnj16ORF8kO3lfABa+7L4BLDtumt7ybjBPcHOy3n28dd07TmMtyWvLjOb0mcxPo+TwDLtHd3L/3C1Dh41jRPg==\n", "SSHFP 2 1 f63dfe8da99f50ffbcfa40a61161cee29d109f70\nSSHFP 2 2 5f57aa6be9baddd71b6049ed5d8639664a7ddf92ce293e3887f16ad0f2d459d9"  ],
+    'SSHECDSAKey' => [ 'ssh_host_ecdsa_key.pub' , 'ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBIuKHtgXQUIrXSVNKC7uY+ZOF7jjfqYNU7Cb/IncDOZ7jW44dxsfBzRJwS5sTHERjBinJskY87mmwY07NFF5GoE=', "SSHFP 3 1 091a088fd3500ad9e35ce201c5101646cbf6ff98\nSSHFP 3 2 1dd2aa8f29b539337316e2862b28c196c68ffe0af78fccf9e50625635677e50f"],
+    'SSHED25519Key' => [ 'ssh_host_ed25519_key.pub' , 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAkxkUMKV0H7Z0KDgfMs+iKQFwJhKUDg8GImV/BwN48X', "SSHFP 4 1 216d49ff3581a42c7a2d4064f2356b375367d493\nSSHFP 4 2 95e3aa6f86bc2dcc46f1e9e5ea930c790afc0669fcf237c4d7b0c8e386ef2790"]
+  }.each_pair do |fact, data|
+    describe "#{fact}" do
+      let(:filename) { data[0] }
+      let(:contents) { data[1] }
+      let(:fingerprint) { data[2] }
+      let(:fingerprint_fact) { "SSHFP_#{fact[3..-4]}" }
+      let(:private_key) { /AAAA\S+/.match(contents).to_s }
+
+      # Before we start testing, we'll say that the file
+      # doesn't exist in any of our search locations.
+      # Then, when we test a specific directory, we'll
+      # toggle just that one on.
+      # This doesn't test the search order, but it does
+      # make testing each of the individual cases *way*
+      # easier.  --jeffweiss 24 May 2012
+      before(:each) do
+        dirs.each do |dir|
+          full_path = File.join(dir, filename)
+          FileTest.stubs(:file?).with(full_path).returns false
+        end
+      end
+
+      # Now, let's go through each and individually flip then
+      # on for that test.
+      dirs.each do |dir|
+        describe "when data is in #{dir}" do
+          let(:full_path) { File.join(dir, filename) }
+          before(:each) do
+            full_path = File.join(dir, filename)
+            FileTest.stubs(:file?).with(full_path).returns true
+          end
+
+          it "should find in #{dir}" do
+            FileTest.expects(:file?).with(full_path)
+            Facter.fact(fact).value
+          end
+
+          it "should match the contents" do
+            File.expects(:read).with(full_path).at_least_once.returns contents
+            Facter.fact(fact).value.should == private_key
+          end
+
+          it "should have matching fingerprint" do
+            File.expects(:read).with(full_path).at_least_once.returns contents
+            Facter.fact(fingerprint_fact).value.should == fingerprint
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/uniqueid_spec.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "Uniqueid fact" do
+  it "should match hostid on Solaris" do
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    Facter::Core::Execution.stubs(:exec).with("hostid").returns("Larry")
+
+    Facter.fact(:uniqueid).value.should == "Larry"
+  end
+
+  it "should match hostid on Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter::Core::Execution.stubs(:exec).with("hostid").returns("Curly")
+
+    Facter.fact(:uniqueid).value.should == "Curly"
+  end
+
+  it "should match hostid on AIX" do
+    Facter.fact(:kernel).stubs(:value).returns("AIX")
+    Facter::Core::Execution.stubs(:exec).with("hostid").returns("Moe")
+
+    Facter.fact(:uniqueid).value.should == "Moe"
+  end
+end

data/spec/unit/uptime_spec.rb

@@ -0,0 +1,110 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/uptime'
+
+describe "uptime facts:" do
+  before { Facter.clear }
+  after { Facter.clear }
+
+  describe "when uptime information is available" do
+    describe "uptime" do
+      test_cases = [
+        [60 * 60 * 24 * 3,      '3 days'],
+        [60 * 60 * 24 * 3 + 25, '3 days'],
+        [60 * 60 * 24 * 1,      '1 day'],
+        [60 * 60 * 24 * 1 + 25, '1 day'],
+        [60 * (60 * 3 + 45),    '3:45 hours'],
+        [60 * (60 * 3 + 4),     '3:04 hours'],
+        [60 * 60,               '1:00 hours'],
+        [60 * 35,               '0:35 hours']
+      ]
+
+      test_cases.each do |seconds, expected|
+        it "should return #{expected.inspect} for #{seconds} seconds" do
+          Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(seconds)
+          Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(seconds)
+
+          Facter.fact(:uptime).value.should == expected
+        end
+      end
+    end
+
+  end
+
+  describe "when uptime information is available" do
+    before do
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(60 * 60 * 24 + 23)
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(60 * 60 * 24 + 23)
+    end
+
+    describe "uptime_seconds" do
+      it "should return the uptime in seconds" do
+        Facter.fact(:uptime_seconds).value.should == 60 * 60 * 24 + 23
+      end
+    end
+
+    describe "uptime_hours" do
+      it "should return the uptime in hours" do
+        Facter.fact(:uptime_hours).value.should == 24
+      end
+    end
+
+    describe "uptime_days" do
+      it "should return the uptime in days" do
+        Facter.fact(:uptime_days).value.should == 1
+      end
+    end
+  end
+
+  describe "when uptime information is not available" do
+    before do
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(nil)
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(nil)
+      $stderr, @old = StringIO.new, $stderr
+    end
+
+    after do
+      $stderr = @old
+    end
+
+    describe "uptime" do
+      it "should return 'unknown'" do
+        Facter.fact(:uptime).value.should == "unknown"
+      end
+    end
+
+    describe "uptime_seconds" do
+      it "should return nil" do
+        Facter.fact(:uptime_seconds).value.should == nil
+      end
+
+      it "should not print a warn message to stderr" do
+        Facter.fact(:uptime_seconds).value
+        $stderr.string.should == ""
+      end
+    end
+
+    describe "uptime_hours" do
+      it "should return nil" do
+        Facter.fact(:uptime_hours).value.should == nil
+      end
+
+      it "should not print a warn message to stderr" do
+        Facter.fact(:uptime_hours).value
+        $stderr.string.should == ""
+      end
+    end
+
+    describe "uptime_days" do
+      it "should return nil" do
+        Facter.fact(:uptime_days).value.should == nil
+      end
+
+      it "should not print a warn message to stderr" do
+        Facter.fact(:uptime_days).value
+        $stderr.string.should == ""
+      end
+    end
+  end
+end

data/spec/unit/util/collection_spec.rb

@@ -0,0 +1,258 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/collection'
+require 'facter/util/nothing_loader'
+
+describe Facter::Util::Collection do
+  let(:external_loader) { Facter::Util::NothingLoader.new }
+  let(:internal_loader) do
+    load = Facter::Util::Loader.new
+    load.stubs(:load).returns nil
+    load.stubs(:load_all).returns nil
+    load
+  end
+  let(:collection) { Facter::Util::Collection.new(internal_loader, external_loader) }
+
+  it "should delegate its load_all method to its loader" do
+    internal_loader.expects(:load_all)
+
+    collection.load_all
+  end
+
+  describe "when adding facts" do
+    it "should create a new fact if no fact with the same name already exists" do
+      collection.add(:myname)
+      collection.fact(:myname).name.should == :myname
+    end
+
+    it "should accept options" do
+      collection.add(:myname, :timeout => 1) { }
+    end
+
+    it "passes resolution specific options to the fact" do
+      fact = Facter::Util::Fact.new(:myname)
+      Facter::Util::Fact.expects(:new).with(:myname, {:timeout => 'myval'}).returns fact
+
+      fact.expects(:add).with({:timeout => 'myval'})
+
+      collection.add(:myname, :timeout => "myval") {}
+    end
+
+    describe "and a block is provided" do
+      it "should use the block to add a resolution to the fact" do
+        fact = mock 'fact'
+        fact.stubs(:extract_ldapname_option!)
+        Facter::Util::Fact.expects(:new).returns fact
+
+        fact.expects(:add)
+
+        collection.add(:myname) {}
+      end
+
+      it "should discard resolutions that throw an exception when added" do
+        Facter.expects(:warn).with(regexp_matches(/Unable to add resolve .* kaboom!/))
+        expect {
+          collection.add('yay') do
+            raise "kaboom!"
+          end
+        }.to_not raise_error
+        expect(collection.value('yay')).to be_nil
+      end
+    end
+  end
+
+  describe "when only defining facts" do
+    it "creates a new fact if no such fact exists" do
+      fact = Facter::Util::Fact.new(:newfact)
+      Facter::Util::Fact.expects(:new).with(:newfact, {}).returns fact
+      expect(collection.define_fact(:newfact)).to equal fact
+    end
+
+    it "returns an existing fact if the fact has already been defined" do
+      fact = collection.define_fact(:newfact)
+      expect(collection.define_fact(:newfact)).to equal fact
+    end
+
+    it "passes options to newly generated facts" do
+      Facter.stubs(:warnonce)
+      fact = collection.define_fact(:newfact, :ldapname => 'NewFact')
+      expect(fact.ldapname).to eq 'NewFact'
+    end
+
+    it "logs a warning if the fact could not be defined" do
+      Facter.expects(:warn).with("Unable to add fact newfact: kaboom!")
+
+      collection.define_fact(:newfact) do
+        raise "kaboom!"
+      end
+    end
+  end
+
+  describe "when retrieving facts" do
+    before do
+      @fact = collection.add("YayNess")
+    end
+
+    it "should return the fact instance specified by the name" do
+      collection.fact("YayNess").should equal(@fact)
+    end
+
+    it "should be case-insensitive" do
+      collection.fact("yayness").should equal(@fact)
+    end
+
+    it "should treat strings and symbols equivalently" do
+      collection.fact(:yayness).should equal(@fact)
+    end
+
+    it "should use its loader to try to load the fact if no fact can be found" do
+      collection.internal_loader.expects(:load).with(:testing)
+      collection.fact("testing")
+    end
+
+    it "should return nil if it cannot find or load the fact" do
+      collection.internal_loader.expects(:load).with(:testing)
+      collection.fact("testing").should be_nil
+    end
+  end
+
+  describe "when returning a fact's value" do
+    before do
+      @fact = collection.add("YayNess", :value => "result")
+    end
+
+    it "should return the result of calling :value on the fact" do
+      collection.value("YayNess").should == "result"
+    end
+
+    it "should be case-insensitive" do
+      collection.value("yayness").should == "result"
+    end
+
+    it "should treat strings and symbols equivalently" do
+      collection.value(:yayness).should == "result"
+    end
+  end
+
+  it "should return the fact's value when the array index method is used" do
+    collection.add("myfact", :value => "foo")
+
+    collection["myfact"].should == "foo"
+  end
+
+  it "should have a method for flushing all facts" do
+    fact = collection.add("YayNess")
+
+    fact.expects(:flush)
+
+    collection.flush
+  end
+
+  it "should have a method that returns all fact names" do
+    collection.add(:one)
+    collection.add(:two)
+
+    collection.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
+  end
+
+  describe "when returning a hash of values" do
+    it "should return a hash of fact names and values with the fact names as strings" do
+      collection.add(:one, :value => "me")
+
+      collection.to_hash.should == {"one" => "me"}
+    end
+
+    it "should not include facts that did not return a value" do
+      collection.add(:two, :value => nil)
+
+      collection.to_hash.should_not be_include(:two)
+    end
+  end
+
+  describe "when iterating over facts" do
+    before do
+      collection.add(:one, :value => "ONE")
+      collection.add(:two, :value => "TWO")
+    end
+
+    it "should yield each fact name and the fact value" do
+      facts = {}
+      collection.each do |fact, value|
+        facts[fact] = value
+      end
+      facts.should == {"one" => "ONE", "two" => "TWO"}
+    end
+
+    it "should convert the fact name to a string" do
+      facts = {}
+      collection.each do |fact, value|
+        fact.should be_instance_of(String)
+      end
+    end
+
+    it "should only yield facts that have values" do
+      collection.add(:nil_fact, :value => nil)
+      facts = {}
+      collection.each do |fact, value|
+        facts[fact] = value
+      end
+
+      facts.should_not be_include("nil_fact")
+    end
+  end
+
+  describe "when no facts are loaded" do
+    it "should warn when no facts were loaded" do
+      Facter.expects(:warnonce).with("No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}").once
+
+      collection.fact("one")
+    end
+  end
+
+  describe "external facts" do
+    let(:external_loader) { SingleFactLoader.new(:test_fact, "fact value") }
+    let(:collection) { Facter::Util::Collection.new(internal_loader, external_loader) }
+
+    it "loads when a specific fact is requested" do
+      collection.fact(:test_fact).value.should == "fact value"
+    end
+
+    it "loads when facts are listed" do
+      collection.list.should == [:test_fact]
+    end
+
+    it "loads when all facts are iterated over" do
+      facts = []
+      collection.each { |fact_name, fact_value| facts << [fact_name, fact_value] }
+
+      facts.should == [["test_fact", "fact value"]]
+    end
+
+    it "are loaded only once" do
+      external_loader.expects(:load).with(collection)
+
+      collection.load_all
+      collection.load_all
+    end
+
+    it "are reloaded after flushing" do
+      external_loader.expects(:load).with(collection).twice
+
+      collection.load_all
+      collection.flush
+      collection.load_all
+    end
+  end
+
+  class SingleFactLoader
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def load(collection)
+      collection.add(@name, :value => @value)
+    end
+  end
+end