facter 2.5.7 → 3.9.6.cfacter.20180606

data/spec/unit/util/solaris_zones_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'facter/util/solaris_zones'
-
-describe Facter::Util::SolarisZones do
-  let :zone_list do
-    zone_list = <<-EOF
-0:global:running:/::native:shared
--:local:configured:/::native:shared
--:zoneA:stopped:/::native:shared
-    EOF
-  end
-
-  let :zone_list2 do
-    zone_list = <<-EOF
-0:global:running:/::native:shared
--:local:configured:/::native:shared
--:zoneB:stopped:/::native:shared
--:zoneC:stopped:/::native:shared
-    EOF
-  end
-
-  subject do
-    described_class.new(:zoneadm_output => zone_list)
-  end
-
-  describe '.add_facts' do
-    before :each do
-      zones = described_class.new(:zoneadm_output => zone_list)
-      zones.send(:parse!)
-      zones.stubs(:refresh)
-      described_class.stubs(:new).returns(zones)
-    end
-
-    it 'defines the zones fact' do
-      described_class.add_facts
-      Facter.fact(:zones).value.should == 3
-    end
-
-    it 'defines a fact for each attribute of a zone' do
-      described_class.add_facts
-      [:id, :name, :status, :path, :uuid, :brand, :iptype].each do |attr|
-        Facter.fact("zone_local_#{attr}".intern).
-          should be_a_kind_of Facter::Util::Fact
-      end
-    end
-  end
-
-  describe '#refresh' do
-    it 'executes the zoneadm_cmd' do
-      Facter::Core::Execution.expects(:execute).with(subject.zoneadm_cmd, {:on_fail => nil}).returns(zone_list)
-      subject.refresh
-    end
-  end
-
-  describe 'multiple facts sharing a single model' do
-    context 'when zones is resolved for the first time' do
-      it 'counts the number of zones' do
-        given_initial_zone_facts
-        Facter.fact(:zones).value.should == 3
-      end
-      it 'defines facts for zoneA' do
-        given_initial_zone_facts
-        Facter.fact(:zone_zoneA_id).value.should == '-'
-      end
-      it 'does not define facts for zoneB' do
-        given_initial_zone_facts
-        Facter.fact(:zone_zoneB_id).should be_nil
-      end
-      it 'uses a single read of the system information for all of the dynamically generated zone facts' do
-        given_initial_zone_facts # <= single read happens here
-
-        Facter::Core::Execution.expects(:execute).never
-        Facter.fact(:zone_zoneA_id).value
-        Facter.fact(:zone_local_id).value
-      end
-    end
-    context 'when all facts have been flushed after zones was resolved once' do
-      it 'updates the number of zones' do
-        given_initial_zone_facts
-        when_facts_have_been_resolved_then_flushed
-
-        Facter.fact(:zones).value.should == 4
-      end
-      it 'stops resolving a value for a zone that no longer exists' do
-        given_initial_zone_facts
-        when_facts_have_been_resolved_then_flushed
-
-        Facter.fact(:zone_zoneA_id).value.should be_nil
-        Facter.fact(:zone_zoneA_status).value.should be_nil
-        Facter.fact(:zone_zoneA_path).value.should be_nil
-      end
-      it 'defines facts for new zones' do
-        given_initial_zone_facts
-        when_facts_have_been_resolved_then_flushed
-
-        Facter.fact(:zone_zoneB_id).should be_nil
-        Facter.fact(:zones).value
-        Facter.fact(:zone_zoneB_id).value.should be_a_kind_of String
-      end
-      it 'uses a single read of the system information for all of the dynamically generated zone facts' do
-        given_initial_zone_facts
-        when_facts_have_been_resolved_then_flushed
-
-        Facter::Core::Execution.expects(:execute).once.returns(zone_list2)
-        Facter.fact(:zones).value
-        Facter.fact(:zone_zoneA_id).value
-        Facter.fact(:zone_local_id).value
-      end
-
-    end
-  end
-
-  def given_initial_zone_facts
-    Facter::Core::Execution.stubs(:execute).
-      with(subject.zoneadm_cmd, {:on_fail => nil}).
-      returns(zone_list)
-    described_class.add_facts
-  end
-
-  def when_facts_have_been_resolved_then_flushed
-    Facter.fact(:zones).value
-    Facter.fact(:zone_zoneA_id).value
-    Facter.fact(:zone_local_id).value
-    Facter::Core::Execution.stubs(:execute).returns(zone_list2)
-    Facter.flush
-  end
-end

data/spec/unit/util/uptime_spec.rb

