cucumber_analytics 0.0.1

data/features/modeling/scenario_modeling.feature

@@ -0,0 +1,154 @@
+Feature: Scenario elements can be modeled.
+
+
+  Acceptance criteria
+
+  All conceptual pieces of a Scenario can be modeled:
+    1. the scenario's name
+    2. the scenario's description
+    3. the scenario's steps
+    4. the scenario's tags
+
+
+  Background: Test file setup.
+    Given the following feature file:
+    """
+    @a_feature_level_tag
+    Feature: The test feature name.
+      Some more feature description.
+
+      @a_tag
+
+      @another_tag@yet_another_tag
+      Scenario: The first scenario's name.
+    #a comment
+
+        Some text describing the scenario.
+        More text.
+        Given this *parameterized* step takes a table:
+          | data      |
+          | more data |
+        And some setup step
+#
+        When a step with a *parameter*
+        And a big step:
+        #random comment
+        \"\"\"
+      some text
+
+        #some comments
+        Scenario:
+        Scenario Outline:
+        Examples:
+        @
+        Feature:
+        |
+        Given
+        When
+        Then
+        *
+            some more text
+        \"\"\"
+        Then *lots* *of* *parameters*
+
+    """
+    And parameter delimiters of "*" and "*"
+    When the file is read
+
+
+  Scenario: The scenario name is modeled.
+    Then the test is found to have the following properties:
+      | name | The first scenario's name. |
+
+  Scenario: The scenario description is modeled.
+    Then the test descriptive lines are as follows:
+      | Some text describing the scenario. |
+      | More text.                         |
+
+  Scenario: The scenario steps are modeled.
+    Then the test steps are as follows:
+      | Given this *parameterized* step takes a table: |
+      | \| data      \|                                |
+      | \| more data \|                                |
+      | And some setup step                            |
+      | When a step with a *parameter*                 |
+      | And a big step:                                |
+      | """                                            |
+      | 'some text'                                    |
+      | ''                                             |
+      | '#some comments'                               |
+      | 'Scenario:'                                    |
+      | 'Scenario Outline:'                            |
+      | 'Examples:'                                    |
+      | '@'                                            |
+      | 'Feature:'                                     |
+      | '\|'                                           |
+      | 'Given'                                        |
+      | 'When'                                         |
+      | 'Then'                                         |
+      | '*'                                            |
+      | '    some more text'                           |
+      | """                                            |
+      | Then *lots* *of* *parameters*                  |
+    And the test steps "without" arguments are as follows:
+      | Given this ** step takes a table: |
+      | And some setup step               |
+      | When a step with a **             |
+      | And a big step:                   |
+      | Then ** ** **                     |
+    And the test steps "without" keywords are as follows:
+      | this *parameterized* step takes a table: |
+      | \| data      \|                          |
+      | \| more data \|                          |
+      | some setup step                          |
+      | a step with a *parameter*                |
+      | a big step:                              |
+      | """                                      |
+      | 'some text'                              |
+      | ''                                       |
+      | '#some comments'                         |
+      | 'Scenario:'                              |
+      | 'Scenario Outline:'                      |
+      | 'Examples:'                              |
+      | '@'                                      |
+      | 'Feature:'                               |
+      | '\|'                                     |
+      | 'Given'                                  |
+      | 'When'                                   |
+      | 'Then'                                   |
+      | '*'                                      |
+      | '    some more text'                     |
+      | """                                      |
+      | *lots* *of* *parameters*                 |
+    And the test steps "without" arguments "without" keywords are as follows:
+      | this ** step takes a table: |
+      | some setup step             |
+      | a step with a **            |
+      | a big step:                 |
+      | ** ** **                    |
+    And the test step "1" has the following block:
+      | \| data      \| |
+      | \| more data \| |
+    And the test step "4" has the following block:
+      | """                  |
+      | 'some text'          |
+      | ''                   |
+      | '#some comments'     |
+      | 'Scenario:'          |
+      | 'Scenario Outline:'  |
+      | 'Examples:'          |
+      | '@'                  |
+      | 'Feature:'           |
+      | '\|'                 |
+      | 'Given'              |
+      | 'When'               |
+      | 'Then'               |
+      | '*'                  |
+      | '    some more text' |
+      | """                  |
+
+  Scenario: The scenario tags are modeled.
+    Then the test is found to have the following tags:
+      | @a_tag           |
+      | @another_tag     |
+      | @yet_another_tag |

