cuke_modeler 2.0.0 → 2.1.0

data/testing/rspec/spec/integration/models/feature_integration_spec.rb

@@ -69,38 +69,43 @@ describe 'Feature, Integration' do
       expect(tag.parent_model).to equal(feature)
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin6 => true do
-      feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
-      data = feature.parsing_data
+    describe 'parsing data' do
 
-      expect(data.keys).to match_array([:tags, :location, :language, :keyword, :name, :children, :description])
-      expect(data[:name]).to eq('test feature')
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(6, 7, 8, 9) do
+        feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
+        data = feature.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4_5 => true do
-      feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
-      data = feature.parsing_data
+        expect(data.keys).to match_array([:tags, :location, :language, :keyword, :name, :children, :description])
+        expect(data[:name]).to eq('test feature')
+      end
 
-      expect(data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :children, :description])
-      expect(data[:type]).to eq(:Feature)
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(4, 5) do
+        feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
+        data = feature.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
-      data = feature.parsing_data
+        expect(data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :children, :description])
+        expect(data[:type]).to eq(:Feature)
+      end
 
-      expect(data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :scenarioDefinitions, :comments, :background, :description])
-      expect(data[:type]).to eq(:Feature)
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(3) do
+        feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
+        data = feature.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
-      data = feature.parsing_data
+        expect(data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :scenarioDefinitions, :comments, :background, :description])
+        expect(data[:type]).to eq(:Feature)
+      end
+
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(2) do
+        feature = clazz.new("@tag\n#{FEATURE_KEYWORD}: test feature\ndescription\n#{BACKGROUND_KEYWORD}:\n#{SCENARIO_KEYWORD}:")
+        data = feature.parsing_data
+
+        expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'uri', 'elements', 'tags'])
+        expect(data['keyword']).to eq('Feature')
+      end
 
-      expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'uri', 'elements', 'tags'])
-      expect(data['keyword']).to eq('Feature')
     end
 
+
     it 'trims whitespace from its source description' do
       source = ["#{FEATURE_KEYWORD}:",
                 '  ',

data/testing/rspec/spec/integration/models/outline_integration_spec.rb

@@ -14,26 +14,14 @@ describe 'Outline, Integration' do
 
   describe 'unique behavior' do
 
-    it 'can be instantiated with the minimum viable Gherkin', :gherkin6 => true do
-      source = "#{OUTLINE_KEYWORD}:"
-
-      expect { clazz.new(source) }.to_not raise_error
-    end
-
-    it 'can be instantiated with the minimum viable Gherkin', :gherkin4_5 => true do
-      source = "#{OUTLINE_KEYWORD}:"
-
-      expect { clazz.new(source) }.to_not raise_error
-    end
-
-    it 'can be instantiated with the minimum viable Gherkin', :gherkin2 => true do
+    it 'can be instantiated with the minimum viable Gherkin', :unless => gherkin?(3) do
       source = "#{OUTLINE_KEYWORD}:"
 
       expect { clazz.new(source) }.to_not raise_error
     end
 
     # gherkin 3.x does not accept incomplete outlines
-    it 'can be instantiated with the minimum viable Gherkin', :gherkin3 => true do
+    it 'can be instantiated with the minimum viable Gherkin', :if => gherkin?(3) do
       source = "#{OUTLINE_KEYWORD}:
                 #{EXAMPLE_KEYWORD}:
                   | param |
@@ -63,36 +51,32 @@ describe 'Outline, Integration' do
       end
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin6 => true do
-      outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
-      data = outline.parsing_data
+    describe 'parsing data' do
 
-      expect(data.keys).to match_array([:background, :rule, :scenario])
-      expect(data[:scenario][:name]).to eq('test outline')
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(6, 7, 8, 9) do
+        outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
+        data = outline.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4_5 => true do
-      outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
-      data = outline.parsing_data
+        expect(data.keys).to match_array([:background, :rule, :scenario])
+        expect(data[:scenario][:name]).to eq('test outline')
+      end
 
-      expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples, :description])
-      expect(data[:type]).to eq(:ScenarioOutline)
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(3, 4, 5) do
+        outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
+        data = outline.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
-      data = outline.parsing_data
+        expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples, :description])
+        expect(data[:type]).to eq(:ScenarioOutline)
+      end
 
