facter 2.5.7 → 3.9.6.cfacter.20180606

data/spec/unit/lsbmajdistrelease_spec.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "LSB distribution major release fact" do
-  let(:os_hash) { { "name"          => "SomeOS",
-                    "family"        => "SomeFamily",
-                    "release"       => {
-                      "major" => "1",
-                      "minor" => "2",
-                      "full"  => "1.2.3"
-                    },
-                    "lsb"           => {
-                       "distcodename"     => "SomeCodeName",
-                       "distid"           => "SomeID",
-                       "distdescription"  => "SomeDesc",
-                       "distrelease"      => "1.2.3",
-                       "release"          => "1.2.3",
-                       "majdistrelease"   => "1",
-                       "minordistrelease" => "2"
-                    },
-                  }
-                }
-
-  it "should use the 'minordistrelease' key of the 'os' fact" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    Facter.fact("os").stubs(:value).returns(os_hash)
-    Facter.fact(:lsbminordistrelease).value.should eq "2"
-  end
-end

data/spec/unit/lsbminordistrelease_spec.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter'
-
-describe "LSB distribution major release fact" do
-  let(:os_hash) { { "name"          => "SomeOS",
-                    "family"        => "SomeFamily",
-                    "release"       => {
-                      "major" => "1",
-                      "minor" => "2",
-                      "full"  => "1.2.3"
-                    },
-                    "lsb"           => {
-                       "distcodename"     => "SomeCodeName",
-                       "distid"           => "SomeID",
-                       "distdescription"  => "SomeDesc",
-                       "distrelease"      => "1.2.3",
-                       "release"          => "1.2.3",
-                       "majdistrelease"   => "1",
-                       "minordistrelease" => "2"
-                    },
-                  }
-                }
-
-  it "should use the 'majdistrelease' key of the 'os' fact" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    Facter.fact("os").stubs(:value).returns(os_hash)
-    Facter.fact(:lsbmajdistrelease).value.should eq "1"
-  end
-end

data/spec/unit/lsbrelease_spec.rb

@@ -1,30 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "lsbrelease fact" do
-  let(:os_hash) { { "name"          => "SomeOS",
-                    "family"        => "SomeFamily",
-                    "release"       => {
-                      "major" => "1",
-                      "minor" => "2",
-                      "full"  => "1.2.3"
-                    },
-                    "lsb"           => {
-                       "distcodename"      => "SomeCodeName",
-                       "distid"            => "SomeID",
-                       "distdescription"   => "SomeDesc",
-                       "distrelease"       => "1.2.3",
-                       "release"           => "1.2.3",
-                       "majdistrelease"    => "1",
-                       "minordistrelease"  => "2"
-                    },
-                  }
-                }
-
-  it "should use the 'distrelease' key from the 'os' fact" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    Facter.fact("os").stubs(:value).returns(os_hash)
-    Facter.fact(:lsbrelease).value.should eq "1.2.3"
-  end
-end

data/spec/unit/macaddress_spec.rb

