cuke_modeler 0.3.0 → 0.4.0

data/spec/unit/nested_element_unit_specs.rb

@@ -4,27 +4,28 @@ shared_examples_for 'a nested element' do
 
   # clazz must be defined by the calling file
 
-  before(:each) do
-    @nested_element = clazz.new
-  end
+  let(:nested_element) { clazz.new }
+
 
-  it 'has a parent element - #parent_element' do
-    @nested_element.should respond_to(:parent_element)
+  it 'has a parent element' do
+    nested_element.should respond_to(:parent_element)
   end
 
-  it 'can get and set its parent element - #parent_element, #parent_element=' do
-    @nested_element.parent_element = :some_parent_element
-    @nested_element.parent_element.should == :some_parent_element
-    @nested_element.parent_element = :some_other_parent_element
-    @nested_element.parent_element.should == :some_other_parent_element
+  it 'can change its parent element' do
+    expect(nested_element).to respond_to(:parent_element=)
+
+    nested_element.parent_element = :some_parent_element
+    nested_element.parent_element.should == :some_parent_element
+    nested_element.parent_element = :some_other_parent_element
+    nested_element.parent_element.should == :some_other_parent_element
   end
 
   it 'starts with no parent element' do
-    @nested_element.parent_element.should == nil
+    nested_element.parent_element.should == nil
   end
 
   it 'has access to its ancestors' do
-    @nested_element.should respond_to(:get_ancestor)
+    nested_element.should respond_to(:get_ancestor)
   end
 
   it 'gets an ancestor based on type' do
@@ -32,7 +33,7 @@ shared_examples_for 'a nested element' do
   end
 
   it 'raises and exception if an unknown ancestor type is requested' do
