pickle-dupe 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 iawgens
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= pickle-dupe
+
+Pickle-dupe is an add-on to pickle that works with Dupe, an Active Resource mocking/factory.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 iawgens. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,97 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pickle-dupe"
+    gem.summary = %Q{Pickle that works with Dupe, an Active Resource mocking/factory}
+    gem.description = %Q{Dupe is Active Resource mocking/factory for use with cucumber. Pickle-dupe is a pickle add-on that works with Dupe}
+    gem.email = "gary.s.cheong@gmail.com"
+    gem.homepage = "http://github.com/iawgens/pickle-dupe"
+    gem.authors = ["iawgens"]
+    gem.add_dependency "pickle",">=0.2.1"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pickle-dupe #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+## cucumber rake tasks
+unless ARGV.any? {|a| a =~ /^gems/} # Don't load anything when running the gems:* tasks
+
+# vendored_cucumber_bin = Dir["#{RAILS_ROOT}/vendor/{gems,plugins}/cucumber*/bin/cucumber"].first
+# $LOAD_PATH.unshift(File.dirname(vendored_cucumber_bin) + '/../lib') unless vendored_cucumber_bin.nil?
+vendored_cucumber_bin = nil
+
+begin
+  require 'cucumber/rake/task'
+
+  namespace :cucumber do
+    Cucumber::Rake::Task.new(:ok, 'Run features that should pass') do |t|
+      t.binary = vendored_cucumber_bin # If nil, the gem's binary is used.
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = 'default'
+    end
+
+    Cucumber::Rake::Task.new({:wip => 'db:test:prepare'}, 'Run features that are being worked on') do |t|
+      t.binary = vendored_cucumber_bin
+      t.fork = true # You may get faster startup if you set this to false
+      t.profile = 'wip'
+    end
+
+    desc 'Run all features'
+    task :all => [:ok, :wip]
+  end
+  desc 'Alias for cucumber:ok'
+  task :cucumber => 'cucumber:ok'
+
+  task :default => :cucumber
+
+  task :features => :cucumber do
+    STDERR.puts "*** The 'features' task is deprecated. See rake -T cucumber ***"
+  end
+rescue LoadError
+  desc 'cucumber rake task not available (cucumber not installed)'
+  task :cucumber do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+  end
+end
+
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/features/app/active_resources.rb

@@ -0,0 +1,8 @@
+class AbstractResource < ActiveResource::Base
+  self.site = ''
+end
+class Recipe < AbstractResource
+end
+
+class Ingredient < AbstractResource
+end

data/features/app/dupe_definitions.rb

@@ -0,0 +1,43 @@
+# Dupe definitions
+require 'dupe'
+
+Dupe.debug = true
+Dupe.sequence :recipe_title do |n|
+  "Recipe #{n} Title"
+end
+
+Dupe.define :recipe do |recipe|
+  recipe.title do
+    Dupe.next :recipe_title
+  end
+  
+  # recipe.ingredients do |ingredients|
+  #     ingredients.split(', ').map do |ingredient|
+  #       Dupe.find(:ingredient) do |i|
+  #         i.label == labelize(ingredient)
+  #       end
+  #     end
+  #   end
+  
+  recipe.after_create do |r|
+    r.label = labelize(r.title)
+  end
+end
+
+
+# Not Applicable in Dupe
+# Dupe.define :fancy_recipe, :class => Recipe do |t|
+#   t.name {"Fancy " + Dupe.next(:reipe_title)}
+# end
+
+Dupe.define :ingredient do |ingredient|
+  ingredient.uniquify :name
+  
+  ingredient.after_create do |i|
+    i.label = labelize(i.name)
+  end
+end
+
+def labelize(name)
+  name.gsub(/\s/,'-').downcase
+end

data/features/pickle/create_from_dupe.feature

