cucumber_analytics 0.0.9 → 1.0.0

data/spec/unit/outline_unit_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Outline') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Outline, Unit' do
+
+  clazz = CucumberAnalytics::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 'can be parsed from stand alone text' do
+    source = 'Scenario Outline: '
+
+    expect { clazz.new(source) }.to_not raise_error
+  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
+
+end

data/spec/unit/parsing_unit_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Parsing') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Parsing, Unit' do
+
+  it 'can parse text - #parse_text' do
+    CucumberAnalytics::Parsing.should respond_to(:parse_text)
+  end
+
+  it 'can only parse strings' do
+    expect{CucumberAnalytics::Parsing.parse_text(5)}.to raise_error(ArgumentError)
+    expect{CucumberAnalytics::Parsing.parse_text('Feature:')}.to_not raise_error
+  end
+
+  it 'returns an Array' do
+    result = CucumberAnalytics::Parsing.parse_text('Feature:')
+    result.is_a?(Array).should be_true
+  end
+
+end

data/spec/unit/prepopulated_unit_specs.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+shared_examples_for 'a prepopulated element' do |clazz|
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+  it 'can take an argument' do
+    (clazz.instance_method(:initialize).arity != 0).should be_true
+  end
+
+end

data/spec/unit/scenario_unit_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Scenario') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Scenario, Unit' do
+
+  clazz = CucumberAnalytics::Scenario
+
+  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 'can be parsed from stand alone text' do
+    source = 'Scenario: '
+
+    expect { clazz.new(source) }.to_not raise_error
+  end
+
+  before(:each) do
+    @scenario = clazz.new
+  end
+
+  it 'contains only steps' do
+    steps = [:step_1, :step_2]
+    everything = steps
+
+    @scenario.steps = steps
+
+    @scenario.contains.should =~ everything
+  end
+
+end

