chefspec 8.0.1 → 9.3.0

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

data/spec/unit/matchers/subscribes_matcher_spec.rb

@@ -1,65 +1,63 @@
-require 'spec_helper'
+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) }
+  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,
-    )
+    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
+  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:|
+          .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
+  context "when the resource exists" do
     let(:execute) do
-      double('execute',
-        name: 'execute',
-        to_s: 'execute[install]',
+      double("execute",
+        name: "execute",
+        to_s: "execute[install]",
         immediate_notifications: [],
         delayed_notifications: [],
-        before_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
+    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.|
+          .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
+    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.|
+          .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
+  describe "#description" do
+    it "has the right value" do
       subject.matches?(package)
       expect(subject.description)
-        .to eq %|notify "package[foo]"|
+        .to eq %{notify "package[foo]"}
     end
   end
 end

data/spec/unit/renderer_spec.rb

@@ -1,69 +1,69 @@
-require 'spec_helper'
+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')
+  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', {node: 'node'}) }
-  let(:resource) { double('resource', {cookbook: 'cookbook', source: 'source', variables: {}}) }
+  let(:chef_run) { double("chef_run", { node: "node" }) }
+  let(:resource) { double("resource", { cookbook: "cookbook", source: "source", variables: {} }) }
   subject { described_class.new(chef_run, resource) }
 
-  describe '#content' do
+  describe "#content" do
     before do
-      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')
+      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
-        allow(resource).to receive(:resource_name).and_return('cookbook_file')
-        expect(subject.content).to eq('cookbook_file content')
+    context "when the resource is a cookbook_file" do
+      it "renders the cookbook_file content" do
+        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
-        allow(resource).to receive(:resource_name).and_return('file')
-        expect(subject.content).to eq('file content')
+    context "when the resource is a file" do
+      it "renders the file content" do
+        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
-        allow(resource).to receive(:resource_name).and_return('template')
-        expect(subject.content).to eq('template content')
+    context "when the resource is a template" do
+      it "renders the template content" do
+        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
-        allow(resource).to receive(:resource_name).and_return('service')
+    context "when the resource is not a file type" do
+      it "returns nil" do
+        allow(resource).to receive(:resource_name).and_return("service")
         expect(subject.content).to be_nil
       end
     end
   end
 
-  describe 'content_from_template' do
-    it 'renders the template by extending modules for rendering paritals within the template' do
+  describe "content_from_template" do
+    it "renders the template by extending modules for rendering paritals within the template" do
       cookbook_collection = {}
-      cookbook_collection['cookbook'] = double('', {preferred_filename_on_disk_location: "/template/location"} )
-      allow(subject).to receive(:cookbook_collection).with('node').and_return(cookbook_collection)
+      cookbook_collection["cookbook"] = double("", { preferred_filename_on_disk_location: "/template/location" } )
+      allow(subject).to receive(:cookbook_collection).with("node").and_return(cookbook_collection)
       allow(subject).to receive(:template_finder)
-      
+
       allow(resource).to receive(:helper_modules).and_return([Module.new])
-      allow(resource).to receive(:resource_name).and_return('template')
+      allow(resource).to receive(:resource_name).and_return("template")
 
-      chef_template_context = double('context', {render_template: 'rendered template content',update: nil})
+      chef_template_context = double("context", { render_template: "rendered template content", update: nil })
       allow(Chef::Mixin::Template::TemplateContext).to receive(:new).and_return(chef_template_context)
-      
+
       expect(chef_template_context).to receive(:_extend_modules).with(resource.helper_modules)
-      expect(subject.content).to eq('rendered template content')
+      expect(subject.content).to eq("rendered template content")
     end
   end
 end

data/spec/unit/server_runner_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::ServerRunner do
-  context 'when the RSpec config is set' do
-    it 'does not create a tmpdir' do
+  context "when the RSpec config is set" do
+    it "does not create a tmpdir" do
       allow(RSpec.configuration).to receive(:file_cache_path)
         .and_return("/foo/bar")
       expect(ChefSpec::FileCachePathProxy).to_not receive(:instance)
@@ -10,15 +10,15 @@ describe ChefSpec::ServerRunner do
     end
   end
 
-  context 'when the RSpec config is not set' do
-    it 'creates and returns a tmpdir' do
+  context "when the RSpec config is not set" do
+    it "creates and returns a tmpdir" do
       expect(ChefSpec::FileCachePathProxy).to receive(:instance)
         .and_call_original
       described_class.new
       expect(Chef::Config[:file_cache_path]).to match(/chefspec/)
     end
 
-    it 'uses the same path' do
+    it "uses the same path" do
       val = ChefSpec::FileCachePathProxy.instance.file_cache_path
       expect(described_class.new.options[:file_cache_path]).to eq(val)
       expect(described_class.new.options[:file_cache_path]).to eq(val)

data/spec/unit/solo_runner_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChefSpec::SoloRunner do
   before do
@@ -7,7 +7,7 @@ describe ChefSpec::SoloRunner do
       .and_return(true)
   end
 
-  describe '#initialize' do
+  describe "#initialize" do
     let(:windows_caller_stack) do
       [
         "C:/cookbooks/Temp/spec/test_spec.rb:11:in `block (2 levels) in <top (required)>'",
@@ -29,22 +29,22 @@ describe ChefSpec::SoloRunner do
       ]
     end
 
-    it 'defaults the log level to :warn' do
+    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
+    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
+    it "defaults the cookbook_path to the calling spec" do
       described_class.new
-      expect(Chef::Config.cookbook_path).to eq([File.expand_path('../../../..', __FILE__)])
+      expect(Chef::Config.cookbook_path).to eq([File.expand_path("../../..", __dir__)])
     end
 
-    it 'defaults the cookbook_path to the calling spec when using windows paths' do
+    it "defaults the cookbook_path to the calling spec when using windows paths" do
       runner = described_class.new
       windows_path = runner.instance_exec(windows_caller_stack) { |callstack|
         calling_cookbook_path({}, callstack)
@@ -55,117 +55,117 @@ describe ChefSpec::SoloRunner do
       expect(windows_path).to end_with("C:/cookbooks")
     end
 
-    it 'sets the cookbook path' do
-      described_class.new(cookbook_path: '/tmp/bacon')
-      expect(Chef::Config.cookbook_path).to eq(['/tmp/bacon'])
+    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 file cache path' do
-      described_class.new( file_cache_path: '/tmp/pantoa')
-      expect(Chef::Config.file_cache_path).to eq('/tmp/pantoa')
+    it "sets the file cache path" do
+      described_class.new( file_cache_path: "/tmp/pantoa")
+      expect(Chef::Config.file_cache_path).to eq("/tmp/pantoa")
     end
 
-    it 'sets the Chef::Config' do
-      expect(Chef::Config.cache_type).to eq('Memory')
+    it "sets the Chef::Config" do
+      expect(Chef::Config.cache_type).to eq("Memory")
       expect(Chef::Config.force_logger).to be_truthy
       expect(Chef::Config.no_lazy_load).to be_truthy
       expect(Chef::Config.solo).to be_truthy
       expect(Chef::Config.use_policyfile).to be_falsey
     end
 
-    it 'yields a block to set node attributes' do
+    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
+    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']['bin_dir']).to eq('/usr/local/bin')
-        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')
+      it "sets the default attributes" do
+        expect(hash["os"]).to eq("chefspec")
+        expect(hash["languages"]["ruby"]["bin_dir"]).to eq("/usr/local/bin")
+        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: '18.04').node.to_hash }
+    context "fauxhai attributes" do
+      let(:hash) { described_class.new(platform: "ubuntu", version: "18.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 match(/4.15.0-.*-.*/) # avoid failing when fauxhai data changes
-        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')
+      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 match(/5.4.0-.*-.*/) # avoid failing when fauxhai data changes
+        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
+    context "RSpec global configuration" do
       before do
-        allow(RSpec.configuration).to receive(:cookbook_path).and_return('./path')
-        allow(RSpec.configuration).to receive(:environment_path).and_return('./env-path')
-        allow(RSpec.configuration).to receive(:file_cache_path).and_return('./file-cache-path')
+        allow(RSpec.configuration).to receive(:cookbook_path).and_return("./path")
+        allow(RSpec.configuration).to receive(:environment_path).and_return("./env-path")
+        allow(RSpec.configuration).to receive(:file_cache_path).and_return("./file-cache-path")
         allow(RSpec.configuration).to receive(:log_level).and_return(:fatal)
-        allow(RSpec.configuration).to receive(:path).and_return('ohai.json')
-        allow(RSpec.configuration).to receive(:platform).and_return('ubuntu')
-        allow(RSpec.configuration).to receive(:version).and_return('12.04')
+        allow(RSpec.configuration).to receive(:path).and_return("ohai.json")
+        allow(RSpec.configuration).to receive(:platform).and_return("ubuntu")
+        allow(RSpec.configuration).to receive(:version).and_return("12.04")
       end
 
-      it 'uses the RSpec values' do
+      it "uses the RSpec values" do
         options = described_class.new.options
-        expect(options[:cookbook_path]).to eq('./path')
-        expect(options[:environment_path]).to eq('./env-path')
-        expect(options[:file_cache_path]).to eq('./file-cache-path')
+        expect(options[:cookbook_path]).to eq("./path")
+        expect(options[:environment_path]).to eq("./env-path")
+        expect(options[:file_cache_path]).to eq("./file-cache-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')
+        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
+  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
+    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.normal['bacon'] = 'ham'
-      expect(subject.node.bacon).to eq('ham')
+    it "allows attributes to be set on the node" do
+      subject.node.normal["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('#<ChefSpec::SoloRunner run_list: [recipe[apache2::default]]>')
+  describe "#to_s" do
+    it "overrides the default string representation to something readable" do
+      expect(subject.converge("apache2::default").to_s)
+        .to eq("#<ChefSpec::SoloRunner run_list: [recipe[apache2::default]]>")
     end
 
-    it 'is ok when a convergence has not yet taken place' do
-      expect(subject.to_s).to eq('#<ChefSpec::SoloRunner run_list: []>')
+    it "is ok when a convergence has not yet taken place" do
+      expect(subject.to_s).to eq("#<ChefSpec::SoloRunner run_list: []>")
     end
 
-    it 'includes the entire run_list' do
-      expect(subject.converge('apache2::default', 'apache2::mod_ssl').to_s)
-        .to eq('#<ChefSpec::SoloRunner run_list: [recipe[apache2::default], recipe[apache2::mod_ssl]]>')
+    it "includes the entire run_list" do
+      expect(subject.converge("apache2::default", "apache2::mod_ssl").to_s)
+        .to eq("#<ChefSpec::SoloRunner run_list: [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) }
+    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('#<ChefSpec::SoloRunner run_list: [recipe[mysql::server]]>')
+        .to eq("#<ChefSpec::SoloRunner run_list: [recipe[mysql::server]]>")
     end
   end
 end