data/features/step_definitions/background_steps.rb

@@ -0,0 +1,55 @@
+Then /^the(?: feature "([^"]*)")? background is found to have the following properties:$/ do |file, properties|
+  file ||= 1
+  properties = properties.rows_hash
+
+  properties.each do |property, expected_value|
+    assert { expected_value == @parsed_files[file - 1].feature.background.send(property.to_sym).to_s }
+  end
+end
+
+Then /^the(?: feature "([^"]*)")? background's descriptive lines are as follows:$/ do |file, lines|
+  file ||= 1
+  expected_description = lines.raw.flatten
+
+  assert { @parsed_files[file - 1].feature.background.description == expected_description }
+end
+
+Then /^the(?: feature "([^"]*)")? background's steps(?: "([^"]*)" arguments)?(?: "([^"]*)" keywords)? are as follows:$/ do |file, arguments, keywords, steps|
+  file ||= 1
+  arguments ||= 'with'
+  keywords ||= 'with'
+  translate = {'with' => true,
+               'without' => false}
+
+  options = {:with_keywords => translate[keywords], :with_arguments => translate[arguments]}
+
+  steps = steps.raw.flatten.collect do |step|
+    if step.start_with? "'"
+      step.slice(1..step.length - 2)
+    else
+      step
+    end
+  end
+
+  actual_steps = Array.new.tap do |steps|
+    @parsed_files[file - 1].feature.background.steps.each do |step|
+      steps << step.step_text(options)
+    end
+  end
+
+  assert { actual_steps.flatten == steps }
+end
+
+When /^step "([^"]*)" of the background (?:of feature "([^"]*)" )?has the following block:$/ do |step, file, block|
+  file ||= 1
+
+  block = block.raw.flatten.collect do |line|
+    if line.start_with? "'"
+      line.slice(1..line.length - 2)
+    else
+      line
+    end
+  end
+
+  assert { @parsed_files[file - 1].feature.background.steps[step - 1].block == block }
+end

data/features/step_definitions/directory_steps.rb

@@ -0,0 +1,20 @@
+Then /^(?:the )?directory(?: "([^"]*)")? is found to have the following properties:$/ do |directory, properties|
+  directory ||= 1
+  properties = properties.rows_hash
+
+  properties.each do |property, expected_value|
+    if property == 'path'
+      expected_value.sub!('path_to', @default_file_directory)
+    end
+
+    assert { expected_value == @parsed_directories[directory - 1].send(property.to_sym).to_s }
+  end
+end
+
+When /^(?:the )?directory(?: "([^"]*)")? feature files are as follows:$/ do |directory, files|
+  directory ||= 1
+
+  actual_files = @parsed_directories[directory - 1].feature_files.collect { |file| file.name }
+
+  assert { actual_files.flatten.sort == files.raw.flatten.sort }
+end

data/features/step_definitions/feature_steps.rb

