stairs 0.9.0 → 0.10.0

data/spec/lib/stairs/interactive_configuration_spec.rb

@@ -1,51 +1,58 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Stairs::InteractiveConfiguration do
   subject { described_class.new }
 
-  describe "metadata" do
-    it "has a title" do
+  describe 'metadata' do
+    it 'has a title' do
       expect(described_class.step_title).not_to be_nil
     end
 
-    it "has a description" do
+    it 'has a description' do
       expect(described_class.step_description).not_to be_nil
     end
   end
 
-  describe "#run!" do
+  describe '#run!' do
     before do
-      Stairs::EnvAdapters.stub recommended_adapter: Stairs::EnvAdapters::Rbenv
+      allow(Stairs::EnvAdapters)
+        .to receive(:recommended_adapter).and_return(Stairs::EnvAdapters::Rbenv)
     end
 
-    it "recommends an adapter" do
-      output = follow_prompts("Y") { subject.run! }
+    it 'recommends an adapter' do
+      output = follow_prompts('Y') { subject.run! }
       expect(output).to include "you're using rbenv"
     end
 
-    it "sets the adapter" do
-      follow_prompts("Y") { subject.run! }
-      expect(Stairs.configuration.env_adapter).to be_a Stairs::EnvAdapters::Rbenv
+    it 'sets the adapter' do
+      follow_prompts('Y') { subject.run! }
+      expect(Stairs.configuration.env_adapter)
+        .to be_a Stairs::EnvAdapters::Rbenv
     end
 
-    it "allows for specifying your desired adapter" do
-      follow_prompts("N", "dotenv") { subject.run! }
-      expect(Stairs.configuration.env_adapter).to be_a Stairs::EnvAdapters::Dotenv
+    it 'allows for specifying your desired adapter' do
+      follow_prompts('N', 'dotenv') { subject.run! }
+      expect(Stairs.configuration.env_adapter)
+        .to be_a Stairs::EnvAdapters::Dotenv
     end
 
-    context "when Stairs is configured to use defaults" do
+    context 'when Stairs is configured to use defaults' do
       before { Stairs.configuration.use_defaults = true }
 
-      it "uses the default adapter without asking" do
+      it 'uses the default adapter without asking' do
         subject.run!
-        expect(Stairs.configuration.env_adapter).to be_a Stairs::EnvAdapters::Rbenv
+        expect(Stairs.configuration.env_adapter)
+          .to be_a Stairs::EnvAdapters::Rbenv
       end
     end
 
-    context "when no adapter can be found to recommend" do
-      before { Stairs::EnvAdapters.stub recommended_adapter: nil }
+    context 'when no adapter can be found to recommend' do
+      before do
+        allow(Stairs::EnvAdapters)
+          .to receive(:recommended_adapter).and_return(nil)
+      end
 
-      it "aborts" do
+      it 'aborts' do
         expect { subject.run! }.to raise_error SystemExit
       end
     end

data/spec/lib/stairs/runner_spec.rb

@@ -1,36 +1,40 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Stairs::Runner do
   let(:groups) { nil }
   let(:subject) { described_class.new(groups) }
 
-  describe "#run!" do
-    let(:script_double) { double("script", run!: true) }
+  describe '#run!' do
+    let(:script_double) { double('script', run!: true) }
 
     before do
       # Stub things as to not block IO
-      Stairs::InteractiveConfiguration.any_instance.stub :run!
-      Stairs::Script.any_instance.stub :run!
-      Stairs::Script.stub(:new).and_return(script_double)
+      allow_any_instance_of(Stairs::InteractiveConfiguration).to receive(:run!)
+      allow_any_instance_of(Stairs::Script).to receive(:run!)
+      allow(Stairs::Script).to receive(:new).and_return(script_double)
     end
 
-    it "runs the interactive configuration" do
-      Stairs::InteractiveConfiguration.any_instance.should_receive(:run!)
+    it 'runs the interactive configuration' do
+      expect_any_instance_of(Stairs::InteractiveConfiguration)
+        .to receive(:run!)
+
       subject.run!
     end
 