@@ -1,131 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/uptime'
-require 'facter/util/posix'
-
-describe Facter::Util::Uptime do
-
-  describe ".get_uptime_seconds_unix", :unless => Facter::Util::Config.is_windows? do
-    describe "when /proc/uptime is available" do
-      before do
-        uptime_file = my_fixture("ubuntu_proc_uptime")
-        Facter::Util::Uptime.stubs(:uptime_file).returns("\"#{uptime_file}\"")
-      end
-
-      it "should return the uptime in seconds as an integer" do
-        Facter::Util::Uptime.get_uptime_seconds_unix.should == 5097686
-      end
-
-    end
-
-    describe "when /proc/uptime is not available" do
-      before :each do
-        @nonexistent_file = '/non/existent/file'
-        File.exists?(@nonexistent_file).should == false
-        Facter::Util::Uptime.stubs(:uptime_file).returns(@nonexistent_file)
-      end
-
-      it "should use 'sysctl -n kern.boottime' on OpenBSD" do
-        Facter::Util::POSIX.stubs(:sysctl).returns(my_fixture_read("sysctl_kern_boottime_openbsd"))
-        Time.stubs(:now).returns Time.utc(2011,12,9,22,11,46) # one hour later
-        Facter::Util::Uptime.get_uptime_seconds_unix.should == 60 * 60
-      end
-
-      it "should use 'sysctl -n kern.boottime' on Darwin, etc." do
-        Facter::Util::POSIX.stubs(:sysctl).returns(my_fixture_read("sysctl_kern_boottime_darwin"))
-        Time.stubs(:now).returns Time.utc(2011,10,30,22,52,27) # one hour later
-        Facter::Util::Uptime.get_uptime_seconds_unix.should == 60 * 60
-      end
-
-      describe "nor is 'sysctl kern.boottime'" do
-        before :each do
-          Facter::Util::Uptime.stubs(:uptime_proc_uptime).returns(false)
-          Facter::Util::Uptime.stubs(:uptime_sysctl).returns(false)
-          Facter.fact(:kernel).stubs(:value).returns('SunOS')
-        end
-
-        describe "should use 'uptime' command" do
-          # Note about uptime variations.
-          # Solaris (I have examined 5.6, 5.7, 5.8, 5.9, 5.10 & 5.11) and HP-UX (11.00, 11.11, 11.23, 11.31) have time
-          #   right justified at at 8 characters, and two spaces before 'up'.
-          # Solaris differs from all other Unices (and Linux) in that the plural/singular case of minutes/hours/days are
-          #   written min(s)/hr(s)/day(s) instead of min/mins/hr/hrs etc., e.g. 1 min(s), 2 min(s) as opposed to
-          #   1 min, 2 mins, etc.
-          # The coreutils package can be installed in Solaris, which brings in a GNU version of uptime. The output
-          #   from this binary differs in that is is missing the comma after "day(s)"
-          # Some versions of uptime in Solaris may also include a '-' character in the minutes field.
-          # AIX (4.3.3, 5.2, 5.3, 6.1) differs from other SysV Unices in that times are padded with a leading 0 in the
-          #   hour column where necessary, and have AM/PM in uppercase, and there are three spaces before 'up'.
-          # Tru64 (4.0, 5.1) differs from other SysV Unices in that times are in 24 hour format, and there are no
-          #   leading spaces.
-          # Linux (RHEL, uptime version 2.0.7) differs from the SysV Unices in that only minutes before the first hour
-          #   are written as 1 min, 2 min, 3 min etc. and after that full hours are rendered 1:00 or 21:00.  Time of
-          #   day was written 5:37pm and right-justified at 8 characters, with 2 spaces before 'up'.  A figure in
-          #   whole days was written as 3 days, 0 min.
-          # By version 2.0.17 the time of day was rewritten in 24hr time with seconds, right-justified at 9 characters.
-          # By version 3.2.7 one of the spaces before 'up' had been removed.
-          test_cases = [
-            ['  4:42pm  up 1 min(s),  0 users,  load average: 0.95, 0.25, 0.09',                                         1*60],
-            ['13:16  up 58 mins,  2 users,  load average: 0.00, 0.02, 0.05',                                            58*60],
-            ['13:18  up 1 hr,  1 user,  load average: 0.58, 0.23, 0.14',                                      1*60*60        ],
-            [' 10:14pm  up 3 hr(s),  0 users,  load average: 0.00, 0.00, 0.00',                               3*60*60        ],
-            ['14:18  up 2 hrs,  0 users,  load average: 0.33, 0.27, 0.29',                                    2*60*60        ],
-            ['  9:01pm  up  1:47,  0 users,  load average: 0.00, 0.00, 0.00',                                 1*60*60 + 47*60],
-            ['13:19  up  1:01,  1 user,  load average: 0.10, 0.26, 0.21',                                     1*60*60 +  1*60],
-            ['10:49  up 22:31,  0 users,  load average: 0.26, 0.34, 0.27',                                   22*60*60 + 31*60],
-            ['12:18  up 1 day,  0 users,  load average: 0.74, 0.20, 0.10',                      1*24*60*60                   ],
-            ['  2:48pm  up 1 day(s),  0 users,  load average: 0.21, 0.20, 0.17',                1*24*60*60                   ],
-            ['12:18  up 2 days,  0 users,  load average: 0.50, 0.27, 0.16',                     2*24*60*60                   ],
-            ['  1:56pm  up 25 day(s),  2 users,  load average: 0.59, 0.56, 0.50',              25*24*60*60                   ],
-            ['  1:29pm  up 485 days,  0 users,  load average: 0.00, 0.01, 0.01',              485*24*60*60                   ],
-            [' 18:11:24  up 69 days, 0 min,  0 users,  load average: 0.00, 0.00, 0.00',        69*24*60*60                   ],
-            ['12:19  up 1 day, 1 min,  0 users,  load average: 0.07, 0.16, 0.13',               1*24*60*60            +  1*60],
-            ['  3:23pm  up 25 day(s), 27 min(s),  2 users,  load average: 0.49, 0.45, 0.46',   25*24*60*60            + 27*60],
-            ['  02:42PM   up 1 day, 39 mins,  0 users,  load average: 1.49, 1.74, 1.80',        1*24*60*60            + 39*60],
-            [' 18:13:13  up 245 days, 44 min,  1 user,  load average: 0.00, 0.00, 0.00',      245*24*60*60            + 44*60],
-            ['  6:09pm  up 350 days, 2 min,  1 user,  load average: 0.02, 0.03, 0.00',        350*24*60*60            +  2*60],
-            ['  1:07pm  up 174 day(s), 16 hr(s),  0 users,  load average: 0.05, 0.04, 0.03',  174*24*60*60 + 16*60*60        ],
-            ['  02:34PM   up 621 days, 18 hrs,  0 users,  load average: 2.67, 2.52, 2.56',    621*24*60*60 + 18*60*60        ],
-            ['  3:30am  up 108 days, 1 hr,  31 users,  load average: 0.39, 0.40, 0.41',       108*24*60*60 +  1*60*60        ],
-            ['13:18  up 1 day, 1 hr,  0 users,  load average: 0.78, 0.33, 0.18',                1*24*60*60 +  1*60*60        ],
-            ['14:18  up 1 day, 2 hrs,  0 users,  load average: 1.17, 0.48, 0.41',               1*24*60*60 +  2*60*60        ],
-            ['15:56  up 152 days, 17 hrs,  0 users,  load average: 0.01, 0.06, 0.07',         152*24*60*60 + 17*60*60        ],
-            ['  5:37pm  up 25 days, 21:00,  0 users,  load average: 0.01, 0.02, 0.00',         25*24*60*60 + 21*60*60        ],
-            ['  8:59pm  up 94 day(s),  3:17,  46 users,  load average: 0.66, 0.67, 0.70',      94*24*60*60 +  3*60*60 + 17*60],
-            ['  3:01pm  up 4496 day(s), 21:19,  32 users,  load average: 0.61, 0.62, 0.62',  4496*24*60*60 + 21*60*60 + 19*60],
-            ['  02:42PM   up 41 days,   2:38,  0 users,  load average: 0.38, 0.70, 0.55',      41*24*60*60 +  2*60*60 + 38*60],
-            [' 18:13:29  up 25 days, 21:36,  0 users,  load average: 0.00, 0.00, 0.00',        25*24*60*60 + 21*60*60 + 36*60],
-            [' 13:36:05 up 118 days,  1:15,  1 user,  load average: 0.00, 0.00, 0.00',        118*24*60*60 +  1*60*60 + 15*60],
-            ['10:27am  up 1 day  7:26,  1 user,  load average: 0.00, 0.00, 0.00',               1*24*60*60 +  7*60*60 + 26*60],
-            ['22:45pm up 0:-6, 1 user, load average: 0.00, 0.00, 0.00',                                                  6*60],
-            ['22:45pm up 1 day 0:-6, 1 user, load average: 0.00, 0.00, 0.00',                   1*24*60*60 +             6*60]
-          ]
-
-          test_cases.each do |uptime, expected|
-            it "should return #{expected} for #{uptime}" do
-              Facter::Core::Execution.stubs(:execute).with('uptime 2>/dev/null', {:on_fail => nil}).returns(uptime)
-              Facter.fact(:uptime_seconds).value.should == expected
-            end
-          end
-
-          describe "nor is 'uptime' command" do
-            before :each do
-              Facter::Core::Execution.stubs(:execute).with('uptime 2>/dev/null', {:on_fail => nil}).returns(nil)
-            end
-
-            it "should return nil" do
-              Facter::Util::Uptime.get_uptime_seconds_unix.should == nil
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe ".get_uptime_seconds_win", :if => Facter::Util::Config.is_windows? do
-    it "should return a postive value" do
-      Facter::Util::Uptime.get_uptime_seconds_win.should > 0
-    end
-  end
-end

