facter 2.0.1.rc1-universal-darwin

data/spec/unit/core/resolvable_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'facter/core/resolvable'
+
+describe Facter::Core::Resolvable do
+
+  class ResolvableClass
+    def initialize(name)
+      @name = name
+      @fact = Facter::Util::Fact.new("stub fact")
+    end
+    attr_accessor :name, :resolve_value
+    attr_reader :fact
+    include Facter::Core::Resolvable
+  end
+
+  subject { ResolvableClass.new('resolvable') }
+
+  it "has a default timeout of 0 seconds" do
+    expect(subject.limit).to eq 0
+  end
+
+  it "can specify a custom timeout" do
+    subject.timeout = 10
+    expect(subject.limit).to eq 10
+  end
+
+  describe "generating a value" do
+    it "returns the results of #resolve_value" do
+      subject.resolve_value = 'stuff'
+      expect(subject.value).to eq 'stuff'
+    end
+
+    it "normalizes the resolved value" do
+      Facter::Util::Normalization.expects(:normalize).returns 'stuff'
+      subject.resolve_value = 'stuff'
+      expect(subject.value).to eq('stuff')
+    end
+
+    it "logs a warning if an exception was raised" do
+      subject.expects(:resolve_value).raises RuntimeError, "kaboom!"
+      Facter.expects(:warn).with(regexp_matches(/Could not retrieve .*: kaboom!/))
+      expect(subject.value).to eq nil
+    end
+  end
+
+  describe "timing out" do
+    it "uses #limit instead of #timeout to determine the timeout period" do
+      subject.expects(:timeout).never
+      subject.expects(:limit).returns 25
+
+      Timeout.expects(:timeout).with(25)
+      subject.value
+    end
+
+    it "returns nil if the timeout was reached" do
+      Facter.expects(:warn).with(regexp_matches(/Timed out after 0\.1 seconds while resolving/))
+      Timeout.expects(:timeout).raises Timeout::Error
+
+      subject.timeout = 0.1
+
+      expect(subject.value).to be_nil
+    end
+  end
+
+  describe 'callbacks when flushing facts' do
+    class FlushFakeError < StandardError; end
+
+    context '#on_flush' do
+      it 'accepts a block with on_flush' do
+        subject.on_flush() { raise NotImplementedError }
+      end
+    end
+
+    context '#flush' do
+      it 'calls the block passed to on_flush' do
+        subject.on_flush() { raise FlushFakeError }
+        expect { subject.flush }.to raise_error FlushFakeError
+      end
+    end
+  end
+end

data/spec/unit/core/suitable_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'facter/core/suitable'
+
+describe Facter::Core::Suitable do
+
+  class SuitableClass
+    def initialize
+      @confines = []
+    end
+    attr_reader :confines
+    include Facter::Core::Suitable
+  end
+
+  subject { SuitableClass.new }
+
+  describe "confining on facts" do
+    it "can add confines with a fact and a single value" do
+      subject.confine :kernel => 'Linux'
+    end
+
+    it "creates a Facter::Util::Confine object for the confine call" do
+      subject.confine :kernel => 'Linux'
+      conf = subject.confines.first
+      expect(conf).to be_a_kind_of Facter::Util::Confine
+      expect(conf.fact).to eq :kernel
+      expect(conf.values).to eq ['Linux']
+    end
+  end
+
+  describe "confining on blocks" do
+    it "can add a single fact with a block parameter" do
+      subject.confine(:one) { true }
+    end
+
+    it "creates a Util::Confine instance for the provided fact with block parameter" do
+      block = lambda { true }
+      Facter::Util::Confine.expects(:new).with("one")
+
+      subject.confine("one", &block)
+    end
+
+    it "should accept a single block parameter" do
+      subject.confine() { true }
+    end
+
+    it "should create a Util::Confine instance for the provided block parameter" do
+      block = lambda { true }
+      Facter::Util::Confine.expects(:new)
+
+      subject.confine(&block)
+    end
+  end
+
+  describe "determining weight" do
+    it "is zero if no confines are set" do
+      expect(subject.weight).to eq 0
+    end
+
+    it "defaults to the number of confines" do
+      subject.confine :kernel => 'Linux'
+      expect(subject.weight).to eq 1
+    end
+
+    it "can be explicitly set" do
+      subject.has_weight 10
+      expect(subject.weight).to eq 10
+    end
+
+    it "prefers an explicit weight over the number of confines" do
+      subject.confine :kernel => 'Linux'
+      subject.has_weight 11
+      expect(subject.weight).to eq 11
+    end
+  end
+
+  describe "determining suitability" do
+    it "is true if all confines for the object evaluate to true" do
+      subject.confine :kernel => 'Linux'
+      subject.confine :operatingsystem => 'Redhat'
+
+      subject.confines.each { |confine| confine.stubs(:true?).returns true }
+
+      expect(subject).to be_suitable
+    end
+
+    it "is false if any confines for the object evaluate to false" do
+      subject.confine :kernel => 'Linux'
+      subject.confine :operatingsystem => 'Redhat'
+
+      subject.confines.first.stubs(:true?).returns true
+      subject.confines.first.stubs(:true?).returns false
+
+      expect(subject).to_not be_suitable
+    end
+  end
+end

