cuke_modeler 0.4.1 → 1.0.0

data/spec/integration/parsing_integration_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+
+describe 'Parsing, Integration' do
+
+  let(:nodule) { CukeModeler::Parsing }
+
+
+  describe 'unique behavior' do
+
+
+    it 'raises and error if given something to parse besides a string' do
+      expect { nodule.parse_text(5) }.to raise_error(ArgumentError, /Text to parse must be a String but got/)
+      expect { nodule.parse_text('Feature:') }.to_not raise_error
+    end
+
+    it 'includes the type of object provided when raising an non-string exception' do
+      expect { nodule.parse_text(5) }.to raise_error(ArgumentError, /Fixnum/)
+    end
+
+    it 'returns an Array' do
+      result = nodule.parse_text('Feature:')
+      expect(result).to be_a(Array)
+    end
+
+    it 'raises and error if an error is encountered while parsing text' do
+      expect { nodule.parse_text('bad file') }.to raise_error(ArgumentError, /Error encountered while parsing '.*'/)
+    end
+
+    it 'includes the file parsed in the error that it raises' do
+      expect { nodule.parse_text('bad file', 'file foo.txt') }.to raise_error(/'file foo\.txt'/)
+    end
+
+    it 'includes the underlying error message in the error that it raises' do
+      begin
+        # Custom error type in order to ensure that we are throwing the correct thing
+        module CukeModeler
+          class TestError < StandardError
+          end
+        end
+
+        # Monkey patch Gherkin to throw the error that we need for testing
+        if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
+          old_method = Gherkin::Parser.instance_method(:parse)
+
+          module Gherkin
+            class Parser
+              def parse(*args)
+                raise(CukeModeler::TestError, 'something went wrong')
+              end
+            end
+          end
+        else
+          old_method = Gherkin::Parser::Parser.instance_method(:parse)
+
+          module Gherkin
+            module Parser
+              class Parser
+                def parse(*args)
+                  raise(CukeModeler::TestError, 'something went wrong')
+                end
+              end
+            end
+          end
+        end
+
+        expect { nodule.parse_text('bad file') }.to raise_error(/CukeModeler::TestError.*something went wrong/)
+      ensure
+        # Making sure that our changes don't escape a test and ruin the rest of the suite
+        if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
+          Gherkin::Parser.send(:define_method, :parse, old_method)
+        else
+          Gherkin::Parser::Parser.send(:define_method, :parse, old_method)
+        end
+      end
+
+    end
+
+    it 'has a default file name if one is not provided' do
+      expect { nodule.parse_text('bad file') }.to raise_error(ArgumentError, /'cuke_modeler_fake_file\.feature'/)
+    end
+
+  end
+
+end

data/spec/integration/row_integration_spec.rb

@@ -1,24 +1,76 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Row') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Row, Integration' do
 
   let(:clazz) { CukeModeler::Row }
 
 
+  describe 'common behavior' do
+
+    it_should_behave_like 'a model, integration'
+
+  end
+
+
   describe 'unique behavior' do
 
+    it 'can be instantiated with the minimum viable Gherkin' do
+      source = '| a | row |'
+
+      expect { clazz.new(source) }.to_not raise_error
+    end
+
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = " |bad |row| text| \n @foo "
+
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_row\.feature'/)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      example_row = clazz.new("| a | row |")
+      data = example_row.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :cells])
+      expect(data[:type]).to eq(:TableRow)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      example_row = clazz.new("| a | row |")
+      data = example_row.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :cells])
+      expect(data[:type]).to eq('TableRow')
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      example_row = clazz.new("| a | row |")
+      data = example_row.parsing_data
+
+      expect(data.keys).to match_array(['cells', 'line'])
+      expect(data['line']).to eq(4)
+    end
+
+    it 'properly sets its child models' do
+      source = '| cell 1 | cell 2 |'
+
+      row = clazz.new(source)
+      cell_1 = row.cells.first
+      cell_2 = row.cells.last
+
+      expect(cell_1.parent_model).to equal(row)
+      expect(cell_2.parent_model).to equal(row)
+    end
+
+
     describe 'getting ancestors' do
 
       before(:each) do
         source = ['Feature: Test feature',
                   '',
-                  '  Scenario Outline: Test test',
-                  '    * a step',
-                  '  Examples: Test example',
-                  '    | a param |',
-                  '    | a value |']
+                  '  Scenario: Test test',
+                  '    * a step:',
+                  '      | a | table |']
         source = source.join("\n")
 
         file_path = "#{@default_file_directory}/row_test_file.feature"
