facter 2.5.7-x86-mingw32 → 3.9.6.cfacter.20180606-x86-mingw32

data/spec/unit/util/partitions/partitions_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'facter'
-require 'facter/util/partitions/linux'
-
-describe 'Facter::Util::Partitions::Linux' do
-  describe 'on Linux OS' do
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-
-      File.stubs(:exist?).with('/sys/block/').returns(true)
-      File.stubs(:exist?).with("/sys/block/./device").returns(false)
-      File.stubs(:exist?).with("/sys/block/../device").returns(false)
-      File.stubs(:exist?).with('/dev/disk/by-uuid/').returns(true)
-
-      devices = [".", "..", "sda", "sdb", "sdc"]
-      Dir.stubs(:entries).with('/sys/block/').returns(devices)
-      
-      Facter::Core::Execution.stubs(:which).with('mount').returns(true)
-      Facter::Core::Execution.stubs(:which).with('blkid').returns(true)
-
-      test_parts = {
-        'sda1' => '13459663-22cc-47b4-a9e6-21dea9906e03',  
-        'sdb2' => '98043570-eb10-457f-9718-0b85a26e66bf',  
-        'sdc3' => 'a35fb506-e831-4752-9899-dff6c601214b',
-      }
-      
-      Dir.stubs(:entries).with('/dev/disk/by-uuid/').returns(test_parts.values)
-      test_parts.each do |part,uuid|
-        device = part.match(/(\D+)/)[1]
-        File.stubs(:exist?).with("/sys/block/#{device}/device").returns(true)
-        File.stubs(:symlink?).with("/dev/disk/by-uuid/#{uuid}").returns(true)
-        File.stubs(:readlink).with("/dev/disk/by-uuid/#{uuid}").returns("/dev/#{part}")
-        Dir.stubs(:glob).with("/sys/block/#{device}/#{device}*").returns(["/sys/block/#{device}/#{part}"])
-        Facter::Util::Partitions::Linux.stubs(:read_size).returns('12345')
-        Facter::Core::Execution.stubs(:exec).with("blkid /dev/#{part}").returns("/dev/#{part}: UUID=\"#{uuid}\" TYPE=\"ext4\"")
-      end
-
-      Facter::Core::Execution.stubs(:exec).with('mount').returns(my_fixture_read("mount"))
-    end
-
-    it '.list should return a list of partitions' do
-      Facter::Util::Partitions::Linux.list.should == ['sda1', 'sdb2', 'sdc3']
-    end
-
-    it '.uuid should return a string containing the uuid' do
-      Facter::Util::Partitions::Linux.uuid('sda1').should == '13459663-22cc-47b4-a9e6-21dea9906e03'
-      Facter::Util::Partitions::Linux.uuid('sdb2').should == '98043570-eb10-457f-9718-0b85a26e66bf'
-      Facter::Util::Partitions::Linux.uuid('sdc3').should == 'a35fb506-e831-4752-9899-dff6c601214b'
-    end
-
-    it '.size should return a string containing the size' do
-      Facter::Util::Partitions::Linux.size('sda1').should == '12345'
-    end
-
-    it '.mount should return a string containing the mount point of the partition' do
-      Facter::Util::Partitions::Linux.mount('sda1').should == '/home'
-      Facter::Util::Partitions::Linux.mount('sdb2').should == '/'
-      Facter::Util::Partitions::Linux.mount('sdc3').should == '/var'
-    end
-
-    it '.filesystem should return a string containing the filesystem on the partition' do
-      Facter::Util::Partitions::Linux.filesystem('sda1').should == 'ext4'
-      Facter::Util::Partitions::Linux.filesystem('sdb2').should == 'ext4'
-      Facter::Util::Partitions::Linux.filesystem('sdc3').should == 'ext4'
-    end
-  end
-end

