facter 2.0.2-universal-darwin → 2.1.0-universal-darwin

data/spec/unit/ec2_spec.rb

@@ -1,187 +1,127 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
-require 'facter/util/ec2'
-
-describe "ec2 facts" 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 "when running on ec2" do
-    before :each do
-      # This is an ec2 instance, not a eucalyptus instance
-      Facter::Util::EC2.stubs(:has_euca_mac?).returns(false)
-      Facter::Util::EC2.stubs(:has_openstack_mac?).returns(false)
-      Facter::Util::EC2.stubs(:has_ec2_arp?).returns(true)
-
-      # Assume we can connect
-      Facter::Util::EC2.stubs(:can_connect?).returns(true)
-    end
+require 'facter/ec2/rest'
 
-    it "should create flat meta-data facts" do
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/").
-        at_least_once.returns(StringIO.new("foo"))
+describe "ec2_metadata" do
+  let(:querier) { stub('EC2 metadata querier') }
 
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/foo").
-        at_least_once.returns(StringIO.new("bar"))
+  before do
+    Facter::EC2::Metadata.stubs(:new).returns querier
 
-      Facter.collection.internal_loader.load(:ec2)
-
-      Facter.fact(:ec2_foo).value.should == "bar"
-    end
+    # 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
 
-    it "should create flat meta-data facts with comma seperation" do
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/").
-        at_least_once.returns(StringIO.new("foo"))
+  subject { Facter.fact(:ec2_metadata).resolution(:rest) }
 
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/foo").
-        at_least_once.returns(StringIO.new("bar\nbaz"))
+  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
 
-      Facter.collection.internal_loader.load(:ec2)
+  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
 
-      Facter.fact(:ec2_foo).value.should == "bar,baz"
+  describe "when the ec2 endpoint is reachable" do
+    before do
+      querier.stubs(:reachable?).returns true
     end
 
-    it "should create structured meta-data facts" do
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/").
-        at_least_once.returns(StringIO.new("foo/"))
-
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/foo/").
-        at_least_once.returns(StringIO.new("bar"))
+    it "is suitable if the virtual fact is xen" do
+      Facter.fact(:virtual).stubs(:value).returns "xen"
+      subject.suitable?
 
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/foo/bar").
-        at_least_once.returns(StringIO.new("baz"))
-
-      Facter.collection.internal_loader.load(:ec2)
-
-      Facter.fact(:ec2_foo_bar).value.should == "baz"
+      expect(subject).to be_suitable
     end
 
-    it "should create ec2_user_data fact" do
-      # No meta-data
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/").
-        at_least_once.returns(StringIO.new(""))
-
-      Facter::Util::EC2.stubs(:read_uri).
-        with("#{api_prefix}/latest/user-data/").
-        returns("test")
-
-      Facter.collection.internal_loader.load(:ec2)
-      Facter.fact(:ec2_userdata).value.should == ["test"]
+    it "is suitable if the virtual fact is xenu" do
+      Facter.fact(:virtual).stubs(:value).returns "xenu"
+      expect(subject).to be_suitable
     end
   end
 
-  describe "when running on eucalyptus" do
-    before :each do
-      # Return false for ec2, true for eucalyptus
-      Facter::Util::EC2.stubs(:has_euca_mac?).returns(true)
-      Facter::Util::EC2.stubs(:has_openstack_mac?).returns(false)
-      Facter::Util::EC2.stubs(:has_ec2_arp?).returns(false)
+  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
 
-      # Assume we can connect
-      Facter::Util::EC2.stubs(:can_connect?).returns(true)
-    end
+describe "ec2_userdata" do
+  let(:querier) { stub('EC2 metadata querier') }
 
-    it "should create ec2_user_data fact" do
-      # No meta-data
-      Object.any_instance.expects(:open).\
-        with("#{api_prefix}/2008-02-01/meta-data/").\
-        at_least_once.returns(StringIO.new(""))
+  before do
+    Facter::EC2::Userdata.stubs(:new).returns querier
 
-      Facter::Util::EC2.stubs(:read_uri).
-        with("#{api_prefix}/latest/user-data/").
-        returns("test")
+    # 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
 
-      # Force a fact load
-      Facter.collection.internal_loader.load(:ec2)
+  subject { Facter.fact(:ec2_userdata).resolution(:rest) }
 
-      Facter.fact(:ec2_userdata).value.should == ["test"]
-    end
+  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
 
-  describe "when running on openstack" do
-    before :each do
-      # Return false for ec2, true for eucalyptus
-      Facter::Util::EC2.stubs(:has_openstack_mac?).returns(true)
-      Facter::Util::EC2.stubs(:has_euca_mac?).returns(false)
-      Facter::Util::EC2.stubs(:has_ec2_arp?).returns(false)
+  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
 
