cuke_modeler 0.4.1 → 1.0.0

data/spec/unit/outline_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Outline') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Outline, Unit' do
+describe 'Outline, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Outline }
   let(:outline) { clazz.new }
@@ -10,99 +9,83 @@ describe 'Outline, Unit' do
 
   describe 'common behavior' do
 
-    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'
+    it_should_behave_like 'a model'
+    it_should_behave_like 'a named model'
+    it_should_behave_like 'a described model'
+    it_should_behave_like 'a stepped model'
+    it_should_behave_like 'a tagged model'
+    it_should_behave_like 'a sourced model'
+    it_should_behave_like 'a parsed model'
 
   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
-
-      # 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 "
-
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_outline\.feature'/)
+    it 'has examples' do
+      expect(outline).to respond_to(:examples)
     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 'can change its examples' do
+      expect(outline).to respond_to(:examples=)
 
-      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples])
-      expect(raw_data[:type]).to eq(:ScenarioOutline)
+      outline.examples = :some_examples
+      expect(outline.examples).to eq(:some_examples)
+      outline.examples = :some_other_examples
+      expect(outline.examples).to eq(:some_other_examples)
     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
 
-      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :examples])
-      expect(raw_data[:type]).to eq(:ScenarioOutline)
-    end
+    describe 'abstract instantiation' do
 
-    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
+      context 'a new outline object' do
 
-      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type'])
-      expect(raw_data['keyword']).to eq('Scenario Outline')
-    end
+        let(:outline) { clazz.new }
 
-    it 'has examples' do
-      outline.should respond_to(:examples)
-    end
 
-    it 'can change its examples' do
-      expect(outline).to respond_to(:examples=)
+        it 'starts with no examples' do
+          expect(outline.examples).to eq([])
+        end
 
-      outline.examples = :some_examples
-      outline.examples.should == :some_examples
-      outline.examples = :some_other_examples
-      outline.examples.should == :some_other_examples
-    end
+      end
 
-    it 'starts with no examples' do
-      outline.examples.should == []
     end
 
-    it 'contains steps and examples' do
+    it 'contains steps, examples, and tags' do
+      tags = [:tag_1, :tagt_2]
       steps = [:step_1, :step_2, :step_3]
       examples = [:example_1, :example_2, :example_3]
-      everything = steps + examples
+      everything = steps + examples + tags
 
       outline.steps = steps
       outline.examples = examples
+      outline.tags = tags
+
+      expect(outline.children).to match_array(everything)
+    end
+
+
+    describe 'comparison' do
+
+      it 'can gracefully be compared to other types of objects' do
+        # Some common types of object
+        [1, 'foo', :bar, [], {}].each do |thing|
+          expect { outline == thing }.to_not raise_error
+          expect(outline == thing).to be false
+        end
+      end
 
-      outline.contains.should =~ everything
     end
 
-    describe 'outline output edge cases' do
+
+    describe 'outline output' do
 
       it 'is a String' do
-        outline.to_s.should be_a(String)
+        expect(outline.to_s).to be_a(String)
       end
 
 
-      context 'a new outline object' do
+      context 'from abstract instantiation' do
 
         let(:outline) { clazz.new }
 
@@ -118,13 +101,7 @@ describe 'Outline, Unit' do
         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']
+          outline.description = 'a description'
 
           expect { outline.to_s }.to_not raise_error
         end

data/spec/unit/parsed_unit_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+
+describe 'Parsed, Unit' do
+
+  let(:nodule) { CukeModeler::Parsed }
+  let(:model) { Object.new.extend(nodule) }
+
+
+  describe 'unique behavior' do
+
+    it 'can access its original parsing data' do
+      expect(model).to respond_to(:parsing_data)
+    end
+
+    it 'can change its parsing data' do
+      expect(model).to respond_to(:parsing_data=)
+
+      model.parsing_data = :some_parsing_data
+      expect(model.parsing_data).to eq(:some_parsing_data)
+      model.parsing_data = :some_other_parsing_data
+      expect(model.parsing_data).to eq(:some_other_parsing_data)
+    end
+
+  end
+
+end

data/spec/unit/parsing_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Parsing') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Parsing, Unit' do
+describe 'Parsing, Unit', :unit_test => true do
 
   let(:nodule) { CukeModeler::Parsing }
 
@@ -10,80 +9,13 @@ describe 'Parsing, Unit' do
   describe 'unique behavior' do
 
     it 'can 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
-
-    it 'returns an Array' do
-      result = nodule.parse_text('Feature:')
-      result.is_a?(Array).should be_true
+      expect(nodule).to 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 '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 '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 '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
-
-        # 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
-
-        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
-
-    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
 
 end

data/spec/unit/row_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Row') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Row, Unit' do
+describe 'Row, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Row }
   let(:row) { clazz.new }
@@ -10,81 +9,53 @@ describe 'Row, Unit' do
 
   describe 'common behavior' do
 
-    it_should_behave_like 'a nested element'
-    it_should_behave_like 'a bare bones element'
-    it_should_behave_like 'a prepopulated element'
-    it_should_behave_like 'a sourced element'
-    it_should_behave_like 'a raw element'
+    it_should_behave_like 'a model'
+    it_should_behave_like 'a sourced model'
+    it_should_behave_like 'a parsed model'
 
   end
 
 
   describe 'unique behavior' do
 
