chefspec 3.1.4 → 3.2.0

data/spec/unit/matchers/include_recipe_matcher_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::IncludeRecipeMatcher do
+  let(:chef_run) { double('chef run', run_context: { loaded_recipes: %w(one two three) }) }
+  subject { described_class.new('one::default') }
+
+  describe '#failure_message_for_should' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_for_should)
+        .to eq(%q(expected ["one::default", "two::default", "three::default"] to include "one::default"))
+    end
+  end
+
+  describe '#failure_message_for_should_not' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_for_should_not)
+        .to eq(%q(expected "one::default" to not be included))
+    end
+  end
+
+  describe '#description' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.description).to eq(%q(include recipe "one::default"))
+    end
+  end
+
+  it 'matches when the recipe is included' do
+    expect(subject.matches?(chef_run)).to be_true
+  end
+
+  it 'does not match when the recipe is not included' do
+    failure = described_class.new('nope')
+    expect(failure.matches?(chef_run)).to be_false
+  end
+end

data/spec/unit/matchers/link_to_matcher_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::LinkToMatcher do
+  let(:path) { '/var/www' }
+  let(:link) { double('link', to: path, to_s: "link[#{path}]", is_a?: true, performed_action?: true) }
+  subject { described_class.new(path) }
+
+  describe '#failure_message_for_should' do
+    it 'has the right value' do
+      subject.matches?(link)
+      expect(subject.failure_message_for_should)
+        .to eq(%Q(expected "link[#{path}]" to link to "#{path}" but was "#{path}"))
+    end
+  end
+
+  describe '#failure_message_for_should_not' do
+    it 'has the right value' do
+      subject.matches?(link)
+      expect(subject.failure_message_for_should_not)
+        .to eq(%Q(expected "link[#{path}]" to not link to "#{path}"))
+    end
+  end
+
+  describe '#description' do
+    it 'has the right value' do
+      subject.matches?(link)
+      expect(subject.description).to eq(%Q(link to "#{path}"))
+    end
+  end
+
+  it 'matches when the link is correct' do
+    expect(subject.matches?(link)).to be_true
+  end
+
+  it 'does not match when the link is incorrect' do
+    failure = described_class.new('nope')
+    expect(failure.matches?(link)).to be_false
+  end
+end

data/spec/unit/matchers/notifications_matcher_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::NotificationsMatcher do
+  pending
+end

data/spec/unit/matchers/render_file_matcher_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::RenderFileMatcher do
+  let(:path) { '/tmp/thing' }
+  let(:file) { double('file', to: path, to_s: "file[#{path}]", performed_action?: true) }
+  let(:chef_run) { double('chef run', find_resource: file) }
+  subject { described_class.new(path) }
+
+  describe '#failure_message_for_should' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_for_should)
+        .to eq(%Q(expected Chef run to render "#{path}"))
+    end
+  end
+
+  describe '#failure_message_for_should_not' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_for_should_not)
+        .to eq(%Q(expected file "#{path}" to not be in Chef run))
+    end
+  end
+
+  describe '#description' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.description).to eq(%Q(render file "#{path}"))
+    end
+  end
+
+  it 'matches when the file is correct' do
+    expect(subject.matches?(chef_run)).to be_true
+  end
+
+  it 'does not match when the file is incorrect' do
+    chef_run.stub(:find_resource).and_return(nil)
+    failure = described_class.new('nope')
+    expect(failure.matches?(chef_run)).to be_false
+  end
+end

data/spec/unit/matchers/resource_matcher_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::ResourceMatcher do
+  pending
+end

data/spec/unit/matchers/state_attrs_matcher_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::StateAttrsMatcher do
+  subject { described_class.new([:a, :b]) }
+
+  context 'when the resource does not exist' do
+    let(:resource) { nil }
+    before { subject.matches?(resource) }
+
+    it 'does not match' do
+      expect(subject).to_not be_matches(resource)
+    end
+
+    its(:description) { should eq('have state attributes [:a, :b]') }
+
+    its(:failure_message_for_should) do
+      should eq "expected _something_ to have state attributes, but " \
+        "the _something_ you gave me was nil!" \
+        "\n" \
+        "Ensure the resource exists before making assertions:" \
+        "\n\n" \
+        "  expect(resource).to be" \
+        "\n "
+    end
+
+    its(:failure_message_for_should_not) do
+      should eq "expected _something_ to not have state attributes, but " \
+        "the _something_ you gave me was nil!" \
+        "\n" \
+        "Ensure the resource exists before making assertions:" \
+        "\n\n" \
+        "  expect(resource).to be" \
+        "\n "
+    end
+  end
+
+  context 'when the resource exists' do
+    let(:klass) { double('class', state_attrs: [:a, :b]) }
+    let(:resource) { double('resource', class: klass) }
+    before { subject.matches?(resource) }
+
+    its(:description) { should eq('have state attributes [:a, :b]') }
+    its(:failure_message_for_should) do
+      should eq('expected [:a, :b] to equal [:a, :b]')
+    end
+    its(:failure_message_for_should_not) do
+      should eq('expected [:a, :b] to not equal [:a, :b]')
+    end
+
+    it 'matches when the state attributes are correct' do
+      expect(subject).to be_matches(resource)
+    end
+
+    it 'does not match when the state attributes are incorrect' do
+      klass.stub(:state_attrs).and_return([:c, :d])
+      expect(subject).to_not be_matches(resource)
+    end
+
+    it 'does not match when partial state attribute are incorrect' do
+      klass.stub(:state_attrs).and_return([:b, :c])
+      expect(subject).to_not be_matches(resource)
+    end
+  end
+end

