facter 2.1.0-x64-mingw32

data/spec/unit/application_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'facter/application'
+
+describe Facter::Application do
+  describe '.parse' do
+    it 'returns an empty hash when given no options' do
+      Facter::Application.parse([]).should == {}
+      Facter::Application.parse(['architecture', 'kernel']).should == {}
+    end
+
+    [:yaml, :json].each do |option_key|
+      it "sets options[:#{option_key}] when given --#{option_key}" do
+        options = Facter::Application.parse(["--#{option_key}"])
+        options[option_key].should be_true
+      end
+    end
+
+    [['-y', :yaml], ['-j', :json]].each do |option, key|
+      it "sets options[:#{key}] when given #{option}" do
+        options = Facter::Application.parse([option])
+        options[key].should be_true
+      end
+    end
+
+    ['-d', '--debug'].each do |option|
+      it "enables debugging when given #{option}" do
+        Facter.debugging(false)
+        Facter::Application.parse([option])
+        Facter.should be_debugging
+        Facter.debugging(false)
+      end
+    end
+
+    it "enables tracing when given --trace" do
+      Facter.trace(false)
+      Facter::Application.parse(['--trace'])
+      Facter.should be_trace
+      Facter.trace(false)
+    end
+
+    ['-t', '--timing'].each do |option|
+      it "enables timing when given #{option}" do
+        Facter.timing(false)
+        Facter::Application.parse([option])
+        Facter.should be_timing
+        Facter.timing(false)
+      end
+    end
+
+    ['-p', '--puppet'].each do |option|
+      it "calls load_puppet when given #{option}" do
+        Facter::Application.expects(:load_puppet)
+        Facter::Application.parse([option])
+      end
+    end
+
+    it 'mutates argv so that non-option arguments are left' do
+      argv = ['-y', '--trace', 'uptime', 'virtual']
+      Facter::Application.parse(argv)
+      argv.should == ['uptime', 'virtual']
+    end
+
+    after(:all) do
+      Facter.debugging(false)
+      Facter.timing(false)
+      Facter.trace(false)
+    end
+  end
+
+  describe "formatting facts" do
+    before do
+      Facter.stubs(:to_hash)
+      Facter.stubs(:value)
+      Facter::Application.stubs(:puts)
+    end
+
+    it "delegates YAML formatting" do
+      Facter::Util::Formatter.expects(:format_yaml)
+      Facter::Application.stubs(:exit).with(0)
+      Facter::Application.run(['--yaml'])
+    end
+
+    it "delegates JSON formatting", :if => Facter.json? do
+      Facter::Util::Formatter.expects(:format_json)
+      Facter::Application.stubs(:exit).with(0)
+      Facter::Application.run(['--json'])
+    end
+
+    it "delegates plaintext formatting" do
+      Facter::Util::Formatter.expects(:format_plaintext)
+      Facter::Application.stubs(:exit).with(0)
+      Facter::Application.run(['--plaintext'])
+    end
+
+    it "defaults to plaintext" do
+      Facter::Util::Formatter.expects(:format_plaintext)
+      Facter::Application.stubs(:exit).with(0)
+      Facter::Application.run([])
+    end
+  end
+end

data/spec/unit/architecture_spec.rb