-      expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples, :description])
-      expect(data[:type]).to eq(:ScenarioOutline)
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(2) do
+        outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
+        data = outline.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      outline = clazz.new("@tag\n#{OUTLINE_KEYWORD}: test outline\ndescription\n#{STEP_KEYWORD} a step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|")
-      data = outline.parsing_data
+        expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type', 'examples', 'steps', 'tags'])
+        expect(data['keyword']).to eq('Scenario Outline')
+      end
 
-      expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type', 'examples', 'steps', 'tags'])
-      expect(data['keyword']).to eq('Scenario Outline')
     end
 
     it 'provides a descriptive filename when being parsed from stand alone text' do
@@ -176,10 +160,21 @@ describe 'Outline, Integration' do
 
 
         # gherkin 3.x does not accept incomplete outlines
-        it "models the outline's keyword", :gherkin3 => false do
+        it "models the outline's keyword", :unless => gherkin?(3) do
           expect(outline.keyword).to eq("#{OUTLINE_KEYWORD}")
         end
 
+        context 'using gherkin 3.x', :if => gherkin?(3) do
+
+          let(:source_text) { "#{OUTLINE_KEYWORD}:\n#{STEP_KEYWORD} step\n#{EXAMPLE_KEYWORD}:\n|param|\n|value|" }
+          let(:outline) { clazz.new(source_text) }
+
+          it "models the outline's keyword" do
+            expect(outline.keyword).to eq(OUTLINE_KEYWORD)
+          end
+
+        end
+
         it "models the outline's source line" do
           source_text = "#{FEATURE_KEYWORD}:
 
@@ -251,7 +246,7 @@ describe 'Outline, Integration' do
 
 
         # gherkin 3.x does not accept incomplete outlines
-        context 'an empty outline', :gherkin3 => false do
+        context 'an empty outline', :unless => gherkin?(3) do
 
           let(:source_text) { "#{OUTLINE_KEYWORD}:" }
           let(:outline) { clazz.new(source_text) }
@@ -433,7 +428,7 @@ describe 'Outline, Integration' do
       context 'from source text' do
 
         # gherkin 3.x does not accept incomplete outlines
-        it 'can output an empty outline', :gherkin3 => false do
+        it 'can output an empty outline', :unless => gherkin?(3) do
           source = ["#{OUTLINE_KEYWORD}:"]
           source = source.join("\n")
           outline = clazz.new(source)
@@ -444,7 +439,7 @@ describe 'Outline, Integration' do
         end
 
         # gherkin 3.x does not accept incomplete outlines
-        it 'can output a outline that has a name', :gherkin3 => false do
+        it 'can output a outline that has a name', :unless => gherkin?(3) do
           source = ["#{OUTLINE_KEYWORD}: test outline"]
           source = source.join("\n")
           outline = clazz.new(source)
@@ -455,7 +450,7 @@ describe 'Outline, Integration' do
         end
 
         # gherkin 3.x does not accept incomplete outlines
-        it 'can output a outline that has a description', :gherkin3 => false do
+        it 'can output a outline that has a description', :unless => gherkin?(3) do
           source = ["#{OUTLINE_KEYWORD}:",
                     'Some description.',
                     'Some more description.']
@@ -471,7 +466,7 @@ describe 'Outline, Integration' do
         end
 
         # gherkin 3.x does not accept incomplete outlines
