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

data/spec/unit/system32_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe "system32 fact" do
-  let(:systemroot) { 'D:\Windows' }
-  let(:sysnative)  { "#{systemroot}\\sysnative" }
-  let(:system32)   { "#{systemroot}\\system32" }
-
-  before(:each) do
-    Facter.fact(:kernel).stubs(:value).returns("windows")
-    ENV['SYSTEMROOT'] = systemroot
-  end
-
-  describe "when running in 32-bit ruby" do
-    it "resolves to sysnative" do
-      File.expects(:exist?).with(sysnative).returns(true)
-
-      expect(Facter.fact(:system32).value).to eq(sysnative)
-    end
-  end
-
-  describe "when running in 64-bit ruby" do
-    it "resolves to system32" do
-      File.expects(:exist?).with(sysnative).returns(false)
-
-      expect(Facter.fact(:system32).value).to eq(system32)
-    end
-  end
-end

data/spec/unit/system_uptime_spec.rb

@@ -1,80 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/uptime'
-
-describe "system_uptime:" do
-  before { Facter.clear }
-  after { Facter.clear }
-
-  describe "When uptime information is available" do
-    describe "uptime" do
-      test_cases = [
-        [60 * 60 * 24 * 3,      '3 days'],
-        [60 * 60 * 24 * 3 + 25, '3 days'],
-        [60 * 60 * 24 * 1,      '1 day'],
-        [60 * 60 * 24 * 1 + 25, '1 day'],
-        [60 * (60 * 3 + 45),    '3:45 hours'],
-        [60 * (60 * 3 + 4),     '3:04 hours'],
-        [60 * 60,               '1:00 hours'],
-        [60 * 35,               '0:35 hours']
-      ]
-
-      test_cases.each do |seconds, expected|
-        it "should return #{expected.inspect} for #{seconds} seconds in Linux" do
-          Facter.fact(:kernel).stubs(:value).returns("linux")
-          Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(seconds)
-          Facter.fact(:system_uptime).value['uptime'].should eq expected
-        end
-
-        it "should return #{expected.inspect} for #{seconds} seconds in Windows" do
-          Facter.fact(:kernel).stubs(:value).returns("windows")
-          Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(seconds)
-          Facter.fact(:system_uptime).value['uptime'].should eq expected
-        end
-      end
-    end
-  end
-
-  describe "when uptime information is available" do
-    before do
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(60 * 60 * 24 + 23)
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(60 * 60 * 24 + 23)
-    end
-
-    it "should include a key for seconds" do
-      Facter.fact(:system_uptime).value['seconds'].should eq 60 * 60 * 24 + 23
-    end
-
-     it "should include a key for hours" do
-      Facter.fact(:system_uptime).value['hours'].should eq 24
-    end
-
-    it "should include a key for days" do
-      Facter.fact(:system_uptime).value['days'].should eq 1
-    end
-  end
-
-  describe "when uptime information is not available" do
-    before do
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(nil)
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(nil)
-    end
-
-    it "should have an 'uptime' key with value 'unknown'" do
-      Facter.fact(:system_uptime).value['uptime'].should eq "unknown"
-    end
-
-    it "should have a 'seconds' key with value nil" do
-      Facter.fact(:system_uptime).value['seconds'].should eq nil
-    end
-
-    it "should have a 'hours' key with value nil" do
-      Facter.fact(:system_uptime).value['hours'].should eq nil
-    end
-
-    it "should have a 'days' key with value nil" do
-      Facter.fact(:system_uptime).value['days'].should eq nil
-    end
-  end
-end

data/spec/unit/uniqueid_spec.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter'
-
-describe "Uniqueid fact" do
-  it "should match hostid on Solaris" do
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-    Facter::Core::Execution.stubs(:execute).with("hostid", anything).returns("Larry")
-
-    Facter.fact(:uniqueid).value.should == "Larry"
-  end
-
-  it "should match hostid on Linux" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    Facter::Core::Execution.stubs(:execute).with("hostid", anything).returns("Curly")
-
-    Facter.fact(:uniqueid).value.should == "Curly"
-  end
-
-  it "should match hostid on AIX" do
-    Facter.fact(:kernel).stubs(:value).returns("AIX")
-    Facter::Core::Execution.stubs(:execute).with("hostid", anything).returns("Moe")
-
-    Facter.fact(:uniqueid).value.should == "Moe"
-  end
-end

data/spec/unit/uptime_spec.rb

