cuke_modeler 0.4.1 → 1.0.0

data/spec/unit/step_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Step') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Step, Unit' do
+describe 'Step, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Step }
   let(:step) { clazz.new }
@@ -10,286 +9,96 @@ describe 'Step, 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 'has arguments' do
-      step.should respond_to(:arguments)
+    it 'has text' do
+      expect(step).to respond_to(:text)
     end
 
-    it 'can change its arguments' do
-      expect(step).to respond_to(:arguments=)
+    it 'can change its text' do
+      expect(step).to respond_to(:text=)
 
-      step.arguments = :some_arguments
-      step.arguments.should == :some_arguments
-      step.arguments = :some_other_arguments
-      step.arguments.should == :some_other_arguments
-    end
-
-    it 'starts with no arguments' do
-      step.arguments.should == []
-    end
-
-    it 'has a base' do
-      step.should respond_to(:base)
-    end
-
-    it 'can change its base' do
-      expect(step).to respond_to(:base=)
-
-      step.base = :some_base
-      step.base.should == :some_base
-      step.base = :some_other_base
-      step.base.should == :some_other_base
-    end
-
-    it 'starts with no base' do
-      step.base.should == nil
+      step.text = :some_text
+      expect(step.text).to eq(:some_text)
+      step.text = :some_other_text
+      expect(step.text).to eq(:some_other_text)
     end
 
     it 'has a block' do
-      step.should respond_to(:block)
+      expect(step).to respond_to(:block)
     end
 
     it 'can change its block' do
       expect(step).to respond_to(:block=)
 
       step.block = :some_block
-      step.block.should == :some_block
+      expect(step.block).to eq(:some_block)
       step.block = :some_other_block
-      step.block.should == :some_other_block
-    end
-
-    it 'starts with no block' do
-      step.block.should == nil
+      expect(step.block).to eq(:some_other_block)
     end
 
     it 'has a keyword' do
-      step.should respond_to(:keyword)
+      expect(step).to respond_to(:keyword)
     end
 
     it 'can change its keyword' do
       expect(step).to respond_to(:keyword=)
 
       step.keyword = :some_keyword
-      step.keyword.should == :some_keyword
+      expect(step.keyword).to eq(:some_keyword)
       step.keyword = :some_other_keyword
-      step.keyword.should == :some_other_keyword
-    end
-
-    it 'starts with no keyword' do
-      step.keyword.should == nil
-    end
-
-    it 'has a left delimiter' do
-      step.should respond_to(:left_delimiter)
-    end
-
-    it 'can change its left delimiter' do
-      expect(step).to respond_to(:left_delimiter=)
-
-      step.left_delimiter = :some_left_delimiter
-      step.left_delimiter.should == :some_left_delimiter
-      step.left_delimiter = :some_other_left_delimiter
-      step.left_delimiter.should == :some_other_left_delimiter
-    end
-
-    it 'starts with no left delimiter' do
-      step.left_delimiter.should == nil
-    end
-
-    it 'has a right delimiter' do
-      step.should respond_to(:right_delimiter)
+      expect(step.keyword).to eq(:some_other_keyword)
     end
 
-    it 'can change its right delimiter' do
-      expect(step).to respond_to(:right_delimiter=)
-
-      step.right_delimiter = :some_right_delimiter
-      step.right_delimiter.should == :some_right_delimiter
-      step.right_delimiter = :some_other_right_delimiter
-      step.right_delimiter.should == :some_other_right_delimiter
-    end
-
-    it 'starts with no right delimiter' do
-      step.right_delimiter.should == nil
-    end
-
-    it 'can set both of its delimiters at once' do
-      step.delimiter = :new_delimiter
-      step.left_delimiter.should == :new_delimiter
-      step.right_delimiter.should == :new_delimiter
-    end
-
-    describe '#scan_arguments' do
-
-      it 'can explicitly scan for arguments' do
-        step.should respond_to(:scan_arguments)
-      end
-
-      it 'can determine its arguments based on a regular expression' do
-        source = 'Given a test step with a parameter'
-        step = clazz.new(source)
-
-        step.scan_arguments(/parameter/)
-        step.arguments.should == ['parameter']
-        step.scan_arguments(/t s/)
-        step.arguments.should == ['t s']
-      end
-
-      it 'can determine its arguments based on delimiters' do
-        source = 'Given a test step with -parameter 1- and -parameter 2-'
-
-        step = clazz.new(source)
-
-        step.scan_arguments('-', '-')
-        step.arguments.should == ['parameter 1', 'parameter 2']
-        step.scan_arguments('!', '!')
-        step.arguments.should == []
-      end
-
-      it 'can use different left and right delimiters when scanning' do
-        source = 'Given a test step with !a parameter-'
-
-        step = clazz.new(source)
-
-        step.scan_arguments('!', '-')
-        step.arguments.should == ['a parameter']
-      end
-
-      it 'can use delimiters of varying lengths' do
-        source = 'Given a test step with -start-a parameter-end-'
 