@@ -1,76 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/ip'
-
-
-def ifconfig_fixture(filename)
-  File.read(fixtures('ifconfig', filename))
-end
-
-describe "macaddress fact" do
-  include FacterSpec::ConfigHelper
-
-  before do
-    given_a_configuration_of(:is_windows => false)
-  end
-
-  describe "when run on Linux" do
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      Facter.fact(:operatingsystem).stubs(:value).returns("Linux")
-      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-    end
-
-    it "should return the macaddress of the first interface" do
-      Facter::Util::IP.stubs(:exec_ifconfig).with(["-a","2>/dev/null"]).
-        returns(ifconfig_fixture('linux_ifconfig_all_with_multiple_interfaces'))
-
-      Facter.value(:macaddress).should == "00:12:3f:be:22:01"
-    end
-
-    it "should return nil when no macaddress can be found" do
-      Facter::Util::IP.stubs(:exec_ifconfig).with(["-a","2>/dev/null"]).
-        returns(ifconfig_fixture('linux_ifconfig_no_mac'))
-
-      proc { Facter.value(:macaddress) }.should_not raise_error
-      Facter.value(:macaddress).should be_nil
-    end
-
-    # some interfaces dont have a real mac addresses (like venet inside a container)
-    it "should return nil when no interface has a real macaddress" do
-      Facter::Util::IP.stubs(:exec_ifconfig).with(["-a","2>/dev/null"]).
-        returns(ifconfig_fixture('linux_ifconfig_venet'))
-
-      proc { Facter.value(:macaddress) }.should_not raise_error
-      Facter.value(:macaddress).should be_nil
-    end
-  end
-
-  describe "when run on BSD" do
-    it "should return macaddress information" do
-      Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
-      Facter.fact(:operatingsystem).stubs(:value).returns("FreeBSD")
-      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-      Facter::Util::IP.stubs(:exec_ifconfig).
-        returns(ifconfig_fixture('bsd_ifconfig_all_with_multiple_interfaces'))
-
-      Facter.value(:macaddress).should == "00:0b:db:93:09:67"
-    end
-  end
-
-  describe "when run on OpenBSD with bridge(4) rules" do
-    it "should return macaddress information" do
-      Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
-      Facter.fact(:operatingsystem).stubs(:value).returns("OpenBSD")
-      Facter.fact(:osfamily).stubs(:value).returns("OpenBSD")
-      Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-      Facter::Util::IP.stubs(:exec_ifconfig).
-        returns(ifconfig_fixture('openbsd_bridge_rules'))
-
-      proc { Facter.value(:macaddress) }.should_not raise_error
-      Facter.value(:macaddress).should be_nil
-    end
-  end
-
-end

data/spec/unit/manufacturer_spec.rb

@@ -1,115 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter'
-require 'facter/util/manufacturer'
-
-describe "Hardware manufacturer facts" do
-  
-  describe "on OS'es without DMI support" do
-
-    it "no DMI facts should be reported" do
-      Facter.fact(:kernel).stubs(:value).returns("Darwin")
-      Facter.fact(:boardmanufacturer).should == nil
-      Facter.fact(:boardproductname).should == nil
-      Facter.fact(:boardserialnumber).should == nil
-      Facter.fact(:bios_vendor).should == nil
-      Facter.fact(:bios_version).should == nil
-      Facter.fact(:bios_release_date).should == nil
-      Facter.fact(:type).should == nil
-    end
-
-  end
-  
-  describe "on OS'es with DMI support" do
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      dmidecode_output = <<-eos
-Handle 0x0000, DMI type 0, 24 bytes
-BIOS Information
-        Vendor: Dell Inc.
-        Version: 1.2.5
-        Release Date: 03/16/2011
-        Address: 0xF0000
-        Runtime Size: 64 kB
-        ROM Size: 4096 kB
-        Characteristics:
-                ISA is supported
-                PCI is supported
-                PNP is supported
-                BIOS is upgradeable
-                BIOS shadowing is allowed
-                Boot from CD is supported
-                Selectable boot is supported
-                EDD is supported
-                8042 keyboard services are supported (int 9h)
-                Serial services are supported (int 14h)
-                CGA/mono video services are supported (int 10h)
-                ACPI is supported
-                USB legacy is supported
-                BIOS boot specification is supported
-                Function key-initiated network boot is supported
-                Targeted content distribution is supported
-        BIOS Revision: 1.2
-
-Handle 0x0100, DMI type 1, 27 bytes
-System Information
-        Manufacturer: Dell Inc.
-        Product Name: PowerEdge R515
-        Version: Not Specified
-        Serial Number: ABCD124
-        UUID: 1A2B3456-7890-1A23-4567-B8C91D123456
-        Wake-up Type: Power Switch
-        SKU Number: Not Specified
-        Family: Not Specified
-
-Handle 0x0200, DMI type 2, 9 bytes
-Base Board Information
-        Manufacturer: Dell Inc.
-        Product Name: 03X0MN
-        Version: A03
-        Serial Number: ..AB1234567B1234.
-        Asset Tag: Not Specified
-
-Handle 0x0300, DMI type 3, 21 bytes
-Chassis Information
-        Manufacturer: Dell Inc.
-        Type: Rack Mount Chassis
-        Lock: Present
-        Version: Not Specified
-        Serial Number: ABCD124
-        Asset Tag: Not Specified
-        Boot-up State: Safe
-        Power Supply State: Safe
-        Thermal State: Safe
-        Security Status: Unknown
-        OEM Information: 0x00000000
-        Height: 2 U
-        Number Of Power Cords: Unspecified
-        Contained Elements: 0
-
-Handle 0x7F00, DMI type 127, 4 bytes
-End Of Table
-      eos
-      Facter::Manufacturer.stubs(:get_dmi_table).returns(dmidecode_output)
-    end
-    
-    it "should report the correct details from the DMI query" do
-      Facter.fact(:manufacturer).value.should == "Dell Inc."
-      Facter.fact(:boardmanufacturer).value.should == "Dell Inc."
-      Facter.fact(:boardproductname).value.should == "03X0MN"
-      Facter.fact(:boardserialnumber).value.should == "..AB1234567B1234."
-      Facter.fact(:bios_vendor).value.should == "Dell Inc."
-      Facter.fact(:bios_version).value.should == "1.2.5"
-      Facter.fact(:bios_release_date).value.should == "03/16/2011"
-      Facter.fact(:manufacturer).value.should == "Dell Inc."
-      Facter.fact(:productname).value.should == "PowerEdge R515"
-      Facter.fact(:serialnumber).value.should == "ABCD124"
-      Facter.fact(:type).value.should == "Rack Mount Chassis"
-      Facter.fact(:productname).value.should_not == Facter.fact(:boardproductname).value
-      Facter.fact(:serialnumber).value.should_not == Facter.fact(:boardserialnumber).value
-    end
-    
-  end
-  
-end