-    expect { @nested_element.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
+    expect { nested_element.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
   end
 
 end

data/spec/unit/nested_unit_spec.rb

@@ -4,34 +4,37 @@ SimpleCov.command_name('Nested') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Nested, Unit' do
 
-  nodule = CukeModeler::Nested
+  let(:nodule) { CukeModeler::Nested }
+  let(:nested_element) { Object.new.extend(nodule) }
 
-  before(:each) do
-    @nested_element = Object.new.extend(nodule)
-  end
 
+  describe 'unique behavior' do
 
-  it 'has a parent element - #parent_element' do
-    @nested_element.should respond_to(:parent_element)
-  end
+    it 'has a parent element' do
+      nested_element.should respond_to(:parent_element)
+    end
 
-  it 'can get and set its parent element - #parent_element, #parent_element=' do
-    @nested_element.parent_element = :some_parent_element
-    @nested_element.parent_element.should == :some_parent_element
-    @nested_element.parent_element = :some_other_parent_element
-    @nested_element.parent_element.should == :some_other_parent_element
-  end
+    it 'can change its parent element' do
+      expect(nested_element).to respond_to(:parent_element=)
 
-  it 'has access to its ancestors' do
-    @nested_element.should respond_to(:get_ancestor)
-  end
+      nested_element.parent_element = :some_parent_element
+      nested_element.parent_element.should == :some_parent_element
+      nested_element.parent_element = :some_other_parent_element
+      nested_element.parent_element.should == :some_other_parent_element
+    end
 
-  it 'gets an ancestor based on type' do
-    (nodule.instance_method(:get_ancestor).arity == 1).should be_true
-  end
+    it 'has access to its ancestors' do
+      nested_element.should respond_to(:get_ancestor)
+    end
+
+    it 'gets an ancestor based on type' do
+      (nodule.instance_method(:get_ancestor).arity == 1).should be_true
+    end
+
+    it 'raises and exception if an unknown ancestor type is requested' do
+      expect { nested_element.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
+    end
 
-  it 'raises and exception if an unknown ancestor type is requested' do
-    expect { @nested_element.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
   end
 
 end

data/spec/unit/outline_unit_spec.rb

@@ -5,118 +5,132 @@ SimpleCov.command_name('Outline') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'Outline, Unit' do
 
   let(:clazz) { CukeModeler::Outline }
+  let(:outline) { clazz.new }
 
-  it_should_behave_like 'a feature element'
-  it_should_behave_like 'a nested element'
-  it_should_behave_like 'a containing element'
-  it_should_behave_like 'a tagged element'
-  it_should_behave_like 'a bare bones element'
-  it_should_behave_like 'a prepopulated element'
-  it_should_behave_like 'a test element'
-  it_should_behave_like 'a sourced element'
-  it_should_behave_like 'a raw element'
 
+  describe 'common behavior' do
 
-  it 'can be parsed from stand alone text' do
-    source = "Scenario Outline: test outline
+    it_should_behave_like 'a feature element'
+    it_should_behave_like 'a nested element'
+    it_should_behave_like 'a containing element'
+    it_should_behave_like 'a tagged element'
+    it_should_behave_like 'a bare bones element'
+    it_should_behave_like 'a prepopulated element'
+    it_should_behave_like 'a test element'
+    it_should_behave_like 'a sourced element'
+    it_should_behave_like 'a raw element'
+
+  end
+
+
+  describe 'unique behavior' do
+
+    it 'can be parsed from stand alone text' do
+      source = "Scenario Outline: test outline
               Examples:
                 |param|
                 |value|"
 
-    expect { @element = clazz.new(source) }.to_not raise_error
+      expect { @element = clazz.new(source) }.to_not raise_error
 
-    # Sanity check in case instantiation failed in a non-explosive manner
-    @element.name.should == 'test outline'
-  end
+      # Sanity check in case instantiation failed in a non-explosive manner
+      @element.name.should == 'test outline'
+    end
 
-  it 'provides a descriptive filename when being parsed from stand alone text' do
-    source = "bad outline text \n Scenario Outline:\n And a step\n @foo "
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = "bad outline text \n Scenario Outline:\n And a step\n @foo "
 
-    expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_outline\.feature'/)
-  end
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_outline\.feature'/)
+    end
 
-  it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-    outline = clazz.new("Scenario Outline: test outline\nExamples:\n|param|\n|value|")
-    raw_data = outline.raw_element
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      outline = clazz.new("Scenario Outline: test outline\nExamples:\n|param|\n|value|")
+      raw_data = outline.raw_element
 
-    expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples])
-    expect(raw_data[:type]).to eq(:ScenarioOutline)
-  end
+      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples])
+      expect(raw_data[:type]).to eq(:ScenarioOutline)
+    end
 
-  it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-    outline = clazz.new("Scenario Outline: test outline\nExamples:\n|param|\n|value|")
-    raw_data = outline.raw_element
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      outline = clazz.new("Scenario Outline: test outline\nExamples:\n|param|\n|value|")
+      raw_data = outline.raw_element
 
-    expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples])
-    expect(raw_data[:type]).to eq(:ScenarioOutline)
-  end
+      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples])
+      expect(raw_data[:type]).to eq(:ScenarioOutline)
+    end
 
-  it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-    outline = clazz.new("Scenario Outline: test outline\nExamples:\n|param|\n|value|")
-    raw_data = outline.raw_element
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      outline = clazz.new("Scenario Outline: test outline\nExamples:\n|param|\n|value|")
+      raw_data = outline.raw_element
 
-    expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type'])
-    expect(raw_data['keyword']).to eq('Scenario Outline')
-  end
+      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type'])
+      expect(raw_data['keyword']).to eq('Scenario Outline')
+    end
+
+    it 'has examples' do
+      outline.should respond_to(:examples)
+    end
 
+    it 'can change its examples' do
+      expect(outline).to respond_to(:examples=)
 
-  before(:each) do
-    @outline = clazz.new
-  end
+      outline.examples = :some_examples
+      outline.examples.should == :some_examples
+      outline.examples = :some_other_examples
+      outline.examples.should == :some_other_examples
+    end
 
+    it 'starts with no examples' do
+      outline.examples.should == []
+    end
 
-  it 'has examples - #examples' do
-    @outline.should respond_to(:examples)
-  end
+    it 'contains steps and examples' do
+      steps = [:step_1, :step_2, :step_3]
+      examples = [:example_1, :example_2, :example_3]
+      everything = steps + examples
 
