chefspec 7.3.3 → 7.3.4

data/spec/unit/expect_exception_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ChefSpec::ExpectException do
+  context 'when there have been no `raise_error` matchers' do
+    subject { described_class.new(Exception) }
+
+    it 'does not match' do
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(nil)
+      expect(subject.expected?).to be_falsy
+    end
+  end
+
+  context 'when the last error does not match the expected type' do
+    subject { described_class.new(RuntimeError) }
+
+    it 'does not match' do
+      last_error = double('last error', last_error_for_chefspec: ArgumentError)
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(last_error)
+      expect(subject.expected?).to be_falsy
+    end
+  end
+
+  context 'when the last error matches the expected type' do
+    subject { described_class.new(RuntimeError) }
+
+    it 'does not match' do
+      last_error = double('last error', last_error_for_chefspec: RuntimeError)
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(last_error)
+      expect(subject.expected?).to be_truthy
+    end
+  end
+end

data/spec/unit/macros_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe ChefSpec::API::Stubs do
+  describe '#stub_command' do
+    let(:command_stub) { double('command') }
+
+    it 'adds the command to the command registry' do
+      allow(ChefSpec::Stubs::CommandStub).to receive(:new).and_return(command_stub)
+      stub_command('echo "hello"')
+
+      expect(ChefSpec::Stubs::CommandRegistry.stubs).to include(command_stub)
+    end
+  end
+
+  describe '#stub_search' do
+    let(:search_stub) { double('search') }
+
+    it 'adds the query to the search registry' do
+      allow(ChefSpec::Stubs::SearchStub).to receive(:new).and_return(search_stub)
+      stub_search(:node, '*:*')
+
+      expect(ChefSpec::Stubs::SearchRegistry.stubs).to include(search_stub)
+    end
+  end
+
+  describe '#stub_data_bag' do
+    let(:data_bag_stub) { double('data_bag') }
+
+    it 'adds the query to the data_bag registry' do
+      allow(ChefSpec::Stubs::DataBagStub).to receive(:new).and_return(data_bag_stub)
+      stub_data_bag(:users)
+
+      expect(ChefSpec::Stubs::DataBagRegistry.stubs).to include(data_bag_stub)
+    end
+  end
+
+  describe '#stub_data_bag_item' do
+    let(:data_bag_item_stub) { double('data_bag_item') }
+
+    it 'adds the query to the data_bag_item registry' do
+      allow(ChefSpec::Stubs::DataBagItemStub).to receive(:new).and_return(data_bag_item_stub)
+      stub_data_bag_item(:users, 'id')
+
+      expect(ChefSpec::Stubs::DataBagItemRegistry.stubs).to include(data_bag_item_stub)
+    end
+  end
+
+  describe '#stub_node' do
+    it 'returns a Chef::Node' do
+      expect(stub_node).to be_a(Chef::Node)
+    end
+
+    it 'defaults the node name to `node.example`' do
+      node = stub_node
+      expect(node.name).to eq('node.example')
+    end
+
+    it 'sets the node name when given' do
+      node = stub_node('example.com')
+      expect(node.name).to eq('example.com')
+    end
+
+    it 'sets the automatic attributes' do
+      node = stub_node
+      expect(node.automatic).to eq(Fauxhai.mock.data)
+    end
+
+    it 'sets the automatic attributes with ohai overrides' do
+      node = stub_node('node.example', ohai: { ipaddress: '1.2.3.4' })
+      expect(node['ipaddress']).to eq('1.2.3.4')
+    end
+
+    it 'sets the automatic attributes for a specific platform and version' do
+      node = stub_node('node.example', platform: 'ubuntu', version: '18.04')
+      expect(node.automatic).to eq(Fauxhai.mock(platform: 'ubuntu', version: '18.04').data)
+    end
+
+    it 'sets the automatic attributes from a JSON data path' do
+      allow(File).to receive(:exist?).with('/path/to/json').and_return(true)
+      allow(File).to receive(:read).with('/path/to/json').and_return('{ "ipaddress": "1.2.3.4" }')
+      node = stub_node('node.example', path: '/path/to/json')
+      expect(node['ipaddress']).to eq('1.2.3.4')
+    end
+
+    it 'yields a block' do
+      expect { |block| stub_node(&block) }.to yield_with_args(Chef::Node)
+    end
+  end
+end
+
+describe 'nginx::source' do
+  describe '#described_cookbook' do
+    describe 'nginx::source' do
+      it 'returns the name of the cookbook' do
+        expect(described_cookbook).to eq('nginx')
+      end
+
+      context 'in a nested context' do
+        it 'still returns the name of the cookbook' do
+          expect(described_cookbook).to eq('nginx')
+        end
+      end
+    end
+  end
+
+  describe '#described_recipe' do
+    describe 'nginx::source' do
+      it 'returns the cookbook::recipe' do
+        expect(described_recipe).to eq('nginx::source')
+      end
+
+      context 'in a nested context' do
+        it 'still retrns the cookbook::recipe' do
+          expect(described_recipe).to eq('nginx::source')
+        end
+      end
+    end
+  end
+end

