cuke_modeler 0.4.1 → 1.0.0

data/spec/spec_helper.rb

@@ -1,31 +1,41 @@
-require 'simplecov' unless RUBY_VERSION.to_s < '1.9.0'
+unless RUBY_VERSION.to_s < '1.9.0'
+  require 'simplecov'
+  SimpleCov.command_name('rspec_tests')
+end
 
 
 this_dir = File.dirname(__FILE__)
 
 require "#{this_dir}/../lib/cuke_modeler"
 
-require "#{this_dir}/unit/feature_element_unit_specs"
-require "#{this_dir}/unit/nested_element_unit_specs"
-require "#{this_dir}/unit/tagged_element_unit_specs"
-require "#{this_dir}/unit/containing_element_unit_specs"
-require "#{this_dir}/unit/bare_bones_unit_specs"
-require "#{this_dir}/unit/test_element_unit_specs"
-require "#{this_dir}/unit/prepopulated_unit_specs"
-require "#{this_dir}/unit/sourced_element_unit_specs"
-require "#{this_dir}/unit/raw_element_unit_specs"
+require "#{this_dir}/unit/shared/models_unit_specs"
+require "#{this_dir}/integration/shared/models_integration_specs"
+require "#{this_dir}/unit/shared/named_models_unit_specs"
+require "#{this_dir}/unit/shared/described_models_unit_specs"
+require "#{this_dir}/unit/shared/stepped_models_unit_specs"
+require "#{this_dir}/unit/shared/stringifiable_models_unit_specs"
+require "#{this_dir}/unit/shared/nested_models_unit_specs"
+require "#{this_dir}/unit/shared/tagged_models_unit_specs"
+require "#{this_dir}/unit/shared/containing_models_unit_specs"
+require "#{this_dir}/unit/shared/bare_bones_models_unit_specs"
+require "#{this_dir}/unit/shared/prepopulated_models_unit_specs"
+require "#{this_dir}/unit/shared/sourced_models_unit_specs"
+require "#{this_dir}/unit/shared/parsed_models_unit_specs"
 
 
 RSpec.configure do |config|
   case
     when Gem.loaded_specs['gherkin'].version.version[/^4/]
       config.filter_run_excluding :gherkin2 => true,
-                                  :gherkin3 => true
+                                  :gherkin3 => true,
+                                  :gherkin4 => false
     when Gem.loaded_specs['gherkin'].version.version[/^3/]
       config.filter_run_excluding :gherkin2 => true,
+                                  :gherkin3 => false,
                                   :gherkin4 => true
     else
-      config.filter_run_excluding :gherkin3 => true,
+      config.filter_run_excluding :gherkin2 => false,
+                                  :gherkin3 => true,
                                   :gherkin4 => true
   end
 
@@ -34,14 +44,18 @@ RSpec.configure do |config|
     @default_feature_file_name = 'test_feature.feature'
   end
 
-  config.before(:each) do
-    FileUtils.remove_dir(@default_file_directory, true) if File.exists?(@default_file_directory)
+  config.before(:each) do |spec|
+    unless spec.metadata[:unit_test]
+      FileUtils.remove_dir(@default_file_directory, true) if File.exists?(@default_file_directory)
 
-    FileUtils.mkdir(@default_file_directory)
+      FileUtils.mkdir(@default_file_directory)
+    end
   end
 
-  config.after(:each) do
-    FileUtils.remove_dir(@default_file_directory, true)
+  config.after(:each) do |spec|
+    unless spec.metadata[:unit_test]
+      FileUtils.remove_dir(@default_file_directory, true)
+    end
   end
-end
 
+end

data/spec/unit/background_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Background') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Background, Unit' do
+describe 'Background, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Background }
   let(:background) { clazz.new }
@@ -10,68 +9,49 @@ describe 'Background, 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 bare bones element'
-    it_should_behave_like 'a prepopulated element'
-    it_should_behave_like 'a test 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 stepped 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 = 'Background: test background'
+    it 'contains steps' do
+      steps = [:step_1, :step_2]
+      everything = steps
 
-      expect { @element = clazz.new(source) }.to_not raise_error
+      background.steps = steps
 