data/spec/unit/util/partitions_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'facter'
-require 'facter/util/partitions'
-
-describe 'Facter::Util::Partitions' do
-  describe 'on unsupported OSs' do
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("SunOS")
-    end
-    
-    it 'list should return empty array' do
-      Facter::Util::Partitions.list.should == []
-    end
-
-    it 'available? should return false' do
-      Facter::Util::Partitions.available?.should == false
-    end
-  end
-end

data/spec/unit/util/posix_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-require 'facter/util/posix'
-
-describe Facter::Util::POSIX do
-  describe "retrieving values via sysctl" do
-    it "returns the result of the sysctl command" do
-      Facter::Util::Resolution.expects(:exec).with("sysctl -n hw.pagesize 2>/dev/null").returns("somevalue")
-      expect(described_class.sysctl("hw.pagesize")).to eq "somevalue"
-    end
-  end
-end

data/spec/unit/util/processor_spec.rb

@@ -1,212 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/processor'
-require 'facter_spec/cpuinfo'
-
-describe Facter::Util::Processor do
-  describe "on linux" do
-    include FacterSpec::Cpuinfo
-
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      File.stubs(:exists?).with("/proc/cpuinfo").returns(true)
-    end
-
-    describe "with architecture amd64" do
-      before :each do
-        Facter.fact(:architecture).stubs(:value).returns("amd64")
-      end
-
-      it "should get the processor description from the amd64solo fixture" do
-        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64solo"))
-        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
-      end
-
-      it "should get the processor descriptions from the amd64dual fixture" do
-        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64dual"))
-
-        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
-        Facter::Util::Processor.enum_cpuinfo[1].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
-      end
-
-      it "should get the processor descriptions from the amd64tri fixture" do
-        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64tri"))
-
-        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
-        Facter::Util::Processor.enum_cpuinfo[1].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
-        Facter::Util::Processor.enum_cpuinfo[2].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
-      end
-
-      it "should get the processor descriptions from the amd64quad fixture" do
-        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64quad"))
-
-        Facter::Util::Processor.enum_cpuinfo[0].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
-        Facter::Util::Processor.enum_cpuinfo[1].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
-        Facter::Util::Processor.enum_cpuinfo[2].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
-        Facter::Util::Processor.enum_cpuinfo[3].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
-      end
-    end
-
-    describe "with architecture x86" do
-      before :each do
-        Facter.fact(:architecture).stubs(:value).returns("x86")
-        File.stubs(:readlines).with("/proc/cpuinfo").returns(my_fixture_read("x86-pentium2").lines)
-      end
-
-      subject { Facter::Util::Processor.enum_cpuinfo }
-
-      it "should have the correct processor titles" do
-        subject[0].should == "Pentium II (Deschutes)"
-        subject[1].should == "Pentium II (Deschutes)"
-      end
-    end
-  end
-
-  describe "on Solaris" do
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("SunOS")
-    end
-
-    it "should get the processor description on Solaris (x86)" do
-      Facter.fact(:architecture).stubs(:value).returns("i86pc")
-      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-i86pc"))
-
-      Facter::Util::Processor.enum_kstat[0].should == "Intel(r) Core(tm) i5 CPU       M 450  @ 2.40GHz"
-    end
-
-    it "should get the processor description on Solaris (SPARC64)" do
-      Facter.fact(:architecture).stubs(:value).returns("sun4u")
-      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-sun4u"))
-
-      Facter::Util::Processor.enum_kstat[0].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[1].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[2].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[3].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[4].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[5].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[6].should == "SPARC64-VII"
-      Facter::Util::Processor.enum_kstat[7].should == "SPARC64-VII"
-    end
-  end
-
-  describe "on AIX" do
-    let(:lsattr) do
-      "type PowerPC_POWER5 Processor type False\n"
-    end
-
-    def lsdev_examples
-      examples = "proc0  Available 00-00 Processor\n" +
-        "proc4  Available 00-04 Processor\n" +
-        "proc8  Defined   00-08 Processor\n" +
-        "proc12 Defined   00-12 Processor\n"
-      examples
-    end
-
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("AIX")
-      Facter::Util::Processor.stubs(:lsdev).returns(lsdev_examples)
-      Facter::Util::Processor.stubs(:lsattr).returns(lsattr)
-    end
-
-    it "should create an array of processors" do
-      Facter::Util::Processor.aix_processor_list[0].should eq "PowerPC_POWER5"
-      Facter::Util::Processor.aix_processor_list[1].should eq "PowerPC_POWER5"
-      Facter::Util::Processor.aix_processor_list[2].should eq "PowerPC_POWER5"
-    end
-  end
-
-  describe "on HP-UX" do
-    let(:ioscan) do
-      "Class       I  H/W Path  Driver    S/W State H/W Type  Description\n" +
-      "===================================================================\n" +
-      "processor   0  0/120     processor CLAIMED   PROCESSOR Processor\n" +
-      "processor   1  0/123     processor CLAIMED   PROCESSOR Processor\n"
-    end
-
-    describe "when machinfo is available" do
-      def self.machinfo_examples
-        examples = []
-        examples << [File.read(fixtures('hpux','machinfo','ia64-rx2620')), "Intel(R) Itanium 2 processor"]
-        examples << [File.read(fixtures('hpux','machinfo','ia64-rx6600')), "Intel(R) Itanium 2 9100 series processor (1.59 GHz, 18 MB)"]
-        examples << [File.read(fixtures('hpux','machinfo','ia64-rx8640')), "Intel(R) Itanium 2 9100 series"]
-        examples << [File.read(fixtures('hpux','machinfo','hppa-rp4440')), "PA-RISC 8800 processor (1000 MHz, 64 MB)"]
-        examples << [File.read(fixtures('hpux','machinfo','superdome-server-SD32B')), "Intel(R) Itanium 2 9000 series"]
-        examples << [File.read(fixtures('hpux','machinfo','superdome2-16s')), "Intel(R)  Itanium(R)  Processor 9340 (1.6 GHz, 15 MB)"]
-        examples
-      end
-
-      machinfo_examples.each_with_index do |example, i|
-        machinfo_example, expected_cpu = example
-        context "machinfo example ##{i}" do
-          before :each do
-            Facter.fact(:kernel).stubs(:value).returns("HP-UX")
-            Facter::Util::Processor.stubs(:ioscan).returns(ioscan)
-            Facter::Util::Processor.stubs(:machinfo).returns(machinfo_example)
-          end
-
-          %w{ 0 1 }.each do |j|
-            it "should find #{expected_cpu}" do
-              Facter::Util::Processor.hpux_processor_list[j.to_i].should eq expected_cpu
-            end
-          end
-        end
-      end
-    end
-
-    describe "when machinfo is not available" do
-      def self.model_and_getconf_examples
-        examples = []
-        examples << ["9000/800/L3000-5x",     "sched.models_present", "unistd.h_present", "532", "616",       "PA-RISC 8600 processor"]
-        examples << ["9000/800/L3000-5x",     "",                     "unistd.h_present", "532", "616",       "HP PA-RISC2.0 CHIP TYPE #616"]
-        examples << ["9000/800/L3000-5x",     "",                     "",                 "532", "616",       "CPU v532 CHIP TYPE #616"]
-        examples << ["ia64 hp server rx2660", "sched.models_present", "unistd.h_present", "768", "536936708", "IA-64 archrev 0 CHIP TYPE #536936708"]
-        examples << ["ia64 hp server rx2660", "",                     "unistd.h_present", "768", "536936708", "IA-64 archrev 0 CHIP TYPE #536936708"]
-        examples << ["ia64 hp server rx2660", "",                     "",                 "768", "536936708", "CPU v768 CHIP TYPE #536936708"]
-        examples
-      end
-
-      sched_models = File.readlines(fixtures('hpux','sched.models'))
-      unistd_h     = File.readlines(fixtures('hpux','unistd.h'))
-      model_and_getconf_examples.each_with_index do |example, i|
-        model_example, sm, unistd, getconf_cpu_ver, getconf_chip_type, expected_cpu = example
-        context "and model and getconf example ##{i}" do
-          before :each do
-            Facter.fact(:kernel).stubs(:value).returns("HP-UX")
-            Facter::Util::Processor.stubs(:ioscan).returns(ioscan)
-            Facter::Util::Processor.stubs(:getconf_cpu_version).returns(getconf_cpu_ver)
-            Facter::Util::Processor.stubs(:getconf_cpu_chip_type).returns(getconf_chip_type)
-            Facter::Util::Processor.stubs(:machinfo).returns(nil)
-            Facter::Util::Processor.stubs(:model).returns(model_example)
-          end
-
-          if unistd == "unistd.h_present" then
-            before :each do
-              Facter::Util::Processor.stubs(:read_unistd_h).returns(unistd_h)
-            end
-          else
-            before :each do
-              Facter::Util::Processor.stubs(:read_unistd_h).returns(nil)
-            end
-          end
-
-          if sm == "sched.models_present" then
-            before :each do
-              Facter::Util::Processor.stubs(:read_sched_models).returns(sched_models)
-            end
-          else
-            before :each do
-              Facter::Util::Processor.stubs(:read_sched_models).returns(nil)
-            end
-          end
-
-          %w{ 0 1 }.each do |j|
-            it "should find #{expected_cpu}" do
-              Facter::Util::Processor.hpux_processor_list[j.to_i].should eq expected_cpu
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/util/registry_spec.rb