data/spec/unit/matchers/do_nothing_matcher.rb

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

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' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message)
+        .to eq(%q(expected ["one::default", "two::default", "three::default"] to include "one::default"))
+    end
+  end
+
+  describe '#failure_message_when_negated' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_when_negated)
+        .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_truthy
+  end
+
+  it 'does not match when the recipe is not included' do
+    failure = described_class.new('nope')
+    expect(failure.matches?(chef_run)).to be_falsy
+  end
+end

data/spec/unit/matchers/link_to_matcher_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::LinkToMatcher do
+  let(:from) { '/var/www' }
+  let(:to)   { '/var/html' }
+  let(:link) do
+    Chef::Resource::Link.new(from).tap do |link|
+      link.to(to)
+      link.perform_action(:create)
+    end
+  end
+  subject { described_class.new(to) }
+
+  describe '#failure_message' do
+    it 'has the right value' do
+      subject.matches?(link)
+      expect(subject.failure_message)
+        .to eq(%Q(expected "link[#{from}]" to link to "#{to}" but was "#{to}"))
+    end
+  end
+
+  describe '#failure_message_when_negated' do
+    it 'has the right value' do
+      subject.matches?(link)
+      expect(subject.failure_message_when_negated)
+        .to eq(%Q(expected "link[#{from}]" to not link to "#{to}"))
+    end
+  end
+
+  describe '#description' do
+    it 'has the right value' do
+      subject.matches?(link)
+      expect(subject.description).to eq(%Q(link to "#{to}"))
+    end
+  end
+
+  context 'when the link is correct' do
+    it 'matches' do
+      expect(subject.matches?(link)).to be_truthy
+    end
+
+    it 'adds the link to the coverage report' do
+      expect(ChefSpec::Coverage).to receive(:cover!).with(link)
+      subject.matches?(link)
+    end
+  end
+
+  context 'when the link is not correct' do
+    subject { described_class.new('/nope/bad/path/bro') }
+
+    it 'does not match' do
+      expect(subject.matches?(link)).to be_falsy
+    end
+  end
+end

data/spec/unit/matchers/notifications_matcher_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::NotificationsMatcher do
+  subject { described_class.new('execute[install]') }
+  let(:package) do
+    double('package',
+      name: 'package',
+      to_s: 'package[foo]',
+      is_a?: true,
+      performed_action?: true,
+      immediate_notifications: [],
+      delayed_notifications: [],
+      before_notifications: []
+    )
+  end
+
+  describe '#failure_message' do
+    it 'has the right value' do
+      subject.matches?(package)
+      expect(subject.failure_message)
+        .to include %|expected "package[foo]" to notify "execute[install]", but did not.|
+    end
+  end
+
+  describe '#failure_message_when_negated' do
+    it 'has the right value' do
+      subject.matches?(package)
+      expect(subject.failure_message_when_negated)
+        .to eq %|expected "package[foo]" to not notify "execute[install]", but it did.|
+    end
+  end
+
+  describe '#description' do
+    it 'has the right value' do
+      subject.matches?(package)
+      expect(subject.description)
+        .to eq %|notify "execute[install]"|
+    end
+  end
+end

data/spec/unit/matchers/render_file_matcher_spec.rb

