chefspec 3.4.0 → 4.0.0

data/lib/chefspec/version.rb

@@ -1,3 +1,3 @@
 module ChefSpec
-  VERSION = '3.4.0'
+  VERSION = '4.0.0'
 end

data/spec/unit/cacher_spec.rb

@@ -7,7 +7,7 @@ describe ChefSpec::Cacher do
       extend ChefSpec::Cacher
 
       def self.metadata
-        { example_group: { location: 'spec' } }
+        { parent_example_group: { location: 'spec' } }
       end
     end
   end

data/spec/unit/expect_exception_spec.rb

@@ -5,8 +5,8 @@ describe ChefSpec::ExpectException do
     subject { described_class.new(Exception) }
 
     it 'does not match' do
-      RSpec::Matchers::BuiltIn::RaiseError.stub(:last_run).and_return(nil)
-      expect(subject.expected?).to be_false
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(nil)
+      expect(subject.expected?).to be_falsy
     end
   end
 
@@ -15,8 +15,8 @@ describe ChefSpec::ExpectException do
 
     it 'does not match' do
       last_error = double('last error', last_error_for_chefspec: ArgumentError)
-      RSpec::Matchers::BuiltIn::RaiseError.stub(:last_run).and_return(last_error)
-      expect(subject.expected?).to be_false
+      allow(RSpec::Matchers::BuiltIn::RaiseError).to receive(:last_run).and_return(last_error)
+      expect(subject.expected?).to be_falsy
     end
   end
 
@@ -25,8 +25,8 @@ describe ChefSpec::ExpectException do
 
     it 'does not match' do
       last_error = double('last error', last_error_for_chefspec: RuntimeError)
-      RSpec::Matchers::BuiltIn::RaiseError.stub(:last_run).and_return(last_error)
-      expect(subject.expected?).to be_true
+      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/extensions/lwrp_base_spec.rb

@@ -9,7 +9,7 @@ if Chef::VERSION >= '11.0.0'
         describe '#remove_existing_lwrp' do
           before do
             Chef::Provider::MysqlDatabase = nil
-            Chef::Resource::MysqlDatabase = nil
+            Chef::Resource::MysqlDatabase = Class.new(Chef::Resource)
           end
 
           after do
@@ -40,6 +40,8 @@ if Chef::VERSION >= '11.0.0'
           end
 
           context Chef::Resource do
+            let!(:resource_class) { Chef::Resource::MysqlDatabase }
+
             before do
               Chef::Resource::LWRPBase.remove_existing_lwrp('MysqlDatabase')
             end
@@ -48,6 +50,12 @@ if Chef::VERSION >= '11.0.0'
               expect(Chef::Resource.constants).to_not include(:MysqlDatabase)
             end
 
+            if Chef::Resource.respond_to?(:resource_classes)
+              it 'removes the resource from Chef::Resource.resource_classes' do
+                expect(Chef::Resource.resource_classes).to_not include(resource_class)
+              end
+            end
+
             it 'does not remove the provider'  do
               Chef::Resource::LWRPBase.remove_existing_lwrp('MysqlDatabase')
               expect(Chef::Provider.constants).to include(:MysqlDatabase)

data/spec/unit/macros_spec.rb

@@ -5,7 +5,7 @@ describe ChefSpec::Macros do
     let(:command_stub) { double('command') }
 
     it 'adds the command to the command registry' do
-      ChefSpec::Stubs::CommandStub.stub(:new).and_return(command_stub)
+      allow(ChefSpec::Stubs::CommandStub).to receive(:new).and_return(command_stub)
       described_class.stub_command('echo "hello"')
 
       expect(ChefSpec::Stubs::CommandRegistry.stubs).to include(command_stub)
@@ -16,7 +16,7 @@ describe ChefSpec::Macros do
     let(:search_stub) { double('search') }
 
     it 'adds the query to the search registry' do
-      ChefSpec::Stubs::SearchStub.stub(:new).and_return(search_stub)
+      allow(ChefSpec::Stubs::SearchStub).to receive(:new).and_return(search_stub)
       described_class.stub_search(:node, '*:*')
 
       expect(ChefSpec::Stubs::SearchRegistry.stubs).to include(search_stub)