@@ -0,0 +1,49 @@
+Feature: I can easily create models from dupe
+  As a pickle user
+  I want to be able to leverage my factories
+  So that I can create models quickly and easily in my features
+  
+  Scenario: I create a recipe, and see if it looks right
+    Given a recipe exists
+    Then a recipe should exist
+    
+  Scenario: I create a recipe with specific name, and see if it looks right
+    Given a recipe exists with name: "Chicken Recipe"
+    Then a recipe should exist with name: "Chicken Recipe"
+  
+  Scenario: I create stub recipes, and see if it looks right
+    Given 3 recipes exist
+	  Then 3 recipes should exist
+	  
+	Scenario: I create some recipes, and some ingredients
+	  Given a recipe: "one" exists
+	  And an ingredient exists with recipe: recipe "one"
+	  And another ingredient exists with recipe: recipe "one"
+	  And a recipe: "two" exists
+	  And an ingredient exists with recipe: recipe "two"
+	  
+    # TODO: GC 02/05/2010 named factory definition is not yet supported by dupe 
+    # And a fancy recipe exists
+    # And an ingredient exists with recipe: the fancy recipe
+	  
+	  Then the first ingredient should be ingredient of the recipe: "one"
+	  And the 2nd ingredient should be the ingredient of recipe "one"
+	  And the last ingredient should be the recipe of recipe "two"
+	  
+	  Then the first ingredient should be in recipe "one"'s ingredients
+	  And the 2nd ingredient should be in recipe: "one"'s ingredients
+	  And the last ingredient should be in recipe "two"'s ingredients
+	  And recipe "two" should be the last ingredient's recipe
+	  
+	  But the first ingredient should not be in the fancy recipe's ingredients
+	  And the last ingredient should not be in recipe "one"'s ingredients
+	  And the fancy recipe should not be the first ingredient's recipe
+ 
+  Scenario: Create an ingredient and a recipe refs in a table
+    Given 2 recipes exist
+    And the following ingredients exist:
+      | recipe      |
+      | the 1st recipe |
+      | the 2nd recipe |
+    Then the 1st ingredient should be in the 1st recipe's ingredients
+    And the 2nd ingredient should be in the 2nd recipe's ingredients

data/features/step_definitions/path_steps.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+Then(/^(.+?) should match route \/(.+?)$/) do |page, route|
+  regexp = route.gsub(/:(\w*?)id/,'\d+')
+  path_to(page).should =~ /#{regexp}/
+end
+
+When(/^I go to (.+)$/) do |page|
+  visit path_to(page)
+end
+
+Then(/^I should be at (.+)$/) do |page|
+  request.path.should =~ /#{path_to(page)}/
+end

data/features/step_definitions/pickle_steps.rb

@@ -0,0 +1,73 @@
+# 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|
+  count.to_i.times { create_model(plural_factory.singularize, fields) }
+end
+
+# create models from a table
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
+  name = plural_factory.singularize
+  table.hashes.each { |hash| create_model(name, hash) }
+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|
+  find_model(name, fields).should be_nil
+end
+
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  name = plural_factory.singularize
+  table.hashes.each { |hash| find_model!(name, hash)}
+end
+
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  find_models(plural_factory.singularize, fields).size.should == count.to_i
+end
+
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == 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|
+  model!(owner).send(association).should 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|
+  model!(owner).send(association).should_not 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|
+  model!(owner).send(association).should == 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|
+  model!(owner).send(association).should_not == model!(target)
+end
+
+# assert model.predicate? 
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+end

data/features/step_definitions/recipe_steps.rb

