cucumber_analytics 1.4.2 → 1.5.0

data/features/modeling/step_modeling.feature

@@ -3,13 +3,15 @@ Feature: Step elements can be modeled.
 
   Acceptance criteria
 
-  All conceptual pieces of a Step can be modeled:
-    1. the step's keyword
-    2. the text of the step
-    3. the step's arguments, if any
-    4. the step's associated block, if any
-    5. the step's source line
-    6. the step's raw element
+    1. All conceptual pieces of a step can be modeled:
+      - the step's keyword
+      - the text of the step
+      - the step's arguments, if any
+      - the step's associated block, if any
+      - the step's source line
+      - the step's raw element
+
+    2. Steps can be outputted in a convenient form
 
 
   Background: Test file setup.
@@ -68,8 +70,11 @@ Feature: Step elements can be modeled.
     And step "3" has a "table"
     And step "4" has no block
 
+  Scenario: Convenient output of a step
+    Then the step has convenient output
+
   Scenario Outline: Step models pass all other specifications
-  Exact specifications detailing the API for Step models.
+  Exact specifications detailing the API for step models.
     Given that there are "<additional specifications>" detailing models
     When the corresponding specifications are run
     Then all of those specifications are met

data/features/modeling/step_output.feature

@@ -0,0 +1,52 @@
+Feature: Outputting step elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a step without a block
+    Given a step element based on the following gherkin:
+    """
+    * a step
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    * a step
+    """
+
+  Scenario: Output of a step with a doc string
+    Given a step element based on the following gherkin:
+    """
+    * a step
+    \"\"\"
+    Some text
+
+      some more text
+    \"\"\"
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    * a step
+      \"\"\"
+      Some text
+      
+        some more text
+      \"\"\"
+    """
+
+  Scenario: Output of a step with a table
+    Given a step element based on the following gherkin:
+    """
+    * a step
+    |value1|
+    |value2|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    * a step
+      | value1 |
+      | value2 |
+    """

data/features/modeling/table_modeling.feature

@@ -3,9 +3,11 @@ Feature: Table elements can be modeled.
 
   Acceptance criteria
 
-  All conceptual pieces of a Table can be modeled:
-    1. the table's contents
-    2. the table's raw element
+    1. All conceptual pieces of a table can be modeled:
+      - the table's contents
+      - the table's raw element
+
+    2. Tables can be outputted in a convenient form
 
 
   Background: Test file setup.
@@ -35,8 +37,11 @@ Feature: Table elements can be modeled.
   Scenario: The raw table element is modeled.
     Then the table correctly stores its underlying implementation
 
+  Scenario: Convenient output of a table
+    Then the table has convenient output
+
   Scenario Outline: Table models pass all other specifications
-  Exact specifications detailing the API for Table String models.
+  Exact specifications detailing the API for table models.
     Given that there are "<additional specifications>" detailing models
     When the corresponding specifications are run
     Then all of those specifications are met

data/features/modeling/table_output.feature

@@ -0,0 +1,42 @@
+Feature: Outputting table elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a table that has one row
+    Given a table element based on the following gherkin:
+    """
+    |value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value |
+    """
+
+  Scenario: Output of a table that has multiple rows
+    Given a table element based on the following gherkin:
+    """
+    |value1|
+    |value2|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value1 |
+    | value2 |
+    """
+
+  Scenario: Whitespace buffers are based on the longest value in a column
+    Given a table element based on the following gherkin:
+    """
+    |value|x|
+    |y|another_value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value | x             |
+    | y     | another_value |
+    """

data/features/modeling/table_row_modeling.feature

@@ -3,10 +3,12 @@ Feature: Table Row elements can be modeled.
 
   Acceptance criteria
 
-  All conceptual pieces of a table row can be modeled:
-    1. the row's source line
-    2. the row's cells
-    3. the row's raw element
+    1. All conceptual pieces of a table row can be modeled:
+      - the row's source line
+      - the row's cells
+      - the row's raw element
+
+    2. Rows can be outputted in a convenient form
 
 
   Background: Test file setup.