data/spec/unit/domain_spec.rb

@@ -0,0 +1,310 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'stringio'
+
+describe "Domain name facts" do
+
+  def resolv_conf_contains(*lines)
+    file_handle = StringIO.new(lines.join("\n"))
+    FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(true)
+    File.stubs(:open).with("/etc/resolv.conf").yields(file_handle)
+  end
+
+  [
+    { :kernel => "Linux", :hostname_command => "hostname -f 2> /dev/null" },
+    { :kernel => "SunOS", :hostname_command => "hostname 2> /dev/null" },
+    { :kernel => "Darwin", :hostname_command => "hostname -f 2> /dev/null" },
+    { :kernel => "FreeBSD", :hostname_command => "hostname -f 2> /dev/null" },
+    { :kernel => "HP-UX", :hostname_command => "hostname 2> /dev/null" },
+  ].each do |scenario|
+
+    describe "on #{scenario[:kernel]}" do
+      let(:hostname_command) { scenario[:hostname_command] }
+      let(:dnsdomain_command) { "dnsdomainname 2> /dev/null" }
+
+      def the_hostname_is(value)
+        Facter::Core::Execution.stubs(:exec).with(hostname_command).returns(value)
+      end
+
+      def the_dnsdomainname_is(value)
+        Facter::Core::Execution.stubs(:exec).with(dnsdomain_command).returns(value)
+      end
+
+      before do
+        Facter.fact(:kernel).stubs(:value).returns(scenario[:kernel])
+      end
+
+      it "should use the hostname binary" do
+        the_hostname_is("test.example.com")
+
+        Facter.fact(:domain).value.should == "example.com"
+      end
+
+      it "should fall back to the dnsdomainname binary" do
+        the_hostname_is("myhost")
+        the_dnsdomainname_is("example.com")
+
+        Facter.fact(:domain).value.should == "example.com"
+      end
+
+      it "should fall back to /etc/resolv.conf" do
+        the_hostname_is("myhost")
+        the_dnsdomainname_is("")
+
+        resolv_conf_contains("domain testing.com")
+
+        Facter.fact(:domain).value.should == "testing.com"
+      end
+
+      describe "Top level domain" do
+        it "should find the domain name" do
+          the_hostname_is("ns01.tld")
+
+          Facter.fact(:domain).value.should == "tld"
+        end
+      end
+
+      describe "when using /etc/resolv.conf" do
+        before do
+          the_hostname_is("")
+          the_dnsdomainname_is("")
+        end
+
+        it "should use the domain field over the search field" do
+          resolv_conf_contains(
+            "nameserver 4.2.2.1",
+            "search example.org",
+            "domain example.com"
+          )
+
+          Facter.fact(:domain).value.should == 'example.com'
+        end
+
+        it "should fall back to the search field" do
+          resolv_conf_contains(
+            "nameserver 4.2.2.1",
+            "search example.org"
+          )
+
+          Facter.fact(:domain).value.should == 'example.org'
+        end
+
+        it "should use the first domain in the search field" do
+          resolv_conf_contains("search example.org example.net")
+
+          Facter.fact(:domain).value.should == 'example.org'
+        end
+
+        # Test permutations of domain and search, where 'domain' can be a value of
+        # the search keyword and the domain keyword
+        # and also where 'search' can be a value of the search keyword and the
+        # domain keyword
+        # For example, /etc/resolv.conf may look like:
+        #     domain domain
+        # or
+        #     search search
+        # or
+        #     domain search
+        #
+        #
+        # Why someone would have their machines named 'www.domain' or 'www.search', I
+        # don't know, but we'll at least handle it properly
+        [
+         [["domain domain"], "domain"],
+         [["domain search"], "search"],
+         [["search domain"], "domain"],
+         [["search search"], "search"],
+         [["search domain notdomain"], "domain"],
+         [["#search notdomain", "search search"], "search"],
+         [["# search notdomain", "search search"], "search"],
+         [["#domain notdomain", "domain domain"], "domain"],
+         [["# domain notdomain", "domain domain"], "domain"],
+        ].each do |tuple|
+          conf  = tuple[0]
+          expect = tuple[1]
+          it "should return #{expect} from \"#{conf}\"" do
+            resolv_conf_contains(*conf)
+
+            Facter.fact(:domain).value.should == expect
+          end
+        end
+      end
+    end
+  end
+
+  describe "on Windows" do
+    before(:each) do
+      Facter.fact(:kernel).stubs(:value).returns("windows")
+      require 'facter/util/registry'
+    end
+
+    describe "with primary dns suffix" do
+      before(:each) do
+        Facter::Util::Registry.stubs(:hklm_read).returns('baz.com')
+      end
+
+      it "should get the primary dns suffix" do
+        Facter.fact(:domain).value.should == 'baz.com'
+      end
+
+      it "should not execute the wmi query" do
+        require 'facter/util/wmi'
+        Facter::Util::WMI.expects(:execquery).never
+        Facter.fact(:domain).value
+      end
+    end
+
+    describe "without primary dns suffix" do
+      before(:each) do
+        Facter::Util::Registry.stubs(:hklm_read).returns('')
+      end
+
+      def expects_dnsdomains(domains)
+        nics = []
+
+        domains.each do |domain|
+          nic = stubs 'nic'
+          nic.stubs(:DNSDomain).returns(domain)
+          nics << nic
+        end
+
+        require 'facter/util/wmi'
+        Facter::Util::WMI.stubs(:execquery).with("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").returns(nics)
+      end
+
+      it "uses the first DNSDomain" do
+        expects_dnsdomains(['foo.com', 'bar.com'])
+
+        Facter.fact(:domain).value.should == 'foo.com'
+      end
+
+      it "uses the first non-nil DNSDomain" do
+        expects_dnsdomains([nil, 'bar.com'])
+
+        Facter.fact(:domain).value.should == 'bar.com'
+      end
+
+      it "uses the first non-empty DNSDomain" do
+        expects_dnsdomains(['', 'bar.com'])
+
+        Facter.fact(:domain).value.should == 'bar.com'
+      end
+
+      context "without any network adapters with a specified DNSDomain" do
+        let(:hostname_command) { 'hostname > NUL' }
+
+        it "should return nil" do
+          expects_dnsdomains([nil])
+
+          Facter::Core::Execution.stubs(:exec).with(hostname_command).returns('sometest')
+          FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(false)
+
+          Facter.fact(:domain).value.should be_nil
+        end
+      end
+    end
+  end
+
+  describe "with trailing dots" do
+    describe "on Windows" do
+      before do
+        Facter.fact(:kernel).stubs(:value).returns("windows")
+        require 'facter/util/registry'
+        require 'facter/util/wmi'
+      end
+
+      [{:registry => 'testdomain.', :wmi => '', :expect => 'testdomain'},
+       {:registry => '', :wmi => 'testdomain.', :expect => 'testdomain'},
+      ].each do |scenario|
+
+        describe "scenarios" do
+          before(:each) do
+            Facter::Util::Registry.stubs(:hklm_read).returns(scenario[:registry])
+            nic = stubs 'nic'
+            nic.stubs(:DNSDomain).returns(scenario[:wmi])
+            Facter::Util::WMI.stubs(:execquery).with("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").returns([nic])
+          end
+
+          it "should return #{scenario[:expect]}" do
+            Facter.fact(:domain).value.should == scenario[:expect]
+          end
+
+          it "should remove trailing dots"  do
+            Facter.fact(:domain).value.should_not =~ /\.$/
+          end
+        end
+      end
+    end
+
+    describe "on everything else" do
+      before do
+        Facter.fact(:kernel).stubs(:value).returns("Linux")
+        FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(true)
+      end
+
+      [
+        {
+          :scenario => 'when there is only a hostname',
+          :hostname => 'host.testdomain.',
+          :dnsdomainname => '',
+          :resolve_domain => '',
+          :resolve_search => '',
+          :expect => 'testdomain'
+        },
+        {
+          :scenario => 'when there is only a domain name',
+          :hostname => '',
+          :dnsdomainname => 'testdomain.',
+          :resolve_domain => '',
+          :resolve_search => '',
+          :expect => 'testdomain'
+        },
+        {
+          :scenario => 'when there is only a resolve domain',
+          :hostname => '',
+          :dnsdomainname => '',
+          :resolve_domain => 'testdomain.',
+          :resolve_search => '',
+          :expect => 'testdomain'
+        },
+        {
+          :scenario => 'when there is only a resolve search',
+          :hostname => '',
+          :dnsdomainname => '',
+          :resolve_domain => '',
+          :resolve_search => 'testdomain.',
+          :expect => 'testdomain'
+        },
+        {
+          :scenario => 'when there is no information available',
+          :hostname => '',
+          :dnsdomainname => '',
+          :resolve_domain => '',
+          :resolve_search => '',
+          :expect => nil
+        }
+      ].each do |scenario|
+
+        describe scenario[:scenario] do
+          before(:each) do
+            Facter::Core::Execution.stubs(:exec).with("hostname -f 2> /dev/null").returns(scenario[:hostname])
+            Facter::Core::Execution.stubs(:exec).with("dnsdomainname 2> /dev/null").returns(scenario[:dnsdomainname])
+            resolv_conf_contains(
+              "search #{scenario[:resolve_search]}",
+              "domain #{scenario[:resolve_domain]}"
+            )
+          end
+
+          it "should remove trailing dots" do
+            Facter.fact(:domain).value.should_not =~ /\.$/
+          end
+
+          it "should return #{scenario[:expect]}" do
+            Facter.fact(:domain).value.should == scenario[:expect]
+          end
+        end
+      end
+    end
+  end
+end