-        it 'can output a outline that has steps', :gherkin3 => false do
+        it 'can output a outline that has steps', :unless => gherkin?(3) do
           source = ["#{OUTLINE_KEYWORD}:",
                     "  #{STEP_KEYWORD} a step",
                     '    | value |',
@@ -494,7 +489,7 @@ describe 'Outline, Integration' do
         end
 
         # gherkin 3.x does not accept incomplete outlines
-        it 'can output a outline that has tags', :gherkin3 => false do
+        it 'can output a outline that has tags', :unless => gherkin?(3) do
           source = ['@tag1 @tag2',
                     '@tag3',
                     "#{OUTLINE_KEYWORD}:"]

data/testing/rspec/spec/integration/models/row_integration_spec.rb

@@ -44,36 +44,48 @@ describe 'Row, Integration' do
       expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_row\.feature'/)
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin6 => true do
-      example_row = clazz.new("| a | row |")
-      data = example_row.parsing_data
+    describe 'parsing data' do
 
-      expect(data.keys).to match_array([:location, :cells])
-      expect(data[:location][:line]).to eq(5)
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(8, 9) do
+        example_row = clazz.new("| a | row |")
+        data = example_row.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4_5 => true do
-      example_row = clazz.new("| a | row |")
-      data = example_row.parsing_data
+        expect(data.keys).to match_array([:location, :cells, :id])
+        expect(data[:location][:line]).to eq(5)
+      end
 
-      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', :if => gherkin?(6, 7) do
+        example_row = clazz.new("| a | row |")
+        data = example_row.parsing_data
 
-    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([:location, :cells])
+        expect(data[:location][:line]).to eq(5)
+      end
 
-      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', :if => gherkin?(4, 5) 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', :if => gherkin?(3) 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', :if => gherkin?(2) do
+        example_row = clazz.new("| a | row |")
+        data = example_row.parsing_data
 
-    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(5)
+      end
 
-      expect(data.keys).to match_array(['cells', 'line'])
-      expect(data['line']).to eq(5)
     end
 
     it 'properly sets its child models' do

data/testing/rspec/spec/integration/models/scenario_integration_spec.rb

@@ -43,36 +43,32 @@ describe 'Scenario, Integration' do
       expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_scenario\.feature'/)
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin6 => true do
-      scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} a step")
-      data = scenario.parsing_data
+    describe 'parsing data' do
 
-      expect(data.keys).to match_array([:background, :rule, :scenario])
-      expect(data[:scenario][:name]).to eq('test scenario')
-    end
+      it 'stores the original data generated by the parsing adapter', :if => gherkin?(6, 7, 8, 9) do
+        scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} a step")
+        data = scenario.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4_5 => true do
-      scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} a step")
-      data = scenario.parsing_data
+        expect(data.keys).to match_array([:background, :rule, :scenario])
+        expect(data[:scenario][:name]).to eq('test scenario')
+      end
 
-      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', :if => gherkin?(3, 4, 5) do
+        scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} a step")
+        data = scenario.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} 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
 
-      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', :if => gherkin?(2) do
+        scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} a step")
+        data = scenario.parsing_data
 
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      scenario = clazz.new("@tag\n#{SCENARIO_KEYWORD}: test scenario\ndescription\n#{STEP_KEYWORD} 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
 
-      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

data/testing/rspec/spec/integration/models/step_integration_spec.rb

@@ -43,68 +43,72 @@ describe 'Step, Integration' do
       expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_step\.feature'/)
     end
 
-    it 'stores the original data generated by the parsing adapter (with a table)', :gherkin6 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
-      data = step.parsing_data
+    describe 'parsing data' do
 
-      expect(data.keys).to match_array([:location, :keyword, :text, :data_table, :doc_string])
-      expect(data[:text]).to eq('test step')
-    end
+      it 'stores the original data generated by the parsing adapter (with a table)', :if => gherkin?(8, 9) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a doc string)', :gherkin6 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
-      data = step.parsing_data
+        expect(data.keys).to match_array([:location, :keyword, :text, :data_table, :doc_string, :id])
+        expect(data[:text]).to eq('test step')
+      end
 
