chef-sugar 1.0.0.beta.1

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec'
+require 'chefspec'
+require 'chef/sugar'
+
+require_relative 'support/shared_examples'

data/spec/support/shared_examples.rb

@@ -0,0 +1,20 @@
+module RSpec
+  shared_examples 'a chef sugar' do
+    it 'acts as a singleton' do
+      described_class.module_eval("def foo; 'result'; end")
+      klass = Class.new.tap { |k| k.send(:include, described_class) }
+      expect(described_class.foo).to eq(klass.new.foo)
+    end
+
+    described_class.instance_methods.each do |name|
+      it "defines a `#{name}` DSL method" do
+        expect(Chef::Sugar::DSL.instance_methods).to include(name)
+      end
+
+      it 'has n-1 arity from the parent method' do
+        method = Chef::Sugar::DSL.instance_method(name)
+        expect(method.arity).to eq(described_class.method(name).arity - 1)
+      end
+    end
+  end
+end

data/spec/unit/chef/extensions/architecture_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Architecture do
+  it_behaves_like 'a chef sugar'
+
+  describe '#_64_bit?' do
+    it 'returns true when the system is 64 bit' do
+      node = { 'kernel' => { 'machine' => 'x86_64' } }
+      expect(described_class._64_bit?(node)).to be_true
+    end
+
+    it 'returns false when the system is not 64 bit' do
+      node = { 'kernel' => { 'machine' => 'i386' } }
+      expect(described_class._64_bit?(node)).to be_false
+    end
+  end
+
+  describe '#_32_bit?' do
+    it 'returns true when the system is 32 bit' do
+      node = { 'kernel' => { 'machine' => 'i386' } }
+      expect(described_class._32_bit?(node)).to be_true
+    end
+
+    it 'returns false when the system is not 32 bit' do
+      node = { 'kernel' => { 'machine' => 'x86_64' } }
+      expect(described_class._32_bit?(node)).to be_false
+    end
+  end
+end

data/spec/unit/chef/extensions/cloud_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Cloud do
+  it_behaves_like 'a chef sugar'
+
+  describe '#cloud?' do
+    it 'is true when the node is on cloud' do
+      node = { 'cloud' => nil }
+      expect(described_class.cloud?(node)).to be_true
+    end
+
+    it 'is false when the node is not on cloud' do
+      node = {}
+      expect(described_class.cloud?(node)).to be_false
+    end
+  end
+
+  describe '#ec2?' do
+    it 'is true when the node is on ec2' do
+      node = { 'ec2' => nil }
+      expect(described_class.ec2?(node)).to be_true
+    end
+
+    it 'is false when the node is not on ec2' do
+      node = {}
+      expect(described_class.ec2?(node)).to be_false
+    end
+  end
+
+  describe '#gce?' do
+    it 'is true when the node is on gce' do
+      node = { 'gce' => nil }
+      expect(described_class.gce?(node)).to be_true
+    end
+
+    it 'is false when the node is not on gce' do
+      node = {}
+      expect(described_class.gce?(node)).to be_false
+    end
+  end
+
+  describe '#rackspace?' do
+    it 'is true when the node is on rackspace' do
+      node = { 'rackspace' => nil }
+      expect(described_class.rackspace?(node)).to be_true
+    end
+
+    it 'is false when the node is not on rackspace' do
+      node = {}
+      expect(described_class.rackspace?(node)).to be_false
+    end
+  end
+
+  describe '#eucalyptus?' do
+    it 'is true when the node is on eucalyptus' do
+      node = { 'eucalyptus' => nil }
+      expect(described_class.eucalyptus?(node)).to be_true
+    end
+
+    it 'is false when the node is not on eucalyptus' do
+      node = {}
+      expect(described_class.eucalyptus?(node)).to be_false
+    end
+  end
+
+  describe '#euca?' do
+    it 'is true when the node is on eucalyptus' do
+      node = { 'eucalyptus' => nil }
+      expect(described_class.euca?(node)).to be_true
+    end
+
+    it 'is false when the node is not on eucalyptus' do
+      node = {}
+      expect(described_class.euca?(node)).to be_false
+    end
+  end
+
+  describe '#linode?' do
+    it 'is true when the node is on linode' do
+      node = { 'linode' => nil }
+      expect(described_class.linode?(node)).to be_true
+    end
+
+    it 'is false when the node is not on linode' do
+      node = {}
+      expect(described_class.linode?(node)).to be_false
+    end
+  end
+
+  describe '#openstack?' do
+    it 'is true when the node is on openstack' do
+      node = { 'openstack' => nil }
+      expect(described_class.openstack?(node)).to be_true
+    end
+
+    it 'is false when the node is not on openstack' do
+      node = {}
+      expect(described_class.openstack?(node)).to be_false
+    end
+  end
+
+  describe '#azure?' do
+    it 'is true when the node is on azure' do
+      node = { 'azure' => nil }
+      expect(described_class.azure?(node)).to be_true
+    end
+
+    it 'is false when the node is not on azure' do
+      node = {}
+      expect(described_class.azure?(node)).to be_false
+    end
+  end
+end