data/spec/unit/matchers/subscribes_matcher_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::SubscribesMatcher do
+  pending
+end

data/spec/unit/renderer_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ChefSpec::Renderer do
+  describe '.initialize' do
+    it 'accepts two arguments and assigns their instance variables' do
+      instance = described_class.new('runner', 'resource')
+      expect(instance.chef_run).to eq('runner')
+      expect(instance.resource).to eq('resource')
+    end
+  end
+
+  let(:chef_run) { double('chef_run') }
+  let(:resource) { double('resource') }
+  subject { described_class.new(chef_run, resource) }
+
+  describe '#content' do
+    before do
+      subject.stub(:content_from_cookbook_file).and_return('cookbook_file content')
+      subject.stub(:content_from_file).and_return('file content')
+      subject.stub(:content_from_template).and_return('template content')
+    end
+
+    context 'when the resource is a cookbook_file' do
+      it 'renders the cookbook_file content' do
+        resource.stub(:resource_name).and_return('cookbook_file')
+        expect(subject.content).to eq('cookbook_file content')
+      end
+    end
+
+    context 'when the resource is a file' do
+      it 'renders the file content' do
+        resource.stub(:resource_name).and_return('file')
+        expect(subject.content).to eq('file content')
+      end
+    end
+
+    context 'when the resource is a template' do
+      it 'renders the template content' do
+        resource.stub(:resource_name).and_return('template')
+        expect(subject.content).to eq('template content')
+      end
+    end
+
+    context 'when the resource is not a file type' do
+      it 'returns nil' do
+        resource.stub(:resource_name).and_return('service')
+        expect(subject.content).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/runner_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe ChefSpec::Runner do
+  before do
+    ChefSpec::Runner.any_instance.stub(:dry_run?).and_return(true)
+  end
+
+  describe '#initialize' do
+    subject {} # need to explicitly control the creation
+
+    it 'defaults the log level to :warn' do
+      described_class.new
+      expect(Chef::Log.level).to eq(:warn)
+    end
+
+    it 'sets the log level' do
+      described_class.new(log_level: :error)
+      expect(Chef::Log.level).to eq(:error)
+    end
+
+    it 'defaults the cookbook_path to the calling spec' do
+      described_class.new
+      expect(Chef::Config.cookbook_path).to eq([File.expand_path('../../../..', __FILE__)])
+    end
+
+    it 'sets the cookbook path' do
+      described_class.new(cookbook_path: '/tmp/bacon')
+      expect(Chef::Config.cookbook_path).to eq(['/tmp/bacon'])
+    end
+
+    it 'sets the Chef::Config' do
+      expect(Chef::Config.cache_type).to eq('Memory')
+      expect(Chef::Config.force_logger).to be_true
+      expect(Chef::Config.solo).to be_true
+    end
+
+    it 'yields a block to set node attributes' do
+      expect { |block| described_class.new({}, &block) }.to yield_with_args(Chef::Node)
+    end
+
+    context 'default ohai attributes' do
+      let(:hash) { described_class.new.node.to_hash }
+
+      it 'sets the default attributes' do
+        expect(hash['os']).to eq('chefspec')
+        expect(hash['languages']['ruby']).to eq('/usr/somewhere')
+        expect(hash['os_version']).to eq('0.6.1')
+        expect(hash['fqdn']).to eq('chefspec.local')
+        expect(hash['domain']).to eq('local')
+        expect(hash['ipaddress']).to eq('127.0.0.1')
+        expect(hash['hostname']).to eq('chefspec')
+        expect(hash['kernel']['machine']).to eq('i386')
+      end
+    end
+
+    context 'fauxhai attributes' do
+      let(:hash) { described_class.new(platform: 'ubuntu', version: '12.04').node.to_hash }
+
+      it 'sets the attributes from fauxhai' do
+        expect(hash['os']).to eq('linux')
+        expect(hash['languages']['ruby']['ruby_bin']).to eq('/usr/local/bin/ruby')
+        expect(hash['os_version']).to eq('3.2.0-26-generic')
+        expect(hash['fqdn']).to eq('fauxhai.local')
+        expect(hash['domain']).to eq('local')
+        expect(hash['ipaddress']).to eq('10.0.0.2')
+        expect(hash['hostname']).to eq('Fauxhai')
+        expect(hash['kernel']['machine']).to eq('x86_64')
+      end
+    end
+
+    context 'RSpec global configuration' do
+      before do
+        RSpec.configuration.stub(:cookbook_path).and_return('./path')
+        RSpec.configuration.stub(:log_level).and_return(:fatal)
+        RSpec.configuration.stub(:path).and_return('ohai.json')
+        RSpec.configuration.stub(:platform).and_return('ubuntu')
+        RSpec.configuration.stub(:version).and_return('12.04')
+      end
+
+      it 'uses the RSpec values' do
+        options = described_class.new.options
+        expect(options[:cookbook_path]).to eq('./path')
+        expect(options[:log_level]).to eq(:fatal)
+        expect(options[:path]).to eq('ohai.json')
+        expect(options[:platform]).to eq('ubuntu')
+        expect(options[:version]).to eq('12.04')
+      end
+    end
+  end
+
+  describe '#node' do
+    it 'returns the Chef::Node' do
+      expect(subject.node).to be_a(Chef::Node)
+    end
+
+    it 'defines a #runner method that returns self' do
+      expect(subject.node.methods).to include(:runner)
+      expect(subject.node.runner).to be(subject)
+    end
+
+    it 'allows attributes to be set on the node' do
+      subject.node.set['bacon'] = 'ham'
+      expect(subject.node.bacon).to eq('ham')
+    end
+  end
+
+  describe '#to_s' do
+    it 'overrides the default string representation to something readable' do
+      expect(subject.converge('apache2::default').to_s).to eq('chef_run: recipe[apache2::default]')
+    end
+
+    it 'is ok when a convergence has not yet taken place' do
+      expect(subject.to_s).to eq('chef_run')
+    end
+
+    it 'includes the entire run_list' do
+      expect(subject.converge('apache2::default', 'apache2::mod_ssl').to_s).to eq('chef_run: recipe[apache2::default], recipe[apache2::mod_ssl]')
+    end
+
+    it 'has the run_list only for the last convergence' do
+      ['mysql::client', 'mysql::server'].each { |recipe| subject.converge(recipe) }
+      expect(subject.to_s).to eq('chef_run: recipe[mysql::server]')
+    end
+  end
+end

