cuke_modeler 0.4.1 → 1.0.0

data/lib/cuke_modeler/version.rb

@@ -1,3 +1,4 @@
 module CukeModeler
-  VERSION = "0.4.1"
+  # The gem version
+  VERSION = "1.0.0"
 end

data/spec/integration/background_integration_spec.rb

@@ -1,15 +1,56 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Background') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Background, Integration' do
 
   let(:clazz) { CukeModeler::Background }
 
 
+  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 = 'Background:'
+
+      expect { clazz.new(source) }.to_not raise_error
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      background = clazz.new("Background: test background\ndescription\n* a step")
+      data = background.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :keyword, :name, :steps, :description])
+      expect(data[:type]).to eq(:Background)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      background = clazz.new("Background: test background\ndescription\n* a step")
+      data = background.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :keyword, :name, :steps, :description])
+      expect(data[:type]).to eq(:Background)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      background = clazz.new("Background: test background\ndescription\n* a step")
+      data = background.parsing_data
+
+      expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'steps', 'type'])
+      expect(data['keyword']).to eq('Background')
+    end
+
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = "bad background text \n Background:\n And a step\n @foo "
+
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_background\.feature'/)
+    end
+
+    it 'properly sets its child models' do
       source = ['  Background: Test background',
                 '    * a step']
       source = source.join("\n")
@@ -17,9 +58,32 @@ describe 'Background, Integration' do
       background = clazz.new(source)
       step = background.steps.first
 
-      expect(step.parent_element).to equal(background)
+      expect(step.parent_model).to equal(background)
     end
 
+    it 'trims whitespace from its source description' do
+      source = ['Background:',
+                '  ',
+                '        description line 1',
+                '',
+                '   description line 2',
+                '     description line 3               ',
+                '',
+                '',
+                '',
+                '  * a step']
+      source = source.join("\n")
+
+      background = clazz.new(source)
+      description = background.description.split("\n")
+
+      expect(description).to eq(['     description line 1',
+                                 '',
+                                 'description line 2',
+                                 '  description line 3'])
+    end
+
+
     describe 'getting ancestors' do
 
       before(:each) do
@@ -34,7 +98,7 @@ describe 'Background, Integration' do
       end
 
       let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:background) { directory.feature_files.first.features.first.background }
+      let(:background) { directory.feature_files.first.feature.background }
 
 
       it 'can get its directory' do
@@ -52,7 +116,7 @@ describe 'Background, Integration' do
       it 'can get its feature' do
         ancestor = background.get_ancestor(:feature)
 
-        expect(ancestor).to 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
@@ -63,9 +127,270 @@ describe 'Background, Integration' do
 
     end
 
-    describe 'background output edge cases' do
 
