cuke_modeler 0.3.0 → 0.4.0

data/spec/unit/example_unit_spec.rb

@@ -5,303 +5,319 @@ SimpleCov.command_name('Example') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'Example, Unit' do
 
   let(:clazz) { CukeModeler::Example }
+  let(:example) { clazz.new }
 
-  it_should_behave_like 'a feature element'
-  it_should_behave_like 'a nested element'
-  it_should_behave_like 'a tagged element'
-  it_should_behave_like 'a bare bones element'
-  it_should_behave_like 'a prepopulated element'
-  it_should_behave_like 'a sourced element'
-  it_should_behave_like 'a containing element'
-  it_should_behave_like 'a raw element'
+  describe 'common behavior' do
 
+    it_should_behave_like 'a feature element'
+    it_should_behave_like 'a nested element'
+    it_should_behave_like 'a tagged element'
+    it_should_behave_like 'a bare bones element'
+    it_should_behave_like 'a prepopulated element'
+    it_should_behave_like 'a sourced element'
+    it_should_behave_like 'a containing element'
+    it_should_behave_like 'a raw element'
 
-  it 'can be parsed from stand alone text' do
-    source = ['Examples: test example',
-              '|param| ',
-              '|value|']
+  end
 
-    source = source.join("\n")
 
-    expect { @element = clazz.new(source) }.to_not raise_error
+  describe 'unique behavior' do
 
-    # Sanity check in case instantiation failed in a non-explosive manner
-    @element.name.should == 'test example'
-  end
+    it 'can be parsed from stand alone text' do
+      source = ['Examples: test example',
+                '|param| ',
+                '|value|']
 
-  # todo - add more tests like this to the 'barebones' test set
-  it 'can be instantiated with the minimum viable Gherkin', :gherkin4 => true do
-    source = ['Examples:']
-    source = source.join("\n")
+      source = source.join("\n")
 
-    expect { @element = clazz.new(source) }.to_not raise_error
-  end
+      expect { @element = clazz.new(source) }.to_not raise_error
 
-  # todo - add more tests like this to the 'barebones' test set
-  it 'can be instantiated with the minimum viable Gherkin', :gherkin3 => true do
-    source = ['Examples:',
-              '|param|',
-              '|value|']
-    source = source.join("\n")
+      # Sanity check in case instantiation failed in a non-explosive manner
+      @element.name.should == 'test example'
+    end
 
-    expect { @element = clazz.new(source) }.to_not raise_error
-  end
+    # todo - add more tests like this to the 'barebones' test set
+    it 'can be instantiated with the minimum viable Gherkin', :gherkin4 => true do
+      source = ['Examples:']
+      source = source.join("\n")
 
-  # todo - add more tests like this to the 'barebones' test set
-  it 'can be instantiated with the minimum viable Gherkin', :gherkin2 => true do
-    source = ['Examples:',
-              '|param|']
-    source = source.join("\n")
+      expect { @element = clazz.new(source) }.to_not raise_error
+    end
 
-    expect { @element = clazz.new(source) }.to_not raise_error
-  end
+    # todo - add more tests like this to the 'barebones' test set
+    it 'can be instantiated with the minimum viable Gherkin', :gherkin3 => true do
+      source = ['Examples:',
+                '|param|',
+                '|value|']
+      source = source.join("\n")
 
-  it 'provides a descriptive filename when being parsed from stand alone text' do
-    source = 'bad example text'
+      expect { @element = clazz.new(source) }.to_not raise_error
+    end
 
-    expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_example\.feature'/)
-  end
+    # todo - add more tests like this to the 'barebones' test set
+    it 'can be instantiated with the minimum viable Gherkin', :gherkin2 => true do
+      source = ['Examples:',
+                '|param|']
+      source = source.join("\n")
 
-  it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-    example = clazz.new("Examples: test example\n|param|\n|value|")
-    raw_data = example.raw_element
+      expect { @element = clazz.new(source) }.to_not raise_error
+    end
 
-    expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :tableHeader, :tableBody])
-    expect(raw_data[:type]).to eq(:Examples)
-  end
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = 'bad example text'
 