-    it "runs all groups in the setup.rb script" do
-      Stairs::Script.should_receive(:new).with("setup.rb", groups).and_return(script_double)
-      script_double.should_receive(:run!)
+    it 'runs all groups in the setup.rb script' do
+      expect(Stairs::Script)
+        .to receive(:new).with('setup.rb', groups).and_return(script_double)
+
+      expect(script_double).to receive(:run!)
 
       subject.run!
     end
 
-    context "with groups provided" do
+    context 'with groups provided' do
       let(:groups) { [:reset] }
 
-      it "passes the specified groups to the script" do
-        Stairs::Script.should_receive(:new).with("setup.rb", groups)
+      it 'passes the specified groups to the script' do
+        expect(Stairs::Script).to receive(:new).with('setup.rb', groups)
         subject.run!
       end
     end

data/spec/lib/stairs/script_spec.rb

@@ -1,38 +1,37 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Stairs::Script do
-  let(:filename) { "setup.rb" }
+  let(:filename) { 'setup.rb' }
   let(:groups) { [:reset] }
   subject { described_class.new(filename, groups) }
 
-
-  context "with a script present" do
+  context 'with a script present' do
     before do
-      File.open(filename, "w") do |file|
-        file.write("self.class")
+      File.open(filename, 'w') do |file|
+        file.write('self.class')
       end
     end
 
     after { File.delete(filename) }
 
-    describe "initialize" do
-      it "receives groups" do
+    describe 'initialize' do
+      it 'receives groups' do
         expect { described_class.new(filename, groups) }.not_to raise_error
       end
     end
 
-    describe "#run!" do
-      it "outputs running message" do
+    describe '#run!' do
+      it 'outputs running message' do
         output = capture_stdout { subject.run! }
-        expect(output).to include "= Running script setup.rb"
+        expect(output).to include '= Running script setup.rb'
       end
 
-      it "passes groups to the new instance of Step" do
-        Stairs::Step.should_receive(:new).with(groups)
+      it 'passes groups to the new instance of Step' do
+        expect(Stairs::Step).to receive(:new).with(groups)
         subject.run!
       end
 
-      it "evaluates the script in the context of an instance of Step" do
+      it 'evaluates the script in the context of an instance of Step' do
         # because our test setup.rb only contains `self.class` we can check
         # this way:
         expect(subject.run!).to eq Stairs::Step

data/spec/lib/stairs/step_spec.rb

@@ -1,349 +1,378 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Stairs::Step do
   let(:anon_step) { Class.new(described_class) }
   let(:groups) { nil }
   subject { anon_step.new(groups) }
 
-  describe "metadata" do
-    describe "step_title" do
-      it "can be set on the class using title class DSL" do
-        anon_step.title "Class Step Name"
-        expect(subject.step_title).to eq "Class Step Name"
+  describe 'metadata' do
+    describe 'step_title' do
+      it 'can be set on the class using title class DSL' do
+        anon_step.title 'Class Step Name'
+        expect(subject.step_title).to eq 'Class Step Name'
       end
 
-      it "can be set on the instance" do
-        subject.step_title = "Instance Step Name"
-        expect(subject.step_title).to eq "Instance Step Name"
+      it 'can be set on the instance' do
+        subject.step_title = 'Instance Step Name'
+        expect(subject.step_title).to eq 'Instance Step Name'
       end
 
-      it "prefers the value set on instance" do
-        anon_step.title "Class Step Name"
-        subject.step_title = "Instance Step Name"
-        expect(subject.step_title).to eq "Instance Step Name"
+      it 'prefers the value set on instance' do
+        anon_step.title 'Class Step Name'
+        subject.step_title = 'Instance Step Name'
+        expect(subject.step_title).to eq 'Instance Step Name'
       end
     end
 
