cuke_modeler 0.4.1 → 1.0.0

data/spec/unit/doc_string_unit_spec.rb

@@ -1,152 +1,99 @@
 require 'spec_helper'
 
-SimpleCov.command_name('DocString') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'DocString, Unit' do
+describe 'DocString, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::DocString }
   let(:doc_string) { clazz.new }
 
   describe 'common behavior' do
 
-    it_should_behave_like 'a nested element'
-    it_should_behave_like 'a bare bones element'
-    it_should_behave_like 'a prepopulated element'
-    it_should_behave_like 'a raw element'
+    it_should_behave_like 'a model'
+    it_should_behave_like 'a parsed model'
+    it_should_behave_like 'a sourced model'
 
   end
 
 
   describe 'unique behavior' do
 
-    it 'can be parsed from stand alone text' do
-      source = "\"\"\"\nsome doc string\n\"\"\""
-
-      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"
-      #todo Remove once Array contents is no longer supported
-      @element.contents.should == ["some doc string"]
-    end
-
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = 'bad doc string text'
-
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_doc_string\.feature'/)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
-      raw_data = doc_string.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :content])
-      expect(raw_data[:type]).to eq(:DocString)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
-      raw_data = doc_string.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :content])
-      expect(raw_data[:type]).to eq(:DocString)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
-      raw_data = doc_string.raw_element
-
-      expect(raw_data.keys).to match_array(['value', 'content_type', 'line'])
-      expect(raw_data['value']).to eq('some doc string')
-    end
-
     it 'has a content type' do
-      doc_string.should respond_to(:content_type)
+      expect(doc_string).to respond_to(:content_type)
     end
 
     it 'can change its content type' do
       expect(doc_string).to respond_to(:content_type=)
 
       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
+    it 'has content' do
+      expect(doc_string).to respond_to(:content)
     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)
+    it 'can change its content' do
+      expect(doc_string).to respond_to(:content=)
+
+      doc_string.content = :some_content
+      expect(doc_string.content).to eq(:some_content)
+      doc_string.content = :some_other_content
+      expect(doc_string.content).to eq(:some_other_content)
     end
 
-    it 'can get and set its contents' do
-      expect(doc_string).to respond_to(:contents=)
-      expect(doc_string).to respond_to(:contents_text=)
 
-      #todo Remove once Array contents is no longer supported
-      doc_string.contents = :some_contents
-      doc_string.contents.should == :some_contents
-      doc_string.contents = :some_other_contents
-      doc_string.contents.should == :some_other_contents
+    describe 'abstract instantiation' do
 
-      doc_string.contents_text = :some_contents
-      doc_string.contents_text.should == :some_contents
-      doc_string.contents_text = :some_other_contents
-      doc_string.contents_text.should == :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 == ''
-    end
+      context 'a new doc string object' do
 
-    #todo Remove once Array contents is no longer supported
-    it 'stores its contents as an array of strings - deprecated' do
-      source = "\"\"\"\nsome text\nsome more text\n\"\"\""
-      doc_string = clazz.new(source)
+        let(:doc_string) { clazz.new }
 
-      contents = doc_string.contents
 
-      contents.is_a?(Array).should be_true
-      contents.each do |line|
-        line.is_a?(String).should be_true
-      end
-    end
+        it 'starts with no content type' do
+          expect(doc_string.content_type).to be_nil
+        end
 
-    it 'stores its contents as a String' do
-      source = "\"\"\"\nsome text\nsome more text\n\"\"\""
-      doc_string = clazz.new(source)
+        it 'starts with no content' do
+          expect(doc_string.content).to be_nil
+        end
 
-      contents = doc_string.contents_text
+      end
 
-      contents.is_a?(String).should be_true
     end
 
-    describe 'doc string output edge cases' do
+
+    describe 'doc string output' do
 
       it 'is a String' do
-        doc_string.to_s.should be_a(String)
+        expect(doc_string.to_s).to be_a(String)
       end
 
 
-      context 'a new doc string object' do
+      context 'from abstract instantiation' do
 
-        let(:doc_string) { clazz.new }
+        context 'a new doc string object' do
 
+          let(:doc_string) { clazz.new }
 
-        it 'can output an empty doc string' do
-          expect { doc_string.to_s }.to_not raise_error
-        end
 