@@ -0,0 +1,62 @@
+Then /^(?:the )?feature(?: "([^"]*)")? is found to have the following properties:$/ do |file, properties|
+  file ||= 1
+  properties = properties.rows_hash
+
+  properties.each do |property, expected_value|
+    assert { expected_value == @parsed_files[file - 1].feature.send(property.to_sym).to_s }
+  end
+end
+
+Then /^the descriptive lines of feature "([^"]*)" are as follows:$/ do |file, lines|
+  expected_description = lines.raw.flatten
+
+  assert { @parsed_files[file - 1].feature.description == expected_description }
+end
+
+Then /^feature "([^"]*)" is found to have the following tags:$/ do |file, tags|
+  expected_tags = tags.raw.flatten
+
+  assert { @parsed_files[file - 1].feature.tags == expected_tags }
+end
+
+Then /^feature "([^"]*)" has no descriptive lines$/ do |file|
+  assert { @parsed_files[file - 1].feature.description == [] }
+end
+
+Then /^feature "([^"]*)" has no tags$/ do |file|
+  assert { @parsed_files[file - 1].feature.tags == [] }
+end
+
+When /^(?:the )?feature(?: "([^"]*)")? scenarios are as follows:$/ do |file, scenarios|
+  file ||= 1
+
+  actual_scenarios = @parsed_files[file - 1].feature.scenarios.collect { |scenario| scenario.name }
+
+  assert { actual_scenarios.flatten.sort == scenarios.raw.flatten.sort }
+end
+
+When /^(?:the )?feature(?: "([^"]*)")? outlines are as follows:$/ do |file, outlines|
+  file ||= 1
+
+  actual_outlines = @parsed_files[file - 1].feature.outlines.collect { |outline| outline.name }
+
+  assert { actual_outlines.flatten.sort == outlines.raw.flatten.sort }
+end
+
+When /^(?:the )?feature(?: "([^"]*)")? background is as follows:$/ do |file, background|
+  file ||= 1
+
+  assert { @parsed_files[file - 1].feature.background.name == background.raw.flatten.first }
+end
+
+When /^feature "([^"]*)" has no scenarios$/ do |file|
+  assert { @parsed_files[file - 1].feature.scenarios == [] }
+end
+
+When /^feature "([^"]*)" has no outlines/ do |file|
+  assert { @parsed_files[file - 1].feature.outlines == [] }
+end
+
+When /^feature "([^"]*)" has no background/ do |file|
+  assert { @parsed_files[file - 1].feature.has_background? == false }
+end

data/features/step_definitions/file_steps.rb

@@ -0,0 +1,18 @@
+Then /^(?:the )?file(?: "([^"]*)")? is found to have the following properties:$/ do |file, properties|
+  file ||= 1
+  properties = properties.rows_hash
+
+  properties.each do |property, expected_value|
+    if property == 'path'
+      expected_value.sub!('path_to', @test_directory)
+    end
+
+    assert { expected_value == @parsed_files[file - 1].send(property.to_sym).to_s }
+  end
+end
+
+When /^(?:the )?file(?: "([^"]*)")? features are as follows:$/ do |file, feature|
+  file ||= 1
+
+  assert { @parsed_files[file - 1].feature.name == feature.raw.flatten.first }
+end

data/features/step_definitions/outline_steps.rb

@@ -0,0 +1,26 @@
+Then /^(?:feature "([^"]*)" )?"([^"]*)" example "([^"]*)" has a "([^"]*)"$/ do |file, test, example, name|
+  file ||= 1
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].name == name }
+end
+
+When /^(?:feature "([^"]*)" )?"([^"]*)" example "([^"]*)" descriptive lines are as follows:$/ do |file, test, example, lines|
+  file ||= 1
+  lines = lines.raw.flatten.delete_if { |line| line == '' }
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].description == lines }
+end
+
+When /^(?:feature "([^"]*)" )?"([^"]*)" example "([^"]*)" tags are as follows:$/ do |file, test, example, tags|
+  file ||= 1
+  tags = tags.raw.flatten.delete_if { |line| line == '' }
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].tags == tags }
+end
+
+When /^(?:feature "([^"]*)" )?"([^"]*)" example "([^"]*)" rows are as follows:$/ do |file, test, example, rows|
+  file ||= 1
+  rows = rows.raw.flatten
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].rows == rows }
+end

data/features/step_definitions/setup_steps.rb

