facter 2.1.0-x86-mingw32 → 2.2.0-x86-mingw32

data/spec/unit/lsbmajdistrelease_spec.rb

@@ -1,13 +1,30 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
-require 'facter'
 
 describe "LSB distribution major release fact" do
-    it "should be derived from lsb_release" do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        Facter.stubs(:value).with(:lsbdistrelease).returns("10.10")
+  let(:os_hash) { { "name"          => "SomeOS",
+                    "family"        => "SomeFamily",
+                    "release"       => {
+                      "major" => "1",
+                      "minor" => "2",
+                      "full"  => "1.2.3"
+                    },
+                    "lsb"           => {
+                       "distcodename"     => "SomeCodeName",
+                       "distid"           => "SomeID",
+                       "distdescription"  => "SomeDesc",
+                       "distrelease"      => "1.2.3",
+                       "release"          => "1.2.3",
+                       "majdistrelease"   => "1",
+                       "minordistrelease" => "2"
+                    },
+                  }
+                }
 
-        Facter.fact(:lsbmajdistrelease).value.should == "10"
-    end
+  it "should use the 'minordistrelease' key of the 'os' fact" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.fact("os").stubs(:value).returns(os_hash)
+    Facter.fact(:lsbminordistrelease).value.should eq "2"
+  end
 end

data/spec/unit/lsbminordistrelease_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "LSB distribution major release fact" do
+  let(:os_hash) { { "name"          => "SomeOS",
+                    "family"        => "SomeFamily",
+                    "release"       => {
+                      "major" => "1",
+                      "minor" => "2",
+                      "full"  => "1.2.3"
+                    },
+                    "lsb"           => {
+                       "distcodename"     => "SomeCodeName",
+                       "distid"           => "SomeID",
+                       "distdescription"  => "SomeDesc",
+                       "distrelease"      => "1.2.3",
+                       "release"          => "1.2.3",
+                       "majdistrelease"   => "1",
+                       "minordistrelease" => "2"
+                    },
+                  }
+                }
+
+  it "should use the 'majdistrelease' key of the 'os' fact" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.fact("os").stubs(:value).returns(os_hash)
+    Facter.fact(:lsbmajdistrelease).value.should eq "1"
+  end
+end

data/spec/unit/lsbrelease_spec.rb

@@ -3,23 +3,28 @@
 require 'spec_helper'
 
 describe "lsbrelease fact" do
+  let(:os_hash) { { "name"          => "SomeOS",
+                    "family"        => "SomeFamily",
+                    "release"       => {
+                      "major" => "1",
+                      "minor" => "2",
+                      "full"  => "1.2.3"
+                    },
+                    "lsb"           => {
+                       "distcodename"      => "SomeCodeName",
+                       "distid"            => "SomeID",
+                       "distdescription"   => "SomeDesc",
+                       "distrelease"       => "1.2.3",
+                       "release"           => "1.2.3",
+                       "majdistrelease"    => "1",
+                       "minordistrelease"  => "2"
+                    },
+                  }
+                }
 
-  [ "Linux", "GNU/kFreeBSD"].each do |kernel|
-    describe "on #{kernel}" do
-      before :each do
-        Facter.fact(:kernel).stubs(:value).returns kernel
-      end
-
-      it "returns the release through lsb_release -v -s 2>/dev/null" do
-        Facter::Core::Execution.impl.stubs(:execute).with('lsb_release -v -s 2>/dev/null', anything).returns 'n/a'
-        expect(Facter.fact(:lsbrelease).value).to eq 'n/a'
-      end
-
-      it "returns nil if lsb_release is not installed" do
-        Facter::Core::Execution.impl.stubs(:expand_command).with('lsb_release -v -s 2>/dev/null').returns nil
-        expect(Facter.fact(:lsbrelease).value).to be_nil
-      end
-    end
+  it "should use the 'distrelease' key from the 'os' fact" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.fact("os").stubs(:value).returns(os_hash)
+    Facter.fact(:lsbrelease).value.should eq "1.2.3"
   end
-
 end

data/spec/unit/macaddress_spec.rb

@@ -50,6 +50,7 @@ describe "macaddress fact" do
   describe "when run on BSD" do
     it "should return macaddress information" do
       Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+      Facter.fact(:operatingsystem).stubs(:value).returns("FreeBSD")
       Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
       Facter::Util::IP.stubs(:exec_ifconfig).
         returns(ifconfig_fixture('bsd_ifconfig_all_with_multiple_interfaces'))