-      # Sanity check in case instantiation failed in a non-explosive manner
-      @element.name.should == 'test background'
+      expect(background.children).to match_array(everything)
     end
 
-    it 'provides a descriptive filename when being parsed from stand alone text' do
-      source = "bad background text \n Background:\n And a step\n @foo "
 
-      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_background\.feature'/)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-      background = clazz.new('Background: test background')
-      raw_data = background.raw_element
-
-      expect(raw_data.keys).to match_array([:type, :location, :keyword, :name, :steps])
-      expect(raw_data[:type]).to eq(:Background)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-      background = clazz.new('Background: test background')
-      raw_data = background.raw_element
+    describe 'comparison' do
 
-      expect(raw_data.keys).to match_array([:type, :location, :keyword, :name, :steps])
-      expect(raw_data[:type]).to eq(:Background)
-    end
-
-    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-      background = clazz.new('Background: test background')
-      raw_data = background.raw_element
+      it 'can gracefully be compared to other types of objects' do
+        # Some common types of object
+        [1, 'foo', :bar, [], {}].each do |thing|
+          expect { background == thing }.to_not raise_error
+          expect(background == thing).to be false
+        end
+      end
 
-      expect(raw_data.keys).to match_array(['keyword', 'name', 'line', 'description', 'type'])
-      expect(raw_data['keyword']).to eq('Background')
     end
 
 
-    describe 'background output edge cases' do
+    describe 'background output' do
 
       it 'is a String' do
-        background.to_s.should be_a(String)
+        expect(background.to_s).to be_a(String)
       end
 
 
-      context 'a new background object' do
+      context 'from abstract instantiation' do
 
         let(:background) { clazz.new }
 
@@ -87,7 +67,7 @@ describe 'Background, Unit' do
         end
 
         it 'can output a background that has only a description' do
-          background.description_text = 'a description'
+          background.description = 'a description'
 
           expect { background.to_s }.to_not raise_error
         end

