cucumber_factory 1.9.2 → 1.10.0

data/lib/cucumber/factory.rb

@@ -1,3 +1,5 @@
+require 'cucumber/factory/build_strategy'
+
 module Cucumber
   class Factory
 
@@ -58,7 +60,8 @@ module Cucumber
       end
     
       def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
-        model_class = model_class_from_prose(raw_model)
+        build_strategy = BuildStrategy.from_prose(raw_model, raw_variant)
+        model_class = build_strategy.model_class
         attributes = {}
         if raw_attributes.try(:strip).present?
           raw_attributes.scan(/(?:the|and|with|but|,| )+(.*?) ("([^\"]*)"|above)/).each do |fragment|
@@ -75,8 +78,7 @@ module Cucumber
             attributes[attribute] = flag
           end
         end
-        variant = raw_variant.present? && /\((.*?)\)/.match(raw_variant)[1].downcase.gsub(" ", "_")
-        record = create_record(model_class, variant, attributes)
+        record = build_strategy.create_record(attributes)
         remember_record_names(world, record, attributes)
         record
       end
@@ -99,35 +101,6 @@ module Cucumber
         prose.downcase.gsub(" ", "_").to_sym
       end
 
-      def model_class_from_prose(prose)
-        # don't use \w which depends on the system locale
-        prose.gsub(/[^A-Za-z0-9_\/]+/, "_").camelize.constantize
-      end
-
-      def factory_girl_factory_name(name)
-        name.to_s.underscore.gsub('/', '_').to_sym
-      end
-
-      def create_record(model_class, variant, attributes)
-        fg_factory_name = factory_girl_factory_name(variant || model_class)
-        if defined?(::FactoryGirl) && factory = ::FactoryGirl.factories[fg_factory_name]
-          ::FactoryGirl.create(fg_factory_name, attributes)
-        elsif model_class.respond_to?(:make) # Machinist blueprint
-          if variant.present?
-            model_class.make(variant.to_sym, attributes)
-          else
-            model_class.make(attributes)
-          end
-        elsif model_class.respond_to?(:create!) # Plain ActiveRecord
-          model = model_class.new
-          CucumberFactory::Switcher.assign_attributes(model, attributes)
-          model.save!
-          model
-        else
-          model_class.new(attributes)
-        end
-      end
-
       def remember_record_names(world, record, attributes)
         string_values = attributes.values.select { |v| v.is_a?(String) }
         for string_value in string_values

data/lib/cucumber/factory/build_strategy.rb

@@ -0,0 +1,90 @@
+module Cucumber
+  class Factory
+
+    # wraps machinist / factory_girl / ruby object logic
+
+    class BuildStrategy
+
+      class << self
+
+        def from_prose(model_prose, variant_prose)
+          # don't use \w which depends on the system locale
+          underscored_model_name = model_prose.gsub(/[^A-Za-z0-9_\/]+/, "_")
+          variant = variant_prose.present? && /\((.*?)\)/.match(variant_prose)[1].downcase.gsub(" ", "_")
+
+          if factory_girl_strategy = factory_girl_strategy(variant || underscored_model_name)
+            factory_girl_strategy
+          else
+            model_class = underscored_model_name.camelize.constantize
+            machinist_strategy(model_class, variant) ||
+              active_record_strategy(model_class) ||
+              ruby_object_strategy(model_class)
+          end
+        end
+
+        private
+
+        def factory_girl_strategy(factory_name)
+          return unless defined?(::FactoryGirl)
+
+          factory_name = factory_name.to_s.underscore.gsub('/', '_').to_sym
+          if factory = ::FactoryGirl.factories[factory_name]
+
+            new(factory.build_class) do |attributes|
+              ::FactoryGirl.create(factory.name, attributes)
+            end
+
+          end
+        end
+
+        def machinist_strategy(model_class, variant)
+          if model_class.respond_to?(:make)
+
+            new(model_class) do |attributes|
+              if variant.present?
+                model_class.make(variant.to_sym, attributes)
+              else
+                model_class.make(attributes)
+              end
+            end
+
+          end
+        end
+
+        def active_record_strategy(model_class)
+          if model_class.respond_to?(:create!)
+
+            new(model_class) do |attributes|
+              model = model_class.new
+              CucumberFactory::Switcher.assign_attributes(model, attributes)
+              model.save!
+              model
+            end
+
+          end
+        end
+
+        def ruby_object_strategy(model_class)
+          new(model_class) do |attributes|
+            model_class.new(attributes)
+          end
+        end
+
+      end
+
+
+      attr_reader :model_class
+
+      def initialize(model_class, &block)
+        @model_class = model_class
+        @create_proc = block
+      end
+
+      def create_record(attributes)
+        @create_proc.call(attributes)
+      end
+
+    end
+
+  end
+end

data/lib/cucumber_factory/version.rb

@@ -1,3 +1,3 @@
 module CucumberFactory
-  VERSION = '1.9.2'
+  VERSION = '1.10.0'
 end