@@ -61,6 +62,8 @@ describe "macaddress fact" do
   describe "when run on OpenBSD with bridge(4) rules" do
     it "should return macaddress information" do
       Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
+      Facter.fact(:operatingsystem).stubs(:value).returns("OpenBSD")
+      Facter.fact(:osfamily).stubs(:value).returns("OpenBSD")
       Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
       Facter::Util::IP.stubs(:exec_ifconfig).
         returns(ifconfig_fixture('openbsd_bridge_rules'))

data/spec/unit/operatingsystem/base_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'facter/operatingsystem/base'
+
+describe Facter::Operatingsystem::Base do
+  subject { described_class.new }
+
+  before :each do
+    Facter.fact(:kernel).stubs(:value).returns("Nutmeg")
+  end
+
+  describe "Operating system fact" do
+    it "should default to the kernel name" do
+      os = subject.get_operatingsystem
+      expect(os).to eq "Nutmeg"
+    end
+  end
+
+  describe "Osfamily fact" do
+    it "should default to the kernel name" do
+      osfamily = subject.get_osfamily
+      expect(osfamily).to eq "Nutmeg"
+    end
+  end
+
+  describe "Operatingsystemrelease fact" do
+    it "should return the kernel fact by default" do
+      Facter.fact(:kernelrelease).stubs(:value).returns("1.2.3")
+      operatingsystemrelease = subject.get_operatingsystemrelease
+      expect(operatingsystemrelease).to eq "1.2.3"
+    end
+  end
+
+  describe "Operatingsystemmajrelease fact" do
+    it "should base major release on release fact if available" do
+      subject.expects(:get_operatingsystemrelease).returns("1.2.3")
+      operatingsystemmajrelease = subject.get_operatingsystemmajorrelease
+      expect(operatingsystemmajrelease).to eq "1"
+    end
+
+    it "should return nil if release fact not available" do
+      subject.expects(:get_operatingsystemrelease).returns(nil)
+      operatingsystemmajrelease = subject.get_operatingsystemmajorrelease
+      expect(operatingsystemmajrelease).to be_nil
+    end
+  end
+
+  describe "Operatingsystemminorrelease" do
+    it "should base minor release on release fact if available" do
+      subject.expects(:get_operatingsystemrelease).returns("1.2.3")
+      operatingsystemminorrelease = subject.get_operatingsystemminorrelease
+      expect(operatingsystemminorrelease).to eq "2"
+    end
+
+    it "should strip off the patch release if appended with a '-'" do
+      subject.stubs(:get_operatingsystem).returns("FreeBSD")
+      subject.expects(:get_operatingsystemrelease).returns("10.0-RELEASE")
+      release = subject.get_operatingsystemminorrelease
+      expect(release).to eq "0"
+    end
+
+    it "should return nil if release fact not available" do
+      subject.expects(:get_operatingsystemrelease).returns(nil)
+      operatingsystemmajrelease = subject.get_operatingsystemminorrelease
+      expect(operatingsystemmajrelease).to be_nil
+    end
+  end
+
+
+  describe "Operatingsystemrelease hash" do
+    it "should return a hash of release values" do
+      subject.expects(:get_operatingsystemrelease).at_least_once.returns("1.2.3")
+      release_hash = subject.get_operatingsystemrelease_hash
+      expect(release_hash).to eq({"major" => "1", "minor" => "2", "full" => "1.2.3" })
+    end
+  end
+end

data/spec/unit/operatingsystem/cumuluslinux_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'facter/operatingsystem/cumuluslinux'
+
+describe Facter::Operatingsystem::CumulusLinux do
+  subject { described_class.new }
+
+  before :all do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+  end
+
+  describe "Operating system fact" do
+    it "should identify Cumulus Linux" do
+      os = subject.get_operatingsystem
+      expect(os).to eq "CumulusLinux"
+    end
+  end
+
+  describe "Osfamily fact" do
+    it "should return Debian" do
+      osfamily = subject.get_osfamily
+      expect(osfamily).to eq "Debian"
+    end
+  end
+
+  describe "Operatingsystemrelease fact" do
+    it "uses '/etc/os-release" do
+      Facter::Util::Operatingsystem.expects(:os_release).returns({"VERSION_ID" => "1.5.0"})
+      release = subject.get_operatingsystemrelease
+      expect(release).to eq "1.5.0"
+    end
+  end
+
+  describe "Operatingsystemmajrelease fact" do
+    it "should return the majrelease value based on its operatingsystemrelease" do
+      subject.expects(:get_operatingsystemrelease).returns("1.5.0")
+      release = subject.get_operatingsystemmajrelease
+      expect(release).to eq "1"
+    end
+  end
+end