data/spec/unit/chef/extensions/ip_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Chef::Sugar::IP do
+  it_behaves_like 'a chef sugar'
+
+  let(:node)  { { 'ipaddress' => '1.2.3.4' } }
+  let(:other) { { 'ipaddress' => '5.6.7.8' } }
+
+  context 'when not on a cloud' do
+    it 'returns the default IP address' do
+      expect(described_class.best_ip_for(node, other)).to eq(other['ipaddress'])
+    end
+  end
+
+  context 'when the target is on the cloud' do
+    before do
+      other['cloud'] = {}
+      other['cloud']['provider']    = 'ec2'
+      other['cloud']['local_ipv4']  = '9.10.11.12'
+      other['cloud']['public_ipv4'] = '13.14.15.16'
+
+      node['cloud'] = nil
+    end
+
+    context 'when the current node is not on the cloud' do
+      it 'uses the public ipv4' do
+        expect(described_class.best_ip_for(node, other)).to eq('13.14.15.16')
+      end
+    end
+
+    context 'when the current node is on a different cloud' do
+      before do
+        node['cloud'] = {}
+        node['cloud']['provider'] = 'rackspace'
+      end
+
+      it 'uses the public ipv4' do
+        expect(described_class.best_ip_for(node, other)).to eq('13.14.15.16')
+      end
+    end
+
+    context 'when the current node is on the same cloud' do
+      before do
+        node['cloud'] = {}
+        node['cloud']['provider'] = 'ec2'
+      end
+
+      it 'uses the local ipv4' do
+        expect(described_class.best_ip_for(node, other)).to eq('9.10.11.12')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Chef::Node do
+  describe '#in?' do
+    it 'returns true when the node is in the environment' do
+      subject.stub(: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
+      subject.stub(:chef_environment).and_return('staging')
+      expect(subject.in?('production')).to be_false
+      expect(subject.in?(/production$/)).to be_false
+    end
+  end
+
+  describe '#includes_recipe?' do
+    it 'returns true when the recipe exists' do
+      subject.stub(:run_list).and_return(['recipe[magic::recipe]'])
+      expect(subject.includes_recipe?('recipe[magic::recipe]')).to be_true
+    end
+
+    it 'returns false when the recipe does
+     not exist' do
+      subject.stub(:run_list).and_return([])
+      expect(subject.includes_recipe?('recipe[magic::recipe]')).to be_false
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+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 '#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 '#linux?' do
+    it 'returns true when the platform_family is linux-based' do
+      node = { 'platform_family' => 'debian' }
+      expect(described_class.debian?(node)).to be_true
+    end
+
+    it 'returns false when the platform_family is not linux-based' do
+      node = { 'platform_family' => 'windows' }
+      expect(described_class.debian?(node)).to be_false
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+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' => 'enterprise' }
+      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' => 'windows' }
+      expect(described_class.redhat_enterprise_linux?(node)).to be_false
+    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
+  end
+end