data/spec/unit/step_unit_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Step') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Step, Unit' do
+
+  clazz = CucumberAnalytics::Step
+
+  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
+
+
+  before(:each) do
+    @step = clazz.new
+  end
+
+  it 'has arguments - #arguments' do
+    @step.should respond_to(:arguments)
+  end
+
+  it 'can get and set its arguments - #arguments, #arguments=' do
+    @step.arguments = :some_arguments
+    @step.arguments.should == :some_arguments
+    @step.arguments = :some_other_arguments
+    @step.arguments.should == :some_other_arguments
+  end
+
+  it 'starts with no arguments' do
+    @step.arguments.should == []
+  end
+
+  it 'has a base - #base' do
+    @step.should respond_to(:base)
+  end
+
+  it 'can get and set its base - #base, #base=' do
+    @step.base = :some_base
+    @step.base.should == :some_base
+    @step.base = :some_other_base
+    @step.base.should == :some_other_base
+  end
+
+  it 'starts with no base' do
+    @step.base.should == nil
+  end
+
+  it 'has a block - #block' do
+    @step.should respond_to(:block)
+  end
+
+  it 'can get and set its block - #block, #block=' do
+    @step.block = :some_block
+    @step.block.should == :some_block
+    @step.block = :some_other_block
+    @step.block.should == :some_other_block
+  end
+
+  it 'starts with no block' do
+    @step.block.should == nil
+  end
+
+  it 'has a keyword - #keyword' do
+    @step.should respond_to(:keyword)
+  end
+
+  it 'can get and set its keyword - #keyword, #keyword=' do
+    @step.keyword = :some_keyword
+    @step.keyword.should == :some_keyword
+    @step.keyword = :some_other_keyword
+    @step.keyword.should == :some_other_keyword
+  end
+
+  it 'starts with no keyword' do
+    @step.keyword.should == nil
+  end
+
+  it 'has a left delimiter - #left_delimiter' do
+    @step.should respond_to(:left_delimiter)
+  end
+
+  it 'can get and set its left delimiter - #left_delimiter, #left_delimiter=' do
+    @step.left_delimiter = :some_left_delimiter
+    @step.left_delimiter.should == :some_left_delimiter
+    @step.left_delimiter = :some_other_left_delimiter
+    @step.left_delimiter.should == :some_other_left_delimiter
+  end
+
+  it 'starts with no left delimiter' do
+    @step.left_delimiter.should == nil
+  end
+
+  it 'has a right delimiter - #right_delimiter' do
+    @step.should respond_to(:right_delimiter)
+  end
+
+  it 'can get and set its right delimiter - #right_delimiter, #right_delimiter=' do
+    @step.right_delimiter = :some_right_delimiter
+    @step.right_delimiter.should == :some_right_delimiter
+    @step.right_delimiter = :some_other_right_delimiter
+    @step.right_delimiter.should == :some_other_right_delimiter
+  end
+
+  it 'starts with no right delimiter' do
+    @step.right_delimiter.should == nil
+  end
+
+  it 'can set both of its delimiters at once - #delimiter=' do
+    @step.delimiter = :new_delimiter
+    @step.left_delimiter.should == :new_delimiter
+    @step.right_delimiter.should == :new_delimiter
+  end
+
+  context '#scan_arguments' do
+
+    it 'can explicitly scan for arguments' do
+      @step.should respond_to(:scan_arguments)
+    end
+
+    it 'can determine its arguments based on a regular expression' do
+      source = 'Given a test step with a parameter'
+      step = CucumberAnalytics::Step.new(source)
+
+      step.scan_arguments(/parameter/)
+      step.arguments.should == ['parameter']
+      step.scan_arguments(/t s/)
+      step.arguments.should == ['t s']
+    end
+
+    it 'can determine its arguments based on delimiters' do
+      source = 'Given a test step with -parameter 1- and -parameter 2-'
+
+      step = CucumberAnalytics::Step.new(source)
+
+      step.scan_arguments('-', '-')
+      step.arguments.should == ['parameter 1', 'parameter 2']
+      step.scan_arguments('!', '!')
+      step.arguments.should == []
+    end
+
+    it 'can use different left and right delimiters when scanning' do
+      source = 'Given a test step with !a parameter-'
+
+      step = CucumberAnalytics::Step.new(source)
+
+      step.scan_arguments('!', '-')
+      step.arguments.should == ['a parameter']
+    end
+
+    it 'can use delimiters of varying lengths' do
+      source = 'Given a test step with -start-a parameter-end-'
+
+      step = CucumberAnalytics::Step.new(source)
+
+      step.scan_arguments('-start-', '-end-')
+      step.arguments.should == ['a parameter']
+    end
+
+    it 'can handle delimiters with special regular expression characters' do
+      source = 'Given a test step with \d+a parameter.?'
+
+      step = CucumberAnalytics::Step.new(source)
+
+      step.scan_arguments('\d+', '.?')
+      step.arguments.should == ['a parameter']
+    end
+
+    it 'defaults to its set delimiters when scanning' do
+      source = 'Given a test step with *parameter 1* and "parameter 2" and *parameter 3*'
+      step = CucumberAnalytics::Step.new(source)
+
+      step.left_delimiter = '"'
+      step.right_delimiter = '"'
+      step.scan_arguments
+
+      step.arguments.should == ['parameter 2']
+    end
+  end
+
+  it 'can be parsed from stand alone text' do
+    source = '* some step'
+
+    expect { clazz.new(source) }.to_not raise_error
+  end
+
+  context '#step_text ' do
+
+    before(:each) do
+      source = "Given a test step with -parameter 1- ^and@ *parameter 2!!\n|a block|"
+      @step = CucumberAnalytics::Step.new(source)
+      @step.delimiter = '-'
+    end
+
+    it 'can provide different flavors of step\'s text' do
+      @step.should respond_to(:step_text)
+    end
+
+    it 'returns different text based on options' do
+      (clazz.instance_method(:step_text).arity != 0).should be_true
+    end
+
+    it 'returns the step\'s text as an Array' do
+      @step.step_text.is_a?(Array).should be_true
+    end
+
+    it 'can provide the step\'s text without the arguments' do
+      expected_output = ['Given a test step with -- ^and@ *parameter 2!!']
+
+      @step.step_text(with_arguments: false).should == expected_output
+    end
+
+    it 'can determine its arguments based on delimiters' do
+      expected_output = ['Given a test step with -parameter 1- ^@ *parameter 2!!']
+
+      @step.step_text(with_arguments: false, left_delimiter: '^', right_delimiter: '@').should == expected_output
+    end
+
+    it 'can use delimiters of varying lengths' do
+      expected_output = ['Given a test step with -parameter 1- ^and@ *!!']
+
+      @step.step_text(with_arguments: false, left_delimiter: '*', right_delimiter: '!!').should == expected_output
+    end
+
+    it 'can handle delimiters with special regular expression characters' do
+      expected_output = ['Given a test step with -parameter 1- ^and@ *!!']
+
+      @step.step_text(with_arguments: false, left_delimiter: '*', right_delimiter: '!!').should == expected_output
+    end
+
+  end
+end