@@ -0,0 +1,50 @@
+Given /^the following(?: feature)? file(?: "([^"]*)")?:$/ do |file_name, file_text|
+  @test_directory ||= @default_file_directory
+  file_name ||= @default_feature_file_name
+
+  File.open("#{@test_directory}/#{file_name}", 'w') { |file|
+    file.write(file_text)
+  }
+end
+
+When /^the file(?: "([^"]*)")? is read$/ do |file_name|
+  @parsed_files ||= []
+  @test_directory ||= @default_file_directory
+  file_name ||= @default_feature_file_name
+
+  @parsed_files << CucumberAnalytics::ParsedFile.new("#{@test_directory}/#{file_name}")
+end
+
+When /^the step definition file "([^"]*)" is read$/ do |file_name|
+  @test_directory ||= @default_file_directory
+  file_name ||= @default_step_file_name
+
+  CucumberAnalytics::World.load_step_file("#{@test_directory}/#{file_name}")
+end
+
+When /^parameter delimiters of "([^"]*)" and "([^"]*)"$/ do |left_delimiter, right_delimiter|
+  CucumberAnalytics::World.left_delimiter = left_delimiter
+  CucumberAnalytics::World.right_delimiter = right_delimiter
+end
+
+Given /^a directory "([^"]*)"$/ do |directory_name|
+  @test_directory = "#{@default_file_directory}/#{directory_name}"
+
+  FileUtils.mkdir(@test_directory) unless File.exists?(@test_directory)
+end
+
+When /^the directory(?: "([^"]*)")? is read$/ do |directory_name|
+  @parsed_directories ||= []
+  @test_directory = "#{@default_file_directory}/#{directory_name}" if directory_name
+
+  @parsed_directories << CucumberAnalytics::ParsedDirectory.new(@test_directory)
+end
+
+When /^the following step definition file(?: "([^"]*)")?:$/ do |file_name, file_text|
+  @test_directory ||= @default_file_directory
+  file_name ||= @default_step_file_name
+
+  File.open("#{@test_directory}/#{file_name}", 'w') { |file|
+    file.write(file_text)
+  }
+end

data/features/step_definitions/test_steps.rb

@@ -0,0 +1,82 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is found to have the following properties:$/ do |file, test, properties|
+  file ||= 1
+  test ||= 1
+
+  properties = properties.rows_hash
+
+  properties.each do |property, value|
+    assert { value == @parsed_files[file - 1].feature.tests[test - 1].send(property.to_sym).to_s }
+  end
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? descriptive lines are as follows:$/ do |file, test, lines|
+  file ||= 1
+  test ||= 1
+  lines = lines.raw.flatten
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].description == lines }
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? steps(?: "([^"]*)" arguments)?(?: "([^"]*)" keywords)? are as follows:$/ do |file, test, arguments, keywords, steps|
+  file ||= 1
+  test ||= 1
+  arguments ||= 'with'
+  keywords ||= 'with'
+  translate = {'with' => true,
+               'without' => false}
+
+  options = {:with_keywords => translate[keywords], :with_arguments => translate[arguments]}
+
+
+  steps = steps.raw.flatten.collect do |step|
+    if step.start_with? "'"
+      step.slice(1..step.length - 2)
+    else
+      step
+    end
+  end
+
+  actual_steps = Array.new.tap do |steps|
+    @parsed_files[file - 1].feature.tests[test - 1].steps.each do |step|
+      steps << step.step_text(options)
+    end
+  end
+
+  assert { actual_steps.flatten == steps }
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is found to have the following tags:$/ do |file, test, tags|
+  file ||= 1
+  test ||= 1
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].tags == tags.raw.flatten }
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step "([^"]*)" has the following block:$/ do |file, test, step, block|
+  file ||= 1
+  test ||= 1
+
+  block = block.raw.flatten.collect do |line|
+    if line.start_with? "'"
+      line.slice(1..line.length - 2)
+    else
+      line
+    end
+  end
+
+  assert { @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block == block }
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is equal to test "([^"]*)"$/ do |file, first_test, second_test|
+  file ||= 1
+  first_test ||= 1
+
+  assert { @parsed_files[file - 1].feature.tests[first_test - 1] == @parsed_files[file - 1].feature.tests[second_test - 1] }
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? is not equal to test "([^"]*)"$/ do |file, first_test, second_test|
+  file ||= 1
+  first_test ||= 1
+
+  assert { @parsed_files[file - 1].feature.tests[first_test - 1] != @parsed_files[file - 1].feature.tests[second_test - 1] }
+end