-        step = clazz.new(source)
+    describe 'abstract instantiation' do
 
-        step.scan_arguments('-start-', '-end-')
-        step.arguments.should == ['a parameter']
-      end
+      context 'a new step object' do
 
-      it 'can handle delimiters with special regular expression characters' do
-        source = 'Given a test step with \d+a parameter.?'
+        let(:step) { clazz.new }
 
-        step = clazz.new(source)
 
-        step.scan_arguments('\d+', '.?')
-        step.arguments.should == ['a parameter']
-      end
+        it 'starts with no text' do
+          expect(step.text).to be_nil
+        end
 
-      it 'defaults to its set delimiters when scanning' do
-        source = 'Given a test step with *parameter 1* and "parameter 2" and *parameter 3*'
-        step = clazz.new(source)
+        it 'starts with no block' do
+          expect(step.block).to be_nil
+        end
 
-        step.left_delimiter = '"'
-        step.right_delimiter = '"'
-        step.scan_arguments
+        it 'starts with no keyword' do
+          expect(step.keyword).to be_nil
+        end
 
-        step.arguments.should == ['parameter 2']
       end
-    end
-
-    it 'can be parsed from stand alone text' do
-      source = '* test step'
 
-      expect { @element = clazz.new(source) }.to_not raise_error
-
-      # Sanity check in case instantiation failed in a non-explosive manner
-      @element.base.should == 'test step'
     end
 
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = "bad step text\n And a step\n @foo"
+    it 'contains some kind of block' do
+      block = :block
+      everything = [block]
 
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_step\.feature'/)
-    end
+      step.block = block
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      step = clazz.new("* test step")
-      raw_data = step.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :keyword, :text])
-      expect(raw_data[:type]).to eq(:Step)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      step = clazz.new("* test step")
-      raw_data = step.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :keyword, :text])
-      expect(raw_data[:type]).to eq(:Step)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      step = clazz.new("* test step")
-      raw_data = step.raw_element
-
-      expect(raw_data.keys).to match_array(['keyword', 'name', 'line'])
-      expect(raw_data['keyword']).to eq('* ')
+      expect(step.children).to match_array(everything)
     end
 
 
-    describe '#step_text' do
-
-      let(:source) { "Given a test step with -parameter 1- ^and@ *parameter 2!!\n|a block|" }
-      let(:delimiter) { '-' }
-      let(:step) { s = clazz.new(source)
-      s.delimiter = delimiter
-      s }
-
-
-      it 'can provide different flavors of step\'s text' do
-        step.should respond_to(:step_text)
-      end
-
-      it 'returns different text based on options' do
-        (clazz.instance_method(:step_text).arity != 0).should be_true
-      end
-
-      it 'returns the step\'s text as an Array' do
-        step.step_text.is_a?(Array).should be_true
-      end
-
-      it 'can provide the step\'s text without the arguments' do
-        expected_output = ['Given a test step with -- ^and@ *parameter 2!!']
-
-        step.step_text(:with_arguments => false).should == expected_output
-      end
-
-      it 'can determine its arguments based on delimiters' do
-        expected_output = ['Given a test step with -parameter 1- ^@ *parameter 2!!']
-
-        step.step_text(:with_arguments => false, :left_delimiter => '^', :right_delimiter => '@').should == expected_output
-      end
-
-      it 'can use delimiters of varying lengths' do
-        expected_output = ['Given a test step with -parameter 1- ^and@ *!!']
-
-        step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '!!').should == expected_output
-      end
-
-      it 'can handle delimiters with special regular expression characters' do
-        expected_output = ['Given a test step with -parameter 1- ^and@ *!!']
-
-        step.step_text(:with_arguments => false, :left_delimiter => '*', :right_delimiter => '!!').should == expected_output
-      end
-
-    end
-
-    describe 'step output edge cases' do
+    describe 'step output' do
 
       it 'is a String' do
-        step.to_s.should be_a(String)
+        expect(step.to_s).to be_a(String)
       end
 
 
-      context 'a new step object' do
+      context 'from abstract instantiation' do
 
         let(:step) { clazz.new }
 
@@ -304,8 +113,8 @@ describe 'Step, Unit' do
           expect { step.to_s }.to_not raise_error
         end
 
-        it 'can output a step that has only a base' do
-          step.base = 'step base'
+        it 'can output a step that has only a text' do
+          step.text = 'step text'
 
           expect { step.to_s }.to_not raise_error
         end