@@ -50,6 +52,9 @@ Feature: Table Row elements can be modeled.
     And step "2" table row "2" cells are as follows:
       | value 2 |
 
+  Scenario: Convenient output of a table row
+    Then the table row has convenient output
+
   Scenario Outline: Table row models pass all other specifications
   Exact specifications detailing the API for table table row models.
     Given that there are "<additional specifications>" detailing models

data/features/modeling/table_row_output.feature

@@ -0,0 +1,27 @@
+Feature: Outputting table row elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a table row that has one cell
+    Given a table row element based on the following gherkin:
+    """
+    |value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value |
+    """
+
+  Scenario: Output of a table row that has multiple cells
+    Given a table row element based on the following gherkin:
+    """
+    |value|another_value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value | another_value |
+    """

data/features/modeling/tag_modeling.feature

@@ -3,10 +3,12 @@ Feature: Tag elements can be modeled.
 
   Acceptance criteria
 
-  All conceptual pieces of a Tag can be modeled:
-    1. the tag's name
-    2. the tags's source line
-    3. the tags's raw element
+    1. All conceptual pieces of a tag can be modeled:
+      - the tag's name
+      - the tags's source line
+      - the tags's raw element
+
+    2. Features can be outputted in a convenient form
 
 
   Background: Test file setup.
@@ -41,8 +43,11 @@ Feature: Tag elements can be modeled.
     And the test tag name is "@outline_tag"
     And the example tag name is "@example_tag"
 
+  Scenario: Convenient output of a tag
+    Then the tag has convenient output
+
   Scenario Outline: Tag models pass all other specifications
-  Exact specifications detailing the API for Tag models.
+  Exact specifications detailing the API for tag models.
     Given that there are "<additional specifications>" detailing models
     When the corresponding specifications are run
     Then all of those specifications are met

data/features/modeling/tag_output.feature

@@ -0,0 +1,16 @@
+Feature: Outputting tag elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a tag that has a name
+    Given a tag element based on the following gherkin:
+    """
+    @some_tag
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    @some_tag
+    """

data/features/step_definitions/action_steps.rb

@@ -0,0 +1,3 @@
+When(/^it is outputted$/) do
+  @output = @element.to_s
+end

data/features/step_definitions/background_steps.rb

@@ -10,12 +10,16 @@ Then /^the(?: feature "([^"]*)")? background is found to have the following prop
   end
 end
 
-Then /^the(?: feature "([^"]*)")? background's descriptive lines are as follows:$/ do |file, lines|
+Then /^the(?: feature "([^"]*)")? background has the following description:/ do |file, text|
   file ||= 1
-  expected_description = lines.raw.flatten
-  actual_description = @parsed_files[file - 1].feature.background.description
 
-  actual_description.should == expected_description
+  expected = text
+
+  new_description = @parsed_files[file - 1].feature.background.description_text
+  old_description = @parsed_files[file - 1].feature.background.description
+
+  new_description.should == expected
+  old_description.should == remove_whitespace(expected)
 end
 
 Then /^the(?: feature "([^"]*)")? background's steps are as follows:$/ do |file, steps|
@@ -66,3 +70,12 @@ Then(/^the(?: feature "([^"]*)")? background correctly stores its underlying imp
 
   assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
+
+Given(/^a background element based on the following gherkin:$/) do |background_text|
+  @element = CucumberAnalytics::Background.new(background_text)
+end
+
+Then /^the background has convenient output$/ do
+  @parsed_files.first.feature.background.method(:to_s).owner.should == CucumberAnalytics::Background
+end
+

data/features/step_definitions/directory_steps.rb

@@ -39,3 +39,14 @@ When /^(?:the )?directory(?: "([^"]*)")? has no directories$/ do |directory|
 
   assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
 end
+
+Given(/^a directory element based on "([^"]*)"$/) do |directory_name|
+  directory_path = "#{@default_file_directory}/#{directory_name}"
+  FileUtils.mkdir(directory_path) unless File.exists?(directory_path)
+
+  @element = CucumberAnalytics::Directory.new(directory_path)
+end
+
+Then(/^the directory has convenient output$/) do
+  @parsed_directories.first.method(:to_s).owner.should == CucumberAnalytics::Directory
+end