-        it 'can output a doc string that has only a content type' do
-          doc_string.content_type = 'some type'
+          it 'can output an empty doc string' do
+            expect { doc_string.to_s }.to_not raise_error
+          end
+
+          it 'can output a doc string that has only a content type' do
+            doc_string.content_type = 'some type'
+
+            expect { doc_string.to_s }.to_not raise_error
+          end
+
+          it 'can output a doc string that has only content' do
+            doc_string.content = 'foo'
+
+            expect { doc_string.to_s }.to_not raise_error
+          end
 
-          expect { doc_string.to_s }.to_not raise_error
         end
 
       end

data/spec/unit/example_unit_spec.rb

@@ -1,333 +1,107 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Example') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Example, Unit' do
+describe 'Example, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Example }
   let(:example) { clazz.new }
 
   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_should_behave_like 'a model'
+    it_should_behave_like 'a named model'
+    it_should_behave_like 'a described model'
+    it_should_behave_like 'a tagged model'
+    it_should_behave_like 'a sourced model'
+    it_should_behave_like 'a parsed model'
 
   end
 
 
   describe 'unique behavior' do
 
-    it 'can be parsed from stand alone text' do
-      source = ['Examples: test example',
-                '|param| ',
-                '|value|']
-
-      source = source.join("\n")
-
-      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'
-    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")
-
-      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")
-
-      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', :gherkin2 => true do
-      source = ['Examples:',
-                '|param|']
-      source = source.join("\n")
-
-      expect { @element = clazz.new(source) }.to_not raise_error
-    end
-
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = 'bad example text'
-
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_example\.feature'/)
-    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
-
-      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', :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
-
-    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' do
-      example.should respond_to(:parameters)
-    end
-
-    it 'can change its parameters' do
-      expect(example).to respond_to(:parameters=)
-
-      example.parameters = :some_parameters
-      example.parameters.should == :some_parameters
-      example.parameters = :some_other_parameters
-      example.parameters.should == :some_other_parameters
-    end
-
-    it 'starts with no parameters' do
-      example.parameters.should == []
-    end
-
     it 'has rows' do
-      example.should respond_to(:rows)
+      expect(example).to respond_to(:rows)
     end
 
-    #todo - remove once Hash rows are no longer supported
     it 'can change its rows' do
       expect(example).to respond_to(:rows=)
 
       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 == []
+    it 'can selectively access its parameter row' do
+      expect(example).to respond_to(:parameter_row)
     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)
-
-      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
-
-    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)
-
-      rows = example.rows
-
-      rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => 'value4'}]
+    it 'can selectively access its argument rows' do
+      expect(example).to respond_to(:argument_rows)
     end
 
-    it 'has row elements' do
-      example.should respond_to(:row_elements)
+    it 'can determine its parameters' do
+      expect(example).to respond_to(:parameters)
     end
 
-    it 'can change its row elements' do
-      expect(example).to respond_to(:row_elements=)
-
-      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 'starts with no row elements' do
-      example.row_elements.should == []
-    end
-
-    describe '#add_row' do
-
-      it 'can add a new example row' do
-        clazz.new.should respond_to(:add_row)
-      end
-
-      it 'can add a new row as a hash, string values' do
-        source = "Examples:\n|param1|param2|\n|value1|value2|"
-        example = clazz.new(source)
-
-        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
-
-      it 'can add a new row as a hash, non-string values' do
-        source = "Examples:\n|param1|param2|\n|value1|value2|"
-        example = clazz.new(source)
 
-        new_row = {:param1 => 'value3', 'param2' => 4}
-        example.add_row(new_row)
+    describe 'abstract instantiation' do
 