-    describe "step_description" do
-      it "can be set on the class using description class DSL" do
-        anon_step.description "Class Step Description"
-        expect(subject.step_description).to eq "Class Step Description"
+    describe 'step_description' do
+      it 'can be set on the class using description class DSL' do
+        anon_step.description 'Class Step Description'
+        expect(subject.step_description).to eq 'Class Step Description'
       end
 
-      it "can be set on the instance" do
-        subject.step_description = "Instance Step Description"
-        expect(subject.step_description).to eq "Instance Step Description"
+      it 'can be set on the instance' do
+        subject.step_description = 'Instance Step Description'
+        expect(subject.step_description).to eq 'Instance Step Description'
       end
 
-      it "prefers the value set on instance" do
-        anon_step.title "Class Step Description"
-        subject.step_description = "Instance Step Description"
-        expect(subject.step_description).to eq "Instance Step Description"
+      it 'prefers the value set on instance' do
+        anon_step.title 'Class Step Description'
+        subject.step_description = 'Instance Step Description'
+        expect(subject.step_description).to eq 'Instance Step Description'
       end
     end
   end
 
-  describe "#initialize" do
-    describe "options" do
-      describe "default options" do
-        it "is required" do
-          expect(subject.options[:required]).to be_true
+  describe '#initialize' do
+    describe 'options' do
+      describe 'default options' do
+        it 'is required' do
+          expect(subject.options[:required]).to eq true
         end
       end
 
-      context "with options" do
-        let(:options) { { something: "cool" } }
+      context 'with options' do
+        let(:options) { { something: 'cool' } }
         subject { anon_step.new(options) }
 
-        it "exposes options on the instance" do
-          expect(subject.options[:something]).to eq "cool"
+        it 'exposes options on the instance' do
+          expect(subject.options[:something]).to eq 'cool'
         end
       end
     end
 
-    it "exposes supplied groups on the instance" do
+    it 'exposes supplied groups on the instance' do
       expect(subject.groups).to eq groups
     end
   end
 
-  describe "#run!" do
-    before { subject.stub run: true }
-    before { anon_step.title "Step Name" }
+  describe '#run!' do
+    before { allow(subject).to receive(:run).and_return(true) }
+    before { anon_step.title 'Step Name' }
 
-    it "outputs lead-in message" do
+    it 'outputs lead-in message' do
       output = capture_stdout { subject.run! }
-      expect(output).to include "== Running Step Name"
+      expect(output).to include '== Running Step Name'
     end
 
-    it "calls #run where the implementation lives" do
-      subject.should_receive(:run)
+    it 'calls #run where the implementation lives' do
+      expect(subject).to receive(:run)
       subject.run!
     end
 
-    it "outputs completed message" do
+    it 'outputs completed message' do
       output = capture_stdout { subject.run! }
-      expect(output).to include "== Completed Step Name"
+      expect(output).to include '== Completed Step Name'
     end
 
-    context "when the step is not required" do
+    context 'when the step is not required' do
       subject { anon_step.new required: false }
-      before { subject.stub run: true }
+      before { allow(subject).to receive(:run).and_return(true) }
 
-      it "prompts the user to decide if we should run the step" do
-        output = follow_prompts("Y") { subject.run! }
-        expect(output).to include "This step is optional, would you like to perform it? (Y/N): "
+      it 'prompts the user to decide if we should run the step' do
+        output = follow_prompts('Y') { subject.run! }
+        expect(output).to include 'This step is optional, would you like to ' \
+                                  'perform it? (Y/N): '
       end
 
-      context "user says yes" do
-        it "runs the step" do
-          subject.should_receive :run
-          follow_prompts("Y") { subject.run! }
+      context 'user says yes' do
+        it 'runs the step' do
+          expect(subject).to receive(:run)
+          follow_prompts('Y') { subject.run! }
         end
       end
 
-      context "user says no" do
+      context 'user says no' do
         it "doesn't run the step" do
