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

data/spec/unit/util/manufacturer_spec.rb

@@ -1,223 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/manufacturer'
-
-describe Facter::Manufacturer do
-  before :each do
-    Facter.clear
-  end
-
-  it "should return the system DMI table" do
-    Facter::Manufacturer.should respond_to(:get_dmi_table)
-  end
-
-  it "should return nil on non-supported operating systems" do
-    Facter.stubs(:value).with(:kernel).returns("SomeThing")
-    Facter::Manufacturer.get_dmi_table().should be_nil
-  end
-
-  it "should parse prtdiag output on a sunfire v120" do
-    Facter::Core::Execution.stubs(:exec).returns(my_fixture_read("solaris_sunfire_v120_prtdiag"))
-    Facter::Manufacturer.prtdiag_sparc_find_system_info()
-    Facter.value(:manufacturer).should == "Sun Microsystems"
-    Facter.value(:productname).should == "Sun Fire V120 (UltraSPARC-IIe 648MHz)"
-  end
-
-  it "should parse prtdiag output on a t5220" do
-    Facter::Core::Execution.stubs(:exec).returns(my_fixture_read("solaris_t5220_prtdiag"))
-    Facter::Manufacturer.prtdiag_sparc_find_system_info()
-    Facter.value(:manufacturer).should == "Sun Microsystems"
-    Facter.value(:productname).should == "SPARC Enterprise T5220"
-  end
-
-  it "should not set manufacturer if prtdiag output is nil" do
-    # Stub kernel so we don't have windows fall through to its own mechanism
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-    Facter.fact(:hardwareisa).stubs(:value).returns("sparc")
-
-    Facter::Core::Execution.stubs(:exec).with(regexp_matches(/prtdiag/)).returns(nil)
-    Facter::Manufacturer.prtdiag_sparc_find_system_info()
-    Facter.value(:manufacturer).should_not == "Sun Microsystems"
-  end
-
-  it "should strip white space on dmi output with spaces" do
-    dmidecode_output = my_fixture_read("linux_dmidecode_with_spaces")
-    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-
-    query = { '[Ss]ystem [Ii]nformation' => [ { 'Product(?: Name)?:' => 'productname' } ] }
-
-    Facter::Manufacturer.dmi_find_system_info(query)
-    Facter.value(:productname).should == "MS-6754"
-  end
-
-  it "should handle output from smbios when run under sunos" do
-    smbios_output = my_fixture_read("opensolaris_smbios")
-    Facter::Manufacturer.expects(:get_dmi_table).returns(smbios_output)
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-
-    query = { 'BIOS information' => [ { 'Release Date:' => 'reldate' } ] }
-
-    Facter::Manufacturer.dmi_find_system_info(query)
-    Facter.value(:reldate).should == "12/01/2006"
-  end
-
-  it "can parse smbios output that contains non-UTF8 characters" do
-    smbios_output = my_fixture_read("smartos_smbios")
-    Facter::Core::Execution.stubs(:exec).with('/usr/sbin/smbios 2>/dev/null').returns(smbios_output)
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-
-    query = { 'BIOS information' => [ { 'Release Date:' => 'reldate' } ] }
-
-    Facter::Manufacturer.dmi_find_system_info(query)
-    Facter.value(:reldate).should == "06/11/2007"
-  end
-
-  it "should not split on dmi keys containing the string Handle" do
-    dmidecode_output = <<-eos
-Handle 0x1000, DMI type 16, 15 bytes
-Physical Memory Array
-        Location: System Board Or Motherboard
-        Use: System Memory
-        Error Correction Type: None
-        Maximum Capacity: 4 GB
-        Error Information Handle: Not Provided
-        Number Of Devices: 123
-
-Handle 0x001F
-        DMI type 127, 4 bytes.
-        End Of Table
-    eos
-    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    query = { 'Physical Memory Array' => [ { 'Number Of Devices:' => 'ramslots'}]}
-    Facter::Manufacturer.dmi_find_system_info(query)
-    Facter.value(:ramslots).should == "123"
-  end
-
-  it "should match the key in the defined section and not the first one found" do
-    dmidecode_output = <<-eos
-Handle 0x000C, DMI type 7, 19 bytes
-Cache Information
-        Socket Designation: Internal L2 Cache
-        Configuration: Enabled, Socketed, Level 2
-        Operational Mode: Write Back
-        Location: Internal
-        Installed Size: 4096 KB
-        Maximum Size: 4096 KB
-        Supported SRAM Types:
-                Burst
-        Installed SRAM Type: Burst
-        Speed: Unknown
-        Error Correction Type: Single-bit ECC
-        System Type: Unified
-        Associativity: 8-way Set-associative
-
-Handle 0x1000, DMI type 16, 15 bytes
-Physical Memory Array
-        Location: System Board Or Motherboard
-        Use: System Memory
-        Error Correction Type: None
-        Maximum Capacity: 4 GB
-        Error Information Handle: Not Provided
-        Number Of Devices: 2
-
-Handle 0x001F
-        DMI type 127, 4 bytes.
-        End Of Table
-    eos
-    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    query = { 'Physical Memory Array' => [ { 'Location:' => 'ramlocation'}]}
-    Facter::Manufacturer.dmi_find_system_info(query)
-    Facter.value(:ramlocation).should == "System Board Or Motherboard"
-  end
-
-  it "should return an appropriate uuid on linux" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    dmidecode = my_fixture_read("intel_linux_dmidecode")
-    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode)
-   
-    query = { '[Ss]ystem [Ii]nformation' => [ { 'UUID:' => 'uuid' } ] }
-    Facter::Manufacturer.dmi_find_system_info(query)
-    Facter.value(:uuid).should == "60A98BB3-95B6-E111-AF74-4C72B9247D28"
-  end
-
-  def find_product_name(os)
-    output_file = case os
-      when "FreeBSD" then my_fixture("freebsd_dmidecode")
-      when "SunOS" then my_fixture("opensolaris_smbios")
-      end
-
-    output = File.new(output_file).read()
-    query = { '[Ss]ystem [Ii]nformation' => [ { 'Product(?: Name)?:' => "product_name_#{os}" } ] }
-
-    Facter.fact(:kernel).stubs(:value).returns(os)
-    Facter::Manufacturer.expects(:get_dmi_table).returns(output)
-
-    Facter::Manufacturer.dmi_find_system_info(query)
-
-    return Facter.value("product_name_#{os}")
-  end
-
-  it "should return the same result with smbios than with dmidecode" do
-    find_product_name("FreeBSD").should_not == nil
-    find_product_name("FreeBSD").should == find_product_name("SunOS")
-  end
-
-  it "should find information on Windows" do
-    Facter.fact(:kernel).stubs(:value).returns("windows")
-    require 'facter/util/wmi'
-
-    bios = stubs 'bios'
-    bios.stubs(:Manufacturer).returns("Phoenix Technologies LTD")
-    bios.stubs(:Serialnumber).returns("56 4d 40 2b 4d 81 94 d6-e6 c5 56 a4 56 0c 9e 9f")
-
-    product = stubs 'product'
-    product.stubs(:Name).returns("VMware Virtual Platform")
-
-    wmi = stubs 'wmi'
-    wmi.stubs(:ExecQuery).with("select * from Win32_Bios").returns([bios])
-    wmi.stubs(:ExecQuery).with("select * from Win32_Bios").returns([bios])
-    wmi.stubs(:ExecQuery).with("select * from Win32_ComputerSystemProduct").returns([product])
-
-    Facter::Util::WMI.stubs(:connect).returns(wmi)
-    Facter.value(:manufacturer).should == "Phoenix Technologies LTD"
-    Facter.value(:serialnumber).should == "56 4d 40 2b 4d 81 94 d6-e6 c5 56 a4 56 0c 9e 9f"
-    Facter.value(:productname).should == "VMware Virtual Platform"
-  end
-
-  describe "using sysctl to look up manufacturer information" do
-    before do
-      Facter.fact(:kernel).stubs(:value).returns 'OpenBSD'
-    end
-
-    let(:mfg_keys) do
-      {
-        'hw.vendor'   => 'manufacturer',
-        'hw.product'  => 'productname',
-        'hw.serialno' => 'serialnumber'
-      }
-    end
-
-    it "creates a new fact for the each hash key" do
-      mfg_keys.values.each do |value|
-        Facter.expects(:add).with(value)
-      end
-      described_class.sysctl_find_system_info(mfg_keys)
-    end
-
-    it "uses sysctl to determine the value for that fact" do
-      mfg_keys.keys.each do |sysctl|
-        Facter::Util::POSIX.expects(:sysctl).with(sysctl).returns "sysctl #{sysctl}"
-      end
-
-      described_class.sysctl_find_system_info(mfg_keys)
-
-      mfg_keys.invert.each_pair do |factname, value|
-        expect(Facter.value(factname)).to eq "sysctl #{value}"
-      end
-    end
-  end
-end