@@ -26,43 +78,194 @@ describe 'Row, Integration' do
       end
 
       let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:row) { directory.feature_files.first.features.first.tests.first.examples.first.row_elements.first }
+      let(:row) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first }
 
 
       it 'can get its directory' do
         ancestor = row.get_ancestor(:directory)
 
-        ancestor.should equal directory
+        expect(ancestor).to equal(directory)
       end
 
       it 'can get its feature file' do
         ancestor = row.get_ancestor(:feature_file)
 
-        ancestor.should equal directory.feature_files.first
+        expect(ancestor).to equal(directory.feature_files.first)
       end
 
       it 'can get its feature' do
         ancestor = row.get_ancestor(:feature)
 
-        ancestor.should equal directory.feature_files.first.features.first
+        expect(ancestor).to equal(directory.feature_files.first.feature)
+      end
+
+      it 'can get its step' do
+        ancestor = row.get_ancestor(:step)
+
+        expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first)
+      end
+
+      it 'can get its table' do
+        ancestor = row.get_ancestor(:table)
+
+        expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first.block)
+      end
+
+      context 'a row that is part of a scenario' do
+
+        before(:each) do
+          source = 'Feature: Test feature
+
+                      Scenario: Test test
+                        * a step:
+                          | a | table |'
+
+          file_path = "#{@default_file_directory}/row_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:row) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first }
+
+
+        it 'can get its scenario' do
+          ancestor = row.get_ancestor(:scenario)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+        end
+
       end
 
-      it 'can get its test' do
-        ancestor = row.get_ancestor(:test)
 
-        ancestor.should equal directory.feature_files.first.features.first.tests.first
+      context 'a row that is part of a background' do
+
+        before(:each) do
+          source = 'Feature: Test feature
+
+                      Background: Test background
+                        * a step:
+                          | a | table |'
+
+          file_path = "#{@default_file_directory}/row_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:row) { directory.feature_files.first.feature.background.steps.first.block.rows.first }
+
+
+        it 'can get its background' do
+          ancestor = row.get_ancestor(:background)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.background)
+        end
+
       end
 
-      it 'can get its example' do
-        ancestor = row.get_ancestor(:example)
+      context 'a row that is part of an outline' do
+
+        before(:each) do
+          source = 'Feature: Test feature
+                      
+                      Scenario Outline: Test outline
+                        * a step
+                      Examples:
+                        | param |
+                        | value |'
+
+          file_path = "#{@default_file_directory}/row_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:row) { directory.feature_files.first.feature.tests.first.examples.first.rows.first }
+
+
+        it 'can get its outline' do
+          ancestor = row.get_ancestor(:outline)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+        end
+
+        it 'can get its example' do
+          ancestor = row.get_ancestor(:example)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.examples.first)
+        end
 
