cuke_modeler 0.3.0 → 0.4.0

data/spec/unit/feature_element_unit_spec.rb

@@ -5,15 +5,15 @@ SimpleCov.command_name('FeatureElement') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'FeatureElement, Unit' do
 
   let(:clazz) { CukeModeler::FeatureElement }
+  let(:element) { clazz.new }
 
-  it_should_behave_like 'a feature element'
-  it_should_behave_like 'a nested element'
-  it_should_behave_like 'a prepopulated element'
-  it_should_behave_like 'a bare bones element'
+  describe 'common behavior' do
 
+    it_should_behave_like 'a feature element'
+    it_should_behave_like 'a nested element'
+    it_should_behave_like 'a prepopulated element'
+    it_should_behave_like 'a bare bones element'
 
-  before(:each) do
-    @element = clazz.new
   end
 
 end

data/spec/unit/feature_element_unit_specs.rb

@@ -4,45 +4,49 @@ shared_examples_for 'a feature element' do
 
   # clazz must be defined by the calling file
 
-  before(:each) do
-    @element = clazz.new
-  end
+  let(:element) { clazz.new }
+
 
-  it 'has a name - #name' do
-    @element.should respond_to(:name)
+  it 'has a name' do
+    element.should respond_to(:name)
   end
 
-  it 'can get and set its name - #name, #name=' do
-    @element.name = :some_name
-    @element.name.should == :some_name
-    @element.name = :some_other_name
-    @element.name.should == :some_other_name
+  it 'can change its name' do
+    expect(element).to respond_to(:name=)
+
+    element.name = :some_name
+    element.name.should == :some_name
+    element.name = :some_other_name
+    element.name.should == :some_other_name
   end
 
   it 'has a description' do
-    @element.should respond_to(:description)
-    @element.should respond_to(:description_text)
+    element.should respond_to(:description)
+    element.should respond_to(:description_text)
   end
 
   it 'can get and set its description' do
-    @element.description = :some_description
-    @element.description.should == :some_description
-    @element.description = :some_other_description
-    @element.description.should == :some_other_description
-
-    @element.description_text = :some_description
-    @element.description_text.should == :some_description
-    @element.description_text = :some_other_description
-    @element.description_text.should == :some_other_description
+    expect(element).to respond_to(:description=)
+    expect(element).to respond_to(:description_text=)
+
+    element.description = :some_description
+    element.description.should == :some_description
+    element.description = :some_other_description
+    element.description.should == :some_other_description
+
+    element.description_text = :some_description
+    element.description_text.should == :some_description
+    element.description_text = :some_other_description
+    element.description_text.should == :some_other_description
   end
 
   it 'starts with no name' do
-    @element.name.should == ''
+    element.name.should == ''
   end
 
   it 'starts with no description' do
-    @element.description.should == []
-    @element.description_text.should == ''
+    element.description.should == []
+    element.description_text.should == ''
   end
 
 end

data/spec/unit/feature_file_unit_spec.rb

@@ -5,95 +5,105 @@ SimpleCov.command_name('FeatureFile') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'FeatureFile, Unit' do
 
   let(:clazz) { CukeModeler::FeatureFile }
+  let(:feature_file) { clazz.new }
 
-  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'
 
+  describe 'common behavior' do
 
-  before(:each) do
-    @feature_file = clazz.new
-  end
-
-  it 'cannot model a non-existent file' do
-    path = "#{@default_file_directory}/missing_file.txt"
+    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'
 
-    expect { CukeModeler::FeatureFile.new(path) }.to raise_error(ArgumentError)
   end
 
-  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}'/)
-  end
+  describe 'unique behavior' do
 
-  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:" }
+    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' }
 
-    feature = CukeModeler::FeatureFile.new(path)
+      expect { clazz.new(path) }.to raise_error(/'#{path}'/)
+    end
 
-    feature.name.should == @default_feature_file_name
-  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:" }
 
-  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:" }
+      feature = clazz.new(path)
 
-    file = CukeModeler::FeatureFile.new(path)
+      feature.name.should == @default_feature_file_name
+    end
 
-    file.path.should == 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 features - #features' do
-    @feature_file.should respond_to(:features)
-  end
+      file = clazz.new(path)
 
-  it 'can get and set its features - #features, #features=' do
-    @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
+      file.path.should == path
+    end
 
