chef-sugar-ng 4.2.2

data/spec/unit/chef/sugar/kernel_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Kernel do
+  describe '.require_chef_gem' do
+    it 'raises an exception when the gem is not installed' do
+      expect {
+        described_class.require_chef_gem('bacon')
+      }.to raise_error(Chef::Sugar::Kernel::ChefGemLoadError)
+    end
+
+    it 'loads the gem' do
+      allow(Chef::Sugar::Kernel).to receive(:require).and_return(true)
+      expect(described_class.require_chef_gem('bacon')).to be true
+    end
+  end
+end

data/spec/unit/chef/sugar/kitchen_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Kitchen do
+  it_behaves_like 'a chef sugar'
+
+  describe '#kitchen?' do
+    it 'is true when the TEST_KITCHEN environment variable is set' do
+      allow(ENV).to receive(:[]).with('TEST_KITCHEN').and_return('1')
+      node = {}
+      expect(described_class.kitchen?(node)).to be true
+    end
+
+    it 'is false when the TEST_KITCHEN environment variable is unset' do
+      node = {}
+      expect(described_class.kitchen?(node)).to be false
+    end
+  end
+end

data/spec/unit/chef/sugar/node_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe Chef::Node do
+  describe '#in?' do
+    it 'returns true when the node is in the environment' do
+      allow(subject).to receive(:chef_environment).and_return('production')
+      expect(subject.in?('production')).to be true
+      expect(subject.in?(/production$/)).to be true
+    end
+
+    it 'returns false when the node is not in the environment' do
+      allow(subject).to receive(:chef_environment).and_return('staging')
+      expect(subject.in?('production')).to be false
+      expect(subject.in?(/production$/)).to be false
+    end
+  end
+
+  describe '#deep_fetch' do
+    let(:node) { described_class.new }
+    before { node.default['apache2']['config']['root'] = '/var/www' }
+
+    it 'fetches a deeply nested attribute' do
+      expect(node.deep_fetch('apache2', 'config', 'root')).to eq('/var/www')
+    end
+
+    it 'ignores symbols, strings, etc' do
+      expect(node.deep_fetch(:apache2, :config, :root)).to eq('/var/www')
+    end
+
+    it 'safely returns nil if a key does not exist' do
+      expect(node.deep_fetch(:apache2, :not_real, :nested, :yup)).to be_nil
+    end
+  end
+
+  describe '#deep_fetch!' do
+    let(:node) { described_class.new }
+    before { node.default['apache2']['config']['root'] = '/var/www' }
+
+    it 'fetches a deeply nested attribute' do
+      expect(node.deep_fetch!('apache2', 'config', 'root')).to eq('/var/www')
+    end
+
+    it 'ignores symbols, strings, etc' do
+      expect(node.deep_fetch!(:apache2, :config, :root)).to eq('/var/www')
+    end
+
+    it 'raises an error if a key does not exist' do
+      expect {
+        node.deep_fetch!(:apache2, :not_real)
+      }.to raise_error(Chef::Node::AttributeDoesNotExistError) { |e|
+        expect(e.message).to eq(<<-EOH.gsub(/^ {10}/, ''))
+          No attribute `node['apache2']['not_real']' exists on
+          the current node. Specifically the `not_real' attribute is not
+          defined. Please make sure you have spelled everything correctly.
+        EOH
+      }
+    end
+  end
+
+  describe '#namespace' do
+    let(:node) { described_class.new }
+
+    it 'defines the attributes' do
+      node.instance_eval do
+        namespace 'apache2' do
+          namespace 'config' do
+            root '/var/www'
+          end
+        end
+      end
+
+      expect(node.default).to eq({
+        'apache2' => {
+          'config' => { 'root' => '/var/www' }
+        }
+      })
+    end
+
+    it 'accepts multiple attributes' do
+      node.instance_eval do
+        namespace 'apache2', 'config' do
+          root '/var/www'
+        end
+      end
+
+      expect(node.default).to eq({
+        'apache2' => {
+          'config' => { 'root' => '/var/www' }
+        }
+      })
+    end
+
+    it 'accepts attribute precedence levels' do
+      node.instance_eval do
+        namespace 'apache2', precedence: normal do
+          namespace 'config', precedence: override do
+            root '/var/www'
+          end
+        end
+      end
+
+      expect(node.override).to eq({
+        'apache2' => {
+          'config' => { 'root' => '/var/www' }
+        }
+      })
+    end
+
+    it 'maintains precedence level into nested calls' do
+      node.instance_eval do
+        namespace 'apache2', precedence: override do
+          namespace 'config' do
+            root '/var/www'
+          end
+        end
+      end
+
+      expect(node.override).to eq({
+        'apache2' => {
+          'config' => { 'root' => '/var/www' }
+        }
+      })
+    end
+
+    it 'resets precedence to default in subsequent non-nested calls' do
+      node.instance_eval do
+        namespace 'apache2', precedence: override do
+          namespace 'config' do
+            root '/var/www'
+          end
+        end
+
+        namespace 'php' do
+          version '5.3'
+        end
+      end
+
+      expect(node.override).to eq({
+        'apache2' => {
+          'config' => { 'root' => '/var/www' }
+        }
+      })
+
+      expect(node.default).to eq({
+        'php' => {
+          'version' => '5.3'
+        }
+      })
+    end
+
+    it 'can access attributes within itself' do
+      node.instance_eval do
+        namespace 'apache2' do
+          namespace 'config' do
+            root '/var/www'
+            ssl File.join(root, 'ssl')
+          end
+        end
+      end
+
+      expect(node.default).to eq({
+        'apache2' => {
+          'config' => {
+            'root' => '/var/www',
+            'ssl' => '/var/www/ssl',
+          }
+        }
+      })
+    end
+  end
+
+end