-      # Assume we can connect
-      Facter::Util::EC2.stubs(:can_connect?).returns(true)
+  describe "when the ec2 endpoint is reachable" do
+    before do
+      querier.stubs(:reachable?).returns true
     end
 
-    it "should create ec2_user_data fact" do
-      # No meta-data
-      Object.any_instance.expects(:open).\
-        with("#{api_prefix}/2008-02-01/meta-data/").\
-        at_least_once.returns(StringIO.new(""))
-
-      Facter::Util::EC2.stubs(:read_uri).
-        with("#{api_prefix}/latest/user-data/").
-        returns("test")
-
-      # Force a fact load
-      Facter.collection.internal_loader.load(:ec2)
-
-      Facter.fact(:ec2_userdata).value.should == ["test"]
+    it "is suitable if the virtual fact is xen" do
+      Facter.fact(:virtual).stubs(:value).returns "xen"
+      expect(subject).to be_suitable
     end
 
-    it "should return nil if open fails" do
-      Facter.stubs(:warn) # do not pollute test output
-      Facter.expects(:warn).with('Could not retrieve ec2 metadata: host unreachable')
-
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/").
-        at_least_once.raises(RuntimeError, 'host unreachable')
-
-      Facter::Util::EC2.stubs(:read_uri).
-        with("#{api_prefix}/latest/user-data/").
-        raises(RuntimeError, 'host unreachable')
-
-      # Force a fact load
-      Facter.collection.internal_loader.load(:ec2)
-
-      Facter.fact(:ec2_userdata).value.should be_nil
+    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 "when api connect test fails" do
-    before :each do
-      Facter.stubs(:warnonce)
-    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 "should not populate ec2_userdata" do
-      # Emulate ec2 for now as it matters little to this test
-      Facter::Util::EC2.stubs(:has_euca_mac?).returns(true)
-      Facter::Util::EC2.stubs(:has_ec2_arp?).never
-      Facter::Util::EC2.expects(:can_connect?).at_least_once.returns(false)
+  it "unpacks the ec2_metadata fact" do
+    Facter.define_fact(:ec2_metadata).stubs(:value).returns({"hello" => "world"})
+    Facter.collection.internal_loader.load(:ec2)
 
-      # The API should never be called at this point
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/meta-data/").never
-      Object.any_instance.expects(:open).
-        with("#{api_prefix}/2008-02-01/user-data/").never
+    expect(Facter.value("ec2_hello")).to eq "world"
+  end
 
-      # Force a fact load
-      Facter.collection.internal_loader.load(:ec2)
+  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.fact(:ec2_userdata).should == nil
-    end
+    Facter.collection.internal_loader.load(:ec2)
 
-    it "should rescue the exception" do
-      Facter::Util::EC2.expects(:open).with("#{api_prefix}:80/").raises(Timeout::Error)
+    all_facts = Facter.collection.to_hash
 
-      Facter::Util::EC2.should_not be_can_connect
-    end
+    ec2_facts = all_facts.keys.select { |k| k =~ /^ec2_/ }
+    expect(ec2_facts).to be_empty
   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

data/spec/unit/gce/metadata_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'facter/gce/metadata'
+
+describe Facter::GCE::Metadata, :if => Facter.json? do
+
+  describe "contacting the metadata server" do
+    it "retries the request when a connection error is thrown" do
+      subject.stubs(:open).returns(stub(:read => '{"hello": "world"}'))
+      seq = sequence('open-uri seq')
+      Timeout.expects(:timeout).with(0.05).twice.in_sequence(seq).raises(Timeout::Error)
+      Timeout.expects(:timeout).with(0.05).once.in_sequence(seq).yields
+      expect(subject.fetch).to eq({'hello' => 'world'})
+    end
+
+    it "logs the exception when all retries failed" do
+      Timeout.expects(:timeout).with(0.05).times(3).raises(Timeout::Error)
+      Facter.expects(:log_exception).with(instance_of(Timeout::Error), instance_of(String))
+      expect(subject.fetch).to be_nil
+    end
+  end
+
+  describe "parsing the metadata response" do
+    let(:body) { my_fixture_read('metadata.json') }
+    before do
+      subject.stubs(:open).returns(stub(:read => body))
+    end
+
+    it "transforms hash values with the 'image' key" do
+      expect(subject.fetch['instance']['image']).to eq 'centos6'
+    end
+
+    it "transforms hash values with the 'machineType' key" do
+      expect(subject.fetch['instance']['machineType']).to eq 'n1-standard-1'
+    end
+
+    it "transforms hash values with the 'zone' key" do
+      expect(subject.fetch['instance']['zone']).to eq 'us-central1-b'
+    end
+
+    it "transforms hash values with the 'network' key" do
+      expect(subject.fetch['instance']['networkInterfaces'][0]['network']).to eq 'default'
+    end
+
+    it "splits up the elements of the 'sshKeys' value into an array" do
+      expect(subject.fetch['project']['attributes']['sshKeys'][0]).to match(/justin:ssh-rsa/)
+      expect(subject.fetch['project']['attributes']['sshKeys'][1]).to match(/adrien:ssh-rsa/)
+    end
+  end
+end