@@ -1,76 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'facter/operatingsystem'
-require 'facter/util/registry'
-
-describe Facter::Util::Registry do
-  describe "hklm_read", :if => Facter::Util::Config.is_windows? do
-    before(:all) do
-      require 'win32/registry'
-    end
-    describe "valid params" do
-      [ {:key => "valid_key", :value => "valid_value",  :expected => "valid"},
-        {:key => "valid_key", :value => "",             :expected => "valid"},
-        {:key => "valid_key", :value => nil,            :expected => "invalid"},
-        {:key => "",          :value => "valid_value",  :expected => "valid"},
-        {:key => "",          :value => "",             :expected => "valid"},
-        {:key => "",          :value => nil,            :expected => "invalid"},
-        {:key => nil,         :value => "valid_value",  :expected => "invalid"},
-        {:key => nil,         :value => "",             :expected => "invalid"},
-        {:key => nil,         :value => nil,            :expected => "invalid"}
-      ].each do |scenario|
-        describe "with key #{scenario[:key] || "nil"} and value #{scenario[:value] || "nil"}" do
-          let :fake_registry_key do
-            fake = {}
-            fake[scenario[:value]] = scenario[:expected]
-            fake
-          end
-          it "should return #{scenario[:expected]} value" do
-            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).returns(fake_registry_key)
-            fake_registry_key.stubs(:close)
-
-            Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value]).should == scenario[:expected]
-          end
-        end
-      end
-    end
-
-    describe "invalid params" do
-      [ {:key => "valid_key",   :value => "invalid_value"},
-        {:key => "valid_key",   :value => ""},
-        {:key => "valid_key",   :value => nil},
-      ].each do |scenario|
-        describe "with valid key and value #{scenario[:value] || "nil"}" do
-          let :fake_registry_key do
-            {}
-          end
-          it "should raise an error" do
-            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).returns(fake_registry_key)
-            fake_registry_key.stubs(:close)
-
-            Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value]).should raise_error
-          end
-        end
-      end
-      [ {:key => "invalid_key", :value => "valid_value"},
-        {:key => "invalid_key", :value => ""},
-        {:key => "invalid_key", :value => nil},
-        {:key => "",            :value => "valid_value"},
-        {:key => "",            :value => ""},
-        {:key => "",            :value => nil},
-        {:key => nil,           :value => "valid_value"},
-        {:key => nil,           :value => ""},
-        {:key => nil,           :value => nil}
-      ].each do |scenario|
-        describe "with invalid key #{scenario[:key] || "nil"} and value #{scenario[:value] || "nil"}" do
-          it "should raise an error" do
-            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).raises(Win32::Registry::Error, 2)
-            expect do
-              Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value])
-            end.to raise_error Win32::Registry::Error
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/util/resolution_spec.rb

