cuke_modeler 0.0.1

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

@@ -0,0 +1,58 @@
+Feature: Tag elements can be modeled.
+
+
+  Acceptance criteria
+
+    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.
+    Given the following feature file:
+    """
+    @feature_tag
+    Feature:
+
+      @outline_tag
+      Scenario Outline:
+        * a step
+
+      @example_tag
+      Examples:
+        | a param |
+    """
+    When the file is read
+
+
+  Scenario: The raw tag element is modeled.
+    Then the feature tag correctly stores its underlying implementation
+    And the test tag correctly stores its underlying implementation
+    And the example tag correctly stores its underlying implementation
+
+  Scenario: The tag's source line is modeled.
+    Then the feature tag source line "1"
+    And the test tag source line "4"
+    And the example tag source line "8"
+
+  Scenario: The tag name is modeled.
+    Then the feature tag name is "@feature_tag"
+    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
+
+  @redundant
+  Scenario Outline: Tag models pass all other specifications
+  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
+  Examples:
+    | additional specifications |
+    | tag_unit_spec.rb          |
+    | tag_integration_spec.rb   |

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

@@ -0,0 +1,81 @@
+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|
+    expected = expected_value
+    actual = @parsed_files[file - 1].feature.background.send(property.to_sym).to_s
+
+    actual.should == expected
+  end
+end
+
+Then /^the(?: feature "([^"]*)")? background has the following description:/ do |file, text|
+  file ||= 1
+
+  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|
+  file ||= 1
+
+  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.base
+    end
+  end
+
+  expected = steps
+  actual = actual_steps.flatten
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+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
+
+
+Then(/^the(?: feature "([^"]*)")? background correctly stores its underlying implementation$/) do |file|
+  file ||= 1
+
+  raw_element = @parsed_files[file - 1].feature.background.raw_element
+
+  expected = 'Background'
+  actual = raw_element['keyword']
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Given(/^a background element based on the following gherkin:$/) do |background_text|
+  @element = CukeModeler::Background.new(background_text)
+end
+
+Then /^the background has convenient output$/ do
+  @parsed_files.first.feature.background.method(:to_s).owner.should == CukeModeler::Background
+end
+

data/features/step_definitions/directory_steps.rb

@@ -0,0 +1,52 @@
+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
+
+    expected = expected_value
+    actual = @parsed_directories[directory - 1].send(property.to_sym).to_s
+
+    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  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
+
+When /^(?:the )?directory(?: "([^"]*)")? directories are as follows:$/ do |directory, directories|
+  directory ||= 1
+
+  expected = directories.raw.flatten.sort
+  actual = @parsed_directories[directory - 1].directories.collect { |sub_directory| sub_directory.name }
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+When /^(?:the )?directory(?: "([^"]*)")? has no directories$/ do |directory|
+  directory ||= 1
+
+  expected = []
+  actual = @parsed_directories[directory - 1].directories
+
+  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 = CukeModeler::Directory.new(directory_path)
+end
+
+Then(/^the directory has convenient output$/) do
+  @parsed_directories.first.method(:to_s).owner.should == CukeModeler::Directory
+end

data/features/step_definitions/doc_string_steps.rb

@@ -0,0 +1,63 @@
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string content type is "([^"]*)"$/ do |file, test, step, type|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = type
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.content_type
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string has no content type$/ do |file, test, step|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  expected = nil
+  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.content_type
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string has the following contents:$/ do |file, test, step, contents|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  @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|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  #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|
+  file ||= 1
+  test ||= 1
+  step ||= 1
+
+  raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.raw_element
+
+  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 == CukeModeler::DocString
+end
+
+Given(/^a doc string element based on the following gherkin:$/) do |doc_string_text|
+  @element = CukeModeler::DocString.new(doc_string_text)
+end
+
+Given(/^a doc string element based on the string "(.*)"$/) do |string|
+  @element = CukeModeler::DocString.new(string.gsub('\n', "\n"))
+end

data/features/step_definitions/feature_file_steps.rb

@@ -0,0 +1,41 @@
+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
+
+    expected = expected_value
+    actual = @parsed_files[file - 1].send(property.to_sym).to_s
+
+    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  end
+end
+
+When /^(?:the )?file(?: "([^"]*)")? features are as follows:$/ do |file, feature|
+  file ||= 1
+
+  expected = feature.raw.flatten.first
+  actual = @parsed_files[file - 1].feature.name
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+When /^(?:the )?file(?: "([^"]*)")? has no features$/ do |file|
+  file ||= 1
+
+  assert @parsed_files[file - 1].feature.nil?
+end
+
+Then(/^the feature file has convenient output$/) do
+  @parsed_files.first.method(:to_s).owner.should == CukeModeler::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 = CukeModeler::FeatureFile.new(file_path)
+end

data/features/step_definitions/feature_steps.rb

@@ -0,0 +1,96 @@
+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|
+    expected = expected_value
+    actual = @parsed_files[file - 1].feature.send(property.to_sym).to_s
+
+    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+  end
+end
+
+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
+
+  new_description.should == text
+  old_description.should == remove_whitespace(text)
+end
+
+Then /^feature "([^"]*)" is found to have the following tags:$/ do |file, expected_tags|
+  expected_tags = expected_tags.raw.flatten
+
+  @parsed_files[file - 1].feature.tags.should == expected_tags
+  @parsed_files[file - 1].feature.tag_elements.collect { |tag| tag.name }.should == expected_tags
+end
+
+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|
+  assert @parsed_files[file - 1].feature.tags == []
+  assert @parsed_files[file - 1].feature.tag_elements.collect { |tag| tag.name } == []
+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 }
+
+  expected = outlines.raw.flatten.sort
+  actual = actual_outlines.flatten.sort
+
+  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
+end
+
+When /^(?:the )?feature(?: "([^"]*)")? background is as follows:$/ do |file, background|
+  file ||= 1
+
+  @parsed_files[file - 1].feature.background.name.should == 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
+
+Then /^(?:the )?feature(?: "([^"]*)")? correctly stores its underlying implementation$/ do |file|
+  file ||= 1
+
+  raw_element = @parsed_files[file - 1].feature.raw_element
+
+  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 == CukeModeler::Feature
+end
+
+Given(/^a feature element based on the following gherkin:$/) do |feature_text|
+  @element = CukeModeler::Feature.new(feature_text)
+end
+
+def remove_whitespace(text)
+  stripped_text = text.split("\n").collect { |line| line.strip }
+  stripped_text.delete('')
+
+  stripped_text
+end