cuke_modeler 0.0.1

data/spec/unit/feature_element_unit_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+SimpleCov.command_name('FeatureElement') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'FeatureElement, Unit' do
+
+  clazz = CukeModeler::FeatureElement
+
+  it_should_behave_like 'a feature element', clazz
+  it_should_behave_like 'a nested element', clazz
+  it_should_behave_like 'a prepopulated element', clazz
+  it_should_behave_like 'a bare bones element', clazz
+
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+end

data/spec/unit/feature_element_unit_specs.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+shared_examples_for 'a feature element' do |clazz|
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+  it 'has a name - #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
+  end
+
+  it 'has a description' do
+    @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
+  end
+
+  it 'starts with no name' do
+    @element.name.should == ''
+  end
+
+  it 'starts with no description' do
+    @element.description.should == []
+    @element.description_text.should == ''
+  end
+
+end

data/spec/unit/feature_file_unit_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+SimpleCov.command_name('FeatureFile') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'FeatureFile, Unit' do
+
+  clazz = CukeModeler::FeatureFile
+
+  it_should_behave_like 'a nested element', clazz
+  it_should_behave_like 'a containing element', clazz
+  it_should_behave_like 'a bare bones element', clazz
+  it_should_behave_like 'a prepopulated element', clazz
+
+
+  before(:each) do
+    @feature_file = clazz.new
+  end
+
+  it 'cannot model a non-existent directory' do
+    path = "#{@default_file_directory}/missing_file.txt"
+
+    expect { CukeModeler::FeatureFile.new(path) }.to raise_error(ArgumentError)
+  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") {}
+
+    feature = CukeModeler::FeatureFile.new(path)
+
+    feature.name.should == @default_feature_file_name
+  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") {}
+
+    directory = CukeModeler::FeatureFile.new(path)
+
+    directory.path.should == path
+  end
+
+  it 'has features - #features' do
+    @feature_file.should respond_to(:features)
+  end
+
+  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
+
+  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 'starts with no features' do
+    @feature_file.features.should == []
+  end
+
+  it 'contains features' do
+    features = [:a_feature]
+    everything = features
+
+    @feature_file.features = features
+
+    @feature_file.contains.should =~ everything
+  end
+
+  it 'can easily access its sole feature' do
+    @feature_file.features = []
+    @feature_file.feature.should be_nil
+
+    @feature_file.features = [:a_feature]
+    @feature_file.feature.should == :a_feature
+  end
+
+  context 'feature file output edge cases' do
+
+    it 'is a String' do
+      @feature_file.to_s.should be_a(String)
+    end
+
+    it 'can output an empty feature file' do
+      expect { @feature_file.to_s }.to_not raise_error
+    end
+
+  end
+
+end

data/spec/unit/feature_unit_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Feature') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Feature, Unit' do
+
+  clazz = CukeModeler::Feature
+
+  it_should_behave_like 'a feature element', clazz
+  it_should_behave_like 'a nested element', clazz
+  it_should_behave_like 'a containing element', clazz
+  it_should_behave_like 'a tagged element', clazz
+  it_should_behave_like 'a bare bones element', clazz
+  it_should_behave_like 'a prepopulated element', clazz
+  it_should_behave_like 'a sourced element', clazz
+  it_should_behave_like 'a raw element', clazz
+
+  before(:each) do
+    @feature = clazz.new
+  end
+
+  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 '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 - #background' do
+    @feature.should respond_to(:background)
+  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 '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 'has tests - #tests' do
+    @feature.should respond_to(:tests)
+  end
+
+  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
+
+  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 '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 'contains a background only if one is present' do
+    tests = [:test_1, :test_2]
+    background = nil
+    everything = tests
+
+    @feature.background = background
+    @feature.tests = tests
+
+    @feature.contains.should =~ everything
+  end
+
+  it 'starts with no background' do
+    @feature.background.should == nil
+  end
+
+  it 'starts with no tests' do
+    @feature.tests.should == []
+  end
+
+  context 'feature output edge cases' do
+
+    it 'is a String' do
+      @feature.to_s.should be_a(String)
+    end
+
+    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 a tags' do
+      @feature.tags = ['a tag']
+
+      expect { @feature.to_s }.to_not raise_error
+    end
+
+  end
+
+end

