cuke_modeler 0.3.0 → 0.4.0

data/spec/integration/feature_file_integration_spec.rb

@@ -4,41 +4,55 @@ SimpleCov.command_name('FeatureFile') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'FeatureFile, Integration' do
 
-  it 'properly sets its child elements' do
-    file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
+  let(:clazz) { CukeModeler::FeatureFile }
 
-    File.open(file_path, "w") { |file|
-      file.puts('Feature: Test feature')
-    }
 
-    file = CukeModeler::FeatureFile.new(file_path)
-    feature = file.feature
+  describe 'unique behavior' do
 
-    feature.parent_element.should equal file
-  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
 
-  context 'getting stuff' do
+    it 'properly sets its child elements' do
+      file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
 
-    before(:each) do
-      file_path = "#{@default_file_directory}/feature_file_test_file.feature"
-      File.open(file_path, 'w') { |file| file.write('Feature: Test feature') }
+      File.open(file_path, "w") { |file|
+        file.puts('Feature: Test feature')
+      }
 
-      @directory = CukeModeler::Directory.new(@default_file_directory)
-      @feature_file = @directory.feature_files.first
+      file = clazz.new(file_path)
+      feature = file.feature
+
+      expect(feature.parent_element).to equal(file)
     end
 
+    describe 'getting ancestors' do
 
-    it 'can get its directory' do
-      directory = @feature_file.get_ancestor(:directory)
+      before(:each) do
+        file_path = "#{@default_file_directory}/feature_file_test_file.feature"
+        File.open(file_path, 'w') { |file| file.write('Feature: Test feature') }
+      end
 
-      directory.should equal @directory
-    end
+      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+      let(:feature_file) { directory.feature_files.first }
 
-    it 'returns nil if it does not have the requested type of ancestor' do
-      example = @feature_file.get_ancestor(:example)
 
-      example.should be_nil
+      it 'can get its directory' do
+        ancestor = feature_file.get_ancestor(:directory)
+
+        expect(ancestor).to equal(directory)
+      end
+
+      it 'returns nil if it does not have the requested type of ancestor' do
+        ancestor = feature_file.get_ancestor(:example)
+
+        expect(ancestor).to be_nil
+      end
+
     end
 
   end
+
 end

data/spec/integration/feature_integration_spec.rb

@@ -4,150 +4,159 @@ SimpleCov.command_name('Feature') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Feature, Integration' do
 
-  clazz = CukeModeler::Feature
+  let(:clazz) { CukeModeler::Feature }
+  let(:feature) { clazz.new }
 
-  before(:each) do
-    @feature = clazz.new
-  end
 
-  it 'properly sets its child elements' do
-    source = ['@a_tag',
-              'Feature: Test feature',
-              '  Background: Test background',
-              '  Scenario: Test scenario',
-              '  Scenario Outline: Test outline',
-              '  Examples: Test Examples',
-              '    | param |',
-              '    | value |']
-    source = source.join("\n")
-
-
-    feature = CukeModeler::Feature.new(source)
-    background = feature.background
-    scenario = feature.tests[0]
-    outline = feature.tests[1]
-    tag = feature.tag_elements[0]
-
-
-    outline.parent_element.should equal feature
-    scenario.parent_element.should equal feature
-    background.parent_element.should equal feature
-    tag.parent_element.should equal feature
-  end
+  describe 'unique behavior' do
 
-  it 'can distinguish scenarios from outlines - #scenarios, #outlines' do
-    scenarios = [CukeModeler::Scenario.new('Scenario: 1'), CukeModeler::Scenario.new('Scenario: 2')]
-    outlines = [CukeModeler::Outline.new("Scenario Outline: 1\nExamples:\n|param|\n|value|"), CukeModeler::Outline.new("Scenario Outline: 2\nExamples:\n|param|\n|value|")]
+    it 'properly sets its child elements' do
+      source = ['@a_tag',
+                'Feature: Test feature',
+                '  Background: Test background',
+                '  Scenario: Test scenario',
+                '  Scenario Outline: Test outline',
+                '  Examples: Test Examples',
+                '    | param |',
+                '    | value |']
+      source = source.join("\n")
 