data/spec/unit/cell_unit_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+
+describe 'Cell, Unit', :unit_test => true do
+
+  let(:clazz) { CukeModeler::Cell }
+  let(:cell) { 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 value' do
+      expect(cell).to respond_to(:value)
+    end
+
+    it 'can change its value' do
+      expect(cell).to respond_to(:value=)
+
+      cell.value = :some_value
+      expect(cell.value).to eq(:some_value)
+      cell.value = :some_other_value
+      expect(cell.value).to eq(:some_other_value)
+    end
+
+
+    describe 'abstract instantiation' do
+
+      context 'a new cell object' do
+
+        let(:cell) { clazz.new }
+
+
+        it 'starts with no value' do
+          expect(cell.value).to be_nil
+        end
+
+      end
+
+    end
+
+
+    describe 'cell output' do
+
+      it 'is a String' do
+        expect(cell.to_s).to be_a(String)
+      end
+
+
+      context 'from abstract instantiation' do
+
+        let(:cell) { clazz.new }
+
+
+        it 'can output an empty cell' do
+          expect { cell.to_s }.to_not raise_error
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/described_unit_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+
+describe 'Described, Unit', :unit_test => true do
+
+  let(:nodule) { CukeModeler::Described }
+  let(:described_model) { Object.new.extend(nodule) }
+
+
+  it 'has a description' do
+    expect(described_model).to respond_to(:description)
+  end
+
+  it 'can change its description' do
+    expect(described_model).to respond_to(:description=)
+
+    described_model.description = :some_description
+    expect(described_model.description).to eq(:some_description)
+    described_model.description = :some_other_description
+    expect(described_model.description).to eq(:some_other_description)
+  end
+
+end

data/spec/unit/directory_unit_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Directory') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Directory, Unit' do
+describe 'Directory, Unit', :unit_test => true do
 
   let(:clazz) { CukeModeler::Directory }
   let(:directory) { clazz.new }
@@ -10,10 +9,7 @@ describe 'Directory, 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
 
@@ -30,78 +26,71 @@ describe 'Directory, Unit' do
       expect(directory.name).to eq('foo')
     end
 
-    it 'has a path' do
-      expect(directory).to respond_to(:path)
-    end
 
-    it 'can change its path' do
-      expect(directory).to respond_to(:path=)
+    describe 'attributes' do
 
-      directory.path = :some_path
-      directory.path.should == :some_path
-      directory.path = :some_other_path
-      directory.path.should == :some_other_path
-    end
+      it 'has a path' do
+        expect(directory).to respond_to(:path)
+      end
 
-    it 'knows the path of the directory that it is modeling' do
-      path = "#{@default_file_directory}"
+      it 'can change its path' do
+        expect(directory).to respond_to(:path=)
 
-      directory = clazz.new(path)
+        directory.path = :some_path
+        expect(directory.path).to eq(:some_path)
+        directory.path = :some_other_path
+        expect(directory.path).to eq(:some_other_path)
+      end
 
-      directory.path.should == path
-    end
+      it 'has feature files' do
+        expect(directory).to respond_to(:feature_files)
+      end
 
-    it 'has feature files' do
-      directory.should respond_to(:feature_files)
-    end
+      it 'can change its feature files' do
+        expect(directory).to respond_to(:feature_files=)
 
-    it 'can change its feature files' do
-      expect(directory).to respond_to(:feature_files=)
+        directory.feature_files = :some_feature_files
+        expect(directory.feature_files).to eq(:some_feature_files)
+        directory.feature_files = :some_other_feature_files
+        expect(directory.feature_files).to eq(:some_other_feature_files)
+      end
 
-      directory.feature_files = :some_feature_files
-      directory.feature_files.should == :some_feature_files
-      directory.feature_files = :some_other_feature_files
-      directory.feature_files.should == :some_other_feature_files
-    end
+      it 'has directories' do
+        expect(directory).to respond_to(:directories)
+      end
 
-    it 'knows how many feature files it has' do
-      directory.feature_files = [:file_1, :file_2, :file_3]
+      it 'can change its directories' do
+        expect(directory).to respond_to(:directories=)
 
-      directory.feature_file_count.should == 3
-    end
+        directory.directories = :some_directories
+        expect(directory.directories).to eq(:some_directories)
+        directory.directories = :some_other_directories
+        expect(directory.directories).to eq(:some_other_directories)
+      end
 
-    it 'has directories' do
-      directory.should respond_to(:directories)
     end
 
-    it 'can change its directories' do
-      expect(directory).to respond_to(:directories=)
 
-      directory.directories = :some_directories
-      directory.directories.should == :some_directories
-      directory.directories = :some_other_directories
-      directory.directories.should == :some_other_directories
-    end
+    describe 'abstract instantiation' do
 
-    it 'knows how many directories it has' do
-      directory.directories = [:directory_1, :directory_2, :directory_3]
+      context 'a new directory object' do
 
-      directory.directory_count.should == 3
-    end
+        let(:directory) { clazz.new }
 
-    describe 'abstract instantiation' do
 
-      it 'starts with no path' do
-        expect(directory.path).to be nil
-      end
+        it 'starts with no path' do
+          expect(directory.path).to be_nil
+        end
 
-      it 'starts with no name' do
-        expect(directory.name).to be nil
-      end
+        it 'starts with no name' do
+          expect(directory.name).to be_nil
+        end
+
+        it 'starts with no feature files or directories' do
+          expect(directory.feature_files).to eq([])
+          expect(directory.directories).to eq([])
+        end
 
-      it 'starts with no feature files or directories' do
-        directory.feature_files.should == []
-        directory.directories.should == []
       end
 
     end
@@ -114,17 +103,18 @@ describe 'Directory, Unit' do
       directory.directories = directories
       directory.feature_files = files
 
-      directory.contains.should =~ everything
+      expect(directory.children).to match_array(everything)
     end
 
-    describe 'directory output edge cases' do
+
+    describe 'directory output' do
 
       it 'is a String' do
-        directory.to_s.should be_a(String)
+        expect(directory.to_s).to be_a(String)
       end
 
 
-      context 'a new directory object' do
+      context 'from abstract instantiation' do
 
         let(:directory) { clazz.new }