data/spec/unit/memory_spec.rb

@@ -1,470 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "Memory facts" do
-  before(:each) do
-    Facter.collection.internal_loader.load(:memory)
-  end
-
-  after(:each) do
-    Facter.clear
-  end
-
-  describe "when returning scaled sizes" do
-    [  "memorysize",
-       "memoryfree",
-       "swapsize",
-       "swapfree"
-    ].each do |fact|
-
-      describe "when #{fact}_mb does not exist" do
-        before(:each) do
-          Facter.fact(fact + "_mb").stubs(:value).returns(nil)
-        end
-
-        it "#{fact} should not exist either" do
-          Facter.fact(fact).value.should be_nil
-        end
-      end
-
-      {   "200.00"      => "200.00 MB",
-          "1536.00"     => "1.50 GB",
-          "1572864.00"  => "1.50 TB",
-      }.each do |mbval, scval|
-        it "should scale #{fact} when given #{mbval} MB" do
-          Facter.fact(fact + "_mb").stubs(:value).returns(mbval)
-          Facter.fact(fact).value.should == scval
-        end
-      end
-    end
-
-    after(:each) do
-      Facter.clear
-    end
-  end
-
-  describe "on Darwin" do
-    before(:each) do
-      Facter.clear
-      Facter.fact(:kernel).stubs(:value).returns("Darwin")
-      Facter::Util::POSIX.stubs(:sysctl).with('hw.memsize').returns('8589934592')
-      Facter::Core::Execution.stubs(:exec).with('vm_stat').returns(my_fixture_read('darwin-vm_stat'))
-      Facter::Util::POSIX.stubs(:sysctl).with('vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 1.00M  free = 63.00M  (encrypted)")
-
-      Facter.collection.internal_loader.load(:memory)
-    end
-
-    it "should return the current swap size in MB" do
-      Facter.fact(:swapsize_mb).value.should == "64.00"
-    end
-
-    it "should return the current swap free in MB" do
-      Facter.fact(:swapfree_mb).value.should == "63.00"
-    end
-
-    it "should return whether swap is encrypted" do
-      Facter.fact(:swapencrypted).value.should == true
-    end
-
-    it "should return the memory size in MB" do
-      Facter.fact(:memorysize_mb).value.should == "8192.00"
-    end
-
-    it "should return the memory free in MB" do
-      Facter.fact(:memoryfree_mb).value.should == "138.70"
-    end
-
-    after(:each) do
-      Facter.clear
-    end
-  end
-
-  [   "linux",
-      "gnu/kfreebsd",
-  ].each do |kernel|
-
-
-    describe "on #{kernel}" do
-      before(:each) do
-        Facter.clear
-        Facter.fact(:kernel).stubs(:value).returns(kernel)
-
-        meminfo_contents = my_fixture_read('linux-proc_meminfo').split("\n")
-
-        File.stubs(:readlines).with("/proc/meminfo").returns(meminfo_contents)
-
-        Facter.collection.internal_loader.load(:memory)
-      end
-
-      after(:each) do
-        Facter.clear
-      end
-
-      it "should return the current memory size in MB" do
-        Facter.fact(:memorysize_mb).value.should == "249.91"
-      end
-
-      it "should return the current memory free in MB" do
-        Facter.fact(:memoryfree_mb).value.should == "196.16"
-      end
-
-      it "should return the current swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "511.99"
-      end
-
-      it "should return the current swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "511.99"
-      end
-    end
-  end
-
-  describe "on AIX" do
-    before (:each) do
-      Facter.clear
-      Facter.fact(:kernel).stubs(:value).returns("AIX")
-
-      Facter::Core::Execution.stubs(:exec).with('swap -l 2>/dev/null').returns(my_fixture_read('aix-swap_l'))
-      Facter::Core::Execution.stubs(:exec).with('/usr/bin/svmon -O unit=KB').returns(my_fixture_read('aix-svmon'))
-
-      Facter.collection.internal_loader.load(:memory)
-    end
-
-    after(:each) do
-      Facter.clear
-    end
-
-    describe "when not root" do
-      before(:each) do
-        Facter.fact(:id).stubs(:value).returns("notroot")
-      end
-
-      it "should return nil for swap size" do
-        Facter.fact(:swapsize_mb).value.should be_nil
-      end
-
-      it "should return nil for swap free" do
-        Facter.fact(:swapfree_mb).value.should be_nil
-      end
-    end
-
-    describe "when root" do
-      before(:each) do
-        Facter.fact(:id).stubs(:value).returns("root")
-      end
-
-      it "should return the current swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "512.00"
-      end
-
-      it "should return the current swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "508.00"
-      end
-    end
-
-    it "should return the current memory free in MB" do
-      Facter.fact(:memoryfree_mb).value.should == "22284.76"
-    end
-
-    it "should return the current memory size in MB" do
-      Facter.fact(:memorysize_mb).value.should == "32000.00"
-    end
-
-  end
-
-
-  describe "on OpenBSD" do
-    before :each do
-      Facter.clear
-      Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
-
-      swapusage = "total: 4080510 512-blocks allocated, 461832 used, 3618678 available"
-      Facter::Core::Execution.stubs(:exec).with('swapctl -s 2>/dev/null').returns(swapusage)
-
-      Facter::Core::Execution.stubs(:exec).with('vmstat').returns(my_fixture_read('openbsd-vmstat'))
-
-      Facter::Util::POSIX.stubs(:sysctl).with('hw.physmem').returns('267321344')
-      Facter::Util::POSIX.stubs(:sysctl).with('vm.swapencrypt.enable').returns('1')
-
-      Facter.collection.internal_loader.load(:memory)
-    end
-
-    after :each do
-      Facter.clear
-    end
-
-    it "should return the current swap free in MB" do
-      Facter.fact(:swapfree_mb).value.should == "1766.93"
-    end
-
-    it "should return the current swap size in MB" do
-      Facter.fact(:swapsize_mb).value.should == "1992.44"
-    end
-
-    it "should return the current memory free in MB" do
-      Facter.fact(:memoryfree_mb).value.should == "176.79"
-    end
-
-    it "should return the current memory size in MB" do
-      Facter.fact(:memorysize_mb).value.should == "254.94"
-    end
-
-    it "should return whether swap is encrypted" do
-      Facter.fact(:swapencrypted).value.should == true
-    end
-  end
-
-
-  describe "on Solaris" do
-    before(:each) do
-      Facter.clear
-      Facter.fact(:kernel).stubs(:value).returns("SunOS")
-
-      Facter::Core::Execution.stubs(:exec).with('/usr/sbin/prtconf 2>/dev/null').returns(my_fixture_read('solaris-prtconf'))
-      Facter::Core::Execution.stubs(:exec).with('vmstat').returns(my_fixture_read('solaris-vmstat'))
-    end
-
-    after(:each) do
-      Facter.clear
-    end
-
-    describe "when single swap exists" do
-      before(:each) do
-        Facter::Core::Execution.stubs(:exec).with('/usr/sbin/swap -l 2>/dev/null').returns my_fixture_read('solaris-swap_l-single')
-
-        Facter.collection.internal_loader.load(:memory)
-      end
-
-      it "should return the current memory size in MB" do
-        Facter.fact(:memorysize_mb).value.should == "2048.00"
-      end
-
-      it "should return the current memory free in MB" do
-        Facter.fact(:memoryfree_mb).value.should == "465.06"
-      end
-
-      it "should return the current swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "1023.99"
-      end
-
-      it "should return the current swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "1023.99"
-      end
-
-    end
-
-    describe "when multiple swaps exist" do
-      before(:each) do
-        Facter::Core::Execution.stubs(:exec).with('/usr/sbin/swap -l 2>/dev/null').returns my_fixture_read('solaris-swap_l-multiple')
-        Facter.collection.internal_loader.load(:memory)
-      end
-
-      it "should return the current memory size in MB" do
-        Facter.fact(:memorysize_mb).value.should == "2048.00"
-      end
-
-      it "should return the current memory free in MB" do
-        Facter.fact(:memoryfree_mb).value.should == "465.06"
-      end
-
-      it "should return the current swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "2047.98"
-      end
-
-      it "should return the current swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "2047.98"
-      end
-    end
-
-    describe "when no swap exists" do
-      before(:each) do
-        Facter::Core::Execution.stubs(:exec).with('/usr/sbin/swap -l 2>/dev/null').returns ""
-
-        Facter.collection.internal_loader.load(:memory)
-      end
-
-      it "should return the current memory size in MB" do
-        Facter.fact(:memorysize_mb).value.should == "2048.00"
-      end
-
-      it "should return the current memory free in MB" do
-        Facter.fact(:memoryfree_mb).value.should == "465.06"
-      end
-
-      it "should return 0 for the swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "0.00"
-      end
-
-      it "should return 0 for the swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "0.00"
-      end
-    end
-
-    describe "when in a SmartOS zone" do
-      before(:each) do
-        Facter::Core::Execution.stubs(:exec).with('/usr/sbin/swap -l 2>/dev/null').returns my_fixture_read('smartos_zone_swap_l-single')
-        Facter.collection.internal_loader.load(:memory)
-      end
-
-      it "should return the current swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "49152.00"
-      end
-
-      it "should return the current swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "33676.06"
-      end
-    end
-
-  end
-
-    describe "on DragonFly BSD" do
-      before :each do
-        Facter.clear
-        Facter.fact(:kernel).stubs(:value).returns("dragonfly")
-
-        swapusage = "total: 148342k bytes allocated = 0k used, 148342k available"
-        Facter::Util::POSIX.stubs(:sysctl).with('hw.pagesize').returns("4096")
-        Facter::Util::POSIX.stubs(:sysctl).with('vm.swap_size').returns("128461")
-        Facter::Util::POSIX.stubs(:sysctl).with('vm.swap_anon_use').returns("2635")
-        Facter::Util::POSIX.stubs(:sysctl).with('vm.swap_cache_use').returns("0")
-
-        Facter::Core::Execution.stubs(:exec).with('vmstat').returns my_fixture_read('dragonfly-vmstat')
-
-        Facter::Util::POSIX.stubs(:sysctl).with("hw.physmem").returns('248512512')
-
-        Facter.collection.internal_loader.load(:memory)
-      end
-
-      after :each do
-        Facter.clear
-      end
-
-      it "should return the current swap free in MB" do
-        Facter.fact(:swapfree_mb).value.should == "491.51"
-      end
-
-      it "should return the current swap size in MB" do
-        Facter.fact(:swapsize_mb).value.should == "501.80"
-      end
-
-      it "should return the current memory size in MB" do
-        Facter.fact(:memorysize_mb).value.should == "237.00"
-      end
-
-      it "should return the current memory free in MB" do
-        Facter.fact(:memoryfree_mb).value.should == "13.61"
-      end
-    end
-
-    describe "on FreeBSD" do
-      before(:each) do
-        Facter.clear
-        Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
-
-        Facter::Core::Execution.stubs(:exec).with('vmstat -H').returns my_fixture_read('freebsd-vmstat')
-        Facter::Util::POSIX.stubs(:sysctl).with('hw.physmem').returns '1056276480'
-      end
-
-      after(:each) do
-        Facter.clear
-      end
-
-      describe "with no swap" do
-        before(:each) do
-          sample_swapinfo = 'Device          1K-blocks     Used    Avail Capacity'
-
-          Facter::Core::Execution.stubs(:exec).with('swapinfo -k').returns sample_swapinfo
-          Facter.collection.internal_loader.load(:memory)
-        end
-
-        it "should return the current swap free in MB" do
-          Facter.fact(:swapfree_mb).value.should == "0.00"
-        end
-
-        it "should return the current swap size in MB" do
-          Facter.fact(:swapsize_mb).value.should == "0.00"
-        end
-
-        it "should return the current memory size in MB" do
-          Facter.fact(:memorysize_mb).value.should == "1007.34"
-        end
-
-        it "should return the current memory free in MB" do
-          Facter.fact(:memoryfree_mb).value.should == "641.25"
-        end
-      end
-
-      describe "with one swap" do
-        before(:each) do
-          Facter::Core::Execution.stubs(:exec).with('swapinfo -k').returns my_fixture_read('darwin-swapinfo-single')
-
-          Facter.collection.internal_loader.load(:memory)
-        end
-
-        it "should return the current swap free in MB" do
-          Facter.fact(:swapfree_mb).value.should == "1023.96"
-        end
-
-        it "should return the current swap size in MB" do
-          Facter.fact(:swapsize_mb).value.should == "2000.53"
-        end
-
-        it "should return the current memory size in MB" do
-          Facter.fact(:memorysize_mb).value.should == "1007.34"
-        end
-
-        it "should return the current memory free in MB" do
-          Facter.fact(:memoryfree_mb).value.should == "641.25"
-        end
-      end
-
-      describe "with multiple swaps" do
-        before(:each) do
-          Facter::Core::Execution.stubs(:exec).with('swapinfo -k').returns my_fixture_read('darwin-swapinfo-multiple')
-
-          Facter.collection.internal_loader.load(:memory)
-        end
-
-        it "should return the current swap free in MB" do
-          Facter.fact(:swapfree_mb).value.should == "2047.93"
-        end
-
-        it "should return the current swap size in MB" do
-          Facter.fact(:swapsize_mb).value.should == "4977.62"
-        end
-
-        it "should return the current memory size in MB" do
-          Facter.fact(:memorysize_mb).value.should == "1007.34"
-        end
-
-        it "should return the current memory free in MB" do
-          Facter.fact(:memoryfree_mb).value.should == "641.25"
-        end
-      end
-    end
-
-    describe "on Windows" do
-      before :each do
-        Facter.clear
-        Facter.fact(:kernel).stubs(:value).returns("windows")
-        Facter.collection.internal_loader.load(:memory)
-        require 'facter/util/wmi'
-      end
-
-      it "should return free memory in MB" do
-        os = stubs 'os'
-        os.stubs(:FreePhysicalMemory).returns("3415624")
-        Facter::Util::WMI.stubs(:execquery).returns([os])
-
-        Facter.fact(:memoryfree_mb).value.should == '3335.57'
-      end
-
-      it "should return total memory in MB" do
-        computer = stubs 'computer'
-        computer.stubs(:TotalPhysicalMemory).returns("4193837056")
-        Facter::Util::WMI.stubs(:execquery).returns([computer])
-
-        Facter.fact(:memorysize_mb).value.should == '3999.55'
-    end
-  end
-end