cucumber_analytics 1.5.1 → 1.5.2

data/spec/integration/world_integration_spec.rb

@@ -25,14 +25,14 @@ describe 'World, Integration' do
       nested_container = double(:steps => @defined_steps)
       container = double(:steps => @undefined_steps, :contains => [nested_container])
 
-      @defined_steps.should =~ @world.defined_steps_in(container)
+      expect(@defined_steps).to match_array(@world.defined_steps_in(container))
     end
 
     it 'can collect undefined steps from containers' do
       nested_container = double(:steps => @defined_steps)
       container = double(:steps => @undefined_steps, :contains => [nested_container])
 
-      @undefined_steps.should =~ @world.undefined_steps_in(container)
+      expect(@undefined_steps).to match_array(@world.undefined_steps_in(container))
     end
 
   end

data/spec/unit/background_unit_spec.rb

@@ -21,7 +21,7 @@ describe 'Background, 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 background'
+    expect(@element.name).to eq('test background')
   end
 
   context 'background output edge cases' do
@@ -31,7 +31,7 @@ describe 'Background, Unit' do
     end
 
     it 'is a String' do
-      @background.to_s.should be_a(String)
+      expect(@background.to_s).to be_a(String)
     end
 
     it 'can output an empty background' do

data/spec/unit/containing_element_unit_specs.rb

@@ -7,11 +7,11 @@ shared_examples_for 'a containing element' do |clazz|
   end
 
   it 'has children - #contains' do
-    @element.should respond_to(:contains)
+    expect(@element.respond_to?(:contains)).to be true
   end
 
   it 'returns a collection of children - #contains' do
-    @element.contains.is_a?(Array).should be_true
+    expect(@element.contains).to be_a(Array)
   end
 
 end

data/spec/unit/directory_unit_spec.rb

@@ -26,7 +26,7 @@ describe 'Directory, Unit' do
 
     directory = CucumberAnalytics::Directory.new(path)
 
-    directory.name.should == 'temp_files'
+    expect(directory.name).to eq('temp_files')
   end
 
   it 'knows the path of the directory that it is modeling' do
@@ -34,46 +34,46 @@ describe 'Directory, Unit' do
 
     directory = CucumberAnalytics::Directory.new(path)
 
-    directory.path.should == path
+    expect(directory.path).to eq(path)
   end
 
   it 'has feature files - #feature_files' do
-    @directory.should respond_to(:feature_files)
+    expect(@directory.respond_to?(:feature_files)).to be true
   end
 
   it 'can get and set its feature files - #feature_files, #feature_files=' do
     @directory.feature_files = :some_feature_files
-    @directory.feature_files.should == :some_feature_files
+    expect(@directory.feature_files).to eq(:some_feature_files)
     @directory.feature_files = :some_other_feature_files
-    @directory.feature_files.should == :some_other_feature_files
+    expect(@directory.feature_files).to eq(:some_other_feature_files)
   end
 
   it 'knows how many feature files it has - #feature_file_count' do
     @directory.feature_files = [:file_1, :file_2, :file_3]
 
-    @directory.feature_file_count.should == 3
+    expect(@directory.feature_file_count).to eq(3)
   end
 
   it 'has directories - #directories' do
-    @directory.should respond_to(:directories)
+    expect(@directory.respond_to?(:directories)).to be true
   end
 
   it 'can get and set its directories - #directories, #directories=' do
     @directory.directories = :some_directories
-    @directory.directories.should == :some_directories
+    expect(@directory.directories).to eq(:some_directories)
     @directory.directories = :some_other_directories
-    @directory.directories.should == :some_other_directories
+    expect(@directory.directories).to eq(:some_other_directories)
   end
 
   it 'knows how many directories it has - #directory_count' do
     @directory.directories = [:directory_1, :directory_2, :directory_3]
 
-    @directory.directory_count.should == 3
+    expect(@directory.directory_count).to eq(3)
   end
 
   it 'starts with no feature files or directories' do
