active_cucumber 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b74fd70bd52ca80c98362537b7412860f8da8d04
-  data.tar.gz: 56ec6ca577595a1d25b51f91eacea3264e48cf15
+  metadata.gz: cd6e427a1ea5dd697035f91e1344e7dbfe0f8717
+  data.tar.gz: 0998293ca8816de728f5f1b5419e350ac42f712c
 SHA512:
-  metadata.gz: f1a7c9599fb559349b1b7b4f2ffc4ecebfe6f3100f10a8c33b872dafa8e8be46a80afdc1efcbbe0683d8938f8404c8caaf9876cc8a4f4738fae9425cc957df4c
-  data.tar.gz: bd49642ca5cd23485265c6a548345e348f5fcbdcf2cdb5da94625e056d169791e89999340a1d00659407ec75829d2c13772b6038638050d3d0b9c30f593f79d8
+  metadata.gz: 0c2ce7cc37de5e7bd600080238d73f8c10f7db99b623db4a51208d7cef6ea66697de28b814830d732df24ea1608f3cb7b15b06e313edf7a158b6c031a4bd5c78
+  data.tar.gz: 12bad9a4a815ba38efefed654a9175cf276317d6aea7c9f658a9e7c45db9fe4c9cfea613a6145338ac164f28c4f78b8bd9b44e879ae5a2022bde47e3018f36bc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_cucumber (0.0.3)
+    active_cucumber (0.0.4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,8 +1,101 @@
 # ActiveCucumber [![Circle CI](https://circleci.com/gh/Originate/active_cucumber.svg?style=shield)](https://circleci.com/gh/Originate/active_cucumber)
 
-High-level Cucumber helpers for testing
+High-level Cucumber helpers for [creating](#creating-database-records)
+and [verifying](#verifying-database-records)
 [ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html)-based
-database applications using Cucumber tables.
+database entries using Cucumber tables.
+
+
+## Creating database records
+
+Creating simple fields works out of the box.
+Let's assume we have an application that stores TV shows and their episodes,
+and our tests contain this Cucumber table:
+
+```cucumber
+Given the episodes:
+  | NAME                  | YEAR |
+  | Encounter at Farpoint | 1987 |
+  | All Good Things       | 1994 |
+```
+
+Implementing this step looks like:
+
+```ruby
+Given(/^the episodes:$/) do |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:
+
+```cucumber
+Given the episodes:
+  | SERIES        | NAME                  |
+  | Star Trek TNG | Encounter at Farpoint |
+  | 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:
+
+```ruby
+class EpisodeCreator < ActiveCucumber::Creator
+
+  def value_for_series series_name
+    Series.find_by(name: series_name) || FactoryGirl.create(:series, name: series_name)
+  end
+
+end
+```
+
+ActiveCucumber automatically uses creator classes that follow the given naming schema:
+* name is `<class name>Creator`
+* method names are `value_for_<attribute name>`
+
+
+### Other columns
+
+Cucumber tables can contain columns that provide other test data,
+and don't correspond to attributes on the created object.
+
+```cucumber
+Given the episodes:
+  | GENRE           | SERIES              | NAME                    |
+  | Science Fiction | Star Trek TNG       | Encounter at Farpoint   |
+  | Comedy          | The Big Bang Theory | The Big Bran Hypothesis |
+```
+
+A `Genre` has many series, and a series belongs to a genre.
+Episodes are not directly associated with genres.
+
+```ruby
+class EpisodeCreator < ActiveCucumber::Creator
+
+  def value_for_genre genre_name
+    @genre = Genre.find_by(name: genre_name) || FactoryGirl.create(:genre, name: genre_name)
+    delete :genre
+  end
+
+  def value_for_show show_name
+    Show.find_by(name: show_name) || FactoryGirl.create(:show, name: show_name, genre: @genre)
+  end
+
+end
+```
+
+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.
 
 
 ## Verifying database records

data/active_cucumber.gemspec

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name          = 'active_cucumber'
-  s.version       = '0.0.3'
+  s.version       = '0.0.4'
   s.authors       = ['Kevin Goslar']
   s.email         = ['kevin.goslar@gmail.com']
   s.summary       = %s(ActiveRecord tools for Cucumber)

data/features/active_cucumber/create_many.feature

@@ -30,6 +30,20 @@ Feature: ActiveCucumber.create_many
     And the database contains the show "Star Trek TNG"
 
 
+  Scenario: creating associated objects that depend on other associated objects
+    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       |
+    Then the database contains the shows:
+      | GENRE           | NAME          |
+      | Science Fiction | Star Trek TNG |
+    And the database contains the episodes:
+      | SHOW          | NAME                  |
+      | Star Trek TNG | Encounter at Farpoint |
+      | Star Trek TNG | All Good Things       |
+
+
   Scenario: complex example
     When running "ActiveCucumber.create_many Episode, table" with this table:
       | SHOW          | NAME                  | YEAR |

data/features/active_cucumber/diff_all.feature

@@ -6,7 +6,7 @@ Feature: ActiveCucumber.diff_all!
 
 
   Background:
-    Given the TV episodes:
+    Given the episodes:
       | SHOW          | NAME                  | YEAR |
       | Star Trek TNG | Encounter at Farpoint | 1987 |
       | Star Trek TNG | All Good Things       | 1994 |

data/features/active_cucumber/diff_one.feature

@@ -6,33 +6,33 @@ Feature: ActiveCucumber.diff_one!
 
 
   Background:
-    Given the TV episode:
+    Given the episode:
       | SHOW | Star Trek TNG   |
       | NAME | All Good Things |
       | YEAR | 1994            |
 
 
   Scenario: verifying string fields
-    When running "ActiveCucumber.diff_one! @episode, table" with this table:
+    When running "ActiveCucumber.diff_one! @created_episode, table" with this table:
       | NAME | All Good Things |
     Then the test passes
 
 
   Scenario: verifying non-string fields
-    When running "ActiveCucumber.diff_one! @episode, table" with this table:
+    When running "ActiveCucumber.diff_one! @created_episode, table" with this table:
       | YEAR | 1994            |
     Then the test passes
 
 
   Scenario: verifying associated fields
-    When running "ActiveCucumber.diff_one! @episode, table" with this table:
+    When running "ActiveCucumber.diff_one! @created_episode, table" with this table:
       | SHOW | Star Trek TNG   |
       | NAME | All Good Things |
     Then the test passes
 
 
   Scenario: complete table match
-    When running "ActiveCucumber.diff_one! @episode, table" with this table:
+    When running "ActiveCucumber.diff_one! @created_episode, table" with this table:
       | SHOW | Star Trek TNG   |
       | NAME | All Good Things |
       | YEAR | 1994            |
@@ -40,7 +40,7 @@ Feature: ActiveCucumber.diff_one!
 
 
   Scenario: providing a non-existing field
-    When running "ActiveCucumber.diff_one! @episode, table" with this table:
+    When running "ActiveCucumber.diff_one! @created_episode, table" with this table:
       | NAME   | All Good Things |
       | FOOBAR | 1994            |
     Then the test fails
@@ -48,7 +48,7 @@ Feature: ActiveCucumber.diff_one!
 
 
   Scenario: mismatching data in a table cell
-    When running "ActiveCucumber.diff_one! @episode, table" with this table:
+    When running "ActiveCucumber.diff_one! @created_episode, table" with this table:
       | SHOW | Star Trek TOS   |
       | NAME | All Good Things |
     Then the test fails

data/features/step_definitions/steps.rb

@@ -1,15 +1,12 @@
-Given(/^the TV episode:$/) do |table|
-  data = ActiveCucumber.vertical_table table
-  show = Show.find_or_create_by name: data['SHOW']
-  @episode = show.episodes.create name: data['NAME'], year: data['YEAR']
-end
-
-
-Given(/^the TV episodes:$/) do |table|
-  ActiveCucumber.horizontal_table(table).each do |row|
-    show = Show.find_or_create_by name: row['SHOW']
-    show.episodes.create name: row['NAME'], year: row['YEAR']
-  end
+Given(/^the (\w+):$/) do |class_name, table|
+  singular = class_name.singularize
+  clazz = singular.humanize.constantize
+  created_data = if (class_name == singular)
+                   ActiveCucumber.create_one clazz, table
+                 else
+                   ActiveCucumber.create_many clazz, table
+                 end
+  instance_variable_set "@created_#{class_name}", created_data
 end
 
 
@@ -38,6 +35,11 @@ Then(/^the database contains the given episodes$/) do
 end
 
 
+Then(/^the database contains the (\w+):$/) do |class_name, table|
+  ActiveCucumber.diff_all! class_name.humanize.singularize.constantize, table
+end
+
+
 Then(/^the database contains the shows? (.+)$/) do |show_names|
   expect(Show.all.map(&:name)).to match Kappamaki.from_sentence show_names
 end
@@ -46,8 +48,9 @@ end
 Then(/^the test (passes|fails)$/) do |expected_result|
   @error_checked = true
   if expected_result == 'passes' && @error_happened
-    p @error_message
-    p @exception
+    puts "\n#{@error_message}"
+    puts ''
+    @exception.backtrace.take(5).each { |trace| puts "in #{trace}" }
   end
   expect(@error_happened).to be expected_result != 'passes'
 end

data/features/support/env.rb

@@ -15,13 +15,19 @@ ActiveRecord::Base.establish_connection(
 
 
 ActiveRecord::Schema.define do
+  create_table :genres, force: true do |t|
+    t.string :name
+    t.datetime 'created_at'
+  end
+
   create_table :shows, force: true do |t|
+    t.belongs_to :genre
     t.string :name
     t.datetime 'created_at'
   end
 
   create_table :episodes, force: true do |t|
-    t.belongs_to :show, index: true
+    t.belongs_to :show
     t.string :name
     t.integer :year
     t.datetime 'created_at'
@@ -30,6 +36,10 @@ end
 
 
 FactoryGirl.define do
+  factory :genre do
+    name { Faker::Book.title }
+  end
+
   factory :show do
     name { Faker::Book.title }
   end
@@ -49,5 +59,10 @@ Before do
 end
 
 After do
-  expect(@error_happened).to be false unless @error_checked
+  if @error_happened && !@error_checked
+    puts "\n#{@error_message}"
+    puts ''
+    @exception.backtrace.take(5).each { |trace| puts "in #{trace}" }
+    expect(@error_happened).to be false
+  end
 end

data/features/support/episode.rb

@@ -1,3 +1,3 @@
 class Episode < ActiveRecord::Base
-  belongs_to :show, inverse_of: :episodes, required: true
+  belongs_to :show, required: true
 end

data/features/support/episode_cureator.rb

@@ -1,7 +1,12 @@
-class EpisodeCureator < ActiveCucumber::Cureator
+class EpisodeCreator < ActiveCucumber::Creator
 
   def value_for_show show_name
-    Show.find_by(name: show_name) || FactoryGirl.create(:show, name: show_name)
+    Show.find_by(name: show_name) || FactoryGirl.create(:show, name: show_name, genre: @genre)
+  end
+
+  def value_for_genre genre_name
+    @genre = Genre.find_by(name: genre_name) || FactoryGirl.create(:genre, name: genre_name)
+    delete :genre
   end
 
 end

data/features/support/genre.rb

@@ -0,0 +1,3 @@
+class Genre < ActiveRecord::Base
+  has_many :shows
+end

data/features/support/show.rb

@@ -1,3 +1,4 @@
 class Show < ActiveRecord::Base
-  has_many :episodes, inverse_of: :show
+  belongs_to :genre
+  has_many :episodes
 end

data/features/support/show_cucumberator.rb

@@ -0,0 +1,7 @@
+class ShowCucumberator < ActiveCucumber::Cucumberator
+
+  def value_for_genre
+    genre.name
+  end
+
+end

data/lib/active_cucumber/active_record_builder.rb

@@ -0,0 +1,44 @@
+module ActiveCucumber
+
+  # Creates ActiveRecord entries with data from given Cucumber tables.
+  class ActiveRecordBuilder
+
+    def initialize activerecord_class
+      @clazz = activerecord_class
+      @creator_class = creator_class
+    end
+
+
+    # Creates all entries in the given horizontal table hash
+    def create_many table
+      table.map do |row|
+        create_record row
+      end
+    end
+
+
+    # Creates a new record with the given attributes in the database
+    def create_record attributes
+      creator = @creator_class.new attributes
+      FactoryGirl.create @clazz, creator.factorygirl_attributes
+    end
+
+
+  private
+
+    # Returns the Cucumberator subclass to be used by this Cucumparer instance
+    def creator_class
+      creator_class_name.constantize
+    rescue NameError
+      Creator
+    end
+
+
+    # Returns the name of the Cucumberator subclass to be used by this Cucumparer instance.
+    def creator_class_name
+      "#{@clazz.name}Creator"
+    end
+
+  end
+
+end

data/lib/active_cucumber/creator.rb

@@ -0,0 +1,59 @@
+module ActiveCucumber
+
+  # Converts an attributes hash in Cucumber format
+  # into a hash consumable by FactoryGirl
+  #
+  # Subclasses define methods to convert particular fields.
+  class Creator
+
+    def initialize attributes
+      @attributes = attributes
+    end
+
+    # Returns the FactoryGirl version of this Creator's attributes
+    def factorygirl_attributes
+      symbolize_attributes!
+      @attributes.each do |key, value|
+        next unless respond_to?(method = method_name(key))
+        if (result = send method, value)
+          @attributes[key] = result if @attributes.key? key
+        else
+          @attributes.delete key
+        end
+      end
+    end
+
+
+  private
+
+    def method_missing method_name, *arguments
+      # This is necessary so that a Creator subclass can access
+      # methods of @attributes as if they were its own.
+      @attributes.send method_name, *arguments
+    end
+
+
+    # Returns the name of the value_for method for the given key
+    def method_name key
+      "value_for_#{key}"
+    end
+
+
+    # Converts the key given in Cucumber format into FactoryGirl format
+    def normalized_key key
+      key.downcase.parameterize.underscore.to_sym
+    end
+
+
+    # Makes the keys on @attributes be normalized symbols
+    def symbolize_attributes!
+      @attributes = {}.tap do |result|
+        @attributes.each do |key, value|
+          result[normalized_key key] = value
+        end
+      end
+    end
+
+  end
+
+end

data/lib/active_cucumber.rb

@@ -1,20 +1,23 @@
 require 'active_cucumber/cucumparer'
 require 'active_cucumber/cucumberator'
-require 'active_cucumber/cureator'
+require 'active_cucumber/active_record_builder'
+require 'active_cucumber/creator'
 
 # The main namespace for this gem
 module ActiveCucumber
 
   # Creates entries of the given ActiveRecord class
-  # specified by the given Cucumber table
+  # specified by the given horizontal Cucumber table
   def self.create_many activerecord_class, cucumber_table
-    Cureator.for(activerecord_class).create_records ActiveCucumber.horizontal_table(cucumber_table)
+    builder = ActiveRecordBuilder.new activerecord_class
+    builder.create_many ActiveCucumber.horizontal_table(cucumber_table)
   end
 
   # Creates an entry of the given ActiveRecord class
-  # specified by the given Cucumber table
+  # specified by the given vertical Cucumber table
   def self.create_one activerecord_class, cucumber_table
-    Cureator.for(activerecord_class).create_record ActiveCucumber.vertical_table(cucumber_table)
+    builder = ActiveRecordBuilder.new activerecord_class
+    builder.create_record ActiveCucumber.vertical_table(cucumber_table)
   end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_cucumber
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Kevin Goslar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-22 00:00:00.000000000 Z
+date: 2015-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -220,11 +220,14 @@ files:
 - features/support/episode.rb
 - features/support/episode_cucumberator.rb
 - features/support/episode_cureator.rb
+- features/support/genre.rb
 - features/support/show.rb
+- features/support/show_cucumberator.rb
 - lib/active_cucumber.rb
+- lib/active_cucumber/active_record_builder.rb
+- lib/active_cucumber/creator.rb
 - lib/active_cucumber/cucumberator.rb
 - lib/active_cucumber/cucumparer.rb
-- lib/active_cucumber/cureator.rb
 homepage: https://github.com/Originate/active_cucumber
 licenses:
 - MIT

data/lib/active_cucumber/cureator.rb

@@ -1,86 +0,0 @@
-module ActiveCucumber
-
-  # Creates ActiveRecord entries
-  class Cureator
-
-    # Returns the Cureator instance for the given ActiveRecord class.
-    def self.for activerecord_class
-      cureator_class(activerecord_class).new activerecord_class
-    end
-
-
-    def initialize activerecord_class
-      @clazz = activerecord_class
-    end
-
-
-    # Creates all entries in the given Cucumber table
-    #
-    # Assumes a horizontal Cucumber table.
-    def create_records table
-      table.map do |row|
-        create_record row
-      end
-    end
-
-
-    # Creates a new record in the database,
-    # of the given class, with the given Cucumber-formatted String attributes.
-    def create_record attributes
-      FactoryGirl.create @clazz, factorygirl_row(symbolized_hash(attributes))
-    end
-
-
-  private
-
-    # Returns the Cucumberator subclass to be used by this Cucumparer instance
-    def self.cureator_class activerecord_class
-      cureator_class_name(activerecord_class).constantize
-    rescue NameError
-      Cureator
-    end
-
-
-    # Returns the name of the Cucumberator subclass to be used by this Cucumparer instance.
-    def self.cureator_class_name activerecord_class
-      "#{activerecord_class.name}Cureator"
-    end
-
-
-    # Returns the given row, with values converted to FactoryGirl format
-    #
-    # Assumes the keys of the row are hashes
-    def factorygirl_row row
-      {}.tap do |result|
-        row.each do |key, value|
-          method = method_name key
-          result[key] = respond_to?(method) ? send(method, value) : value
-        end
-      end
-    end
-
-
-    # Returns the name of the value_for method for the given key
-    def method_name key
-      "value_for_#{key}"
-    end
-
-
-    # Converts the key given in Cucumber format into FactoryGirl format
-    def normalized_key key
-      key.downcase.parameterize.underscore
-    end
-
-
-    # Returns a new hash with the keys normalized to symbols
-    def symbolized_hash row
-      {}.tap do |result|
-        row.each do |key, value|
-          result[normalized_key key] = value
-        end
-      end
-    end
-
-  end
-
-end