data/features/step_definitions/doc_string_steps.rb

@@ -25,17 +25,9 @@ Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"
   test ||= 1
   step ||= 1
 
-  expected = contents.raw.flatten.collect do |cell_value|
-    if cell_value.start_with? "'"
-      cell_value.slice(1..cell_value.length - 2)
-    else
-      cell_value
-    end
-  end
-
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents_text.should == contents
+  # Remove once Array contents is no longer supported
+  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents.should == contents.split("\n", -1)
 end
 
 Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string contents are empty$/ do |file, test, step|
@@ -43,10 +35,9 @@ Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"
   test ||= 1
   step ||= 1
 
-  expected = []
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  #todo Remove once Array contents is no longer supported
+  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents.should be_empty
+  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents_text.should be_empty
 end
 
 Then(/^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string correctly stores its underlying implementation$/) do |file, test, step|
@@ -58,3 +49,15 @@ Then(/^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"
 
   raw_element.has_key?('content_type').should be_true
 end
+
+Then(/^the doc string has convenient output$/) do
+  @parsed_files.first.feature.tests.first.steps.first.block.method(:to_s).owner.should == CucumberAnalytics::DocString
+end
+
+Given(/^a doc string element based on the following gherkin:$/) do |doc_string_text|
+  @element = CucumberAnalytics::DocString.new(doc_string_text)
+end
+
+Given(/^a doc string element based on the string "(.*)"$/) do |string|
+  @element = CucumberAnalytics::DocString.new(string.gsub('\n', "\n"))
+end

data/features/step_definitions/feature_file_steps.rb

@@ -27,4 +27,15 @@ When /^(?:the )?file(?: "([^"]*)")? has no features$/ do |file|
   file ||= 1
 
   assert @parsed_files[file - 1].feature.nil?
-end
+end
+
+Then(/^the feature file has convenient output$/) do
+  @parsed_files.first.method(:to_s).owner.should == CucumberAnalytics::FeatureFile
+end
+
+Given(/^a feature file element based on "([^"]*)"$/) do |file_name|
+  file_path = "#{@default_file_directory}/#{file_name}"
+  File.open(file_path, 'w') { |file| file.puts "Feature:" } unless File.exists?(file_path)
+
+  @element = CucumberAnalytics::FeatureFile.new(file_path)
+end

data/features/step_definitions/feature_steps.rb

@@ -10,11 +10,12 @@ Then /^(?:the )?feature(?: "([^"]*)")? is found to have the following properties
   end
 end
 
-Then /^the descriptive lines of feature "([^"]*)" are as follows:$/ do |file, lines|
-  expected = lines.raw.flatten
-  actual = @parsed_files[file - 1].feature.description
+Then /^(?:the )?feature "([^"]*)" has the following description:$/ do |file, text|
+  new_description = @parsed_files[file - 1].feature.description_text
+  old_description = @parsed_files[file - 1].feature.description
 
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  new_description.should == text
+  old_description.should == remove_whitespace(text)
 end
 
 Then /^feature "([^"]*)" is found to have the following tags:$/ do |file, expected_tags|
@@ -24,8 +25,9 @@ Then /^feature "([^"]*)" is found to have the following tags:$/ do |file, expect
   @parsed_files[file - 1].feature.tag_elements.collect { |tag| tag.name }.should == expected_tags
 end
 
-Then /^feature "([^"]*)" has no descriptive lines$/ do |file|
-  assert @parsed_files[file - 1].feature.description == []
+Then /^feature "([^"]*)" has no description$/ do |file|
+  @parsed_files[file - 1].feature.description_text.should == ''
+  @parsed_files[file - 1].feature.description.should == []
 end
 
 Then /^feature "([^"]*)" has no tags$/ do |file|
@@ -77,3 +79,18 @@ Then /^(?:the )?feature(?: "([^"]*)")? correctly stores its underlying implement
 
   raw_element.has_key?('elements').should be_true
 end