data/features/step_definitions/world_steps.rb

@@ -0,0 +1,158 @@
+Then /^the tags collected from (?:feature "([^"]*)" )?test "([^"]*)" are as follows:$/ do |file, test, tags|
+  file ||= 1
+  tags = tags.raw.flatten
+
+  assert { CucumberAnalytics::World.tags_in(@parsed_files[file - 1].feature.tests[test - 1]).sort == tags.sort }
+end
+
+Then /^the tags collected from feature "([^"]*)" are as follows:$/ do |file, tags|
+  file ||= 1
+  tags = tags.raw.flatten
+
+  assert { CucumberAnalytics::World.tags_in(@parsed_files[file - 1].feature).sort == tags.sort }
+end
+
+Then /^the tags collected from file "([^"]*)" are as follows:$/ do |file, tags|
+  file ||= 1
+  tags = tags.raw.flatten
+
+  assert { CucumberAnalytics::World.tags_in(@parsed_files[file - 1]).sort == tags.sort }
+end
+
+Then /^the tags collected from directory are as follows:$/ do |tags|
+  tags = tags.raw.flatten
+
+  assert { CucumberAnalytics::World.tags_in(@parsed_directories.last).sort == tags.sort }
+end
+
+Then /^the(?: "([^"]*)")? steps collected from feature "([^"]*)" background are as follows:$/ do |defined, file, steps|
+  file ||= 1
+  steps = steps.raw.flatten
+  container = @parsed_files[file - 1].feature.background
+
+  case defined
+    when 'defined'
+      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+    when 'undefined'
+      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+    else
+      expected_steps = CucumberAnalytics::World.steps_in(container)
+  end
+
+  assert { expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort }
+end
+
+Then /^the(?: "([^"]*)")? steps collected from feature "([^"]*)" test "([^"]*)" are as follows:$/ do |defined, file, test, steps|
+  file ||= 1
+  steps = steps.raw.flatten
+  container = @parsed_files[file - 1].feature.tests[test - 1]
+
+  case defined
+    when 'defined'
+      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+    when 'undefined'
+      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+    else
+      expected_steps = CucumberAnalytics::World.steps_in(container)
+  end
+
+  assert { expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort }
+end
+
+When /^the(?: "([^"]*)")? steps collected from (?:the )?feature(?: "([^"]*)")? are as follows:$/ do |defined, file, steps|
+  file ||= 1
+  steps = steps.raw.flatten
+  container = @parsed_files[file - 1].feature
+
+  case defined
+    when 'defined'
+      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+    when 'undefined'
+      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+    else
+      expected_steps = CucumberAnalytics::World.steps_in(container)
+  end
+
+  assert { expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort }
+end
+
+When /^the(?: "([^"]*)")? steps collected from (?:the )?file(?: "([^"]*)")? are as follows:$/ do |defined, file, steps|
+  file ||= 1
+  steps = steps.raw.flatten
+  container = @parsed_files[file - 1]
+
+  case defined
+    when 'defined'
+      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+    when 'undefined'
+      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+    else
+      expected_steps = CucumberAnalytics::World.steps_in(container)
+  end
+
+  assert { expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort }
+end
+
+When /^the(?: "([^"]*)")? steps collected from the directory are as follows:$/ do |defined, steps|
+  steps = steps.raw.flatten
+  container = @parsed_directories.last
+
+  case defined
+    when 'defined'
+      expected_steps = CucumberAnalytics::World.defined_steps_in(container)
+    when 'undefined'
+      expected_steps = CucumberAnalytics::World.undefined_steps_in(container)
+    else
+      expected_steps = CucumberAnalytics::World.steps_in(container)
+  end
+
+  assert { expected_steps.collect { |step| step.step_text }.flatten.sort == steps.sort }
+end
+
+Then /^the tests collected from feature "([^"]*)" are as follows:$/ do |file, tests|
+  file ||= 1
+
+  actual_tests = CucumberAnalytics::World.tests_in(@parsed_files[file - 1].feature).collect { |test| test.name }
+
+  assert { actual_tests.flatten.sort == tests.raw.flatten.sort }
+end
+
+Then /^the tests collected from file "([^"]*)" are as follows:$/ do |file, tests|
+  file ||= 1
+
+  actual_tests = CucumberAnalytics::World.tests_in(@parsed_files[file - 1]).collect { |test| test.name }
+
+  assert { actual_tests.flatten.sort == tests.raw.flatten.sort }
+end
+
+Then /^the tests collected from directory "([^"]*)" are as follows:$/ do |directory, tests|
+  directory ||= 1
+
+  actual_tests = CucumberAnalytics::World.tests_in(@parsed_directories[directory - 1]).collect { |test| test.name }
+
+  assert { actual_tests.flatten.sort == tests.raw.flatten.sort }
+end
+
+Then /^the features collected from file "([^"]*)" are as follows:$/ do |file, features|
+  file ||= 1
+
+  actual_features = CucumberAnalytics::World.features_in(@parsed_files[file - 1]).collect { |feature| feature.name }
+
+  assert { actual_features.flatten.sort == features.raw.flatten.sort }
+end
+
+Then /^the features collected from directory "([^"]*)" are as follows:$/ do |directory, features|
+  directory ||= 1
+
+  actual_features = CucumberAnalytics::World.features_in(@parsed_directories[directory - 1]).collect { |feature| feature.name }
+
+  assert { actual_features.flatten.sort == features.raw.flatten.sort }
+end
+
+Then /^the files collected from directory "([^"]*)" are as follows:$/ do |directory, files|
+  directory ||= 1
+
+  actual_files = CucumberAnalytics::World.files_in(@parsed_directories[directory - 1]).collect { |file| file.name }
+
+  assert { actual_files.flatten.sort == files.raw.flatten.sort }
+end

