facter 2.1.0-x64-mingw32

data/spec/unit/ec2/rest_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'facter/ec2/rest'
+
+shared_examples_for "an ec2 rest querier" do
+  describe "determining if the uri is reachable" do
+    it "retries if the connection times out" do
+      subject.stubs(:open).returns(stub(:read => nil))
+      Timeout.expects(:timeout).with(0.2).twice.raises(Timeout::Error).returns(true)
+      expect(subject).to be_reachable
+    end
+
+    it "retries if the connection is reset" do
+      subject.expects(:open).twice.raises(Errno::ECONNREFUSED).returns(StringIO.new("woo"))
+      expect(subject).to be_reachable
+    end
+
+    it "is false if the given uri returns a 404" do
+      subject.expects(:open).with(anything).once.raises(OpenURI::HTTPError.new("404 Not Found", StringIO.new("woo")))
+      expect(subject).to_not be_reachable
+    end
+
+    it "is false if the connection always times out" do
+      Timeout.expects(:timeout).with(0.2).times(3).raises(Timeout::Error)
+      expect(subject).to_not be_reachable
+    end
+  end
+
+end
+
+describe Facter::EC2::Metadata do
+
+  subject { described_class.new('http://0.0.0.0/latest/meta-data/') }
+
+  let(:response) { StringIO.new }
+
+  describe "fetching a metadata endpoint" do
+    it "splits the body into an array" do
+      response.string = my_fixture_read("meta-data/root")
+      subject.stubs(:open).with("http://0.0.0.0/latest/meta-data/").returns response
+      output = subject.fetch_endpoint('')
+
+      expect(output).to eq %w[
+        ami-id ami-launch-index ami-manifest-path block-device-mapping/ hostname
+        instance-action instance-id instance-type kernel-id local-hostname
+        local-ipv4 mac metrics/ network/ placement/ profile public-hostname
+        public-ipv4 public-keys/ reservation-id
+      ]
+    end
+
+    it "reformats keys that are array indices" do
+      response.string = "0=adrien@grey/"
+      subject.stubs(:open).with("http://0.0.0.0/latest/meta-data/public-keys/").returns response
+      output = subject.fetch_endpoint("public-keys/")
+
+      expect(output).to eq %w[0/]
+    end
+
+    it "returns nil if the endpoint returns a 404" do
+      Facter.expects(:log_exception).never
+      subject.stubs(:open).with("http://0.0.0.0/latest/meta-data/public-keys/1/").raises OpenURI::HTTPError.new("404 Not Found", response)
+      output = subject.fetch_endpoint('public-keys/1/')
+
+      expect(output).to be_nil
+    end
+
+    it "logs an error if the endpoint raises a non-404 HTTPError" do
+      Facter.expects(:log_exception).with(instance_of(OpenURI::HTTPError), anything)
+
+      subject.stubs(:open).with("http://0.0.0.0/latest/meta-data/").raises OpenURI::HTTPError.new("418 I'm a Teapot", response)
+      output = subject.fetch_endpoint("")
+
+      expect(output).to be_nil
+    end
+
+    it "logs an error if the endpoint raises a connection error" do
+      Facter.expects(:log_exception).with(instance_of(Errno::ECONNREFUSED), anything)
+
+      subject.stubs(:open).with("http://0.0.0.0/latest/meta-data/").raises Errno::ECONNREFUSED
+      output = subject.fetch_endpoint('')
+
+      expect(output).to be_nil
+    end
+  end
+
+  describe "recursively fetching the EC2 metadata API" do
+    it "queries the given endpoint for metadata keys" do
+      subject.expects(:fetch_endpoint).with("").returns([])
+      subject.fetch
+    end
+
+    it "fetches the value for a simple metadata key" do
+      subject.expects(:fetch_endpoint).with("").returns(['indexthing'])
+      subject.expects(:fetch_endpoint).with("indexthing").returns(['first', 'second'])
+
+      output = subject.fetch
+      expect(output).to eq({'indexthing' => ['first', 'second']})
+    end
+
+    it "unwraps metadata values that are in single element arrays" do
+      subject.expects(:fetch_endpoint).with("").returns(['ami-id'])
+      subject.expects(:fetch_endpoint).with("ami-id").returns(['i-12x'])
+
+      output = subject.fetch
+      expect(output).to eq({'ami-id' => 'i-12x'})
+    end
+
+    it "recursively queries an endpoint if the key ends with '/'" do
+      subject.expects(:fetch_endpoint).with("").returns(['metrics/'])
+      subject.expects(:fetch_endpoint).with("metrics/").returns(['vhostmd'])
+      subject.expects(:fetch_endpoint).with("metrics/vhostmd").returns(['woo'])
+
+      output = subject.fetch
+      expect(output).to eq({'metrics' => {'vhostmd' => 'woo'}})
+    end
+  end
+
+  it_behaves_like "an ec2 rest querier"
+end
+
+describe Facter::EC2::Userdata do
+
+  subject { described_class.new('http://0.0.0.0/latest/user-data/') }
+
+  let(:response) { StringIO.new }
+
+  describe "reaching the userdata" do
+    it "queries the userdata URI" do
+      subject.expects(:open).with('http://0.0.0.0/latest/user-data/').returns(response)
+      subject.fetch
+    end
+
+    it "returns the result of the query without modification" do
+      response.string = "clooouuuuud"
+      subject.expects(:open).with('http://0.0.0.0/latest/user-data/').returns(response)
+      expect(subject.fetch).to eq  "clooouuuuud"
+    end
+
+    it "is nil if the URI returned a 404" do
+      subject.expects(:open).with('http://0.0.0.0/latest/user-data/').once.raises(OpenURI::HTTPError.new("404 Not Found", StringIO.new("woo")))
+      expect(subject.fetch).to be_nil
+    end
+  end
+
+  it_behaves_like "an ec2 rest querier"
+end