-  it 'knows how many features it has - #feature_count' do
-    @feature_file.features = [:a_feature]
-    @feature_file.feature_count.should == 1
-    @feature_file.features = []
-    @feature_file.feature_count.should == 0
-  end
+    it 'has features' do
+      feature_file.should respond_to(:features)
+    end
 
-  it 'starts with no features' do
-    @feature_file.features.should == []
-  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 'contains features' do
-    features = [:a_feature]
-    everything = features
+    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
+    end
 
-    @feature_file.features = features
+    it 'starts with no features' do
+      feature_file.features.should == []
+    end
 
-    @feature_file.contains.should =~ everything
-  end
+    it 'contains features' do
+      features = [:a_feature]
+      everything = features
 
-  it 'can easily access its sole feature' do
-    @feature_file.features = []
-    @feature_file.feature.should be_nil
+      feature_file.features = features
 
-    @feature_file.features = [:a_feature]
-    @feature_file.feature.should == :a_feature
-  end
+      feature_file.contains.should =~ everything
+    end
 
-  context 'feature file output edge cases' do
+    it 'can easily access its sole feature' do
+      feature_file.features = []
+      feature_file.feature.should be_nil
 
-    it 'is a String' do
-      @feature_file.to_s.should be_a(String)
+      feature_file.features = [:a_feature]
+      feature_file.feature.should == :a_feature
     end
 
-    it 'can output an empty feature file' do
-      expect { @feature_file.to_s }.to_not raise_error
+    describe 'feature file output edge cases' do
+
+      it 'is a String' do
+        feature_file.to_s.should be_a(String)
+      end
+
+
+      context 'a new feature file object' 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

data/spec/unit/feature_unit_spec.rb

@@ -5,159 +5,193 @@ SimpleCov.command_name('Feature') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'Feature, Unit' do
 
   let(:clazz) { CukeModeler::Feature }
+  let(:feature) { clazz.new }
 
-  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'
-
-  before(:each) do
-    @feature = clazz.new
-  end
 
-  it 'can be parsed from stand alone text' do
-    source = 'Feature: test feature'
+  describe 'common behavior' do
 
-    expect { @element = clazz.new(source) }.to_not raise_error
+    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'
 
-    # 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
+  describe 'unique behavior' do
 
-  it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-    feature = clazz.new('Feature: test feature')
-    raw_data = feature.raw_element
+    it 'can be parsed from stand alone text' do
+      source = 'Feature: test feature'
 
-    expect(raw_data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :children])
-    expect(raw_data[:type]).to eq(:Feature)
-  end
+      expect { @element = clazz.new(source) }.to_not raise_error
 
-  it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-    feature = clazz.new('Feature: test feature')
-    raw_data = feature.raw_element
+      # Sanity check in case instantiation failed in a non-explosive manner
+      @element.name.should == 'test feature'
+    end
 
-    expect(raw_data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :scenarioDefinitions, :comments])
-    expect(raw_data[:type]).to eq(:Feature)
-  end
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = 'bad feature text'
 
-  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 { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_feature\.feature'/)
+    end
 
-    expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'uri'])
-    expect(raw_data['keyword']).to eq('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
 
-  it 'will complain about unknown element types' do
-    parsed_element = {'description' => '',
-                      'elements' => [{'keyword' => 'Scenario', 'description' => ''},
-                                     {'keyword' => 'New Type', 'description' => ''}]}
+      expect(raw_data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :children])
+      expect(raw_data[:type]).to eq(:Feature)
+    end
 
-    expect { clazz.new(parsed_element) }.to raise_error(ArgumentError)
-  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
 
-  it 'has a background - #background' do
-    @feature.should respond_to(:background)
-  end
+      expect(raw_data.keys).to match_array([:type, :tags, :location, :language, :keyword, :name, :scenarioDefinitions, :comments])
+      expect(raw_data[:type]).to eq(:Feature)
+    end
 
-  it 'can get and set its background - #background, #background=' do
-    @feature.background = :some_background
-    @feature.background.should == :some_background
-    @feature.background = :some_other_background
-    @feature.background.should == :some_other_background
-  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
 
-  it 'knows whether or not it presently has a background - has_background?' do
-    @feature.background = :a_background
-    @feature.has_background?.should be_true
-    @feature.background = nil
-    @feature.has_background?.should be_false
-  end
+      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'uri'])
+      expect(raw_data['keyword']).to eq('Feature')
+    end
 