-        ancestor.should equal directory.feature_files.first.features.first.tests.first.examples.first
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = row.get_ancestor(:table)
+        ancestor = row.get_ancestor(:outline)
+
+        expect(ancestor).to be_nil
+      end
+
+    end
+
+
+    describe 'model population' do
+
+      context 'from source text' do
+
+        let(:source_text) { '| cell 1 | cell 2 |' }
+        let(:row) { clazz.new(source_text) }
+
+
+        it "models the row's cells" do
+          cell_values = row.cells.collect { |cell| cell.value }
+
+          expect(cell_values).to match_array(['cell 1', 'cell 2'])
+        end
+
+        it "models the row's source line" do
+          source_text = "Feature: Test feature
+
+                           Scenario Outline: Test outline
+                             * a step
+                           Examples:
+                             | param |
+                             | value |"
+          row = CukeModeler::Feature.new(source_text).tests.first.examples.first.rows.first
+
+          expect(row.source_line).to eq(6)
+        end
+
+      end
+
+    end
+
+
+    describe 'row output' do
+
+      it 'can be remade from its own output' do
+        source = ['| value1 | value2 |']
+        source = source.join("\n")
+        row = clazz.new(source)
+
+        row_output = row.to_s
+        remade_row_output = clazz.new(row_output).to_s
+
+        expect(remade_row_output).to eq(row_output)
+      end
+
+
+      context 'from source text' do
+
+        it 'can output a row' do
+          source = '| some value |'
+          row = clazz.new(source)
+
+          expect(row.to_s).to eq('| some value |')
+        end
+
+        it 'can output a row with multiple cells' do
+          source = '| some value | some other value |'
+          row = clazz.new(source)
+
+          expect(row.to_s).to eq('| some value | some other value |')
+        end
 
-        ancestor.should be_nil
       end
 
     end

data/spec/integration/scenario_integration_spec.rb

@@ -1,15 +1,56 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Scenario') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Scenario, Integration' do
 
   let(:clazz) { CukeModeler::Scenario }
 
 
+  describe 'common behavior' do
+
+    it_should_behave_like 'a model, integration'
+
+  end
+
   describe 'unique behavior' do
 
-    it 'properly sets its child elements' do
+    it 'can be instantiated with the minimum viable Gherkin' do
+      source = 'Scenario:'
+
+      expect { clazz.new(source) }.to_not raise_error
+    end
+
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = "bad scenario text \n Scenario:\n And a step\n @foo "
+
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_scenario\.feature'/)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      scenario = clazz.new("@tag\nScenario: test scenario\ndescription\n* a step")
+      data = scenario.parsing_data
+
+      expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :description])
+      expect(data[:type]).to eq(:Scenario)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      scenario = clazz.new("@tag\nScenario: test scenario\ndescription\n* a step")
+      data = scenario.parsing_data
+
+      expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :description])
+      expect(data[:type]).to eq(:Scenario)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      scenario = clazz.new("@tag\nScenario: test scenario\ndescription\n* a step")
+      data = scenario.parsing_data
+
+      expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type', 'steps', 'tags'])
+      expect(data['keyword']).to eq('Scenario')
+    end
+
+    it 'properly sets its child models' do
       source = ['@a_tag',
                 'Scenario: Test scenario',
                 '  * a step']
@@ -17,10 +58,32 @@ describe 'Scenario, Integration' do
 
       scenario = clazz.new(source)
       step = scenario.steps.first
-      tag = scenario.tag_elements.first
+      tag = scenario.tags.first
+
+      expect(step.parent_model).to equal(scenario)
+      expect(tag.parent_model).to equal(scenario)
+    end
 
-      step.parent_element.should equal scenario
-      tag.parent_element.should equal scenario
+    it 'trims whitespace from its source description' do
+      source = ['Scenario:',
+                '  ',
+                '        description line 1',
+                '',
+                '   description line 2',
+                '     description line 3               ',
+                '',
+                '',
+                '',
+                '  * a step']
+      source = source.join("\n")
+
+      scenario = clazz.new(source)
+      description = scenario.description.split("\n")
+
+      expect(description).to eq(['     description line 1',
+                                 '',
+                                 'description line 2',
+                                 '  description line 3'])
     end
 
 
@@ -38,42 +101,331 @@ describe 'Scenario, Integration' do
       end
 
       let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:scenario) { directory.feature_files.first.features.first.tests.first }
+      let(:scenario) { directory.feature_files.first.feature.tests.first }
 
 
       it 'can get its directory' do
         ancestor = scenario.get_ancestor(:directory)
 
-        ancestor.should equal directory
+        expect(ancestor).to equal(directory)
       end
 
       it 'can get its feature file' do
         ancestor = scenario.get_ancestor(:feature_file)
 
-        ancestor.should equal directory.feature_files.first
+        expect(ancestor).to equal(directory.feature_files.first)
       end
 
       it 'can get its feature' do
         ancestor = scenario.get_ancestor(:feature)
 
