facter 2.0.1.rc1-universal-darwin

data/spec/unit/util/config_spec.rb

@@ -0,0 +1,84 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Facter::Util::Config do
+  include PuppetlabsSpec::Files
+
+  describe "is_windows? function" do
+    it "should detect windows if Ruby RbConfig::CONFIG['host_os'] returns a windows OS" do
+      host_os = ["mswin","win32","dos","mingw","cygwin"]
+      host_os.each do |h|
+        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
+        Facter::Util::Config.is_windows?.should be_true
+      end
+    end
+
+    it "should not detect windows if Ruby RbConfig::CONFIG['host_os'] returns a non-windows OS" do
+      host_os = ["darwin","linux"]
+      host_os.each do |h|
+        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
+        Facter::Util::Config.is_windows?.should be_false
+      end
+    end
+  end
+
+  describe "is_mac? function" do
+    it "should detect mac if Ruby RbConfig::CONFIG['host_os'] returns darwin" do
+      host_os = ["darwin"]
+      host_os.each do |h|
+        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
+        Facter::Util::Config.is_mac?.should be_true
+      end
+    end
+  end
+
+  describe "external_facts_dirs" do
+    before :each do
+      Facter::Util::Root.stubs(:root?).returns(true)
+    end
+
+    it "should return the default value for linux" do
+      Facter::Util::Config.stubs(:is_windows?).returns(false)
+      Facter::Util::Config.stubs(:windows_data_dir).returns(nil)
+      Facter::Util::Config.setup_default_ext_facts_dirs
+      Facter::Util::Config.external_facts_dirs.should == ["/etc/facter/facts.d", "/etc/puppetlabs/facter/facts.d"]
+    end
+
+    it "should return the default value for windows 2008" do
+      Facter::Util::Config.stubs(:is_windows?).returns(true)
+      Facter::Util::Config.stubs(:windows_data_dir).returns("C:\\ProgramData")
+      Facter::Util::Config.setup_default_ext_facts_dirs
+      Facter::Util::Config.external_facts_dirs.should == [File.join("C:\\ProgramData", 'PuppetLabs', 'facter', 'facts.d')]
+    end
+
+    it "should return the default value for windows 2003R2" do
+      Facter::Util::Config.stubs(:is_windows?).returns(true)
+      Facter::Util::Config.stubs(:windows_data_dir).returns("C:\\Documents")
+      Facter::Util::Config.setup_default_ext_facts_dirs
+      Facter::Util::Config.external_facts_dirs.should == [File.join("C:\\Documents", 'PuppetLabs', 'facter', 'facts.d')]
+    end
+
+    it "returns the users home directory when not root" do
+      Facter::Util::Root.stubs(:root?).returns(false)
+      Facter::Util::Config.setup_default_ext_facts_dirs
+      Facter::Util::Config.external_facts_dirs.should == [File.expand_path(File.join("~", ".facter", "facts.d"))]
+    end
+
+    it "includes additional values when user appends to the list" do
+      Facter::Util::Config.setup_default_ext_facts_dirs
+      original_values = Facter::Util::Config.external_facts_dirs.dup
+      new_value = '/usr/share/newdir'
+      Facter::Util::Config.external_facts_dirs << new_value
+      Facter::Util::Config.external_facts_dirs.should == original_values + [new_value]
+    end
+
+    it "should only output new values when explicitly set" do
+      Facter::Util::Config.setup_default_ext_facts_dirs
+      new_value = ['/usr/share/newdir']
+      Facter::Util::Config.external_facts_dirs = new_value
+      Facter::Util::Config.external_facts_dirs.should == new_value
+    end
+
+  end
+end

data/spec/unit/util/confine_spec.rb