-        #todo - remove once Hash rows are no longer supported
-        example.rows.should == [{'param1' => 'value1', 'param2' => 'value2'}, {'param1' => 'value3', 'param2' => '4'}]
-        example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2'], ['value3', '4']]
-      end
-
-      it 'can add a new row as an array, string values' do
-        source = "Examples:\n|param1|param2|\n|value1|value2|"
-        example = clazz.new(source)
-
-        new_row = ['value3', '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
-
-      it 'can add a new row as an array, non-string values' do
-        source = "Examples:\n|param1|param2|param3|\n|value1|value2|value3|"
-        example = clazz.new(source)
-
-        new_row = [:value4, 5, 'value6']
-        example.add_row(new_row)
-
-        #todo - remove once Hash rows are no longer supported
-        example.rows.should == [{'param1' => 'value1', 'param2' => 'value2', 'param3' => 'value3'}, {'param1' => 'value4', 'param2' => '5', 'param3' => 'value6'}]
-        example.row_elements.collect { |row| row.cells }[1..example.row_elements.count].should == [['value1', 'value2', 'value3'], ['value4', '5', 'value6']]
-      end
-
-      it 'can only use a Hash or an Array to add a new row' do
-        source = "Examples:\n|param|\n|value|"
-        example = clazz.new(source)
-
-        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 'trims whitespace from added rows' do
-        source = "Examples:\n|param1|param2|\n|value1|value2|"
-        example = clazz.new(source)
-
-        hash_row = {'param1' => 'value3  ', 'param2' => '  value4'}
-        array_row = ['value5', ' value6 ']
-        example.add_row(hash_row)
-        example.add_row(array_row)
+      context 'a new example object' do
 
-        #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
+        let(:example) { clazz.new }
 
-      #todo - remove once Hash rows are no longer supported
-      it 'will complain if a row is added and no parameters have been set' do
-        example = clazz.new
-        example.parameters = []
 
-        new_row = ['value1', 'value2']
-        expect { example.add_row(new_row) }.to raise_error('Cannot add a row. No parameters have been set.')
+        it 'starts with no rows' do
+          expect(example.rows).to eq([])
+        end
 
-        new_row = {'param1' => 'value1', 'param2' => 'value2'}
-        expect { example.add_row(new_row) }.to raise_error('Cannot add a row. No parameters have been set.')
-      end
+        it 'starts with no argument rows' do
+          expect(example.argument_rows).to eq([])
+        end
 
-      #todo - remove once Hash rows are no longer supported
-      it 'does not modify its row input' do
-        source = "Examples:\n|param1|param2|\n|value1|value2|"
-        example = clazz.new(source)
+        it 'starts with no parameter row' do
+          expect(example.parameter_row).to be_nil
+        end
 
-        new_row = ['value1'.freeze, 'value2'.freeze].freeze
-        expect { example.add_row(new_row) }.to_not raise_error
+        it 'starts with no parameters' do
+          expect(example.parameters).to eq([])
+        end
 
-        new_row = {'param1'.freeze => 'value1'.freeze, 'param2'.freeze => 'value2'.freeze}.freeze
-        expect { example.add_row(new_row) }.to_not raise_error
       end
 
     end
 
-    describe '#remove_row' do
-
-      it 'can remove an existing example row' do
-        clazz.new.should respond_to(:remove_row)
-      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)
 
-        old_row = {'param1' => 'value3', 'param2' => '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
-
-      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)
-
-        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
+    it 'can add a new example row' do
+      expect(clazz.new).to respond_to(:add_row)
+    end
 
-      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
+    it 'can remove an existing example row' do
+      expect(clazz.new).to respond_to(:remove_row)
+    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)
+    it 'contains rows and tags' do
+      tags = [:tag_1, :tag_2]
+      rows = [:row_1, :row_2]
+      everything = rows + tags
 
-        hash_row = {'param1' => 'value3  ', 'param2' => '  value4'}
-        array_row = ['value5', ' value6 ']
-        example.remove_row(hash_row)
-        example.remove_row(array_row)
+      example.rows = rows
+      example.tags = tags
 
-        #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
+      expect(example.children).to match_array(everything)
     end
 
-    describe 'example output edge cases' do
+
+    describe 'example output' do
 
       it 'is a String' do
-        example.to_s.should be_a(String)
+        expect(example.to_s).to be_a(String)
       end
 
-      context 'a new example object' do
+
+      context 'from abstract instantiation' do
 
         let(:example) { clazz.new }
 
@@ -343,27 +117,7 @@ describe 'Example, Unit' do
         end
 
         it 'can output an example that has only a description' do
-          example.description_text = 'a description'
-
-          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'}]
+          example.description = 'a description'
 
           expect { example.to_s }.to_not raise_error
         end