cuke_modeler 2.1.0 → 3.4.0

data/testing/rspec/spec/unit/models/scenario_unit_spec.rb

@@ -1,86 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Scenario, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Scenario }
-  let(:scenario) { clazz.new }
-
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a model'
-    it_should_behave_like 'a keyworded 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 'contains steps and tags' do
-      tags = [:tag_1, :tag_2]
-      steps = [:step_1, :step_2]
-      everything = steps + tags
-
-      scenario.steps = steps
-      scenario.tags = tags
-
-      expect(scenario.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 { scenario == thing }.to_not raise_error
-          expect(scenario == thing).to be false
-        end
-      end
-
-    end
-
-
-    describe 'scenario output' do
-
-      context 'from abstract instantiation' do
-
-        let(:scenario) { clazz.new }
-
-
-        it 'can output an empty scenario' do
-          expect { scenario.to_s }.to_not raise_error
-        end
-
-        it 'can output a scenario that has only a keyword' do
-          scenario.keyword = 'foo'
-
-          expect(scenario.to_s).to eq('foo:')
-        end
-
-        it 'can output a scenario that has only a name' do
-          scenario.name = 'a name'
-
-          expect { scenario.to_s }.to_not raise_error
-        end
-
-        it 'can output a scenario that has only a description' do
-          scenario.description = 'a description'
-
-          expect { scenario.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/unit/models/step_unit_spec.rb

@@ -1,109 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Step, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Step }
-  let(:step) { clazz.new }
-
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a model'
-    it_should_behave_like 'a keyworded model'
-    it_should_behave_like 'a sourced model'
-    it_should_behave_like 'a parsed model'
-
-  end
-
-
-  describe 'unique behavior' do
-
-    it 'has text' do
-      expect(step).to respond_to(:text)
-    end
-
-    it 'can change its text' do
-      expect(step).to respond_to(:text=)
-
-      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
-      expect(step).to respond_to(:block)
-    end
-
-    it 'can change its block' do
-      expect(step).to respond_to(:block=)
-
-      step.block = :some_block
-      expect(step.block).to eq(:some_block)
-      step.block = :some_other_block
-      expect(step.block).to eq(:some_other_block)
-    end
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new step object' do
-
-        let(:step) { clazz.new }
-
-
-        it 'starts with no text' do
-          expect(step.text).to be_nil
-        end
-
-        it 'starts with no block' do
-          expect(step.block).to be_nil
-        end
-
-      end
-
-    end
-
-    it 'contains some kind of block' do
-      block = :block
-      everything = [block]
-
-      step.block = block
-
-      expect(step.children).to match_array(everything)
-    end
-
-
-    describe 'step output' do
-
-      context 'from abstract instantiation' do
-
-        let(:step) { clazz.new }
-
-
-        it 'can output an empty step' do
-          expect { step.to_s }.to_not raise_error
-        end
-
-        it 'can output a step that has only a text' do
-          step.text = 'step text'
-
-          expect { step.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-    it 'can gracefully be compared to other types of objects' do
-      # Some common types of object
-      [1, 'foo', :bar, [], {}, nil].each do |thing|
-        expect { step == thing }.to_not raise_error
-        expect(step == thing).to be false
-      end
-    end
-
-  end
-
-end

data/testing/rspec/spec/unit/models/table_unit_spec.rb

@@ -1,77 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Table, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Table }
-  let(:table) { clazz.new }
-
-
-  describe 'common behavior' do
-
-    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 'has rows' do
-      expect(table).to respond_to(:rows)
-    end
-
-    it 'can change its rows' do
-      expect(table).to respond_to(:rows=)
-
-      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
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new table object' do
-
-        let(:table) { clazz.new }
-
-
-        it 'starts with no rows' do
-          expect(table.rows).to eq([])
-        end
-
-      end
-
-    end
-
-    it 'contains rows' do
-      rows = [:row_1, :row_2]
-      everything = rows
-
-      table.rows = rows
-
-      expect(table.children).to match_array(everything)
-    end
-
-
-    describe 'table output' do
-
-      context 'from abstract instantiation' do
-
-        let(:table) { clazz.new }
-
-
-        it 'can output an empty table' do
-          expect { table.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/unit/models/tag_unit_spec.rb

@@ -1,68 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Tag, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Tag }
-  let(:model) { clazz.new }
-
-
-  describe 'common behavior' do
-
-    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 a name' do
-      expect(model).to respond_to(:name)
-    end
-
-    it 'can change its name' do
-      expect(model).to respond_to(:name=)
-
-      model.name = :some_name
-      expect(model.name).to eq(:some_name)
-      model.name = :some_other_name
-      expect(model.name).to eq(:some_other_name)
-    end
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new tag object' do
-
-        let(:tag) { clazz.new }
-
-
-        it 'starts with no name' do
-          expect(tag.name).to be_nil
-        end
-
-      end
-
-    end
-
-  end
-
-
-  describe 'tag output' do
-
-    context 'from abstract instantiation' do
-
-      let(:tag) { clazz.new }
-
-
-      it 'can output an empty tag' do
-        expect { tag.to_s }.to_not raise_error
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/unit/named_unit_spec.rb

@@ -1,23 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Named, Unit', :unit_test => true do
-
-  let(:nodule) { CukeModeler::Named }
-  let(:named_model) { Object.new.extend(nodule) }
-
-
-  it 'has a name' do
-    expect(named_model).to respond_to(:name)
-  end
-
-  it 'can change its name' do
-    expect(named_model).to respond_to(:name=)
-
-    named_model.name = :some_name
-    expect(named_model.name).to eq(:some_name)
-    named_model.name = :some_other_name
-    expect(named_model.name).to eq(:some_other_name)
-  end
-
-end

data/testing/rspec/spec/unit/nested_unit_spec.rb

@@ -1,43 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Nested, Unit', :unit_test => true do
-
-  let(:nodule) { CukeModeler::Nested }
-  let(:nested_model) { Object.new.extend(nodule) }
-
-
-  describe 'unique behavior' do
-
-    describe 'an object including the module' do
-
-      it 'has a parent model' do
-        expect(nested_model).to respond_to(:parent_model)
-      end
-
-      it 'can change its parent model' do
-        expect(nested_model).to respond_to(:parent_model=)
-
-        nested_model.parent_model = :some_parent_model
-        expect(nested_model.parent_model).to eq(:some_parent_model)
-        nested_model.parent_model = :some_other_parent_model
-        expect(nested_model.parent_model).to eq(:some_other_parent_model)
-      end
-
-      it 'has access to its ancestors' do
-        expect(nested_model).to respond_to(:get_ancestor)
-      end
-
-      it 'gets an ancestor based on type' do
-        expect(nodule.instance_method(:get_ancestor).arity).to eq(1)
-      end
-
-      it 'raises and exception if an unknown ancestor type is requested' do
-        expect { nested_model.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/unit/parsed_unit_spec.rb

@@ -1,27 +0,0 @@
-require "#{File.dirname(__FILE__)}/../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/testing/rspec/spec/unit/parsing_unit_spec.rb

@@ -1,54 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Parsing, Unit', :unit_test => true do
-
-  let(:nodule) { CukeModeler::Parsing }
-
-
-  before(:all) do
-    @original_dialect = CukeModeler::Parsing.dialect
-  end
-
-  # Making sure that our changes don't escape a test and ruin the rest of the suite
-  after(:all) do
-    CukeModeler::Parsing.dialect = @original_dialect
-  end
-
-
-  describe 'unique behavior' do
-
-    it 'can parse text' do
-      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 'knows all of the available Gherkin dialects' do
-      expect(nodule).to respond_to(:dialects)
-    end
-
-    it 'has an expected dialect to use for parsing' do
-      expect(nodule).to respond_to(:dialect)
-    end
-
-    it 'can change its expected dialect' do
-      expect(nodule).to respond_to(:dialect=)
-
-      nodule.dialect = :some_dialect
-      expect(nodule.dialect).to eq(:some_dialect)
-      nodule.dialect = :some_other_dialect
-      expect(nodule.dialect).to eq(:some_other_dialect)
-    end
-
-    it 'defaults to English if no dialect is set' do
-      nodule.dialect = nil
-
-      expect(nodule.dialect).to eq('en')
-    end
-
-  end
-
-end