@@ -0,0 +1,68 @@
+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 '#with_content' do
+    it 'accepts do/end syntax' do
+      subject.matches?(chef_run)
+      expect(
+        subject.with_content do |content|
+          'Does not raise ArgumentError'
+        end.expected_content.first.call
+      ).to eq('Does not raise ArgumentError')
+    end
+  end
+
+  describe '#failure_message' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message)
+        .to eq(%Q(expected Chef run to render "#{path}"))
+    end
+  end
+
+  describe '#failure_message_when_negated' do
+    it 'has the right value' do
+      subject.matches?(chef_run)
+      expect(subject.failure_message_when_negated)
+        .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
+
+    it 'has the right value when with_content is chained' do
+      subject.matches?(chef_run)
+      expect(
+        subject.with_content('foo').with_content('bar').description
+      ).to eq(%Q(render file "#{path}" with content "foo" with content "bar"))
+    end
+  end
+
+  context 'when the file is correct' do
+    it 'matches' do
+      expect(subject.matches?(chef_run)).to be_truthy
+    end
+
+    it 'adds the resource to the coverage report' do
+      expect(ChefSpec::Coverage).to receive(:cover!).with(file)
+      subject.matches?(chef_run)
+    end
+  end
+
+  context 'when the file is not correct' do
+    it 'does not match' do
+      allow(chef_run).to receive(:find_resource).and_return(nil)
+      failure = described_class.new('nope')
+      expect(failure.matches?(chef_run)).to be_falsy
+    end
+  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,68 @@
+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
+
+    it 'has the correct description' do
+      expect(subject.description).to eq('have state attributes [:a, :b]')
+    end
+
+    it 'has the correct failure message for should' do
+      expect(subject.failure_message).to include <<-EOH.gsub(/^ {8}/, '')
+        expected _something_ to have state attributes, but the _something_ you gave me was nil!
+        Ensure the resource exists before making assertions:
+
+          expect(resource).to be
+      EOH
+    end
+
+    it 'has the correct failure message for should not' do
+      expect(subject.failure_message_when_negated).to include <<-EOH.gsub(/^ {8}/, '')
+        expected _something_ to not have state attributes, but the _something_ you gave me was nil!
+        Ensure the resource exists before making assertions:
+
+          expect(resource).to be
+      EOH
+    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) }
+
+    it 'has the correct description' do
+      expect(subject.description).to eq('have state attributes [:a, :b]')
+    end
+
+    it 'has the correct failure message for should' do
+      expect(subject.failure_message).to eq('expected [:a, :b] to equal [:a, :b]')
+    end
+
+    it 'has the correct failure message for should not' do
+      expect(subject.failure_message_when_negated).to 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
+      allow(klass).to receive(: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
+      allow(klass).to receive(: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,65 @@
+require 'spec_helper'
+
+describe ChefSpec::Matchers::SubscribesMatcher do
+  subject { described_class.new('execute[install]') }
+  let(:runner) { double('runner', find_resource: nil) }
+  let(:run_context) { double('run_context', node: node) }
+  let(:node) { double('node', runner: runner) }
+  let(:package) do
+    double('package',
+      name: 'package',
+      to_s: 'package[foo]',
+      run_context: run_context,
+    )
+  end
+
+  context 'when no resource is found' do
+    describe '#failure_message' do
+      it 'has the right value' do
+        subject.matches?(package)
+        expect(subject.failure_message)
+          .to include %|expected _something_ to notify "package[foo]", but the _something_ you gave me was nil! If you are running a test like:|
+      end
+    end
+  end
+
+  context 'when the resource exists' do
+    let(:execute) do
+      double('execute',
+        name: 'execute',
+        to_s: 'execute[install]',
+        immediate_notifications: [],
+        delayed_notifications: [],
+        before_notifications: []
+      )
+    end
+
+    before do
+      allow(runner).to receive(:find_resource).and_return(execute)
+    end
+
+    describe '#failure_message' do
+      it 'has the right value' do
+        subject.matches?(package)
+        expect(subject.failure_message)
+          .to include %|expected "execute[install]" to notify "package[foo]", but did not.|
+      end
+    end
+
+    describe '#failure_message_when_negated' do
+      it 'has the right value' do
+        subject.matches?(package)
+        expect(subject.failure_message_when_negated)
+          .to eq %|expected "execute[install]" to not notify "package[foo]", but it did.|
+      end
+    end
+  end
+
+  describe '#description' do
+    it 'has the right value' do
+      subject.matches?(package)
+      expect(subject.description)
+        .to eq %|notify "package[foo]"|
+    end
+  end
+end