data/spec/unit/operatingsystem/implementation_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'facter/operatingsystem/implementation'
+require 'facter/operatingsystem/base'
+require 'facter/operatingsystem/cumuluslinux'
+require 'facter/operatingsystem/linux'
+require 'facter/operatingsystem/sunos'
+require 'facter/operatingsystem/vmkernel'
+require 'facter/operatingsystem/windows'
+
+describe Facter::Operatingsystem do
+  it "should return an object of type Linux for linux kernels that are not Cumulus Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter::Util::Operatingsystem.expects(:os_release).at_least_once.returns({'NAME' => 'Some Linux'})
+    object = described_class.implementation
+    object.should be_a_kind_of(Facter::Operatingsystem::Linux)
+  end
+
+  it "should return an object of type Linux for gnu/kfreebsd kernels" do
+    Facter.fact(:kernel).stubs(:value).returns("GNU/kFreeBSD")
+    Facter::Util::Operatingsystem.expects(:os_release).at_least_once.returns({'NAME' => 'Some Linux'})
+    object = described_class.implementation
+    object.should be_a_kind_of(Facter::Operatingsystem::Linux)
+  end
+
+  it "should identify Cumulus Linux when a Linux kernel is encountered" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter::Util::Operatingsystem.expects(:os_release).at_least_once.returns({'NAME' => 'Cumulus Linux'})
+    object = described_class.implementation
+    object.should be_a_kind_of(Facter::Operatingsystem::CumulusLinux)
+  end
+
+  it "should return an object of type SunOS for SunOS kernels" do
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    object = described_class.implementation
+    object.should be_a_kind_of(Facter::Operatingsystem::SunOS)
+  end
+
+  it "should return an object of type VMkernel for VMkernel kernels" do
+    Facter.fact(:kernel).stubs(:value).returns("VMkernel")
+    object = described_class.implementation
+    object.should be_a_kind_of(Facter::Operatingsystem::VMkernel)
+  end
+
+  it "should return an object of type Base for other kernels" do
+    Facter.fact(:kernel).stubs(:value).returns("Nutmeg")
+    object = described_class.implementation
+    object.should be_a_kind_of(Facter::Operatingsystem::Base)
+  end
+end

data/spec/unit/operatingsystem/linux_spec.rb

