cucumber_analytics 1.5.1 → 1.5.2

data/spec/unit/feature_file_unit_spec.rb

@@ -28,7 +28,7 @@ describe 'FeatureFile, Unit' do
 
     feature = CucumberAnalytics::FeatureFile.new(path)
 
-    feature.name.should == DEFAULT_FEATURE_FILE_NAME
+    expect(feature.name).to eq(DEFAULT_FEATURE_FILE_NAME)
   end
 
   it 'knows the path of the file that it is modeling' do
@@ -37,29 +37,29 @@ describe 'FeatureFile, Unit' do
 
     directory = CucumberAnalytics::FeatureFile.new(path)
 
-    directory.path.should == path
+    expect(directory.path).to eq(path)
   end
 
   it 'has features - #features' do
-    @feature_file.should respond_to(:features)
+    expect(@feature_file.respond_to?(:features)).to be true
   end
 
   it 'can get and set its features - #features, #features=' do
     @feature_file.features = :some_features
-    @feature_file.features.should == :some_features
+    expect(@feature_file.features).to eq(:some_features)
     @feature_file.features = :some_other_features
-    @feature_file.features.should == :some_other_features
+    expect(@feature_file.features).to eq(:some_other_features)
   end
 
   it 'knows how many features it has - #feature_count' do
     @feature_file.features = [:a_feature]
-    @feature_file.feature_count.should == 1
+    expect(@feature_file.feature_count).to eq(1)
     @feature_file.features = []
-    @feature_file.feature_count.should == 0
+    expect(@feature_file.feature_count).to eq(0)
   end
 
   it 'starts with no features' do
-    @feature_file.features.should == []
+    expect(@feature_file.features).to eq([])
   end
 
   it 'contains features' do
@@ -68,21 +68,21 @@ describe 'FeatureFile, Unit' do
 
     @feature_file.features = features
 
-    @feature_file.contains.should =~ everything
+    expect(@feature_file.contains).to match_array(everything)
   end
 
   it 'can easily access its sole feature' do
     @feature_file.features = []
-    @feature_file.feature.should be_nil
+    expect(@feature_file.feature).to be_nil
 
     @feature_file.features = [:a_feature]
-    @feature_file.feature.should == :a_feature
+    expect(@feature_file.feature).to eq(:a_feature)
   end
 
   context 'feature file output edge cases' do
 
     it 'is a String' do
-      @feature_file.to_s.should be_a(String)
+      expect(@feature_file.to_s).to be_a(String)
     end
 
     it 'can output an empty feature file' do

data/spec/unit/feature_unit_spec.rb

@@ -25,7 +25,7 @@ describe 'Feature, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.name.should == 'test feature'
+    expect(@element.name).to eq('test feature')
   end
 
   it 'will complain about unknown element types' do
@@ -37,39 +37,39 @@ describe 'Feature, Unit' do
   end
 
   it 'has a background - #background' do
-    @feature.should respond_to(:background)
+    expect(@feature.respond_to?(:background)).to be true
   end
 
   it 'can get and set its background - #background, #background=' do
     @feature.background = :some_background
-    @feature.background.should == :some_background
+    expect(@feature.background).to eq(:some_background)
     @feature.background = :some_other_background
-    @feature.background.should == :some_other_background
+    expect(@feature.background).to eq(:some_other_background)
   end
 
   it 'knows whether or not it presently has a background - has_background?' do
     @feature.background = :a_background
-    @feature.has_background?.should be_true
+    expect(@feature).to have_background
     @feature.background = nil
-    @feature.has_background?.should be_false
+    expect(@feature).to_not have_background
   end
 
   it 'has tests - #tests' do
-    @feature.should respond_to(:tests)
+    expect(@feature.respond_to?(:tests)).to be true
   end
 
   it 'can get and set its tests - #tests, #tests=' do
     @feature.tests = :some_tests
-    @feature.tests.should == :some_tests
+    expect(@feature.tests).to eq(:some_tests)
     @feature.tests = :some_other_tests
-    @feature.tests.should == :some_other_tests
+    expect(@feature.tests).to eq(:some_other_tests)
   end
 
   it 'knows how many tests it has - #test_count' do
     @feature.tests = []
