cucumber_analytics 1.5.1 → 1.5.2

data/spec/unit/table_row_unit_spec.rb

@@ -18,7 +18,7 @@ describe 'TableRow, 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 'TableRow, Unit' do
   end
 
   it 'has cells' do
-    @row.should respond_to(:cells)
+    expect(@row.respond_to?(:cells)).to be true
   end
 
   it 'can get and set its 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 'table 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 table row' do

data/spec/unit/table_unit_spec.rb

@@ -17,9 +17,9 @@ describe 'Table, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.row_elements.collect { |row| row.cells }.should == [['a table']]
+    expect(@element.row_elements.collect { |row| row.cells }).to eq([['a table']])
     # todo - remove once #contents is no longer supported
-    @element.contents.should == [['a table']]
+    expect(@element.contents).to eq([['a table']])
   end
 
   before(:each) do
@@ -28,35 +28,35 @@ describe 'Table, Unit' do
 
   # todo - remove once #contents is no longer supported
   it 'has contents - #contents' do
-    @table.should respond_to(:contents)
+    expect(@table.respond_to?(:contents)).to be true
   end
 
   # todo - remove once #contents is no longer supported
   it 'can get and set its contents - #contents, #contents=' do
     @table.contents = :some_contents
-    @table.contents.should == :some_contents
+    expect(@table.contents).to eq(:some_contents)
     @table.contents = :some_other_contents
-    @table.contents.should == :some_other_contents
+    expect(@table.contents).to eq(:some_other_contents)
   end
 
   # todo - remove once #contents is no longer supported
   it 'starts with no contents' do
-    @table.contents.should == []
+    expect(@table.contents).to eq([])
   end
 
   it 'has row elements' do
-    @table.should respond_to(:row_elements)
+    expect(@table.respond_to?(:row_elements)).to be true
   end
 
   it 'can get and set its row elements' do
     @table.row_elements = :some_row_elements
-    @table.row_elements.should == :some_row_elements
+    expect(@table.row_elements).to eq(:some_row_elements)
     @table.row_elements = :some_other_row_elements
-    @table.row_elements.should == :some_other_row_elements
+    expect(@table.row_elements).to eq(:some_other_row_elements)
   end
 
   it 'starts with no row elements' do
-    @table.row_elements.should == []
+    expect(@table.row_elements).to eq([])
   end
 
   # todo - remove once #contents is no longer supported
@@ -66,18 +66,18 @@ describe 'Table, Unit' do
 
     contents = table.contents
 
-    contents.is_a?(Array).should be_true
+    expect(contents).to be_a(Array)
 
     contents.each do |row|
-      row.is_a?(Array).should be_true
-      row.each { |cell| cell.is_a?(String).should be_true }
+      expect(row).to be_a(Array)
+      row.each { |cell| expect(cell).to be_a(String) }
     end
   end
 
   context 'table output edge cases' do
 
     it 'is a String' do
-      @table.to_s.should be_a(String)
+      expect(@table.to_s).to be_a(String)
     end
 
     it 'can output an empty table' do

data/spec/unit/tag_unit_spec.rb

@@ -17,7 +17,7 @@ describe 'Tag, Unit' do
     source = '@a_tag'
 
     expect { @element = clazz.new(source) }.to_not raise_error
-    @element.name.should == '@a_tag'
+    expect(@element.name).to eq('@a_tag')
   end
 
   before(:each) do
@@ -26,20 +26,20 @@ describe 'Tag, Unit' do
 
 
   it 'has a name' do
-    @element.should respond_to(:name)
+    expect(@element.respond_to?(:name)).to be true
   end
 
   it 'can get and set its name' do
     @element.name = :some_name
-    @element.name.should == :some_name
+    expect(@element.name).to eq(:some_name)
     @element.name = :some_other_name
-    @element.name.should == :some_other_name
+    expect(@element.name).to eq(:some_other_name)
   end
 
   context 'tag output edge cases' do
 
     it 'is a String' do
-      @element.to_s.should be_a(String)
+      expect(@element.to_s).to be_a(String)
     end
 
     it 'can output an empty tag' do

data/spec/unit/taggable_unit_spec.rb

@@ -20,25 +20,25 @@ describe 'Taggable, Unit' do
 
 
   it 'has tags' do
