chef-sugar 4.2.1 → 5.0.0

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

@@ -1,172 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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

@@ -1,342 +0,0 @@
-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