@@ -0,0 +1,148 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/confine'
+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"
+  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
+    def confined(fact_value, *confines)
+      @fact.stubs(:value).returns fact_value
+      Facter::Util::Confine.new("yay", *confines).true?
+    end
+
+    before do
+      @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
+
+      Facter::Util::Confine.new("yay", "test").true?.should be_false
+    end
+
+    it "should use the returned fact to get the value" do
+      Facter.expects(:[]).with("yay").returns @fact
+
+      @fact.expects(:value).returns nil
+
+      Facter::Util::Confine.new("yay", "test").true?
+    end
+
+    it "should return false if the fact has no value" do
+      confined(nil, "test").should be_false
+    end
+
+    it "should return true if any of the provided values matches the fact's value" do
+      confined("two", "two").should be_true
+    end
+
+    it "should return true if any of the provided symbol values matches the fact's value" do
+      confined(:xy, :xy).should be_true
+    end
+
+    it "should return true if any of the provided integer values matches the fact's value" do
+      confined(1, 1).should be_true
+    end
+
+    it "should return true if any of the provided boolan values matches the fact's value" do
+      confined(true, true).should be_true
+    end
+
+    it "should return true if any of the provided array values matches the fact's value" do
+      confined([3,4], [3,4]).should be_true
+    end
+
+    it "should return true if any of the provided symbol values matches the fact's string value" do
+      confined(:one, "one").should be_true
+    end
+
+    it "should return true if any of the provided string values matches case-insensitive the fact's value" do
+      confined("four", "Four").should be_true
+    end
+
+    it "should return true if any of the provided symbol values matches case-insensitive the fact's string value" do
+      confined(:four, "Four").should be_true
+    end
+
+    it "should return true if any of the provided symbol values matches the fact's string value" do
+      confined("xy", :xy).should be_true
+    end
+
+    it "should return true if any of the provided regexp values matches the fact's string value" do
+      confined("abc", /abc/).should be_true
+    end
+
+    it "should return true if any of the provided ranges matches the fact's value" do
+      confined(6, (5..7)).should be_true
+    end
+
+    it "should return false if none of the provided values matches the fact's value" do
+      confined("three", "two", "four").should be_false
+    end
+
+    it "should return false if none of the provided integer values matches the fact's value" do
+      confined(2, 1, [3,4], (5..7)).should be_false
+    end
+
+    it "should return false if none of the provided boolan values matches the fact's value" do
+      confined(false, true).should be_false
+    end
+
+    it "should return false if none of the provided array values matches the fact's value" do
+      confined([1,2], [3,4]).should be_false
+    end
+
+    it "should return false if none of the provided ranges matches the fact's value" do
+      confined(8, (5..7)).should be_false
+    end
+
+    it "should accept and evaluate a block argument against the fact" do
+      @fact.expects(:value).returns 'foo'
+      confine = Facter::Util::Confine.new :yay do |f| f === 'foo' end
+      confine.true?.should be_true
+    end
+
+    it "should return false if the block raises a StandardError when checking a fact" do
+      @fact.stubs(:value).returns 'foo'
+      confine = Facter::Util::Confine.new :yay do |f| raise StandardError end
+      confine.true?.should be_false
+    end
+
+    it "should accept and evaluate only a block argument" do
+      Facter::Util::Confine.new { true }.true?.should be_true
+      Facter::Util::Confine.new { false }.true?.should be_false
+    end
+
+    it "should return false if the block raises a StandardError" do
+      Facter::Util::Confine.new { raise StandardError }.true?.should be_false
+    end
+  end
+end