+
+Then(/^the feature has convenient output$/) do
+  @parsed_files.first.feature.method(:to_s).owner.should == CucumberAnalytics::Feature
+end
+
+Given(/^a feature element based on the following gherkin:$/) do |feature_text|
+  @element = CucumberAnalytics::Feature.new(feature_text)
+end
+
+def remove_whitespace(text)
+  stripped_text = text.split("\n").collect { |line| line.strip }
+  stripped_text.delete('')
+  
+  stripped_text
+end

data/features/step_definitions/outline_steps.rb

@@ -16,7 +16,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   properties = properties.rows_hash
 
   properties.each do |property, value|
-    assert value == @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].send(property.to_sym).to_s
+    @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].send(property.to_sym).to_s.should == value
   end
 end
 
@@ -36,14 +36,28 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   end
 end
 
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? descriptive lines are as follows:$/ do |file, test, example, lines|
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? has the following description:$/ do |file, test, example, text|
   file ||= 1
   test ||= 1
   example ||= 1
 
-  lines = lines.raw.flatten
+  new_description = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].description_text
+  old_description = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].description
 
-  assert @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].description == lines
+  new_description.should == text
+  old_description.should == remove_whitespace(text)
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? has no description$/ do |file, test, example|
+  file ||= 1
+  test ||= 1
+  example ||= 1
+
+  new_description = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].description_text
+  old_description = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].description
+
+  new_description.should == ''
+  old_description.should == []
 end
 
 Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? is found to have the following tags:$/ do |file, test, example, expected_tags|
@@ -86,9 +100,13 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   example = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1]
 
   expected = rows.collect { |row| row.split(',') }
-  actual = example.row_elements[1..example.row_elements.count].collect { |row| row.cells }
 
+  actual = example.row_elements[1..example.row_elements.count].collect { |row| row.cells }
   assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+
+  # todo - remove once Hash rows are no longer supported
+  actual = example.rows.collect { |row| example.parameters.collect { |parameter| row[parameter] } }
+  assert(actual == expected, "Expected: #{expected.inspect}\n but was: #{actual.inspect}")
 end
 
 When /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? has the following rows added to it:$/ do |file, test, example, rows|
@@ -163,10 +181,9 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
 
   example = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1]
 
-  expected = []
-  actual = example.row_elements[1..example.row_elements.count]
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  example.row_elements[1..example.row_elements.count].should be_empty
+  #todo - remove once Hash rows are no longer supported
+  example.rows.should be_empty
 end
 
 Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^"]*)")? row(?: "([^"]*)")? correctly stores its underlying implementation$/ do |file, test, example, row|
@@ -189,3 +206,47 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
 
   raw_element.has_key?('rows').should be_true
 end
+
+Then(/^the row has convenient output$/) do
+  @parsed_files.first.feature.tests.first.examples.first.row_elements.first.method(:to_s).owner.should == CucumberAnalytics::Row
+end
+
+Given(/^a row element based on the following gherkin:$/) do |row_text|
+  @element = CucumberAnalytics::Row.new(row_text)
+end
+
+Given(/^a row element$/) do
+  @element = CucumberAnalytics::Row.new
+end
+
+When(/^the row element has no cells$/) do
+  @element.cells = []
+end
+
+Then(/^the example block has convenient output$/) do
+  @parsed_files.first.feature.tests.first.examples.first.method(:to_s).owner.should == CucumberAnalytics::Example
+end
+
+Given(/^an example element based on the following gherkin:$/) do |example_text|
+  @element = CucumberAnalytics::Example.new(example_text)
+end
+
+Given(/^an example element$/) do
+  @element = CucumberAnalytics::Example.new
+end
+
+When(/^the example element has no parameters or rows$/) do
+  @element.parameters = []
+
+  #todo - remove once Hash rows are no longer supported
+  @element.rows = []
+  @element.row_elements = []
+end
+
+Then(/^the outline has convenient output$/) do
+  @parsed_files.first.feature.tests.first.method(:to_s).owner.should == CucumberAnalytics::Outline
+end
+
+Given(/^an outline element based on the following gherkin:$/) do |outline_text|
+  @element = CucumberAnalytics::Outline.new(outline_text)
+end