data/spec/unit/stubs/command_registry_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ChefSpec::Stubs::CommandRegistry do
+  before { described_class.reset! }
+
+  it 'inherits from Registry' do
+    expect(described_class.superclass).to be(ChefSpec::Stubs::Registry)
+  end
+
+  describe '#stub_for' do
+    it 'finds a stub by name' do
+      command = double('command', command: 'test -f /var/www')
+      described_class.register(command)
+      expect(described_class.stub_for('test -f /var/www')).to eq(command)
+    end
+
+    it 'finds a stub by regex' do
+      command = double('command', command: /test -f (.+)/)
+      described_class.register(command)
+      expect(described_class.stub_for('test -f /var/www')).to eq(command)
+    end
+
+    it 'returns nil when no commands are matched' do
+      expect(described_class.stub_for('which a2ensite')).to eq(nil)
+    end
+  end
+end

data/spec/unit/stubs/command_stub_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ChefSpec::Stubs::CommandStub do
+  describe '#initialize' do
+    it 'sets the command and block' do
+      block = Proc.new {}
+      stub  = described_class.new('command', &block)
+
+      expect(stub.command).to eq('command')
+      expect(stub.block).to eq(block)
+    end
+  end
+
+  describe '#and_return' do
+    subject { described_class.new('command').and_return('value') }
+
+    it 'sets the value' do
+      expect(subject.value).to eq('value')
+    end
+
+    it 'returns an instance of the stub' do
+      expect(subject.and_return('value')).to be(subject)
+    end
+  end
+
+  describe '#result' do
+    context 'when a value is given' do
+      subject { described_class.new('command').and_return('value') }
+
+      it 'returns the value' do
+        expect(subject.result).to eq('value')
+      end
+    end
+
+    context 'when a block is given' do
+      subject { described_class.new('command') { 1 == 2 } }
+
+      it 'calls the block' do
+        expect(subject.result).to eq(false)
+      end
+    end
+  end
+
+  describe '#signature' do
+    context 'when a value is given' do
+      subject { described_class.new('command').and_return(false) }
+
+      it 'includes the value' do
+        expect(subject.signature).to eq('stub_command("command").and_return(false)')
+      end
+    end
+
+    context 'when a block is given' do
+      subject { described_class.new('command') { 1 == 2 } }
+
+      it 'includes a comment about the block' do
+        expect(subject.signature).to eq('stub_command("command") { # Ruby code }')
+      end
+    end
+  end
+end