data/spec/unit/util/values_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-require 'facter/util/values'
-
-describe Facter::Util::Values do
-  describe 'deep_freeze' do
-    it "it dups and freezes strings" do
-      input = "hi"
-      output = described_class.deep_freeze(input)
-      expect(input).to_not be_frozen
-      expect(output).to be_frozen
-    end
-
-    it "freezes arrays and each element in the array" do
-      input = %w[one two three]
-      output = described_class.deep_freeze(input)
-
-      input.each { |entry| expect(entry).to_not be_frozen }
-      output.each { |entry| expect(entry).to be_frozen }
-
-      expect(input).to_not be_frozen
-      expect(output).to be_frozen
-    end
-
-    it "freezes hashes and each key and value in the hash" do
-      input = {'one' => 'two', 'three' => 'four'}
-
-      output = described_class.deep_freeze(input)
-
-      input.each_pair do |key, val|
-        # Ruby freezes all string keys, so these will always be frozen
-        expect(key).to be_frozen
-        expect(val).to_not be_frozen
-      end
-
-      output.each_pair do |key, val|
-        expect(key).to be_frozen
-        expect(val).to be_frozen
-      end
-
-      expect(input).to_not be_frozen
-      expect(output).to be_frozen
-    end
-
-    it "raises an error when given a structure that cannot be deeply frozen" do
-      expect {
-        described_class.deep_freeze(Set.new)
-      }.to raise_error(Facter::Util::Values::DeepFreezeError, /Cannot deep freeze.*Set/)
-    end
-  end
-
-  describe 'deep_merge' do
-    it "non-destructively concatenates arrays" do
-      first = %w[foo bar]
-      second = %w[baz quux]
-
-      expect(described_class.deep_merge(first, second)).to eq %w[foo bar baz quux]
-      expect(first).to eq %w[foo bar]
-      expect(second).to eq %w[baz quux]
-    end
-
-    it "returns the left value if the right value is nil" do
-      expect(described_class.deep_merge("left", nil)).to eq "left"
-    end
-
-    it "returns the right value if the left value is nil" do
-      expect(described_class.deep_merge(nil, "right")).to eq "right"
-    end
-
-    it "returns nil if both values are nil" do
-      expect(described_class.deep_merge(nil, nil)).to be_nil
-    end
-
-    describe "with hashes" do
-      it "merges when keys do not overlap" do
-
-        first = {:foo => 'bar'}
-        second = {:baz => 'quux'}
-
-        expect(described_class.deep_merge(first, second)).to eq(:foo => 'bar', :baz => 'quux')
-        expect(first).to eq(:foo => 'bar')
-        expect(second).to eq(:baz => 'quux')
-      end
-
-      it "concatenates arrays when both keys are arrays" do
-        first = {:foo => %w[bar]}
-        second = {:foo => %w[baz quux]}
-
-        expect(described_class.deep_merge(first, second)).to eq(:foo => %w[bar baz quux])
-        expect(first).to eq(:foo => %w[bar])
-        expect(second).to eq(:foo => %w[baz quux])
-      end
-
-      it "merges hashes when both keys are hashes" do
-        first = {:foo => {:pb => 'lead', :ag => 'silver'}}
-        second = {:foo => {:au => 'gold', :na => 'sodium'}}
-
-        expect(described_class.deep_merge(first, second)).to eq(
-          :foo => {
-            :pb => 'lead',
-            :ag => 'silver',
-            :au => 'gold',
-            :na => 'sodium'
-          }
-        )
-      end
-
-      it "prints the data structure path if an error is raised" do
-        first = {:foo => {:bar => {:baz => {:quux => true}}}}
-        second = {:foo => {:bar => {:baz => {:quux => false}}}}
-
-        expect {
-          described_class.deep_merge(first, second)
-        }.to raise_error(Facter::Util::Values::DeepMergeError, /Cannot merge .*at .*foo.*bar.*baz.*quux/)
-      end
-    end
-
-    describe "with unmergable scalar values" do
-      [
-        [true, false],
-        [1, 2],
-        ['up', 'down']
-      ].each do |(left, right)|
-        it "raises an error when merging #{left}:#{left.class} and #{right}:#{right.class}" do
-          expect {
-            described_class.deep_merge(left, right)
-          }.to raise_error(Facter::Util::Values::DeepMergeError, /Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}/)
-        end
-      end
-    end
-  end
-
-  describe "flatten_structure" do
-    it "converts a string to a hash containing that string" do
-      input = "foo"
-      output = described_class.flatten_structure("path", input)
-      expect(output).to eq({"path" => "foo"})
-    end
-
-    it "converts an array to a hash with the array elements with indexes" do
-      input = ["foo"]
-      output = described_class.flatten_structure("path", input)
-      expect(output).to eq({"path_0" => "foo"})
-    end
-
-    it "prefixes a non-nested hash with the given path" do
-      input = {"foo" => "bar"}
-      output = described_class.flatten_structure("path", input)
-      expect(output).to eq({"path_foo" => "bar"})
-    end
-
-    it "flattens elements till it reaches the first non-flattenable structure" do
-      input = {
-        "first" => "second",
-        "arr" => ["zero", "one"],
-        "nested_array" => [
-          "hash" => "string",
-        ],
-        "top" => {"middle" => ['bottom']},
-      }
-      output = described_class.flatten_structure("path", input)
-
-      expect(output).to eq({
-        "path_first" => "second",
-        "path_arr_0" => "zero",
-        "path_arr_1" => "one",
-        "path_nested_array_0_hash" => "string",
-        "path_top_middle_0" => "bottom"
-      })
-    end
-  end
-end