-    @element.should respond_to(:tags)
-    @element.should respond_to(:tag_elements)
+    expect(@element.respond_to?(:tags)).to be true
+    expect(@element.respond_to?(:tag_elements)).to be true
   end
 
   it 'can get and set its tags' do
     @element.tags = :some_tags
-    @element.tags.should == :some_tags
+    expect(@element.tags).to eq(:some_tags)
     @element.tags = :some_other_tags
-    @element.tags.should == :some_other_tags
+    expect(@element.tags).to eq(:some_other_tags)
 
     @element.tag_elements = :some_tag_elements
-    @element.tag_elements.should == :some_tag_elements
+    expect(@element.tag_elements).to eq(:some_tag_elements)
     @element.tag_elements = :some_other_tag_elements
-    @element.tag_elements.should == :some_other_tag_elements
+    expect(@element.tag_elements).to eq(:some_other_tag_elements)
   end
 
   it 'has applied tags' do
-    @element.should respond_to(:applied_tags)
-    @element.should respond_to(:applied_tag_elements)
+    expect(@element.respond_to?(:applied_tags)).to be true
+    expect(@element.respond_to?(:applied_tag_elements)).to be true
   end
 
   it 'inherits its applied tags from its ancestors' do
@@ -48,8 +48,8 @@ describe 'Taggable, Unit' do
 
     @element.parent_element = parent
 
-    @element.applied_tags.should == all_parent_tags
-    @element.applied_tag_elements.should == all_parent_tag_elements
+    expect(@element.applied_tags).to eq(all_parent_tags)
+    expect(@element.applied_tag_elements).to eq(all_parent_tag_elements)
   end
 
   it 'knows all of its applicable tags' do
@@ -64,15 +64,15 @@ describe 'Taggable, Unit' do
     @element.tags = own_tags
     @element.tag_elements = own_tag_elements
 
-    @element.all_tags.should == all_parent_tags + own_tags
-    @element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
+    expect(@element.all_tags).to eq(all_parent_tags + own_tags)
+    expect(@element.all_tag_elements).to eq(all_parent_tag_elements + own_tag_elements)
   end
 
   it 'may have no applied tags' do
     @element.parent_element = :not_a_tagged_object
 
-    @element.applied_tags.should == []
-    @element.applied_tag_elements.should == []
+    expect(@element.applied_tags).to eq([])
+    expect(@element.applied_tag_elements).to eq([])
   end
 
 end

data/spec/unit/tagged_element_unit_specs.rb

@@ -7,30 +7,30 @@ shared_examples_for 'a tagged element' do |clazz|
   end
 
   it 'has tags' do
-    @element.should respond_to(:tags)
-    @element.should respond_to(:tag_elements)
+    expect(@element.respond_to?(:tags)).to be true
+    expect(@element.respond_to?(:tag_elements)).to be true
   end
 
   it 'can get and set its tags' do
     @element.tags = :some_tags
-    @element.tags.should == :some_tags
+    expect(@element.tags).to eq(:some_tags)
     @element.tags = :some_other_tags
-    @element.tags.should == :some_other_tags
+    expect(@element.tags).to eq(:some_other_tags)
 
     @element.tag_elements = :some_tag_elements
-    @element.tag_elements.should == :some_tag_elements
+    expect(@element.tag_elements).to eq(:some_tag_elements)
     @element.tag_elements = :some_other_tag_elements
-    @element.tag_elements.should == :some_other_tag_elements
+    expect(@element.tag_elements).to eq(:some_other_tag_elements)
   end
 
   it 'starts with no tags' do
-    @element.tags.should == []
-    @element.tag_elements.should == []
+    expect(@element.tags).to eq([])
+    expect(@element.tag_elements).to eq([])
   end
 
   it 'has applied tags' do
-    @element.should respond_to(:applied_tags)
-    @element.should respond_to(:applied_tag_elements)
+    expect(@element.respond_to?(:applied_tags)).to be true
+    expect(@element.respond_to?(:applied_tag_elements)).to be true
   end
 
   it 'inherits its applied tags from its ancestors' do
@@ -40,8 +40,8 @@ shared_examples_for 'a tagged element' do |clazz|
 
     @element.parent_element = parent
 
-    @element.applied_tags.should == all_parent_tags
-    @element.applied_tag_elements.should == all_parent_tag_elements
+    expect(@element.applied_tags).to eq(all_parent_tags)
+    expect(@element.applied_tag_elements).to eq(all_parent_tag_elements)
   end
 
   it 'knows all of its applicable tags' do