-  it 'has tests - #tests' do
-    @feature.should respond_to(:tests)
-  end
+    it 'will complain about unknown element types' do
+      parsed_element = {'description' => '',
+                        'elements' => [{'keyword' => 'Scenario', 'description' => ''},
+                                       {'keyword' => 'New Type', 'description' => ''}]}
 
-  it 'can get and set its tests - #tests, #tests=' do
-    @feature.tests = :some_tests
-    @feature.tests.should == :some_tests
-    @feature.tests = :some_other_tests
-    @feature.tests.should == :some_other_tests
-  end
+      expect { clazz.new(parsed_element) }.to raise_error(ArgumentError)
+    end
 
-  it 'knows how many tests it has - #test_count' do
-    @feature.tests = []
-    @feature.test_count.should == 0
-    @feature.tests = [:test_1, :test_2]
-    @feature.test_count.should == 2
-  end
+    it 'has a background' do
+      feature.should respond_to(:background)
+    end
 
-  it 'contains backgrounds and tests' do
-    tests = [:test_1, :test_2]
-    background = :a_background
-    everything = [background] + tests
+    it 'can change its background' do
+      expect(feature).to respond_to(:background=)
 
-    @feature.background = background
-    @feature.tests = tests
+      feature.background = :some_background
+      feature.background.should == :some_background
+      feature.background = :some_other_background
+      feature.background.should == :some_other_background
+    end
 
-    @feature.contains.should =~ everything
-  end
+    it 'knows whether or not it presently has a background - has_background?' do
+      feature.background = :a_background
+      feature.has_background?.should be_true
+      feature.background = nil
+      feature.has_background?.should be_false
+    end
 
-  it 'contains a background only if one is present' do
-    tests = [:test_1, :test_2]
-    background = nil
-    everything = tests
+    it 'has tests' do
+      feature.should respond_to(:tests)
+    end
 
-    @feature.background = background
-    @feature.tests = tests
+    it 'can change its tests' do
+      expect(feature).to respond_to(:tests=)
 
-    @feature.contains.should =~ everything
-  end
+      feature.tests = :some_tests
+      feature.tests.should == :some_tests
+      feature.tests = :some_other_tests
+      feature.tests.should == :some_other_tests
+    end
 
-  it 'starts with no background' do
-    @feature.background.should == nil
-  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
+    end
 
-  it 'starts with no tests' do
-    @feature.tests.should == []
-  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
 
-  context 'feature output edge cases' do
+    it 'finds no scenarios or outlines when it has no tests' do
+      feature.tests = []
 
-    it 'is a String' do
-      @feature.to_s.should be_a(String)
+      expect(feature.scenarios).to be_empty
+      expect(feature.outlines).to be_empty
     end
 
-    it 'can output an empty feature' do
-      expect { @feature.to_s }.to_not raise_error
+    it 'contains backgrounds and tests' do
+      tests = [:test_1, :test_2]
+      background = :a_background
+      everything = [background] + tests
+
+      feature.background = background
+      feature.tests = tests
+
+      feature.contains.should =~ everything
     end
 
-    it 'can output a feature that has only a name' do
-      @feature.name = 'a name'
+    it 'contains a background only if one is present' do
+      tests = [:test_1, :test_2]
+      background = nil
+      everything = tests
 
-      expect { @feature.to_s }.to_not raise_error
+      feature.background = background
+      feature.tests = tests
+
+      feature.contains.should =~ everything
     end
 
-    it 'can output a feature that has only a description' do
-      @feature.description_text = 'a description'
+    it 'starts with no background' do
+      feature.background.should == nil
+    end
 
-      expect { @feature.to_s }.to_not raise_error
+    it 'starts with no tests' do
+      feature.tests.should == []
     end
 
-    it 'can output a feature that has only a tags' do
-      @feature.tags = ['a tag']
+    describe 'feature output edge cases' do
+
+      it 'is a String' do
+        feature.to_s.should be_a(String)
+      end
+
+
+      context 'a new feature object' 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 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_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']
+
+          expect { feature.to_s }.to_not raise_error
+        end
+
+      end
 
-      expect { @feature.to_s }.to_not raise_error
     end
 
   end