facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/spec/unit/ec2/rest_spec.rb

@@ -1,168 +0,0 @@
-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
-      (f_times_out = mock).stubs(:read).raises(Timeout::Error)
-      (f_ok = mock).stubs(:read).returns(StringIO.new("woo"))
-
-      subject.expects(:open).twice.returns(f_times_out).returns(f_ok)
-      expect(subject).to be_reachable
-    end
-
-    it "retries if the connection is reset" do
-      (f_ok = mock).stubs(:read).returns(StringIO.new("woo"))
-
-      subject.expects(:open).twice.raises(Errno::ECONNREFUSED).returns(f_ok)
-      expect(subject).to be_reachable
-    end
-
-    it "is false if the given uri returns a 404" do
-      subject.expects(:open).once.raises(OpenURI::HTTPError.new("404 Not Found", StringIO.new("boo")))
-      expect(subject).to_not be_reachable
-    end
-
-    it "is false if the connection always times out" do
-      (f_times_out = mock).stubs(:read).raises(Timeout::Error)
-
-      subject.expects(:open).times(3).returns(f_times_out)
-      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/", {:proxy => nil}).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/", {:proxy => nil}).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/", {:proxy => nil}).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/", {:proxy => nil}).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/", {:proxy => nil}).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 'filters out IAM security credentials' do
-    subject.expects(:fetch_endpoint).with('').returns(['iam/'])
-    subject.expects(:fetch_endpoint).with('iam/').returns(['foo', 'security-credentials/', 'bar/'])
-    subject.expects(:fetch_endpoint).with('iam/foo').returns(['baz'])
-    subject.expects(:fetch_endpoint).with('iam/bar/').returns(['baz'])
-    subject.expects(:fetch_endpoint).with('iam/bar/baz').returns(['foo'])
-    output = subject.fetch
-    expect(output).to eq({
-      'iam' => {
-        'foo' => 'baz',
-        'bar' => {
-          'baz' => 'foo'
-        }
-      }
-    })
-  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/', {:proxy => nil}).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/', {:proxy => nil}).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/', {:proxy => nil}).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

@@ -1,139 +0,0 @@
-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,xenu or kvm" do
-    querier.stubs(:reachable?).returns false
-    Facter.fact(:virtual).stubs(:value).returns("Not kvm","Not xen","Not xenu")
-    expect(subject).to_not be_suitable
-  end
-
-  it "is unsuitable if ec2 endpoint is not reachable" do
-    Facter.fact(:virtual).stubs(:value).returns("xen","kvm")
-    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 kvm" do
-      Facter.fact(:virtual).stubs(:value).returns "kvm"
-      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,xenu or kvm" do
-    querier.stubs(:reachable?).returns(true)
-    Facter.fact(:virtual).stubs(:value).returns("Not kvm","Not xen","Not xenu")
-    expect(subject).to_not be_suitable
-  end
-
-  it "is unsuitable if ec2 endpoint is not reachable" do
-    Facter.fact(:virtual).stubs(:value).returns("xen","kvm")
-    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 kvm" do
-      Facter.fact(:virtual).stubs(:value).returns "kvm"
-      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

@@ -1,108 +0,0 @@
-#! /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

@@ -1,50 +0,0 @@
-#! /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