data/spec/unit/util/directory_loader_spec.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+require 'facter/util/directory_loader'
+
+describe Facter::Util::DirectoryLoader do
+  include PuppetlabsSpec::Files
+  include FacterSpec::ConfigHelper
+
+  subject { Facter::Util::DirectoryLoader.new(tmpdir('directory_loader')) }
+  let(:collection) { Facter::Util::Collection.new(mock("internal loader"), subject) }
+
+  it "should make the directory available" do
+    subject.directory.should be_instance_of(String)
+  end
+
+  it "can be created with a given directory" do
+    Facter::Util::DirectoryLoader.loader_for("ext").directory.should == "ext"
+  end
+
+  it "raises an error when the directory does not exist" do
+    missing_dir = "missing"
+    File.stubs(:directory?).with(missing_dir).returns(false)
+    expect { Facter::Util::DirectoryLoader.loader_for(missing_dir) }.to raise_error Facter::Util::DirectoryLoader::NoSuchDirectoryError
+  end
+
+  it "should do nothing bad when dir doesn't exist" do
+    fakepath = "/foobar/path"
+    my_loader = Facter::Util::DirectoryLoader.new(fakepath)
+    FileTest.exists?(my_loader.directory).should be_false
+    expect { my_loader.load(collection) }.to_not raise_error
+   end
+
+  describe "when loading facts from disk" do
+    it "should be able to load files from disk and set facts" do
+      data = {"f1" => "one", "f2" => "two"}
+      write_to_file("data.yaml", YAML.dump(data))
+
+      subject.load(collection)
+
+      collection.value("f1").should == "one"
+      collection.value("f2").should == "two"
+    end
+
+    it "should ignore files that begin with '.'" do
+      not_to_be_used_collection = mock("collection should not be used")
+      not_to_be_used_collection.expects(:add).never
+
+      data = {"f1" => "one", "f2" => "two"}
+      write_to_file(".data.yaml", YAML.dump(data))
+
+      subject.load(not_to_be_used_collection)
+    end
+
+    %w{bak orig}.each do |ext|
+      it "should ignore files with an extension of '#{ext}'" do
+        Facter.expects(:warn).with(regexp_matches(/#{ext}/))
+        write_to_file("data" + ".#{ext}", "foo=bar")
+
+        subject.load(collection)
+      end
+    end
+
+    it "should warn when trying to parse unknown file types" do
+      write_to_file("file.unknownfiletype", "stuff=bar")
+
+      Facter.expects(:warn).with(regexp_matches(/file.unknownfiletype/))
+
+      subject.load(collection)
+    end
+
+    it "external facts should almost always precedence over all other facts" do
+      Facter.add("f1", :value => "lower_weight_fact") { has_weight(Facter::Util::DirectoryLoader::EXTERNAL_FACT_WEIGHT - 1) }
+      data = {"f1" => "external_fact"}
+      write_to_file("data.yaml", YAML.dump(data))
+
+      subject.load(collection)
+
+      collection.value("f1").should == "external_fact"
+    end
+  end
+
+  def write_to_file(file_name, to_write)
+    file = File.join(subject.directory, file_name)
+    File.open(file, "w") { |f| f.print to_write}
+  end
+end

data/spec/unit/util/ec2_spec.rb

@@ -0,0 +1,180 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/ec2'
+
+describe Facter::Util::EC2 do
+  # This is the standard prefix for making an API call in EC2 (or fake)
+  # environments.
+  let(:api_prefix) { "http://169.254.169.254" }
+
+  describe "is_ec2_arp? method" do
+    describe "on linux" do
+      before :each do
+        # Return fake kernel
+        Facter.stubs(:value).with(:kernel).returns("linux")
+      end
+
+      it "should succeed if arp table contains fe:ff:ff:ff:ff:ff" do
+        ec2arp = my_fixture_read("linux-arp-ec2.out")
+        Facter::Core::Execution.expects(:exec).with("arp -an").\
+          at_least_once.returns(ec2arp)
+        Facter::Util::EC2.has_ec2_arp?.should == true
+      end
+
+      it "should succeed if arp table contains FE:FF:FF:FF:FF:FF" do
+        ec2arp = my_fixture_read("centos-arp-ec2.out")
+        Facter::Core::Execution.expects(:exec).with("arp -an").\
+          at_least_once.returns(ec2arp)
+        Facter::Util::EC2.has_ec2_arp?.should == true
+      end
+
+      it "should fail if arp table does not contain fe:ff:ff:ff:ff:ff" do
+        ec2arp = my_fixture_read("linux-arp-not-ec2.out")
+        Facter::Core::Execution.expects(:exec).with("arp -an").
+          at_least_once.returns(ec2arp)
+        Facter::Util::EC2.has_ec2_arp?.should == false
+      end
+    end
+
+    describe "on windows" do
+      before :each do
+        # Return fake kernel
+        Facter.stubs(:value).with(:kernel).returns("windows")
+      end
+
+      it "should succeed if arp table contains fe-ff-ff-ff-ff-ff" do
+        ec2arp = my_fixture_read("windows-2008-arp-a.out")
+        Facter::Core::Execution.expects(:exec).with("arp -a").\
+          at_least_once.returns(ec2arp)
+        Facter::Util::EC2.has_ec2_arp?.should == true
+      end
+
+      it "should fail if arp table does not contain fe-ff-ff-ff-ff-ff" do
+        ec2arp = my_fixture_read("windows-2008-arp-a-not-ec2.out")
+        Facter::Core::Execution.expects(:exec).with("arp -a").
+          at_least_once.returns(ec2arp)
+        Facter::Util::EC2.has_ec2_arp?.should == false
+      end
+    end
+
+    describe "on solaris" do
+      before :each do
+        Facter.stubs(:value).with(:kernel).returns("SunOS")
+      end
+
+      it "should fail if arp table does not contain fe:ff:ff:ff:ff:ff" do
+        ec2arp = my_fixture_read("solaris8_arp_a_not_ec2.out")
+
+        Facter::Core::Execution.expects(:exec).with("arp -a").
+          at_least_once.returns(ec2arp)
+
+        Facter::Util::EC2.has_ec2_arp?.should == false
+      end
+    end
+  end
+
+  describe "is_euca_mac? method" do
+    it "should return true when the mac is a eucalyptus one" do
+      Facter.expects(:value).with(:macaddress).\
+        at_least_once.returns("d0:0d:1a:b0:a1:00")
+
+      Facter::Util::EC2.has_euca_mac?.should == true
+    end
+
+    it "should return false when the mac is not a eucalyptus one" do
+      Facter.expects(:value).with(:macaddress).\
+        at_least_once.returns("0c:1d:a0:bc:aa:02")
+
+      Facter::Util::EC2.has_euca_mac?.should == false
+    end
+  end
+
+  describe "is_openstack_mac? method" do
+    it "should return true when the mac is an openstack one" do
+      Facter.expects(:value).with(:macaddress).\
+        at_least_once.returns("02:16:3e:54:89:fd")
+
+      Facter::Util::EC2.has_openstack_mac?.should == true
+    end
+
+    it "should return true when the mac is a newer openstack mac" do
+      # https://github.com/openstack/nova/commit/b684d651f540fc512ced58acd5ae2ef4d55a885c#nova/utils.py
+      Facter.expects(:value).with(:macaddress).\
+        at_least_once.returns("fa:16:3e:54:89:fd")
+
+      Facter::Util::EC2.has_openstack_mac?.should == true
+    end
+
+    it "should return true when the mac is a newer openstack mac and returned in upper case" do
+      # https://github.com/openstack/nova/commit/b684d651f540fc512ced58acd5ae2ef4d55a885c#nova/utils.py
+      Facter.expects(:value).with(:macaddress).\
+        at_least_once.returns("FA:16:3E:54:89:FD")
+
+      Facter::Util::EC2.has_openstack_mac?.should == true
+    end
+
+    it "should return false when the mac is not a openstack one" do
+      Facter.expects(:value).with(:macaddress).\
+        at_least_once.returns("0c:1d:a0:bc:aa:02")
+
+      Facter::Util::EC2.has_openstack_mac?.should == false
+    end
+  end
+
+  describe "can_connect? method" do
+    it "returns true if api responds" do
+      # Return something upon connecting to the root
+      Module.any_instance.expects(:open).with("#{api_prefix}:80/").
+        at_least_once.returns("2008-02-01\nlatest")
+
+      Facter::Util::EC2.can_connect?.should be_true
+    end
+
+    describe "when connection times out" do
+      it "should return false" do
+        # Emulate a timeout when connecting by throwing an exception
+        Module.any_instance.expects(:open).with("#{api_prefix}:80/").
+          at_least_once.raises(RuntimeError)
+
+        Facter::Util::EC2.can_connect?.should be_false
+      end
+    end
+
+    describe "when connection is refused" do
+      it "should return false" do
+        # Emulate a connection refused
+        Module.any_instance.expects(:open).with("#{api_prefix}:80/").
+          at_least_once.raises(Errno::ECONNREFUSED)
+
+        Facter::Util::EC2.can_connect?.should be_false
+      end
+    end
+  end
+
+  describe "Facter::Util::EC2.userdata" do
+    let :not_found_error do
+      OpenURI::HTTPError.new("404 Not Found", StringIO.new)
+    end
+
+    let :example_userdata do
+      "owner=jeff@puppetlabs.com\ngroup=platform_team"
+    end
+
+    it 'returns nil when no userdata is present' do
+      Facter::Util::EC2.stubs(:read_uri).raises(not_found_error)
+      Facter::Util::EC2.userdata.should be_nil
+    end
+
+    it "returns the string containing the body" do
+      Facter::Util::EC2.stubs(:read_uri).returns(example_userdata)
+      Facter::Util::EC2.userdata.should == example_userdata
+    end
+
+    it "uses the specified API version" do
+      expected_uri = "http://169.254.169.254/2008-02-01/user-data/"
+      Facter::Util::EC2.expects(:read_uri).with(expected_uri).returns(example_userdata)
+      Facter::Util::EC2.userdata('2008-02-01').should == example_userdata
+    end
+  end
+end