spbtv_pickle 0.5.1

data/lib/pickle/session/parser.rb

@@ -0,0 +1,34 @@
+module Pickle
+  module Session
+    # add ability to parse model names as fields, using a session
+    module Parser
+      def self.included(parser_class)
+        parser_class.alias_method_chain :parse_field, :model
+      end
+
+      attr_accessor :session
+
+      def match_field
+        "(?:\\w+: (?:#{match_model}|#{match_value}))"
+      end
+
+      def parse_field_with_model(field)
+        if session && field =~ /^(\w+): #{capture_model}$/
+          {$1 => session.model!($2)}
+        else
+          parse_field_without_model(field)
+        end
+      end
+
+      def parse_hash(hash)
+        hash.inject({}) do |parsed, (key, val)|
+          if session && val =~ /^#{capture_model}$/
+            parsed.merge(key => session.model($1))
+          else
+            parsed.merge(key => val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pickle/version.rb

@@ -0,0 +1,3 @@
+module Pickle
+  VERSION = "0.5.1"
+end

data/lib/pickle/world.rb

@@ -0,0 +1,14 @@
+require 'pickle'
+
+# auto require for active record, datamapper and mongoid
+require 'pickle/adapters/active_record' if defined?(ActiveRecord::Base)
+require 'pickle/adapters/data_mapper'   if defined?(DataMapper::Resource)
+require 'pickle/adapters/mongoid'       if defined?(Mongoid::Document)
+
+# make cucumber world pickle aware
+World(Pickle::Session)
+
+# shortcuts to regexps for use in step definition regexps
+class << self
+  delegate :capture_model, :capture_fields, :capture_factory, :capture_plural_factory, :capture_predicate, :capture_value, :to => 'Pickle.parser'
+end

data/lib/spbtv_pickle.rb

@@ -0,0 +1 @@
+require_relative 'pickle'

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,31 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(args, options)
+    super(args, options)
+    @generate_email_steps = args.include?('email')
+    @generate_path_steps = args.include?('path')
+  end
+  
+  def manifest
+    record do |m|
+      m.directory File.join('features/step_definitions')
+      m.directory File.join('features/support')
+      
+      current_pickle = File.exists?('features/support/pickle.rb') ? File.read('features/support/pickle.rb') : ''
+      pickle_assigns = {:pickle_path => false, :pickle_email => false}
+      
+      if @generate_path_steps
+        pickle_assigns[:pickle_path] = true
+        m.template 'paths.rb', File.join('features/support', 'paths.rb')
+      end
+      
+      if @generate_email_steps
+        pickle_assigns[:pickle_email] = true
+        m.template 'email_steps.rb', File.join('features/step_definitions', 'email_steps.rb')
+        m.template 'email.rb', File.join('features/support', 'email.rb')
+      end
+
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', 'pickle_steps.rb')      
+      m.template 'pickle.rb', File.join('features/support', 'pickle.rb'), :assigns => pickle_assigns
+    end
+  end
+end

data/rails_generators/pickle/templates/email.rb

@@ -0,0 +1,21 @@
+module EmailHelpers
+  # Maps a name to an email address. Used by email_steps
+
+  def email_for(to)
+    case to
+  
+    # add your own name => email address mappings here
+  
+    when /^#{capture_model}$/
+      model($1).email
+  
+    when /^"(.*)"$/
+      $1
+  
+    else
+      to
+    end
+  end
+end
+
+World(EmailHelpers)

data/rails_generators/pickle/templates/email_steps.rb

@@ -0,0 +1,65 @@
+# this file generated by script/generate pickle email
+#
+# add email mappings in features/support/email.rb
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+
+Before do
+  ActionMailer::Base.deliveries.clear
+end
+
+# Clear the deliveries array, useful if your background sends email that you want to ignore
+Given(/^all emails? (?:have|has) been delivered$/) do
+  ActionMailer::Base.deliveries.clear
+end
+
+Given(/^(\d)+ emails? should be delivered$/) do |count|
+  expect(emails.size).to eq(count.to_i)
+end
+
+When(/^(?:I|they) follow "([^"]*?)" in #{capture_email}$/) do |link, email_ref|
+  visit_in_email(email(email_ref), link)
+end
+
+When(/^(?:I|they) click the first link in #{capture_email}$/) do |email_ref|
+  click_first_link_in_email(email(email_ref))
+end
+
+Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
+  actual = emails("to: \"#{email_for(to)}\"").size
+  expect(actual).to eq(count.to_i), "Expected #{count} emails but encountered #{actual} delivered to #{to}"
+end
+
+Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
+  actual = emails(fields).size
+  expect(actual).to eq(count.to_i), "Expected #{count} emails but encountered #{actual} to be delivered with #{fields}"
+end
+
+Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).not_to be_nil, "Failed to find #{email_ref} delivered to: #{to}"
+end
+
+Then(/^#{capture_email} should not be delivered to (.+)$/) do |email_ref, to|
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).to be_nil, "Unexpectedly found #{email_ref} delivered to: #{to}"
+end
+
+Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|
+  expect(email(email_ref, fields)).not_to be_nil, "Failed to find #{fields} in #{email_ref}"
+end
+
+Then(/^#{capture_email} should contain "(.*)"$/) do |email_ref, text|
+  expect(email(email_ref).body).to match(/#{text}/), "Failed to find \"#{text}\" in #{email_ref}"
+end
+
+Then(/^#{capture_email} should not contain "(.*)"$/) do |email_ref, text|
+  expect(email(email_ref).body).not_to match(/#{text}/), "Unexpectedly found \"#{text}\" in #{email_ref}"
+end
+
+Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
+  expect(email(email_ref).body).to match(/#{path_to(page)}/), "Failed to find link to #{page} in #{email_ref}"
+end
+
+Then(/^show me the emails?$/) do
+  save_and_open_emails
+end

data/rails_generators/pickle/templates/paths.rb

@@ -0,0 +1,47 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the home\s?page/
+      '/'
+
+    # the following are examples using path_to_pickle
+
+    when /^#{capture_model}(?:'s)? page$/                           # eg. the forum's page
+      path_to_pickle $1
+
+    when /^#{capture_model}(?:'s)? #{capture_model}(?:'s)? page$/   # eg. the forum's post's page
+      path_to_pickle $1, $2
+
+    when /^#{capture_model}(?:'s)? #{capture_model}'s (.+?) page$/  # eg. the forum's post's comments page
+      path_to_pickle $1, $2, :extra => $3                           #  or the forum's post's edit page
+
+    when /^#{capture_model}(?:'s)? (.+?) page$/                     # eg. the forum's posts page
+      path_to_pickle $1, :extra => $2                               #  or the forum's edit page
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Now, go and add a mapping in #{__FILE__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)

data/rails_generators/pickle/templates/pickle.rb

@@ -0,0 +1,29 @@
+# this file generated by script/generate pickle [paths] [email]
+#
+# Make sure that you are loading your factory of choice in your cucumber environment
+#
+# For machinist add: features/support/machinist.rb
+#
+#    require 'machinist/active_record' # or your chosen adaptor
+#    require File.dirname(__FILE__) + '/../../spec/blueprints' # or wherever your blueprints are
+#
+# For FactoryGirl add: features/support/factory_girl.rb
+#
+#    require 'factory_girl'
+#    require File.dirname(__FILE__) + '/../../spec/factories' # or wherever your factories are
+#
+# For Fabrication, just include it in the adapter list when configuring pickle as explained below.
+#
+# You may also need to add gem dependencies on your factory of choice in <tt>config/environments/cucumber.rb</tt>
+
+require 'pickle/world'
+# Example of configuring pickle:
+#
+# Pickle.configure do |config|
+#   config.adapters = [:machinist]
+#   config.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
+# end
+<%- if pickle_path -%>require 'pickle/path/world'
+<%- end -%>
+<%- if pickle_email -%>require 'pickle/email/world'
+<%- end -%>

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -0,0 +1,105 @@
+# this file generated by script/generate pickle
+
+# create a model
+Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
+  create_model(name, fields)
+end
+
+# create n models
+Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  create_models(count, plural_factory.singularize, fields)
+end
+
+# create models from a table
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
+  create_models_from_table(plural_factory, table)
+end
+
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model!(name, fields)
+end
+
+# not find a model
+Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
+  expect(find_model(name, fields)).to be_nil
+end
+
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exist:?$/) do |plural_factory, table|
+  expect(find_models_from_table(plural_factory, table)).not_to be_any(&:nil?)
+end
+
+# not find models with a table
+Then(/^the following #{capture_plural_factory} should not exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should be_all(&:nil?)
+end
+
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  expect(find_models(plural_factory.singularize, fields).size).to eq(count.to_i)
+end
+
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  expect(model!(a)).to eq(model!(b))
+end
+
+# assert model is in another model's has_many assoc
+Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  expect(model!(owner).send(association)).to include(model!(target))
+end
+
+# assert model is not in another model's has_many assoc
+Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  expect(model!(owner).send(association)).not_to include(model!(target))
+end
+
+# assert model is another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  expect(model!(owner).send(association)).to eq(model!(target))
+end
+
+# assert model is not another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  expect(model!(owner).send(association)).not_to eq(model!(target))
+end
+
+# assert model.predicate?
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).to send("have_#{predicate.gsub(' ', '_')}")
+  else
+    expect(model!(name)).to send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    expect(model!(name)).not_to send("have_#{predicate.gsub(' ', '_')}")
+  else
+    expect(model!(name)).not_to send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# expect(model.attribute).to eq(value)
+# expect(model.attribute).not_to eq(value)
+Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
+  actual_value  = model(name).send(attribute)
+  expectation   = expectation.gsub("should", "to").gsub(" ", "_")
+
+  case expected
+  when 'nil', 'true', 'false'
+    expect(actual_value).send(expectation, eq(eval(expected)))
+  when /^[+-]?[0-9_]+(\.\d+)?$/
+    expect(actual_value).send(expectation, eq(expected.to_f))
+  else
+    expect(actual_value.to_s).send(expectation, eq(eval(expected)))
+  end
+end
+
+# assert size of association
+Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
+  expect(model!(name).send(association).size).to eq(size.to_i)
+end

data/spbtv_pickle.gemspec

@@ -0,0 +1,38 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "pickle/version"
+
+Gem::Specification.new do |s|
+  s.name = "spbtv_pickle"
+  s.version = Pickle::VERSION.dup
+  s.platform = Gem::Platform::RUBY
+  s.licenses = ["MIT"]
+  s.authors = ["Ian White", "James Le Cuirot"]
+  s.description = "Easy model creation and reference in your cucumber features"
+  s.summary = "Easy model creation and reference in your cucumber features."
+  s.email = ["ian.w.white@gmail.com", "chewi@aura-online.co.uk"]
+  s.homepage = "https://github.com/ianwhite/pickle"
+
+  s.rubyforge_project = "pickle"
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "cucumber", ">=0.8"
+  s.add_dependency "rake"
+
+  s.add_development_dependency "rack"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "git"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "rspec-rails", "~>3.0"
+  s.add_development_dependency "rails", "~>3.1.0"
+  s.add_development_dependency "cucumber-rails"
+  s.add_development_dependency "factory_girl"
+  s.add_development_dependency "fabrication", '~> 2.0'
+  s.add_development_dependency "machinist", "~>2.0"
+  s.add_development_dependency "database_cleaner"
+  s.add_development_dependency "capybara"
+  s.add_development_dependency "sqlite3"
+end

data/spec/pickle/adapter_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+require 'active_record'
+require 'factory_girl'
+require 'fabrication'
+require 'machinist/active_record'
+require 'pickle/adapters/active_record'
+
+describe Pickle::Adapter do
+  it ".factories should raise NotImplementedError" do
+    expect { Pickle::Adapter.factories }.to raise_error(NotImplementedError)
+  end
+
+  it "#create should raise NotImplementedError" do
+    expect { Pickle::Adapter.new.create }.to raise_error(NotImplementedError)
+  end
+
+  describe "adapters: " do
+    around do |example|
+      begin
+        class One < ActiveRecord::Base; end
+        class One::Two < ActiveRecord::Base; end
+        class Three < ActiveRecord::Base; end
+        example.run
+      ensure
+        Object.send :remove_const, :One
+        Object.send :remove_const, :Three
+      end
+    end
+
+    describe 'ActiveRecord' do
+      describe 'with class stubs' do
+        before do
+          allow(Pickle::Adapter::Orm).to receive(:model_classes).and_return([One, One::Two, Three])
+        end
+
+        it ".factories should create one for each active record class" do
+          expect(Pickle::Adapter::Orm).to receive(:new).with(One).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(One::Two).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(Three).once
+          expect(Pickle::Adapter::Orm.factories.length).to eq(3)
+        end
+
+        describe ".new(Class)" do
+          before do
+            @factory = Pickle::Adapter::Orm.new(One::Two)
+          end
+
+          it "should have underscored (s/_) name of Class as #name" do
+            expect(@factory.name).to eq('one_two')
+          end
+
+          it "#create(attrs) should call Class.create!(attrs)" do
+            expect(One::Two).to receive(:create!).with({:key => "val"})
+            @factory.create(:key => "val")
+          end
+        end
+      end
+    end
+
+    describe 'FactoryGirl' do
+      before do
+        allow(Pickle::Adapter::FactoryGirl).to receive(:model_classes).and_return([One, One::Two, Three])
+
+        if defined? ::FactoryGirl
+          @orig_factories = ::FactoryGirl.factories.dup
+          ::FactoryGirl.factories.clear
+          ::FactoryGirl::Syntax::Default::DSL.new.factory(:one, :class => One) {}
+          ::FactoryGirl::Syntax::Default::DSL.new.factory(:two, :class => One::Two) {}
+          @factory1 = ::FactoryGirl.factories[:one]
+          @factory2 = ::FactoryGirl.factories[:two]
+        else
+          @orig_factories, Factory.factories = Factory.factories, {}
+          Factory.define(:one, :class => One) {}
+          Factory.define(:two, :class => One::Two) {}
+          @factory1 = Factory.factories[:one]
+          @factory2 = Factory.factories[:two]
+        end
+      end
+
+      after do
+        if defined? ::FactoryGirl
+          ::FactoryGirl.factories.clear
+          @orig_factories.each {|f| ::FactoryGirl.factories.add(f) }
+        else
+          Factory.factories = @orig_factories
+        end
+      end
+
+      it ".factories should create one for each factory" do
+        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory1, @factory1.name).once
+        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory2, @factory2.name).once
+        Pickle::Adapter::FactoryGirl.factories
+      end
+
+      describe ".new(factory, factory_name)" do
+        before do
+          @factory = Pickle::Adapter::FactoryGirl.new(@factory1, @factory1.name)
+        end
+
+        it "should have name of factory_name" do
+          expect(@factory.name).to eq('one')
+        end
+
+        it "should have klass of build_class" do
+          expect(@factory.klass).to eq(One)
+        end
+
+        unless defined? ::FactoryGirl
+          it "#create(attrs) should call Factory(<:key>, attrs)" do
+            expect(Factory).to receive(:create).with("one", {:key => "val"})
+            @factory.create(:key => "val")
+          end
+        end
+      end
+    end
+
+    describe 'Fabrication' do
+      before do
+        @schematic1 = [:one, Fabrication::Schematic::Definition.new(One)]
+        @schematic2 = [:two, Fabrication::Schematic::Definition.new(One::Two)]
+        allow(::Fabrication.manager).to receive(:schematics).and_return(Hash[[@schematic1, @schematic2]])
+      end
+
+      it '.factories should create one for each fabricator' do
+        expect(Pickle::Adapter::Fabrication).to receive(:new).with(@schematic1)
+        expect(Pickle::Adapter::Fabrication).to receive(:new).with(@schematic2)
+
+        Pickle::Adapter::Fabrication.factories
+      end
+
+      describe ".new" do
+        before do
+          @factory = Pickle::Adapter::Fabrication.new(@schematic1)
+        end
+
+        it ".new should have name of schematic name" do
+          expect(@factory.name).to eq('one')
+        end
+
+        it "should have klass of build_class" do
+          expect(@factory.klass).to eq(One)
+        end
+      end
+
+      describe ".create" do
+        it "returns the fabricated instance" do
+          @factory = Pickle::Adapter::Fabrication.new(@schematic1)
+          expect(Fabricate).to receive(:create).
+              with(@factory.name.to_sym, {:attribute => 'value'})
+          @factory.create({:attribute => 'value'})
+        end
+      end
+    end
+
+    describe 'Machinist' do
+      before do
+        allow(Pickle::Adapter::Machinist).to receive(:model_classes).and_return([One, One::Two, Three])
+
+        One.blueprint {}
+        Three.blueprint {}
+        Three.blueprint(:special) {}
+      end
+
+      it ".factories should create one for each master blueprint, and special case" do
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(One, :master).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(Three, :master).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(Three, :special).once
+        Pickle::Adapter::Machinist.factories
+      end
+
+      describe ".new(Class, :master)" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(One, :master)
+        end
+
+        it "should have underscored (s/_) name of Class as #name" do
+          expect(@factory.name).to eq('one')
+        end
+
+        it "#create(attrs) should call Class.make!(:master, attrs)" do
+          expect(One).to receive(:make!).with(:master, {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+
+      describe ".new(Class, :special)" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(Three, :special)
+        end
+
+        it "should have 'special_<Class name>' as #name" do
+          expect(@factory.name).to eq('special_three')
+        end
+
+        it "#create(attrs) should call Class.make!(:special, attrs)" do
+          expect(Three).to receive(:make!).with(:special, {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+  end
+end