cuke_modeler 0.4.1 → 1.0.0

data/features/step_definitions/modeling_steps.rb

@@ -0,0 +1,44 @@
+Given(/^the models provided by CukeModeler/) do
+  @available_model_classes = Array.new.tap do |classes|
+    CukeModeler.constants.each do |constant|
+      if CukeModeler.const_get(constant).is_a?(Class)
+        classes << CukeModeler.const_get(constant) if CukeModeler.const_get(constant).ancestors.include?(CukeModeler::Model)
+      end
+    end
+  end
+end
+
+When(/^the model is output as a string$/) do |code_text|
+  @output = eval(code_text)
+end
+
+And(/^a(?:n)? \w+(?: \w+)? model based on that gherkin$/) do |code_text|
+  code_text.gsub!('<source_text>', "'#{@source_text}'")
+
+  eval(code_text)
+end
+
+Given(/^(?:a|the) (?:directory|feature file) is modeled$/) do |code_text|
+  code_text.gsub!('<path_to>', @default_file_directory)
+
+  eval(code_text)
+end
+
+When(/^the \w+(?: \w+)?'s \w+(?: \w+)? (?:is|are) requested$/) do |code_text|
+  @result = eval(code_text)
+end
+
+Given(/^a model for the following background:$/) do |gherkin_text|
+  @models ||= []
+  @models << CukeModeler::Background.new(gherkin_text)
+end
+
+Given(/^a model for the following scenario:$/) do |gherkin_text|
+  @models ||= []
+  @models << CukeModeler::Scenario.new(gherkin_text)
+end
+
+Given(/^a model for the following outline:$/) do |gherkin_text|
+  @models ||= []
+  @models << CukeModeler::Outline.new(gherkin_text)
+end

data/features/step_definitions/setup_steps.rb

@@ -1,50 +1,28 @@
-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 << CukeModeler::FeatureFile.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
-
-  CukeModeler::World.load_step_file("#{@test_directory}/#{file_name}")
-end
-
-When /^parameter delimiters of "([^"]*)" and "([^"]*)"$/ do |left_delimiter, right_delimiter|
-  CukeModeler::World.left_delimiter = left_delimiter
-  CukeModeler::World.right_delimiter = right_delimiter
-end
-
-Given /^a directory "([^"]*)"$/ do |directory_name|
+Given /^(?:a|the) 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 << CukeModeler::Directory.new(@test_directory)
+And(/^(?:a|the) file "([^"]*)"$/) do |file_name|
+  file_path = "#{@default_file_directory}/#{file_name}"
+
+  # Some versions of Gherkin require feature content to be present in feature files
+  if file_name =~ /\.feature/
+    File.open(file_path, 'w') { |file|
+      file.write('Feature:')
+    }
+  else
+    FileUtils.touch(file_path)
+  end
 end
 
-When /^the following step definition file(?: "([^"]*)")?:$/ do |file_name, file_text|
-  @test_directory ||= @default_file_directory
-  file_name ||= @default_step_file_name
+And(/^the file "([^"]*)":$/) do |file_name, file_text|
+  file_path = "#{@default_file_directory}/#{file_name}"
+
+  File.open(file_path, 'w') { |file| file.write(file_text) }
+end
 
-  File.open("#{@test_directory}/#{file_name}", 'w') { |file|
-    file.write(file_text)
-  }
+Given(/^the following gherkin:$/) do |text|
+  @source_text = text
 end

data/features/step_definitions/step_steps.rb