data/spec/unit/ec2_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'facter/ec2/rest'
+
+describe "ec2_metadata" do
+  let(:querier) { stub('EC2 metadata querier') }
+
+  before do
+    Facter::EC2::Metadata.stubs(:new).returns querier
+
+    # Prevent flattened facts from forcing evaluation of the ec2 metadata fact
+    Facter.stubs(:value).with(:ec2_metadata)
+    Facter.collection.internal_loader.load(:ec2)
+    Facter.unstub(:value)
+  end
+
+  subject { Facter.fact(:ec2_metadata).resolution(:rest) }
+
+  it "is unsuitable if the virtual fact is not xen" do
+    querier.stubs(:reachable?).returns false
+    Facter.fact(:virtual).stubs(:value).returns "kvm"
+    expect(subject).to_not be_suitable
+  end
+
+  it "is unsuitable if ec2 endpoint is not reachable" do
+    Facter.fact(:virtual).stubs(:value).returns "xen"
+    querier.stubs(:reachable?).returns false
+    expect(subject).to_not be_suitable
+  end
+
+  describe "when the ec2 endpoint is reachable" do
+    before do
+      querier.stubs(:reachable?).returns true
+    end
+
+    it "is suitable if the virtual fact is xen" do
+      Facter.fact(:virtual).stubs(:value).returns "xen"
+      subject.suitable?
+
+      expect(subject).to be_suitable
+    end
+
+    it "is suitable if the virtual fact is xenu" do
+      Facter.fact(:virtual).stubs(:value).returns "xenu"
+      expect(subject).to be_suitable
+    end
+  end
+
+  it "resolves the value by recursively querying the rest endpoint" do
+    querier.expects(:fetch).returns({"hello" => "world"})
+    expect(subject.value).to eq({"hello" => "world"})
+  end
+end
+
+describe "ec2_userdata" do
+  let(:querier) { stub('EC2 metadata querier') }
+
+  before do
+    Facter::EC2::Userdata.stubs(:new).returns querier
+
+    # Prevent flattened facts from forcing evaluation of the ec2 metadata fact
+    Facter.stubs(:value).with(:ec2_metadata)
+    Facter.collection.internal_loader.load(:ec2)
+    Facter.unstub(:value)
+  end
+
+  subject { Facter.fact(:ec2_userdata).resolution(:rest) }
+
+  it "is unsuitable if the virtual fact is not xen" do
+    querier.stubs(:reachable?).returns(true)
+    Facter.fact(:virtual).stubs(:value).returns "kvm"
+    expect(subject).to_not be_suitable
+  end
+
+  it "is unsuitable if ec2 endpoint is not reachable" do
+    Facter.fact(:virtual).stubs(:value).returns "xen"
+    querier.stubs(:reachable?).returns false
+    expect(subject).to_not be_suitable
+  end
+
+  describe "when the ec2 endpoint is reachable" do
+    before do
+      querier.stubs(:reachable?).returns true
+    end
+
+    it "is suitable if the virtual fact is xen" do
+      Facter.fact(:virtual).stubs(:value).returns "xen"
+      expect(subject).to be_suitable
+    end
+
+    it "is suitable if the virtual fact is xenu" do
+      Facter.fact(:virtual).stubs(:value).returns "xenu"
+      expect(subject).to be_suitable
+    end
+  end
+
+  it "resolves the value by fetching the rest endpoint" do
+    querier.expects(:fetch).returns "user data!"
+    expect(subject.value).to eq "user data!"
+  end
+end
+
+describe "flattened versions of ec2 facts" do
+  # These facts are tricky to test because they are dynamic facts, and they are
+  # generated from a fact that is defined in the same file. In order to pull
+  # this off we need to define the ec2_metadata fact ahead of time so that we
+  # can stub the value, and then manually load the correct files.
+
+  it "unpacks the ec2_metadata fact" do
+    Facter.define_fact(:ec2_metadata).stubs(:value).returns({"hello" => "world"})
+    Facter.collection.internal_loader.load(:ec2)
+
+    expect(Facter.value("ec2_hello")).to eq "world"
+  end
+
+  it "does not set any flat ec2 facts if the ec2_metadata fact is nil" do
+    Facter.define_fact(:ec2_metadata).stubs(:value)
+    Facter.define_fact(:ec2_userdata).stubs(:value).returns(nil)
+
+    Facter.collection.internal_loader.load(:ec2)
+
+    all_facts = Facter.collection.to_hash
+
+    ec2_facts = all_facts.keys.select { |k| k =~ /^ec2_/ }
+    expect(ec2_facts).to be_empty
+  end
+
+end