-  it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-    example = clazz.new("Examples: test example\n|param|\n|value|")
-    raw_data = example.raw_element
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_example\.feature'/)
+    end
 
-    expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :tableHeader, :tableBody])
-    expect(raw_data[:type]).to eq(:Examples)
-  end
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      example = clazz.new("Examples: test example\n|param|\n|value|")
+      raw_data = example.raw_element
 
-  it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-    example = clazz.new("Examples: test example\n|param|\n|value|")
-    raw_data = example.raw_element
+      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :tableHeader, :tableBody])
+      expect(raw_data[:type]).to eq(:Examples)
+    end
 
-    expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'rows'])
-    expect(raw_data['keyword']).to eq('Examples')
-  end
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      example = clazz.new("Examples: test example\n|param|\n|value|")
+      raw_data = example.raw_element
 
+      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :tableHeader, :tableBody])
+      expect(raw_data[:type]).to eq(:Examples)
+    end
 
-  before(:each) do
-    @example = clazz.new
-  end
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      example = clazz.new("Examples: test example\n|param|\n|value|")
+      raw_data = example.raw_element
 
+      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'rows'])
+      expect(raw_data['keyword']).to eq('Examples')
+    end
 
-  it 'has parameters - #parameters' do
-    @example.should respond_to(:parameters)
-  end
+    it 'has parameters' do
+      example.should respond_to(:parameters)
+    end
 
-  it 'can get and set its parameters - #parameters, #parameters=' do
-    @example.parameters = :some_parameters
-    @example.parameters.should == :some_parameters
-    @example.parameters = :some_other_parameters
-    @example.parameters.should == :some_other_parameters
-  end
+    it 'can change its parameters' do
+      expect(example).to respond_to(:parameters=)
 
-  it 'starts with no parameters' do
-    @example.parameters.should == []
-  end
+      example.parameters = :some_parameters
+      example.parameters.should == :some_parameters
+      example.parameters = :some_other_parameters
+      example.parameters.should == :some_other_parameters
+    end
 
-  it 'has rows - #rows' do
-    @example.should respond_to(:rows)
-  end
+    it 'starts with no parameters' do
+      example.parameters.should == []
+    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
-    @example.rows = :some_other_rows
-    @example.rows.should == :some_other_rows
-  end
+    it 'has rows' do
+      example.should respond_to(:rows)
+    end
 
-  #todo - remove once Hash rows are no longer supported
-  it 'starts with no rows' do
-    @example.rows.should == []
-  end
+    #todo - remove once Hash rows are no longer supported
+    it 'can change its rows' do
+      expect(example).to respond_to(:rows=)
 
-  #todo - remove once Hash rows are no longer supported
-  it 'stores its rows as an nested array of hashes' do
-    source = "Examples:\n|param1|param2|\n|value1|value2|"
-    example = CukeModeler::Example.new(source)
+      example.rows = :some_rows
+      example.rows.should == :some_rows
+      example.rows = :some_other_rows
+      example.rows.should == :some_other_rows
+    end
 
-    rows = example.rows
+    #todo - remove once Hash rows are no longer supported
+    it 'starts with no rows' do
+      example.rows.should == []
+    end
 
-    rows.is_a?(Array).should be_true
-    rows.empty?.should be_false
-    rows.each { |row| row.is_a?(Hash).should be_true }
-  end
+    #todo - remove once Hash rows are no longer supported
+    it 'stores its rows as an nested array of hashes' do
+      source = "Examples:\n|param1|param2|\n|value1|value2|"
+      example = clazz.new(source)
 
-  it 'does not include the parameter row as a row' do
-    source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|"
-    example = CukeModeler::Example.new(source)
+      rows = example.rows
 
-    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 }
+    end
 
-    rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}]
-  end
+    it 'does not include the parameter row as a row' do
+      source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|"
+      example = clazz.new(source)
 
-  it 'has row elements - #row_elements' do
-    @example.should respond_to(:row_elements)
-  end
+      rows = example.rows
 
