facter 2.0.2-x86-mingw32 → 2.1.0-x86-mingw32

data/spec/fixtures/unit/util/operatingsystem/cumuluslinux.txt

@@ -0,0 +1,8 @@
+NAME="Cumulus Linux"
+VERSION_ID=1.5.2
+VERSION="1.5.2-28283a7-201311181623-final"
+PRETTY_NAME="Cumulus Linux"
+ID=cumulus-linux
+ID_LIKE=debian
+CPE_NAME=cpe:/o:cumulusnetworks:cumulus_linux:1.5.2-28283a7-201311181623-final
+HOME_URL="http://www.cumulusnetworks.com/"

data/spec/fixtures/unit/util/operatingsystem/redhat-7.txt

@@ -0,0 +1,12 @@
+NAME="Red Hat Enterprise Linux Everything"
+VERSION="7.0 (Maipo)"
+ID="rhel"
+VERSION_ID="7.0"
+PRETTY_NAME="Red Hat Enterprise Linux Everything 7.0 (Maipo)"
+ANSI_COLOR="0;31"
+CPE_NAME="cpe:/o:redhat:enterprise_linux:7.0:beta:everything"
+
+REDHAT_BUGZILLA_PRODUCT="Red Hat Enterprise Linux 7"
+REDHAT_BUGZILLA_PRODUCT_VERSION=7.0
+REDHAT_SUPPORT_PRODUCT="Red Hat Enterprise Linux"
+REDHAT_SUPPORT_PRODUCT_VERSION=7.0

data/spec/fixtures/unit/util/operatingsystem/sabayon.txt

@@ -0,0 +1,7 @@
+NAME=Sabayon
+ID=sabayon
+PRETTY_NAME="Sabayon/Linux"
+ANSI_COLOR="1;32"
+HOME_URL="http://www.sabayon.org/"
+SUPPORT_URL="http://forum.sabayon.org/"
+BUG_REPORT_URL="https://bugs.sabayon.org/"

data/spec/fixtures/unit/util/operatingsystem/wheezy.txt

@@ -0,0 +1,9 @@
+PRETTY_NAME="Debian GNU/Linux 7 (wheezy)"
+NAME="Debian GNU/Linux"
+VERSION_ID="7"
+VERSION="7 (wheezy)"
+ID=debian
+ANSI_COLOR="1;31"
+HOME_URL="http://www.debian.org/"
+SUPPORT_URL="http://www.debian.org/support/"
+BUG_REPORT_URL="http://bugs.debian.org/"

data/spec/fixtures/unit/util/partitions/partitions/mount

@@ -0,0 +1,9 @@
+proc on /proc type proc (rw,noexec,nosuid,nodev)
+sysfs on /sys type sysfs (rw,noexec,nosuid,nodev)
+none on /sys/fs/cgroup type tmpfs (rw)
+udev on /dev type devtmpfs (rw,mode=0755)
+devpts on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
+tmpfs on /run type tmpfs (rw,noexec,nosuid,size=10%,mode=0755)
+/dev/sda1 on /home type ext4 (rw)
+/dev/sdb2 on / type ext4 (rw,errors=remount-ro)
+/dev/sdc3 on /var type ext4 (rw,errors=remount-ro)

data/spec/fixtures/virtual/proc_1_cgroup/in_a_container

@@ -0,0 +1,9 @@
+9:hugetlb:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+8:perf_event:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+7:blkio:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+6:freezer:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+5:devices:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+4:memory:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+3:cpuacct:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+2:cpu:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be
+1:cpuset:/lxc/e411045bbbc61eca5d3af7eb0764c30833606f51d20c176f406afbdb47bb04be

data/spec/fixtures/virtual/proc_1_cgroup/in_a_docker_container

@@ -0,0 +1,8 @@
+9:perf_event:/
+8:blkio:/
+7:freezer:/
+6:devices:/docker/0e3c605ac1470c776c34a8eff362a0c816bcaac78559a43955173bd786281b7f
+5:memory:/
+4:cpuacct:/
+3:cpu:/docker/0e3c605ac1470c776c34a8eff362a0c816bcaac78559a43955173bd786281b7f
+2:cpuset:/

data/spec/fixtures/virtual/proc_1_cgroup/not_in_a_container

@@ -0,0 +1,9 @@
+9:hugetlb:/
+8:perf_event:/
+7:blkio:/
+6:freezer:/
+5:devices:/
+4:memory:/
+3:cpuacct:/
+2:cpu:/
+1:cpuset:/

data/spec/spec_helper.rb

@@ -38,7 +38,7 @@ LogSpecOrder.log_spec_order
 RSpec.configure do |config|
   config.mock_with :mocha
 
-  if Facter::Util::Config.is_windows?
+  if Facter::Util::Config.is_windows? && RUBY_VERSION =~ /^1\./
     require 'win32console'
     config.output_stream = $stdout
     config.error_stream = $stderr

data/spec/unit/core/execution/base_spec.rb

@@ -5,7 +5,7 @@ describe Facter::Core::Execution::Base do
 
   describe "#with_env" do
     it "should execute the caller's block with the specified env vars" do