data/spec/unit/facter_spec.rb

@@ -0,0 +1,108 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Facter do
+  it "caches the collection" do
+    Facter.collection.should equal(Facter.collection)
+  end
+
+  describe "methods on the collection" do
+    it "delegates the :flush method to the collection" do
+      Facter.collection.expects(:flush)
+      Facter.flush
+    end
+
+    it "delegates the :fact method to the collection" do
+      Facter.collection.expects(:fact).with("afact")
+      Facter.fact("afact")
+    end
+
+    it "delegates the :list method to the collection" do
+      Facter.collection.expects(:list)
+      Facter.list
+    end
+
+    it "loads all facts when listing" do
+      Facter.collection.expects(:load_all)
+      Facter.list
+    end
+
+    it "delegates the :to_hash method to the collection" do
+      Facter.collection.expects(:to_hash)
+      Facter.to_hash
+    end
+
+    it "loads all facts when calling :to_hash" do
+      Facter.collection.expects(:load_all)
+      Facter.collection.stubs(:to_hash)
+      Facter.to_hash
+    end
+
+    it "delegates the :value method to the collection" do
+      Facter.collection.expects(:value).with("myvaluefact")
+      Facter.value("myvaluefact")
+    end
+
+    it "delegates the :each method to the collection" do
+      Facter.collection.expects(:each)
+      Facter.each
+    end
+
+    it "delegates the :add method to the collection" do
+      Facter.collection.expects(:add).with("factname", {})
+      Facter.add("factname")
+    end
+
+    it "delegates the :define_fact method to the collection" do
+      Facter.collection.expects(:define_fact).with("factname", {})
+      Facter.define_fact("factname")
+    end
+
+    it "loads all facts when calling :each" do
+      Facter.collection.expects(:load_all)
+      Facter.collection.stubs(:each)
+      Facter.each
+    end
+  end
+
+  it "yields to the block when using :each" do
+    Facter.collection.stubs(:load_all)
+    Facter.collection.stubs(:each).yields "foo"
+    result = []
+    Facter.each { |f| result << f }
+    result.should == %w{foo}
+  end
+
+  describe "when registering directories to search" do
+    after { Facter.reset_search_path! }
+
+    it "allows registration of a directory" do
+      Facter.search "/my/dir"
+    end
+
+    it "allows registration of multiple directories" do
+      Facter.search "/my/dir", "/other/dir"
+    end
+
+    it "returns all registered directories when asked" do
+      Facter.search "/my/dir", "/other/dir"
+      Facter.search_path.should == %w{/my/dir /other/dir}
+    end
+  end
+
+  describe "when registering directories to search for external facts" do
+    it "allows registration of a directory" do
+      Facter.search_external ["/my/dir"]
+    end
+
+    it "allows registration of multiple directories" do
+      Facter.search_external ["/my/dir", "/other/dir"]
+    end
+
+    it "returns all registered directories when asked" do
+      Facter.search_external ["/my/dir", "/other/dir"]
+      Facter.search_external_path.should include("/my/dir", "/other/dir")
+    end
+  end
+end