@@ -27,7 +27,7 @@ describe ChefSpec::Macros do
     let(:data_bag_stub) { double('data_bag') }
 
     it 'adds the query to the data_bag registry' do
-      ChefSpec::Stubs::DataBagStub.stub(:new).and_return(data_bag_stub)
+      allow(ChefSpec::Stubs::DataBagStub).to receive(:new).and_return(data_bag_stub)
       described_class.stub_data_bag(:users)
 
       expect(ChefSpec::Stubs::DataBagRegistry.stubs).to include(data_bag_stub)
@@ -38,7 +38,7 @@ describe ChefSpec::Macros do
     let(:data_bag_item_stub) { double('data_bag_item') }
 
     it 'adds the query to the data_bag_item registry' do
-      ChefSpec::Stubs::DataBagItemStub.stub(:new).and_return(data_bag_item_stub)
+      allow(ChefSpec::Stubs::DataBagItemStub).to receive(:new).and_return(data_bag_item_stub)
       described_class.stub_data_bag_item(:users, 'id')
 
       expect(ChefSpec::Stubs::DataBagItemRegistry.stubs).to include(data_bag_item_stub)
@@ -76,8 +76,8 @@ describe ChefSpec::Macros do
     end
 
     it 'sets the automatic attributes from a JSON data path' do
-      File.stub(:exists?).with('/path/to/json').and_return(true)
-      File.stub(:read).with('/path/to/json').and_return('{ "ipaddress": "1.2.3.4" }')
+      allow(File).to receive(:exists?).with('/path/to/json').and_return(true)
+      allow(File).to receive(:read).with('/path/to/json').and_return('{ "ipaddress": "1.2.3.4" }')
       node = described_class.stub_node('node.example', path: '/path/to/json')
       expect(node['ipaddress']).to eq('1.2.3.4')
     end

data/spec/unit/matchers/include_recipe_matcher_spec.rb

@@ -4,18 +4,18 @@ 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
+  describe '#failure_message' do
     it 'has the right value' do
       subject.matches?(chef_run)
-      expect(subject.failure_message_for_should)
+      expect(subject.failure_message)
         .to eq(%q(expected ["one::default", "two::default", "three::default"] to include "one::default"))
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '#failure_message_when_negated' do
     it 'has the right value' do
       subject.matches?(chef_run)
-      expect(subject.failure_message_for_should_not)
+      expect(subject.failure_message_when_negated)
         .to eq(%q(expected "one::default" to not be included))
     end
   end
@@ -28,11 +28,11 @@ describe ChefSpec::Matchers::IncludeRecipeMatcher do
   end
 
   it 'matches when the recipe is included' do
-    expect(subject.matches?(chef_run)).to be_true
+    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_false
+    expect(failure.matches?(chef_run)).to be_falsy
   end
 end

data/spec/unit/matchers/link_to_matcher_spec.rb

@@ -1,39 +1,55 @@
 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) }
+  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_for_should' do
+  describe '#failure_message' 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}"))
+      expect(subject.failure_message)
+        .to eq(%Q(expected "link[#{from}]" to link to "#{to}" but was "#{to}"))
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '#failure_message_when_negated' 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}"))
+      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 "#{path}"))
+      expect(subject.description).to eq(%Q(link to "#{to}"))
     end
   end
 
-  it 'matches when the link is correct' do
-    expect(subject.matches?(link)).to be_true
+  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
 
-  it 'does not match when the link is incorrect' do
-    failure = described_class.new('nope')
-    expect(failure.matches?(link)).to be_false
+  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

@@ -13,18 +13,18 @@ describe ChefSpec::Matchers::NotificationsMatcher do
     )
   end
 
-  describe '#failure_message_for_should' do
+  describe '#failure_message' do
     it 'has the right value' do
       subject.matches?(package)
-      expect(subject.failure_message_for_should)
+      expect(subject.failure_message)
         .to include %|expected "package[foo]" to notify "execute[install]", but did not.|
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '#failure_message_when_negated' do
     it 'has the right value' do
       subject.matches?(package)
-      expect(subject.failure_message_for_should_not)
+      expect(subject.failure_message_when_negated)
         .to eq %|expected "package[foo]" to not notify "execute[install]", but it did.|
     end
   end