@@ -1,110 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/uptime'
-
-describe "uptime facts:" do
-  before { Facter.clear }
-  after { Facter.clear }
-
-  describe "when uptime information is available" do
-    describe "uptime" do
-      test_cases = [
-        [60 * 60 * 24 * 3,      '3 days'],
-        [60 * 60 * 24 * 3 + 25, '3 days'],
-        [60 * 60 * 24 * 1,      '1 day'],
-        [60 * 60 * 24 * 1 + 25, '1 day'],
-        [60 * (60 * 3 + 45),    '3:45 hours'],
-        [60 * (60 * 3 + 4),     '3:04 hours'],
-        [60 * 60,               '1:00 hours'],
-        [60 * 35,               '0:35 hours']
-      ]
-
-      test_cases.each do |seconds, expected|
-        it "should return #{expected.inspect} for #{seconds} seconds" do
-          Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(seconds)
-          Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(seconds)
-
-          Facter.fact(:uptime).value.should == expected
-        end
-      end
-    end
-
-  end
-
-  describe "when uptime information is available" do
-    before do
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(60 * 60 * 24 + 23)
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(60 * 60 * 24 + 23)
-    end
-
-    describe "uptime_seconds" do
-      it "should return the uptime in seconds" do
-        Facter.fact(:uptime_seconds).value.should == 60 * 60 * 24 + 23
-      end
-    end
-
-    describe "uptime_hours" do
-      it "should return the uptime in hours" do
-        Facter.fact(:uptime_hours).value.should == 24
-      end
-    end
-
-    describe "uptime_days" do
-      it "should return the uptime in days" do
-        Facter.fact(:uptime_days).value.should == 1
-      end
-    end
-  end
-
-  describe "when uptime information is not available" do
-    before do
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(nil)
-      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(nil)
-      $stderr, @old = StringIO.new, $stderr
-    end
-
-    after do
-      $stderr = @old
-    end
-
-    describe "uptime" do
-      it "should return 'unknown'" do
-        Facter.fact(:uptime).value.should == "unknown"
-      end
-    end
-
-    describe "uptime_seconds" do
-      it "should return nil" do
-        Facter.fact(:uptime_seconds).value.should == nil
-      end
-
-      it "should not print a warn message to stderr" do
-        Facter.fact(:uptime_seconds).value
-        $stderr.string.should == ""
-      end
-    end
-
-    describe "uptime_hours" do
-      it "should return nil" do
-        Facter.fact(:uptime_hours).value.should == nil
-      end
-
-      it "should not print a warn message to stderr" do
-        Facter.fact(:uptime_hours).value
-        $stderr.string.should == ""
-      end
-    end
-
-    describe "uptime_days" do
-      it "should return nil" do
-        Facter.fact(:uptime_days).value.should == nil
-      end
-
-      it "should not print a warn message to stderr" do
-        Facter.fact(:uptime_days).value
-        $stderr.string.should == ""
-      end
-    end
-  end
-end

data/spec/unit/util/collection_spec.rb