-    @feature.test_count.should == 0
+    expect(@feature.test_count).to eq(0)
     @feature.tests = [:test_1, :test_2]
-    @feature.test_count.should == 2
+    expect(@feature.test_count).to eq(2)
   end
 
   it 'contains backgrounds and tests' do
@@ -80,7 +80,7 @@ describe 'Feature, Unit' do
     @feature.background = background
     @feature.tests = tests
 
-    @feature.contains.should =~ everything
+    expect(@feature.contains).to match_array(everything)
   end
 
   it 'contains a background only if one is present' do
@@ -91,21 +91,21 @@ describe 'Feature, Unit' do
     @feature.background = background
     @feature.tests = tests
 
-    @feature.contains.should =~ everything
+    expect(@feature.contains).to match_array(everything)
   end
 
   it 'starts with no background' do
-    @feature.background.should == nil
+    expect(@feature.background).to be_nil
   end
 
   it 'starts with no tests' do
-    @feature.tests.should == []
+    expect(@feature.tests).to eq([])
   end
 
   context 'feature output edge cases' do
 
     it 'is a String' do
-      @feature.to_s.should be_a(String)
+      expect(@feature.to_s).to be_a(String)
     end
 
     it 'can output an empty feature' do

data/spec/unit/nested_element_unit_specs.rb

@@ -7,26 +7,26 @@ shared_examples_for 'a nested element' do |clazz|
   end
 
   it 'has a parent element - #parent_element' do
-    @nested_element.should respond_to(:parent_element)
+    expect(@nested_element.respond_to?(:parent_element)).to be true
   end
 
   it 'can get and set its parent element - #parent_element, #parent_element=' do
     @nested_element.parent_element = :some_parent_element
-    @nested_element.parent_element.should == :some_parent_element
+    expect(@nested_element.parent_element).to eq(:some_parent_element)
     @nested_element.parent_element = :some_other_parent_element
-    @nested_element.parent_element.should == :some_other_parent_element
+    expect(@nested_element.parent_element).to eq(:some_other_parent_element)
   end
 
   it 'starts with no parent element' do
-    @nested_element.parent_element.should == nil
+    expect(@nested_element.parent_element).to be_nil
   end
 
   it 'has access to its ancestors' do
-    @nested_element.should respond_to(:get_ancestor)
+    expect(@nested_element.respond_to?(:get_ancestor)).to be true
   end
 
   it 'gets an ancestor based on type' do
-    (clazz.instance_method(:get_ancestor).arity == 1).should be_true
+    expect(clazz.instance_method(:get_ancestor).arity == 1).to be true
   end
 
   it 'raises and exception if an unknown ancestor type is requested' do

data/spec/unit/nested_unit_spec.rb

@@ -12,22 +12,22 @@ describe 'Nested, Unit' do
 
 
   it 'has a parent element - #parent_element' do
-    @nested_element.should respond_to(:parent_element)
+    expect(@nested_element.respond_to?(:parent_element)).to be true
   end
 
   it 'can get and set its parent element - #parent_element, #parent_element=' do
     @nested_element.parent_element = :some_parent_element
-    @nested_element.parent_element.should == :some_parent_element
+    expect(@nested_element.parent_element).to eq(:some_parent_element)
     @nested_element.parent_element = :some_other_parent_element
-    @nested_element.parent_element.should == :some_other_parent_element
+    expect(@nested_element.parent_element).to eq(:some_other_parent_element)
   end
 
   it 'has access to its ancestors' do
-    @nested_element.should respond_to(:get_ancestor)
+    expect(@nested_element.respond_to?(:get_ancestor)).to be true
   end
 
   it 'gets an ancestor based on type' do
-    (nodule.instance_method(:get_ancestor).arity == 1).should be_true
+    expect(nodule.instance_method(:get_ancestor).arity == 1).to be true
   end
 
   it 'raises and exception if an unknown ancestor type is requested' do

data/spec/unit/outline_unit_spec.rb

@@ -23,7 +23,7 @@ describe 'Outline, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.name.should == 'test outline'
+    expect(@element.name).to eq('test outline')
   end
 
 