@@ -56,8 +56,8 @@ shared_examples_for 'a tagged element' do |clazz|
     @element.tags = own_tags
     @element.tag_elements = own_tag_elements
 
-    @element.all_tags.should == all_parent_tags + own_tags
-    @element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
+    expect(@element.all_tags).to eq(all_parent_tags + own_tags)
+    expect(@element.all_tag_elements).to eq(all_parent_tag_elements + own_tag_elements)
   end
 
 end

data/spec/unit/test_element_unit_spec.rb

@@ -21,7 +21,7 @@ describe 'TestElement, Unit' do
     steps = [:step_1, :step_2, :step_3]
     @element.steps = steps
 
-    @element.contains.should =~ steps
+    expect(@element.contains).to match_array(steps)
   end
 
   it 'can determine its equality with another TestElement - #==' do
@@ -33,8 +33,16 @@ describe 'TestElement, Unit' do
     element_2.steps = :some_steps
     element_3.steps = :some_other_steps
 
-    (element_1 == element_2).should be_true
-    (element_1 == element_3).should be_false
+    expect(element_1).to eq(element_2)
+    expect(element_1).to_not eq(element_3)
+  end
+
+  it 'can gracefully be compared to other types of objects' do
+    # Some common types of object
+    [1, 'foo', :bar, [], {}].each do |thing|
+      expect { @element == thing }.to_not raise_error
+      expect(@element == thing).to be false
+    end
   end
 
 end

data/spec/unit/test_element_unit_specs.rb

@@ -7,25 +7,25 @@ shared_examples_for 'a test element' do |clazz|
   end
 
   it 'has steps - #steps' do
-    @element.should respond_to(:steps)
+    expect(@element.respond_to?(:steps)).to be true
   end
 
   it 'can get and set its steps - #steps, #steps=' do
     @element.steps = :some_steps
-    @element.steps.should == :some_steps
+    expect(@element.steps).to eq(:some_steps)
     @element.steps = :some_other_steps
-    @element.steps.should == :some_other_steps
+    expect(@element.steps).to eq(:some_other_steps)
   end
 
   it 'starts with no steps' do
-    @element.steps.should == []
+    expect(@element.steps).to eq([])
   end
 
   it 'contains steps - #contains' do
     steps = [:step_1, :step_2, :step_3]
     @element.steps = steps
 
-    steps.each { |step| @element.contains.should include(step) }
+    steps.each { |step| expect(@element.contains).to include(step) }
   end
 
 end

data/spec/unit/world_unit_spec.rb

@@ -11,49 +11,49 @@ describe 'World, Unit' do
   end
 
   it 'has left and right delimiters used for step argument parsing - #left_delimiter, #right_delimiter' do
-    @world.should respond_to(:left_delimiter)
-    @world.should respond_to(:right_delimiter)
+    expect(@world.respond_to?(:left_delimiter)).to be true
+    expect(@world.respond_to?(:right_delimiter)).to be true
   end
 
   it 'can get and set the delimiters used for step argument parsing' do
     @world.left_delimiter = '"'
     @world.right_delimiter = '"'
-    @world.left_delimiter.should == '"'
-    @world.right_delimiter.should == '"'
+    expect(@world.left_delimiter).to eq('"')
+    expect(@world.right_delimiter).to eq('"')
 
     @world.left_delimiter = '!'
     @world.right_delimiter = '!'
-    @world.left_delimiter.should == '!'
-    @world.right_delimiter.should == '!'
+    expect(@world.left_delimiter).to eq('!')
+    expect(@world.right_delimiter).to eq('!')
   end
 
   it 'can have different left and right delimiters' do
     @world.left_delimiter = '"'
     @world.right_delimiter = '*'
 
-    (@world.left_delimiter != @world.right_delimiter).should be_true
+    expect(@world.left_delimiter).to_not eq(@world.right_delimiter)
   end
 
   it 'can set both of its delimiters at once - #delimiter=' do
     @world.delimiter = '*'
 
-    @world.left_delimiter.should == '*'
-    @world.right_delimiter.should == '*'
+    expect(@world.left_delimiter).to eq('*')
+    expect(@world.right_delimiter).to eq('*')
   end
 
   it 'starts with no delimiters' do
-    @world.left_delimiter.should == nil
-    @world.right_delimiter.should == nil
+    expect(@world.left_delimiter).to be_nil
+    expect(@world.right_delimiter).to be_nil
   end
 
   context 'step patterns' do
 
     it 'can load step patterns - #load_step_pattern' do