-  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
-    @example.row_elements = :some_other_row_elements
-    @example.row_elements.should == :some_other_row_elements
-  end
+      rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}]
+    end
 
-  it 'starts with no row elements' do
-    @example.row_elements.should == []
-  end
+    it 'has row elements' do
+      example.should respond_to(:row_elements)
+    end
 
-  context '#add_row' do
+    it 'can change its row elements' do
+      expect(example).to respond_to(:row_elements=)
 
-    it 'can add a new example row' do
-      clazz.new.should respond_to(:add_row)
+      example.row_elements = :some_row_elements
+      example.row_elements.should == :some_row_elements
+      example.row_elements = :some_other_row_elements
+      example.row_elements.should == :some_other_row_elements
     end
 
-    it 'can add a new row as a hash' do
-      source = "Examples:\n|param1|param2|\n|value1|value2|"
-      example = CukeModeler::Example.new(source)
+    it 'starts with no row elements' do
+      example.row_elements.should == []
+    end
 
-      new_row = {'param1' => 'value3', 'param2' => 'value4'}
-      example.add_row(new_row)
+    describe '#add_row' do
 
-      #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']]
-    end
+      it 'can add a new example row' do
+        clazz.new.should respond_to(:add_row)
+      end
 
-    it 'can add a new row as an array' do
-      source = "Examples:\n|param1|param2|\n|value1|value2|"
-      example = CukeModeler::Example.new(source)
+      it 'can add a new row as a hash' do
+        source = "Examples:\n|param1|param2|\n|value1|value2|"
+        example = clazz.new(source)
 
-      new_row = ['value3', 'value4']
-      example.add_row(new_row)
+        new_row = {'param1' => 'value3', 'param2' => 'value4'}
+        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']]
-    end
+        #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']]
+      end
 
-    it 'can only use a Hash or an Array to add a new row' do
-      expect { @example.add_row({}) }.to_not raise_error
-      expect { @example.add_row([]) }.to_not raise_error
-      expect { @example.add_row(:a_row) }.to raise_error(ArgumentError)
-    end
+      it 'can add a new row as an array' do
+        source = "Examples:\n|param1|param2|\n|value1|value2|"
+        example = clazz.new(source)
 
-    it 'trims whitespace from added rows' do
-      source = "Examples:\n|param1|param2|\n|value1|value2|"
-      example = CukeModeler::Example.new(source)
+        new_row = ['value3', 'value4']
+        example.add_row(new_row)
 
-      hash_row = {'param1' => 'value3  ', 'param2' => '  value4'}
-      array_row = ['value5', ' value6 ']
-      example.add_row(hash_row)
-      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'}]
+        example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2'], ['value3', 'value4']]
+      end
 
-      #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']]
-    end
-  end
+      it 'can only use a Hash or an Array to add a new row' do
+        expect { example.add_row({}) }.to_not raise_error
+        expect { example.add_row([]) }.to_not raise_error
+        expect { example.add_row(:a_row) }.to raise_error(ArgumentError)
+      end
 
-  context '#remove_row' do
+      it 'trims whitespace from added rows' do
+        source = "Examples:\n|param1|param2|\n|value1|value2|"
+        example = clazz.new(source)
 
-    it 'can remove an existing example row' do
-      clazz.new.should respond_to(:remove_row)
+        hash_row = {'param1' => 'value3  ', 'param2' => '  value4'}
+        array_row = ['value5', ' value6 ']
+        example.add_row(hash_row)
+        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']]
+      end
     end
 
-    it 'can remove an existing row as a hash' do
-      source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|"
-      example = CukeModeler::Example.new(source)
+    describe '#remove_row' do
 
-      old_row = {'param1' => 'value3', 'param2' => 'value4'}
-      example.remove_row(old_row)
+      it 'can remove an existing example row' do
+        clazz.new.should respond_to(:remove_row)
+      end
 
-      #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']]
-    end
+      it 'can remove an existing row as a hash' do
+        source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|"
+        example = clazz.new(source)
 
-    it 'can remove an existing row as an array' do
-      source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|"
-      example = CukeModeler::Example.new(source)
+        old_row = {'param1' => 'value3', 'param2' => 'value4'}
+        example.remove_row(old_row)
 