@@ -0,0 +1,538 @@
+require 'spec_helper'
+require 'facter/operatingsystem/linux'
+
+describe Facter::Operatingsystem::Linux do
+  subject { described_class.new }
+
+  describe "Operating system fact" do
+    describe "On gnu/kfreebsd" do
+      it "should return 'GNU/kFreeBSD'" do
+        Facter.expects(:value).with(:kernel).returns("GNU/kFreeBSD")
+        os = subject.get_operatingsystem
+        expect(os).to eq "GNU/kFreeBSD"
+      end
+    end
+
+    describe "When lsbdistid is available" do
+      it "on Ubuntu should use the lsbdistid fact" do
+        subject.expects(:get_lsbdistid).returns("Ubuntu")
+        os = subject.get_operatingsystem
+        expect(os).to eq "Ubuntu"
+      end
+
+      it "on LinuxMint should use the lsbdistid fact" do
+        subject.expects(:get_lsbdistid).returns("LinuxMint")
+        os = subject.get_operatingsystem
+        expect(os).to eq "LinuxMint"
+      end
+    end
+
+    describe "When lsbdistid is not available" do
+     {
+        "Debian"      => "/etc/debian_version",
+        "Gentoo"      => "/etc/gentoo-release",
+        "Fedora"      => "/etc/fedora-release",
+        "Mageia"      => "/etc/mageia-release",
+        "Mandriva"    => "/etc/mandriva-release",
+        "Mandrake"    => "/etc/mandrake-release",
+        "MeeGo"       => "/etc/meego-release",
+        "Archlinux"   => "/etc/arch-release",
+        "OracleLinux" => "/etc/oracle-release",
+        "OpenWrt"     => "/etc/openwrt_release",
+        "Alpine"      => "/etc/alpine-release",
+        "VMWareESX"   => "/etc/vmware-release",
+        "Bluewhite64" => "/etc/bluewhite64-version",
+        "Slamd64"     => "/etc/slamd64-version",
+        "Slackware"   => "/etc/slackware-version",
+        "Amazon"      => "/etc/system-release"
+      }.each_pair do |distribution, releasefile|
+        it "should be #{distribution} if #{releasefile} exists" do
+          subject.expects(:get_lsbdistid).returns(nil)
+          FileTest.expects(:exists?).at_least_once.returns false
+          FileTest.expects(:exists?).with(releasefile).returns true
+          os = subject.get_operatingsystem
+          expect(os).to eq distribution
+        end
+      end
+    end
+
+    describe "on distributions that rely on the contents of /etc/redhat-release" do
+      before :each do
+        subject.expects(:get_lsbdistid).returns(nil)
+      end
+
+      {
+        "RedHat"     => "Red Hat Enterprise Linux Server release 6.0 (Santiago)",
+        "CentOS"     => "CentOS release 5.6 (Final)",
+        "Scientific" => "Scientific Linux release 6.0 (Carbon)",
+        "SLC"        => "Scientific Linux CERN SLC release 5.7 (Boron)",
+        "Ascendos"   => "Ascendos release 6.0 (Nameless)",
+        "CloudLinux" => "CloudLinux Server release 5.5",
+        "XenServer"  => "XenServer release 5.6.0-31188p (xenenterprise)",
+        "XCP"        => "XCP release 1.6.10-61809c",
+      }.each_pair do |operatingsystem, string|
+        it "should be #{operatingsystem} based on /etc/redhat-release contents #{string}" do
+          FileTest.expects(:exists?).at_least_once.returns false
+          FileTest.expects(:exists?).with("/etc/enterprise-release").returns false
+          FileTest.expects(:exists?).with("/etc/redhat-release").returns true
+          File.expects(:read).with("/etc/redhat-release").at_least_once.returns string
+          os = subject.get_operatingsystem
+          expect(os).to eq operatingsystem
+        end
+      end
+
+      it "should be OEL if /etc/ovs-release doesn't exist" do
+        FileTest.expects(:exists?).at_least_once.returns false
+        FileTest.expects(:exists?).with("/etc/enterprise-release").returns true
+        FileTest.expects(:exists?).with("/etc/ovs-release").returns false
+        os = subject.get_operatingsystem
+        expect(os).to eq "OEL"
+      end
+
+      it "should differentiate between Scientific Linux CERN and Scientific Linux" do
+        FileTest.expects(:exists?).at_least_once.returns false
+        FileTest.expects(:exists?).with("/etc/redhat-release").returns true
+        FileTest.expects(:exists?).with("/etc/enterprise-release").returns false
+        File.expects(:read).with("/etc/redhat-release").at_least_once.returns("Scientific Linux CERN SLC 5.7 (Boron)")
+        os = subject.get_operatingsystem
+        expect(os).to eq "SLC"
+      end
+
+      it "should default to RedHat" do
+        FileTest.expects(:exists?).at_least_once.returns false
+        FileTest.expects(:exists?).with("/etc/redhat-release").returns true
+        FileTest.expects(:exists?).with("/etc/enterprise-release").returns false
+        File.expects(:read).with("/etc/redhat-release").at_least_once.returns("Mystery RedHat")
+        os = subject.get_operatingsystem
+        expect(os).to eq "RedHat"
+      end
+
+      describe "on Oracle variants" do
+        it "should be OVS if /etc/ovs-release exists" do
+          FileTest.expects(:exists?).at_least_once.returns false
+          FileTest.expects(:exists?).with("/etc/enterprise-release").returns true
+          FileTest.expects(:exists?).with("/etc/ovs-release").returns true
+          os = subject.get_operatingsystem
+          expect(os).to eq "OVS"
+        end
+
+        it "should be OEL if /etc/ovs-release doesn't exist" do
+          FileTest.expects(:exists?).at_least_once.returns false
+          FileTest.expects(:exists?).with("/etc/enterprise-release").returns true
+          FileTest.expects(:exists?).with("/etc/ovs-release").returns false
+          os = subject.get_operatingsystem
+          expect(os).to eq "OEL"
+        end
+      end
+    end
+
+    describe "on distributions that rely on the contents of /etc/SuSE-release" do
+      before :each do
+        subject.expects(:get_lsbdistid).returns(nil)
+      end
+
+      {
+        "SLES"     => "SUSE LINUX Enterprise Server",
+        "SLED"     => "SUSE LINUX Enterprise Desktop",
+        "OpenSuSE" => "openSUSE"
+      }.each_pair do |operatingsystem, string|
+        it "should be #{operatingsystem} based on /etc/SuSE-release contents #{string}" do
+          FileTest.expects(:exists?).at_least_once.returns false
+          FileTest.expects(:exists?).with("/etc/enterprise-release").returns false
+          FileTest.expects(:exists?).with("/etc/redhat-release").returns false
+          FileTest.expects(:exists?).with("/etc/SuSE-release").returns true
+          File.expects(:read).with("/etc/SuSE-release").at_least_once.returns string
+          os = subject.get_operatingsystem
+          expect(os).to eq operatingsystem
+        end
+      end
+    end
+  end
+
+  describe "Osfamily fact" do
+    {
+      'Archlinux'    => 'Archlinux',
+      'Ubuntu'       => 'Debian',
+      'Debian'       => 'Debian',
+      'LinuxMint'    => 'Debian',
+      'Gentoo'       => 'Gentoo',
+      'Fedora'       => 'RedHat',
+      'Amazon'       => 'RedHat',
+      'OracleLinux'  => 'RedHat',
+      'OVS'          => 'RedHat',
+      'OEL'          => 'RedHat',
+      'CentOS'       => 'RedHat',
+      'SLC'          => 'RedHat',
+      'Scientific'   => 'RedHat',
+      'CloudLinux'   => 'RedHat',
+      'PSBM'         => 'RedHat',
+      'Ascendos'     => 'RedHat',
+      'XenServer'    => 'RedHat',
+      'RedHat'       => 'RedHat',
+      'SLES'         => 'Suse',
+      'SLED'         => 'Suse',
+      'OpenSuSE'     => 'Suse',
+      'SuSE'         => 'Suse',
+      'Mageia'       => 'Mandrake',
+      'Mandriva'     => 'Mandrake',
+      'Mandrake'     => 'Mandrake',
+    }.each do |os,family|
+      it "should return #{family} on operatingsystem #{os}" do
+        subject.expects(:get_operatingsystem).returns(os)
+        osfamily = subject.get_osfamily
+        expect(osfamily).to eq family
+      end
+    end
+
+    [
+      'MeeGo',
+      'VMWareESX',
+      'Bluewhite64',
+      'Slamd64',
+      'Slackware',
+      'Alpine',
+    ].each do |os|
+      it "should return the kernel fact on operatingsystem #{os}" do
+        Facter.expects(:value).with("kernel").returns "Linux"
+        subject.expects(:get_operatingsystem).returns(os)
+        osfamily = subject.get_osfamily
+        expect(osfamily).to eq "Linux"
+      end
+    end
+
+    it "should return the kernel value on gnu/kfreebsd" do
+      Facter.expects(:value).with("kernel").returns "gnu/kfreebsd"
+      subject.expects(:get_operatingsystem).returns("Gnu/kfreebsd")
+      osfamily = subject.get_osfamily
+      expect(osfamily).to eq "gnu/kfreebsd"
+    end
+  end
+
+  describe "Operatingsystemrelease fact" do
+    test_cases = {
+      "OpenWrt"    => "/etc/openwrt_version",
+      "CentOS"    => "/etc/redhat-release",
+      "RedHat"    => "/etc/redhat-release",
+      "LinuxMint"   => "/etc/linuxmint/info",
+      "Scientific"  => "/etc/redhat-release",
+      "Fedora"    => "/etc/fedora-release",
+      "MeeGo"     => "/etc/meego-release",
+      "OEL"     => "/etc/enterprise-release",
+      "oel"     => "/etc/enterprise-release",
+      "OVS"     => "/etc/ovs-release",
+      "ovs"     => "/etc/ovs-release",
+      "OracleLinux" => "/etc/oracle-release",
+      "Ascendos"    => "/etc/redhat-release",
+    }
+
+    test_cases.each do |system, file|
+      describe "with operatingsystem reported as #{system}" do
+        it "should read #{file}" do
+          subject.expects(:get_operatingsystem).at_least_once.returns(system)
+          Facter::Util::FileRead.expects(:read).with(file).at_least_once
+          release = subject.get_operatingsystemrelease
+        end
+      end
+    end
+
+    it "should not include trailing whitespace on Debian" do
+      subject.expects(:get_operatingsystem).returns("Debian")
+      Facter::Util::FileRead.expects(:read).returns("6.0.6\n")
+      release = subject.get_operatingsystemrelease
+      expect(release).to eq "6.0.6"
+    end
+
+    it "should run the vmware -v command in VMWareESX" do
+      Facter.fact(:kernel).stubs(:value).returns("VMkernel")
+      Facter.fact(:kernelrelease).stubs(:value).returns("4.1.0")
+      subject.expects(:get_operatingsystem).returns("VMwareESX")
+      Facter::Core::Execution.expects(:exec).with('vmware -v').returns("VMware ESX 4.1.0")
+      release = subject.get_operatingsystemrelease
+      expect(release).to eq "4.1.0"
+    end
+
+    it "should use the contents of /etc/alpine-release in Alpine" do
+      subject.expects(:get_operatingsystem).returns("Alpine")
+      File.expects(:read).with("/etc/alpine-release").returns("foo")
+      release = subject.get_operatingsystemrelease
+      expect(release).to eq "foo"
+    end
+
+    it "should fall back to parsing /etc/system-release if lsb facts are not available in Amazon" do
+      subject.expects(:get_operatingsystem).returns("Amazon")
+      subject.expects(:get_lsbdistrelease).returns(nil)
+      Facter::Util::FileRead.expects(:read).with('/etc/system-release').returns("Amazon Linux AMI release 2014.03")
+      release = subject.get_operatingsystemrelease
+      expect(release).to eq "2014.03"
+    end
+
+    it "should fall back to kernelrelease fact for gnu/kfreebsd" do
+      Facter.fact(:kernelrelease).stubs(:value).returns("1.2.3")
+      subject.expects(:get_operatingsystem).returns("GNU/kFreeBSD")
+      release = subject.get_operatingsystemrelease
+      expect(release).to eq "1.2.3"
+    end
+
+    describe "with operatingsystem reported as Ubuntu" do
+      let(:lsbrelease) { 'DISTRIB_ID=Ubuntu\nDISTRIB_RELEASE=10.04\nDISTRIB_CODENAME=lucid\nDISTRIB_DESCRIPTION="Ubuntu 10.04.4 LTS"'}
+
+      it "Returns only the major and minor version (not patch version)" do
+        Facter::Util::FileRead.expects(:read).with("/etc/lsb-release").returns(lsbrelease)
+        subject.expects(:get_operatingsystem).returns("Ubuntu")
+        release = subject.get_operatingsystemrelease
+        expect(release).to eq "10.04"
+      end
+    end
+  end
+
+  describe "Operatingsystemmajrelease key" do
+    ['Amazon','CentOS','CloudLinux','Debian','Fedora','OEL','OracleLinux','OVS','RedHat','Scientific','SLC','CumulusLinux'].each do |operatingsystem|
+      describe "on #{operatingsystem} operatingsystems" do
+        it "should be derived from operatingsystemrelease" do
+          subject.stubs(:get_operatingsystem).returns(operatingsystem)
+          subject.expects(:get_operatingsystemrelease).returns("6.3")
+          release = subject.get_operatingsystemmajorrelease
+          expect(release).to eq "6"
+        end
+      end
+    end
+
+    it "should derive major release properly in Ubuntu" do
+      subject.stubs(:get_operatingsystem).returns("Ubuntu")
+      subject.expects(:get_operatingsystemrelease).returns("10.04")
+      release = subject.get_operatingsystemmajorrelease
+      expect(release).to eq "10.04"
+    end
+  end
+
+  describe "Operatingsystem minor release key" do
+    it "should strip off the patch release if appended with a '-'" do
+      subject.stubs(:get_operatingsystem).returns("FreeBSD")
+      subject.expects(:get_operatingsystemrelease).returns("10.0-RELEASE")
+      release = subject.get_operatingsystemminorrelease
+      expect(release).to eq "0"
+    end
+  end
+
+  describe "Lsb facts" do
+    let(:raw_lsb_data) { "Distributor ID:\tSomeID\nDescription:\tSome Desc\nRelease:\t14.04\nCodename:\tSomeCodeName\nLSB Version:\t1.2.3" }
+
+    let(:lsb_data) { { "Distributor ID" => "SomeID",
+                       "Description"    => "Some Desc",
+                       "Release"        => "14.04",
+                       "Codename"       => "SomeCodeName",
+                       "LSB Version"    => "1.2.3"
+                     }
+                  }
+
+    let(:lsb_hash) { { "distcodename"      => "SomeCodeName",
+                       "distid"            => "SomeID",
+                       "distdescription"   => "Some Desc",
+                       "distrelease"       => "14.04",
+                       "release"           => "1.2.3",
+                       "majdistrelease"    => "1",
+                       "minordistrelease"  => "2"
+                     }
+                  }
+
+    describe "collecting LSB data" do
+      it "should properly parse the lsb_release command" do
+        Facter::Core::Execution.expects(:exec).with('lsb_release -cidvr 2>/dev/null', anything).returns raw_lsb_data
+        lsb_hash = subject.collect_lsb_information
+        expect(lsb_hash).to eq lsb_data
+      end
+    end
+
+    describe "lsbdistcodename fact" do
+      [ "Linux", "GNU/kFreeBSD"].each do |kernel|
+        describe "on #{kernel}" do
+          it "returns the codename" do
+            subject.expects(:collect_lsb_information).returns lsb_data
+            lsbdistcodename = subject.get_lsbdistcodename
+            expect(lsbdistcodename).to eq 'SomeCodeName'
+          end
+
+          it "returns nil if lsb_release is not installed" do
+            subject.expects(:collect_lsb_information).returns nil
+            lsbdistcodename = subject.get_lsbdistcodename
+            expect(lsbdistcodename).to be_nil
+          end
+        end
+      end
+
+      it "should return the lsbdistcodename in the lsb facts hash" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbdistcodename = subject.get_lsb_facts_hash["distcodename"]
+        expect(lsbdistcodename).to eq "SomeCodeName"
+      end
+    end
+
+    describe "lsbdistid fact" do
+      [ "Linux", "GNU/kFreeBSD"].each do |kernel|
+        describe "on #{kernel}" do
+          it "returns the id" do
+            subject.expects(:collect_lsb_information).returns lsb_data
+            lsbdistid = subject.get_lsbdistid
+            expect(lsbdistid).to eq 'SomeID'
+          end
+
+          it "returns nil if lsb_release is not installed" do
+            subject.expects(:collect_lsb_information).returns nil
+            lsbdistid = subject.get_lsbdistid
+            expect(lsbdistid).to be_nil
+          end
+        end
+      end
+
+      it "should return the lsbdistid in the lsb facts hash" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbdistid = subject.get_lsb_facts_hash["distid"]
+        expect(lsbdistid).to eq "SomeID"
+      end
+    end
+
+    describe "lsbdistdescription fact" do
+      [ "Linux", "GNU/kFreeBSD"].each do |kernel|
+        describe "on #{kernel}" do
+          it "returns the description" do
+            subject.expects(:collect_lsb_information).returns lsb_data
+            lsbdistdescription = subject.get_lsbdistdescription
+            expect(lsbdistdescription).to eq 'Some Desc'
+          end
+
+          it "returns nil if lsb_release is not installed" do
+            subject.expects(:collect_lsb_information).returns nil
+            lsbdistdescription = subject.get_lsbdistdescription
+            expect(lsbdistdescription).to be_nil
+          end
+        end
+      end
+
+      it "should return the lsbdistdescription in the lsb facts hash" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbdistdescription = subject.get_lsb_facts_hash["distdescription"]
+        expect(lsbdistdescription).to eq "Some Desc"
+      end
+    end
+
+    describe "lsbrelease fact" do
+      [ "Linux", "GNU/kFreeBSD"].each do |kernel|
+        describe "on #{kernel}" do
+          it "returns the LSB release" do
+            subject.expects(:collect_lsb_information).returns lsb_data
+            lsbrelease = subject.get_lsbrelease
+            expect(lsbrelease).to eq '1.2.3'
+          end
+
+          it "returns nil if lsb_release is not installed" do
+            subject.expects(:collect_lsb_information).returns nil
+            lsbrelease = subject.get_lsbrelease
+            expect(lsbrelease).to be_nil
+          end
+        end
+      end
+
+      it "should return the lsbrelease in the lsb facts hash" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbrelease = subject.get_lsb_facts_hash["release"]
+        expect(lsbrelease).to eq '1.2.3'
+      end
+    end
+
+    describe "lsbdistrelease fact" do
+      [ "Linux", "GNU/kFreeBSD"].each do |kernel|
+        describe "on #{kernel}" do
+          it "should return the dist release" do
+            subject.expects(:collect_lsb_information).returns lsb_data
+            lsbdistrelease = subject.get_lsbdistrelease
+            expect(lsbdistrelease).to eq '14.04'
+          end
+
+          it "should return nil if lsb_release is not installed" do
+            subject.expects(:collect_lsb_information).returns nil
+            lsbdistrelease = subject.get_lsbdistrelease
+            expect(lsbdistrelease).to be_nil
+          end
+        end
+      end
+
+      it "should return the lsbdistrelease in the lsb facts hash" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbdistrelease = subject.get_lsb_facts_hash["distrelease"]
+        expect(lsbdistrelease).to eq '14.04'
+      end
+    end
+
+    describe "lsbmajdistrelease fact" do
+      it "should be derived from lsb_release" do
+        subject.expects(:get_operatingsystem).returns("Amazon")
+        subject.expects(:get_lsbdistrelease).returns("10.04")
+        lsbmajdistrelease = subject.get_lsbmajdistrelease
+        expect(lsbmajdistrelease).to eq "10"
+      end
+
+      it "should derive correctly in Ubuntu" do
+        subject.expects(:get_operatingsystem).returns("Ubuntu")
+        subject.expects(:get_lsbdistrelease).returns("10.04")
+        lsbmajdistrelease = subject.get_lsbmajdistrelease
+        expect(lsbmajdistrelease).to eq "10.04"
+      end
+
+      it "should return the lsbmajdistrelease" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbmajdistrelease = subject.get_lsb_facts_hash["majdistrelease"]
+        expect(lsbmajdistrelease).to eq "1"
+      end
+    end
+
+    describe "lsbminordistrelease fact" do
+      it "should be derived from lsb_release" do
+        subject.expects(:get_operatingsystem).returns("Amazon")
+        subject.expects(:get_lsbdistrelease).returns("10.04")
+        lsbminordistrelease = subject.get_lsbminordistrelease
+        expect(lsbminordistrelease).to eq "04"
+      end
+
+      it "should derive correctly in Ubuntu" do
+        subject.expects(:get_operatingsystem).returns("Ubuntu")
+        subject.expects(:get_lsbdistrelease).returns("10.04.02")
+        lsbminordistrelease = subject.get_lsbminordistrelease
+        expect(lsbminordistrelease).to eq "02"
+      end
+
+      it 'should be derived from lsbdistrelease and take Y from version X.Y' do
+        subject.expects(:get_operatingsystem).returns("Amazon")
+        subject.expects(:get_lsbdistrelease).returns("6.4")
+        lsbminordistrelease = subject.get_lsbminordistrelease
+        expect(lsbminordistrelease).to eq "4"
+      end
+
+      it 'should be derived from lsbdistrelease and take Y from version X.Y.Z' do
+        subject.expects(:get_operatingsystem).returns("Amazon")
+        subject.expects(:get_lsbdistrelease).returns("6.4.1")
+        lsbminordistrelease = subject.get_lsbminordistrelease
+        expect(lsbminordistrelease).to eq "4"
+      end
+
+      it 'should be derived from lsbdistrelease and take Y from version X.Y.Z where multiple digits exist' do
+        subject.expects(:get_operatingsystem).returns("Amazon")
+        subject.expects(:get_lsbdistrelease).returns("10.20.30")
+        lsbminordistrelease = subject.get_lsbminordistrelease
+        expect(lsbminordistrelease).to eq "20"
+      end
+
+      it 'should not be present if lsbdistrelease is only X and is missing .Y' do
+        subject.expects(:get_operatingsystem).returns("Amazon")
+        subject.expects(:get_lsbdistrelease).returns("6")
+        lsbminordistrelease = subject.get_lsbminordistrelease
+        expect(lsbminordistrelease).to be_nil
+      end
+
+      it "should return the lsbmajdistrelease" do
+        subject.expects(:get_lsb_facts_hash).returns(lsb_hash)
+        lsbminordistrelease = subject.get_lsb_facts_hash["minordistrelease"]
+        expect(lsbminordistrelease).to eq "2"
+      end
+    end
+  end
+end