@@ -33,18 +33,18 @@ describe 'Outline, Unit' do
 
 
   it 'has examples - #examples' do
-    @outline.should respond_to(:examples)
+    expect(@outline.respond_to?(:examples)).to be true
   end
 
   it 'can get and set its examples - #examples, #examples=' do
     @outline.examples = :some_examples
-    @outline.examples.should == :some_examples
+    expect(@outline.examples).to eq(:some_examples)
     @outline.examples = :some_other_examples
-    @outline.examples.should == :some_other_examples
+    expect(@outline.examples).to eq(:some_other_examples)
   end
 
   it 'starts with no examples' do
-    @outline.examples.should == []
+    expect(@outline.examples).to eq([])
   end
 
   it 'contains steps and examples' do
@@ -55,13 +55,13 @@ describe 'Outline, Unit' do
     @outline.steps = steps
     @outline.examples = examples
 
-    @outline.contains.should =~ everything
+    expect(@outline.contains).to match_array(everything)
   end
 
   context 'outline output edge cases' do
 
     it 'is a String' do
-      @outline.to_s.should be_a(String)
+      expect(@outline.to_s).to be_a(String)
     end
 
     it 'can output an empty outline' do

data/spec/unit/parsing_unit_spec.rb

@@ -5,17 +5,17 @@ SimpleCov.command_name('Parsing') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'Parsing, Unit' do
 
   it 'can parse text - #parse_text' do
-    CucumberAnalytics::Parsing.should respond_to(:parse_text)
+    expect(CucumberAnalytics::Parsing.respond_to?(:parse_text)).to be true
   end
 
   it 'can only parse strings' do
-    expect{CucumberAnalytics::Parsing.parse_text(5)}.to raise_error(ArgumentError)
-    expect{CucumberAnalytics::Parsing.parse_text('Feature:')}.to_not raise_error
+    expect { CucumberAnalytics::Parsing.parse_text(5) }.to raise_error(ArgumentError)
+    expect { CucumberAnalytics::Parsing.parse_text('Feature:') }.to_not raise_error
   end
 
   it 'returns an Array' do
     result = CucumberAnalytics::Parsing.parse_text('Feature:')
-    result.is_a?(Array).should be_true
+    expect(result).to be_a(Array)
   end
 
 end

data/spec/unit/prepopulated_unit_specs.rb

@@ -7,7 +7,7 @@ shared_examples_for 'a prepopulated element' do |clazz|
   end
 
   it 'can take an argument' do
-    (clazz.instance_method(:initialize).arity != 0).should be_true
+    expect(clazz.instance_method(:initialize).arity != 0).to be true
   end
 
 end

data/spec/unit/raw_element_unit_specs.rb

@@ -7,18 +7,18 @@ shared_examples_for 'a raw element' do |clazz|
   end
 
   it 'has an underlying implementation representation - #raw_element' do
-    @element.should respond_to(:raw_element)
+    expect(@element.respond_to?(:raw_element)).to be true
   end
 
   it 'can get and set its underlying implementation representation - #raw_element, #raw_element=' do
     @element.raw_element = :some_raw_element
-    @element.raw_element.should == :some_raw_element
+    expect(@element.raw_element).to eq(:some_raw_element)
     @element.raw_element = :some_other_raw_element
-    @element.raw_element.should == :some_other_raw_element
+    expect(@element.raw_element).to eq(:some_other_raw_element)
   end
 
   it 'starts with no underlying implementation representation' do
-    @element.raw_element.should == nil
+    expect(@element.raw_element).to be_nil
   end
 
 end

data/spec/unit/raw_unit_spec.rb

@@ -12,14 +12,14 @@ describe 'Raw, Unit' do
 
 
   it 'has a raw element - #raw_element' do
-    @element.should respond_to(:raw_element)
+    expect(@element.respond_to?(:raw_element)).to be true
   end
 
   it 'can get and set its raw element - #raw_element, #raw_element=' do
     @element.raw_element = :some_raw_element
-    @element.raw_element.should == :some_raw_element
+    expect(@element.raw_element).to eq(:some_raw_element)
     @element.raw_element = :some_other_raw_element
