prefactory 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1332489daa6ce963998267eb39bf65c86230c965
+  data.tar.gz: 87cbdfcf4efeee19253b6faeefdd70f9063c3431
+SHA512:
+  metadata.gz: e0955140a9e5b688c1126ec1cfef0535feb29b0fd01340e7aca0c030b0efc9975721d0b5440473599e4b6150ec1cff9b6b7705515537170148c74f06f425cfff
+  data.tar.gz: db7508fef186aad0c0a9b2e49cd421ec86bd09865ba10efcc9db0bd28e83cbd082f6b17dd5850549572db571e66f5f5ecce9e0c9a1f591a1859b3e6352ea5108

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+spec/*.log
+spec/*.sqlite3
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use default@prefactory --create

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+env:
+  - "ACTIVE_RECORD_VERSION=4.0.0"
+  - "ACTIVE_RECORD_VERSION=4.1.0"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in prefactory.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014, VMware, Inc. All Rights Reserved.
+
+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.md

@@ -0,0 +1,114 @@
+[![Build Status](https://secure.travis-ci.org/socialcast/prefactory.png?branch=master)](http://travis-ci.org/socialcast/prefactory)
+
+# Prefactory
+
+The ease and fidelity of factories with the performance of static fixtures.
+
+Prefactory allows you to create factory objects and perform other
+expensive ActiveRecord operations in RSpec before(:all) blocks, transparently
+wrapping example groups in nested transactions to automatically roll back
+any data changes that occur during a specific test.
+
+## Requirements
+
+* ActiveRecord >= 4
+* RSpec
+* FactoryGirl
+* A database for which ActiveRecord supports [nested transactions](http://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#module-ActiveRecord::Transactions::ClassMethods-label-Nested+transactions) (e.g. MySQL, Postgresql)
+
+## Installation
+
+Add the gem to the :test group in your Rails application's Gemfile:
+
+```  ruby
+group :test do
+  gem 'prefactory'
+end
+```
+
+Add this to your RSpec `spec_helper.rb`
+
+``` ruby
+RSpec.configure do |config|
+  config.include Prefactory
+
+  # ensure Rails' transaction fixtures are disabled
+  config.use_transactional_fixtures = false
+
+  # optional, to enable shorthand creation
+  # using only Factory name (see examples, below)
+  config.include FactoryGirl::Syntax::Methods
+end
+```
+
+## Example
+
+``` ruby
+describe User do
+  before :all do   # executes once
+
+    # invokes FactoryGirl.create(:user)
+    # reference object as 'friend' in tests
+    prefactory_add(:friend) { FactoryGirl.create :user }
+
+    # invokes create(:user) if available, e.g
+    # if rspec is configured with:
+    #   config.include FactoryGirl::Syntax::Methods
+    # reference object as 'user' in examples
+    prefactory_add :user
+
+  end
+
+  # convenience method, equivalent to:
+  # before(:all) do
+  #   prefactory_add(:other_friend) do
+  #     create :user
+  #   end
+  # end
+  set!(:other_friend) { create :user }
+
+  context 'a new user has no friends' do
+
+    it { user.friends.count.should == 0 }
+
+    context 'with a friend' do
+      before(:all) { user.add_friend(friend) }   # executes once
+
+      it { user.friends.count.should == 1 }
+
+      # these changes will be transparently rolled back
+      it "allows removing the friend" do
+        expect { user.remove_friend(friend) }.to_not raise_error
+        user.friends.count.should == 0
+      end
+
+      it "disallows adding the same friend again" do
+        expect { user.add_friend(friend) }.to raise_error
+        user.friends.count.should == 1
+      end
+
+      # these changes will be transparently rolled back
+      it "allows adding a different friend" do
+        expect { user.add_friend(other_friend) }.to_not raise_error
+        user.friends.count.should == 2
+      end
+
+      it { user.friends.should include friend }
+      it { user.friends.should_not include other_friend }
+    end
+  end
+end
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/socialcast/prefactory/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a pull request
+
+## Copyright
+
+Copyright (c) 2012-2014 VMware, Inc. All Rights Reserved.
+Released under the terms of the MIT license. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake'
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+end
+task :default => :spec
+task :test => :spec

data/lib/prefactory.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+# Copyright (c) 2014, VMware, Inc. All Rights Reserved.
+#
+# 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.
+
+require 'prefactory/version'
+require 'rspec/core/prefactory.rb'

data/lib/prefactory/active_record_integration.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+
+# Copyright (c) 2014, VMware, Inc. All Rights Reserved.
+#
+# 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.
+
+require 'active_record/connection_adapters/abstract/database_statements'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module DatabaseStatements
+
+      # Allow for setting a 'base' number of open transactions at which
+      # a commit should fire commit callbacks, when nesting transactional
+      # example groups.
+
+      attr_writer :commit_at_open_transaction_level
+
+      def commit_at_open_transaction_level
+        @commit_at_open_transaction_level || 1
+      end
+
+      def transaction_with_transactional_specs(options = {}, &block)
+        return_value = nil
+        rolled_back = false
+
+        transaction_without_transactional_specs(options.merge(:requires_new => true)) do
+          begin
+            return_value = yield
+          rescue StandardError => e
+            rolled_back = true
+            raise e
+          end
+          if !rolled_back && open_transactions <= commit_at_open_transaction_level + 1
+            current_transaction.instance_variable_set(:@fake_commit, true)
+          end
+        end
+        return_value
+      end
+      alias_method_chain :transaction, :transactional_specs
+
+    end
+  end
+end
+
+require 'active_record/connection_adapters/abstract/transaction'
+module ActiveRecord
+  module ConnectionAdapters
+    class SavepointTransaction
+
+      # If the savepoint was already released, we have an exception in an after-commit callback.
+      # That means *this* transaction cannot and should not be rolled back, unlike the parent
+      # transactions, which will roll back as the exception bubbles upwards.
+      def perform_rollback
+        unless @savepoint_already_released
+          connection.rollback_to_savepoint
+          rollback_records
+        end
+      end
+
+      def perform_commit
+        connection.release_savepoint
+        if @fake_commit
+          @savepoint_already_released = true
+          commit_records
+        else
+          records.each { |r| parent.add_record(r) }
+        end
+      end
+
+    end
+  end
+end
+
+require 'active_record/base'
+module WithDisposableTransactionExtension
+
+  # do a transaction with a silent rollback (unless another
+  # exception is doing a loud rollback already) and trigger
+  # commit logic for any transaction above this open-transaction level.
+  def with_disposable_transaction(&block)
+    return_value = nil
+    ActiveRecord::Base.connection.transaction(:requires_new => true) do
+      ActiveRecord::Base.connection.commit_at_open_transaction_level = ActiveRecord::Base.connection.open_transactions
+      begin
+        return_value = yield
+      rescue StandardError => e
+        raise e
+      end
+      raise ActiveRecord::Rollback
+    end
+    return_value
+  end
+
+end
+ActiveRecord::Base.send(:extend, WithDisposableTransactionExtension)

data/lib/prefactory/version.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+# Copyright (c) 2014, VMware, Inc. All Rights Reserved.
+#
+# 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.
+
+module Prefactory
+  VERSION = "0.2.0"
+end

data/lib/rspec/core/prefactory.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+
+# Copyright (c) 2014, VMware, Inc. All Rights Reserved.
+#
+# 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.
+
+require 'prefactory/active_record_integration'
+require 'rspec_around_all'
+
+module Prefactory
+
+  def prefactory_lookup(key)
+    @prefactory[key]
+  end
+
+  # instantiate, or access an already-instantiated-and-memoized, prefabricated object.
+  def prefactory(key)
+    lookup = prefactory_lookup(key)
+    return nil unless lookup.present?
+    @prefactory_memo ||= {}
+    begin
+      @prefactory_memo[key] ||= lookup[:class].find(lookup[:id])
+    rescue
+    end
+    @prefactory_memo[key]
+  end
+
+  def in_before_all?
+    @before_all_context
+  end
+
+  # prefabricate an object.  Can be passed any block that returns a class accessible by Klass.find(id),
+  # or, if no block is passed, invokes create(key, options) to use e.g. a FactoryGirl factory of that key name.
+  def prefactory_add(key, *args, &block)
+    raise "prefactory_add can only be used in a before(:all) context.  Change to a before(:all) or set!, or use let/let! instead." unless in_before_all?
+    result = nil
+    clear_prefactory_memoizations
+    if block
+      result = yield
+    else
+      result = create(key, *args) if respond_to?(:create)
+    end
+    if result.present?
+      @prefactory[key] = { :class => result.class, :id => result.id }
+    else
+      warn "WARNING: Failed to add #{key} to prefactory: block result not present"
+    end
+    clear_prefactory_memoizations
+    result
+  end
+
+  def self.included(base)
+    base.extend RSpecAroundAll
+
+    # Wrap outermost describe block in a transaction, so before(:all) data is rolled back at the end of this suite.
+    base.before(:all) do
+      clear_prefactory_map
+      clear_prefactory_memoizations
+    end
+    base.around(:all) do |group|
+      ActiveRecord::Base.with_disposable_transaction { group.run_examples }
+    end
+    base.after(:all) do
+      clear_prefactory_memoizations
+      clear_prefactory_map
+    end
+
+    # Wrap each example in a transaction, instead of using Rails' transactional
+    # fixtures, which does not support itself being wrapped in an outermost transaction.
+    base.around(:each) do |example|
+      clear_prefactory_memoizations
+      ActiveRecord::Base.with_disposable_transaction { example.run }
+      clear_prefactory_memoizations
+    end
+
+    # Wrap each ExampleGroup in a transaction, so group-level before(:all) settings
+    # are scoped only to the group.
+    base.instance_eval do
+      def describe_with_transaction(*args, &block)
+        modified_block = proc do
+          instance_eval do
+            before(:all) { clear_prefactory_memoizations }
+            around(:all) do |group|
+              ActiveRecord::Base.with_disposable_transaction { group.run_examples }
+            end
+            after(:all) { clear_prefactory_memoizations }
+          end
+          instance_eval(&block)
+        end
+        describe_without_transaction(*args, &modified_block)
+      end
+
+      def before_with_detect_before_all(*args, &block)
+        before_all_context = (args.first == :all)
+        modified_block = proc do
+          @before_all_context = before_all_context
+          instance_eval(&block)
+          @before_all_context = nil
+        end
+        before_without_detect_before_all(*args, &modified_block)
+      end
+
+      class << self
+        alias_method_chain :describe, :transaction
+        alias_method :context, :describe
+        alias_method_chain :before, :detect_before_all
+      end
+
+      def set!(key, *args, &set_block)
+        before(:all) do
+          modified_block = proc { instance_eval(&set_block) } if set_block
+          prefactory_add(key, *args, &modified_block)
+        end
+      end
+
+    end
+
+    # allow shorthand access to a prefabricated object
+    # e.g. with prefactory_add(:active_user), calling the method active_user will return the (memoized) object,
+    # by invoking the 'prefactory' method.
+    base.class_eval do
+      def method_missing(key, *args, &block)
+        if prefactory_lookup(key)
+          prefactory(key)
+        else
+          super
+        end
+      end
+    end
+
+  end
+
+  private
+
+  def clear_prefactory_memoizations
+    @prefactory_memo = {}
+  end
+
+  def clear_prefactory_map
+    @prefactory = {}
+  end
+
+end