@@ -1,167 +1,3 @@
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? keyword is "([^"]*)"$/ do |file, test, step, keyword|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = keyword
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].keyword
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? has the following block:$/ do |file, test, step, block|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = block.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.flatten
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? has no block$/ 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
-
-  actual.should == expected
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? text is "([^"]*)"$/ do |file, test, step, text|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = text
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].base
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? arguments are:$/ do |file, test, step, arguments|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = arguments.raw.flatten
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].arguments
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? has no arguments$/ do |file, test, step|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = []
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].arguments
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? has a "([^"]*)"$/ do |file, test, step, type|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  case type
-    when 'doc string'
-      expected = CukeModeler::DocString
-    when 'table'
-      expected = CukeModeler::Table
-    else
-      raise(ArgumentError, "Unknown block type: #{type}")
-  end
-
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.class
-
-  actual.should == expected
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? source line is "([^"]*)"$/ do |file, test, step, line_number|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = line_number.to_i
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].source_line
-
-  actual.should == expected
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? 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].raw_element
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    raw_element.has_key?(:keyword).should be_true
-  else
-    raw_element.has_key?('keyword').should be_true
-  end
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? table row(?: "([^"]*)")? is found to have the following properties:$/ do |file, test, step, row, properties|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-  row ||= 1
-
-  properties = properties.rows_hash
-
-  properties.each do |property, value|
-    expected = value
-    actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.row_elements[row - 1].send(property.to_sym).to_s
-
-    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-  end
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? table row(?: "([^"]*)")? correctly stores its underlying implementation$/ do |file, test, step, row|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-  row ||= 1
-
-  raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.row_elements[row - 1].raw_element
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    raw_element.has_key?(:cells).should be_true
-  else
-    raw_element.has_key?('cells').should be_true
-  end
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)")? table row(?: "([^"]*)")? cells are as follows:$/ do |file, test, step, row, cells|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-  row ||= 1
-
-  expected = cells.raw.flatten
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.row_elements[row - 1].cells
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Given(/^a step element based on the following gherkin:$/) do |step_text|
-  @element = CukeModeler::Step.new(step_text)
-end
-
-Then(/^the step has convenient output$/) do
-  @parsed_files.first.feature.tests.first.steps.first.method(:to_s).owner.should == CukeModeler::Step
+Given(/^a step model based on the following gherkin:$/) do |source_text|
+  @model = CukeModeler::Step.new(source_text)
 end

data/features/step_definitions/table_steps.rb

@@ -1,58 +1 @@
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?table has the following contents:$/ do |file, test, step, contents|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = contents.raw
-
-  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.row_elements.collect { |row| row.cells }.should == expected
-  # todo - remove once #contents is no longer supported
-  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents.should == expected
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?table 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
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    expect(raw_element).to have_key(:rows)
-  else
-    raw_element.is_a?(Array).should be_true
-    raw_element.each { |row| row.has_key?('cells').should be_true }
-  end
-end
-
-Given(/^a table row element$/) do
-  @element = CukeModeler::TableRow.new
-end
-
-When(/^the table row element has no cells$/) do
-  @element.cells = []
-end
-
-Given(/^a table row element based on the following gherkin:$/) do |row_text|
-  @element = CukeModeler::TableRow.new(row_text)
-end
-
-Then(/^the table row has convenient output$/) do
-  @parsed_files.first.feature.tests.first.steps.first.block.row_elements.first.method(:to_s).owner.should == CukeModeler::TableRow
-end
-
-Given(/^a table element$/) do
-  @element = CukeModeler::Table.new
-end
-
-When(/^the table element has no rows$/) do
-  @element.row_elements = []
-end
-
-Then(/^the table has convenient output$/) do
-  @parsed_files.first.feature.tests.first.steps.first.block.method(:to_s).owner.should == CukeModeler::Table
-end
-
-Given(/^a table element based on the following gherkin:$/) do |table_text|
-  @element = CukeModeler::Table.new(table_text)
-end
+# No steps specific to this type of model

data/features/step_definitions/tag_steps.rb

@@ -1,73 +1,3 @@
-Then /^the feature tag correctly stores its underlying implementation$/ do
-  raw_element = @parsed_files.first.feature.tag_elements.first.raw_element
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    raw_element.has_key?(:name).should be_true
-  else
-    raw_element.has_key?('name').should be_true
-  end
-end
-
-When(/^the test tag correctly stores its underlying implementation$/) do
-  raw_element = @parsed_files.first.feature.tests.first.tag_elements.first.raw_element
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    raw_element.has_key?(:name).should be_true
-  else
-    raw_element.has_key?('name').should be_true
-  end
-end
-
-When(/^the example tag correctly stores its underlying implementation$/) do
-  raw_element = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first.raw_element
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    raw_element.has_key?(:name).should be_true
-  else
-    raw_element.has_key?('name').should be_true
-  end
-end
-
-Then(/^the feature tag name is "([^"]*)"$/) do |tag_name|
-  tag = @parsed_files.first.feature.tag_elements.first
-
-  tag.name.should == tag_name
-end
-
-When(/^the test tag name is "([^"]*)"$/) do |tag_name|
-  tag = @parsed_files.first.feature.tests.first.tag_elements.first
-
-  tag.name.should == tag_name
-end
-
-When(/^the example tag name is "([^"]*)"$/) do |tag_name|
-  tag = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first
-
-  tag.name.should == tag_name
-end
-
-Then(/^the feature tag source line "([^"]*)"$/) do |line|
-  tag = @parsed_files.first.feature.tag_elements.first
-
-  tag.source_line.should == line
-end
-
-When(/^the test tag source line "([^"]*)"$/) do |line|
-  tag = @parsed_files.first.feature.tests.first.tag_elements.first
-
-  tag.source_line.should == line
-end
-
-When(/^the example tag source line "([^"]*)"$/) do |line|
-  tag = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first
-
-  tag.source_line.should == line
-end
-
-Then(/^the tag has convenient output$/) do
-  @parsed_files.first.feature.tag_elements.first.method(:to_s).owner.should == CukeModeler::Tag
-end
-
-Given(/^a tag element based on the following gherkin:$/) do |tag_text|
-  @element = CukeModeler::Tag.new(tag_text)
+When(/^all of the \w+'s tags are requested$/) do |code_text|
+  @result = eval(code_text)
 end

data/features/step_definitions/verification_steps.rb

@@ -1,9 +1,157 @@
+Then(/^all of them can be output as text appropriate to the model type$/) do |code_text|
+  @available_model_classes.each do |clazz|
+    code_text.gsub!('<model_class>', clazz.to_s)
+
+    expect(clazz.instance_method(:to_s).owner).to equal(clazz), "#{clazz} does not override #to_s"
+
+    # Make sure that the example code is valid
+    expect { eval(code_text) }.to_not raise_error
+  end
+end
+
 Then(/^the following text is provided:$/) do |expected_text|
-  expected_text.sub!('path_to', @default_file_directory)
+  expected_text.sub!('<path_to>', @default_file_directory)
+
+  expect(@output).to eq(expected_text)
+end
+
+Then(/^all of them can be contained inside of another model$/) do |code_text|
+  @available_model_classes.each do |clazz|
+    code_text.gsub!('<model_class>', clazz.to_s)
+
+    expect(clazz.new).to respond_to(:parent_model)
+
+    # Make sure that the example code is valid
+    expect { eval(code_text) }.to_not raise_error
+  end
+end
+
+And(/^all of them can contain other models$/) do |code_text|
+  @available_model_classes.each do |clazz|
+    code_text.gsub!('<model_class>', clazz.to_s)
+
+    expect(clazz.new).to respond_to(:children)
+
+    # Make sure that the example code is valid
+    expect { eval(code_text) }.to_not raise_error
+  end
+end
+
+Then(/^all of them can be created without further context$/) do |code_text|
+  @available_model_classes.each do |clazz|
+    code_text.gsub!('<model_class>', clazz.to_s)
+
+    expect { clazz.new }.to_not raise_error
+
+    # Make sure that the example code is valid
+    expect { eval(code_text) }.to_not raise_error
+  end
+end
+
+Then(/^the model returns "([^"]*)"$/) do |value|
+  value.gsub!('path_to', @default_file_directory) if value.is_a?(String)
+
+  expect(@result).to eq(value)
+end
+
+Then(/^the model returns$/) do |value|
+  value.gsub!('path_to', @default_file_directory) if value.is_a?(String)
+
+  expect(@result).to eq(value)
+end
+
+Then(/^the model returns models for the following feature files:$/) do |file_names|
+  file_names = file_names.raw.flatten
+
+  expect(@result.collect { |file_model| file_model.name }).to match_array(file_names)
+end
+
+Then(/^the model returns models for the following directories:$/) do |directory_names|
+  directory_names = directory_names.raw.flatten
+
+  expect(@result.collect { |directory_model| directory_model.name }).to match_array(directory_names)
+end
+
+And(/^the output can be used to make an equivalent model$/) do |code_text|
+  @available_model_classes.each do |clazz|
+    code_text.gsub!('<model_class>', clazz.to_s)
+
+    # More specific verification can't be done for this step because every model has a different
+    # populated shape and abstract shape isn't enough to be useful input to the model again.
 