-      test_env = { "LANG" => "C", "FOO" => "BAR" }
+      test_env = { 'LANG' => 'C', 'LC_ALL' => 'C', 'FOO' => 'BAR' }
       subject.with_env test_env do
         test_env.keys.each do |key|
           ENV[key].should == test_env[key]
@@ -64,13 +64,11 @@ describe Facter::Core::Execution::Base do
 
   describe "#execute" do
 
-    it "switches LANG to C when executing the command" do
-      subject.expects(:with_env).with('LANG' => 'C')
+    it "switches LANG and LC_ALL to C when executing the command" do
+      subject.expects(:with_env).with('LC_ALL' => 'C', 'LANG' => 'C')
       subject.execute('foo')
     end
 
-    it "switches LC_ALL to C when executing the command"
-
     it "expands the command before running it" do
       subject.stubs(:`).returns ''
       subject.expects(:expand_command).with('foo').returns '/bin/foo'

data/spec/unit/core/execution/posix_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
+require 'facter/util/config'
 
-describe Facter::Core::Execution::Posix, :as_plaform => :posix do
-
+describe Facter::Core::Execution::Posix, :unless => Facter::Util::Config.is_windows? do
   describe "#search_paths" do
     it "should use the PATH environment variable plus /sbin and /usr/sbin on unix" do
       ENV.expects(:[]).with('PATH').returns "/bin:/usr/bin"

data/spec/unit/core/suitable_spec.rb

@@ -92,5 +92,15 @@ describe Facter::Core::Suitable do
 
       expect(subject).to_not be_suitable
     end
+
+    it "recalculates suitability on every invocation" do
+      subject.confine :kernel => 'Linux'
+
+      subject.confines.first.stubs(:true?).returns false
+      expect(subject).to_not be_suitable
+      subject.confines.first.unstub(:true?)
+      subject.confines.first.stubs(:true?).returns true
+      expect(subject).to be_suitable
+    end
   end
 end

data/spec/unit/dhcp_servers_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe "DHCP server facts" do
+  describe "on Linux OS's" do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns 'Linux'
+      Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route'))
+    end
+
+    describe "with nmcli version <= 0.9.8 available" do
+      before :each do
+        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
+        Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.8.0')
+      end
+
+      describe "with a main interface configured with DHCP" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
+        end
+
+        it "should produce a dhcp_servers fact that includes values for 'system' as well as each dhcp enabled interface" do
+          Facter.fact(:dhcp_servers).value.should == { 'system' => '192.168.1.1', 'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
+        end
+      end
+
+      describe "with a main interface NOT configured with DHCP" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_static"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
+        end
+
+        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
+          Facter.fact(:dhcp_servers).value.should == {'wlan0' => '192.168.2.1' }
+        end
+      end
+
+      describe "with no default gateway" do
+        before :each do
+          Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route_nogw'))
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
+        end
+
+        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
+          Facter.fact(:dhcp_servers).value.should == {'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
+        end
+      end
+
+      describe "with no DHCP enabled interfaces" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_static"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_static"))
+        end
+
+        it "should not produce a dhcp_servers fact" do
+          Facter.fact(:dhcp_servers).value.should be_nil
+        end
+      end
+
+      describe "with no CONNECTED devices" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices_disconnected"))
+        end
+
+        it "should not produce a dhcp_servers fact" do
+          Facter.fact(:dhcp_servers).value.should be_nil
+        end
+      end
+    end
+
+    describe "with nmcli version >= 0.9.9 available" do
+      before :each do
+        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
+        Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.9.0-20.git20131003.fc20')
+      end
+
+      describe "with a main interface configured with DHCP" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
+        end
+
+        it "should produce a dhcp_servers fact that includes values for 'system' as well as each dhcp enabled interface" do
+          Facter.fact(:dhcp_servers).value.should == { 'system' => '192.168.1.1', 'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
+        end
+      end
+
+      describe "with a main interface NOT configured with DHCP" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_static"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
+        end
+
+        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
+          Facter.fact(:dhcp_servers).value.should == {'wlan0' => '192.168.2.1' }
+        end
+      end
+
+      describe "with no default gateway" do
+        before :each do
+          Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route_nogw'))
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
+        end
+
+        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
+          Facter.fact(:dhcp_servers).value.should == {'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
+        end
+      end
+
+      describe "with no DHCP enabled interfaces" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_static"))
+          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_static"))
+        end
+
+        it "should not produce a dhcp_servers fact" do
+          Facter.fact(:dhcp_servers).value.should be_nil
+        end
+      end
+
+      describe "with no CONNECTED devices" do
+        before :each do
+          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices_disconnected"))
+        end
+
+        it "should not produce a dhcp_servers fact" do
+          Facter.fact(:dhcp_servers).value.should be_nil
+        end
+      end
+    end
+
+    describe "without nmcli available" do
+      before :each do
+        Facter::Core::Execution.stubs(:which).with('nmcli').returns(nil)
+      end
+
+      it "should not produce a dhcp_server fact" do
+        Facter.fact(:dhcp_servers).value.should be_nil
+      end
+    end
+  end
+end

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

@@ -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