-    @feature.tests = scenarios + outlines
 
-    @feature.scenarios.should =~ scenarios
-    @feature.outlines.should =~ outlines
-  end
+      feature = clazz.new(source)
+      background = feature.background
+      scenario = feature.tests[0]
+      outline = feature.tests[1]
+      tag = feature.tag_elements[0]
 
-  it 'knows how many scenarios it has - #scenario_count' do
-    scenarios = [CukeModeler::Scenario.new('Scenario: 1'), CukeModeler::Scenario.new('Scenario: 2')]
-    outlines = [CukeModeler::Outline.new("Scenario Outline: 1\nExamples:\n|param|\n|value|")]
 
-    @feature.tests = []
-    @feature.scenario_count.should == 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)
+    end
 
-    @feature.tests = scenarios + outlines
-    @feature.scenario_count.should == 2
-  end
+    it 'can selectively access its scenarios and outlines' do
+      scenarios = [CukeModeler::Scenario.new, CukeModeler::Scenario.new]
+      outlines = [CukeModeler::Outline.new, CukeModeler::Outline.new]
 
-  it 'knows how many outlines it has - #outline_count' do
-    scenarios = [CukeModeler::Scenario.new('Scenario: 1')]
-    outlines = [CukeModeler::Outline.new("Scenario Outline: 1\nExamples:\n|param|\n|value|"), CukeModeler::Outline.new("Scenario Outline: 2\nExamples:\n|param|\n|value|")]
+      feature.tests = scenarios + outlines
 
-    @feature.tests = []
-    @feature.outline_count.should == 0
+      expect(feature.scenarios).to match_array(scenarios)
+      expect(feature.outlines).to match_array(outlines)
+    end
 
-    @feature.tests = scenarios + outlines
-    @feature.outline_count.should == 2
-  end
+    it 'knows how many scenarios it has' do
+      scenarios = [CukeModeler::Scenario.new, CukeModeler::Scenario.new]
+      outlines = [CukeModeler::Outline.new]
 
-  it 'knows how many test cases it has - #test_case_count' do
-    source_1 = ['Feature: Test feature']
-    source_1 = source_1.join("\n")
+      feature.tests = []
+      expect(feature.scenario_count).to eq(0)
 
-    source_2 = ['Feature: Test feature',
-                '  Scenario: Test scenario',
-                '  Scenario Outline: Test outline',
-                '    * a step',
-                '  Examples: Test examples',
-                '    |param|',
-                '    |value_1|',
-                '    |value_2|']
-    source_2 = source_2.join("\n")
+      feature.tests = scenarios + outlines
+      expect(feature.scenario_count).to eq(2)
+    end
 
-    feature_1 = CukeModeler::Feature.new(source_1)
-    feature_2 = CukeModeler::Feature.new(source_2)
+    it 'knows how many outlines it has' do
+      scenarios = [CukeModeler::Scenario.new]
+      outlines = [CukeModeler::Outline.new, CukeModeler::Outline.new]
 
+      feature.tests = []
+      expect(feature.outline_count).to eq(0)
 
-    feature_1.test_case_count.should == 0
-    feature_2.test_case_count.should == 3
-  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")
 
-  context 'getting stuff' do
+      source_2 = ['Feature: Test feature',
+                  '  Scenario: Test scenario',
+                  '  Scenario Outline: Test outline',
+                  '    * a step',
+                  '  Examples: Test examples',
+                  '    |param|',
+                  '    |value_1|',
+                  '    |value_2|']
+      source_2 = source_2.join("\n")
 
-    before(:each) do
-      source = ['Feature: Test feature']
-      source = source.join("\n")
+      feature_1 = clazz.new(source_1)
+      feature_2 = clazz.new(source_2)
 
-      file_path = "#{@default_file_directory}/feature_test_file.feature"
-      File.open(file_path, 'w') { |file| file.write(source) }
 