-          subject.should_not_receive :run
-          follow_prompts("N") { subject.run! }
+          expect(subject).not_to receive(:run)
+          follow_prompts('N') { subject.run! }
         end
       end
     end
   end
 
-  describe "#provide" do
-    it "prompts the user to provide input" do
-      output = follow_prompts("here") { subject.provide "Gimme" }
-      expect(output).to include "Gimme: "
+  describe '#provide' do
+    it 'prompts the user to provide input' do
+      output = follow_prompts('here') { subject.provide 'Gimme' }
+      expect(output).to include 'Gimme: '
     end
 
-    it "returns the input" do
-      follow_prompts("here") do
-        expect(subject.provide("Gimme")).to eq "here"
+    it 'returns the input' do
+      follow_prompts('here') do
+        expect(subject.provide('Gimme')).to eq 'here'
       end
     end
 
-    it "requires user input" do
-      follow_prompts "", "", "", "finally" do
-        expect(subject.provide("Gimme")).to eq "finally"
+    it 'requires user input' do
+      follow_prompts '', '', '', 'finally' do
+        expect(subject.provide('Gimme')).to eq 'finally'
       end
     end
 
-    context "Stairs is configured to use defaults automatically" do
+    context 'Stairs is configured to use defaults automatically' do
       before { Stairs.configuration.use_defaults = true }
 
-      context "but no default is provided" do
-        it "prompts for input as usual" do
-          follow_prompts "here ya go" do
-            expect(subject.provide("Gimme")).to eq "here ya go"
+      context 'but no default is provided' do
+        it 'prompts for input as usual' do
+          follow_prompts 'here ya go' do
+            expect(subject.provide('Gimme')).to eq 'here ya go'
           end
         end
       end
 
-      context "and a default is provided" do
-        it "returns the default without prompting" do
-          expect(subject.provide("Gimme", default: "adefault")).to eq "adefault"
+      context 'and a default is provided' do
+        it 'returns the default without prompting' do
+          expect(subject.provide('Gimme', default: 'adefault')).to eq 'adefault'
         end
       end
     end
 
-    context "with a default" do
+    context 'with a default' do
       def call_method
-        subject.provide "Gimme", default: "adefault"
+        subject.provide 'Gimme', default: 'adefault'
       end
 
-      it "does not require input" do
-        output = follow_prompts("here") { call_method }
+      it 'does not require input (this test would hang if it did)' do
+        follow_prompts('here') { call_method }
       end
 
-      context "and required" do
-        it "does not require input" do
-          follow_prompts "" do
-            expect(subject.provide("Gimme", required: true, default: "adefault")).to eq "adefault"
+      context 'and required' do
+        it 'does not require input' do
+          follow_prompts '' do
+            expect(
+              subject.provide('Gimme', required: true, default: 'adefault')
+            ).to eq 'adefault'
           end
         end
       end
 
-      context "with no input" do
-        it "returns the default" do
-          follow_prompts("") do
-            expect(call_method).to eq "adefault"
+      context 'with no input' do
+        it 'returns the default' do
+          follow_prompts('') do
+            expect(call_method).to eq 'adefault'
           end
         end
       end
 
-      context "with input" do
-        it "returns the input" do
-          follow_prompts("here") do
-            expect(call_method).to eq "here"
+      context 'with input' do
+        it 'returns the input' do
+          follow_prompts('here') do
+            expect(call_method).to eq 'here'
           end
         end
       end
     end
 
-    context "optional" do
-      it "does not require input" do
-        follow_prompts "" do
-          expect(subject.provide("Gimme", required: false)).to eq nil
+    context 'optional' do
+      it 'does not require input' do
+        follow_prompts '' do
+          expect(subject.provide('Gimme', required: false)).to eq nil
+        end
+      end
+    end
+
+    context 'with frozen string literals (in anticipation of ruby3)' do
+      it 'does not attempt to modify frozen string' do
+        follow_prompts 'here' do
+          expect { subject.provide('Gimme') }.not_to raise_error
         end
       end
     end
   end
 