-  @output.should == expected_text
+    # Make sure that the example code is valid
+    expect { eval(code_text) }.to_not raise_error
+  end
 end
 
-Then(/^the text provided is "(.*)"$/) do |text_string|
-  @output.should == text_string.gsub('\n', "\n")
+Then(/^all of them provide access to the parsing data that was used to create them$/) do |code_text|
+  unparsed_models = [CukeModeler::Model, CukeModeler::FeatureFile, CukeModeler::Directory]
+
+  @available_model_classes.each do |clazz|
+    next if unparsed_models.include?(clazz)
+
+    expect(clazz.new).to respond_to(:parsing_data)
+
+    # Make sure that the example code is valid
+    code_text.gsub!('<model_class>', clazz.to_s)
+    code_text.gsub!('<source_text>', '')
+
+    expect { eval(code_text) }.to_not raise_error
+  end
+end
+
+Then(/^the model returns models for the following steps:$/) do |step_names|
+  step_names = step_names.raw.flatten
+
+  expect(@result.collect { |step_model| step_model.text }).to eq(step_names)
+end
+
+Then(/^the model returns models for the following rows:$/) do |rows|
+  rows = rows.raw
+
+  expect(@result.collect { |row_model| row_model.cells.collect { |cell| cell.value } }).to eq(rows)
+end
+
+Then(/^the model returns a model for the following feature:$/) do |feature_name|
+  feature_name = feature_name.raw.flatten.first
+
+  expect(@result.name).to eq(feature_name)
+end
+
+Then(/^the model returns a model for the following table:$/) do |table_rows|
+  table_rows = table_rows.raw
+
+  expect(@result.rows.collect { |row| row.cells.collect { |cell| cell.value } }).to eq(table_rows)
+end
+
+Then(/^the model returns a model for the following doc string:$/) do |string_text|
+  expect(@result.content).to eq(string_text)
+end
+
+Then(/^the model returns a model for the background "([^"]*)"$/) do |background_name|
+  expect(@result.name).to eq(background_name)
+end
+
+Then(/^the model returns models for the following (?:scenario|outline|tag|example)s:$/) do |model_names|
+  model_names = model_names.raw.flatten
+
+  expect(@result.collect { |model| model.name }).to eq(model_names)
+end
+
+Then(/^the model returns models for the following cells:$/) do |model_values|
+  model_values = model_values.raw.flatten
+
+  expect(@result.collect { |model| model.value }).to eq(model_values)
+end
+
+Then(/^all of them are equivalent$/) do
+  expect(@results).to_not include(false)
+end
+
+But(/^none of the models are equivalent with a model for the following scenario:$/) do |gherkin_text|
+  model = CukeModeler::Scenario.new(gherkin_text)
+
+  @models.each do |other_model|
+    expect(model == other_model).to_not be true
+  end
 end