active_cucumber 1.0.0 → 1.1.0

data/README.md

@@ -1,28 +1,29 @@
-# ActiveCucumber
-[![Circle CI](https://circleci.com/gh/Originate/active_cucumber.svg?style=shield)](https://circleci.com/gh/Originate/active_cucumber) [![Code Climate](https://codeclimate.com/github/Originate/active_cucumber/badges/gpa.svg)](https://codeclimate.com/github/Originate/active_cucumber) [![Dependency Status](https://gemnasium.com/Originate/active_cucumber.svg)](https://gemnasium.com/Originate/active_cucumber) [![Coverage Status](https://coveralls.io/repos/Originate/active_cucumber/badge.svg?branch=kg-coveralls&service=github)](https://coveralls.io/github/Originate/active_cucumber?branch=kg-coveralls)
+[![CI](https://github.com/kevgo/active_cucumber/actions/workflows/ruby.yml/badge.svg)](https://github.com/kevgo/active_cucumber/actions/workflows/ruby.yml)
+[![Coverage Status](https://coveralls.io/repos/kevgo/active_cucumber/badge.svg?branch=kg-coveralls&service=github)](https://coveralls.io/github/kevgo/active_cucumber?branch=kg-coveralls)
 
 High-level Cucumber helpers for performing
 [ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html)-based
 database operations using Cucumber tables in tests.
 
-
 ## Installation
 
-* add `gem 'active_cucumber'` to your Gemfile
-* run `bundle install`
-* make sure you have your [FactoryGirl factories](https://github.com/thoughtbot/factory_girl) set up and loaded
-
+- add `gem 'active_cucumber'` to your Gemfile
+- run `bundle install`
+- make sure you have your
+  [FactoryBot factories](https://github.com/thoughtbot/factory_bot) set up and
+  loaded
 
 ## Creating database records
 
-ActiveCucumber allows to create ActiveRecord objects from data in Cucumber tables using [FactoryGirl factories](https://github.com/thoughtbot/factory_girl).
+ActiveCucumber allows to create ActiveRecord objects from data in Cucumber
+tables using [FactoryBot factories](https://github.com/thoughtbot/factory_bot).
 
 Let's assume we have an application that stores TV shows and their episodes.
 
-
 ### Creating simple fields
 
-Simple fields works out of the box. Let's say our tests contain this Cucumber table:
+Simple fields works out of the box. Let's say our tests contain this Cucumber
+table:
 
 ```cucumber
 Given the episodes:
@@ -35,16 +36,15 @@ ActiveCucumber makes it trivially easy to implement this step:
 
 ```ruby
 Given(/^the episodes:$/) do |table|
-  ActiveCucumber.create_many Episode, table
+  ActiveCucumber.create_many(Episode, table)
 end
 ```
 
-
 ### Transforming values
 
-Let's say our data model also contains a `Series` class
-(an episode belongs to a series, and a series has many episodes).
-We want to also define (and if necessary create) the series that an episode belongs to:
+Let's say our data model also contains a `Series` class (an episode belongs to a
+series, and a series has many episodes). We want to also define (and if
+necessary create) the series that an episode belongs to:
 
 ```cucumber
 Given the episodes:
@@ -53,34 +53,33 @@ Given the episodes:
   | Star Trek TNG | All Good Things       |
 ```
 
-ActiveCucumber doesn't require custom step definitions here.
-To make this work, tell ActiveCucumber how to convert particular Cucumber table fields
-into ActiveRecord attributes via a `Creator` class:
+ActiveCucumber doesn't require custom step definitions here. To make this work,
+tell ActiveCucumber how to convert particular Cucumber table fields into
+ActiveRecord attributes via a `Creator` class:
 
 ```ruby
 class EpisodeCreator < ActiveCucumber::Creator
 
-  def value_for_series series_name
-    Series.find_by(name: series_name) || FactoryGirl.create(:series, name: series_name)
+  def value_for_series(series_name)
+    Series.find_by(name: series_name) || FactoryBot.create(:series, name: series_name)
   end
 
 end
 ```
 
-ActiveCucumber automatically uses classes named `<class name>Creator`
-as creator classes for the respective class.
-This class must have methods named `value_for_<attribute name>`.
-They receive the value of the respective attribute in the Cucumber table (a string),
-and return whatever value should be assigned to that attribute on the ActiveRecord instance.
-
+ActiveCucumber automatically uses classes named `<class name>Creator` as creator
+classes for the respective class. This class must have methods named
+`value_for_<attribute name>`. They receive the value of the respective attribute
+in the Cucumber table (a string), and return whatever value should be assigned
+to that attribute on the ActiveRecord instance.
 
 ### Other columns
 
-Cucumber tables can contain columns that provide other test data,
-and don't correspond to attributes on the created object.
+Cucumber tables can contain columns that provide other test data, and don't
+correspond to attributes on the created object.
 
-For example, let's say series belong to a `Genre` class that specifies
-the genre that the series is in.
+For example, let's say series belong to a `Genre` class that specifies the genre
+that the series is in.
 
 ```cucumber
 Given the episodes:
@@ -91,37 +90,34 @@ Given the episodes:
 
 Implementing this with Creators is simple:
 
-Creators decorate the data structure that
-is sent to FactoryGirl to create the record.
-This means `self` inside creator methods behaves like a Hash
-that is pre-populated with the Cucumber table data.
-You can modify this hash, use other field values,
-add or remove fields,
-or store instance variables to be used later.
+Creators decorate the data structure that is sent to FactoryBot to create the
+record. This means `self` inside creator methods behaves like a Hash that is
+pre-populated with the Cucumber table data. You can modify this hash, use other
+field values, add or remove fields, or store instance variables to be used
+later.
 
 ```ruby
 class EpisodeCreator < ActiveCucumber::Creator
 
-  def value_for_genre genre_name
-    @genre = Genre.find_by(name: genre_name) || FactoryGirl.create(:genre, name: genre_name)
+  def value_for_genre(genre_name)
+    @genre = Genre.find_by(name: genre_name) || FactoryBot.create(:genre, name: genre_name)
     delete :genre
   end
 
-  def value_for_series series_name
-    Series.find_by(name: series_name) || FactoryGirl.create(:series, name: series_name, genre: @genre)
+  def value_for_series(series_name)
+    Series.find_by(name: series_name) || FactoryBot.create(:series, name: series_name, genre: @genre)
   end
 
 end
 ```
 
-
 ### Context values
 
 You can provide extra values to ActiveCucumber that are available as instance
 variables on your creators.
 
-Let's say our system has subscriptions for series, and we want to be able to
-use the currently logged in user in them:
+Let's say our system has subscriptions for series, and we want to be able to use
+the currently logged in user in them:
 
 ```cucumber
 Given the subscriptions:
@@ -129,11 +125,12 @@ Given the subscriptions:
   | me         | Star Trek TNG |
 ```
 
-The currently logged in user can be provided to ActiveCucumber using the `context` parameter:
+The currently logged in user can be provided to ActiveCucumber using the
+`context` parameter:
 
 ```ruby
 Given(/^the subscriptions:$/) do |table|
-  ActiveCucumber.create_many Subscription, table, context: { logged_in_user: @current_user }
+  ActiveCucumber.create_many(Subscription, table, context: { logged_in_user: @current_user })
 end
 ```
 
@@ -142,18 +139,17 @@ In the Creator, the context is available as instance variables:
 ```ruby
 class SubscriptionCreator < ActiveCucumber::Creator
 
-  def value_for_subscriber subscriber_name
+  def value_for_subscriber(subscriber_name)
     subscriber_name == 'me' ? @logged_in_user : subscriber_name
   end
 
 end
 ```
 
-
 ### Retrieving record attributes
 
-If you want to create the database record yourself,
-you can have ActiveCucumber parse a Cucumber table into an attributes hash by calling
+If you want to create the database record yourself, you can have ActiveCucumber
+parse a Cucumber table into an attributes hash by calling
 
 ```ruby
 ActiveCucumber.attributes_for <class>, table
@@ -161,15 +157,11 @@ ActiveCucumber.attributes_for <class>, table
 
 with a vertical Cucumber table.
 
-
 ## Verifying database records
 
-ActiveCucumber allows to compare ActiveRecord objects
-against Cucumber tables,
-with the differences visualized intuitively as a Cucumber table diff.
-Only the attributes provided in the table are compared,
-the ones not listed are ignored.
-
+ActiveCucumber allows to compare ActiveRecord objects against Cucumber tables,
+with the differences visualized intuitively as a Cucumber table diff. Only the
+attributes provided in the table are compared, the ones not listed are ignored.
 
 ### diff_one!
 
@@ -179,9 +171,8 @@ the ones not listed are ignored.
      src="documentation/vertical_diff.png">
 
 `ActiveCucumber.diff_one!` compares the given ActiveRecord entry with the given
-_vertical_ Cucumber table.
-These tables have their headers on the left side, and are used to describe
-a single record in greater detail.
+_vertical_ Cucumber table. These tables have their headers on the left side, and
+are used to describe a single record in greater detail.
 
 ```cucumber
 When loading the last Star Trek TNG episode
@@ -196,11 +187,10 @@ The `Then` step is easy to implement with ActiveCucumber:
 ```ruby
 Then /^it returns this episode:$/ do |table|
   # @episode contains one loaded entry
-  ActiveCucumber.diff_one! @episode, table
+  ActiveCucumber.diff_one!(@episode, table)
 end
 ```
 
-
 ### diff_all!
 
 <img width="431"
@@ -209,9 +199,8 @@ end
      src="documentation/horizontal_diff.png">
 
 `ActiveCucumber.diff_all!` verifies that the given _horizontal_ Cucumber table
-describes all existing database entries of the given class.
-Horizontal Cucumber tables have their headers on top, and define several
-records at once:
+describes all existing database entries of the given class. Horizontal Cucumber
+tables have their headers on top, and define several records at once:
 
 ```cucumber
 When I run the importer script with parameter "count=3"
@@ -226,23 +215,21 @@ The last step would be implemented as:
 
 ```ruby
 Then /^Then the database contains these episodes:$/ do |table|
-  ActiveCucumber.diff_all! Episode, table
+  ActiveCucumber.diff_all!(Episode, table)
 end
 ```
 
 The Cucumber table should list the entries sorted by `created_at` timestamp.
 
-
 ### Cucumberators
 
-ActiveCucumber converts the database records into a data table
-and matches it against the given Cucumber table.
+ActiveCucumber converts the database records into a data table and matches it
+against the given Cucumber table.
 
-By default, all attributes are converted into a String.
-It is possible to customize this conversion step by creating a
-_Cucumberator_ (short for Cucumber Decorator).
-This class decorates an ActiveRecord instance, and defines converters
-for attribute values into the format used in the Cucumber table.
+By default, all attributes are converted into a String. It is possible to
+customize this conversion step by creating a _Cucumberator_ (short for Cucumber
+Decorator). This class decorates an ActiveRecord instance, and defines
+converters for attribute values into the format used in the Cucumber table.
 
 ```ruby
 class EpisodeCucumberator < Cucumberator
@@ -256,5 +243,5 @@ class EpisodeCucumberator < Cucumberator
 end
 ```
 
-ActiveCucumber automatically finds and uses these Cucumberators if this
-naming convention is followed.
+ActiveCucumber automatically finds and uses these Cucumberators if this naming
+convention is followed.

data/Rakefile

@@ -1,24 +1,21 @@
-require 'bundler'
-require 'bundler/gem_tasks'
-require 'cucumber'
-require 'cucumber/rake/task'
+# frozen_string_literal: true
 
-Cucumber::Rake::Task.new :features
-task default: %i(lint features)
+require "bundler"
+require "bundler/gem_tasks"
+require "cucumber"
+require "cucumber/rake/task"
 
-desc 'Run linters'
-task lint: %w(lint:ruby lint:cucumber)
+Cucumber::Rake::Task.new :features
+task default: [:lint, :features]
 
-desc 'Run Cucumber linter'
-task 'lint:cucumber' do
-  sh 'bundle exec cucumber_lint'
+desc "Fix all auto-fixable issues"
+task "fix" do
+  sh "bundle exec rubocop -A lib/*.rb lib/**/*.rb active_cucumber.gemspec", verbose: false
+  sh "dprint fmt", verbose: false
 end
 
-desc 'Run Ruby linter'
-task 'lint:ruby' do
-  # NOTE: cannot use "task 'lint:ruby' => [:rubocop]" here,
-  #       because the Heroku toolbelt has issues with JRuby.
-  #       In particular, running "heroku run rake db:migrate"
-  #       fails when JRuby is the active Ruby at this point.
-  sh 'bundle exec rubocop'
+desc "Run linters"
+task "lint" do
+  sh "bundle exec rubocop lib/*.rb lib/**/*.rb active_cucumber.gemspec", verbose: false
+  sh "dprint check", verbose: false
 end

data/active_cucumber.gemspec

@@ -1,32 +1,27 @@
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-Gem::Specification.new do |s|
-  s.name          = 'active_cucumber'
-  s.version       = '1.0.0'
-  s.authors       = ['Kevin Goslar']
-  s.email         = ['kevin.goslar@gmail.com']
-  s.summary       = %s(ActiveRecord tools for Cucumber)
-  s.description   = %s(Tools to compare ActiveRecord entries with Cucumber tables)
-  s.homepage      = 'https://github.com/Originate/active_cucumber'
-  s.license       = 'MIT'
+Gem::Specification.new do |gem|
+  gem.name          = "active_cucumber"
+  gem.version       = "1.1.0"
+  gem.authors       = ["Kevin Goslar"]
+  gem.email         = ["kevin.goslar@gmail.com"]
+  gem.summary       = "ActiveRecord tools for Cucumber"
+  gem.description   = "Tools to compare ActiveRecord entries with Cucumber tables"
+  gem.homepage      = "https://github.com/kevgo/active_cucumber"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.require_paths = ["lib"]
 
-  s.files         = `git ls-files -z`.split("\x0")
-  s.test_files    = Dir['features/*']
-  s.require_paths = ['lib']
+  gem.required_ruby_version = ">= 3.2"
+  gem.metadata["rubygems_mfa_required"] = "true"
 
-  s.add_development_dependency 'activerecord'
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'coveralls'
-  s.add_development_dependency 'cucumber'
-  s.add_development_dependency 'cucumber_lint'
-  s.add_development_dependency 'factory_girl'
-  s.add_development_dependency 'faker'
-  s.add_development_dependency 'kappamaki'
-  s.add_development_dependency 'mortadella'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rubocop'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rspec-collection_matchers'
-  s.add_development_dependency 'sqlite3'
+  # Runtime dependencies
+  gem.add_dependency "activerecord", ">= 6.0"
+  gem.add_dependency "cucumber", ">= 7.0"
+  gem.add_dependency "factory_bot", ">= 5.0"
+  gem.add_dependency "mortadella", ">= 1.0"
 end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --publish-quiet

data/dprint.json

@@ -0,0 +1,11 @@
+{
+  "markdown": {
+    "textWrap": "always"
+  },
+  "yaml": { },
+  "excludes": ["vendor"],
+  "plugins": [
+    "https://plugins.dprint.dev/markdown-0.18.0.wasm",
+    "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.5.0.wasm"
+  ]
+}

data/features/active_cucumber/attributes_for.feature

@@ -1,17 +1,7 @@
 Feature: ActiveCucumber.attributes_for
 
-  As a developer testing my own record create code
-  I want to be able to convert Cucumber tables into attribute hashes
-  So that I can use ActiveCucumber to parse Cucumber tables.
-
-  Rules:
-  - ActiveCucumbe.attributes_for(Class, table) returns the attributes of the given table as a hash
-  - the creator for this class is used to parse attributes in the Cucumber table
-  - related objects are getting created in the database
-
-
   Scenario: data attributes
-    When running "ActiveCucumber.attributes_for Episode, table" with this table:
+    When running "ActiveCucumber.attributes_for(Episode, table)" with this table:
       | NAME | Encounter at Farpoint |
     Then it returns the hash
       """
@@ -24,7 +14,7 @@ Feature: ActiveCucumber.attributes_for
 
 
   Scenario: associated objects are built
-    When running "ActiveCucumber.attributes_for Episode, table" with this table:
+    When running "ActiveCucumber.attributes_for(Episode, table)" with this table:
       | SHOW | Star Trek TNG         |
       | NAME | Encounter at Farpoint |
     Then it returns the hash

data/features/active_cucumber/create_many.feature

@@ -1,12 +1,7 @@
 Feature: ActiveCucumber.create_many
 
-  As a Cucumber user
-  I want to create database records using Cucumber tables
-  So that I can easily and intuitively set up my test environment.
-
-
   Scenario: creating string columns
-    When running "ActiveCucumber.create_many Episode, table" with this table:
+    When running "ActiveCucumber.create_many(Episode, table)" with this table:
       | NAME                  |
       | Encounter at Farpoint |
       | All Good Things       |
@@ -14,7 +9,7 @@ Feature: ActiveCucumber.create_many
 
 
   Scenario: creating integer columns
-    When running "ActiveCucumber.create_many Episode, table" with this table:
+    When running "ActiveCucumber.create_many(Episode, table)" with this table:
       | YEAR |
       | 1987 |
       | 1994 |
@@ -22,7 +17,7 @@ Feature: ActiveCucumber.create_many
 
 
   Scenario: creating associated objects
-    When running "ActiveCucumber.create_many Episode, table" with this table:
+    When running "ActiveCucumber.create_many(Episode, table)" with this table:
       | SHOW          | NAME                  |
       | Star Trek TNG | Encounter at Farpoint |
       | Star Trek TNG | All Good Things       |
@@ -31,7 +26,7 @@ Feature: ActiveCucumber.create_many
 
 
   Scenario: creating associated objects with a nil value
-    When running "ActiveCucumber.create_many Show, table" with this table:
+    When running "ActiveCucumber.create_many(Show, table)" with this table:
       | DIRECTOR         | NAME          |
       |                  | Directionless |
       | Gene Roddenberry | Star Trek TNG |
@@ -40,7 +35,7 @@ Feature: ActiveCucumber.create_many
 
 
   Scenario: creating associated objects that depend on other associated objects
-    When running "ActiveCucumber.create_many Episode, table" with this table:
+    When running "ActiveCucumber.create_many(Episode, table)" with this table:
       | GENRE           | SHOW          | NAME                  |
       | Science Fiction | Star Trek TNG | Encounter at Farpoint |
       | Science Fiction | Star Trek TNG | All Good Things       |
@@ -54,7 +49,7 @@ Feature: ActiveCucumber.create_many
 
 
   Scenario: using context values
-    When running "ActiveCucumber.create_many Subscription, table, context: { current_user: 'Q' }" with this table:
+    When running "ActiveCucumber.create_many(Subscription, table, context: { current_user: 'Q' })" with this table:
       | SUBSCRIBER | SHOW          |
       | me         | Star Trek TNG |
     Then the database contains the subscriptions:
@@ -63,10 +58,9 @@ Feature: ActiveCucumber.create_many
 
 
   Scenario: complex example
-    When running "ActiveCucumber.create_many Episode, table" with this table:
+    When running "ActiveCucumber.create_many(Episode, table)" with this table:
       | SHOW          | NAME                  | YEAR |
       | Star Trek TNG | Encounter at Farpoint | 1987 |
       | Star Trek TOS | The Paradise Syndrome | 1968 |
     Then the database contains the given episodes
     And the database contains the shows "Star Trek TNG" and "Star Trek TOS"
-

data/features/active_cucumber/create_one.feature

@@ -1,22 +1,19 @@
 Feature: ActiveCucumber.create_one
 
-  (see ./create_many.feature)
-
-
   Scenario: creating string columns
-    When running "ActiveCucumber.create_one Episode, table" with this table:
+    When running "ActiveCucumber.create_one(Episode, table)" with this table:
       | NAME | Encounter at Farpoint |
     Then the database contains the given episode
 
 
   Scenario: creating integer columns
-    When running "ActiveCucumber.create_one Episode, table" with this table:
+    When running "ActiveCucumber.create_one(Episode, table)" with this table:
       | YEAR | 1994 |
     Then the database contains the given episode
 
 
   Scenario: creating associated objects
-    When running "ActiveCucumber.create_one Episode, table" with this table:
+    When running "ActiveCucumber.create_one(Episode, table)" with this table:
       | SHOW | Star Trek TNG         |
       | NAME | Encounter at Farpoint |
     Then the database contains the given episode
@@ -24,7 +21,7 @@ Feature: ActiveCucumber.create_one
 
 
   Scenario: using context values
-    When running "ActiveCucumber.create_one Subscription, table, context: { current_user: 'Q' }" with this table:
+    When running "ActiveCucumber.create_one(Subscription, table, context: { current_user: 'Q' })" with this table:
       | SUBSCRIBER | me            |
       | SHOW       | Star Trek TNG |
     Then the database contains the subscriptions:
@@ -33,10 +30,9 @@ Feature: ActiveCucumber.create_one
 
 
   Scenario: complex example
-    When running "ActiveCucumber.create_one Episode, table" with this table:
+    When running "ActiveCucumber.create_one(Episode, table)" with this table:
       | SHOW | Star Trek TNG         |
       | NAME | Encounter at Farpoint |
       | YEAR | 1987                  |
     Then the database contains the given episode
     And the database contains the show "Star Trek TNG"
-

data/features/active_cucumber/diff_all/arrays_of_objects.feature

@@ -1,14 +1,5 @@
 Feature: Comparing arrays of ActiveRecord instances
 
-  As a developer having complex database query logic
-  I want to be able to compare against a manually created array of ActiveRecord objects
-  So that I can use ActiveCucumber for a large variety of data sources.
-
-  Rules:
-  - one can give an ActiveRecord class or an array of ActiveRecord instances to ActiveCucumber
-  - ActiveCucumber choses the Cucumperer based on the class of each record
-
-
   Background:
     Given the episodes:
       | NAME                  | YEAR |
@@ -17,7 +8,7 @@ Feature: Comparing arrays of ActiveRecord instances
 
 
   Scenario: comparing all instances of an ActiveRecord class
-    When running "ActiveCucumber.diff_all! Episode, table" with this table:
+    When running "ActiveCucumber.diff_all!(Episode, table)" with this table:
       | NAME                  | YEAR |
       | Encounter at Farpoint | 1987 |
       | All Good Things       | 1994 |
@@ -25,7 +16,7 @@ Feature: Comparing arrays of ActiveRecord instances
 
 
   Scenario: comparing an array of ActiveRecord instances
-    When running "ActiveCucumber.diff_all! [Episode.first, Episode.last], table" with this table:
+    When running "ActiveCucumber.diff_all!([Episode.first, Episode.last], table)" with this table:
       | NAME                  | YEAR |
       | Encounter at Farpoint | 1987 |
       | All Good Things       | 1994 |

data/features/active_cucumber/diff_all/context_values.feature

@@ -1,19 +1,10 @@
 Feature: Using contextual data
 
-  As a developer wanting to use non-database data in my database specs
-  I want to be able to provide contextual data to ActiveCucumber
-  So that I can use it in my specs.
-
-  Rules:
-  - contextual data is provided as an additional parameter containing key-value pairs in calls to ActiveCucumber
-  - all contextual data is made available to Cucumberators as instance variables whose name is the key and value is the value
-
-
   Scenario: using contextual data
     Given the subscriptions:
       | SUBSCRIBER | SHOW          |
       | Q          | Star Trek TNG |
-    When running "ActiveCucumber.diff_all! Subscription, table, context: { current_user: 'Q' }" with this table:
+    When running "ActiveCucumber.diff_all!(Subscription, table, context: { current_user: 'Q' })" with this table:
       | SUBSCRIBER | SHOW          |
       | me         | Star Trek TNG |
     Then the test passes

data/features/active_cucumber/diff_all/converting_data.feature

@@ -1,14 +1,5 @@
 Feature: Comparing different field types
 
-  As a developer testing a relational database
-  I want to verify my database content and associations the same way
-  So that database verifications are intuitive.
-
-  Rules:
-  - the user can define a Cucumberator to define custom Cucumber representations of fields or associated records
-  - if the Cucumberator doesn't define a conversion or is missing altogether, the content is compared as-is
-
-
   Background:
     Given the episodes:
       | SHOW          | NAME                  | YEAR |
@@ -20,14 +11,14 @@ Feature: Comparing different field types
     Given the genres:
       | NAME            |
       | Science Fiction |
-    When running "ActiveCucumber.diff_all! Genre, table" with this table:
+    When running "ActiveCucumber.diff_all!(Genre, table)" with this table:
       | NAME            |
       | Science Fiction |
     Then the test passes
 
 
   Scenario: verifying fields not defined in the Cucumberator
-    When running "ActiveCucumber.diff_all! Episode, table" with this table:
+    When running "ActiveCucumber.diff_all!(Episode, table)" with this table:
       | NAME                  |
       | Encounter at Farpoint |
       | All Good Things       |
@@ -35,7 +26,7 @@ Feature: Comparing different field types
 
 
   Scenario: verifying numeric fields
-    When running "ActiveCucumber.diff_all! Episode, table" with this table:
+    When running "ActiveCucumber.diff_all!(Episode, table)" with this table:
       | YEAR |
       | 1987 |
       | 1994 |
@@ -43,7 +34,7 @@ Feature: Comparing different field types
 
 
   Scenario: verifying associated fields through a Cucumberator
-    When running "ActiveCucumber.diff_all! Episode, table" with this table:
+    When running "ActiveCucumber.diff_all!(Episode, table)" with this table:
       | SHOW          | NAME                  |
       | Star Trek TNG | Encounter at Farpoint |
       | Star Trek TNG | All Good Things       |