cuke_modeler 0.0.1

data/spec/unit/table_row_unit_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+SimpleCov.command_name('TableRow') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'TableRow, Unit' do
+
+  clazz = CukeModeler::TableRow
+
+  it_should_behave_like 'a nested 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
+
+  it 'can be parsed from stand alone text' do
+    source = '| a | row |'
+
+    expect { @element = clazz.new(source) }.to_not raise_error
+
+    # Sanity check in case instantiation failed in a non-explosive manner
+    @element.cells.should == ['a', 'row']
+  end
+
+  before(:each) do
+    @row = clazz.new
+  end
+
+  it 'has cells' do
+    @row.should respond_to(:cells)
+  end
+
+  it 'can get and set its cells' do
+    @row.cells = :some_cells
+    @row.cells.should == :some_cells
+    @row.cells = :some_other_cells
+    @row.cells.should == :some_other_cells
+  end
+
+  it 'starts with no cells' do
+    @row.cells.should == []
+  end
+
+  context 'table row output edge cases' do
+
+    it 'is a String' do
+      @row.to_s.should be_a(String)
+    end
+
+    it 'can output an empty table row' do
+      expect { @row.to_s }.to_not raise_error
+    end
+
+  end
+
+end

data/spec/unit/table_unit_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Table') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Table, Unit' do
+
+  clazz = CukeModeler::Table
+
+  it_should_behave_like 'a nested element', clazz
+  it_should_behave_like 'a bare bones element', clazz
+  it_should_behave_like 'a prepopulated element', clazz
+  it_should_behave_like 'a raw element', clazz
+
+  it 'can be parsed from stand alone text' do
+    source = '| a table |'
+
+    expect { @element = clazz.new(source) }.to_not raise_error
+
+    # Sanity check in case instantiation failed in a non-explosive manner
+    @element.row_elements.collect { |row| row.cells }.should == [['a table']]
+    # todo - remove once #contents is no longer supported
+    @element.contents.should == [['a table']]
+  end
+
+  before(:each) do
+    @table = clazz.new
+  end
+
+  # todo - remove once #contents is no longer supported
+  it 'has contents - #contents' do
+    @table.should respond_to(:contents)
+  end
+
+  # todo - remove once #contents is no longer supported
+  it 'can get and set its contents - #contents, #contents=' do
+    @table.contents = :some_contents
+    @table.contents.should == :some_contents
+    @table.contents = :some_other_contents
+    @table.contents.should == :some_other_contents
+  end
+
+  # todo - remove once #contents is no longer supported
+  it 'starts with no contents' do
+    @table.contents.should == []
+  end
+
+  it 'has row elements' do
+    @table.should respond_to(:row_elements)
+  end
+
+  it 'can get and set its row elements' do
+    @table.row_elements = :some_row_elements
+    @table.row_elements.should == :some_row_elements
+    @table.row_elements = :some_other_row_elements
+    @table.row_elements.should == :some_other_row_elements
+  end
+
+  it 'starts with no row elements' do
+    @table.row_elements.should == []
+  end
+
+  # todo - remove once #contents is no longer supported
+  it 'stores its contents as a nested array of strings' do
+    source = "| cell 1 | cell 2 |\n| cell 3 | cell 4 |"
+    table = CukeModeler::Table.new(source)
+
+    contents = table.contents
+
+    contents.is_a?(Array).should be_true
+
+    contents.each do |row|
+      row.is_a?(Array).should be_true
+      row.each { |cell| cell.is_a?(String).should be_true }
+    end
+  end
+
+  context 'table output edge cases' do
+
+    it 'is a String' do
+      @table.to_s.should be_a(String)
+    end
+
+    it 'can output an empty table' do
+      expect { @table.to_s }.to_not raise_error
+    end
+
+    # todo - remove once #contents is no longer supported
+    it 'can output a table that only has contents' do
+      @table.contents = ['some contents']
+
+      expect { @table.to_s }.to_not raise_error
+    end
+
+  end
+
+end

data/spec/unit/tag_unit_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Tag') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Tag, Unit' do
+
+  clazz = CukeModeler::Tag
+
+  it_should_behave_like 'a nested 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
+
+
+  it 'can be parsed from stand alone text' do
+    source = '@a_tag'
+
+    expect { @element = clazz.new(source) }.to_not raise_error
+    @element.name.should == '@a_tag'
+  end
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+
+  it 'has a name' do
+    @element.should respond_to(:name)
+  end
+
+  it 'can get and set its name' do
+    @element.name = :some_name
+    @element.name.should == :some_name
+    @element.name = :some_other_name
+    @element.name.should == :some_other_name
+  end
+
+  context 'tag output edge cases' do
+
+    it 'is a String' do
+      @element.to_s.should be_a(String)
+    end
+
+    it 'can output an empty tag' do
+      expect { @element.to_s }.to_not raise_error
+    end
+
+  end
+
+end

