cuke_modeler 0.4.1 → 1.0.0

data/spec/unit/feature_file_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('FeatureFile') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'FeatureFile, Unit' do
+describe 'FeatureFile, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::FeatureFile }
   let(:feature_file) { clazz.new }
@@ -10,90 +9,92 @@ describe 'FeatureFile, Unit' do
 
   describe 'common behavior' do
 
-    it_should_behave_like 'a nested element'
-    it_should_behave_like 'a containing element'
-    it_should_behave_like 'a bare bones element'
-    it_should_behave_like 'a prepopulated element'
+    it_should_behave_like 'a model'
 
   end
 
 
   describe 'unique behavior' do
 
-    it 'provides its own filename when being parsed' do
-      path = "#{@default_file_directory}/#{@default_feature_file_name}"
-      File.open(path, "w") { |file| file.puts 'bad feature text' }
-
-      expect { clazz.new(path) }.to raise_error(/'#{path}'/)
+    it 'has a path' do
+      expect(feature_file).to respond_to(:path)
     end
 
-    it 'knows the name of the file that it is modeling' do
-      path = "#{@default_file_directory}/#{@default_feature_file_name}"
-      File.open(path, "w") { |file| file.puts "Feature:" }
-
-      feature = clazz.new(path)
+    it 'can change its path' do
+      expect(feature_file).to respond_to(:path=)
 
-      feature.name.should == @default_feature_file_name
+      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 'knows the path of the file that it is modeling' do
-      path = "#{@default_file_directory}/#{@default_feature_file_name}"
-      File.open(path, "w") { |file| file.puts "Feature:" }
+    it 'has a feature' do
+      expect(feature_file).to respond_to(:feature)
+    end
 
-      file = clazz.new(path)
+    it 'can change its feature' do
+      expect(feature_file).to respond_to(:feature=)
 
-      file.path.should == path
+      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 features' do
-      feature_file.should respond_to(:features)
+    it 'knows the name of the file that it is modeling' do
+      expect(feature_file).to respond_to(:name)
     end
 
-    it 'can change its features' do
-      expect(feature_file).to respond_to(:features=)
 
-      feature_file.features = :some_features
-      feature_file.features.should == :some_features
-      feature_file.features = :some_other_features
-      feature_file.features.should == :some_other_features
-    end
+    it 'derives its file name from its path' do
+      feature_file.path = 'path/to/foo'
 
-    it 'knows how many features it has' do
-      feature_file.features = [:a_feature]
-      feature_file.feature_count.should == 1
-      feature_file.features = []
-      feature_file.feature_count.should == 0
+      expect(feature_file.name).to eq('foo')
     end
 
-    it 'starts with no features' do
-      feature_file.features.should == []
-    end
 
-    it 'contains features' do
-      features = [:a_feature]
-      everything = features
+    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
 
-      feature_file.features = features
+        it 'starts with no feature' do
+          expect(feature_file.feature).to be_nil
+        end
+
+      end
 
-      feature_file.contains.should =~ everything
     end
 
-    it 'can easily access its sole feature' do
-      feature_file.features = []
-      feature_file.feature.should be_nil
+    it 'contains a feature' do
+      feature = :a_feature
+      everything = [feature]
+
+      feature_file.feature = feature
 
-      feature_file.features = [:a_feature]
-      feature_file.feature.should == :a_feature
+      expect(feature_file.children).to match_array(everything)
     end
 
-    describe 'feature file output edge cases' do
+
+    describe 'feature file output' do
 
       it 'is a String' do
-        feature_file.to_s.should be_a(String)
+        expect(feature_file.to_s).to be_a(String)
       end
 
 
-      context 'a new feature file object' do
+      context 'from abstract instantiation' do
 
         let(:feature_file) { clazz.new }
 

data/spec/unit/feature_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Feature') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Feature, Unit' do
+describe 'Feature, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Feature }
   let(:feature) { clazz.new }