-        ancestor.should equal directory.feature_files.first.features.first
+        expect(ancestor).to equal(directory.feature_files.first.feature)
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
         ancestor = scenario.get_ancestor(:test)
 
-        ancestor.should be_nil
+        expect(ancestor).to be_nil
       end
 
-      describe 'scenario output edge cases' do
 
-        context 'a new scenario object' do
+      describe 'model population' do
+
+        context 'from source text' do
+
+          it "models the scenario's source line" do
+            source_text = "Feature:
+
+                           Scenario: foo
+                             * step"
+            scenario = CukeModeler::Feature.new(source_text).tests.first
+
+            expect(scenario.source_line).to eq(3)
+          end
+
+
+          context 'a filled scenario' do
+
+            let(:source_text) { '@tag1 @tag2 @tag3
+                                 Scenario: Scenario name
+
+                                     Scenario description.
+
+                                   Some more.
+                                       Even more.
+
+                                 * a step
+                                 * another step' }
+            let(:scenario) { clazz.new(source_text) }
+
+
+            it "models the scenario's name" do
+              expect(scenario.name).to eq('Scenario name')
+            end
+
+            it "models the scenario's description" do
+              description = scenario.description.split("\n")
+
+              expect(description).to eq(['  Scenario description.',
+                                         '',
+                                         'Some more.',
+                                         '    Even more.'])
+            end
+
+            it "models the scenario's steps" do
+              step_names = scenario.steps.collect { |step| step.text }
+
+              expect(step_names).to eq(['a step', 'another step'])
+            end
+
+            it "models the scenario's tags" do
+              tag_names = scenario.tags.collect { |tag| tag.name }
+
+              expect(tag_names).to eq(['@tag1', '@tag2', '@tag3'])
+            end
+
+          end
+
+          context 'an empty scenario' do
+
+            let(:source_text) { 'Scenario:' }
+            let(:scenario) { clazz.new(source_text) }
+
+
+            it "models the scenario's name" do
+              expect(scenario.name).to eq('')
+            end
+
+            it "models the scenario's description" do
+              expect(scenario.description).to eq('')
+            end
+
+            it "models the scenario's steps" do
+              expect(scenario.steps).to eq([])
+            end
+
+            it "models the scenario's tags" do
+              expect(scenario.tags).to eq([])
+            end
+
+          end
+
+        end
+
+      end
+
+
+      describe 'comparison' do
+
+        it 'is equal to a background with the same steps' do
+          source = "Scenario:
+                      * step 1
+                      * step 2"
+          scenario = clazz.new(source)
+
+          source = "Background:
+                      * step 1
+                      * step 2"
+          background_1 = CukeModeler::Background.new(source)
+
+          source = "Background:
+                      * step 2
+                      * step 1"
+          background_2 = CukeModeler::Background.new(source)
+
+
+          expect(scenario).to eq(background_1)
+          expect(scenario).to_not eq(background_2)
+        end
+
+        it 'is equal to a scenario with the same steps' do
+          source = "Scenario:
+                      * step 1
+                      * step 2"
+          scenario_1 = clazz.new(source)
+
+          source = "Scenario:
+                      * step 1
+                      * step 2"
+          scenario_2 = clazz.new(source)
+
+          source = "Scenario:
+                      * step 2
+                      * step 1"
+          scenario_3 = clazz.new(source)
+
+
+          expect(scenario_1).to eq(scenario_2)
+          expect(scenario_1).to_not eq(scenario_3)
+        end
+
+        it 'is equal to an outline with the same steps' do
+          source = "Scenario:
+                      * step 1
+                      * step 2"
+          scenario = clazz.new(source)
+
+          source = "Scenario Outline:
+                      * step 1
+                      * step 2
+                    Examples:
+                      | param |
+                      | value |"
+          outline_1 = CukeModeler::Outline.new(source)
+
+          source = "Scenario Outline:
+                      * step 2
+                      * step 1
+                    Examples:
+                      | param |
+                      | value |"
+          outline_2 = CukeModeler::Outline.new(source)
+
+
+          expect(scenario).to eq(outline_1)
+          expect(scenario).to_not eq(outline_2)
+        end
+
+      end
+
+
+      describe 'scenario output' do
+
+        it 'can be remade from its own output' do
+          source = ['@tag1 @tag2 @tag3',
+                    'Scenario: A scenario with everything it could have',
+                    '',
+                    'Including a description',
+                    'and then some.',
+                    '',
+                    '  * a step',
+                    '    | value |',
+                    '  * another step',
+                    '    """',
+                    '    some string',
+                    '    """']
+          source = source.join("\n")
+          scenario = clazz.new(source)
+
+          scenario_output = scenario.to_s
+          remade_scenario_output = clazz.new(scenario_output).to_s
+
+          expect(remade_scenario_output).to eq(scenario_output)
+        end
+
+
+        context 'from source text' do
+
+          it 'can output an empty scenario' do
+            source = ['Scenario:']
+            source = source.join("\n")
+            scenario = clazz.new(source)
+
+            scenario_output = scenario.to_s.split("\n")
+
+            expect(scenario_output).to eq(['Scenario:'])
+          end
+
+          it 'can output a scenario that has a name' do
+            source = ['Scenario: test scenario']
+            source = source.join("\n")
+            scenario = clazz.new(source)
+
+            scenario_output = scenario.to_s.split("\n")
+
+            expect(scenario_output).to eq(['Scenario: test scenario'])
+          end
+
+          it 'can output a scenario that has a description' do
+            source = ['Scenario:',
+                      'Some description.',
+                      'Some more description.']
+            source = source.join("\n")
+            scenario = clazz.new(source)
+
+            scenario_output = scenario.to_s.split("\n")
+
+            expect(scenario_output).to eq(['Scenario:',
+                                           '',
+                                           'Some description.',
+                                           'Some more description.'])
+          end
+
+          it 'can output a scenario that has steps' do
+            source = ['Scenario:',
+                      '* a step',
+                      '|value|',
+                      '* another step',
+                      '"""',
+                      'some string',
+                      '"""']
+            source = source.join("\n")
+            scenario = clazz.new(source)
+
+            scenario_output = scenario.to_s.split("\n")
+
+            expect(scenario_output).to eq(['Scenario:',
+                                           '  * a step',
+                                           '    | value |',
+                                           '  * another step',
+                                           '    """',
+                                           '    some string',
+                                           '    """'])
+          end
+
+          it 'can output a scenario that has tags' do
+            source = ['@tag1 @tag2',
+                      '@tag3',
+                      'Scenario:']
+            source = source.join("\n")
+            scenario = clazz.new(source)
+
+            scenario_output = scenario.to_s.split("\n")
+
+            expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
+                                           'Scenario:'])
+          end
+
+          it 'can output a scenario that has everything' do
+            source = ['@tag1 @tag2 @tag3',
+                      'Scenario: A scenario with everything it could have',
+                      'Including a description',
+                      'and then some.',
+                      '* a step',
+                      '|value|',
+                      '* another step',
+                      '"""',
+                      'some string',
+                      '"""']
+            source = source.join("\n")
+            scenario = clazz.new(source)
+
+            scenario_output = scenario.to_s.split("\n")
+
+            expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
+                                           'Scenario: A scenario with everything it could have',
+                                           '',
+                                           'Including a description',
+                                           'and then some.',
+                                           '',
+                                           '  * a step',
+                                           '    | value |',
+                                           '  * another step',
+                                           '    """',
+                                           '    some string',
+                                           '    """'])
+          end
+
+        end
+
+
+        context 'from abstract instantiation' do
 
           let(:scenario) { clazz.new }
 
 
-          it 'can output a scenario that has only tag elements' do
-            scenario.tag_elements = [CukeModeler::Tag.new]
+          it 'can output a scenario that has only tags' do
+            scenario.tags = [CukeModeler::Tag.new]
 
             expect { scenario.to_s }.to_not raise_error
           end
@@ -93,3 +445,5 @@ describe 'Scenario, Integration' do
   end
 
 end
+
+