-  describe "#choice" do
-    it "prompts the user to answer the question" do
-      output = follow_prompts("Y") { subject.choice("Should I?") }
-      expect(output).to include "Should I?"
+  describe '#choice' do
+    it 'prompts the user to answer the question' do
+      output = follow_prompts('Y') { subject.choice('Should I?') }
+      expect(output).to include 'Should I?'
     end
 
-    it "defaults to a Y/N question" do
-      output = follow_prompts("Y") { subject.choice("Should I?") }
-      expect(output).to include "(Y/N)"
+    it 'defaults to a Y/N question' do
+      output = follow_prompts('Y') { subject.choice('Should I?') }
+      expect(output).to include '(Y/N)'
     end
 
-    it "returns true for Y" do
-      follow_prompts("Y") { expect(subject.choice("Should I?")).to be_true }
+    it 'returns true for Y' do
+      follow_prompts('Y') { expect(subject.choice('Should I?')).to eq true }
     end
 
-    it "returns true for Y" do
-      follow_prompts("N") { expect(subject.choice("Should I?")).to be_false }
+    it 'returns true for Y' do
+      follow_prompts('N') { expect(subject.choice('Should I?')).to eq false }
     end
 
-    context "with available choices provided" do
-      it "displays those choices" do
-        output = follow_prompts("Nick") { subject.choice("What's your name?", ["Nick", "Brendan"]) }
-        expect(output).to include "(Nick/Brendan)"
+    context 'with available choices provided' do
+      it 'displays those choices' do
+        output = follow_prompts('Nick') do
+          subject.choice("What's your name?", %w(Nick Brendan))
+        end
+
+        expect(output).to include '(Nick/Brendan)'
       end
 
       it "returns the user's choice" do
-        follow_prompts("Nick") do
-          expect(subject.choice("What's your name?", ["Nick", "Brendan"])).to eq "Nick"
+        follow_prompts('Nick') do
+          expect(subject.choice("What's your name?", %w(Nick Brendan)))
+            .to eq 'Nick'
         end
       end
 
-      it "prompts repeatedly until it receives input in available choices" do
-        follow_prompts("Sally", "Frank", "Nick") do
-          expect(subject.choice("What's your name?", ["Nick", "Brendan"])).to eq "Nick"
+      it 'prompts repeatedly until it receives input in available choices' do
+        follow_prompts('Sally', 'Frank', 'Nick') do
+          expect(subject.choice("What's your name?", %w(Nick Brendan)))
+            .to eq 'Nick'
         end
       end
     end
 
-    context "with a block" do
+    context 'with a block' do
       it "calls the block with the user's choice" do
-        follow_prompts("Nick") do
+        follow_prompts('Nick') do
           expect do |block|
-            subject.choice("What's your name?", ["Nick", "Brendan"], &block)
-          end.to yield_with_args("Nick")
+            subject.choice("What's your name?", %w(Nick Brendan), &block)
+          end.to yield_with_args('Nick')
         end
       end
     end
   end
 
-  describe "#rake" do
-    before { subject.stub system: true }
+  describe '#rake' do
+    before { allow(subject).to receive(:system).and_return(true) }
 
-    it "outputs lead-in message" do
-      output = capture_stdout { subject.rake "the_task" }
-      expect(output).to include "== Running the_task"
+    it 'outputs lead-in message' do
+      output = capture_stdout { subject.rake 'the_task' }
+      expect(output).to include '== Running the_task'
     end
 
-    it "runs the rake task" do
-      subject.should_receive(:system).with("rake the_task")
-      subject.rake "the_task"
+    it 'runs the rake task' do
+      expect(subject).to receive(:system).with('rake the_task')
+      subject.rake 'the_task'
     end
 
