facter 1.6.2 → 1.6.3

data/spec/unit/operatingsystemrelease_spec.rb

@@ -6,55 +6,56 @@ require 'facter'
 
 describe "Operating System Release fact" do
 
-    before do
-        Facter.clear
-    end
+  before do
+    Facter.clear
+  end
+
+  after do
+    Facter.clear
+  end
+
+  test_cases = {
+    "CentOS"    => "/etc/redhat-release",
+    "RedHat"    => "/etc/redhat-release",
+    "Scientific"  => "/etc/redhat-release",
+    "Fedora"    => "/etc/fedora-release",
+    "MeeGo"     => "/etc/meego-release",
+    "OEL"     => "/etc/enterprise-release",
+    "oel"     => "/etc/enterprise-release",
+    "OVS"     => "/etc/ovs-release",
+    "ovs"     => "/etc/ovs-release",
+    "OracleLinux" => "/etc/oracle-release",
+    "Ascendos"    => "/etc/redhat-release",
+  }
+
+  test_cases.each do |system, file|
+    describe "with operatingsystem reported as #{system.inspect}" do
+      it "should read the #{file.inspect} file" do
+        Facter.fact(:operatingsystem).stubs(:value).returns(system)
+
+        File.expects(:open).with(file, "r").at_least(1)
 
-    after do
-        Facter.clear
+        Facter.fact(:operatingsystemrelease).value
+      end
     end
+  end
 
-    test_cases = {
-        "CentOS"      => "/etc/redhat-release",
-        "RedHat"      => "/etc/redhat-release",
-        "Scientific"  => "/etc/redhat-release",
-        "Fedora"      => "/etc/fedora-release",
-        "MeeGo"       => "/etc/meego-release",
-        "OEL"         => "/etc/enterprise-release",
-        "oel"         => "/etc/enterprise-release",
-        "OVS"         => "/etc/ovs-release",
-        "ovs"         => "/etc/ovs-release",
-        "OracleLinux" => "/etc/oracle-release",
-    }
-
-    test_cases.each do |system, file|
-        describe "with operatingsystem reported as #{system.inspect}" do
-            it "should read the #{file.inspect} file" do
-                Facter.fact(:operatingsystem).stubs(:value).returns(system)
-
-                File.expects(:open).with(file, "r").at_least(1)
-
-                Facter.fact(:operatingsystemrelease).value
-            end
-        end
-    end
+  it "for VMWareESX it should run the vmware -v command" do
+    Facter.fact(:kernel).stubs(:value).returns("VMkernel")
+    Facter.fact(:kernelrelease).stubs(:value).returns("4.1.0")
+    Facter.fact(:operatingsystem).stubs(:value).returns("VMwareESX")
 
-    it "for VMWareESX it should run the vmware -v command" do
-        Facter.fact(:kernel).stubs(:value).returns("VMkernel")
-        Facter.fact(:kernelrelease).stubs(:value).returns("4.1.0")
-        Facter.fact(:operatingsystem).stubs(:value).returns("VMwareESX")
+    Facter::Util::Resolution.stubs(:exec).with('vmware -v').returns('foo')
 
-        Facter::Util::Resolution.stubs(:exec).with('vmware -v').returns('foo')
+    Facter.fact(:operatingsystemrelease).value
+  end
 
-        Facter.fact(:operatingsystemrelease).value
-    end
-
-    it "for Alpine it should use the contents of /etc/alpine-release" do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        Facter.fact(:operatingsystem).stubs(:value).returns("Alpine")
+  it "for Alpine it should use the contents of /etc/alpine-release" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.fact(:operatingsystem).stubs(:value).returns("Alpine")
 
-        File.expects(:read).with("/etc/alpine-release").returns("foo")
+    File.expects(:read).with("/etc/alpine-release").returns("foo")
 
-        Facter.fact(:operatingsystemrelease).value.should == "foo"
-    end
+    Facter.fact(:operatingsystemrelease).value.should == "foo"
+  end
 end

data/spec/unit/processor_spec.rb

@@ -207,7 +207,7 @@ describe "Processor facts" do
       File.stubs(:exists?).with('/sys/devices/system/cpu').returns(true)
       ## sysfs method is only used if cpuinfo method returned no processors
       File.stubs(:exists?).with("/proc/cpuinfo").returns(true)
