cuke_modeler 1.4.0 → 3.0.0

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

@@ -1,100 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'DocString, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::DocString }
-  let(:doc_string) { 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 a content type' do
-      expect(doc_string).to respond_to(:content_type)
-    end
-
-    it 'can change its content type' do
-      expect(doc_string).to respond_to(:content_type=)
-
-      doc_string.content_type = :some_content_type
-      expect(doc_string.content_type).to eq(:some_content_type)
-      doc_string.content_type = :some_other_content_type
-      expect(doc_string.content_type).to eq(:some_other_content_type)
-    end
-
-    it 'has content' do
-      expect(doc_string).to respond_to(:content)
-    end
-
-    it 'can change its content' do
-      expect(doc_string).to respond_to(:content=)
-
-      doc_string.content = :some_content
-      expect(doc_string.content).to eq(:some_content)
-      doc_string.content = :some_other_content
-      expect(doc_string.content).to eq(:some_other_content)
-    end
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new doc string object' do
-
-        let(:doc_string) { clazz.new }
-
-
-        it 'starts with no content type' do
-          expect(doc_string.content_type).to be_nil
-        end
-
-        it 'starts with no content' do
-          expect(doc_string.content).to be_nil
-        end
-
-      end
-
-    end
-
-
-    describe 'doc string output' do
-
-      context 'from abstract instantiation' do
-
-        context 'a new doc string object' do
-
-          let(:doc_string) { clazz.new }
-
-
-          it 'can output an empty doc string' do
-            expect { doc_string.to_s }.to_not raise_error
-          end
-
-          it 'can output a doc string that has only a content type' do
-            doc_string.content_type = 'some type'
-
-            expect { doc_string.to_s }.to_not raise_error
-          end
-
-          it 'can output a doc string that has only content' do
-            doc_string.content = 'foo'
-
-            expect { doc_string.to_s }.to_not raise_error
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,133 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper"
-
-
-describe 'Example, Unit', :unit_test => true do
-
-  let(:clazz) { CukeModeler::Example }
-  let(:example) { 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 'has rows' do
-      expect(example).to respond_to(:rows)
-    end
-
-    it 'can change its rows' do
-      expect(example).to respond_to(:rows=)
-
-      example.rows = :some_rows
-      expect(example.rows).to eq(:some_rows)
-      example.rows = :some_other_rows
-      expect(example.rows).to eq(:some_other_rows)
-    end
-
-    it 'can selectively access its parameter row' do
-      expect(example).to respond_to(:parameter_row)
-    end
-
-    it 'can selectively access its argument rows' do
-      expect(example).to respond_to(:argument_rows)
-    end
-
-    it 'can determine its parameters' do
-      expect(example).to respond_to(:parameters)
-    end
-
-
-    describe 'abstract instantiation' do
-
-      context 'a new example object' do
-
-        let(:example) { clazz.new }
-
-
-        it 'starts with no rows' do
-          expect(example.rows).to eq([])
-        end
-
-        it 'starts with no argument rows' do
-          expect(example.argument_rows).to eq([])
-        end
-
-        it 'starts with no parameter row' do
-          expect(example.parameter_row).to be_nil
-        end
-
-        it 'starts with no parameters' do
-          expect(example.parameters).to eq([])
-        end
-
-      end
-
-    end
-
-
-    it 'can add a new example row' do
-      expect(clazz.new).to respond_to(:add_row)
-    end
-
-    it 'can remove an existing example row' do
-      expect(clazz.new).to respond_to(:remove_row)
-    end
-
-    it 'contains rows and tags' do
-      tags = [:tag_1, :tag_2]
-      rows = [:row_1, :row_2]
-      everything = rows + tags
-
-      example.rows = rows
-      example.tags = tags
-
-      expect(example.children).to match_array(everything)
-    end
-
-
-    describe 'example output' do
-
-      context 'from abstract instantiation' do
-
-        let(:example) { clazz.new }
-
-
-        it 'can output an empty example' do
-          expect { example.to_s }.to_not raise_error
-        end
-
-        it 'can output an example that has only a keyword' do
-          example.keyword = 'foo'
-
-          expect(example.to_s).to eq('foo:')
-        end
-
-        it 'can output an example that has only a name' do
-          example.name = 'a name'
-
-          expect { example.to_s }.to_not raise_error
-        end
-
-        it 'can output an example that has only a description' do
-          example.description = 'a description'
-
-          expect { example.to_s }.to_not raise_error
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/testing/rspec/spec/unit/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/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