data/spec/unit/util/normalization_spec.rb

@@ -1,113 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'facter/util/normalization'
-
-describe Facter::Util::Normalization do
-
-  subject { described_class }
-
-  def utf16(str)
-    if String.method_defined?(:encode) && defined?(::Encoding)
-      str.encode(Encoding::UTF_16LE)
-    else
-      str
-    end
-  end
-
-  def utf8(str)
-    if String.method_defined?(:encode) && defined?(::Encoding)
-      str.encode(Encoding::UTF_8)
-    else
-      str
-    end
-  end
-
-  describe "validating strings" do
-    describe "and string encoding is supported", :if => String.instance_methods.include?(:encoding) do
-      it "accepts strings that are ASCII and match their encoding and converts them to UTF-8" do
-        str = "ASCII".encode(Encoding::ASCII)
-        normalized_str = subject.normalize(str)
-        expect(normalized_str.encoding).to eq(Encoding::UTF_8)
-      end
-
-      it "accepts strings that are UTF-8 and match their encoding" do
-        str = "let's make a ☃!".encode(Encoding::UTF_8)
-        expect(subject.normalize(str)).to eq(str)
-      end
-
-      it "converts valid non UTF-8 strings to UTF-8" do
-        str = "let's make a ☃!".encode(Encoding::UTF_16LE)
-        enc = subject.normalize(str).encoding
-        expect(enc).to eq(Encoding::UTF_8)
-      end
-
-      it "normalizes a frozen string returning a non-frozen string" do
-        str = "factvalue".encode(Encoding::UTF_16LE).freeze
-        normalized_str = subject.normalize(str)
-        expect(normalized_str.encoding).to eq(Encoding::UTF_8)
-        expect(normalized_str).to_not be_frozen
-      end
-
-      it "rejects strings that are not UTF-8 and do not match their claimed encoding" do
-        invalid_shift_jis = "\xFF\x5C!".force_encoding(Encoding::SHIFT_JIS)
-        expect {
-          subject.normalize(invalid_shift_jis)
-        }.to raise_error(Facter::Util::Normalization::NormalizationError, /String encoding Shift_JIS is not UTF-8 and could not be converted to UTF-8/)
-      end
-
-      it "rejects strings that claim to be UTF-8 encoded but aren't" do
-        str = "\255ay!".force_encoding(Encoding::UTF_8)
-        expect {
-          subject.normalize(str)
-        }.to raise_error(Facter::Util::Normalization::NormalizationError, /String.*doesn't match the reported encoding UTF-8/)
-      end
-    end
-
-    describe "and string encoding is not supported", :unless => String.instance_methods.include?(:encoding) do
-      it "accepts strings that are UTF-8 and match their encoding" do
-        str = "let's make a ☃!"
-        expect(subject.normalize(str)).to eq(str)
-      end
-
-      it "rejects strings that are not UTF-8" do
-        str = "let's make a \255\255\255!"
-        expect {
-          subject.normalize(str)
-        }.to raise_error(Facter::Util::Normalization::NormalizationError, /String .* is not valid UTF-8/)
-      end
-    end
-  end
-
-  describe "normalizing arrays" do
-    it "normalizes each element in the array" do
-      arr = [utf16('first'), utf16('second'), [utf16('third'), utf16('fourth')]]
-      expected_arr = [utf8('first'), utf8('second'), [utf8('third'), utf8('fourth')]]
-
-      expect(subject.normalize_array(arr)).to eq(expected_arr)
-    end
-  end
-
-  describe "normalizing hashes" do
-    it "normalizes each element in the array" do
-      hsh = {utf16('first') => utf16('second'), utf16('third') => [utf16('fourth'), utf16('fifth')]}
-      expected_hsh = {utf8('first') => utf8('second'), utf8('third') => [utf8('fourth'), utf8('fifth')]}
-
-      expect(subject.normalize_hash(hsh)).to eq(expected_hsh)
-    end
-  end
-
-  [1, 1.0, true, false, nil].each do |val|
-    it "accepts #{val.inspect}:#{val.class}" do
-      expect(subject.normalize(val)).to eq(val)
-    end
-  end
-
-  [:sym, Object.new, Set.new].each do |val|
-    it "rejects #{val.inspect}:#{val.class}" do
-      expect {
-        subject.normalize(val)
-      }.to raise_error(Facter::Util::Normalization::NormalizationError, /Expected .*but was #{val.class}/ )
-    end
-  end
-end

data/spec/unit/util/operatingsystem_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'facter/util/operatingsystem'
-
-describe Facter::Util::Operatingsystem do
-  describe "reading the os-release file" do
-
-    it "correctly parses the file on Cumulus Linux"  do
-      values = described_class.os_release(my_fixture('cumuluslinux.txt'))
-
-      expect(values).to eq({
-        '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/",
-      })
-    end
-
-    it "correctly parses the file on CoreOS Linux"  do
-      values = described_class.os_release(my_fixture('coreos.txt'))
-
-      expect(values).to eq({
-        'NAME' => "CoreOS",
-        'VERSION_ID' => "575.0.0",
-        'VERSION' => "575.0.0",
-        'PRETTY_NAME' => "CoreOS 575.0.0",
-        'ID' => "coreos",
-        'HOME_URL' => "https://coreos.com/",
-        'BUG_REPORT_URL' => "https://github.com/coreos/bugs/issues",
-        'ANSI_COLOR' => "1;32",
-      })
-    end
-
-    it "correctly parses the file on Sabayon" do
-      values = described_class.os_release(my_fixture('sabayon.txt'))
-
-      expect(values).to eq({
-        "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/",
-      })
-    end
-
-    it "correctly parses the file on Debian Wheezy" do
-      values = described_class.os_release(my_fixture('wheezy.txt'))
-
-      expect(values).to eq({
-        "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/",
-      })
-    end
-
-    it "correctly parses the file on Debian Wheezy" do
-      values = described_class.os_release(my_fixture('wheezy.txt'))
-
-      expect(values).to eq({
-        "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/",
-      })
-    end
-
-
-    it "correctly parses the file on RedHat 7" do
-      values = described_class.os_release(my_fixture('redhat-7.txt'))
-      expect(values).to eq({
-        "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",
-      })
-    end
-
-    it "does not try to read an unreadable '/etc/os-release' file" do
-      File.expects(:readable?).with('/some/nonexistent/file').returns false
-
-      expect(described_class.os_release('/some/nonexistent/file')).to be_empty
-    end
-  end
-end

data/spec/unit/util/parser_spec.rb

@@ -1,233 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/parser'
-require 'tempfile'
-require 'tmpdir.rb'
-
-describe Facter::Util::Parser do
-  include PuppetlabsSpec::Files
-
-  describe "extension_matches? function" do
-    it "should match extensions when subclass uses match_extension" do
-      Facter::Util::Parser.extension_matches?("myfile.foobar", "foobar").should == true
-    end
-
-    it "should match extensions when subclass uses match_extension with an array" do
-      Facter::Util::Parser.extension_matches?("myfile.ext1", ["ext1","ext2","ext3"]).should == true
-      Facter::Util::Parser.extension_matches?("myfile.ext2", ["ext1","ext2","ext3"]).should == true
-      Facter::Util::Parser.extension_matches?("myfile.ext3", ["ext1","ext2","ext3"]).should == true
-    end
-
-    it "should match extension ignoring case on file" do
-      Facter::Util::Parser.extension_matches?("myfile.EXT1", "ext1").should == true
-      Facter::Util::Parser.extension_matches?("myfile.ExT1", "ext1").should == true
-      Facter::Util::Parser.extension_matches?("myfile.exT1", "ext1").should == true
-    end
-
-    it "should match extension ignoring case for match_extension" do
-      Facter::Util::Parser.extension_matches?("myfile.EXT1", "EXT1").should == true
-      Facter::Util::Parser.extension_matches?("myfile.ExT1", "EXT1").should == true
-      Facter::Util::Parser.extension_matches?("myfile.exT1", "EXT1").should == true
-    end
-  end
-
-  let(:data) do {"one" => "two", "three" => "four"} end
-
-  describe "yaml" do
-    let(:data_in_yaml) { YAML.dump(data) }
-    let(:data_file) { "/tmp/foo.yaml" }
-
-    it "should return a hash of whatever is stored on disk" do
-      File.stubs(:read).with(data_file).returns(data_in_yaml)
-      described_class.parser_for(data_file).results.should == data
-    end
-
-    it "should handle exceptions and warn" do
-      # YAML data with an error
-      File.stubs(:read).with(data_file).returns(data_in_yaml + "}")
-      Facter.expects(:warn).at_least_once
-      lambda { Facter::Util::Parser.parser_for(data_file).results }.should_not raise_error
-    end
-  end
-
-  describe "json" do
-    let(:data_in_json) { JSON.dump(data) }
-    let(:data_file) { "/tmp/foo.json" }
-
-    it "should return a hash of whatever is stored on disk" do
-      pending("this test requires the json library") unless Facter.json?
-      File.stubs(:read).with(data_file).returns(data_in_json)
-      Facter::Util::Parser.parser_for(data_file).results.should == data
-    end
-  end
-
-  describe "txt" do
-    let(:data_file) { "/tmp/foo.txt" }
-
-    shared_examples_for "txt parser" do
-      it "should return a hash of whatever is stored on disk" do
-        File.stubs(:read).with(data_file).returns(data_in_txt)
-        Facter::Util::Parser.parser_for(data_file).results.should == data
-      end
-    end
-
-    context "well formed data" do
-      let(:data_in_txt) { "one=two\nthree=four\n" }
-      it_behaves_like "txt parser"
-    end
-
-    context "extra equal sign" do
-      let(:data_in_txt) { "one=two\nthree=four=five\n" }
-      let(:data) do {"one" => "two", "three" => "four=five"} end
-      it_behaves_like "txt parser"
-    end
-
-    context "extra data" do
-      let(:data_in_txt) { "one=two\nfive\nthree=four\n" }
-      it_behaves_like "txt parser"
-    end
-  end
-
-  describe "scripts" do
-    let(:ext) { Facter::Util::Config.is_windows? ? '.bat' : '.sh' }
-    let(:cmd) { "/tmp/foo#{ext}" }
-    let(:data_in_txt) { "one=two\nthree=four\n" }
-
-    def expects_script_to_return(path, content, result)
-      Facter::Core::Execution.stubs(:exec).with(path).returns(content)
-      File.stubs(:executable?).with(path).returns(true)
-      File.stubs(:file?).with(path).returns(true)
-
-      Facter::Util::Parser.parser_for(path).results.should == result
-    end
-
-    def expects_parser_to_return_nil_for_directory(path)
-      File.stubs(:file?).with(path).returns(false)
-
-      Facter::Util::Parser.parser_for(path).results.should be_nil
-    end
-
-    it "returns a hash of whatever is returned by the executable" do
-      expects_script_to_return(cmd, data_in_txt, data)
-    end
-
-    it "should not parse a directory" do
-      expects_parser_to_return_nil_for_directory(cmd)
-    end
-
-    it "returns an empty hash when the script returns nil" do
-      expects_script_to_return(cmd, nil, {})
-    end
-
-    it "quotes scripts with spaces" do
-      path = "/h a s s p a c e s#{ext}"
-
-      Facter::Core::Execution.expects(:exec).with("\"#{path}\"").returns(data_in_txt)
-
-      expects_script_to_return(path, data_in_txt, data)
-    end
-
-    context "exe, bat, cmd, and com files" do
-      let :cmds do ["/tmp/foo.bat", "/tmp/foo.cmd", "/tmp/foo.exe", "/tmp/foo.com"] end
-
-      before :each do
-        cmds.each {|cmd|
-          File.stubs(:executable?).with(cmd).returns(true)
-          File.stubs(:file?).with(cmd).returns(true)
-        }
-      end
-
-      it "should return nothing parser if not on windows" do
-        Facter::Util::Config.stubs(:is_windows?).returns(false)
-        cmds.each {|cmd| Facter::Util::Parser.parser_for(cmd).should be_an_instance_of(Facter::Util::Parser::NothingParser) }
-      end
-
-      it "should return script parser if on windows" do
-        Facter::Util::Config.stubs(:is_windows?).returns(true)
-        cmds.each {|cmd| Facter::Util::Parser.parser_for(cmd).should be_an_instance_of(Facter::Util::Parser::ScriptParser) }
-      end
-    end
-
-    context "exe, bat, cmd, and com files" do
-      let :cmds do ["/tmp/foo.bat", "/tmp/foo.cmd", "/tmp/foo.exe", "/tmp/foo.com"] end
-
-      before :each do
-        cmds.each {|cmd|
-          File.stubs(:executable?).with(cmd).returns(true)
-          File.stubs(:file?).with(cmd).returns(true)
-        }
-      end
-
-      it "should return nothing parser if not on windows" do
-        Facter::Util::Config.stubs(:is_windows?).returns(false)
-        cmds.each {|cmd| Facter::Util::Parser.parser_for(cmd).should be_an_instance_of(Facter::Util::Parser::NothingParser) }
-      end
-
-      it "should return script  parser if on windows" do
-        Facter::Util::Config.stubs(:is_windows?).returns(true)
-        cmds.each {|cmd| Facter::Util::Parser.parser_for(cmd).should be_an_instance_of(Facter::Util::Parser::ScriptParser) }
-      end
-
-     end
-
-    describe "powershell parser" do
-      let(:ps1) { "/tmp/foo.ps1" }
-
-      def expects_to_parse_powershell(cmd, result)
-        Facter::Util::Config.stubs(:is_windows?).returns(true)
-
-        File.stubs(:file?).with(ps1).returns(true)
-
-        Facter::Util::Parser.parser_for(cmd).results.should == result
-      end
-
-      it "should not parse a directory" do
-        expects_parser_to_return_nil_for_directory(ps1)
-      end
-
-      it "should parse output from powershell" do
-        Facter::Core::Execution.stubs(:exec).returns(data_in_txt)
-        expects_to_parse_powershell(ps1, data)
-      end
-
-      describe "when executing powershell", :if => Facter::Util::Config.is_windows? do
-        let(:sysnative_powershell) { "#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe" }
-        let(:system32_powershell)  { "#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe" }
-
-        let(:sysnative_regexp)  { /^\"#{Regexp.escape(sysnative_powershell)}\"/ }
-        let(:system32_regexp)   { /^\"#{Regexp.escape(system32_powershell)}\"/ }
-        let(:powershell_regexp) { /^\"#{Regexp.escape("powershell.exe")}\"/ }
-
-        it "prefers the sysnative alias to resolve 64-bit powershell on 32-bit ruby" do
-          File.expects(:exists?).with(sysnative_powershell).returns(true)
-          Facter::Core::Execution.expects(:exec).with(regexp_matches(sysnative_regexp)).returns(data_in_txt)
-
-          expects_to_parse_powershell(ps1, data)
-        end
-
-        it "uses system32 if sysnative alias doesn't exist on 64-bit ruby" do
-          File.expects(:exists?).with(sysnative_powershell).returns(false)
-          File.expects(:exists?).with(system32_powershell).returns(true)
-          Facter::Core::Execution.expects(:exec).with(regexp_matches(system32_regexp)).returns(data_in_txt)
-
-          expects_to_parse_powershell(ps1, data)
-        end
-
-        it "uses 'powershell' as a last resort" do
-          File.expects(:exists?).with(sysnative_powershell).returns(false)
-          File.expects(:exists?).with(system32_powershell).returns(false)
-          Facter::Core::Execution.expects(:exec).with(regexp_matches(powershell_regexp)).returns(data_in_txt)
-
-          expects_to_parse_powershell(ps1, data)
-        end
-      end
-    end
-  end
-
-  describe "nothing parser" do
-    it "uses the nothing parser when there is no other parser" do
-      Facter::Util::Parser.parser_for("this.is.not.valid").results.should be_nil
-    end
-  end
-end