data/spec/unit/matchers/render_file_matcher_spec.rb

@@ -6,18 +6,18 @@ describe ChefSpec::Matchers::RenderFileMatcher do
   let(:chef_run) { double('chef run', find_resource: file) }
   subject { described_class.new(path) }
 
-  describe '#failure_message_for_should' do
+  describe '#failure_message' do
     it 'has the right value' do
       subject.matches?(chef_run)
-      expect(subject.failure_message_for_should)
+      expect(subject.failure_message)
         .to eq(%Q(expected Chef run to render "#{path}"))
     end
   end
 
-  describe '#failure_message_for_should_not' do
+  describe '#failure_message_when_negated' do
     it 'has the right value' do
       subject.matches?(chef_run)
-      expect(subject.failure_message_for_should_not)
+      expect(subject.failure_message_when_negated)
         .to eq(%Q(expected file "#{path}" to not be in Chef run))
     end
   end
@@ -29,13 +29,22 @@ describe ChefSpec::Matchers::RenderFileMatcher do
     end
   end
 
-  it 'matches when the file is correct' do
-    expect(subject.matches?(chef_run)).to be_true
+  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
 
-  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
+  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/state_attrs_matcher_spec.rb

@@ -11,26 +11,26 @@ describe ChefSpec::Matchers::StateAttrsMatcher do
       expect(subject).to_not be_matches(resource)
     end
 
-    its(:description) { should eq('have state attributes [:a, :b]') }
+    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:
 
-    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 "
+          expect(resource).to be
+      EOH
     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 "
+    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
 
@@ -39,12 +39,16 @@ describe ChefSpec::Matchers::StateAttrsMatcher do
     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]')
+    it 'has the correct description' do
+      expect(subject.description).to eq('have state attributes [:a, :b]')
     end
-    its(:failure_message_for_should_not) do
-      should eq('expected [:a, :b] to not equal [:a, :b]')
+
+    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
@@ -52,12 +56,12 @@ describe ChefSpec::Matchers::StateAttrsMatcher do
     end
 
     it 'does not match when the state attributes are incorrect' do
-      klass.stub(:state_attrs).and_return([:c, :d])
+      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
-      klass.stub(:state_attrs).and_return([:b, :c])
+      allow(klass).to receive(:state_attrs).and_return([:b, :c])
       expect(subject).to_not be_matches(resource)
     end
   end

data/spec/unit/matchers/subscribes_matcher_spec.rb

@@ -14,10 +14,10 @@ describe ChefSpec::Matchers::SubscribesMatcher do
   end
 
   context 'when no resource is found' do
-    describe '#failure_message_for_should' do
+    describe '#failure_message' do
       it 'has the right value' do
         subject.matches?(package)
-        expect(subject.failure_message_for_should)
+        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
@@ -34,21 +34,21 @@ describe ChefSpec::Matchers::SubscribesMatcher do
     end
 
     before do
-      runner.stub(:find_resource).and_return(execute)
+      allow(runner).to receive(:find_resource).and_return(execute)
     end
 
-    describe '#failure_message_for_should' do
+    describe '#failure_message' do
       it 'has the right value' do
         subject.matches?(package)
-        expect(subject.failure_message_for_should)
+        expect(subject.failure_message)
           .to include %|expected "execute[install]" to notify "package[foo]", but did not.|
       end
     end
 
-    describe '#failure_message_for_should_not' do
+    describe '#failure_message_when_negated' do
       it 'has the right value' do
         subject.matches?(package)
-        expect(subject.failure_message_for_should_not)
+        expect(subject.failure_message_when_negated)
           .to eq %|expected "execute[install]" to not notify "package[foo]", but it did.|
       end
     end

data/spec/unit/renderer_spec.rb

@@ -15,35 +15,35 @@ describe ChefSpec::Renderer do
 
   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')
+      allow(subject).to receive(:content_from_cookbook_file).and_return('cookbook_file content')
+      allow(subject).to receive(:content_from_file).and_return('file content')
+      allow(subject).to receive(: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')
+        allow(resource).to receive(: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')
+        allow(resource).to receive(: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')
+        allow(resource).to receive(: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')
+        allow(resource).to receive(:resource_name).and_return('service')
         expect(subject.content).to be_nil
       end
     end