-    @directory.feature_files.should == []
-    @directory.directories.should == []
+    expect(@directory.feature_files).to eq([])
+    expect(@directory.directories).to eq([])
   end
 
   it 'contains feature files and directories' do
@@ -84,13 +84,13 @@ describe 'Directory, Unit' do
     @directory.directories = directories
     @directory.feature_files = files
 
-    @directory.contains.should =~ everything
+    expect(@directory.contains).to match_array(everything)
   end
 
   context 'directory output edge cases' do
 
     it 'is a String' do
-      @directory.to_s.should be_a(String)
+      expect(@directory.to_s).to be_a(String)
     end
 
     it 'can output an empty directory' do

data/spec/unit/doc_string_unit_spec.rb

@@ -17,9 +17,9 @@ describe 'DocString, Unit' do
     expect { @element = clazz.new(source) }.to_not raise_error
 
     # Sanity check in case instantiation failed in a non-explosive manner
-    @element.contents_text.should == "some doc string"
+    expect(@element.contents_text).to eq("some doc string")
     #todo Remove once Array contents is no longer supported
-    @element.contents.should == ["some doc string"]
+    expect(@element.contents).to eq(["some doc string"])
   end
 
   before(:each) do
@@ -27,43 +27,43 @@ describe 'DocString, Unit' do
   end
 
   it 'has a content type - #content_type' do
-    @doc_string.should respond_to(:content_type)
+    expect(@doc_string.respond_to?(:content_type)).to be true
   end
 
   it 'can get and set its content type - #content_type, #content_type=' do
     @doc_string.content_type = :some_content_type
-    @doc_string.content_type.should == :some_content_type
+    expect(@doc_string.content_type).to eq(:some_content_type)
     @doc_string.content_type = :some_other_content_type
-    @doc_string.content_type.should == :some_other_content_type
+    expect(@doc_string.content_type).to eq(:some_other_content_type)
   end
 
   it 'starts with no content type' do
-    @doc_string.content_type.should == nil
+    expect(@doc_string.content_type).to be_nil
   end
 
   it 'has contents' do
     #todo Remove once Array contents is no longer supported
-    @doc_string.should respond_to(:contents)
-    @doc_string.should respond_to(:contents_text)
+    expect(@doc_string.respond_to?(:contents)).to be true
+    expect(@doc_string.respond_to?(:contents_text)).to be true
   end
 
   it 'can get and set its contents' do
     #todo Remove once Array contents is no longer supported
     @doc_string.contents = :some_contents
-    @doc_string.contents.should == :some_contents
+    expect(@doc_string.contents).to eq(:some_contents)
     @doc_string.contents = :some_other_contents
-    @doc_string.contents.should == :some_other_contents
+    expect(@doc_string.contents).to eq(:some_other_contents)
 
     @doc_string.contents_text = :some_contents
-    @doc_string.contents_text.should == :some_contents
+    expect(@doc_string.contents_text).to eq(:some_contents)
     @doc_string.contents_text = :some_other_contents
-    @doc_string.contents_text.should == :some_other_contents
+    expect(@doc_string.contents_text).to eq(:some_other_contents)
   end
 
   it 'starts with no contents' do
     #todo Remove once Array contents is no longer supported
-    @doc_string.contents.should == []
-    @doc_string.contents_text.should == ''
+    expect(@doc_string.contents).to eq([])
+    expect(@doc_string.contents_text).to eq('')
   end
 
   #todo Remove once Array contents is no longer supported
@@ -73,9 +73,9 @@ describe 'DocString, Unit' do
 
     contents = doc_string.contents
 
-    contents.is_a?(Array).should be_true
+    expect(contents).to be_a(Array)
     contents.each do |line|
-      line.is_a?(String).should be_true
+      expect(line).to be_a(String)
     end
   end
 
@@ -85,13 +85,13 @@ describe 'DocString, Unit' do
 
     contents = doc_string.contents_text
 
-    contents.is_a?(String).should be_true
+    expect(contents).to be_a(String)
   end
 
   context 'doc string output edge cases' do
 
     it 'is a String' do