-      File.stubs(:readlines).with("/proc/cpuinfo").returns("")
+      File.stubs(:readlines).with("/proc/cpuinfo").returns([])
       Dir.stubs(:glob).with("/sys/devices/system/cpu/cpu[0-9]*").returns(%w{
         /sys/devices/system/cpu/cpu0
         /sys/devices/system/cpu/cpu1
@@ -221,7 +221,7 @@ describe "Processor facts" do
       File.stubs(:exists?).with('/sys/devices/system/cpu').returns(true)
       ## sysfs method is only used if cpuinfo method returned no processors
       File.stubs(:exists?).with("/proc/cpuinfo").returns(true)
-      File.stubs(:readlines).with("/proc/cpuinfo").returns("")
+      File.stubs(:readlines).with("/proc/cpuinfo").returns([])
       Dir.stubs(:glob).with("/sys/devices/system/cpu/cpu[0-9]*").returns(%w{
         /sys/devices/system/cpu/cpu0
         /sys/devices/system/cpu/cpu1

data/spec/unit/selinux_spec.rb

@@ -7,84 +7,84 @@ require 'facter'
 describe "SELinux facts" do
 
 
-    after do
-        Facter.clear
-    end
+  after do
+    Facter.clear
+  end
 
-    it "should return true if SELinux enabled" do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
+  it "should return true if SELinux enabled" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
 
-        FileTest.stubs(:exists?).returns false
-        File.stubs(:read).with("/proc/self/attr/current").returns("notkernel")
+    FileTest.stubs(:exists?).returns false
+    File.stubs(:read).with("/proc/self/attr/current").returns("notkernel")
 
-        FileTest.expects(:exists?).with("/selinux/enforce").returns true
-        FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
-        File.expects(:read).with("/proc/self/attr/current").returns("kernel")
+    FileTest.expects(:exists?).with("/selinux/enforce").returns true
+    FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
+    File.expects(:read).with("/proc/self/attr/current").returns("kernel")
 
-        Facter.fact(:selinux).value.should == "true"
-    end
+    Facter.fact(:selinux).value.should == "true"
+  end
 
-    it "should return true if SELinux policy enabled" do
-       Facter.fact(:selinux).stubs(:value).returns("true")
+  it "should return true if SELinux policy enabled" do
+    Facter.fact(:selinux).stubs(:value).returns("true")
 
-       FileTest.stubs(:exists?).returns false
-       File.stubs(:read).with("/selinux/enforce").returns("0")
+    FileTest.stubs(:exists?).returns false
+    File.stubs(:read).with("/selinux/enforce").returns("0")
 
-       FileTest.expects(:exists?).with("/selinux/enforce").returns true
-       File.expects(:read).with("/selinux/enforce").returns("1")
+    FileTest.expects(:exists?).with("/selinux/enforce").returns true
+    File.expects(:read).with("/selinux/enforce").returns("1")
 
-       Facter.fact(:selinux_enforced).value.should == "true"
-    end
+    Facter.fact(:selinux_enforced).value.should == "true"
+  end
 
-    it "should return an SELinux policy version" do
-       Facter.fact(:selinux).stubs(:value).returns("true")
-       FileTest.stubs(:exists?).with("/proc/self/mountinfo").returns false
+  it "should return an SELinux policy version" do
+    Facter.fact(:selinux).stubs(:value).returns("true")
+    FileTest.stubs(:exists?).with("/proc/self/mountinfo").returns false
 
-       File.stubs(:read).with("/selinux/policyvers").returns("")
+    File.stubs(:read).with("/selinux/policyvers").returns("")
 
-       File.expects(:read).with("/selinux/policyvers").returns("1")
+    File.expects(:read).with("/selinux/policyvers").returns("1")
 
-       Facter.fact(:selinux_policyversion).value.should == "1"
-    end
+    Facter.fact(:selinux_policyversion).value.should == "1"
+  end
 
-    it "should return the SELinux current mode" do
-       Facter.fact(:selinux).stubs(:value).returns("true")
+  it "should return the SELinux current mode" do
+    Facter.fact(:selinux).stubs(:value).returns("true")
 
-       sample_output_file = File.dirname(__FILE__) + '/data/selinux_sestatus'
-       selinux_sestatus = File.read(sample_output_file)
+    sample_output_file = File.dirname(__FILE__) + '/data/selinux_sestatus'
+    selinux_sestatus = File.read(sample_output_file)
 
-       Facter::Util::Resolution.stubs(:exec).with('/usr/sbin/sestatus').returns(selinux_sestatus)
+    Facter::Util::Resolution.stubs(:exec).with('/usr/sbin/sestatus').returns(selinux_sestatus)
 
-       Facter.fact(:selinux_current_mode).value.should == "permissive"
-    end
+    Facter.fact(:selinux_current_mode).value.should == "permissive"
+  end
 
-    it "should return the SELinux mode from the configuration file" do
-       Facter.fact(:selinux).stubs(:value).returns("true")
+  it "should return the SELinux mode from the configuration file" do
+    Facter.fact(:selinux).stubs(:value).returns("true")
 
-       sample_output_file = File.dirname(__FILE__) + '/data/selinux_sestatus'
-       selinux_sestatus = File.read(sample_output_file)
+    sample_output_file = File.dirname(__FILE__) + '/data/selinux_sestatus'
+    selinux_sestatus = File.read(sample_output_file)
 
-       Facter::Util::Resolution.stubs(:exec).with('/usr/sbin/sestatus').returns(selinux_sestatus)
+    Facter::Util::Resolution.stubs(:exec).with('/usr/sbin/sestatus').returns(selinux_sestatus)
 
-       Facter.fact(:selinux_config_mode).value.should == "permissive"
-    end
+    Facter.fact(:selinux_config_mode).value.should == "permissive"
+  end
 
-    it "should return the SELinux configuration file policy" do
-       Facter.fact(:selinux).stubs(:value).returns("true")
+  it "should return the SELinux configuration file policy" do
+    Facter.fact(:selinux).stubs(:value).returns("true")
 
-       sample_output_file = File.dirname(__FILE__) + '/data/selinux_sestatus'
-       selinux_sestatus = File.read(sample_output_file)
+    sample_output_file = File.dirname(__FILE__) + '/data/selinux_sestatus'
+    selinux_sestatus = File.read(sample_output_file)
 
-       Facter::Util::Resolution.stubs(:exec).with('/usr/sbin/sestatus').returns(selinux_sestatus)
+    Facter::Util::Resolution.stubs(:exec).with('/usr/sbin/sestatus').returns(selinux_sestatus)
 
-       Facter.fact(:selinux_config_policy).value.should == "targeted"
-    end
+    Facter.fact(:selinux_config_policy).value.should == "targeted"
+  end
 
-    it "should ensure legacy selinux_mode facts returns same value as selinux_config_policy fact" do
-       Facter.fact(:selinux).stubs(:value).returns("true")
+  it "should ensure legacy selinux_mode facts returns same value as selinux_config_policy fact" do
+    Facter.fact(:selinux).stubs(:value).returns("true")
 
-       Facter.fact(:selinux_config_policy).stubs(:value).returns("targeted")
+    Facter.fact(:selinux_config_policy).stubs(:value).returns("targeted")
 
-       Facter.fact(:selinux_mode).value.should == "targeted"
-    end
+    Facter.fact(:selinux_mode).value.should == "targeted"
+  end
 end

data/spec/unit/util/collection_spec.rb

@@ -5,251 +5,251 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'facter/util/collection'
 
 describe Facter::Util::Collection do
-    it "should have a method for adding facts" do
-        Facter::Util::Collection.new.should respond_to(:add)
-    end
+  it "should have a method for adding facts" do
+    Facter::Util::Collection.new.should respond_to(:add)
+  end
 
-    it "should have a method for returning a loader" do
-        Facter::Util::Collection.new.should respond_to(:loader)
-    end
+  it "should have a method for returning a loader" do
+    Facter::Util::Collection.new.should respond_to(:loader)
+  end
 
-    it "should use an instance of the Loader class as its loader" do
-        Facter::Util::Collection.new.loader.should be_instance_of(Facter::Util::Loader)
-    end
+  it "should use an instance of the Loader class as its loader" do
+    Facter::Util::Collection.new.loader.should be_instance_of(Facter::Util::Loader)
+  end
 
-    it "should cache its loader" do
-        coll = Facter::Util::Collection.new
-        coll.loader.should equal(coll.loader)
-    end
+  it "should cache its loader" do
+    coll = Facter::Util::Collection.new
+    coll.loader.should equal(coll.loader)
+  end
 
-    it "should have a method for loading all facts" do
-        Facter::Util::Collection.new.should respond_to(:load_all)
+  it "should have a method for loading all facts" do
+    Facter::Util::Collection.new.should respond_to(:load_all)
+  end
+
+  it "should delegate its load_all method to its loader" do
+    coll = Facter::Util::Collection.new
+    coll.loader.expects(:load_all)
+    coll.load_all
+  end
+
+  describe "when adding facts" do
+    before do
+      @coll = Facter::Util::Collection.new
     end
 
-    it "should delegate its load_all method to its loader" do
-        coll = Facter::Util::Collection.new
-        coll.loader.expects(:load_all)
-        coll.load_all
+    it "should create a new fact if no fact with the same name already exists" do
+      fact = mock 'fact'
+      Facter::Util::Fact.expects(:new).with { |name, *args| name == :myname }.returns fact
+
+      @coll.add(:myname)
     end
 
-    describe "when adding facts" do
-        before do
-            @coll = Facter::Util::Collection.new
-        end
+    it "should accept options" do
+      @coll.add(:myname, :ldapname => "whatever") { }
+    end
 
-        it "should create a new fact if no fact with the same name already exists" do
-            fact = mock 'fact'
-            Facter::Util::Fact.expects(:new).with { |name, *args| name == :myname }.returns fact
+    it "should set any appropriate options on the fact instances" do
+      # Use a real fact instance, because we're using respond_to?
+      fact = Facter::Util::Fact.new(:myname)
+      fact.expects(:ldapname=).with("testing")
+      Facter::Util::Fact.expects(:new).with(:myname).returns fact
 
-            @coll.add(:myname)
-        end
+      @coll.add(:myname, :ldapname => "testing")
+    end
 
-        it "should accept options" do
-            @coll.add(:myname, :ldapname => "whatever") { }
-        end
+    it "should set appropriate options on the resolution instance" do
+      fact = Facter::Util::Fact.new(:myname)
+      Facter::Util::Fact.expects(:new).with(:myname).returns fact
 
-        it "should set any appropriate options on the fact instances" do
-            # Use a real fact instance, because we're using respond_to?
-            fact = Facter::Util::Fact.new(:myname)
-            fact.expects(:ldapname=).with("testing")
-            Facter::Util::Fact.expects(:new).with(:myname).returns fact
+      resolve = Facter::Util::Resolution.new(:myname) {}
+      fact.expects(:add).returns resolve
 
-            @coll.add(:myname, :ldapname => "testing")
-        end
+      @coll.add(:myname, :timeout => "myval") {}
+    end
 
-        it "should set appropriate options on the resolution instance" do
-            fact = Facter::Util::Fact.new(:myname)
-            Facter::Util::Fact.expects(:new).with(:myname).returns fact
+    it "should not pass fact-specific options to resolutions" do
+      fact = Facter::Util::Fact.new(:myname)
+      Facter::Util::Fact.expects(:new).with(:myname).returns fact
 
-            resolve = Facter::Util::Resolution.new(:myname) {}
-            fact.expects(:add).returns resolve
+      resolve = Facter::Util::Resolution.new(:myname) {}
+      fact.expects(:add).returns resolve
 
-            @coll.add(:myname, :timeout => "myval") {}
-        end
+      fact.expects(:ldapname=).with("foo")
+      resolve.expects(:timeout=).with("myval")
 
-        it "should not pass fact-specific options to resolutions" do
-            fact = Facter::Util::Fact.new(:myname)
-            Facter::Util::Fact.expects(:new).with(:myname).returns fact
+      @coll.add(:myname, :timeout => "myval", :ldapname => "foo") {}
+    end
 
-            resolve = Facter::Util::Resolution.new(:myname) {}
-            fact.expects(:add).returns resolve
+    it "should fail if invalid options are provided" do
+      lambda { @coll.add(:myname, :foo => :bar) }.should raise_error(ArgumentError)
+    end
 
-            fact.expects(:ldapname=).with("foo")
-            resolve.expects(:timeout=).with("myval")
+    describe "and a block is provided" do
+      it "should use the block to add a resolution to the fact" do
+        fact = mock 'fact'
+        Facter::Util::Fact.expects(:new).returns fact
 
-            @coll.add(:myname, :timeout => "myval", :ldapname => "foo") {}
-        end
+        fact.expects(:add)
 
-        it "should fail if invalid options are provided" do
-            lambda { @coll.add(:myname, :foo => :bar) }.should raise_error(ArgumentError)
-        end
+        @coll.add(:myname) {}
+      end
+    end
+  end
 
-        describe "and a block is provided" do
-            it "should use the block to add a resolution to the fact" do
-                fact = mock 'fact'
-                Facter::Util::Fact.expects(:new).returns fact
+  it "should have a method for retrieving facts by name" do
+    Facter::Util::Collection.new.should respond_to(:fact)
+  end
 
-                fact.expects(:add)
+  describe "when retrieving facts" do
+    before do
+      @coll = Facter::Util::Collection.new
 
-                @coll.add(:myname) {}
-            end
-        end
+      @fact = @coll.add("YayNess")
     end
 
-    it "should have a method for retrieving facts by name" do
-        Facter::Util::Collection.new.should respond_to(:fact)
+    it "should return the fact instance specified by the name" do
+      @coll.fact("YayNess").should equal(@fact)
     end
 
-    describe "when retrieving facts" do
-        before do
-            @coll = Facter::Util::Collection.new
+    it "should be case-insensitive" do
+      @coll.fact("yayness").should equal(@fact)
+    end
 
-            @fact = @coll.add("YayNess")
-        end
+    it "should treat strings and symbols equivalently" do
+      @coll.fact(:yayness).should equal(@fact)
+    end
 
-        it "should return the fact instance specified by the name" do
-            @coll.fact("YayNess").should equal(@fact)
-        end
+    it "should use its loader to try to load the fact if no fact can be found" do
+      @coll.loader.expects(:load).with(:testing)
+      @coll.fact("testing")
+    end
 
-        it "should be case-insensitive" do
-            @coll.fact("yayness").should equal(@fact)
-        end
+    it "should return nil if it cannot find or load the fact" do
+      @coll.loader.expects(:load).with(:testing)
+      @coll.fact("testing").should be_nil
+    end
+  end
 
-        it "should treat strings and symbols equivalently" do
-            @coll.fact(:yayness).should equal(@fact)
-        end
+  it "should have a method for returning a fact's value" do
+    Facter::Util::Collection.new.should respond_to(:value)
+  end
 
-        it "should use its loader to try to load the fact if no fact can be found" do
-            @coll.loader.expects(:load).with(:testing)
-            @coll.fact("testing")
-        end
+  describe "when returning a fact's value" do
+    before do
+      @coll = Facter::Util::Collection.new
+      @fact = @coll.add("YayNess")
 
-        it "should return nil if it cannot find or load the fact" do
-            @coll.loader.expects(:load).with(:testing)
-            @coll.fact("testing").should be_nil
-        end
+      @fact.stubs(:value).returns "result"
     end
 
-    it "should have a method for returning a fact's value" do
-        Facter::Util::Collection.new.should respond_to(:value)
+    it "should use the 'fact' method to retrieve the fact" do
+      @coll.expects(:fact).with(:yayness).returns @fact
+      @coll.value(:yayness)
     end
 
-    describe "when returning a fact's value" do
-        before do
-            @coll = Facter::Util::Collection.new
-            @fact = @coll.add("YayNess")
+    it "should return the result of calling :value on the fact" do
+      @fact.expects(:value).returns "result"
 
-            @fact.stubs(:value).returns "result"
-        end
+      @coll.value("YayNess").should == "result"
+    end
 
-        it "should use the 'fact' method to retrieve the fact" do
-            @coll.expects(:fact).with(:yayness).returns @fact
-            @coll.value(:yayness)
-        end
+    it "should be case-insensitive" do
+      @coll.value("yayness").should_not be_nil
+    end
 
-        it "should return the result of calling :value on the fact" do
-            @fact.expects(:value).returns "result"
+    it "should treat strings and symbols equivalently" do
+      @coll.value(:yayness).should_not be_nil
+    end
+  end
 
-            @coll.value("YayNess").should == "result"
-        end
+  it "should return the fact's value when the array index method is used" do
+    @coll = Facter::Util::Collection.new
+    @coll.expects(:value).with("myfact").returns "foo"
+    @coll["myfact"].should == "foo"
+  end
 
-        it "should be case-insensitive" do
-            @coll.value("yayness").should_not be_nil
-        end
+  it "should have a method for flushing all facts" do
+    @coll = Facter::Util::Collection.new
+    @fact = @coll.add("YayNess")
 
-        it "should treat strings and symbols equivalently" do
-            @coll.value(:yayness).should_not be_nil
-        end
-    end
+    @fact.expects(:flush)
 
-    it "should return the fact's value when the array index method is used" do
-        @coll = Facter::Util::Collection.new
-        @coll.expects(:value).with("myfact").returns "foo"
-        @coll["myfact"].should == "foo"
-    end
+    @coll.flush
+  end
 
-    it "should have a method for flushing all facts" do
-        @coll = Facter::Util::Collection.new
-        @fact = @coll.add("YayNess")
+  it "should have a method that returns all fact names" do
+    @coll = Facter::Util::Collection.new
+    @coll.add(:one)
+    @coll.add(:two)
 
-        @fact.expects(:flush)
+    @coll.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
+  end
 
-        @coll.flush
-    end
+  it "should have a method for returning a hash of fact values" do
+    Facter::Util::Collection.new.should respond_to(:to_hash)
+  end
 
-    it "should have a method that returns all fact names" do
-        @coll = Facter::Util::Collection.new
-        @coll.add(:one)
-        @coll.add(:two)
+  describe "when returning a hash of values" do
+    before do
+      @coll = Facter::Util::Collection.new
+      @fact = @coll.add(:one)
+      @fact.stubs(:value).returns "me"
+    end
 
-        @coll.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
+    it "should return a hash of fact names and values with the fact names as strings" do
+      @coll.to_hash.should == {"one" => "me"}
     end
 
-    it "should have a method for returning a hash of fact values" do
-        Facter::Util::Collection.new.should respond_to(:to_hash)
+    it "should not include facts that did not return a value" do
+      f = @coll.add(:two)
+      f.stubs(:value).returns nil
+      @coll.to_hash.should_not be_include(:two)
     end
+  end
 
-    describe "when returning a hash of values" do
-        before do
-            @coll = Facter::Util::Collection.new
-            @fact = @coll.add(:one)
-            @fact.stubs(:value).returns "me"
-        end
+  it "should have a method for iterating over all facts" do
+    Facter::Util::Collection.new.should respond_to(:each)
+  end
 
-        it "should return a hash of fact names and values with the fact names as strings" do
-            @coll.to_hash.should == {"one" => "me"}
-        end
+  it "should include Enumerable" do
+    Facter::Util::Collection.ancestors.should be_include(Enumerable)
+  end
 
-        it "should not include facts that did not return a value" do
-            f = @coll.add(:two)
-            f.stubs(:value).returns nil
-            @coll.to_hash.should_not be_include(:two)
-        end
+  describe "when iterating over facts" do
+    before do
+      @coll = Facter::Util::Collection.new
+      @one = @coll.add(:one)
+      @two = @coll.add(:two)
     end
 
-    it "should have a method for iterating over all facts" do
-        Facter::Util::Collection.new.should respond_to(:each)
+    it "should yield each fact name and the fact value" do
+      @one.stubs(:value).returns "ONE"
+      @two.stubs(:value).returns "TWO"
+      facts = {}
+      @coll.each do |fact, value|
+        facts[fact] = value
+      end
+      facts.should == {"one" => "ONE", "two" => "TWO"}
     end
 
-    it "should include Enumerable" do
-        Facter::Util::Collection.ancestors.should be_include(Enumerable)
+    it "should convert the fact name to a string" do
+      @one.stubs(:value).returns "ONE"
+      @two.stubs(:value).returns "TWO"
+      facts = {}
+      @coll.each do |fact, value|
+        fact.should be_instance_of(String)
+      end
     end
 
-    describe "when iterating over facts" do
-        before do
-            @coll = Facter::Util::Collection.new
-            @one = @coll.add(:one)
-            @two = @coll.add(:two)
-        end
-
-        it "should yield each fact name and the fact value" do
-            @one.stubs(:value).returns "ONE"
-            @two.stubs(:value).returns "TWO"
-            facts = {}
-            @coll.each do |fact, value|
-                facts[fact] = value
-            end
-            facts.should == {"one" => "ONE", "two" => "TWO"}
-        end
-
-        it "should convert the fact name to a string" do
-            @one.stubs(:value).returns "ONE"
-            @two.stubs(:value).returns "TWO"
-            facts = {}
-            @coll.each do |fact, value|
-                fact.should be_instance_of(String)
-            end
-        end
-
-        it "should only yield facts that have values" do
-            @one.stubs(:value).returns "ONE"
-            @two.stubs(:value).returns nil
-            facts = {}
-            @coll.each do |fact, value|
-                facts[fact] = value
-            end
+    it "should only yield facts that have values" do
+      @one.stubs(:value).returns "ONE"
+      @two.stubs(:value).returns nil
+      facts = {}
+      @coll.each do |fact, value|
+        facts[fact] = value
+      end
 
-            facts.should_not be_include("two")
-        end
+      facts.should_not be_include("two")
     end
+  end
 end