-      @world.should respond_to(:load_step_pattern)
+      expect(@world.respond_to?(:load_step_pattern)).to be true
     end
 
     it 'starts with no patterns loaded' do
-      @world.loaded_step_patterns.should == []
+      expect(@world.loaded_step_patterns).to eq([])
     end
 
     it 'keeps track of loaded step patterns - #loaded_step_patterns' do
@@ -63,7 +63,7 @@ describe 'World, Unit' do
         @world.load_step_pattern(pattern)
       end
 
-      @world.loaded_step_patterns.should =~ patterns
+      expect(@world.loaded_step_patterns).to match_array(patterns)
     end
 
     it 'can load step definition files - #load_step_file' do
@@ -78,7 +78,7 @@ describe 'World, Unit' do
 
       @world.load_step_file(file_path)
 
-      @world.loaded_step_patterns.should =~ patterns
+      expect(@world.loaded_step_patterns).to match_array(patterns)
     end
 
     it 'can handle different step keywords - #load_step_file' do
@@ -95,7 +95,7 @@ describe 'World, Unit' do
 
       @world.load_step_file(file_path)
 
-      @world.loaded_step_patterns.should =~ patterns
+      expect(@world.loaded_step_patterns).to match_array(patterns)
     end
 
     it 'can handle a variety of declaration structures - #load_step_file' do
@@ -110,7 +110,7 @@ describe 'World, Unit' do
 
       @world.load_step_file(file_path)
 
-      @world.loaded_step_patterns.should =~ patterns
+      expect(@world.loaded_step_patterns).to match_array(patterns)
     end
 
     it 'can clear its loaded step patterns - #clear_step_patterns' do
@@ -120,9 +120,9 @@ describe 'World, Unit' do
         @world.load_step_pattern(pattern)
       end
 
-      @world.loaded_step_patterns.should =~ patterns
+      expect(@world.loaded_step_patterns).to match_array(patterns)
       @world.clear_step_patterns
-      @world.loaded_step_patterns.should == []
+      expect(@world.loaded_step_patterns).to eq([])
     end
 
   end
@@ -138,43 +138,43 @@ describe 'World, Unit' do
       nested_container = double(:tags => @set_2, :tag_elements => @set_2)
       container = double(:tags => @set_1, :tag_elements => @set_1, :contains => [nested_container])
 
-      @world.tags_in(container).should =~ (@set_1 + @set_2)
-      @world.tag_elements_in(container).should =~ (@set_1 + @set_2)
+      expect(@world.tags_in(container)).to match_array((@set_1 + @set_2))
+      expect(@world.tag_elements_in(container)).to match_array((@set_1 + @set_2))
     end
 
     it 'can collect directories from containers' do
       nested_container = double(:directories => @set_2)
       container = double(:directories => @set_1, :contains => [nested_container])
 
-      @world.directories_in(container).should =~ (@set_1 + @set_2)
+      expect(@world.directories_in(container)).to match_array((@set_1 + @set_2))
     end
 
     it 'can collect feature files from containers' do
       nested_container = double(:feature_files => @set_2)
       container = double(:feature_files => @set_1, :contains => [nested_container])
 
-      @world.feature_files_in(container).should =~ (@set_1 + @set_2)
+      expect(@world.feature_files_in(container)).to match_array((@set_1 + @set_2))
     end
 
     it 'can collect features from containers' do
       nested_container = double(:features => @set_2)
       container = double(:features => @set_1, :contains => [nested_container])
 
-      @world.features_in(container).should =~ (@set_1 + @set_2)
+      expect(@world.features_in(container)).to match_array((@set_1 + @set_2))
     end
 
     it 'can collect tests from containers' do
       nested_container = double(:tests => @set_2)
       container = double(:tests => @set_1, :contains => [nested_container])
 
-      @world.tests_in(container).should =~ (@set_1 + @set_2)
+      expect(@world.tests_in(container)).to match_array((@set_1 + @set_2))
     end
 
     it 'can collect steps from containers' do
       nested_container = double(:steps => @set_2)
       container = double(:steps => @set_1, :contains => [nested_container])
 
-      @world.steps_in(container).should =~ (@set_1 + @set_2)
+      expect(@world.steps_in(container)).to match_array((@set_1 + @set_2))
     end
 
   end