-      expect(data.keys).to match_array([:location, :keyword, :text, :data_table, :doc_string])
-      expect(data[:text]).to eq('test step')
-    end
+      it 'stores the original data generated by the parsing adapter (with a doc string)', :if => gherkin?(8, 9) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a table)', :gherkin4_5 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
-      data = step.parsing_data
+        expect(data.keys).to match_array([:location, :keyword, :text, :data_table, :doc_string, :id])
+        expect(data[:text]).to eq('test step')
+      end
 
-      expect(data.keys).to match_array([:type, :location, :keyword, :text, :argument])
-      expect(data[:type]).to eq(:Step)
-    end
+      it 'stores the original data generated by the parsing adapter (with a table)', :if => gherkin?(6, 7) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a doc string)', :gherkin4_5 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
-      data = step.parsing_data
+        expect(data.keys).to match_array([:location, :keyword, :text, :data_table, :doc_string])
+        expect(data[:text]).to eq('test step')
+      end
 
-      expect(data.keys).to match_array([:type, :location, :keyword, :text, :argument])
-      expect(data[:type]).to eq(:Step)
-    end
+      it 'stores the original data generated by the parsing adapter (with a doc string)', :if => gherkin?(6, 7) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a table)', :gherkin3 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
-      data = step.parsing_data
+        expect(data.keys).to match_array([:location, :keyword, :text, :data_table, :doc_string])
+        expect(data[:text]).to eq('test step')
+      end
 
-      expect(data.keys).to match_array([:type, :location, :keyword, :text, :argument])
-      expect(data[:type]).to eq(:Step)
-    end
+      it 'stores the original data generated by the parsing adapter (with a table)', :if => gherkin?(3, 4, 5) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a doc string)', :gherkin3 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
-      data = step.parsing_data
+        expect(data.keys).to match_array([:type, :location, :keyword, :text, :argument])
+        expect(data[:type]).to eq(:Step)
+      end
 
-      expect(data.keys).to match_array([:type, :location, :keyword, :text, :argument])
-      expect(data[:type]).to eq(:Step)
-    end
+      it 'stores the original data generated by the parsing adapter (with a doc string)', :if => gherkin?(3, 4, 5) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a table)', :gherkin2 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
-      data = step.parsing_data
+        expect(data.keys).to match_array([:type, :location, :keyword, :text, :argument])
+        expect(data[:type]).to eq(:Step)
+      end
 
-      expect(data.keys).to match_array(['keyword', 'name', 'line', 'rows'])
-      expect(data['keyword']).to eq("#{STEP_KEYWORD} ")
-    end
+      it 'stores the original data generated by the parsing adapter (with a table)', :if => gherkin?(2) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n|table|")
+        data = step.parsing_data
 
-    it 'stores the original data generated by the parsing adapter (with a doc string)', :gherkin2 => true do
-      step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
-      data = step.parsing_data
+        expect(data.keys).to match_array(['keyword', 'name', 'line', 'rows'])
+        expect(data['keyword']).to eq("#{STEP_KEYWORD} ")
+      end
+
+      it 'stores the original data generated by the parsing adapter (with a doc string)', :if => gherkin?(2) do
+        step = clazz.new("#{STEP_KEYWORD} test step\n\"\"\"\na doc string\n\"\"\"")
+        data = step.parsing_data
+
+        expect(data.keys).to match_array(['keyword', 'name', 'line', 'doc_string'])
+        expect(data['keyword']).to eq("#{STEP_KEYWORD} ")
+      end
 
-      expect(data.keys).to match_array(['keyword', 'name', 'line', 'doc_string'])
-      expect(data['keyword']).to eq("#{STEP_KEYWORD} ")
     end
 
     describe 'model population' do