@@ -0,0 +1,63 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/architecture'
+
+describe "Architecture fact" do
+
+  it "should default to the hardware model" do
+    Facter.fact(:hardwaremodel).stubs(:value).returns("NonSpecialCasedHW")
+
+    Facter.fact(:architecture).value.should == "NonSpecialCasedHW"
+  end
+
+  os_archs = Hash.new
+  os_archs = {
+    ["Debian","x86_64"] => "amd64",
+    ["Gentoo","x86_64"] => "amd64",
+    ["GNU/kFreeBSD","x86_64"] => "amd64",
+    ["Ubuntu","x86_64"] => "amd64",
+    ["Gentoo","i386"] => "x86",
+    ["Gentoo","i486"] => "x86",
+    ["Gentoo","i586"] => "x86",
+    ["Gentoo","i686"] => "x86",
+    ["Gentoo","pentium"] => "x86",
+    ["windows","i386"] => "x86",
+    ["windows","i686"] => "x86",
+    ["windows","x64"] => "x64",
+  }
+  generic_archs = Hash.new
+  generic_archs = {
+    "i386" => "i386",
+    "i486" => "i386",
+    "i586" => "i386",
+    "i686" => "i386",
+    "pentium" => "i386",
+  }
+
+  os_archs.each do |pair, result|
+    it "should be #{result} if os is #{pair[0]} and hardwaremodel is #{pair[1]}" do
+     Facter.fact(:operatingsystem).stubs(:value).returns(pair[0])
+     Facter.fact(:hardwaremodel).stubs(:value).returns(pair[1])
+
+     Facter.fact(:architecture).value.should == result
+    end
+  end
+
+  generic_archs.each do |hw, result|
+    it "should be #{result} if hardwaremodel is #{hw}" do
+     Facter.fact(:hardwaremodel).stubs(:value).returns(hw)
+     Facter.fact(:operatingsystem).stubs(:value).returns("NonSpecialCasedOS")
+
+     Facter.fact(:architecture).value.should == result
+    end
+  end
+
+  it "(#16081) should be PowerPC_POWER7 if os is AIX" do
+    Facter.fact(:kernel).stubs(:value).returns("AIX")
+    Facter::Util::Architecture.stubs(:lsattr).returns("type PowerPC_POWER7 Processor type False")
+    Facter.fact(:hardwaremodel).stubs(:value).returns("IBM,8233-E8B")
+    Facter.fact(:architecture).value.should == "PowerPC_POWER7"
+  end
+
+end

data/spec/unit/blockdevices_spec.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+require 'facter/util/nothing_loader'
+
+describe "Block device facts" do
+
+  describe "on non-Linux OS" do
+
+    it "should not exist when kernel isn't Linux" do
+      Facter.fact(:kernel).stubs(:value).returns("SunOS")
+      Facter.fact(:blockdevices).should == nil
+    end
+
+  end
+
+  describe "on Linux" do
+
+    describe "with /sys/block/" do
+
+      describe "with valid entries" do
+        before :each do
+          Facter::Util::Config.ext_fact_loader = Facter::Util::NothingLoader.new
+          Facter.fact(:kernel).stubs(:value).returns("Linux")
+          File.stubs(:exist?).with('/sys/block/').returns(true)
+
+          Dir.stubs(:entries).with("/sys/block/").returns([".", "..", "hda", "sda", "sdb"])
+
+          File.stubs(:exist?).with("/sys/block/./device").returns(false)
+          File.stubs(:exist?).with("/sys/block/../device").returns(false)
+
+          stubdevices = [
+            #device,    size,               vendor,     model
+            ["hda"],
+            ["sda",     "976773168",        "ATA",      "WDC WD5000AAKS-0"],
+            ["sdb",     "8787591168",       "DELL",     "PERC H700"]
+          ]
+
+          stubdevices.each do |device, size, vendor, model|
+            stubdir = "/sys/block/#{device}"
+            File.stubs(:exist?).with(stubdir + "/device").returns(true)
+            File.stubs(:exist?).with(stubdir + "/size").returns(size ? true : false)
+            File.stubs(:exist?).with(stubdir + "/device/model").returns(model ? true : false)
+            File.stubs(:exist?).with(stubdir + "/device/vendor").returns(vendor ? true : false)
+            IO.stubs(:read).with(stubdir + "/size").returns(size) if size
+            IO.stubs(:read).with(stubdir + "/device/vendor").returns(vendor) if vendor
+            IO.stubs(:read).with(stubdir + "/device/model").returns(model) if model
+          end
+        end
+
+        it "should report three block devices, hda, sda, and sdb, with accurate information from sda and sdb, and without invalid . or .. entries" do
+          Facter.fact(:blockdevices).value.should == "hda,sda,sdb"
+
+          # handle facts that should not exist
+          %w{ . .. hda }.each do |device|
+            Facter.fact("blockdevice_#{device}_size".to_sym).should == nil
+            Facter.fact("blockdevice_#{device}_vendor".to_sym).should == nil
+            Facter.fact("blockdevice_#{device}_model".to_sym).should == nil
+          end
+
+          # handle facts that should exist
+          %w{ sda sdb }.each do |device|
+            Facter.fact("blockdevice_#{device}_size".to_sym).should_not == nil
+            Facter.fact("blockdevice_#{device}_vendor".to_sym).should_not == nil
+            Facter.fact("blockdevice_#{device}_model".to_sym).should_not == nil
+          end
+
+          Facter.fact(:blockdevice_sda_model).value.should == "WDC WD5000AAKS-0"
+          Facter.fact(:blockdevice_sda_vendor).value.should == "ATA"
+          Facter.fact(:blockdevice_sda_size).value.should == 500107862016
+
+          Facter.fact(:blockdevice_sdb_model).value.should == "PERC H700"
+          Facter.fact(:blockdevice_sdb_vendor).value.should == "DELL"
+          Facter.fact(:blockdevice_sdb_size).value.should == 4499246678016
+
+        end
+
+      end
+      describe "with invalid entries in /sys/block" do
+        before :each do
+          Facter.fact(:kernel).stubs(:value).returns("Linux")
+          File.stubs(:exist?).with('/sys/block/').returns(true)
+
+          Dir.stubs(:entries).with("/sys/block/").returns([".", "..", "xda", "ydb"])
+
+          File.stubs(:exist?).with("/sys/block/./device").returns(false)
+          File.stubs(:exist?).with("/sys/block/../device").returns(false)
+          File.stubs(:exist?).with("/sys/block/xda/device").returns(false)
+          File.stubs(:exist?).with("/sys/block/ydb/device").returns(false)
+        end
+
+        it "should not exist with invalid entries in /sys/block" do
+          Facter.fact(:blockdevices).should == nil
+        end
+      end
+    end
+    describe "without /sys/block/" do
+
+      it "should not exist without /sys/block/ on Linux" do
+        Facter.fact(:kernel).stubs(:value).returns("Linux")
+        File.stubs(:exist?).with('/sys/block/').returns(false)
+        Facter.fact(:blockdevices).should == nil
+      end
+
+    end
+
+  end
+end

