cuke_modeler 0.4.1 → 1.0.0

data/spec/integration/feature_file_integration_spec.rb

@@ -1,21 +1,78 @@
 require 'spec_helper'
 
-SimpleCov.command_name('FeatureFile') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'FeatureFile, Integration' do
 
   let(:clazz) { CukeModeler::FeatureFile }
 
 
+  describe 'common behavior' do
+
+    it_should_behave_like 'a model, integration'
+
+  end
+
   describe 'unique behavior' do
 
+    it 'provides its own filename when being parsed' do
+      path = "#{@default_file_directory}/#{@default_feature_file_name}"
+      File.open(path, "w") { |file| file.puts 'bad feature text' }
+
+      expect { clazz.new(path) }.to raise_error(/'#{path}'/)
+    end
+
     it 'cannot model a non-existent feature file' do
       path = "#{@default_file_directory}/missing_file.txt"
 
       expect { clazz.new(path) }.to raise_error(ArgumentError)
     end
 
-    it 'properly sets its child elements' do
+
+    describe 'model population' do
+
+      let(:source_text) { "Feature: Test feature" }
+      let(:feature_file_path) { "#{@default_file_directory}/#{@default_feature_file_name}" }
+      let(:feature_file) { clazz.new(feature_file_path) }
+
+      before(:each) do
+        File.open(feature_file_path, "w") { |file| file.puts source_text }
+      end
+
+      it "models the feature file's name" do
+        expect(feature_file.name).to eq(@default_feature_file_name)
+      end
+
+      it "models the feature file's path" do
+        expect(feature_file.path).to eq(feature_file_path)
+      end
+
+      it "models the feature file's feature" do
+        feature_name = feature_file.feature.name
+
+        expect(feature_name).to eq('Test feature')
+      end
+
+      # gherkin 3.x does not accept empty feature files
+      context 'an empty feature file', :gherkin3 => false do
+
+        let(:source_text) { '' }
+        let(:feature_file_path) { "#{@default_file_directory}/#{@default_feature_file_name}" }
+        let(:feature_file) { clazz.new(feature_file_path) }
+
+        before(:each) do
+          File.open(feature_file_path, "w") { |file| file.puts source_text }
+        end
+
+
+        it "models the feature file's feature" do
+          expect(feature_file.feature).to be_nil
+        end
+
+      end
+
+    end
+
+    it 'properly sets its child models' do
       file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
 
       File.open(file_path, "w") { |file|
@@ -25,9 +82,10 @@ describe 'FeatureFile, Integration' do
       file = clazz.new(file_path)
       feature = file.feature
 
-      expect(feature.parent_element).to equal(file)
+      expect(feature.parent_model).to equal(file)
     end
 
+
     describe 'getting ancestors' do
 
       before(:each) do
@@ -53,6 +111,43 @@ describe 'FeatureFile, Integration' do
 
     end
 
+
+    describe 'feature file output' do
+
+      context 'from source text' do
+
+        let(:source_text) { "Feature: Test feature" }
+        let(:feature_file_path) { "#{@default_file_directory}/#{@default_feature_file_name}" }
+        let(:feature_file) { clazz.new(feature_file_path) }
+
+        before(:each) do
+          File.open(feature_file_path, "w") { |file| file.puts source_text }
+        end
+
+
+        it 'can output a feature file' do
+          feature_file_output = feature_file.to_s
+
+          expect(feature_file_output).to eq(feature_file_path)
+        end
+
+      end
+
+      it 'can be remade from its own output' do
+        path = "#{@default_file_directory}/#{@default_feature_file_name}"
+        File.open(path, "w") { |file| file.puts "Feature:" }
+
+        source = path
+        feature_file = clazz.new(source)
+
+        feature_file_output = feature_file.to_s
+        remade_feature_file_output = clazz.new(feature_file_output).to_s
+
+        expect(remade_feature_file_output).to eq(feature_file_output)
+      end
+
+    end
+
   end
 
 end

data/spec/integration/feature_integration_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Feature') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Feature, Integration' do
 
@@ -8,9 +7,27 @@ describe 'Feature, Integration' do
   let(:feature) { clazz.new }
 
 
+  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 = 'Feature:'
+
+      expect { clazz.new(source) }.to_not raise_error
+    end
+
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = 'bad feature text'
+
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_feature\.feature'/)
+    end
+
+    it 'properly sets its child models' do
       source = ['@a_tag',
                 'Feature: Test feature',
                 '  Background: Test background',
@@ -26,13 +43,59 @@ describe 'Feature, Integration' do
       background = feature.background
       scenario = feature.tests[0]
       outline = feature.tests[1]
-      tag = feature.tag_elements[0]
+      tag = feature.tags[0]
 
 
-      expect(outline.parent_element).to equal(feature)
-      expect(scenario.parent_element).to equal(feature)
-      expect(background.parent_element).to equal(feature)
-      expect(tag.parent_element).to equal(feature)
+      expect(outline.parent_model).to equal(feature)
+      expect(scenario.parent_model).to equal(feature)
+      expect(background.parent_model).to equal(feature)
+      expect(tag.parent_model).to equal(feature)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      feature = clazz.new("@tag\nFeature: test feature\ndescription\nBackground:\nScenario:")
+      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
+
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      feature = clazz.new("@tag\nFeature: test feature\ndescription\nBackground:\nScenario:")
+      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', :gherkin2 => true do
+      feature = clazz.new("@tag\nFeature: test feature\ndescription\nBackground:\nScenario:")
+      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
+
+    it 'trims whitespace from its source description' do
+      source = ['Feature:',
+                '  ',
+                '        description line 1',
+                '',
+                '   description line 2',
+                '     description line 3               ',
+                '',
+                '',
+                '',
+                '  Scenario:']
+      source = source.join("\n")
+
+      feature = clazz.new(source)
+      description = feature.description.split("\n")
+
+      expect(description).to eq(['     description line 1',
+                                 '',
+                                 'description line 2',
+                                 '  description line 3'])
     end
 
     it 'can selectively access its scenarios and outlines' do
@@ -45,28 +108,127 @@ describe 'Feature, Integration' do
       expect(feature.outlines).to match_array(outlines)
     end
 
-    it 'knows how many scenarios it has' do
-      scenarios = [CukeModeler::Scenario.new, CukeModeler::Scenario.new]
-      outlines = [CukeModeler::Outline.new]
 
-      feature.tests = []
-      expect(feature.scenario_count).to eq(0)
+    describe 'model population' do
 
-      feature.tests = scenarios + outlines
-      expect(feature.scenario_count).to eq(2)
-    end
+      context 'from source text' do
 
-    it 'knows how many outlines it has' do
-      scenarios = [CukeModeler::Scenario.new]
-      outlines = [CukeModeler::Outline.new, CukeModeler::Outline.new]
+        it "models the feature's source line" do
+          source_text = "Feature:"
+          feature = CukeModeler::Feature.new(source_text)
 
-      feature.tests = []
-      expect(feature.outline_count).to eq(0)
+          expect(feature.source_line).to eq(1)
+        end
+
+
+        context 'a filled feature' do
+
+          let(:source_text) { '@tag_1 @tag_2
+                               Feature: Feature Foo
+
+                                   Some feature description.
+
+                                 Some more.
+                                     And some more.
+
+                                 Background: The background
+                                   * some setup step
+
+                                 Scenario: Scenario 1
+                                   * a step
+
+                                 Scenario Outline: Outline 1
+                                   * a step
+                                 Examples:
+                                   | param |
+                                   | value |
+
+                                 Scenario: Scenario 2
+                                   * a step
+
+                                 Scenario Outline: Outline 2
+                                   * a step
+                                 Examples:
+                                   | param |
+                                   | value |' }
+          let(:feature) { clazz.new(source_text) }
+
+
+          it "models the feature's name" do
+            expect(feature.name).to eq('Feature Foo')
+          end
+
+          it "models the feature's description" do
+            description = feature.description.split("\n")
+
+            expect(description).to eq(['  Some feature description.',
+                                       '',
+                                       'Some more.',
+                                       '    And some more.'])
+          end
+
+          it "models the feature's background" do
+            expect(feature.background.name).to eq('The background')
+          end
+
+          it "models the feature's scenarios" do
+            scenario_names = feature.scenarios.collect { |scenario| scenario.name }
+
+            expect(scenario_names).to eq(['Scenario 1', 'Scenario 2'])
+          end
+
+          it "models the feature's outlines" do
+            outline_names = feature.outlines.collect { |outline| outline.name }
+
+            expect(outline_names).to eq(['Outline 1', 'Outline 2'])
+          end
+
+          it "models the feature's tags" do
+            tag_names = feature.tags.collect { |tag| tag.name }
+
+            expect(tag_names).to eq(['@tag_1', '@tag_2'])
+          end
+
+        end
+
+
+        context 'an empty feature' do
+
+          let(:source_text) { 'Feature:' }
+          let(:feature) { clazz.new(source_text) }
+
+
+          it "models the feature's name" do
+            expect(feature.name).to eq('')
+          end
+
+          it "models the feature's description" do
+            expect(feature.description).to eq('')
+          end
+
+          it "models the feature's background" do
+            expect(feature.background).to be_nil
+          end
+
+          it "models the feature's scenarios" do
+            expect(feature.scenarios).to eq([])
+          end
+
+          it "models the feature's outlines" do
+            expect(feature.outlines).to eq([])
+          end
+
+          it "models the feature's tags" do
+            expect(feature.tags).to eq([])
+          end
+
+        end
+
+      end
 
-      feature.tests = scenarios + outlines
-      expect(feature.outline_count).to eq(2)
     end
 
+
     it 'knows how many test cases it has' do
       source_1 = ['Feature: Test feature']
       source_1 = source_1.join("\n")
@@ -101,7 +263,7 @@ describe 'Feature, Integration' do
       end
 
       let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:feature) { directory.feature_files.first.features.first }
+      let(:feature) { directory.feature_files.first.feature }
 
 
       it 'can get its directory' do
@@ -124,15 +286,271 @@ describe 'Feature, Integration' do
 
     end
 
-    describe 'feature output edge cases' do
 
-      context 'a new feature object' do
+    describe 'feature output' do
+
+      it 'can be remade from its own output' do
+        source = ['@tag1 @tag2 @tag3',
+                  'Feature: A feature with everything it could have',
+                  '',
+                  'Including a description',
+                  'and then some.',
+                  '',
+                  '  Background:',
+                  '',
+                  '  Background',
+                  '  description',
+                  '',
+                  '    * a step',
+                  '      | value1 |',
+                  '    * another step ',
+                  '',
+                  '  @scenario_tag ',
+                  '  Scenario:',
+                  '',
+                  '  Scenario ',
+                  '  description ',
+                  '',
+                  '    * a step ',
+                  '    * another step ',
+                  '      """"',
+                  '      some text ',
+                  '      """',
+                  '',
+                  '  @outline_tag ',
+                  '  Scenario Outline: ',
+                  '',
+                  '  Outline ',
+                  '  description ',
+                  '',
+                  '    * a step ',
+                  '      | value2 |',
+                  '    * another step ',
+                  '      """',
+                  '      some text ',
+                  '      """',
+                  '',
+                  '  @example_tag ',
+                  '  Examples:',
+                  '',
+                  '  Example ',
+                  '  description',
+                  '',
+                  '    | param |',
+                  '    | value |']
+        source = source.join(" \n")
+        feature = clazz.new(source)
+
+        feature_output = feature.to_s
+        remade_feature_output = clazz.new(feature_output).to_s
+
+        expect(remade_feature_output).to eq(feature_output)
+      end
+
+
+      context 'from source text' do
+
+        it 'can output an empty feature' do
+          source = ['Feature:']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['Feature:'])
+        end
+
+        it 'can output a feature that has a name' do
+          source = ['Feature: test feature']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['Feature: test feature'])
+        end
+
+        it 'can output a feature that has a description' do
+          source = ['Feature:',
+                    'Some description.',
+                    'Some more description.']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['Feature:',
+                                        '',
+                                        'Some description.',
+                                        'Some more description.'])
+        end
+
+        it 'can output a feature that has tags' do
+          source = ['@tag1 @tag2',
+                    '@tag3',
+                    'Feature:']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['@tag1 @tag2 @tag3',
+                                        'Feature:'])
+        end
+
+        it 'can output a feature that has a background' do
+          source = ['Feature:',
+                    'Background:',
+                    '* a step']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['Feature:',
+                                        '',
+                                        '  Background:',
+                                        '    * a step'])
+        end
+
+        it 'can output a feature that has a scenario' do
+          source = ['Feature:',
+                    'Scenario:',
+                    '* a step']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['Feature:',
+                                        '',
+                                        '  Scenario:',
+                                        '    * a step'])
+        end
+
+        it 'can output a feature that has an outline' do
+          source = ['Feature:',
+                    'Scenario Outline:',
+                    '* a step',
+                    'Examples:',
+                    '|param|',
+                    '|value|']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['Feature:',
+                                        '',
+                                        '  Scenario Outline:',
+                                        '    * a step',
+                                        '',
+                                        '  Examples:',
+                                        '    | param |',
+                                        '    | value |'])
+        end
+
+        it 'can output a feature that has everything' do
+          source = ['@tag1 @tag2 @tag3',
+                    'Feature: A feature with everything it could have',
+                    'Including a description',
+                    'and then some.',
+                    'Background:',
+                    'Background',
+                    'description',
+                    '* a step',
+                    '|value1|',
+                    '* another step',
+                    '@scenario_tag',
+                    'Scenario:',
+                    'Scenario',
+                    'description',
+                    '* a step',
+                    '* another step',
+                    '"""',
+                    'some text',
+                    '"""',
+                    '@outline_tag',
+                    'Scenario Outline:',
+                    'Outline ',
+                    'description',
+                    '* a step ',
+                    '|value2|',
+                    '* another step',
+                    '"""',
+                    'some text',
+                    '"""',
+                    '@example_tag',
+                    'Examples:',
+                    'Example',
+                    'description',
+                    '|param|',
+                    '|value|']
+          source = source.join("\n")
+          feature = clazz.new(source)
+
+          feature_output = feature.to_s.split("\n")
+
+          expect(feature_output).to eq(['@tag1 @tag2 @tag3',
+                                        'Feature: A feature with everything it could have',
+                                        '',
+                                        'Including a description',
+                                        'and then some.',
+                                        '',
+                                        '  Background:',
+                                        '',
+                                        '  Background',
+                                        '  description',
+                                        '',
+                                        '    * a step',
+                                        '      | value1 |',
+                                        '    * another step',
+                                        '',
+                                        '  @scenario_tag',
+                                        '  Scenario:',
+                                        '',
+                                        '  Scenario',
+                                        '  description',
+                                        '',
+                                        '    * a step',
+                                        '    * another step',
+                                        '      """',
+                                        '      some text',
+                                        '      """',
+                                        '',
+                                        '  @outline_tag',
+                                        '  Scenario Outline:',
+                                        '',
+                                        '  Outline',
+                                        '  description',
+                                        '',
+                                        '    * a step',
+                                        '      | value2 |',
+                                        '    * another step',
+                                        '      """',
+                                        '      some text',
+                                        '      """',
+                                        '',
+                                        '  @example_tag',
+                                        '  Examples:',
+                                        '',
+                                        '  Example',
+                                        '  description',
+                                        '',
+                                        '    | param |',
+                                        '    | value |'])
+        end
+
+      end
+
+
+      context 'from abstract instantiation' do
 
         let(:feature) { clazz.new }
 
 
-        it 'can output a feature that has only tag elements' do
-          feature.tag_elements = [CukeModeler::Tag.new]
+        it 'can output a feature that has only tags' do
+          feature.tags = [CukeModeler::Tag.new]
 
           expect { feature.to_s }.to_not raise_error
         end