-    it "outputs completed message" do
-      output = capture_stdout { subject.rake "the_task" }
-      expect(output).to include "== Completed the_task"
+    it 'outputs completed message' do
+      output = capture_stdout { subject.rake 'the_task' }
+      expect(output).to include '== Completed the_task'
     end
   end
 
-  describe "#env" do
-    let(:adapter) { double("adapter", set: true) }
+  describe '#env' do
+    let(:adapter) { double('adapter', set: true) }
     before { Stairs.configuration.env_adapter = adapter }
 
     it "delegates to the adapter's set" do
-      adapter.should_receive(:set).with("NAME", "value")
-      subject.env "NAME", "value"
+      expect(adapter).to receive(:set).with('NAME', 'value')
+      subject.env 'NAME', 'value'
     end
 
-    it "writes to ENV simultaneously so Rubyland can access without a reload" do
-      ENV.should_receive(:[]=).with("NAME", "value")
-      subject.env "NAME", "value"
+    it 'writes to ENV simultaneously so Rubyland can access without a reload' do
+      expect(ENV).to receive(:[]=).with('NAME', 'value')
+      subject.env 'NAME', 'value'
     end
 
-    context "with no value" do
+    context 'with no value' do
       it "delegates to the adapter's unset" do
-        adapter.should_receive(:unset).with("NAME")
-        subject.env "NAME", nil
+        expect(adapter).to receive(:unset).with('NAME')
+        subject.env 'NAME', nil
       end
     end
   end
 
-  describe "#write" do
-    it "delegates to the well tested FileMutation util" do
-      Stairs::Util::FileMutation.should_receive(:write).with("something", "file.txt")
-      subject.write("something", "file.txt")
+  describe '#write' do
+    it 'delegates to the well tested FileMutation util' do
+      expect(Stairs::Util::FileMutation)
+        .to receive(:write).with('something', 'file.txt')
+
+      subject.write('something', 'file.txt')
     end
   end
 
-  describe "#write_line" do
-    it "delegates to the well tested FileMutation util" do
-      Stairs::Util::FileMutation.should_receive(:write_line).with("something", "file.txt")
-      subject.write_line("something", "file.txt")
+  describe '#write_line' do
+    it 'delegates to the well tested FileMutation util' do
+      expect(Stairs::Util::FileMutation)
+        .to receive(:write_line).with('something', 'file.txt')
+
+      subject.write_line('something', 'file.txt')
     end
   end
 
-  describe "#finish" do
-    it "outputs lead-in message" do
-      output = capture_stdout { subject.finish "Message" }
-      expect(output).to include "== All done!"
+  describe '#finish' do
+    it 'outputs lead-in message' do
+      output = capture_stdout { subject.finish 'Message' }
+      expect(output).to include '== All done!'
     end
 
-    it "outputs supplied message" do
-      output = capture_stdout { subject.finish "My message" }
-      expect(output).to include "My message"
+    it 'outputs supplied message' do
+      output = capture_stdout { subject.finish 'My message' }
+      expect(output).to include 'My message'
     end
   end
 
-  describe "#stairs_info" do
-    it "outputs the message" do
-      output = capture_stdout { subject.stairs_info "Ohai" }
-      expect(output).to include "Ohai"
+  describe '#stairs_info' do
+    it 'outputs the message' do
+      output = capture_stdout { subject.stairs_info 'Ohai' }
+      expect(output).to include 'Ohai'
     end
   end
 
-  describe "#setup" do
-    context "with an invalid step_name" do
-      it "raises when step_name cannot be resolved in Stairs::Steps" do
+  describe '#setup' do
+    context 'with an invalid step_name' do
+      it 'raises when step_name cannot be resolved in Stairs::Steps' do
         expect { subject.setup :blahblahbefkj }.to raise_error
       end
     end
 