@@ -10,59 +9,18 @@ describe 'Feature, 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 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 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 = 'Feature: test feature'
-
-      expect { @element = clazz.new(source) }.to_not raise_error
-
-      # Sanity check in case instantiation failed in a non-explosive manner
-      @element.name.should == 'test feature'
-    end
-
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = 'bad feature text'
-
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_feature\.feature'/)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      feature = clazz.new('Feature: test feature')
-      raw_data = feature.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :children])
-      expect(raw_data[:type]).to eq(:Feature)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      feature = clazz.new('Feature: test feature')
-      raw_data = feature.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :scenarioDefinitions, :comments])
-      expect(raw_data[:type]).to eq(:Feature)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      feature = clazz.new('Feature: test feature')
-      raw_data = feature.raw_element
-
-      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'uri'])
-      expect(raw_data['keyword']).to eq('Feature')
-    end
-
     it 'will complain about unknown element types' do
       parsed_element = {'description' => '',
                         'elements' => [{'keyword' => 'Scenario', 'description' => ''},
@@ -72,43 +30,36 @@ describe 'Feature, Unit' do
     end
 
     it 'has a background' do
-      feature.should respond_to(:background)
+      expect(feature).to respond_to(:background)
     end
 
     it 'can change its background' do
       expect(feature).to respond_to(:background=)
 
       feature.background = :some_background
-      feature.background.should == :some_background
+      expect(feature.background).to eq(:some_background)
       feature.background = :some_other_background
-      feature.background.should == :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
-      feature.has_background?.should be_true
+      expect(feature).to have_background
       feature.background = nil
-      feature.has_background?.should be_false
+      expect(feature).to_not have_background
     end
 
     it 'has tests' do
-      feature.should respond_to(:tests)
+      expect(feature).to respond_to(:tests)
     end
 
     it 'can change its tests' do
       expect(feature).to respond_to(:tests=)
 
       feature.tests = :some_tests
-      feature.tests.should == :some_tests
+      expect(feature.tests).to eq(:some_tests)
       feature.tests = :some_other_tests
-      feature.tests.should == :some_other_tests
-    end
-
-    it 'knows how many tests it has' do
-      feature.tests = []
-      feature.test_count.should == 0
-      feature.tests = [:test_1, :test_2]
-      feature.test_count.should == 2
+      expect(feature.tests).to eq(:some_other_tests)
     end
 
     it 'can selectively access its scenarios' do
@@ -126,15 +77,17 @@ describe 'Feature, Unit' do
       expect(feature.outlines).to be_empty
     end
 
-    it 'contains backgrounds and tests' do
+    it 'contains a background, tests, and tags' do
+      tags = [:tag_1, :tagt_2]
       tests = [:test_1, :test_2]
       background = :a_background
-      everything = [background] + tests
+      everything = [background] + tests + tags
 
       feature.background = background
       feature.tests = tests
+      feature.tags = tags
 
-      feature.contains.should =~ everything
+      expect(feature.children).to match_array(everything)
     end
 
     it 'contains a background only if one is present' do
@@ -145,25 +98,34 @@ describe 'Feature, Unit' do
       feature.background = background
       feature.tests = tests
 
-      feature.contains.should =~ everything
+      expect(feature.children).to match_array(everything)
     end
 
-    it 'starts with no background' do
-      feature.background.should == nil
-    end
 
-    it 'starts with no tests' do
-      feature.tests.should == []
+    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 edge cases' do
+
+    describe 'feature output' do
 
       it 'is a String' do
-        feature.to_s.should be_a(String)
+        expect(feature.to_s).to be_a(String)
       end
 
 
-      context 'a new feature object' do
+      context 'from abstract instantiation' do
 
         let(:feature) { clazz.new }
 
@@ -179,13 +141,7 @@ describe 'Feature, Unit' do
         end
 
         it 'can output a feature that has only a description' do
-          feature.description_text = 'a description'
-
-          expect { feature.to_s }.to_not raise_error
-        end
-
-        it 'can output a feature that has only tags' do
-          feature.tags = ['a tag']
+          feature.description = 'a description'
 
           expect { feature.to_s }.to_not raise_error
         end

data/spec/unit/model_unit_spec.rb

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

data/spec/unit/named_unit_spec.rb

@@ -0,0 +1,23 @@
+require '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/spec/unit/nested_unit_spec.rb

@@ -1,38 +1,41 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Nested') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Nested, Unit' do
+describe 'Nested, Unit', :unit_test => true do
 
   let(:nodule) { CukeModeler::Nested }
-  let(:nested_element) { Object.new.extend(nodule) }
+  let(:nested_model) { Object.new.extend(nodule) }
 
 
   describe 'unique behavior' do
 
-    it 'has a parent element' do
-      nested_element.should respond_to(:parent_element)
-    end
+    describe 'an object including the module' do
 
-    it 'can change its parent element' do
-      expect(nested_element).to respond_to(:parent_element=)
+      it 'has a parent model' do
+        expect(nested_model).to respond_to(:parent_model)
+      end
 
-      nested_element.parent_element = :some_parent_element
-      nested_element.parent_element.should == :some_parent_element
-      nested_element.parent_element = :some_other_parent_element
-      nested_element.parent_element.should == :some_other_parent_element
-    end
+      it 'can change its parent model' do
+        expect(nested_model).to respond_to(:parent_model=)
 
-    it 'has access to its ancestors' do
-      nested_element.should respond_to(:get_ancestor)
-    end
+        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 'gets an ancestor based on type' do
-      (nodule.instance_method(:get_ancestor).arity == 1).should be_true
-    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
 
-    it 'raises and exception if an unknown ancestor type is requested' do
-      expect { nested_element.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
     end
 
   end