data/features/support/env.rb

@@ -0,0 +1,29 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'wrong'
+include Wrong
+
+require File.dirname(__FILE__) + '/../../lib/cucumber_analytics'
+
+
+DEFAULT_FEATURE_FILE_NAME = 'test_feature.feature'
+DEFAULT_STEP_FILE_NAME = 'test_steps.rb'
+DEFAULT_FILE_DIRECTORY = "#{File.dirname(__FILE__)}/../temp_files"
+TEST_FILE_DIRECTORY = "#{File.dirname(__FILE__)}/../test_files"
+TEST_STEP_FILE_LOCATION = "#{DEFAULT_FILE_DIRECTORY}/#{DEFAULT_STEP_FILE_NAME}"
+
+
+Before do
+  @default_feature_file_name = DEFAULT_FEATURE_FILE_NAME
+  @default_step_file_name = DEFAULT_STEP_FILE_NAME
+  @test_file_directory = TEST_FILE_DIRECTORY
+  @default_file_directory = DEFAULT_FILE_DIRECTORY
+  @test_step_file_location = TEST_STEP_FILE_LOCATION
+
+  FileUtils.mkdir(@default_file_directory)
+end
+
+After do
+  FileUtils.remove_dir(@default_file_directory, true)
+end

data/features/support/transforms.rb

@@ -0,0 +1,3 @@
+Transform /^(-?\d+)$/ do |number|
+  number.to_i
+end