data/spec/unit/util/virtual_spec.rb

@@ -1,393 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/virtual'
-require 'stringio'
-
-describe Facter::Util::Virtual do
-
-  after do
-    Facter.clear
-  end
-  it "should detect openvz" do
-    FileTest.stubs(:directory?).with("/proc/vz").returns(true)
-    Dir.stubs(:glob).with("/proc/vz/*").returns(['vzquota'])
-    Facter::Util::Virtual.should be_openvz
-  end
-
-  it "should not detect openvz when /proc/lve/list is present" do
-    FileTest.stubs(:file?).with("/proc/lve/list").returns(true)
-    Facter::Util::Virtual.should_not be_openvz
-  end
-
-  it "should not detect openvz when /proc/vz/ is empty" do
-    FileTest.stubs(:file?).with("/proc/lve/list").returns(false)
-    FileTest.stubs(:directory?).with("/proc/vz").returns(true)
-    Dir.stubs(:glob).with("/proc/vz/*").returns([])
-    Facter::Util::Virtual.should_not be_openvz
-  end
-
-  it "should identify openvzhn when /proc/self/status has envID of 0" do
-    Facter::Util::Virtual.stubs(:openvz?).returns(true)
-    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
-    Facter::Core::Execution.stubs(:exec).with('grep "envID" /proc/self/status').returns("envID:  0")
-    Facter::Util::Virtual.openvz_type().should == "openvzhn"
-  end
-
-  it "should identify openvzve when /proc/self/status has envID of 0" do
-    Facter::Util::Virtual.stubs(:openvz?).returns(true)
-    FileTest.stubs(:exists?).with('/proc/self/status').returns(true)
-    Facter::Core::Execution.stubs(:exec).with('grep "envID" /proc/self/status').returns("envID:  666")
-    Facter::Util::Virtual.openvz_type().should == "openvzve"
-  end
-
-  it "should not attempt to identify openvz when /proc/self/status has no envID" do
-    Facter::Util::Virtual.stubs(:openvz?).returns(true)
-    FileTest.stubs(:exists?).with('/proc/self/status').returns(true)
-    Facter::Core::Execution.stubs(:exec).with('grep "envID" /proc/self/status').returns("")
-    Facter::Util::Virtual.openvz_type().should be_nil
-  end
-
-  it "should identify Solaris zones when non-global zone" do
-    Facter::Core::Execution.stubs(:exec).with("/sbin/zonename").returns("somezone")
-    Facter::Util::Virtual.should be_zone
-  end
-
-  it "should not identify Solaris zones when global zone" do
-    Facter::Core::Execution.stubs(:exec).with("/sbin/zonename").returns("global")
-    Facter::Util::Virtual.should_not be_zone
-  end
-
-  it "(#14522) handles the unencoded binary data in /proc/self/status on Solaris" do
-    Facter.fact(:osfamily).stubs(:value).returns("Solaris")
-    File.stubs(:open).with('/proc/self/status', 'rb').returns(solaris_proc_self_status)
-    FileTest.stubs(:exists?).with('/proc/self/status').returns(true)
-
-    Facter::Util::Virtual.vserver?.should eq(false)
-  end
-
-  it "should not detect vserver if no self status" do
-    FileTest.stubs(:exists?).with("/proc/self/status").returns(false)
-    Facter::Util::Virtual.should_not be_vserver
-  end
-
-  it "should detect vserver when vxid present in process status" do
-    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
-    File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new("VxID: 42\n"))
-    Facter::Util::Virtual.should be_vserver
-  end
-
-  it "should detect vserver when s_context present in process status" do
-    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
-    File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new("s_context: 42\n"))
-    Facter::Util::Virtual.should be_vserver
-  end
-
-  it "should not detect vserver when vserver flags not present in process status" do
-    FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
-    File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new("wibble: 42\n"))
-    Facter::Util::Virtual.should_not be_vserver
-  end
-
-  it "should identify kvm" do
-    Facter::Util::Virtual.stubs(:kvm?).returns(true)
-    Facter::Core::Execution.stubs(:exec).with('dmidecode 2> /dev/null').returns("something")
-    Facter::Util::Virtual.kvm_type().should == "kvm"
-  end
-
-  it "should be able to detect RHEV via sysfs on Linux" do
-    # Fake files are always hard to stub. :/
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
-      returns("RHEV Hypervisor")
-
-    Facter::Util::Virtual.should be_rhev
-  end
-
-  it "should be able to detect RHEV via sysfs on Linux improperly" do
-    # Fake files are always hard to stub. :/
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
-      returns("something else")
-
-    Facter::Util::Virtual.should_not be_rhev
-  end
-
-  it "should be able to detect ovirt via sysfs on Linux" do
-    # Fake files are always hard to stub. :/
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
-      returns("oVirt Node")
-
-    Facter::Util::Virtual.should be_ovirt
-  end
-
-  it "should be able to detect ovirt via sysfs on Linux improperly" do
-    # Fake files are always hard to stub. :/
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
-      returns("something else")
-
-    Facter::Util::Virtual.should_not be_ovirt
-  end
-
-  it "detects GCE if the DMI product name is Google" do
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").returns("Google")
-    expect(Facter::Util::Virtual.gce?).to be_true
-  end
-
-  it "does not detect GCE if the DMI product name is not Google" do
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").returns('')
-    expect(Facter::Util::Virtual.gce?).to be_false
-  end
-
-  fixture_path = fixtures('virtual', 'proc_self_status')
-
-  test_cases = [
-    [File.join(fixture_path, 'vserver_2_1', 'guest'), true, 'vserver 2.1 guest'],
-    [File.join(fixture_path, 'vserver_2_1', 'host'),  true, 'vserver 2.1 host'],
-    [File.join(fixture_path, 'vserver_2_3', 'guest'), true, 'vserver 2.3 guest'],
-    [File.join(fixture_path, 'vserver_2_3', 'host'),  true, 'vserver 2.3 host']
-  ]
-
-  test_cases.each do |status_file, expected, description|
-    describe "with /proc/self/status from #{description}" do
-      it "should detect vserver as #{expected.inspect}" do
-        status = File.read(status_file)
-        FileTest.stubs(:exists?).with("/proc/self/status").returns(true)
-        File.stubs(:open).with("/proc/self/status", "rb").returns(StringIO.new(status))
-        Facter::Util::Virtual.vserver?.should == expected
-      end
-    end
-  end
-
-  it "reads dmi entries as ascii data" do
-    entries_file = my_fixture('invalid_unicode_dmi_entries')
-    expected_contents = 'Virtual'
-
-    entries = Facter::Util::Virtual.read_sysfs_dmi_entries(entries_file)
-
-    entries.should =~ /#{expected_contents}/
-  end
-
-  it "should identify vserver_host when /proc/virtual exists" do
-    Facter::Util::Virtual.expects(:vserver?).returns(true)
-    FileTest.stubs(:exists?).with("/proc/virtual").returns(true)
-    Facter::Util::Virtual.vserver_type().should == "vserver_host"
-  end
-
-  it "should identify vserver_type as vserver when /proc/virtual does not exist" do
-    Facter::Util::Virtual.expects(:vserver?).returns(true)
-    FileTest.stubs(:exists?).with("/proc/virtual").returns(false)
-    Facter::Util::Virtual.vserver_type().should == "vserver"
-  end
-
-  it "should detect xen when /proc/sys/xen exists" do
-    FileTest.expects(:exists?).with("/proc/sys/xen").returns(true)
-    Facter::Util::Virtual.should be_xen
-  end
-
-  it "should detect xen when /sys/bus/xen exists" do
-    FileTest.expects(:exists?).with("/proc/sys/xen").returns(false)
-    FileTest.expects(:exists?).with("/sys/bus/xen").returns(true)
-    Facter::Util::Virtual.should be_xen
-  end
-
-  it "should detect xen when /proc/xen exists" do
-    FileTest.expects(:exists?).with("/proc/sys/xen").returns(false)
-    FileTest.expects(:exists?).with("/sys/bus/xen").returns(false)
-    FileTest.expects(:exists?).with("/proc/xen").returns(true)
-    Facter::Util::Virtual.should be_xen
-  end
-
-  it "should not detect xen when no sysfs/proc xen directories exist" do
-    FileTest.expects(:exists?).with("/proc/sys/xen").returns(false)
-    FileTest.expects(:exists?).with("/sys/bus/xen").returns(false)
-    FileTest.expects(:exists?).with("/proc/xen").returns(false)
-    Facter::Util::Virtual.should_not be_xen
-  end
-
-  it "should detect kvm" do
-    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(true)
-    File.stubs(:read).with("/proc/cpuinfo").returns("model name : QEMU Virtual CPU version 0.9.1\n")
-    Facter::Util::Virtual.should be_kvm
-  end
-
-  it "should detect kvm on FreeBSD" do
-    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(false)
-    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
-    Facter::Util::POSIX.stubs(:sysctl).with("hw.model").returns("QEMU Virtual CPU version 0.12.4")
-    Facter::Util::Virtual.should be_kvm
-  end
-
-  it "should detect kvm on OpenBSD" do
-    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(false)
-    Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
-    Facter::Util::POSIX.stubs(:sysctl).with("hw.model").returns('QEMU Virtual CPU version (cpu64-rhel6) ("AuthenticAMD" 686-class, 512KB L2 cache)')
-    Facter::Util::Virtual.should be_kvm
-  end
-
-  it "should detect kvm on SunOS" do
-    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(false)
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-    FileTest.stubs(:exists?).with("/usr/sbin/prtconf").returns(true)
-    Facter::Core::Execution.stubs(:exec).with("/usr/sbin/prtconf -v").returns("Qemu virtual machine")
-    Facter::Util::Virtual.should be_kvm
-  end
-
-  it "should identify FreeBSD jail when in jail" do
-    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
-    Facter::Core::Execution.stubs(:exec).with("/sbin/sysctl -n security.jail.jailed").returns("1")
-    Facter::Util::Virtual.should be_jail
-  end
-
-  it "should not identify GNU/kFreeBSD jail when not in jail" do
-    Facter.fact(:kernel).stubs(:value).returns("GNU/kFreeBSD")
-    Facter::Core::Execution.stubs(:exec).with("/bin/sysctl -n security.jail.jailed").returns("0")
-    Facter::Util::Virtual.should_not be_jail
-  end
-
-  it "should detect hpvm on HP-UX" do
-    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
-    Facter::Core::Execution.stubs(:exec).with("/usr/bin/getconf MACHINE_MODEL").returns('ia64 hp server Integrity Virtual Machine')
-    Facter::Util::Virtual.should be_hpvm
-  end
-
-  it "should not detect hpvm on HP-UX when not in hpvm" do
-    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
-    Facter::Core::Execution.stubs(:exec).with("/usr/bin/getconf MACHINE_MODEL").returns('ia64 hp server rx660')
-    Facter::Util::Virtual.should_not be_hpvm
-  end
-
-  it "should be able to detect virtualbox via sysfs on Linux" do
-    # Fake files are always hard to stub. :/
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
-      returns("VirtualBox")
-
-    Facter::Util::Virtual.should be_virtualbox
-  end
-
-  it "should be able to detect virtualbox via sysfs on Linux improperly" do
-    # Fake files are always hard to stub. :/
-    File.stubs(:read).with("/sys/devices/virtual/dmi/id/product_name").
-      returns("HP-Oracle-Sun-VMWare-funky-town")
-
-    Facter::Util::Virtual.should_not be_virtualbox
-  end
-
-  let :solaris_proc_self_status do
-    sample_data = my_fixture_read('solaris10_proc_self_status1')
-    mockfile = mock('File')
-    mockfile.stubs(:read).returns(sample_data)
-    mockfile
-  end
-
-  shared_examples_for "virt-what" do |kernel, path, null_device, override_location|
-    before(:each) do
-      Facter.fact(:kernel).stubs(:value).returns(kernel)
-      if override_location
-        Facter::Core::Execution.expects(:which).with(File.join(Facter::Util::Config.override_binary_dir, "virt-what")).returns(path)
-      else
-        Facter::Core::Execution.expects(:which).with(File.join(Facter::Util::Config.override_binary_dir, "virt-what")).returns(nil)
-        Facter::Core::Execution.expects(:which).with("virt-what").returns(path)
-      end
-      Facter::Core::Execution.expects(:exec).with("#{path} 2>#{null_device}")
-    end
-
-    it "on #{kernel} virt-what is at #{path} and stderr is sent to #{null_device}" do
-      Facter::Util::Virtual.virt_what
-    end
-  end
-
-  context "on linux" do
-    describe "override binary dir doesn't exist" do
-      it_should_behave_like "virt-what", "linux", "/usr/bin/virt-what", "/dev/null", true
-      it_should_behave_like "virt-what", "linux", "/usr/bin/virt-what", "/dev/null", false
-
-      it "should strip out warnings on stdout from virt-what" do
-        virt_what_warning = "virt-what: this script must be run as root"
-        Facter.fact(:kernel).stubs(:value).returns('linux')
-        Facter::Core::Execution.expects(:which).with(File.join(Facter::Util::Config.override_binary_dir, "virt-what")).returns(nil)
-        Facter::Core::Execution.expects(:which).with('virt-what').returns "/usr/bin/virt-what"
-        Facter::Core::Execution.expects(:exec).with('/usr/bin/virt-what 2>/dev/null').returns virt_what_warning
-        Facter::Util::Virtual.virt_what.should_not match /^virt-what: /
-      end
-    end
-  end
-
-  context "on unix" do
-    it_should_behave_like "virt-what", "unix", "/usr/bin/virt-what", "/dev/null", true
-    it_should_behave_like "virt-what", "unix", "/usr/bin/virt-what", "/dev/null", false
-  end
-
-  context "on windows" do
-    it_should_behave_like "virt-what", "windows", 'c:\windows\system32\virt-what', "NUL", false
-  end
-
-  describe '.lxc?' do
-    subject do
-      Facter::Util::Virtual.lxc?
-    end
-
-    fixture_path = fixtures('virtual', 'proc_1_cgroup')
-
-    context '/proc/1/cgroup has at least one hierarchy rooted in /lxc/' do
-      before :each do
-        fakepath = Pathname.new(File.join(fixture_path, 'in_a_container'))
-        Pathname.stubs(:new).with('/proc/1/cgroup').returns(fakepath)
-      end
-
-      it 'is true' do
-        subject.should be_true
-      end
-    end
-
-    context '/proc/1/cgroup has no hierarchies rooted in /lxc/' do
-      before :each do
-        fakepath = Pathname.new(File.join(fixture_path, 'not_in_a_container'))
-        Pathname.stubs(:new).with('/proc/1/cgroup').returns(fakepath)
-      end
-
-      it 'is false' do
-        subject.should be_false
-      end
-    end
-  end
-
-  describe '.docker?' do
-    subject do
-      Facter::Util::Virtual.docker?
-    end
-
-    fixture_path = fixtures('virtual', 'proc_1_cgroup')
-
-    context '/proc/1/cgroup has at least one hierarchy rooted in /docker/' do
-      before :each do
-        fakepath = Pathname.new(File.join(fixture_path, 'in_a_docker_container'))
-        Pathname.stubs(:new).with('/proc/1/cgroup').returns(fakepath)
-      end
-
-      it 'is true' do
-        subject.should be_true
-      end
-    end
-
-    context '/proc/1/cgroup has at least one hierarchy with docker underneath a systemd slice parent' do
-      before :each do
-        fakepath = Pathname.new(File.join(fixture_path, 'in_a_docker_container_with_systemd_slices'))
-        Pathname.stubs(:new).with('/proc/1/cgroup').returns(fakepath)
-      end
-
-      it 'is true' do
-        subject.should be_true
-      end
-    end
-
-    context '/proc/1/cgroup has no hierarchies rooted in /docker/' do
-      before :each do
-        fakepath = Pathname.new(File.join(fixture_path, 'not_in_a_container'))
-        Pathname.stubs(:new).with('/proc/1/cgroup').returns(fakepath)
-      end
-
-      it 'is false' do
-        subject.should be_false
-      end
-    end
-  end
-end