data/spec/unit/gce_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'facter/gce/metadata'
+
+describe "gce_metadata" do
+  let(:querier) { stub('GCE metadata querier') }
+
+  before do
+    Facter::GCE::Metadata.stubs(:new).returns querier
+    Facter.collection.internal_loader.load(:ec2)
+  end
+
+  subject { Facter.fact(:gce).resolution(:rest) }
+
+  it "is unsuitable when the virtual type is not gce" do
+    Facter.fact(:virtual).stubs(:value).returns 'kvm'
+    expect(subject).to_not be_suitable
+  end
+
+  it "is unsuitable when JSON is not available" do
+    Facter.stubs(:json?).returns false
+    expect(subject).to_not be_suitable
+  end
+
+  it "is suitable when both the virtual type is gce and JSON is available" do
+    Facter.fact(:virtual).stubs(:value).returns 'gce'
+    Facter.stubs(:json?).returns true
+    expect(subject).to be_suitable
+  end
+
+  it "resolves the fact by querying GCE metadata API" do
+    querier.expects(:fetch).returns({'hello' => 'world'})
+    expect(subject.value).to eq({'hello' => 'world'})
+  end
+end

data/spec/unit/interfaces_spec.rb

@@ -4,15 +4,15 @@ require 'spec_helper'
 require 'shared_formats/parses'
 require 'facter/util/ip'
 
-shared_examples_for "netmask_* from ifconfig output" do |platform, interface, address, fixture|
-  it "correctly on #{platform} interface #{interface}" do
+shared_examples_for "interface netmask and mtu from ifconfig output" do |platform, interface, netmask, mtu, fixture|
+  it "should be correct on #{platform} for interface #{interface}" do
     Facter::Util::IP.stubs(:exec_ifconfig).returns(my_fixture_read(fixture))
     Facter::Util::IP.stubs(:get_output_for_interface_and_label).
       returns(my_fixture_read("#{fixture}.#{interface}"))
     Facter.collection.internal_loader.load(:interfaces)
 
-    fact = Facter.fact("netmask_#{interface}".intern)
-    fact.value.should eq(address)
+    Facter.fact("netmask_#{interface}".intern).value.should eq(netmask)
+    Facter.fact("mtu_#{interface}".intern).value.should eq(mtu)
   end
 end
 
@@ -43,15 +43,15 @@ describe "Per Interface IP facts" do
   end
 end
 
-describe "Netmask handling on Linux" do
+describe "Netmask and MTU handling on Linux" do
   before :each do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
   end
 
-  example_behavior_for "netmask_* from ifconfig output",
+  example_behavior_for "interface netmask and mtu from ifconfig output",
     "Archlinux (net-tools 1.60)", "em1",
-    "255.255.255.0", "ifconfig_net_tools_1.60.txt"
-  example_behavior_for "netmask_* from ifconfig output",
+    "255.255.255.0", "1500", "ifconfig_net_tools_1.60.txt"
+  example_behavior_for "interface netmask and mtu from ifconfig output",
     "Archlinux (net-tools 1.60)", "lo",
-    "255.0.0.0", "ifconfig_net_tools_1.60.txt"
+    "255.0.0.0", "16436", "ifconfig_net_tools_1.60.txt"
 end

data/spec/unit/kernelmajversion_spec.rb

@@ -3,15 +3,20 @@
 require 'spec_helper'
 
 describe "Kernel major version fact" do
-  
-  before do 
-    Facter.fact(:kernelversion).stubs(:value).returns("12.34.56")
-  end 
-  
-  it "should return the kernel major release using the kernel release" do 
-    Facter.fact(:kernelmajversion).value.should == "12.34"
-  end 
-end 
+  context "when the kernelrelease fact contains three components" do
+    it "returns the first two components" do
+      Facter.fact(:kernelversion).stubs(:value).returns("12.34.56")
 
+      Facter.fact(:kernelmajversion).value.should == "12.34"
+    end
+  end
 
+  context "when the kernelrelease fact only contains two components" do
+    it "returns the first component" do
+      Facter.fact(:kernel).stubs(:value).returns('FreeBSD')
+      Facter.fact(:kernelversion).stubs(:value).returns("9.2")
 
+      Facter.fact(:kernelmajversion).value.should == "9"
+    end
+  end
+end