@@ -1,258 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/collection'
-require 'facter/util/nothing_loader'
-
-describe Facter::Util::Collection do
-  let(:external_loader) { Facter::Util::NothingLoader.new }
-  let(:internal_loader) do
-    load = Facter::Util::Loader.new
-    load.stubs(:load).returns nil
-    load.stubs(:load_all).returns nil
-    load
-  end
-  let(:collection) { Facter::Util::Collection.new(internal_loader, external_loader) }
-
-  it "should delegate its load_all method to its loader" do
-    internal_loader.expects(:load_all)
-
-    collection.load_all
-  end
-
-  describe "when adding facts" do
-    it "should create a new fact if no fact with the same name already exists" do
-      collection.add(:myname)
-      collection.fact(:myname).name.should == :myname
-    end
-
-    it "should accept options" do
-      collection.add(:myname, :timeout => 1) { }
-    end
-
-    it "passes resolution specific options to the fact" do
-      fact = Facter::Util::Fact.new(:myname)
-      Facter::Util::Fact.expects(:new).with(:myname, {:timeout => 'myval'}).returns fact
-
-      fact.expects(:add).with({:timeout => 'myval'})
-
-      collection.add(:myname, :timeout => "myval") {}
-    end
-
-    describe "and a block is provided" do
-      it "should use the block to add a resolution to the fact" do
-        fact = mock 'fact'
-        fact.stubs(:extract_ldapname_option!)
-        Facter::Util::Fact.expects(:new).returns fact
-
-        fact.expects(:add)
-
-        collection.add(:myname) {}
-      end
-
-      it "should discard resolutions that throw an exception when added" do
-        Facter.expects(:warn).with(regexp_matches(/Unable to add resolve .* kaboom!/))
-        expect {
-          collection.add('yay') do
-            raise "kaboom!"
-          end
-        }.to_not raise_error
-        expect(collection.value('yay')).to be_nil
-      end
-    end
-  end
-
-  describe "when only defining facts" do
-    it "creates a new fact if no such fact exists" do
-      fact = Facter::Util::Fact.new(:newfact)
-      Facter::Util::Fact.expects(:new).with(:newfact, {}).returns fact
-      expect(collection.define_fact(:newfact)).to equal fact
-    end
-
-    it "returns an existing fact if the fact has already been defined" do
-      fact = collection.define_fact(:newfact)
-      expect(collection.define_fact(:newfact)).to equal fact
-    end
-
-    it "passes options to newly generated facts" do
-      Facter.stubs(:warnonce)
-      fact = collection.define_fact(:newfact, :ldapname => 'NewFact')
-      expect(fact.ldapname).to eq 'NewFact'
-    end
-
-    it "logs a warning if the fact could not be defined" do
-      Facter.expects(:warn).with("Unable to add fact newfact: kaboom!")
-
-      collection.define_fact(:newfact) do
-        raise "kaboom!"
-      end
-    end
-  end
-
-  describe "when retrieving facts" do
-    before do
-      @fact = collection.add("YayNess")
-    end
-
-    it "should return the fact instance specified by the name" do
-      collection.fact("YayNess").should equal(@fact)
-    end
-
-    it "should be case-insensitive" do
-      collection.fact("yayness").should equal(@fact)
-    end
-
-    it "should treat strings and symbols equivalently" do
-      collection.fact(:yayness).should equal(@fact)
-    end
-
-    it "should use its loader to try to load the fact if no fact can be found" do
-      collection.internal_loader.expects(:load).with(:testing)
-      collection.fact("testing")
-    end
-
-    it "should return nil if it cannot find or load the fact" do
-      collection.internal_loader.expects(:load).with(:testing)
-      collection.fact("testing").should be_nil
-    end
-  end
-
-  describe "when returning a fact's value" do
-    before do
-      @fact = collection.add("YayNess", :value => "result")
-    end
-
-    it "should return the result of calling :value on the fact" do
-      collection.value("YayNess").should == "result"
-    end
-
-    it "should be case-insensitive" do
-      collection.value("yayness").should == "result"
-    end
-
-    it "should treat strings and symbols equivalently" do
-      collection.value(:yayness).should == "result"
-    end
-  end
-
-  it "should return the fact's value when the array index method is used" do
-    collection.add("myfact", :value => "foo")
-
-    collection["myfact"].should == "foo"
-  end
-
-  it "should have a method for flushing all facts" do
-    fact = collection.add("YayNess")
-
-    fact.expects(:flush)
-
-    collection.flush
-  end
-
-  it "should have a method that returns all fact names" do
-    collection.add(:one)
-    collection.add(:two)
-
-    collection.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
-  end
-
-  describe "when returning a hash of values" do
-    it "should return a hash of fact names and values with the fact names as strings" do
-      collection.add(:one, :value => "me")
-
-      collection.to_hash.should == {"one" => "me"}
-    end
-
-    it "should not include facts that did not return a value" do
-      collection.add(:two, :value => nil)
-
-      collection.to_hash.should_not be_include(:two)
-    end
-  end
-
-  describe "when iterating over facts" do
-    before do
-      collection.add(:one, :value => "ONE")
-      collection.add(:two, :value => "TWO")
-    end
-
-    it "should yield each fact name and the fact value" do
-      facts = {}
-      collection.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
-      facts = {}
-      collection.each do |fact, value|
-        fact.should be_instance_of(String)
-      end
-    end
-
-    it "should only yield facts that have values" do
-      collection.add(:nil_fact, :value => nil)
-      facts = {}
-      collection.each do |fact, value|
-        facts[fact] = value
-      end
-
-      facts.should_not be_include("nil_fact")
-    end
-  end
-
-  describe "when no facts are loaded" do
-    it "should warn when no facts were loaded" do
-      Facter.expects(:warnonce).with("No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}").once
-
-      collection.fact("one")
-    end
-  end
-
-  describe "external facts" do
-    let(:external_loader) { SingleFactLoader.new(:test_fact, "fact value") }
-    let(:collection) { Facter::Util::Collection.new(internal_loader, external_loader) }
-
-    it "loads when a specific fact is requested" do
-      collection.fact(:test_fact).value.should == "fact value"
-    end
-
-    it "loads when facts are listed" do
-      collection.list.should == [:test_fact]
-    end
-
-    it "loads when all facts are iterated over" do
-      facts = []
-      collection.each { |fact_name, fact_value| facts << [fact_name, fact_value] }
-
-      facts.should == [["test_fact", "fact value"]]
-    end
-
-    it "are loaded only once" do
-      external_loader.expects(:load).with(collection)
-
-      collection.load_all
-      collection.load_all
-    end
-
-    it "are reloaded after flushing" do
-      external_loader.expects(:load).with(collection).twice
-
-      collection.load_all
-      collection.flush
-      collection.load_all
-    end
-  end
-
-  class SingleFactLoader
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
-
-    def load(collection)
-      collection.add(@name, :value => @value)
-    end
-  end
-end