-      @directory = CukeModeler::Directory.new(@default_file_directory)
-      @feature = @directory.feature_files.first.features.first
+      expect(feature_1.test_case_count).to eq(0)
+      expect(feature_2.test_case_count).to eq(3)
     end
 
 
-    it 'can get its directory' do
-      directory = @feature.get_ancestor(:directory)
+    describe 'getting ancestors' do
 
-      directory.should equal @directory
-    end
+      before(:each) do
+        source = ['Feature: Test feature']
+        source = source.join("\n")
 
-    it 'can get its feature file' do
-      feature_file = @feature.get_ancestor(:feature_file)
+        file_path = "#{@default_file_directory}/feature_test_file.feature"
+        File.open(file_path, 'w') { |file| file.write(source) }
+      end
 
-      feature_file.should equal @directory.feature_files.first
-    end
+      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+      let(:feature) { directory.feature_files.first.features.first }
 
-    it 'returns nil if it does not have the requested type of ancestor' do
-      test = @feature.get_ancestor(:test)
 
-      test.should be_nil
-    end
+      it 'can get its directory' do
+        ancestor = feature.get_ancestor(:directory)
 
-  end
+        expect(ancestor).to equal(directory)
+      end
 
-  context 'feature output edge cases' do
+      it 'can get its feature file' do
+        ancestor = feature.get_ancestor(:feature_file)
 
-    it 'can output a feature that has only a tag elements' do
-      @feature.tag_elements = [CukeModeler::Tag.new]
+        expect(ancestor).to equal(directory.feature_files.first)
+      end
 
-      expect { @feature.to_s }.to_not raise_error
-    end
+      it 'returns nil if it does not have the requested type of ancestor' do
+        ancestor = feature.get_ancestor(:test)
 
-    it 'can output a feature that has only a background' do
-      @feature.background = [CukeModeler::Background.new]
+        expect(ancestor).to be_nil
+      end
 
-      expect { @feature.to_s }.to_not raise_error
     end
 
-    it 'can output a feature that has only scenarios' do
-      @feature.tests = [CukeModeler::Scenario.new]
+    describe 'feature output edge cases' do
 
-      expect { @feature.to_s }.to_not raise_error
-    end
+      context 'a new feature object' do
+
+        let(:feature) { clazz.new }
+
+
+        it 'can output a feature that has only tag elements' do
+          feature.tag_elements = [CukeModeler::Tag.new]
+
+          expect { feature.to_s }.to_not raise_error
+        end
+
+        it 'can output a feature that has only a background' do
+          feature.background = [CukeModeler::Background.new]
+
+          expect { feature.to_s }.to_not raise_error
+        end
+
+        it 'can output a feature that has only scenarios' do
+          feature.tests = [CukeModeler::Scenario.new]
+
+          expect { feature.to_s }.to_not raise_error
+        end
+
+        it 'can output a feature that has only outlines' do
+          feature.tests = [CukeModeler::Outline.new]
+
+          expect { feature.to_s }.to_not raise_error
+        end
 
-    it 'can output a feature that has only outlines' do
-      @feature.tests = [CukeModeler::Outline.new]
+      end
 
-      expect { @feature.to_s }.to_not raise_error
     end
 
   end

data/spec/integration/outline_integration_spec.rb

@@ -4,91 +4,106 @@ SimpleCov.command_name('Outline') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Outline, Integration' do
 
-  it 'properly sets its child elements' do
-    source = ['@a_tag',
-              '  Scenario Outline:',
-              '    * a step',
-              '  Examples:',
-              '    | param |',
-              '    | value |']
-    source = source.join("\n")
-
-    outline = CukeModeler::Outline.new(source)
-    example = outline.examples.first
-    step = outline.steps.first
-    tag = outline.tag_elements.first
-
-    example.parent_element.should equal outline
-    step.parent_element.should equal outline
-    tag.parent_element.should equal outline
-  end
+  let(:clazz) { CukeModeler::Outline }
 
 
-  context 'getting stuff' do
+  describe 'unique behavior' do
 