-    context "with a valid step_name" do
-      let!(:mock_step_class) { Stairs::Steps::MockStep = Class.new(Stairs::Step) }
-      before { mock_step_class.any_instance.stub run!: true }
+    context 'with a valid step_name' do
+      let!(:mock_step_class) do
+        Stairs::Steps::MockStep = Class.new(Stairs::Step)
+      end
+      before do
+        allow_any_instance_of(mock_step_class)
+          .to receive(:run!).and_return(true)
+      end
 
-      it "instantiates and runs the step" do
-        mock_step_class.any_instance.should_receive(:run!)
+      it 'instantiates and runs the step' do
+        expect_any_instance_of(mock_step_class).to receive(:run!)
         subject.setup :mock_step
       end
 
-      it "passes groups to the step" do
-        mock_step_class.should_receive(:new).with(groups, {}).and_call_original
+      it 'passes groups to the step' do
+        expect(mock_step_class)
+          .to receive(:new).with(groups, {}).and_call_original
+
         subject.setup :mock_step
       end
 
-      context "with options" do
-        let(:options) { { something: "cool" } }
+      context 'with options' do
+        let(:options) { { something: 'cool' } }
+
+        it 'passes options to the step' do
+          expect(mock_step_class)
+            .to receive(:new).with(groups, options).and_call_original
 
-        it "passes options to the step" do
-          mock_step_class.should_receive(:new).with(groups, options).and_call_original
           subject.setup :mock_step, options
         end
       end
     end
 
-    context "with a block" do
+    context 'with a block' do
       def call_method
         subject.setup(:custom_step) { puts "I'm running in #{self.class}" }
       end
@@ -351,62 +380,69 @@ describe Stairs::Step do
       # Initialize primary subject before asserting against #new for the Step
       # it initializes
       def initialize_primary_subject
-        instance = subject
+        subject
       end
 
       it "sets the new step's title to a titleized version of step_name" do
         output = capture_stdout { call_method }
-        expect(output).to include "Custom Step"
+        expect(output).to include 'Custom Step'
       end
 
-      it "runs the block in the context of the new step" do
+      it 'runs the block in the context of the new step' do
         output = capture_stdout { call_method }
         expect(output).to include "I'm running in Stairs::Step"
       end
 
-      it "passes groups to the step" do
+      it 'passes groups to the step' do
         initialize_primary_subject
 
-        described_class.should_receive(:new).with(groups, {}).and_call_original
+        expect(described_class)
+          .to receive(:new).with(groups, {}).and_call_original
+
         call_method
       end
 
-      context "with options" do
-        let(:options) { { something: "cool" } }
-        before { described_class.any_instance.stub run!: true }
+      context 'with options' do
+        let(:options) { { something: 'cool' } }
+        before do
+          allow_any_instance_of(described_class)
+            .to receive(:run!).and_return(true)
+        end
 
-        it "passes options to the step" do
+        it 'passes options to the step' do
           initialize_primary_subject
 
-          described_class.should_receive(:new).with(groups, options).and_call_original
+          expect(described_class)
+            .to receive(:new).with(groups, options).and_call_original
+
           subject.setup(:custom_step, options) { true }
         end
       end
     end
   end
 
-  describe "#group" do
+  describe '#group' do
     let(:name) { :reset }
 
-    context "when the name is in the groups to run" do
+    context 'when the name is in the groups to run' do
       let(:groups) { [:reset, :init] }
 
-      it "calls the supplied block" do
+      it 'calls the supplied block' do
         expect { |b| subject.group(name, &b) }.to yield_control
       end
     end
 
-    context "when the name is not in the groups to run" do
+    context 'when the name is not in the groups to run' do
       let(:groups) { [:init] }
 
-      it "does not call the supplied block" do
+      it 'does not call the supplied block' do
         expect { |b| subject.group(name, &b) }.not_to yield_control
       end
 
-      context "but no groups to run are provided" do
+      context 'but no groups to run are provided' do
         let(:groups) { nil }
 
-        it "calls the supplied block" do
+        it 'calls the supplied block' do
           expect { |b| subject.group(name, &b) }.to yield_control
         end
       end