data/spec/unit/chef/sugar/platform_family_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Chef::Sugar::PlatformFamily do
+  it_behaves_like 'a chef sugar'
+
+  describe '#arch_linux?' do
+    it 'returns true when the platform_family is arch linux' do
+      node = { 'platform_family' => 'arch' }
+      expect(described_class.arch_linux?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not arch linux' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.arch_linux?(node)).to be false
+    end
+  end
+
+  describe '#debian?' do
+    it 'returns true when the platform_family is debian' do
+      node = { 'platform_family' => 'debian' }
+      expect(described_class.debian?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not debian' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.debian?(node)).to be false
+    end
+  end
+
+  describe '#fedora?' do
+    it 'returns true when the platform_family is fedora' do
+      node = { 'platform_family' => 'fedora' }
+      expect(described_class.fedora?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not fedora' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.fedora?(node)).to be false
+    end
+  end
+
+  describe '#freebsd?' do
+    it 'returns true when the platform_family is freebsd' do
+      node = { 'platform_family' => 'freebsd' }
+      expect(described_class.freebsd?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not freebsd' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.freebsd?(node)).to be false
+    end
+  end
+
+  describe '#gentoo?' do
+    it 'returns true when the platform_family is gentoo' do
+      node = { 'platform_family' => 'gentoo' }
+      expect(described_class.gentoo?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not gentoo' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.gentoo?(node)).to be false
+    end
+  end
+
+  describe '#mac_os_x?' do
+    it 'returns true when the platform_family is mac_os_x' do
+      node = { 'platform_family' => 'mac_os_x' }
+      expect(described_class.mac_os_x?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not mac_os_x' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.mac_os_x?(node)).to be false
+    end
+  end
+
+  describe '#openbsd?' do
+    it 'returns true when the platform_family is openbsd' do
+      node = { 'platform_family' => 'openbsd' }
+      expect(described_class.openbsd?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not openbsd' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.openbsd?(node)).to be false
+    end
+  end
+
+  describe '#rhel?' do
+    it 'returns true when the platform_family is rhel' do
+      node = { 'platform_family' => 'rhel' }
+      expect(described_class.rhel?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not rhel' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.rhel?(node)).to be false
+    end
+  end
+
+  describe '#slackware?' do
+    it 'returns true when the platform_family is slackware' do
+      node = { 'platform_family' => 'slackware' }
+      expect(described_class.slackware?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not slackware' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.slackware?(node)).to be false
+    end
+  end
+
+  describe '#suse?' do
+    it 'returns true when the platform_family is suse' do
+      node = { 'platform_family' => 'suse' }
+      expect(described_class.suse?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not suse' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.suse?(node)).to be false
+    end
+  end
+
+  describe '#windows?' do
+    it 'returns true when the platform_family is windows' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.windows?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not windows' do
+      node = { 'platform_family' => 'debian' }
+      expect(described_class.windows?(node)).to be false
+    end
+  end
+
+  describe '#wrlinux?' do
+    it 'returns true when the platform_family is wrlinux' do
+      node = { 'platform_family' => 'wrlinux' }
+      expect(described_class.wrlinux?(node)).to be true
+    end
+
+    it 'returns false when the platform_family is not wrlinux' do
+      node = { 'platform_family' => 'debian' }
+      expect(described_class.wrlinux?(node)).to be false
+    end
+  end
+
+  describe '#linux?' do
+    it 'returns true when the os is Linux' do
+      node = { 'os' => 'linux' }
+      expect(described_class.linux?(node)).to be true
+    end
+
+    it 'returns false when the os is Windows' do
+      node = { 'os' => 'windows' }
+      expect(described_class.linux?(node)).to be false
+    end
+
+    it 'returns false when the os is Windows' do
+      node = { 'os' => 'darwin' }
+      expect(described_class.linux?(node)).to be false
+    end
+  end
+end

data/spec/unit/chef/sugar/platform_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Platform do
+  it_behaves_like 'a chef sugar'
+
+  describe '#linux_mint?' do
+    it 'returns true when the platform is linux mint' do
+      node = { 'platform' => 'linuxmint' }
+      expect(described_class.linux_mint?(node)).to be true
+    end
+
+    it 'returns false when the platform is not linux mint' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.linux_mint?(node)).to be false
+    end
+  end
+
+  describe '#ubuntu?' do
+    it 'returns true when the platform is ubuntu' do
+      node = { 'platform' => 'ubuntu' }
+      expect(described_class.ubuntu?(node)).to be true
+    end
+
+    it 'returns false when the platform is not ubuntu' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.ubuntu?(node)).to be false
+    end
+  end
+
+  describe '#amazon_linux?' do
+    it 'returns true when the platform is amazon linux' do
+      node = { 'platform' => 'amazon' }
+      expect(described_class.amazon_linux?(node)).to be true
+    end
+
+    it 'returns false when the platform is not amazon linux' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.amazon_linux?(node)).to be false
+    end
+  end
+
+  describe '#centos?' do
+    it 'returns true when the platform is centos' do
+      node = { 'platform' => 'centos' }
+      expect(described_class.centos?(node)).to be true
+    end
+
+    it 'returns false when the platform is not centos' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.centos?(node)).to be false
+    end
+  end
+
+  describe '#oracle_linux?' do
+    it 'returns true when the platform is oracle linux' do
+      node = { 'platform' => 'oracle' }
+      expect(described_class.oracle_linux?(node)).to be true
+    end
+
+    it 'returns false when the platform is not oracle linux' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.oracle_linux?(node)).to be false
+    end
+  end
+
+  describe '#scientific_linux?' do
+    it 'returns true when the platform is scientific linux' do
+      node = { 'platform' => 'scientific' }
+      expect(described_class.scientific_linux?(node)).to be true
+    end
+
+    it 'returns false when the platform is not scientific linux' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.scientific_linux?(node)).to be false
+    end
+  end
+
+  describe '#redhat_enterprise_linux?' do
+    it 'returns true when the platform is redhat enterprise linux' do
+      node = { 'platform' => 'redhat' }
+      expect(described_class.redhat_enterprise_linux?(node)).to be true
+    end
+
+    it 'returns false when the platform is not redhat enterprise linux' do
+      node = { 'platform' => 'enterprise' }
+      expect(described_class.redhat_enterprise_linux?(node)).to be false
+    end
+  end
+
+  describe '#solaris2?' do
+    it 'returns true when the platform is solaris2' do
+      node = { 'platform' => 'solaris2' }
+      expect(described_class.solaris2?(node)).to be true
+    end
+
+    it 'returns false when the platform is not solaris2' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.solaris2?(node)).to be false
+    end
+  end
+
+  describe '#aix?' do
+    it 'returns true when the platform is aix' do
+      node = { 'platform' => 'aix' }
+      expect(described_class.aix?(node)).to be true
+    end
+
+    it 'returns false when the platform is not aix' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.aix?(node)).to be false
+    end
+  end
+
+  describe '#smartos?' do
+    it 'returns true when the platform is smartos' do
+      node = { 'platform' => 'smartos' }
+      expect(described_class.smartos?(node)).to be true
+    end
+
+    it 'returns false when the platform is not smartos' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.smartos?(node)).to be false
+    end
+  end
+
+  describe '#omnios?' do
+    it 'returns true when the platform is omnios' do
+      node = { 'platform' => 'omnios' }
+      expect(described_class.omnios?(node)).to be true
+    end
+
+    it 'returns false when the platform is not omnios' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.omnios?(node)).to be false
+    end
+  end
+
+  describe '#raspbian?' do
+    it 'returns true when platform is raspbian' do
+      node = { 'platform' => 'raspbian' }
+      expect(described_class.raspbian?(node)).to be true
+    end
+
+    it 'returns false when the platform is not raspbian' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.raspbian?(node)).to be false
+    end
+  end
+
+  describe '#nexus' do
+    it 'returns true when the platform is nexus' do
+      node = { 'platform' => 'nexus' }
+      expect(described_class.nexus?(node)).to be true
+    end
+
+    it 'returns false when the platform is not nexus' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.nexus?(node)).to be false
+    end
+  end
+
+  describe '#ios_xr' do
+    it 'returns true when the platform is ios_xr' do
+      node = { 'platform' => 'ios_xr' }
+      expect(described_class.ios_xr?(node)).to be true
+    end
+
+    it 'returns false when the platform is not ios_xr' do
+      node = { 'platform' => 'windows' }
+      expect(described_class.ios_xr?(node)).to be false
+    end
+  end
+
+  describe '#platform_version' do
+    it 'returns the platform version' do
+      node = { 'platform_version' => '1.2.3' }
+      expect(described_class.platform_version(node)).to eq('1.2.3')
+    end
+  end
+
+  context 'dynamic matchers' do
+    describe '#ubuntu_after_lucid?' do
+      it 'returns true when the version is later than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
+        expect(described_class.ubuntu_after_lucid?(node)).to be true
+      end
+
+      it 'returns false when the version is 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
+        expect(described_class.ubuntu_after_lucid?(node)).to be false
+      end
+
+      it 'returns false when the version is a patch release higher than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
+        expect(described_class.ubuntu_after_lucid?(node)).to be false
+      end
+
+      it 'returns false when the version is less than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
+        expect(described_class.ubuntu_after_lucid?(node)).to be false
+      end
+    end
+
+    describe '#ubuntu_after_or_at_lucid?' do
+      it 'returns true when the version is later than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be true
+      end
+
+      it 'returns true when the version is 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be true
+      end
+
+      it 'returns true when the version is a patch release higher than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be true
+      end
+
+      it 'returns false when the version is less than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
+        expect(described_class.ubuntu_after_or_at_lucid?(node)).to be false
+      end
+    end
+
+    describe '#ubuntu_lucid?' do
+      it 'returns false when the version is later than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
+        expect(described_class.ubuntu_lucid?(node)).to be false
+      end
+
+      it 'returns true when the version is 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
+        expect(described_class.ubuntu_lucid?(node)).to be true
+      end
+
+      it 'returns true when the version is a patch release higher than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
+        expect(described_class.ubuntu_lucid?(node)).to be true
+      end
+
+      it 'returns false when the version is less than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
+        expect(described_class.ubuntu_lucid?(node)).to be false
+      end
+    end
+
+    describe '#ubuntu_before_lucid?' do
+      it 'returns false when the version is later than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
+        expect(described_class.ubuntu_before_lucid?(node)).to be false
+      end
+
+      it 'returns false when the version is 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
+        expect(described_class.ubuntu_before_lucid?(node)).to be false
+      end
+
+      it 'returns false when the version is a patch release higher than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
+        expect(described_class.ubuntu_before_lucid?(node)).to be false
+      end
+
+      it 'returns true when the version is less than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
+        expect(described_class.ubuntu_before_lucid?(node)).to be true
+      end
+    end
+
+    describe '#ubuntu_before_or_at_lucid?' do
+      it 'returns false when the version is later than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.10' }
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be false
+      end
+
+      it 'returns true when the version is 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04' }
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be true
+      end
+
+      it 'returns true when the version is a patch release higher than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '10.04.4' }
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be true
+      end
+
+      it 'returns true when the version is less than 10.04' do
+        node = { 'platform' => 'ubuntu', 'platform_version' => '9.10' }
+        expect(described_class.ubuntu_before_or_at_lucid?(node)).to be true
+      end
+    end
+
+    describe '#centos_final?' do
+      it 'returns true when the version is a subset of the major' do
+        node = { 'platform' => 'centos', 'platform_version' => '6.8' }
+        expect(described_class.centos_final?(node)).to be true
+      end
+
+      it 'returns false when the version is not the major' do
+        node = { 'platform' => 'centos', 'platform_version' => '7.4' }
+        expect(described_class.centos_final?(node)).to be false
+      end
+    end
+
+    describe '#debian_wheezy?' do
+      it 'returns true when the version is a subset of the major' do
+        node = { 'platform' => 'debian', 'platform_version' => '7.1' }
+        expect(described_class.debian_wheezy?(node)).to be true
+      end
+
+      it 'returns false when the version is not the major' do
+        node = { 'platform' => 'debian', 'platform_version' => '6.1' }
+        expect(described_class.debian_wheezy?(node)).to be false
+      end
+    end
+
+    describe '#debian_before_wheezy?' do
+      it 'returns true when the version is a less than the major' do
+        node = { 'platform' => 'debian', 'platform_version' => '6.5' }
+        expect(described_class.debian_before_wheezy?(node)).to be true
+      end
+
+      it 'returns false when the version is not less than the major' do
+        node = { 'platform' => 'debian', 'platform_version' => '8.0' }
+        expect(described_class.debian_before_wheezy?(node)).to be false
+      end
+    end
+
+    describe '#solaris_10?' do
+      it 'returns true when the version is 5.10' do
+        node = { 'platform' => 'solaris2', 'platform_version' => '5.10' }
+        expect(described_class.solaris_10?(node)).to be true
+      end
+    end
+
+    describe '#solaris_11?' do
+      it 'returns true when the version is 5.11' do
+        node = { 'platform' => 'solaris2', 'platform_version' => '5.11' }
+        expect(described_class.solaris_11?(node)).to be true
+      end
+    end
+  end
+end