-      @doc_string.to_s.should be_a(String)
+      expect(@doc_string.to_s).to be_a(String)
     end
 
     it 'can output an empty doc string' do

data/spec/unit/example_unit_spec.rb

@@ -25,7 +25,7 @@ describe 'Example, 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 example'
+    expect(@element.name).to eq('test example')
   end
 
 
@@ -35,35 +35,35 @@ describe 'Example, Unit' do
 
 
   it 'has parameters - #parameters' do
-    @example.should respond_to(:parameters)
+    expect(@example.respond_to?(:parameters)).to be true
   end
 
   it 'can get and set its parameters - #parameters, #parameters=' do
     @example.parameters = :some_parameters
-    @example.parameters.should == :some_parameters
+    expect(@example.parameters).to eq(:some_parameters)
     @example.parameters = :some_other_parameters
-    @example.parameters.should == :some_other_parameters
+    expect(@example.parameters).to eq(:some_other_parameters)
   end
 
   it 'starts with no parameters' do
-    @example.parameters.should == []
+    expect(@example.parameters).to eq([])
   end
 
   it 'has rows - #rows' do
-    @example.should respond_to(:rows)
+    expect(@example.respond_to?(:rows)).to be true
   end
 
   #todo - remove once Hash rows are no longer supported
   it 'can get and set its rows - #rows, #rows=' do
     @example.rows = :some_rows
-    @example.rows.should == :some_rows
+    expect(@example.rows).to eq(:some_rows)
     @example.rows = :some_other_rows
-    @example.rows.should == :some_other_rows
+    expect(@example.rows).to eq(:some_other_rows)
   end
 
   #todo - remove once Hash rows are no longer supported
   it 'starts with no rows' do
-    @example.rows.should == []
+    expect(@example.rows).to eq([])
   end
 
   #todo - remove once Hash rows are no longer supported
@@ -73,9 +73,9 @@ describe 'Example, Unit' do
 
     rows = example.rows
 
-    rows.is_a?(Array).should be_true
-    rows.empty?.should be_false
-    rows.each { |row| row.is_a?(Hash).should be_true }
+    expect(rows).to be_a(Array)
+    expect(rows.empty?).to be false
+    rows.each { |row| expect(row).to be_a(Hash) }
   end
 
   it 'does not include the parameter row as a row' do
@@ -84,28 +84,28 @@ describe 'Example, Unit' do
 
     rows = example.rows
 
-    rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}]
+    expect(rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}])
   end
 
   it 'has row elements - #row_elements' do
-    @example.should respond_to(:row_elements)
+    expect(@example.respond_to?(:row_elements)).to be true
   end
 
   it 'can get and set its row elements - #row_elements, #row_elements=' do
     @example.row_elements = :some_row_elements
-    @example.row_elements.should == :some_row_elements
+    expect(@example.row_elements).to eq(:some_row_elements)
     @example.row_elements = :some_other_row_elements
-    @example.row_elements.should == :some_other_row_elements
+    expect(@example.row_elements).to eq(:some_other_row_elements)
   end
 
   it 'starts with no row elements' do
-    @example.row_elements.should == []
+    expect(@example.row_elements).to eq([])
   end
 
   context '#add_row' do
 
     it 'can add a new example row' do
-      clazz.new.should respond_to(:add_row)
+      expect(clazz.new.respond_to?(:add_row)).to be true
     end
 
     it 'can add a new row as a hash' do
@@ -116,8 +116,8 @@ describe 'Example, Unit' do
       example.add_row(new_row)
 
       #todo - remove once Hash rows are no longer supported
-      example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}]
-      example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2'], ['value3', 'value4']]
+      expect(example.rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}])
+      expect(example.row_elements.collect { |row| row.cells }[1..example.row_elements.count]).to eq([['value1', 'value2'], ['value3', 'value4']])
     end
 
     it 'can add a new row as an array' do
@@ -128,8 +128,8 @@ describe 'Example, Unit' do
       example.add_row(new_row)
 
       #todo - remove once Hash rows are no longer supported