data/spec/unit/taggable_unit_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Taggable') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Taggable, Unit' do
+
+  nodule = CukeModeler::Taggable
+
+  before(:each) do
+    @element = Object.new.extend(nodule)
+
+    def @element.parent_element
+      @parent_element
+    end
+
+    def @element.parent_element=(parent)
+      @parent_element = parent
+    end
+  end
+
+
+  it 'has tags' do
+    @element.should respond_to(:tags)
+    @element.should respond_to(:tag_elements)
+  end
+
+  it 'can get and set its tags' do
+    @element.tags = :some_tags
+    @element.tags.should == :some_tags
+    @element.tags = :some_other_tags
+    @element.tags.should == :some_other_tags
+
+    @element.tag_elements = :some_tag_elements
+    @element.tag_elements.should == :some_tag_elements
+    @element.tag_elements = :some_other_tag_elements
+    @element.tag_elements.should == :some_other_tag_elements
+  end
+
+  it 'has applied tags' do
+    @element.should respond_to(:applied_tags)
+    @element.should respond_to(:applied_tag_elements)
+  end
+
+  it 'inherits its applied tags from its ancestors' do
+    all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
+
+    @element.parent_element = parent
+
+    @element.applied_tags.should == all_parent_tags
+    @element.applied_tag_elements.should == all_parent_tag_elements
+  end
+
+  it 'knows all of its applicable tags' do
+    all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    own_tags = ['@tag_1', '@tag_2']
+    own_tag_elements = [:tag_element_1, :tag_element_2]
+
+    parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
+
+    @element.parent_element = parent
+    @element.tags = own_tags
+    @element.tag_elements = own_tag_elements
+
+    @element.all_tags.should == all_parent_tags + own_tags
+    @element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
+  end
+
+  it 'may have no applied tags' do
+    @element.parent_element = :not_a_tagged_object
+
+    @element.applied_tags.should == []
+    @element.applied_tag_elements.should == []
+  end
+
+end

data/spec/unit/tagged_element_unit_specs.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+shared_examples_for 'a tagged element' do |clazz|
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+  it 'has tags' do
+    @element.should respond_to(:tags)
+    @element.should respond_to(:tag_elements)
+  end
+
+  it 'can get and set its tags' do
+    @element.tags = :some_tags
+    @element.tags.should == :some_tags
+    @element.tags = :some_other_tags
+    @element.tags.should == :some_other_tags
+
+    @element.tag_elements = :some_tag_elements
+    @element.tag_elements.should == :some_tag_elements
+    @element.tag_elements = :some_other_tag_elements
+    @element.tag_elements.should == :some_other_tag_elements
+  end
+
+  it 'starts with no tags' do
+    @element.tags.should == []
+    @element.tag_elements.should == []
+  end
+
+  it 'has applied tags' do
+    @element.should respond_to(:applied_tags)
+    @element.should respond_to(:applied_tag_elements)
+  end
+
+  it 'inherits its applied tags from its ancestors' do
+    all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
+
+    @element.parent_element = parent
+
+    @element.applied_tags.should == all_parent_tags
+    @element.applied_tag_elements.should == all_parent_tag_elements
+  end
+
+  it 'knows all of its applicable tags' do
+    all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    own_tags = ['@tag_1', '@tag_2']
+    own_tag_elements = [:tag_element_1, :tag_element_2]
+
+    parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
+
+    @element.parent_element = parent
+    @element.tags = own_tags
+    @element.tag_elements = own_tag_elements
+
+    @element.all_tags.should == all_parent_tags + own_tags
+    @element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
+  end
+
+end

data/spec/unit/test_element_unit_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+SimpleCov.command_name('TestElement') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'TestElement, Unit' do
+
+  clazz = CukeModeler::TestElement
+
+  it_should_behave_like 'a test element', clazz
+  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
+
+  it 'contains only steps - #contains' do
+    steps = [:step_1, :step_2, :step_3]
+    @element.steps = steps
+
+    @element.contains.should =~ steps
+  end
+
+  it 'can determine its equality with another TestElement - #==' do
+    element_1 = clazz.new
+    element_2 = clazz.new
+    element_3 = clazz.new
+
+    element_1.steps = :some_steps
+    element_2.steps = :some_steps
+    element_3.steps = :some_other_steps
+
+    (element_1 == element_2).should be_true
+    (element_1 == element_3).should be_false
+  end
+
+end