data/spec/unit/nested_element_unit_specs.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+shared_examples_for 'a nested element' do |clazz|
+
+  before(:each) do
+    @nested_element = clazz.new
+  end
+
+  it 'has a parent element - #parent_element' do
+    @nested_element.should respond_to(:parent_element)
+  end
+
+  it 'can get and set its parent element - #parent_element, #parent_element=' do
+    @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 'starts with no parent element' do
+    @nested_element.parent_element.should == nil
+  end
+
+  it 'has access to its ancestors' do
+    @nested_element.should respond_to(:get_ancestor)
+  end
+
+  it 'gets an ancestor based on type' do
+    (clazz.instance_method(:get_ancestor).arity == 1).should be_true
+  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

data/spec/unit/nested_unit_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Nested') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Nested, Unit' do
+
+  nodule = CukeModeler::Nested
+
+  before(:each) do
+    @nested_element = Object.new.extend(nodule)
+  end
+
+
+  it 'has a parent element - #parent_element' do
+    @nested_element.should respond_to(:parent_element)
+  end
+
+  it 'can get and set its parent element - #parent_element, #parent_element=' do
+    @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 'has access to its ancestors' do
+    @nested_element.should respond_to(:get_ancestor)
+  end
+
+  it 'gets an ancestor based on type' do
+    (nodule.instance_method(:get_ancestor).arity == 1).should be_true
+  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

data/spec/unit/outline_unit_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Outline') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Outline, Unit' do
+
+  clazz = CukeModeler::Outline
+
+  it_should_behave_like 'a feature element', clazz
+  it_should_behave_like 'a nested element', clazz
+  it_should_behave_like 'a containing element', clazz
+  it_should_behave_like 'a tagged element', clazz
+  it_should_behave_like 'a bare bones element', clazz
+  it_should_behave_like 'a prepopulated element', clazz
+  it_should_behave_like 'a test element', clazz
+  it_should_behave_like 'a sourced element', clazz
+  it_should_behave_like 'a raw element', clazz
+
+
+  it 'can be parsed from stand alone text' do
+    source = 'Scenario Outline: test outline'
+
+    expect { @element = clazz.new(source) }.to_not raise_error
+
+    # Sanity check in case instantiation failed in a non-explosive manner
+    @element.name.should == 'test outline'
+  end
+
+
+  before(:each) do
+    @outline = clazz.new
+  end
+
+
+  it 'has examples - #examples' do
+    @outline.should respond_to(:examples)
+  end
+
+  it 'can get and set its examples - #examples, #examples=' do
+    @outline.examples = :some_examples
+    @outline.examples.should == :some_examples
+    @outline.examples = :some_other_examples
+    @outline.examples.should == :some_other_examples
+  end
+
+  it 'starts with no examples' do
+    @outline.examples.should == []
+  end
+
+  it 'contains steps and examples' do
+    steps = [:step_1, :step_2, :step_3]
+    examples = [:example_1, :example_2, :example_3]
+    everything = steps + examples
+
+    @outline.steps = steps
+    @outline.examples = examples
+
+    @outline.contains.should =~ everything
+  end
+
+  context 'outline output edge cases' do
+
+    it 'is a String' do
+      @outline.to_s.should be_a(String)
+    end
+
+    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 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_text = 'a description'
+
+      expect { @outline.to_s }.to_not raise_error
+    end
+
+    it 'can output an outline that has only a tags' do
+      @outline.tags = ['a tag']
+
+      expect { @outline.to_s }.to_not raise_error
+    end
+
+  end
+
+end