-      example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}]
-      example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2'], ['value3', 'value4']]
+      expect(example.rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}])
+      expect(example.row_elements.collect { |row| row.cells }[1..example.row_elements.count]).to eq([['value1', 'value2'], ['value3', 'value4']])
     end
 
     it 'can only use a Hash or an Array to add a new row' do
@@ -148,15 +148,15 @@ describe 'Example, Unit' do
       example.add_row(array_row)
 
       #todo - remove once Hash rows are no longer supported
-      example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}, {'param1' => 'value5', 'param2' => 'value6'}]
-      example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2'], ['value3', 'value4'], ['value5', 'value6']]
+      expect(example.rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}, {'param1' => 'value5', 'param2' => 'value6'}])
+      expect(example.row_elements.collect { |row| row.cells }[1..example.row_elements.count]).to eq([['value1', 'value2'], ['value3', 'value4'], ['value5', 'value6']])
     end
   end
 
   context '#remove_row' do
 
     it 'can remove an existing example row' do
-      clazz.new.should respond_to(:remove_row)
+      expect(clazz.new.respond_to?(:remove_row)).to be true
     end
 
     it 'can remove an existing row as a hash' do
@@ -167,8 +167,8 @@ describe 'Example, Unit' do
       example.remove_row(old_row)
 
       #todo - remove once Hash rows are no longer supported
-      example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}]
-      example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2']]
+      expect(example.rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}])
+      expect(example.row_elements.collect { |row| row.cells }[1..example.row_elements.count]).to eq([['value1', 'value2']])
     end
 
     it 'can remove an existing row as an array' do
@@ -179,8 +179,8 @@ describe 'Example, Unit' do
       example.remove_row(old_row)
 
       #todo - remove once Hash rows are no longer supported
-      example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}]
-      example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2']]
+      expect(example.rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}])
+      expect(example.row_elements.collect { |row| row.cells }[1..example.row_elements.count]).to eq([['value1', 'value2']])
     end
 
     it 'can only use a Hash or an Array to remove an existing row' do
@@ -199,15 +199,15 @@ describe 'Example, Unit' do
       example.remove_row(array_row)
 
       #todo - remove once Hash rows are no longer supported
-      example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}]
-      example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2']]
+      expect(example.rows).to eq([{'param1' => 'value1', 'param2' => 'value2'}])
+      expect(example.row_elements.collect { |row| row.cells }[1..example.row_elements.count]).to eq([['value1', 'value2']])
     end
   end
 
   context 'example output edge cases' do
 
     it 'is a String' do
-      @example.to_s.should be_a(String)
+      expect(@example.to_s).to be_a(String)
     end
 
     it 'can output an empty example' do

data/spec/unit/feature_element_unit_specs.rb

@@ -7,40 +7,40 @@ shared_examples_for 'a feature element' do |clazz|
   end
 
   it 'has a name - #name' do
-    @element.should respond_to(:name)
+    expect(@element.respond_to?(:name)).to be true
   end
 
   it 'can get and set its name - #name, #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
 
   it 'has a description' do
-    @element.should respond_to(:description)
-    @element.should respond_to(:description_text)
+    expect(@element.respond_to?(:description)).to be true
+    expect(@element.respond_to?(:description_text)).to be true
   end
 
   it 'can get and set its description' do
     @element.description = :some_description
-    @element.description.should == :some_description
+    expect(@element.description).to eq(:some_description)
     @element.description = :some_other_description
-    @element.description.should == :some_other_description
+    expect(@element.description).to eq(:some_other_description)
 
     @element.description_text = :some_description
-    @element.description_text.should == :some_description
+    expect(@element.description_text).to eq(:some_description)
     @element.description_text = :some_other_description
-    @element.description_text.should == :some_other_description
+    expect(@element.description_text).to eq(:some_other_description)
   end
 
   it 'starts with no name' do
-    @element.name.should == ''
+    expect(@element.name).to eq('')
   end
 
   it 'starts with no description' do
-    @element.description.should == []
-    @element.description_text.should == ''
+    expect(@element.description).to eq([])
+    expect(@element.description_text).to eq('')
   end
 
 end