chefspec 9.2.1 → 9.3.0

data/spec/unit/matchers/do_nothing_matcher.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::Matchers::DoNothingMatcher do
   pending

data/spec/unit/matchers/include_any_recipe_matcher_spec.rb

@@ -1,50 +1,50 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::Matchers::IncludeAnyRecipeMatcher do
-  let(:node) { double('Chef::Node', run_list: run_list) }
-  let(:run_list) { double('Chef::RunList', run_list_items: run_list_items) }
+  let(:node) { double("Chef::Node", run_list: run_list) }
+  let(:run_list) { double("Chef::RunList", run_list_items: run_list_items) }
   let(:run_list_items) { [run_list_item_one] }
-  let(:run_list_item_one) { double('Chef::RunList::RunListItem', name: 'one') }
-  let(:run_list_item_two) { double('Chef::RunList::RunListItem', name: 'two') }
-  let(:loaded_recipes) { %w(one) }
-  let(:chef_run) { double('chef run', run_context: { loaded_recipes: loaded_recipes, node: node }) }
+  let(:run_list_item_one) { double("Chef::RunList::RunListItem", name: "one") }
+  let(:run_list_item_two) { double("Chef::RunList::RunListItem", name: "two") }
+  let(:loaded_recipes) { %w{one} }
+  let(:chef_run) { double("chef run", run_context: { loaded_recipes: loaded_recipes, node: node }) }
 
   subject { described_class.new }
 
-  describe '#failure_message' do
-    it 'has the right value' do
+  describe "#failure_message" do
+    it "has the right value" do
       subject.matches?(chef_run)
-      expect(subject.failure_message).to eq('expected to include any recipe')
+      expect(subject.failure_message).to eq("expected to include any recipe")
     end
   end
 
-  describe '#failure_message_when_negated' do
-    it 'has the right value' do
+  describe "#failure_message_when_negated" do
+    it "has the right value" do
       subject.matches?(chef_run)
-      expect(subject.failure_message_when_negated).to eq('expected not to include any recipes')
+      expect(subject.failure_message_when_negated).to eq("expected not to include any recipes")
     end
   end
 
-  describe '#description' do
-    it 'has the right value' do
+  describe "#description" do
+    it "has the right value" do
       subject.matches?(chef_run)
-      expect(subject.description).to eq('include any recipe')
+      expect(subject.description).to eq("include any recipe")
     end
   end
 
-  describe '#matches?' do
-    context 'when 0 recipes are included' do
-      let(:loaded_recipes) { %w(one) }
+  describe "#matches?" do
+    context "when 0 recipes are included" do
+      let(:loaded_recipes) { %w{one} }
 
-      it 'returns false' do
+      it "returns false" do
         expect(subject.matches?(chef_run)).to be false
       end
     end
 
-    context 'when at least one recipe is included' do
-      let(:loaded_recipes) { %w(one two) }
+    context "when at least one recipe is included" do
+      let(:loaded_recipes) { %w{one two} }
 
-      it 'returns true' do
+      it "returns true" do
         expect(subject.matches?(chef_run)).to be true
       end
     end

data/spec/unit/matchers/include_recipe_matcher_spec.rb

@@ -1,38 +1,38 @@
-require 'spec_helper'
+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') }
+  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
+  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"))
+        .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
+  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))
+        .to eq(%q{expected "one::default" to not be included})
     end
   end
 
-  describe '#description' do
-    it 'has the right value' do
+  describe "#description" do
+    it "has the right value" do
       subject.matches?(chef_run)
-      expect(subject.description).to eq(%q(include recipe "one::default"))
+      expect(subject.description).to eq(%q{include recipe "one::default"})
     end
   end
 
-  it 'matches when the recipe is included' do
+  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')
+  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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::Matchers::LinkToMatcher do
-  let(:from) { '/var/www' }
-  let(:to)   { '/var/html' }
+  let(:from) { "/var/www" }
+  let(:to)   { "/var/html" }
   let(:link) do
     Chef::Resource::Link.new(from).tap do |link|
       link.to(to)