data/spec/unit/filesystems_spec.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe 'Filesystem facts' do
+  describe 'on non-Linux OS' do
+    it 'should not exist' do
+      Facter.fact(:kernel).stubs(:value).returns('SunOS')
+      Facter.fact(:filesystems).value.should == nil
+    end
+  end
+
+  describe 'on Linux' do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns('Linux')
+      fixture_data = my_fixture_read('linux')
+      Facter::Core::Execution.expects(:exec) \
+        .with('cat /proc/filesystems 2> /dev/null').returns(fixture_data)
+      Facter.collection.internal_loader.load(:filesystems)
+    end
+
+    after :each do
+      Facter.clear
+    end
+
+    it 'should exist' do
+      Facter.fact(:filesystems).value.should_not == nil
+    end
+
+    it 'should detect the correct number of filesystems' do
+      Facter.fact(:filesystems).value.split(',').length.should == 6
+    end
+
+    # Check that lines from /proc/filesystems that start with 'nodev' are
+    # skipped
+    it 'should not detect sysfs' do
+      Facter.fact(:filesystems).value.split(',').should_not include('sysfs')
+    end
+
+    # Check that all other lines are counted as valid filesystems
+    it 'should detect ext4' do
+      Facter.fact(:filesystems).value.split(',').should include('ext4')
+    end
+
+    # fuseblk is never included in the filesystem list
+    it 'should not detect fuseblk' do
+      Facter.fact(:filesystems).value.split(',').should_not include('fuseblk')
+    end
+  end
+end

data/spec/unit/fqdn_spec.rb

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "fqdn fact" do
+  it "should concatenate hostname and domain" do
+    Facter.fact(:hostname).stubs(:value).returns("foo")
+    Facter.fact(:domain).stubs(:value).returns("bar")
+    Facter.fact(:fqdn).value.should == "foo.bar"
+  end
+  it "should return hostname when domain is nil" do
+    Facter.fact(:hostname).stubs(:value).returns("foo")
+    Facter.fact(:domain).stubs(:value).returns(nil)
+    Facter.fact(:fqdn).value.should == "foo"
+  end
+end