@@ -1,129 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/resolution'
-
-describe Facter::Util::Resolution do
-  include FacterSpec::ConfigHelper
-
-  subject(:resolution) { described_class.new(:foo, stub_fact) }
-
-  let(:stub_fact) { stub('fact', :name => :stubfact) }
-
-  it "requires a name" do
-    expect { Facter::Util::Resolution.new }.to raise_error(ArgumentError)
-  end
-
-  it "requires a fact" do
-    expect { Facter::Util::Resolution.new('yay') }.to raise_error(ArgumentError)
-  end
-
-  it "can return its name" do
-    expect(resolution.name).to eq :foo
-  end
-
-  it "can explicitly set a value" do
-    resolution.value = "foo"
-    expect(resolution.value).to eq "foo"
-  end
-
-  it "defaults to nil for code" do
-    expect(resolution.code).to be_nil
-  end
-
-  describe "when setting the code" do
-    before do
-      Facter.stubs(:warnonce)
-    end
-
-    it "creates a block when given a command" do
-      resolution.setcode "foo"
-      expect(resolution.code).to be_a_kind_of Proc
-    end
-
-    it "stores the provided block when given a block" do
-      block = lambda { }
-      resolution.setcode(&block)
-      resolution.code.should equal(block)
-    end
-
-
-    it "prefers a command over a block" do
-      block = lambda { }
-      resolution.setcode("foo", &block)
-      expect(resolution.code).to_not eq block
-    end
-
-    it "fails if neither a string nor block has been provided" do
-      expect { resolution.setcode }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "when returning the value" do
-    it "returns any value that has been provided" do
-      resolution.value = "foo"
-      expect(resolution.value).to eq "foo"
-    end
-
-    describe "and setcode has not been called" do
-      it "returns nil" do
-        expect(resolution.value).to be_nil
-      end
-    end
-
-    describe "and the code is a string" do
-      it "returns the result of executing the code" do
-        resolution.setcode "/bin/foo"
-        Facter::Core::Execution.expects(:execute).once.with("/bin/foo", anything).returns "yup"
-
-        expect(resolution.value).to eq "yup"
-      end
-    end
-
-    describe "and the code is a block" do
-      it "returns the value returned by the block" do
-        resolution.setcode { "yayness" }
-        expect(resolution.value).to eq "yayness"
-      end
-    end
-  end
-
-  describe "setting options" do
-    it "can set the value" do
-      resolution.set_options(:value => 'something')
-      expect(resolution.value).to eq 'something'
-    end
-
-    it "can set the timeout" do
-      resolution.set_options(:timeout => 314)
-      expect(resolution.limit).to eq 314
-    end
-
-    it "can set the weight" do
-      resolution.set_options(:weight => 27)
-      expect(resolution.weight).to eq 27
-    end
-
-    it "fails on unhandled options" do
-      expect do
-        resolution.set_options(:foo => 'bar')
-      end.to raise_error(ArgumentError, /Invalid resolution options.*foo/)
-    end
-  end
-
-  describe "evaluating" do
-    it "evaluates the block in the context of the given resolution" do
-      subject.expects(:has_weight).with(5)
-      subject.evaluate { has_weight(5) }
-    end
-
-    it "raises a warning if the resolution is evaluated twice" do
-      Facter.expects(:warn).with do |msg|
-        expect(msg).to match /Already evaluated foo at.*reevaluating anyways/
-      end
-
-      subject.evaluate { }
-      subject.evaluate { }
-    end
-  end
-end