facter 2.0.1.rc1-universal-darwin

data/spec/unit/util/manufacturer_spec.rb

@@ -0,0 +1,179 @@
+#! /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 "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
+end

data/spec/unit/util/normalization_spec.rb

@@ -0,0 +1,113 @@
+# 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/parser_spec.rb

@@ -0,0 +1,200 @@
+#!/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, content, result)
+        Facter::Util::Config.stubs(:is_windows?).returns(true)
+        Facter::Core::Execution.stubs(:exec).returns(content)
+        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
+        expects_to_parse_powershell(ps1, data_in_txt, data)
+      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