cuke_modeler 2.1.0 → 3.0.0

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

@@ -1,125 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'FeatureFile, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::FeatureFile }
-  let(:feature_file) { clazz.new }
-
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a model'
-    it_should_behave_like 'a parsed model'
-
-  end
-
-
-  describe 'unique behavior' do
-
-    it 'has a path' do
-      expect(feature_file).to respond_to(:path)
-    end
-
-    it 'can change its path' do
-      expect(feature_file).to respond_to(:path=)
-
-      feature_file.path = :some_path
-      expect(feature_file.path).to eq(:some_path)
-      feature_file.path = :some_other_path
-      expect(feature_file.path).to eq(:some_other_path)
-    end
-
-    it 'has a feature' do
-      expect(feature_file).to respond_to(:feature)
-    end
-
-    it 'can change its feature' do
-      expect(feature_file).to respond_to(:feature=)
-
-      feature_file.feature = :some_features
-      expect(feature_file.feature).to eq(:some_features)
-      feature_file.feature = :some_other_features
-      expect(feature_file.feature).to eq(:some_other_features)
-    end
-
-    it 'has comments' do
-      expect(feature_file).to respond_to(:comments)
-    end
-
-    it 'can change its comments' do
-      expect(feature_file).to respond_to(:comments=)
-
-      feature_file.comments = :some_comments
-      expect(feature_file.comments).to eq(:some_comments)
-      feature_file.comments = :some_other_comments
-      expect(feature_file.comments).to eq(:some_other_comments)
-    end
-
-    it 'knows the name of the file that it is modeling' do
-      expect(feature_file).to respond_to(:name)
-    end
-
-
-    it 'derives its file name from its path' do
-      feature_file.path = 'path/to/foo'
-
-      expect(feature_file.name).to eq('foo')
-    end
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new feature file object' do
-
-        let(:feature_file) { clazz.new }
-
-
-        it 'starts with no path' do
-          expect(feature_file.path).to be_nil
-        end
-
-        it 'starts with no name' do
-          expect(feature_file.name).to be_nil
-        end
-
-        it 'starts with no feature' do
-          expect(feature_file.feature).to be_nil
-        end
-
-        it 'starts with no comments' do
-          expect(feature_file.comments).to eq([])
-        end
-
-      end
-
-    end
-
-    it 'contains a feature' do
-      feature = :a_feature
-      everything = [feature]
-
-      feature_file.feature = feature
-
-      expect(feature_file.children).to match_array(everything)
-    end
-
-
-    describe 'feature file output' do
-
-      context 'from abstract instantiation' do
-
-        let(:feature_file) { clazz.new }
-
-
-        it 'can output an empty feature file' do
-          expect { feature_file.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,157 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Feature, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Feature }
-  let(:feature) { 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 tagged model'
-    it_should_behave_like 'a sourced model'
-    it_should_behave_like 'a parsed model'
-
-  end
-
-
-  describe 'unique behavior' do
-
-    it 'will complain about unknown element types' do
-      parsed_element = {'description' => '',
-                        'elements' => [{'keyword' => 'Scenario', 'description' => ''},
-                                       {'keyword' => 'New Type', 'description' => ''}]}
-
-      expect { clazz.new(parsed_element) }.to raise_error(ArgumentError)
-    end
-
-    it 'has a background' do
-      expect(feature).to respond_to(:background)
-    end
-
-    it 'can change its background' do
-      expect(feature).to respond_to(:background=)
-
-      feature.background = :some_background
-      expect(feature.background).to eq(:some_background)
-      feature.background = :some_other_background
-      expect(feature.background).to eq(:some_other_background)
-    end
-
-    it 'knows whether or not it presently has a background - has_background?' do
-      feature.background = :a_background
-      expect(feature).to have_background
-      feature.background = nil
-      expect(feature).to_not have_background
-    end
-
-    it 'has tests' do
-      expect(feature).to respond_to(:tests)
-    end
-
-    it 'can change its tests' do
-      expect(feature).to respond_to(:tests=)
-
-      feature.tests = :some_tests
-      expect(feature.tests).to eq(:some_tests)
-      feature.tests = :some_other_tests
-      expect(feature.tests).to eq(:some_other_tests)
-    end
-
-    it 'can selectively access its scenarios' do
-      expect(feature).to respond_to(:scenarios)
-    end
-
-    it 'can selectively access its outlines' do
-      expect(feature).to respond_to(:outlines)
-    end
-
-    it 'finds no scenarios or outlines when it has no tests' do
-      feature.tests = []
-
-      expect(feature.scenarios).to be_empty
-      expect(feature.outlines).to be_empty
-    end
-
-    it 'contains a background, tests, and tags' do
-      tags = [:tag_1, :tagt_2]
-      tests = [:test_1, :test_2]
-      background = :a_background
-      everything = [background] + tests + tags
-
-      feature.background = background
-      feature.tests = tests
-      feature.tags = tags
-
-      expect(feature.children).to match_array(everything)
-    end
-
-    it 'contains a background only if one is present' do
-      tests = [:test_1, :test_2]
-      background = nil
-      everything = tests
-
-      feature.background = background
-      feature.tests = tests
-
-      expect(feature.children).to match_array(everything)
-    end
-
-
-    context 'from abstract instantiation' do
-
-      let(:feature) { clazz.new }
-
-
-      it 'starts with no background' do
-        expect(feature.background).to be_nil
-      end
-
-      it 'starts with no tests' do
-        expect(feature.tests).to eq([])
-      end
-
-    end
-
-
-    describe 'feature output' do
-
-      context 'from abstract instantiation' do
-
-        let(:feature) { clazz.new }
-
-
-        it 'can output an empty feature' do
-          expect { feature.to_s }.to_not raise_error
-        end
-
-        it 'can output a feature that has only a keyword' do
-          feature.keyword = 'foo'
-
-          expect(feature.to_s).to eq('foo:')
-        end
-
-        it 'can output a feature that has only a name' do
-          feature.name = 'a name'
-
-          expect { feature.to_s }.to_not raise_error
-        end
-
-        it 'can output a feature that has only a description' do
-          feature.description = 'a description'
-
-          expect { feature.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,15 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Model, Unit' do
-
-  let(:clazz) { CukeModeler::Model }
-
-
-  describe 'common behavior' do
-
-    it_should_behave_like 'a model'
-
-  end
-
-end

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

@@ -1,117 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-
-describe 'Outline, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Outline }
-  let(:outline) { 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 'has examples' do
-      expect(outline).to respond_to(:examples)
-    end
-
-    it 'can change its examples' do
-      expect(outline).to respond_to(:examples=)
-
-      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
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new outline object' do
-
-        let(:outline) { clazz.new }
-
-
-        it 'starts with no examples' do
-          expect(outline.examples).to eq([])
-        end
-
-      end
-
-    end
-
-    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 + 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
-
-    end
-
-
-    describe 'outline output' do
-
-      context 'from abstract instantiation' do
-
-        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 keyword' do
-          outline.keyword = 'foo'
-
-          expect(outline.to_s).to eq('foo:')
-        end
-
-        it 'can output an outline that has only a name' do
-          outline.name = 'a name'
-
-          expect { outline.to_s }.to_not raise_error
-        end
-
-        it 'can output an outline that has only a description' do
-          outline.description = 'a description'
-
-          expect { outline.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

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