-    before(:each) do
-      source = ['Feature: Test feature',
-                '',
-                '  Scenario Outline: Test test',
+    it 'properly sets its child elements' do
+      source = ['@a_tag',
+                '  Scenario Outline:',
                 '    * a step',
-                '  Examples: Test example',
-                '    | a param |',
-                '    | a value |']
+                '  Examples:',
+                '    | param |',
+                '    | value |']
       source = source.join("\n")
 
-      file_path = "#{@default_file_directory}/outline_test_file.feature"
-      File.open(file_path, 'w') { |file| file.write(source) }
+      outline = clazz.new(source)
+      example = outline.examples.first
+      step = outline.steps.first
+      tag = outline.tag_elements.first
 
-      @directory = CukeModeler::Directory.new(@default_file_directory)
-      @outline = @directory.feature_files.first.features.first.tests.first
+      expect(example.parent_element).to equal(outline)
+      expect(step.parent_element).to equal(outline)
+      expect(tag.parent_element).to equal(outline)
     end
 
 
-    it 'can get its directory' do
-      directory = @outline.get_ancestor(:directory)
+    describe 'getting ancestors' do
 
-      directory.should equal @directory
-    end
+      before(:each) do
+        source = ['Feature: Test feature',
+                  '',
+                  '  Scenario Outline: Test test',
+                  '    * a step',
+                  '  Examples: Test example',
+                  '    | a param |',
+                  '    | a value |']
+        source = source.join("\n")
 
-    it 'can get its feature file' do
-      feature_file = @outline.get_ancestor(:feature_file)
+        file_path = "#{@default_file_directory}/outline_test_file.feature"
+        File.open(file_path, 'w') { |file| file.write(source) }
+      end
 
-      feature_file.should equal @directory.feature_files.first
-    end
+      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+      let(:outline) { directory.feature_files.first.features.first.tests.first }
 
-    it 'can get its feature' do
-      feature = @outline.get_ancestor(:feature)
 
-      feature.should equal @directory.feature_files.first.features.first
-    end
+      it 'can get its directory' do
+        ancestor = outline.get_ancestor(:directory)
 
-    it 'returns nil if it does not have the requested type of ancestor' do
-      test = @outline.get_ancestor(:test)
+        expect(ancestor).to equal(directory)
+      end
 
-      test.should be_nil
-    end
+      it 'can get its feature file' do
+        ancestor = outline.get_ancestor(:feature_file)
 
-    context 'outline output edge cases' do
+        expect(ancestor).to equal(directory.feature_files.first)
+      end
 
-      it 'can output an outline that has only a tag elements' do
-        @outline.tag_elements = [CukeModeler::Tag.new]
+      it 'can get its feature' do
+        ancestor = outline.get_ancestor(:feature)
 
-        expect { @outline.to_s }.to_not raise_error
+        expect(ancestor).to equal(directory.feature_files.first.features.first)
       end
 
-      it 'can output an outline that has only steps' do
-        @outline.steps = [CukeModeler::Step.new]
+      it 'returns nil if it does not have the requested type of ancestor' do
+        ancestor = outline.get_ancestor(:test)
 
-        expect { @outline.to_s }.to_not raise_error
+        expect(ancestor).to be_nil
       end
 
-      it 'can output an outline that has only examples' do
-        @outline.examples = [CukeModeler::Example.new]
+      describe 'outline output edge cases' do
+
+        context 'a new outline object' do
+
+          let(:outline) { clazz.new }
+
+
+          it 'can output an outline that has only tag elements' do
+            outline.tag_elements = [CukeModeler::Tag.new]
+
+            expect { outline.to_s }.to_not raise_error
+          end
+
+          it 'can output an outline that has only steps' do
+            outline.steps = [CukeModeler::Step.new]
+
+            expect { outline.to_s }.to_not raise_error
+          end
+
+          it 'can output an outline that has only examples' do
+            outline.examples = [CukeModeler::Example.new]
+
+            expect { outline.to_s }.to_not raise_error
+          end
+
+        end
 
-        expect { @outline.to_s }.to_not raise_error
       end
 
     end
 
   end
+
 end