-      old_row = ['value3', 'value4']
-      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']]
+      end
 
-      #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']]
-    end
+      it 'can remove an existing row as an array' do
+        source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|"
+        example = clazz.new(source)
 
-    it 'can only use a Hash or an Array to remove an existing row' do
-      expect { @example.remove_row({}) }.to_not raise_error
-      expect { @example.remove_row([]) }.to_not raise_error
-      expect { @example.remove_row(:a_row) }.to raise_error(ArgumentError)
-    end
+        old_row = ['value3', 'value4']
+        example.remove_row(old_row)
 
-    it 'trims whitespace from removed rows' do
-      source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|\n|value5|value6|"
-      example = CukeModeler::Example.new(source)
+        #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']]
+      end
 
-      hash_row = {'param1' => 'value3  ', 'param2' => '  value4'}
-      array_row = ['value5', ' value6 ']
-      example.remove_row(hash_row)
-      example.remove_row(array_row)
+      it 'can only use a Hash or an Array to remove an existing row' do
+        expect { example.remove_row({}) }.to_not raise_error
+        expect { example.remove_row([]) }.to_not raise_error
+        expect { example.remove_row(:a_row) }.to raise_error(ArgumentError)
+      end
 
-      #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']]
-    end
-  end
+      it 'trims whitespace from removed rows' do
+        source = "Examples:\n|param1|param2|\n|value1|value2|\n|value3|value4|\n|value5|value6|"
+        example = clazz.new(source)
 
-  context 'example output edge cases' do
+        hash_row = {'param1' => 'value3  ', 'param2' => '  value4'}
+        array_row = ['value5', ' value6 ']
+        example.remove_row(hash_row)
+        example.remove_row(array_row)
 
-    it 'is a String' do
-      @example.to_s.should be_a(String)
+        #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']]
+      end
     end
 
-    it 'can output an empty example' do
-      expect { @example.to_s }.to_not raise_error
-    end
+    describe 'example output edge cases' do
 
-    it 'can output an example that has only a name' do
-      @example.name = 'a name'
+      it 'is a String' do
+        example.to_s.should be_a(String)
+      end
 
-      expect { @example.to_s }.to_not raise_error
-    end
+      context 'a new example object' do
 
-    it 'can output an example that has only a description' do
-      @example.description_text = 'a description'
+        let(:example) { clazz.new }
 
-      expect { @example.to_s }.to_not raise_error
-    end
 
-    it 'can output an example that has only a tags' do
-      @example.tags = ['a tag']
+        it 'can output an empty example' do
+          expect { example.to_s }.to_not raise_error
+        end
 
-      expect { @example.to_s }.to_not raise_error
-    end
+        it 'can output an example that has only a name' do
+          example.name = 'a name'
 
-    #todo - remove once Hash rows are no longer supported
-    it 'can output an example that only has parameters' do
-      @example.parameters = ['param1']
+          expect { example.to_s }.to_not raise_error
+        end
 
-      expect { @example.to_s }.to_not raise_error
-    end
+        it 'can output an example that has only a description' do
+          example.description_text = 'a description'
 
-    #todo - remove once Hash rows are no longer supported
-    it 'can output an example that only has rows' do
-      @example.rows = [{:param1 => 'row1'}]
+          expect { example.to_s }.to_not raise_error
+        end
+
+        it 'can output an example that has only tags' do
+          example.tags = ['a tag']
+
+          expect { example.to_s }.to_not raise_error
+        end
+
+        #todo - remove once Hash rows are no longer supported
+        it 'can output an example that only has parameters' do
+          example.parameters = ['param1']
+
+          expect { example.to_s }.to_not raise_error
+        end
+
+        #todo - remove once Hash rows are no longer supported
+        it 'can output an example that only has rows' do
+          example.rows = [{:param1 => 'row1'}]
+
+          expect { example.to_s }.to_not raise_error
+        end
+
+      end
 
-      expect { @example.to_s }.to_not raise_error
     end
 
   end