-      context 'a new background object' do
+    describe 'model population' do
+
+      context 'from source text' do
+
+        it "models the background's source line" do
+          source_text = "Feature:
+
+                           Background: foo
+                             * step"
+          background = CukeModeler::Feature.new(source_text).background
+
+          expect(background.source_line).to eq(3)
+        end
+
+        context 'a filled background' do
+
+          let(:source_text) { "Background: Background name
+
+                               Background description.
+
+                             Some more.
+                                 Even more.
+
+                                 * a step
+                                 * another step" }
+          let(:background) { clazz.new(source_text) }
+
+
+          it "models the background's name" do
+            expect(background.name).to eq('Background name')
+          end
+
+          it "models the background's description" do
+            description = background.description.split("\n")
+
+            expect(description).to eq(['  Background description.',
+                                       '',
+                                       'Some more.',
+                                       '    Even more.'])
+          end
+
+          it "models the background's steps" do
+            step_names = background.steps.collect { |step| step.text }
+
+            expect(step_names).to eq(['a step', 'another step'])
+          end
+
+        end
+
+        context 'an empty background' do
+
+          let(:source_text) { 'Background:' }
+          let(:background) { clazz.new(source_text) }
+
+
+          it "models the background's name" do
+            expect(background.name).to eq('')
+          end
+
+          it "models the background's description" do
+            expect(background.description).to eq('')
+          end
+
+          it "models the background's steps" do
+            expect(background.steps).to eq([])
+          end
+
+        end
+
+      end
+
+    end
+
+
+    describe 'comparison' do
+
+      it 'is equal to a background with the same steps' do
+        source = "Background:
+                    * step 1
+                    * step 2"
+        background_1 = clazz.new(source)
+
+        source = "Background:
+                    * step 1
+                    * step 2"
+        background_2 = clazz.new(source)
+
+        source = "Background:
+                    * step 2
+                    * step 1"
+        background_3 = clazz.new(source)
+
+
+        expect(background_1).to eq(background_2)
+        expect(background_1).to_not eq(background_3)
+      end
+
+      it 'is equal to a scenario with the same steps' do
+        source = "Background:
+                    * step 1
+                    * step 2"
+        background = clazz.new(source)
+
+        source = "Scenario:
+                    * step 1
+                    * step 2"
+        scenario_1 = CukeModeler::Scenario.new(source)
+
+        source = "Scenario:
+                    * step 2
+                    * step 1"
+        scenario_2 = CukeModeler::Scenario.new(source)
+
+
+        expect(background).to eq(scenario_1)
+        expect(background).to_not eq(scenario_2)
+      end
+
+      it 'is equal to an outline with the same steps' do
+        source = "Background:
+                    * step 1
+                    * step 2"
+        background = 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(background).to eq(outline_1)
+        expect(background).to_not eq(outline_2)
+      end
+
+    end
+
+
+    describe 'background output' do
+
+      it 'can be remade from its own output' do
+        source = ['Background: A background with everything it could have',
+                  '',
+                  'Including a description',
+                  'and then some.',
+                  '',
+                  '  * a step',
+                  '    | value |',
+                  '  * another step',
+                  '    """',
+                  '    some string',
+                  '    """']
+        source = source.join("\n")
+        background = clazz.new(source)
+
+        background_output = background.to_s
+        remade_background_output = clazz.new(background_output).to_s
+
+        expect(remade_background_output).to eq(background_output)
+      end
+
+
+      context 'from source text' do
+
+        it 'can output an empty background' do
+          source = ['Background:']
+          source = source.join("\n")
+          background = clazz.new(source)
+
+          background_output = background.to_s.split("\n")
+
+          expect(background_output).to eq(['Background:'])
+        end
+
+        it 'can output a background that has a name' do
+          source = ['Background: test background']
+          source = source.join("\n")
+          background = clazz.new(source)
+
+          background_output = background.to_s.split("\n")
+
+          expect(background_output).to eq(['Background: test background'])
+        end
+
+        it 'can output a background that has a description' do
+          source = ['Background:',
+                    'Some description.',
+                    'Some more description.']
+          source = source.join("\n")
+          background = clazz.new(source)
+
+          background_output = background.to_s.split("\n")
+
+          expect(background_output).to eq(['Background:',
+                                           '',
+                                           'Some description.',
+                                           'Some more description.'])
+        end
+
+        it 'can output a background that has steps' do
+          source = ['Background:',
+                    '* a step',
+                    '|value|',
+                    '* another step',
+                    '"""',
+                    'some string',
+                    '"""']
+          source = source.join("\n")
+          background = clazz.new(source)
+
+          background_output = background.to_s.split("\n")
+
+          expect(background_output).to eq(['Background:',
+                                           '  * a step',
+                                           '    | value |',
+                                           '  * another step',
+                                           '    """',
+                                           '    some string',
+                                           '    """'])
+        end
+
+        it 'can output a background that has everything' do
+          source = ['Background: A background with everything it could have',
+                    'Including a description',
+                    'and then some.',
+                    '* a step',
+                    '|value|',
+                    '* another step',
+                    '"""',
+                    'some string',
+                    '"""']
+          source = source.join("\n")
+          background = clazz.new(source)
+
+          background_output = background.to_s.split("\n")
+
+          expect(background_output).to eq(['Background: A background 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(:background) { clazz.new }
 

data/spec/integration/cell_integration_spec.rb

@@ -0,0 +1,321 @@
+require 'spec_helper'
+
+
+describe 'Cell, Integration' do
+
+  let(:clazz) { CukeModeler::Cell }
+
+
+  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 = ''
+
+      expect { clazz.new(source) }.to_not raise_error
+    end
+
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = "not a \n cell"
+
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_cell\.feature'/)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      cell = clazz.new('a cell')
+      data = cell.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :value])
+      expect(data[:type]).to eq(:TableCell)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      cell = clazz.new("a cell")
+      data = cell.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :value])
+      expect(data[:type]).to eq('TableCell')
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      cell = clazz.new("a cell")
+      data = cell.parsing_data
+
+      # Cells did not exist as full fledged objects in the Gherkin2 parser
+      expect(data).to eq('a cell')
+    end
+
+
+    describe 'getting ancestors' do
+
+      before(:each) do
+        source = ['Feature: Test feature',
+                  '',
+                  '  Scenario: Test test',
+                  '    * a step',
+                  '      | a value |']
+        source = source.join("\n")
+
+        file_path = "#{@default_file_directory}/cell_test_file.feature"
+        File.open(file_path, 'w') { |file| file.write(source) }
+      end
+
+      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+      let(:cell) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first.cells.first }
+
+
+      it 'can get its directory' do
+        ancestor = cell.get_ancestor(:directory)
+
+        expect(ancestor).to equal(directory)
+      end
+
+      it 'can get its feature file' do
+        ancestor = cell.get_ancestor(:feature_file)
+
+        expect(ancestor).to equal(directory.feature_files.first)
+      end
+
+      it 'can get its feature' do
+        ancestor = cell.get_ancestor(:feature)
+
+        expect(ancestor).to equal(directory.feature_files.first.feature)
+      end
+
+      context 'a cell 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}/cell_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:cell) { directory.feature_files.first.feature.tests.first.examples.first.rows.first.cells.first }
+
+
+        it 'can get its outline' do
+          ancestor = cell.get_ancestor(:outline)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+        end
+
+        it 'can get its example' do
+          ancestor = cell.get_ancestor(:example)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.examples.first)
+        end
+
+        it 'can get its row' do
+          ancestor = cell.get_ancestor(:row)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.examples.first.rows.first)
+        end
+
+      end
+
+
+      context 'a cell 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}/cell_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:cell) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first.cells.first }
+
+
+        it 'can get its scenario' do
+          ancestor = cell.get_ancestor(:scenario)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+        end
+
+      end
+
+      context 'a cell 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}/cell_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:cell) { directory.feature_files.first.feature.background.steps.first.block.rows.first.cells.first }
+
+
+        it 'can get its background' do
+          ancestor = cell.get_ancestor(:background)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.background)
+        end
+
+      end
+
+      context 'a cell that is part of a step' do
+
+        before(:each) do
+          source = 'Feature: Test feature
+
+                      Scenario: Test test
+                        * a step:
+                          | a | table |'
+
+          file_path = "#{@default_file_directory}/cell_test_file.feature"
+          File.open(file_path, 'w') { |file| file.write(source) }
+        end
+
+        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+        let(:cell) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first.cells.first }
+
+
+        it 'can get its step' do
+          ancestor = cell.get_ancestor(:step)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first)
+        end
+
+        it 'can get its table' do
+          ancestor = cell.get_ancestor(:table)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first.block)
+        end
+
+        it 'can get its row' do
+          ancestor = cell.get_ancestor(:row)
+
+          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first.block.rows.first)
+        end
+
+      end
+
+      it 'returns nil if it does not have the requested type of ancestor' do
+        ancestor = cell.get_ancestor(:example)
+
+        expect(ancestor).to be_nil
+      end
+
+    end
+
+
+    describe 'model population' do
+
+      context 'from source text' do
+
+        let(:source_text) { 'a cell' }
+        let(:cell) { clazz.new(source_text) }
+
+
+        it "models the cell's value" do
+          expect(cell.value).to eq('a cell')
+        end
+
+        it "models the cell's source line" do
+          source_text = 'Feature:
+
+                           Scenario:
+                             * a step
+                               | value |'
+          cell = CukeModeler::Feature.new(source_text).tests.first.steps.first.block.rows.first.cells.first
+
+          expect(cell.source_line).to eq(5)
+        end
+
+      end
+
+    end
+
+
+    describe 'cell output' do
+
+      it 'can be remade from its own output' do
+        source = 'a \\\\ complex \| cell'
+        cell = clazz.new(source)
+
+        cell_output = cell.to_s
+        remade_cell_output = clazz.new(cell_output).to_s
+
+        expect(remade_cell_output).to eq(cell_output)
+      end
+
+
+      context 'from source text' do
+
+        it 'can output a cell' do
+          source = 'a cell'
+          cell = clazz.new(source)
+
+          expect(cell.to_s).to eq('a cell')
+        end
+
+        #  Because vertical bars mark the beginning and end of a cell, any vertical bars inside
+        #  of the cell (which would have had to have been escaped to get inside of the cell in
+        #  the first place) will be escaped when outputted so as to retain the quality of being
+        #  able to use the output directly as Gherkin.
+
+        it 'can output a cell that has vertical bars in it' do
+          source = 'cell with a \| in it'
+          cell = clazz.new(source)
+
+          cell_output = cell.to_s
+
+          expect(cell_output).to eq('cell with a \| in it')
+        end
+
+        #  Because backslashes are used to escape special characters, any backslashes inside
+        #  of the cell (which would have had to have been escaped to get inside of the cell in
+        #  the first place) will be escaped when outputted so as to retain the quality of being
+        #  able to use the output directly as Gherkin.
+
+        it 'can output a cell that has backslashes in it' do
+          source = 'cell with a \\\\ in it'
+          cell = clazz.new(source)
+
+          cell_output = cell.to_s
+
+          expect(cell_output).to eq('cell with a \\\\ in it')
+        end
+
+        # Depending on the order in which special characters are escaped, extra backslashes might occur.
+        it 'can output a cell that has several kinds of special characters in it' do
+          source = 'cell with a \\\\ and \| in it'
+          cell = clazz.new(source)
+
+          cell_output = cell.to_s
+
+          expect(cell_output).to eq('cell with a \\\\ and \| in it')
+        end
+
+      end
+
+    end
+
+  end
+
+end