data/spec/unit/table_unit_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Table') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Table, Unit' do
+
+  clazz = CucumberAnalytics::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 'can be parsed from stand alone text' do
+    source = '| a table |'
+
+    expect { clazz.new(source) }.to_not raise_error
+  end
+
+  before(:each) do
+    @table = clazz.new
+  end
+
+  it 'has contents - #contents' do
+    @table.should respond_to(:contents)
+  end
+
+  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
+
+  it 'starts with no contents' do
+    @table.contents.should == []
+  end
+
+  it 'stores its contents as a nested array of strings' do
+    source = "| cell 1 | cell 2 |\n| cell 3 | cell 4 |"
+    table = CucumberAnalytics::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
+
+end

data/spec/unit/taggable_unit_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+SimpleCov.command_name('Taggable') unless RUBY_VERSION.to_s < '1.9.0'
+
+describe 'Taggable, Unit' do
+
+  nodule = CucumberAnalytics::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 - #tags' do
+    @element.should respond_to(:tags)
+  end
+
+  it 'can get and set its tags - #tags, #tags=' do
+    @element.tags = :some_tags
+    @element.tags.should == :some_tags
+    @element.tags = :some_other_tags
+    @element.tags.should == :some_other_tags
+  end
+
+  it 'has applied tags - #applied_tags' do
+    @element.should respond_to(:applied_tags)
+  end
+
+  it 'inherits its applied tags from its ancestors - #applied_tags' do
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    parent = double(:all_tags => all_parent_tags)
+
+    @element.parent_element = parent
+
+    @element.applied_tags.should == all_parent_tags
+  end
+
+  it 'knows all of its applicable tags - #all_tags' do
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    own_tags = ['@tag_1', '@tag_2']
+    parent = double(:all_tags => all_parent_tags)
+
+    @element.parent_element = parent
+    @element.tags = own_tags
+
+    @element.all_tags.should == all_parent_tags + own_tags
+  end
+
+  it 'may have no applied tags' do
+    @element.parent_element = :not_a_tagged_object
+
+    @element.applied_tags.should == []
+  end
+
+end

data/spec/unit/tagged_element_unit_specs.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+shared_examples_for 'a tagged element' do |clazz|
+
+  before(:each) do
+    @element = clazz.new
+  end
+
+  it 'has tags - #tags' do
+    @element.should respond_to(:tags)
+  end
+
+  it 'can get and set its tags - #tags, #tags=' do
+    @element.tags = :some_tags
+    @element.tags.should == :some_tags
+    @element.tags = :some_other_tags
+    @element.tags.should == :some_other_tags
+  end
+
+  it 'starts with no tags' do
+    @element.tags.should == []
+  end
+
+  it 'has applied tags - #applied_tags' do
+    @element.should respond_to(:applied_tags)
+  end
+
+  it 'inherits its applied tags from its ancestors - #applied_tags' do
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    parent = double(:all_tags => all_parent_tags)
+
+    @element.parent_element = parent
+
+    @element.applied_tags.should == all_parent_tags
+  end
+
+  it 'knows all of its applicable tags - #all_tags' do
+    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+    own_tags = ['@tag_1', '@tag_2']
+    parent = double(:all_tags => all_parent_tags)
+
+    @element.parent_element = parent
+    @element.tags = own_tags
+
+    @element.all_tags.should == all_parent_tags + own_tags
+  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 = CucumberAnalytics::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