data/spec/unit/core/aggregate_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'facter/core/aggregate'
+
+describe Facter::Core::Aggregate do
+
+  let(:fact) { stub('stub_fact', :name => 'stub_fact') }
+
+  subject { obj = described_class.new('aggregated', fact) }
+
+  it "can be resolved" do
+    expect(subject).to be_a_kind_of Facter::Core::Resolvable
+  end
+
+  it "can be confined and weighted" do
+    expect(subject).to be_a_kind_of Facter::Core::Suitable
+  end
+
+  describe "setting options" do
+
+    it "can set the timeout" do
+      subject.set_options(:timeout => 314)
+      expect(subject.limit).to eq 314
+    end
+
+    it "can set the weight" do
+      subject.set_options(:weight => 27)
+      expect(subject.weight).to eq 27
+    end
+
+    it "can set the name" do
+      subject.set_options(:name => 'something')
+      expect(subject.name).to eq 'something'
+    end
+
+    it "fails on unhandled options" do
+      expect do
+        subject.set_options(:foo => 'bar')
+      end.to raise_error(ArgumentError, /Invalid aggregate options .*foo/)
+    end
+  end
+
+  describe "declaring chunks" do
+    it "requires that an chunk is given a block" do
+      expect { subject.chunk(:fail) }.to raise_error(ArgumentError, /requires a block/)
+    end
+
+    it "allows an chunk to have a list of requirements" do
+      subject.chunk(:data, :require => [:other]) { }
+      expect(subject.deps[:data]).to eq [:other]
+    end
+
+    it "converts a single chunk requirement to an array" do
+      subject.chunk(:data, :require => :other) { }
+      expect(subject.deps[:data]).to eq [:other]
+    end
+
+    it "raises an error when an unhandled option is passed" do
+      expect {
+        subject.chunk(:data, :before => [:other]) { }
+      }.to raise_error(ArgumentError, /Unexpected options.*#chunk: .*before/)
+    end
+  end
+
+  describe "handling interactions between chunks" do
+    it "generates a warning when there is a dependency cycle in chunks" do
+      subject.chunk(:first, :require => [:second]) { }
+      subject.chunk(:second, :require => [:first]) { }
+
+      Facter.expects(:warn) do |msg|
+        expect(msg).to match /dependency cycles: .*[:first, :second]/
+      end
+
+      subject.value
+    end
+
+    it "passes all requested chunk results to the depending chunk" do
+      subject.chunk(:first) { ['foo'] }
+      subject.chunk(:second, :require => [:first]) do |first|
+        [first[0] + ' bar']
+      end
+
+      output = subject.value
+      expect(output).to include 'foo'
+      expect(output).to include 'foo bar'
+    end
+
+    it "clones and freezes chunk results passed to other chunks" do
+      subject.chunk(:first) { 'foo' }
+      subject.chunk(:second, :require => [:first]) do |first|
+        expect(first).to be_frozen
+      end
+
+      subject.aggregate do |chunks|
+        chunks.values.each do |chunk|
+          expect(chunk).to be_frozen
+        end
+      end
+    end
+  end
+
+  describe "aggregating chunks" do
+    it "passes all chunk results as a hash to the aggregate block" do
+      subject.chunk(:data) { 'data chunk' }
+      subject.chunk(:datum) { 'datum chunk' }
+
+      subject.aggregate do |chunks|
+        expect(chunks).to eq(:data => 'data chunk', :datum => 'datum chunk')
+      end
+
+      subject.value
+    end
+
+    it "uses the result of the aggregate block as the value" do
+      subject.aggregate { "who needs chunks anyways" }
+      expect(subject.value).to eq "who needs chunks anyways"
+    end
+  end
+
+  describe "evaluating" do
+    it "evaluates the block in the context of the aggregate" do
+      subject.expects(:has_weight).with(5)
+      subject.evaluate { has_weight(5) }
+    end
+  end
+end

data/spec/unit/core/directed_graph_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'facter/core/directed_graph'
+
+describe Facter::Core::DirectedGraph do
+  subject(:graph) { described_class.new }
+
+  describe "detecting cycles" do
+    it "is acyclic if the graph is empty" do
+      expect(graph).to be_acyclic
+    end
+
+    it "is acyclic if the graph has no edges" do
+      graph[:one] = []
+      graph[:two] = []
+
+      expect(graph).to be_acyclic
+    end
+
+    it "is acyclic if a vertex has an edge to itself" do
+      graph[:one] = [:one]
+      expect(graph).to be_acyclic
+    end
+
+    it "is acyclic if there are no loops in the graph" do
+      graph[:one] = [:two, :three]
+      graph[:two] = [:four]
+      graph[:three] = [:four]
+      graph[:four] = []
+
+      expect(graph).to be_acyclic
+    end
+
+    it "is cyclic if there is a loop in the graph" do
+      graph[:one] = [:two]
+      graph[:two] = [:one]
+      expect(graph).to_not be_acyclic
+    end
+
+    it "can return the cycles in the graph" do
+      graph[:one] = [:two]
+      graph[:two] = [:one]
+
+      graph[:three] = [:four]
+      graph[:four] = [:three]
+
+      first_cycle = graph.cycles.find { |cycle| cycle.include? :one }
+      second_cycle = graph.cycles.find { |cycle| cycle.include? :three }
+
+      expect(first_cycle).to include :two
+      expect(second_cycle).to include :four
+    end
+  end
+
+  describe "sorting" do
+    it "returns the vertices in topologically sorted order" do
+      graph[:one] = [:two, :three]
+      graph[:two] = [:three]
+      graph[:three] = []
+      expect(graph.tsort).to eq [:three, :two, :one]
+    end
+
+    it "raises an error if there is a cycle in the graph" do
+      graph[:one] = [:two]
+      graph[:two] = [:one]
+
+      expect {
+        graph.tsort
+      }.to raise_error(Facter::Core::DirectedGraph::CycleError, /found the following cycles:/)
+    end
+
+    it "raises an error if there is an edge to a non-existent vertex" do
+      graph[:one] = [:two, :three]
+      graph[:two] = [:three]
+      expect {
+        graph.tsort
+      }.to raise_error(Facter::Core::DirectedGraph::MissingVertex, /missing elements.*three/)
+    end
+  end
+end