@@ -11,44 +11,44 @@ describe ChefSpec::Matchers::LinkToMatcher do
   end
   subject { described_class.new(to) }
 
-  describe '#failure_message' do
-    it 'has the right value' do
+  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}"))
+        .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
+  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}"))
+        .to eq(%Q{expected "link[#{from}]" to not link to "#{to}"})
     end
   end
 
-  describe '#description' do
-    it 'has the right value' do
+  describe "#description" do
+    it "has the right value" do
       subject.matches?(link)
-      expect(subject.description).to eq(%Q(link to "#{to}"))
+      expect(subject.description).to eq(%Q{link to "#{to}"})
     end
   end
 
-  context 'when the link is correct' do
-    it 'matches' do
+  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
+    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') }
+  context "when the link is not correct" do
+    subject { described_class.new("/nope/bad/path/bro") }
 
-    it 'does not match' do
+    it "does not match" do
       expect(subject.matches?(link)).to be_falsy
     end
   end

data/spec/unit/matchers/notifications_matcher_spec.rb

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

data/spec/unit/matchers/render_file_matcher_spec.rb

@@ -1,67 +1,67 @@
-require 'spec_helper'
+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) }
+  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
+  describe "#with_content" do
+    it "accepts do/end syntax" do
       subject.matches?(chef_run)
       expect(
         subject.with_content do |content|
-          'Does not raise ArgumentError'
+          "Does not raise ArgumentError"
         end.expected_content.first.call
-      ).to eq('Does not raise ArgumentError')
+      ).to eq("Does not raise ArgumentError")
     end
   end
 
-  describe '#failure_message' do
-    it 'has the right value' do
+  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}"))
+        .to eq(%Q{expected Chef run to render "#{path}"})
     end
   end
 
-  describe '#failure_message_when_negated' do
-    it 'has the right value' do
+  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))
+        .to eq(%Q{expected file "#{path}" to not be in Chef run})
     end
   end
 
-  describe '#description' do
-    it 'has the right value' do
+  describe "#description" do
+    it "has the right value" do
       subject.matches?(chef_run)
-      expect(subject.description).to eq(%Q(render file "#{path}"))
+      expect(subject.description).to eq(%Q{render file "#{path}"})
     end
 
-    it 'has the right value when with_content is chained' do
+    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"))
+        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
+  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
+    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
+  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')
+      failure = described_class.new("nope")
       expect(failure.matches?(chef_run)).to be_falsy
     end
   end

data/spec/unit/matchers/resource_matcher_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::Matchers::ResourceMatcher do
   pending

data/spec/unit/matchers/state_attrs_matcher_spec.rb

@@ -1,22 +1,22 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::Matchers::StateAttrsMatcher do
-  subject { described_class.new([:a, :b]) }
+  subject { described_class.new(%i{a b}) }
 
-  context 'when the resource does not exist' do
+  context "when the resource does not exist" do
     let(:resource) { nil }
     before { subject.matches?(resource) }
 
-    it 'does not match' do
+    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]')
+    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}/, '')
+    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:
 
@@ -24,8 +24,8 @@ describe ChefSpec::Matchers::StateAttrsMatcher do
       EOH
     end
 
-    it 'has the correct failure message for should not' do
-      expect(subject.failure_message_when_negated).to include <<-EOH.gsub(/^ {8}/, '')
+    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:
 
@@ -34,34 +34,34 @@ describe ChefSpec::Matchers::StateAttrsMatcher do
     end
   end
 
-  context 'when the resource exists' do
-    let(:klass) { double('class', state_attrs: [:a, :b]) }
-    let(:resource) { double('resource', class: klass) }
+  context "when the resource exists" do
+    let(:klass) { double("class", state_attrs: %i{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]')
+    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]')
+    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]')
+    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
+    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])
+    it "does not match when the state attributes are incorrect" do
+      allow(klass).to receive(:state_attrs).and_return(%i{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])
+    it "does not match when partial state attribute are incorrect" do
+      allow(klass).to receive(:state_attrs).and_return(%i{b c})
       expect(subject).to_not be_matches(resource)
     end
   end