-    it 'can be parsed from stand alone text' do
-      source = '| a | row |'
-
-      expect { @element = clazz.new(source) }.to_not raise_error
-
-      # Sanity check in case instantiation failed in a non-explosive manner
-      @element.cells.should == ['a', 'row']
+    it 'has cells' do
+      expect(row).to respond_to(:cells)
     end
 
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = " |bad |row| text| \n @foo "
+    it 'can change its cells' do
+      expect(row).to respond_to(:cells=)
 
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_row\.feature'/)
+      row.cells = :some_cells
+      expect(row.cells).to eq(:some_cells)
+      row.cells = :some_other_cells
+      expect(row.cells).to eq(:some_other_cells)
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      example_row = clazz.new("| a | row |")
-      raw_data = example_row.raw_element
 
-      expect(raw_data.keys).to match_array([:type, :location, :cells])
-      expect(raw_data[:type]).to eq(:TableRow)
-    end
+    describe 'abstract instantiation' do
 
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      example_row = clazz.new("| a | row |")
-      raw_data = example_row.raw_element
+      context 'a new row object' do
 
-      expect(raw_data.keys).to match_array([:type, :location, :cells])
-      expect(raw_data[:type]).to eq('TableRow')
-    end
+        let(:row) { clazz.new }
 
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      example_row = clazz.new("| a | row |")
-      raw_data = example_row.raw_element
 
-      expect(raw_data.keys).to match_array(['cells', 'line', 'id'])
-      expect(raw_data['cells']).to eq(['a', 'row'])
-    end
-
-    it 'has cells' do
-      row.should respond_to(:cells)
-    end
+        it 'starts with no cells' do
+          expect(row.cells).to eq([])
+        end
 
-    it 'can change its cells' do
-      expect(row).to respond_to(:cells=)
+      end
 
-      row.cells = :some_cells
-      row.cells.should == :some_cells
-      row.cells = :some_other_cells
-      row.cells.should == :some_other_cells
     end
 
-    it 'starts with no cells' do
-      row.cells.should == []
-    end
 
-    describe 'row output edge cases' do
+    describe 'row output' do
 
       it 'is a String' do
-        row.to_s.should be_a(String)
+        expect(row.to_s).to be_a(String)
       end
 
 
-      context 'a new row object' do
+      context 'from abstract instantiation' do
 
         let(:row) { clazz.new }
 

data/spec/unit/scenario_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Scenario') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Scenario, Unit' do
+describe 'Scenario, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Scenario }
   let(:scenario) { clazz.new }
@@ -10,77 +9,52 @@ describe 'Scenario, Unit' do
 
   describe 'common behavior' do
 
-    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'
+    it_should_behave_like 'a model'
+    it_should_behave_like 'a named model'
+    it_should_behave_like 'a described model'
+    it_should_behave_like 'a stepped model'
+    it_should_behave_like 'a tagged model'
+    it_should_behave_like 'a sourced model'
+    it_should_behave_like 'a parsed model'
 
   end
 
 
   describe 'unique behavior' do
 
-    it 'can be parsed from stand alone text' do
-      source = 'Scenario: test scenario'
-
-      expect { @element = clazz.new(source) }.to_not raise_error
-
-      # Sanity check in case instantiation failed in a non-explosive manner
-      @element.name.should == 'test scenario'
-    end
-
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = "bad scenario text \n Scenario:\n And a step\n @foo "
-
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_scenario\.feature'/)
-    end
+    it 'contains steps and tags' do
+      tags = [:tag_1, :tag_2]
+      steps = [:step_1, :step_2]
+      everything = steps + tags
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      scenario = clazz.new("Scenario: test scenario")
-      raw_data = scenario.raw_element
+      scenario.steps = steps
+      scenario.tags = tags
 
-      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps])
-      expect(raw_data[:type]).to eq(:Scenario)
+      expect(scenario.children).to match_array(everything)
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      scenario = clazz.new("Scenario: test scenario")
-      raw_data = scenario.raw_element
 
-      expect(raw_data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps])
-      expect(raw_data[:type]).to eq(:Scenario)
-    end
+    describe 'comparison' do
 
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      scenario = clazz.new("Scenario: test scenario")
-      raw_data = scenario.raw_element
+      it 'can gracefully be compared to other types of objects' do
+        # Some common types of object
+        [1, 'foo', :bar, [], {}].each do |thing|
+          expect { scenario == thing }.to_not raise_error
+          expect(scenario == thing).to be false
+        end
+      end
 
-      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type'])
-      expect(raw_data['keyword']).to eq('Scenario')
     end
 
-    it 'contains only steps' do
-      steps = [:step_1, :step_2]
-      everything = steps
-
-      scenario.steps = steps
-
-      scenario.contains.should =~ everything
-    end
 
-    describe 'scenario output edge cases' do
+    describe 'scenario output' do
 
       it 'is a String' do
-        scenario.to_s.should be_a(String)
+        expect(scenario.to_s).to be_a(String)
       end
 
 
-      context 'a new scenario object' do
+      context 'from abstract instantiation' do
 
         let(:scenario) { clazz.new }
 
@@ -96,13 +70,7 @@ describe 'Scenario, Unit' do
         end
 
         it 'can output a scenario that has only a description' do
-          scenario.description_text = 'a description'
-
-          expect { scenario.to_s }.to_not raise_error
-        end
-
-        it 'can output a scenario that has only tags' do
-          scenario.tags = ['a tag']
+          scenario.description = 'a description'
 
           expect { scenario.to_s }.to_not raise_error
         end