-    @element.raw_element.should == :some_other_raw_element
+    expect(@element.raw_element).to eq(:some_other_raw_element)
   end
 
 end

data/spec/unit/row_unit_spec.rb

@@ -18,7 +18,7 @@ describe 'Row, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.cells.should == ['a', 'row']
+    expect(@element.cells).to eq(['a', 'row'])
   end
 
   before(:each) do
@@ -26,24 +26,24 @@ describe 'Row, Unit' do
   end
 
   it 'has cells - #cells' do
-    @row.should respond_to(:cells)
+    expect(@row.respond_to?(:cells)).to be true
   end
 
   it 'can get and set its cells - #cells, #cells=' do
     @row.cells = :some_cells
-    @row.cells.should == :some_cells
+    expect(@row.cells).to eq(:some_cells)
     @row.cells = :some_other_cells
-    @row.cells.should == :some_other_cells
+    expect(@row.cells).to eq(:some_other_cells)
   end
 
   it 'starts with no cells' do
-    @row.cells.should == []
+    expect(@row.cells).to eq([])
   end
 
   context 'row output edge cases' do
 
     it 'is a String' do
-      @row.to_s.should be_a(String)
+      expect(@row.to_s).to be_a(String)
     end
 
     it 'can output an empty row' do

data/spec/unit/scenario_unit_spec.rb

@@ -22,7 +22,7 @@ describe 'Scenario, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.name.should == 'test scenario'
+    expect(@element.name).to eq('test scenario')
   end
 
   before(:each) do
@@ -35,13 +35,13 @@ describe 'Scenario, Unit' do
 
     @scenario.steps = steps
 
-    @scenario.contains.should =~ everything
+    expect(@scenario.contains).to match_array(everything)
   end
 
   context 'scenario output edge cases' do
 
     it 'is a String' do
-      @scenario.to_s.should be_a(String)
+      expect(@scenario.to_s).to be_a(String)
     end
 
     it 'can output an empty scenario' do

data/spec/unit/sourceable_unit_spec.rb

@@ -11,7 +11,7 @@ describe 'Sourceable, Unit' do
   end
 
   it 'has a source line - #source_line' do
-    @element.should respond_to(:source_line)
+    expect(@element.respond_to?(:source_line)).to be true
   end
 
 end

data/spec/unit/sourced_element_unit_specs.rb

@@ -8,11 +8,11 @@ shared_examples_for 'a sourced element' do |clazz|
 
 
   it 'has a source line - #source_line' do
-    @element.should respond_to(:source_line)
+    expect(@element.respond_to?(:source_line)).to be true
   end
 
   it 'starts with no source line' do
-    @element.source_line.should == nil
+    expect(@element.source_line).to be_nil
   end
 
 end

data/spec/unit/step_unit_spec.rb

@@ -17,105 +17,105 @@ describe 'Step, Unit' do
   end
 
   it 'has arguments - #arguments' do
-    @step.should respond_to(:arguments)
+    expect(@step.respond_to?(:arguments)).to be true
   end
 
   it 'can get and set its arguments - #arguments, #arguments=' do
     @step.arguments = :some_arguments
-    @step.arguments.should == :some_arguments
+    expect(@step.arguments).to eq(:some_arguments)
     @step.arguments = :some_other_arguments
-    @step.arguments.should == :some_other_arguments
+    expect(@step.arguments).to eq(:some_other_arguments)
   end
 
   it 'starts with no arguments' do
-    @step.arguments.should == []
+    expect(@step.arguments).to eq([])
   end
 
   it 'has a base - #base' do
-    @step.should respond_to(:base)
+    expect(@step.respond_to?(:base)).to be true
   end
 
   it 'can get and set its base - #base, #base=' do
     @step.base = :some_base
-    @step.base.should == :some_base
+    expect(@step.base).to eq(:some_base)
     @step.base = :some_other_base
-    @step.base.should == :some_other_base
+    expect(@step.base).to eq(:some_other_base)
   end
 
   it 'starts with no base' do
-    @step.base.should == nil
+    expect(@step.base).to be_nil
   end
 
   it 'has a block - #block' do