@@ -0,0 +1,4 @@
+# example of making your own matcher with the pickle backend
+Then(/^#{capture_model} should be ingredient of #{capture_model}$/) do |ingredient, recipe|
+  model(recipe).ingredients.should include(model(ingredient))
+end

data/features/support/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/features/support/env.rb

@@ -0,0 +1,56 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a 
+# newer version of cucumber-rails. Consider adding your own code to a new file 
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+ENV["RAILS_ENV"] ||= "cucumber"
+
+require File.expand_path(File.dirname(__FILE__) + '/../../../../../config/environment')
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/rspec'
+require 'cucumber/rails/world'
+require 'cucumber/rails/active_record'
+require 'cucumber/web/tableish'
+
+require 'webrat'
+require 'webrat/core/matchers'
+#require 'cucumber/webrat/element_locator' # Deprecated in favor of #tableish - remove this line if you don't use #element_at or #table_at
+
+Webrat.configure do |config|
+  config.mode = :rails
+  config.open_error_files = false # Set to true if you want error pages to pop up in the browser
+end
+
+
+# If you set this to false, any error raised from within your app will bubble 
+# up to your step definition and out to cucumber unless you catch it somewhere
+# on the way. You can make Rails rescue errors and render error pages on a
+# per-scenario basis by tagging a scenario or feature with the @allow-rescue tag.
+#
+# If you set this to true, Rails will rescue all errors and render error
+# pages, more or less in the same way your application would behave in the
+# default production environment. It's not recommended to do this for all
+# of your scenarios, as this makes it hard to discover errors in your application.
+ActionController::Base.allow_rescue = false
+
+# If you set this to true, each scenario will run in a database transaction.
+# You can still turn off transactions on a per-scenario basis, simply tagging 
+# a feature or scenario with the @no-txn tag. If you are using Capybara,
+# tagging with @culerity or @javascript will also turn transactions off.
+#
+# If you set this to false, transactions will be off for all scenarios,
+# regardless of whether you use @no-txn or not.
+#
+# Beware that turning transactions off will leave data in your database 
+# after each scenario, which can lead to hard-to-debug failures in 
+# subsequent scenarios. If you do this, we recommend you create a Before
+# block that will explicitly put your database in a known state.
+Cucumber::Rails::World.use_transactional_fixtures = true
+
+# How to clean your database when transactions are turned off. See
+# http://github.com/bmabey/database_cleaner for more info.
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+

data/features/support/paths.rb

@@ -0,0 +1,46 @@
+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/
+      '/'
+    
+    # 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))
+
+    # added by script/generate pickle path
+
+    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
+
+    when /^the (.+?) page$/                                         # translate to named route
+      send "#{$1.downcase.gsub(' ','_')}_path"
+  
+    # end added by pickle path
+
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

data/features/support/pickle.rb

@@ -0,0 +1,26 @@
+# 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
+#    Before { Sham.reset } # to reset Sham's seed between scenarios so each run has same random sequences
+#
+# For FactoryGirl add: features/support/factory_girl.rb
+#
+#    require 'factory_girl'
+#    require File.dirname(__FILE__) + '/../../spec/factories' # or wherever your factories are
+#
+# 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
+require 'pickle/path/world'
+require 'pickle/email/world'

data/features/support/pickle_dupe_app.rb

@@ -0,0 +1,7 @@
+require 'pickle_dupe'
+
+Pickle.configure do |c|
+  c.adapters = [:dupe]
+  c.map 'I', :to => 'user: "me"'
+  c.map 'killah fork', :to => 'fancy fork: "of cornwood"'
+end

data/lib/pickle_dupe/adapter.rb

@@ -0,0 +1,29 @@
+module Pickle
+  # Abstract Factory adapter class, if you have a factory type setup, you
+  # can easily create an adaptor to make it work with Pickle.
+  #
+  # The factory adaptor must have a #factories class method that returns 
+  # its instances, and each instance must respond to:
+  #
+  #   #name : identifies the factory by name (default is attr_reader)
+  #   #klass : returns the associated model class for this factory (default is attr_reader)
+  #   #create(attrs = {}) : returns a newly created object
+  class Adapter
+    
+    # dupe adapter
+    class Dupe < Adapter
+      def self.factories
+        (::Dupe.models.values rescue []).map {|model| new(model)}
+      end
+      
+      def initialize(model)
+        @klass, @name = model.name.to_s.classify.constantize, model.name.to_s
+      end
+    
+      def create(attrs = {})
+        ::Dupe.create(@name, attrs)
+      end
+    end
+
+  end
+end

data/lib/pickle_dupe/session.rb

@@ -0,0 +1,17 @@
+module Pickle
+  module Session
+    # return a newly selected model when dupe is used
+    def model_with_dupe(name)
+      model = created_model(name)
+      
+      if model.kind_of?(Dupe::Database::Record)
+        Dupe.find(model.__model__.name) {|dupe_model| dupe_model.id == model.id}
+      else
+        model_without_dupe(name)
+      end
+    end
+    
+    alias_method :model_without_dupe, :model
+    alias_method :model, :model_with_dupe
+  end
+end

data/lib/pickle_dupe.rb

@@ -0,0 +1,3 @@
+require 'pickle'
+require 'pickle_dupe/adapter'
+require 'pickle_dupe/session'

data/spec/pickle_dupe_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "PickleDupe" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'pickle-dupe'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: pickle-dupe
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- iawgens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-08 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pickle
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+    version: 
+description: Dupe is Active Resource mocking/factory for use with cucumber. Pickle-dupe is a pickle add-on that works with Dupe
+email: gary.s.cheong@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- features/app/active_resources.rb
+- features/app/dupe_definitions.rb
+- features/pickle/create_from_dupe.feature
+- features/step_definitions/path_steps.rb
+- features/step_definitions/pickle_steps.rb
+- features/step_definitions/recipe_steps.rb
+- features/support/email.rb
+- features/support/env.rb
+- features/support/paths.rb
+- features/support/pickle.rb
+- features/support/pickle_dupe_app.rb
+- lib/pickle_dupe.rb
+- lib/pickle_dupe/adapter.rb
+- lib/pickle_dupe/session.rb
+- spec/pickle_dupe_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/iawgens/pickle-dupe
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Pickle that works with Dupe, an Active Resource mocking/factory
+test_files: 
+- spec/pickle_dupe_spec.rb
+- spec/spec_helper.rb