data/spec/unit/stepped_unit_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+
+describe 'Stepped, Unit', :unit_test => true do
+
+  let(:nodule) { CukeModeler::Stepped }
+  let(:stepped_model) { Object.new.extend(nodule) }
+
+
+  it 'has steps' do
+    expect(stepped_model).to respond_to(:steps)
+  end
+
+  it 'can change its steps' do
+    expect(stepped_model).to respond_to(:steps=)
+
+    stepped_model.steps = :some_steps
+    expect(stepped_model.steps).to eq(:some_steps)
+    stepped_model.steps = :some_other_steps
+    expect(stepped_model.steps).to eq(:some_other_steps)
+  end
+
+end

data/spec/unit/table_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Table') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Table, Unit' do
+describe 'Table, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Table }
   let(:table) { clazz.new }
@@ -10,116 +9,62 @@ describe 'Table, 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 raw element'
+    it_should_behave_like 'a model'
+    it_should_behave_like 'a parsed model'
+    it_should_behave_like 'a sourced model'
 
   end
 
 
   describe 'unique behavior' do
 
-    it 'can be parsed from stand alone text' do
-      source = '| a table |'
-
-      expect { @element = clazz.new(source) }.to_not raise_error
-
-      # Sanity check in case instantiation failed in a non-explosive manner
-      @element.row_elements.collect { |row| row.cells }.should == [['a table']]
-      # todo - remove once #contents is no longer supported
-      @element.contents.should == [['a table']]
+    it 'has rows' do
+      expect(table).to respond_to(:rows)
     end
 
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = 'bad table text'
+    it 'can change its rows' do
+      expect(table).to respond_to(:rows=)
 
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_table\.feature'/)
+      table.rows = :some_rows
+      expect(table.rows).to eq(:some_rows)
+      table.rows = :some_other_rows
+      expect(table.rows).to eq(:some_other_rows)
     end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      table = clazz.new("| a table |")
-      raw_data = table.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :rows])
-      expect(raw_data[:type]).to eq(:DataTable)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      table = clazz.new("| a table |")
-      raw_data = table.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :rows])
-      expect(raw_data[:type]).to eq(:DataTable)
-    end
 
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      table = clazz.new("| a table |")
-      raw_data = table.raw_element
+    describe 'abstract instantiation' do
 
-      expect(raw_data).to match_array([{"cells" => ["a table"], "line" => 4}])
-    end
+      context 'a new table object' do
 
-    # todo - remove once #contents is no longer supported
-    it 'has contents' do
-      table.should respond_to(:contents)
-    end
+        let(:table) { clazz.new }
 
-    # todo - remove once #contents is no longer supported
-    it 'can change its contents' do
-      expect(table).to respond_to(:contents=)
 
-      table.contents = :some_contents
-      table.contents.should == :some_contents
-      table.contents = :some_other_contents
-      table.contents.should == :some_other_contents
-    end
+        it 'starts with no rows' do
+          expect(table.rows).to eq([])
+        end
 
-    # todo - remove once #contents is no longer supported
-    it 'starts with no contents' do
-      table.contents.should == []
-    end
+      end
 
-    it 'has row elements' do
-      table.should respond_to(:row_elements)
     end
 
-    it 'can get and set its row elements' do
-      expect(table).to respond_to(:row_elements=)
+    it 'contains rows' do
+      rows = [:row_1, :row_2]
+      everything = rows
 
-      table.row_elements = :some_row_elements
-      table.row_elements.should == :some_row_elements
-      table.row_elements = :some_other_row_elements
-      table.row_elements.should == :some_other_row_elements
-    end
+      table.rows = rows
 
-    it 'starts with no row elements' do
-      table.row_elements.should == []
+      expect(table.children).to match_array(everything)
     end
 
-    # todo - remove once #contents is no longer supported
-    it 'stores its contents as a nested array of strings' do
-      source = "| cell 1 | cell 2 |\n| cell 3 | cell 4 |"
-      table = clazz.new(source)
-
-      contents = table.contents
 
-      contents.is_a?(Array).should be_true
-
-      contents.each do |row|
-        row.is_a?(Array).should be_true
-        row.each { |cell| cell.is_a?(String).should be_true }
-      end
-    end
-
-    describe 'table output edge cases' do
+    describe 'table output' do
 
       it 'is a String' do
-        table.to_s.should be_a(String)
+        expect(table.to_s).to be_a(String)
       end
 
 
-      context 'a new table object' do
+      context 'from abstract instantiation' do
 
         let(:table) { clazz.new }
 
@@ -128,13 +73,6 @@ describe 'Table, Unit' do
           expect { table.to_s }.to_not raise_error
         end
 
-        # todo - remove once #contents is no longer supported
-        it 'can output a table that only has contents' do
-          table.contents = ['some contents']
-
-          expect { table.to_s }.to_not raise_error
-        end
-
       end
 
     end