-    @step.should respond_to(:block)
+    expect(@step.respond_to?(:block)).to be true
   end
 
   it 'can get and set its block - #block, #block=' do
     @step.block = :some_block
-    @step.block.should == :some_block
+    expect(@step.block).to eq(:some_block)
     @step.block = :some_other_block
-    @step.block.should == :some_other_block
+    expect(@step.block).to eq(:some_other_block)
   end
 
   it 'starts with no block' do
-    @step.block.should == nil
+    expect(@step.block).to be_nil
   end
 
   it 'has a keyword - #keyword' do
-    @step.should respond_to(:keyword)
+    expect(@step.respond_to?(:keyword)).to be true
   end
 
   it 'can get and set its keyword - #keyword, #keyword=' do
     @step.keyword = :some_keyword
-    @step.keyword.should == :some_keyword
+    expect(@step.keyword).to eq(:some_keyword)
     @step.keyword = :some_other_keyword
-    @step.keyword.should == :some_other_keyword
+    expect(@step.keyword).to eq(:some_other_keyword)
   end
 
   it 'starts with no keyword' do
-    @step.keyword.should == nil
+    expect(@step.keyword).to be_nil
   end
 
   it 'has a left delimiter - #left_delimiter' do
-    @step.should respond_to(:left_delimiter)
+    expect(@step.respond_to?(:left_delimiter)).to be true
   end
 
   it 'can get and set its left delimiter - #left_delimiter, #left_delimiter=' do
     @step.left_delimiter = :some_left_delimiter
-    @step.left_delimiter.should == :some_left_delimiter
+    expect(@step.left_delimiter).to eq(:some_left_delimiter)
     @step.left_delimiter = :some_other_left_delimiter
-    @step.left_delimiter.should == :some_other_left_delimiter
+    expect(@step.left_delimiter).to eq(:some_other_left_delimiter)
   end
 
   it 'starts with no left delimiter' do
-    @step.left_delimiter.should == nil
+    expect(@step.left_delimiter).to be_nil
   end
 
   it 'has a right delimiter - #right_delimiter' do
-    @step.should respond_to(:right_delimiter)
+    expect(@step.respond_to?(:right_delimiter)).to be true
   end
 
   it 'can get and set its right delimiter - #right_delimiter, #right_delimiter=' do
     @step.right_delimiter = :some_right_delimiter
-    @step.right_delimiter.should == :some_right_delimiter
+    expect(@step.right_delimiter).to eq(:some_right_delimiter)
     @step.right_delimiter = :some_other_right_delimiter
-    @step.right_delimiter.should == :some_other_right_delimiter
+    expect(@step.right_delimiter).to eq(:some_other_right_delimiter)
   end
 
   it 'starts with no right delimiter' do
-    @step.right_delimiter.should == nil
+    expect(@step.right_delimiter).to be_nil
   end
 
   it 'can set both of its delimiters at once - #delimiter=' do
     @step.delimiter = :new_delimiter
-    @step.left_delimiter.should == :new_delimiter
-    @step.right_delimiter.should == :new_delimiter
+    expect(@step.left_delimiter).to eq(:new_delimiter)
+    expect(@step.right_delimiter).to eq(:new_delimiter)
   end
 
   context '#scan_arguments' do
 
     it 'can explicitly scan for arguments' do
-      @step.should respond_to(:scan_arguments)
+      expect(@step.respond_to?(:scan_arguments)).to be true
     end
 
     it 'can determine its arguments based on a regular expression' do
@@ -123,9 +123,9 @@ describe 'Step, Unit' do
       step = CucumberAnalytics::Step.new(source)
 
       step.scan_arguments(/parameter/)
-      step.arguments.should == ['parameter']
+      expect(step.arguments).to eq(['parameter'])
       step.scan_arguments(/t s/)
-      step.arguments.should == ['t s']
+      expect(step.arguments).to eq(['t s'])
     end
 
     it 'can determine its arguments based on delimiters' do
@@ -134,9 +134,9 @@ describe 'Step, Unit' do
       step = CucumberAnalytics::Step.new(source)
 
       step.scan_arguments('-', '-')
-      step.arguments.should == ['parameter 1', 'parameter 2']
+      expect(step.arguments).to eq(['parameter 1', 'parameter 2'])
       step.scan_arguments('!', '!')