-  it 'can get and set its examples - #examples, #examples=' do
-    @outline.examples = :some_examples
-    @outline.examples.should == :some_examples
-    @outline.examples = :some_other_examples
-    @outline.examples.should == :some_other_examples
-  end
+      outline.steps = steps
+      outline.examples = examples
 
-  it 'starts with no examples' do
-    @outline.examples.should == []
-  end
+      outline.contains.should =~ everything
+    end
 
-  it 'contains steps and examples' do
-    steps = [:step_1, :step_2, :step_3]
-    examples = [:example_1, :example_2, :example_3]
-    everything = steps + examples
+    describe 'outline output edge cases' do
 
-    @outline.steps = steps
-    @outline.examples = examples
+      it 'is a String' do
+        outline.to_s.should be_a(String)
+      end
 
-    @outline.contains.should =~ everything
-  end
 
-  context 'outline output edge cases' do
+      context 'a new outline object' do
 
-    it 'is a String' do
-      @outline.to_s.should be_a(String)
-    end
+        let(:outline) { clazz.new }
 
-    it 'can output an empty outline' do
-      expect { @outline.to_s }.to_not raise_error
-    end
 
-    it 'can output an outline that has only a name' do
-      @outline.name = 'a name'
+        it 'can output an empty outline' do
+          expect { outline.to_s }.to_not raise_error
+        end
 
-      expect { @outline.to_s }.to_not raise_error
-    end
+        it 'can output an outline that has only a name' do
+          outline.name = 'a name'
 
-    it 'can output an outline that has only a description' do
-      @outline.description_text = 'a description'
+          expect { outline.to_s }.to_not raise_error
+        end
 
-      expect { @outline.to_s }.to_not raise_error
-    end
+        it 'can output an outline that has only a description' do
+          outline.description_text = 'a description'
+
+          expect { outline.to_s }.to_not raise_error
+        end
+
+        it 'can output an outline that has only tags' do
+          outline.tags = ['a tag']
+
+          expect { outline.to_s }.to_not raise_error
+        end
 
-    it 'can output an outline that has only a tags' do
-      @outline.tags = ['a tag']
+      end
 
-      expect { @outline.to_s }.to_not raise_error
     end
 
   end

data/spec/unit/parsing_unit_spec.rb

@@ -7,79 +7,83 @@ describe 'Parsing, Unit' do
   let(:nodule) { CukeModeler::Parsing }
 
 
-  it 'can parse text - #parse_text' do
-    nodule.should respond_to(:parse_text)
-  end
-
-  it 'can only parse strings' do
-    expect { nodule.parse_text(5) }.to raise_error(ArgumentError)
-    expect { nodule.parse_text('Feature:') }.to_not raise_error
-  end
+  describe 'unique behavior' do
 
-  it 'returns an Array' do
-    result = nodule.parse_text('Feature:')
-    result.is_a?(Array).should be_true
-  end
+    it 'can parse text' do
+      nodule.should respond_to(:parse_text)
+    end
 
-  it 'takes the text that is to be parsed and an optional file name' do
-    expect(nodule.method(:parse_text).arity).to eq(-2)
-  end
+    it 'can only parse strings' do
+      expect { nodule.parse_text(5) }.to raise_error(ArgumentError)
+      expect { nodule.parse_text('Feature:') }.to_not raise_error
+    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 'returns an Array' do
+      result = nodule.parse_text('Feature:')
+      result.is_a?(Array).should be_true
+    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 'takes the text that is to be parsed and an optional file name' do
+      expect(nodule.method(:parse_text).arity).to eq(-2)
+    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
+    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
 
-      # 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)
+    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
 
-        module Gherkin
-          class Parser
-            def parse(*args)
-              raise(CukeModeler::TestError, 'something went wrong')
-            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
-      else
-        old_method = Gherkin::Parser::Parser.instance_method(:parse)
 
-        module Gherkin
-          module Parser
+        # 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
-      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)
+        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
 
-  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
 
-  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