data/spec/unit/test_element_unit_specs.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+shared_examples_for 'a test element' do |clazz|
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+  it 'has steps - #steps' do
+    @element.should respond_to(:steps)
+  end
+
+  it 'can get and set its steps - #steps, #steps=' do
+    @element.steps = :some_steps
+    @element.steps.should == :some_steps
+    @element.steps = :some_other_steps
+    @element.steps.should == :some_other_steps
+  end
+
+  it 'starts with no steps' do
+    @element.steps.should == []
+  end
+
+  it 'contains steps - #contains' do
+    steps = [:step_1, :step_2, :step_3]
+    @element.steps = steps
+
+    steps.each { |step| @element.contains.should include(step) }
+  end
+
+end

data/spec/unit/world_unit_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+SimpleCov.command_name('World') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'World, Unit' do
+
+  before(:each) do
+    @world = CukeModeler::World
+    @world.loaded_step_patterns.clear
+    @world.delimiter = nil
+  end
+
+  it 'has left and right delimiters used for step argument parsing - #left_delimiter, #right_delimiter' do
+    @world.should respond_to(:left_delimiter)
+    @world.should respond_to(:right_delimiter)
+  end
+
+  it 'can get and set the delimiters used for step argument parsing' do
+    @world.left_delimiter = '"'
+    @world.right_delimiter = '"'
+    @world.left_delimiter.should == '"'
+    @world.right_delimiter.should == '"'
+
+    @world.left_delimiter = '!'
+    @world.right_delimiter = '!'
+    @world.left_delimiter.should == '!'
+    @world.right_delimiter.should == '!'
+  end
+
+  it 'can have different left and right delimiters' do
+    @world.left_delimiter = '"'
+    @world.right_delimiter = '*'
+
+    (@world.left_delimiter != @world.right_delimiter).should be_true
+  end
+
+  it 'can set both of its delimiters at once - #delimiter=' do
+    @world.delimiter = '*'
+
+    @world.left_delimiter.should == '*'
+    @world.right_delimiter.should == '*'
+  end
+
+  it 'starts with no delimiters' do
+    @world.left_delimiter.should == nil
+    @world.right_delimiter.should == nil
+  end
+
+  context 'step patterns' do
+
+    it 'can load step patterns - #load_step_pattern' do
+      @world.should respond_to(:load_step_pattern)
+    end
+
+    it 'starts with no patterns loaded' do
+      @world.loaded_step_patterns.should == []
+    end
+
+    it 'keeps track of loaded step patterns - #loaded_step_patterns' do
+      patterns = [/a pattern/, /another pattern/]
+
+      patterns.each do |pattern|
+        @world.load_step_pattern(pattern)
+      end
+
+      @world.loaded_step_patterns.should =~ patterns
+    end
+
+    it 'can load step definition files - #load_step_file' do
+      file_path = "#{@default_file_directory}/step_file.rb"
+      patterns = [/a pattern/, /another pattern/]
+
+      File.open(file_path, 'w') { |file|
+        patterns.each do |pattern|
+          file.puts "Given #{pattern.inspect} do end"
+        end
+      }
+
+      @world.load_step_file(file_path)
+
+      @world.loaded_step_patterns.should =~ patterns
+    end
+
+    it 'can handle different step keywords - #load_step_file' do
+      file_path = "#{@default_file_directory}/step_file.rb"
+      patterns = [/given pattern/, /when pattern/, /then pattern/, /and pattern/, /but pattern/]
+
+      File.open(file_path, 'w') { |file|
+        file.puts "Given #{patterns[0].inspect} do end"
+        file.puts "When #{patterns[1].inspect} do end"
+        file.puts "Then #{patterns[2].inspect} do end"
+        file.puts "And #{patterns[3].inspect} do end"
+        file.puts "But #{patterns[4].inspect} do end"
+      }
+
+      @world.load_step_file(file_path)
+
+      @world.loaded_step_patterns.should =~ patterns
+    end
+
+    it 'can handle a variety of declaration structures - #load_step_file' do
+      file_path = "#{@default_file_directory}/step_file.rb"
+      patterns = [/parentheses pattern/, /no parentheses pattern/, /excess whitespace pattern/]
+
+      File.open(file_path, 'w') { |file|
+        file.puts "Given(#{patterns[0].inspect}) do end"
+        file.puts "Given #{patterns[1].inspect} do end"
+        file.puts "Given   #{patterns[2].inspect}   do end"
+      }
+
+      @world.load_step_file(file_path)
+
+      @world.loaded_step_patterns.should =~ patterns
+    end
+
+    it 'can clear its loaded step patterns - #clear_step_patterns' do
+      patterns = [/a pattern/, /another pattern/]
+
+      patterns.each do |pattern|
+        @world.load_step_pattern(pattern)
+      end
+
+      @world.loaded_step_patterns.should =~ patterns
+      @world.clear_step_patterns
+      @world.loaded_step_patterns.should == []
+    end
+
+  end
+
+end