data/spec/shared/cucumber_factory/factory/build_strategy_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require_relative '../../support/factory_girl_mock'
+
+describe Cucumber::Factory::BuildStrategy do
+
+  subject { Cucumber::Factory::BuildStrategy }
+
+  # most of the behaviour is integration tested in steps_spec.rb
+
+  describe '.from_prose' do
+
+    context 'when describing a factory girl factory' do
+
+      it 'returns a strategy corresponding to the factories model' do
+        FactoryGirl.stub_factories :job_offer => JobOffer
+        strategy = subject.from_prose('job offer', nil)
+
+        strategy.should be_a(described_class)
+        strategy.model_class.should == JobOffer
+      end
+
+      it 'uses the variant for the factory name if present' do
+        FactoryGirl.stub_factories :job_offer => JobOffer
+        strategy = subject.from_prose('foo', '(job offer)')
+
+        strategy.should be_a(described_class)
+        strategy.model_class.should == JobOffer
+      end
+
+    end
+
+    context 'when describing a non factory girl model' do
+
+      it "should return a strategy for the class matching a natural language expression" do
+        subject.from_prose("movie", nil).model_class.should == Movie
+        subject.from_prose("job offer", nil).model_class.should == JobOffer
+      end
+
+      it "should ignore variants for the class name" do
+        subject.from_prose("movie", "(job offer)").model_class.should == Movie
+      end
+
+      it "should allow namespaced models" do
+        subject.from_prose("people/actor", nil).model_class.should == People::Actor
+      end
+
+    end
+
+  end
+
+end

data/spec/shared/cucumber_factory/steps_spec.rb

@@ -3,12 +3,7 @@ require 'spec_helper'
 require_relative 'cucumber_helper'
 require 'cucumber'
 require 'cucumber/rb_support/rb_language'
-
-class FactoryGirl # for factory_girl compatibility spec
-  def self.factories
-    {}
-  end
-end
+require_relative '../support/factory_girl_mock'
 
 describe 'steps provided by cucumber_factory' do
 
@@ -39,17 +34,23 @@ describe 'steps provided by cucumber_factory' do
   end
 
   it "should create models that have a factory_girl factory by calling #FactoryGirl.create(:model_name)" do
-    FactoryGirl.should_receive(:factories).with().and_return({ :job_offer => :job_offer_factory }) # Fake factory look up in factory_girl
+    FactoryGirl.stub_factories :job_offer => JobOffer
     FactoryGirl.should_receive(:create).with(:job_offer, { :title => "Awesome job" })
     invoke_cucumber_step('there is a job offer with the title "Awesome job"')
   end
 
-  it "should create model variants that have a factory_girl factory by calling #FactoryGirl.create(:variant_name)" do
-    FactoryGirl.should_receive(:factories).with().and_return({ :tempting_job_offer => :tempting_job_offer_factory }) # Fake factory look up in factory_girl
+  it "should create model variants that have a factory_girl factory by calling #FactoryGirl.create(:variant)" do
+    FactoryGirl.stub_factories :tempting_job_offer => JobOffer
     FactoryGirl.should_receive(:create).with(:tempting_job_offer, { :title => "Awesomafiablyfantasmic job" })
     invoke_cucumber_step('there is a job offer (tempting job offer) with the title "Awesomafiablyfantasmic job"')
   end
 
+  it "should create model variants that have a factory_girl factory by using the model name as a factory name" do
+    FactoryGirl.stub_factories :tempting_job_offer => JobOffer
+    FactoryGirl.should_receive(:create).with(:tempting_job_offer, { :title => "Awesomafiablyfantasmic job" })
+    invoke_cucumber_step('there is a tempting job offer with the title "Awesomafiablyfantasmic job"')
+  end
+
   it "should instantiate plain ruby classes by calling #new" do
     PlainRubyClass.should_receive(:new).with({})
     invoke_cucumber_step("there is a plain ruby class")

data/spec/shared/support/factory_girl_mock.rb

@@ -0,0 +1,17 @@
+class FactoryGirl # for factory_girl compatibility spec
+
+  def self.factories
+    {}
+  end
+
+  Factory = Struct.new(:name, :build_class)
+
+  def self.stub_factories(hash)
+    factories = {}
+    hash.each do |name, build_class|
+      factories[name] = Factory.new(name, build_class)
+    end
+    FactoryGirl.stub :factories => factories
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber_factory
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2015-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -121,6 +121,7 @@ files:
 - Rakefile
 - cucumber_factory.gemspec
 - lib/cucumber/factory.rb
+- lib/cucumber/factory/build_strategy.rb
 - lib/cucumber/runtime_ext.rb
 - lib/cucumber_factory.rb
 - lib/cucumber_factory/switcher.rb
@@ -207,9 +208,10 @@ files:
 - spec/shared/app_root/db/migrate/003_create_payments.rb
 - spec/shared/app_root/db/migrate/004_create_actors.rb
 - spec/shared/cucumber_factory/cucumber_helper.rb
-- spec/shared/cucumber_factory/factory_spec.rb
+- spec/shared/cucumber_factory/factory/build_strategy_spec.rb
 - spec/shared/cucumber_factory/runtime_ext_spec.rb
 - spec/shared/cucumber_factory/steps_spec.rb
+- spec/shared/support/factory_girl_mock.rb
 homepage: http://github.com/makandra/cucumber_factory
 licenses:
 - MIT
@@ -231,8 +233,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Create records from Cucumber features without writing step definitions.
 test_files: []
+has_rdoc: 

data/spec/shared/cucumber_factory/factory_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Cucumber::Factory do
-
-  subject { Cucumber::Factory }
-
-  describe 'model_class_from_prose' do
-
-    it "should return the class matching a natural language expression" do
-      subject.send(:model_class_from_prose, "movie").should == Movie
-      subject.send(:model_class_from_prose, "job offer").should == JobOffer
-    end
-
-    it "should allow namespaced models" do
-      subject.send(:model_class_from_prose, "people/actor").should == People::Actor
-    end
-
-  end
-
-  describe 'factory_girl_factory_name' do
-
-    it "should underscorize everything" do
-      subject.send(:factory_girl_factory_name, People::Actor).should == :people_actor
-      subject.send(:factory_girl_factory_name, JobOffer).should == :job_offer
-    end
-
-  end
-
-end