-      step.arguments.should == []
+      expect(step.arguments).to eq([])
     end
 
     it 'can use different left and right delimiters when scanning' do
@@ -145,7 +145,7 @@ describe 'Step, Unit' do
       step = CucumberAnalytics::Step.new(source)
 
       step.scan_arguments('!', '-')
-      step.arguments.should == ['a parameter']
+      expect(step.arguments).to eq(['a parameter'])
     end
 
     it 'can use delimiters of varying lengths' do
@@ -154,7 +154,7 @@ describe 'Step, Unit' do
       step = CucumberAnalytics::Step.new(source)
 
       step.scan_arguments('-start-', '-end-')
-      step.arguments.should == ['a parameter']
+      expect(step.arguments).to eq(['a parameter'])
     end
 
     it 'can handle delimiters with special regular expression characters' do
@@ -163,7 +163,7 @@ describe 'Step, Unit' do
       step = CucumberAnalytics::Step.new(source)
 
       step.scan_arguments('\d+', '.?')
-      step.arguments.should == ['a parameter']
+      expect(step.arguments).to eq(['a parameter'])
     end
 
     it 'defaults to its set delimiters when scanning' do
@@ -174,7 +174,7 @@ describe 'Step, Unit' do
       step.right_delimiter = '"'
       step.scan_arguments
 
-      step.arguments.should == ['parameter 2']
+      expect(step.arguments).to eq(['parameter 2'])
     end
   end
 
@@ -184,7 +184,7 @@ describe 'Step, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.base.should == 'test step'
+    expect(@element.base).to eq('test step')
   end
 
   context '#step_text' do
@@ -196,39 +196,39 @@ describe 'Step, Unit' do
     end
 
     it 'can provide different flavors of step\'s text' do
-      @step.should respond_to(:step_text)
+      expect(@step.respond_to?(:step_text)).to be true
     end
 
     it 'returns different text based on options' do
-      (clazz.instance_method(:step_text).arity != 0).should be_true
+      expect(clazz.instance_method(:step_text).arity != 0).to be true
     end
 
     it 'returns the step\'s text as an Array' do
-      @step.step_text.is_a?(Array).should be_true
+      expect(@step.step_text).to be_a(Array)
     end
 
     it 'can provide the step\'s text without the arguments' do
       expected_output = ['Given a test step with -- ^and@ *parameter 2!!']
 
-      @step.step_text(:with_arguments => false).should == expected_output
+      expect(@step.step_text(:with_arguments => false)).to eq(expected_output)
     end
 
     it 'can determine its arguments based on delimiters' do
       expected_output = ['Given a test step with -parameter 1- ^@ *parameter 2!!']
 
-      @step.step_text(:with_arguments => false, :left_delimiter => '^', :right_delimiter => '@').should == expected_output
+      expect(@step.step_text(:with_arguments => false, :left_delimiter => '^', :right_delimiter => '@')).to eq(expected_output)
     end
 
     it 'can use delimiters of varying lengths' do
       expected_output = ['Given a test step with -parameter 1- ^and@ *!!']
 
-      @step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '!!').should == expected_output
+      expect(@step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '!!')).to eq(expected_output)
     end
 
     it 'can handle delimiters with special regular expression characters' do
       expected_output = ['Given a test step with -parameter 1- ^and@ *!!']
 
-      @step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '!!').should == expected_output
+      expect(@step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '!!')).to eq(expected_output)
     end
 
   end
@@ -236,7 +236,7 @@ describe 'Step, Unit' do
   context 'step output edge cases' do
 
     it 'is a String' do
-      @step.to_s.should be_a(String)
+      expect(@step.to_s).to be_a(String)
     end
 
     it 'can output an empty step' do
@@ -256,4 +256,13 @@ describe 'Step, Unit' do
     end
 
   end
+
+  it 'can gracefully be compared to other types of objects' do
+    # Some common types of object
+    [1, 'foo', :bar, [], {}].each do |thing|
+      expect { @step == thing }.to_not raise_error
+      expect(@step == thing).to be false
+    end
+  end
+
 end