prefactory 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1332489daa6ce963998267eb39bf65c86230c965
-  data.tar.gz: 87cbdfcf4efeee19253b6faeefdd70f9063c3431
+  metadata.gz: 6838c79473272087e2903348125c9adf2f9cdfe6
+  data.tar.gz: c32580da0f0b491e4bb2ab9678a257faebbe8f4e
 SHA512:
-  metadata.gz: e0955140a9e5b688c1126ec1cfef0535feb29b0fd01340e7aca0c030b0efc9975721d0b5440473599e4b6150ec1cff9b6b7705515537170148c74f06f425cfff
-  data.tar.gz: db7508fef186aad0c0a9b2e49cd421ec86bd09865ba10efcc9db0bd28e83cbd082f6b17dd5850549572db571e66f5f5ecce9e0c9a1f591a1859b3e6352ea5108
+  metadata.gz: d0cc5f57c32ddc83a8c284e60f197637f8e1861261f372d146cc97cea3342e933e930dfe42186505a4b92e4f31fa6177ef88cb35ef4af96a73aa7d740ff650bd
+  data.tar.gz: 93fc81a665cc1ba0d0e0a9de7c3197a36b151dcb69e02501c16d3a94f0db00e5d0cb8b9aa07503868f2ba391f8aba7301d01bd4c01330a2820b768060c3643e9

data/.travis.yml

@@ -4,5 +4,7 @@ rvm:
   - 2.0.0
   - 2.1.2
 env:
-  - "ACTIVE_RECORD_VERSION=4.0.0"
-  - "ACTIVE_RECORD_VERSION=4.1.0"
+  - ACTIVE_RECORD_VERSION=4.0.0 RSPEC_VERSION=2.99
+  - ACTIVE_RECORD_VERSION=4.0.0
+  - ACTIVE_RECORD_VERSION=4.1.0 RSPEC_VERSION=2.99
+  - ACTIVE_RECORD_VERSION=4.1.0

data/README.md

@@ -7,7 +7,8 @@ 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.
+any data changes that occur during a specific test, while also ensuring
+after-commit callbacks are executed for the synthetic commits.
 
 ## Requirements
 
@@ -41,7 +42,7 @@ RSpec.configure do |config|
 end
 ```
 
-## Example
+## Example Usage
 
 ``` ruby
 describe User do
@@ -100,6 +101,8 @@ describe User do
 end
 ```
 
+See also:  [An example rails application with Prefactory configured](https://github.com/seanwalbran/prefactory-example)
+
 ## Contributing
 
 1. Fork it ( http://github.com/socialcast/prefactory/fork )

data/lib/prefactory/version.rb

@@ -21,5 +21,5 @@
 # SOFTWARE.
 
 module Prefactory
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/rspec/core/prefactory.rb

@@ -93,6 +93,7 @@ module Prefactory
     # are scoped only to the group.
     base.instance_eval do
       def describe_with_transaction(*args, &block)
+        original_caller = caller
         modified_block = proc do
           instance_eval do
             before(:all) { clear_prefactory_memoizations }
@@ -103,6 +104,14 @@ module Prefactory
           end
           instance_eval(&block)
         end
+
+        caller_metadata = { :caller => original_caller }
+        if args.last.is_a?(Hash)
+          args.last.merge!(caller_metadata)
+        else
+          args << caller_metadata
+        end
+
         describe_without_transaction(*args, &modified_block)
       end
 

data/prefactory.gemspec

@@ -3,6 +3,12 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'prefactory/version'
 
+rspec_version = if ENV["RSPEC_VERSION"].to_s == ''
+                  nil
+                else
+                  "~> #{ENV['RSPEC_VERSION']}"
+                end
+
 active_record_version = case ENV["ACTIVE_RECORD_VERSION"].to_s
                         when 'master'
                           { github: "rails/activerecord" }
@@ -28,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'rspec_around_all', '~> 0'
+  spec.add_dependency('rspec', rspec_version) if rspec_version
   spec.add_dependency 'activerecord', active_record_version
   spec.add_dependency 'factory_girl_rails', '~> 4'
 

data/spec/prefactory_spec.rb

@@ -32,9 +32,9 @@ describe Prefactory do
       @in_before_each = in_before_all?
     end
     it "is only true when called inside a before(:all)" do
-      @in_before_all.should be_true
-      @in_before_each.should be_false
-      in_before_all?.should be_false # in this it-block context
+      expect(@in_before_all).to be_truthy
+      expect(@in_before_each).to be_falsey
+      expect(in_before_all?).to be_falsey # in this it-block context
     end
     after(:each) do
       flunk if in_before_all?
@@ -44,6 +44,23 @@ describe Prefactory do
     end
   end
 
+  describe "location metadata" do
+    context "with no other user metadata" do
+      it do
+        expect(RSpec.current_example.metadata[:location]).to include "prefactory_spec.rb"
+        expect(RSpec.current_example.metadata[:example_group][:location]).to include "prefactory_spec.rb"
+      end
+    end
+    context "with other user metadata", :foo => :bar, :baz => :bop do
+      it do
+        expect(RSpec.current_example.metadata[:location]).to include "prefactory_spec.rb"
+        expect(RSpec.current_example.metadata[:example_group][:location]).to include "prefactory_spec.rb"
+        expect(RSpec.current_example.metadata[:foo]).to eq(:bar)
+        expect(RSpec.current_example.metadata[:baz]).to eq(:bop)
+      end
+    end
+  end
+
   describe "#prefactory_add" do
 
     context "when passing a block with no FactoryGirl activity" do
@@ -53,12 +70,12 @@ describe Prefactory do
         end
       end
       it "creates an object using the provided name" do
-        my_blog.should be_present
-        my_blog.title.should == 'My Blog'
-        my_blog.id.should be_present
-        Blog.where(:id => my_blog.id).should exist
-        prefactory(:my_blog).should == my_blog
-        my_blog.counter.should be_nil
+        expect(my_blog).to be_present
+        expect(my_blog.title).to eq('My Blog')
+        expect(my_blog.id).to be_present
+        expect(Blog.where(:id => my_blog.id)).to exist
+        expect(prefactory(:my_blog)).to eq(my_blog)
+        expect(my_blog.counter).to be_nil
       end
     end
 
@@ -67,12 +84,12 @@ describe Prefactory do
         prefactory_add :blog
       end
       it "creates an object based on the factory name, via FactoryGirl::Syntax::Methods" do
-        blog.should be_present
-        blog.title.should =~ /\ATitle [0-9]+\z/
-        blog.id.should be_present
-        Blog.where(:id => blog.id).should exist
-        prefactory(:blog).should == blog
-        blog.counter.should be_nil
+        expect(blog).to be_present
+        expect(blog.title).to match(/\ATitle [0-9]+\z/)
+        expect(blog.id).to be_present
+        expect(Blog.where(:id => blog.id)).to exist
+        expect(prefactory(:blog)).to eq(blog)
+        expect(blog.counter).to be_nil
       end
     end
     context "when passing a factory name and additional attributes" do
@@ -80,12 +97,12 @@ describe Prefactory do
         prefactory_add :blog, :counter => 12
       end
       it "uses the additional attributes" do
-        blog.should be_present
-        blog.title.should =~ /\ATitle [0-9]+\z/
-        blog.id.should be_present
-        Blog.where(:id => blog.id).should exist
-        prefactory(:blog).should == blog
-        blog.counter.should == 12
+        expect(blog).to be_present
+        expect(blog.title).to match(/\ATitle [0-9]+\z/)
+        expect(blog.id).to be_present
+        expect(Blog.where(:id => blog.id)).to exist
+        expect(prefactory(:blog)).to eq(blog)
+        expect(blog.counter).to eq(12)
       end
     end
     context "when using a different name and an explicit create call in a block" do
@@ -93,12 +110,12 @@ describe Prefactory do
         prefactory_add(:some_other_blog) { create :blog, :counter => 24 }
       end
       it "uses the other name" do
-        some_other_blog.should be_present
-        some_other_blog.title.should =~ /\ATitle [0-9]+\z/
-        some_other_blog.id.should be_present
-        Blog.where(:id => some_other_blog.id).should exist
-        prefactory(:some_other_blog).should == some_other_blog
-        some_other_blog.counter.should == 24
+        expect(some_other_blog).to be_present
+        expect(some_other_blog.title).to match(/\ATitle [0-9]+\z/)
+        expect(some_other_blog.id).to be_present
+        expect(Blog.where(:id => some_other_blog.id)).to exist
+        expect(prefactory(:some_other_blog)).to eq(some_other_blog)
+        expect(some_other_blog.counter).to eq(24)
       end
     end
     context "when referencing the object within the before-all block" do
@@ -107,25 +124,25 @@ describe Prefactory do
         blog.update_attributes! :counter => 42
       end
       it "works" do
-        blog.counter.should == 42
+        expect(blog.counter).to eq(42)
       end
     end
     context "nesting a before-all with a prefactory_add" do
       before :all do
         prefactory_add :blog, :title => 'the big book of trains'
       end
-      it { blog.should be_present }
+      it { expect(blog).to be_present }
       context "and another before-all prefactory_add" do
         before :all do
           prefactory_add :comment, :blog => blog, :text => 'old text'
         end
         it do
-          comment.should be_present
-          comment.blog.should == blog
+          expect(comment).to be_present
+          expect(comment.blog).to eq(blog)
         end
         it do
-          blog.should be_present
-          blog.title.should == 'the big book of trains'
+          expect(blog).to be_present
+          expect(blog.title).to eq('the big book of trains')
         end
         context "when modifying the object in a before-each" do
           before do
@@ -133,10 +150,10 @@ describe Prefactory do
             blog.update_attributes! :title => 'the little book of calm'
           end
           it do
-            comment.text.should == 'new text'
+            expect(comment.text).to eq('new text')
           end
           it do
-            blog.title.should == 'the little book of calm'
+            expect(blog.title).to eq('the little book of calm')
           end
         end
         context "when modifying the object in a before-all" do
@@ -145,23 +162,23 @@ describe Prefactory do
             blog.update_attributes! :title => 'the little book of calm'
           end
           it do
-            comment.text.should == 'new text'
+            expect(comment.text).to eq('new text')
           end
           it do
-            blog.title.should == 'the little book of calm'
+            expect(blog.title).to eq('the little book of calm')
           end
         end
         context "when not modifying the object" do
           it do
-            comment.text.should == 'old text'
+            expect(comment.text).to eq('old text')
           end
           it do
-            blog.title.should == 'the big book of trains'
+            expect(blog.title).to eq('the big book of trains')
           end
         end
       end
       it "preserves the title" do
-        blog.title.should == 'the big book of trains'
+        expect(blog.title).to eq('the big book of trains')
       end
     end
 
@@ -178,13 +195,13 @@ describe Prefactory do
         end
       end
       it "raises an error in a before-each context" do
-        @before_each_exception.should be_present
+        expect(@before_each_exception).to be_present
       end
       it "raises an error in an it-context" do
         expect { prefactory_add(:comment) }.to raise_error
       end
       it "works in a before-all context" do
-        prefactory(:blog).should be_present
+        expect(prefactory(:blog)).to be_present
       end
     end
   end
@@ -197,31 +214,31 @@ describe Prefactory do
     context "when passed a key associated with a prefactory_add'ed object" do
       let(:key) { :blog }
       it do
-        should be_present
-        should == blog
-        should be_a Blog
+        is_expected.to be_present
+        is_expected.to eq(blog)
+        is_expected.to be_a Blog
       end
       context "that has since been destroyed in a before-each" do
         before { blog.destroy }
         it do
-          should be_present
-          should be_destroyed
-          blog.should be_present
-          Blog.where(:id => blog.id).should_not exist
+          is_expected.to be_present
+          is_expected.to be_destroyed
+          expect(blog).to be_present
+          expect(Blog.where(:id => blog.id)).not_to exist
         end
       end
       context "that has since been destroyed in a before-all" do
         before(:all) { blog.destroy }
-        it { should be_nil }
+        it { is_expected.to be_nil }
         it "does not raise an error when calling the key name as a method" do
-          blog.should be_nil
+          expect(blog).to be_nil
         end
       end
     end
     context "when passed a nonexistent key" do
       let(:key) { :frog }
       it do
-        should be_nil
+        is_expected.to be_nil
         expect { frog }.to raise_error(NameError)
       end
     end
@@ -231,15 +248,15 @@ describe Prefactory do
       before(:all) { prefactory_add :comment }
       before(:all) { prefactory_add :another_blog, :title => blog.id.to_s }
       it do
-        blog.should be_present
-        Blog.where(:id => blog.id).should exist
+        expect(blog).to be_present
+        expect(Blog.where(:id => blog.id)).to exist
       end
       it do
-        comment.should be_present
-        Comment.where(:id => comment.id).should exist
+        expect(comment).to be_present
+        expect(Comment.where(:id => comment.id)).to exist
       end
       it do
-        another_blog.title.should == blog.id.to_s
+        expect(another_blog.title).to eq(blog.id.to_s)
       end
     end
   end
@@ -251,17 +268,17 @@ describe Prefactory do
       FactoryGirl.create :comment, :text => blog.title
     end
     it do
-      blog.should be_present
-      Blog.where(:id => blog.id).should exist
+      expect(blog).to be_present
+      expect(Blog.where(:id => blog.id)).to exist
     end
     it do
-      comment.should be_present
-      comment.counter.should == 12
-      Comment.where(:id => comment.id).should exist
+      expect(comment).to be_present
+      expect(comment.counter).to eq(12)
+      expect(Comment.where(:id => comment.id)).to exist
     end
     it do
-      some_other_comment.text.should be_present
-      some_other_comment.text.should == blog.title
+      expect(some_other_comment.text).to be_present
+      expect(some_other_comment.text).to eq(blog.title)
     end
   end
 end

data/spec/support/callback_matcher.rb

@@ -81,7 +81,7 @@ RSpec::Matchers.define :trigger_callbacks_for do |types|
     end
   }
 
-  match_for_should do |model_instance|
+  match do |model_instance|
     check_for_match.call(model_instance, types)
     result = true
     result = false unless @called.present?
@@ -89,7 +89,7 @@ RSpec::Matchers.define :trigger_callbacks_for do |types|
     result
   end
 
-  match_for_should_not do |model_instance|
+  match_when_negated do |model_instance|
     check_for_match.call(model_instance, types)
     result = true
     result = false unless @not_called.present?
@@ -97,11 +97,11 @@ RSpec::Matchers.define :trigger_callbacks_for do |types|
     result
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     ["Called:\t#{@called.join("\n\t")}", "Not called:\t#{@called.join("\n\t")}"].join("\n")
   end
 
-  failure_message_for_should_not do |actual|
+  failure_message_when_negated do |actual|
     ["Called:\t#{@called.join("\n\t")}", "Not called:\t#{@called.join("\n\t")}"].join("\n")
   end
 

data/spec/transaction_spec.rb

@@ -28,17 +28,17 @@ describe "WithDisposableTransactionExtension#with_disposable_transaction" do
     previous_open_transaction_count = Blog.connection.open_transactions
     Blog.with_disposable_transaction do
       blog.update_attributes! :title => 'bar'
-      blog.reload.title.should == 'bar'
-      Blog.connection.open_transactions.should == previous_open_transaction_count + 1
+      expect(blog.reload.title).to eq('bar')
+      expect(Blog.connection.open_transactions).to eq(previous_open_transaction_count + 1)
     end
-    blog.reload.title.should == 'foo'
-    Blog.connection.open_transactions.should == previous_open_transaction_count
+    expect(blog.reload.title).to eq('foo')
+    expect(Blog.connection.open_transactions).to eq(previous_open_transaction_count)
   end
   it "preserves the return value" do
     result = Blog.with_disposable_transaction do
       1
     end
-    result.should == 1
+    expect(result).to eq(1)
   end
   it "raises any StandardError occuring in the block" do
     expect do
@@ -53,37 +53,37 @@ describe "Transactional wrapping" do
   shared_examples_for "synthetic after_commit" do
     it "calls after_commit hooks at this open transaction level, but not above" do
       blog = Blog.create! :title => 'foo'
-      blog.called_after_commit.should == 1
-      blog.reload.title.should == 'foo'
+      expect(blog.called_after_commit).to eq(1)
+      expect(blog.reload.title).to eq('foo')
 
       blog.update_attributes! :title => 'bar'
-      blog.called_after_commit.should == 2
-      blog.reload.title.should == 'bar'
+      expect(blog.called_after_commit).to eq(2)
+      expect(blog.reload.title).to eq('bar')
 
       ActiveRecord::Base.connection.transaction(:requires_new => true) do
         blog.update_attributes! :title => 'quux'
-        blog.called_after_commit.should == 2
+        expect(blog.called_after_commit).to eq(2)
       end
-      blog.reload.title.should == 'quux'
+      expect(blog.reload.title).to eq('quux')
 
-      blog.called_after_commit.should == 3
+      expect(blog.called_after_commit).to eq(3)
       ActiveRecord::Base.connection.transaction(:requires_new => true) do
         blog.update_attributes! :title => 'ragz'
-        blog.called_after_commit.should == 3
+        expect(blog.called_after_commit).to eq(3)
         raise ActiveRecord::Rollback
       end
-      blog.called_after_commit.should == 3
-      blog.reload.title.should == 'quux'
+      expect(blog.called_after_commit).to eq(3)
+      expect(blog.reload.title).to eq('quux')
     end
 
     it "does not call after_commit hooks when an error is raised" do
       blog = Blog.create! :title => 'foo'
-      blog.called_after_commit.should == 1
+      expect(blog.called_after_commit).to eq(1)
 
       # raise the level at which a synthetic commit should take place
       Blog.with_disposable_transaction do
         blog.update_attributes! :title => 'ragz'
-        blog.called_after_commit.should == 2
+        expect(blog.called_after_commit).to eq(2)
       end
 
       # raise the level at which a synthetic commit should take place
@@ -91,33 +91,33 @@ describe "Transactional wrapping" do
         expect do
           ActiveRecord::Base.connection.transaction(:requires_new => true) do
             blog.update_attributes! :title => 'ragz'
-            blog.called_after_commit.should == 2
+            expect(blog.called_after_commit).to eq(2)
             raise "Something blows up"
           end
         end.to raise_error("Something blows up")
-        blog.called_after_commit.should == 2
-        blog.reload.title.should == 'foo'
+        expect(blog.called_after_commit).to eq(2)
+        expect(blog.reload.title).to eq('foo')
       end
 
-      blog.called_after_commit.should == 2
-      blog.reload.title.should == 'foo'
+      expect(blog.called_after_commit).to eq(2)
+      expect(blog.reload.title).to eq('foo')
     end
 
   end
 
   it "wraps describe blocks in a savepoint transaction" do
-    ActiveRecord::Base.connection.current_transaction.should be_a ActiveRecord::ConnectionAdapters::SavepointTransaction
+    expect(ActiveRecord::Base.connection.current_transaction).to be_a ActiveRecord::ConnectionAdapters::SavepointTransaction
   end
   it "wrapped the suite before this describe block" do
-    ActiveRecord::Base.connection.open_transactions.should == 2
+    expect(ActiveRecord::Base.connection.open_transactions).to eq(2)
   end
   it "considers this level as commitable" do
-    ActiveRecord::Base.connection.commit_at_open_transaction_level.should == 2
+    expect(ActiveRecord::Base.connection.commit_at_open_transaction_level).to eq(2)
   end
   it "does not consider a nested transaction to be commitable" do
     ActiveRecord::Base.connection.transaction(:requires_new => true) do
-      ActiveRecord::Base.connection.open_transactions.should == 3
-      ActiveRecord::Base.connection.commit_at_open_transaction_level.should == 2
+      expect(ActiveRecord::Base.connection.open_transactions).to eq(3)
+      expect(ActiveRecord::Base.connection.commit_at_open_transaction_level).to eq(2)
     end
   end
   it_behaves_like "synthetic after_commit"
@@ -125,16 +125,16 @@ describe "Transactional wrapping" do
   [:describe, :context].each do |nesting_method|
     send(nesting_method, "with a nested #{nesting_method}") do
       it "is wrapped in in a new savepoint transaction" do
-        ActiveRecord::Base.connection.current_transaction.should be_a ActiveRecord::ConnectionAdapters::SavepointTransaction
-        ActiveRecord::Base.connection.open_transactions.should == 3
+        expect(ActiveRecord::Base.connection.current_transaction).to be_a ActiveRecord::ConnectionAdapters::SavepointTransaction
+        expect(ActiveRecord::Base.connection.open_transactions).to eq(3)
       end
       it "considers this level as commitable" do
-        ActiveRecord::Base.connection.commit_at_open_transaction_level.should == 3
+        expect(ActiveRecord::Base.connection.commit_at_open_transaction_level).to eq(3)
       end
       it "does not consider a nested transaction to be commitable" do
         ActiveRecord::Base.connection.transaction(:requires_new => true) do
-          ActiveRecord::Base.connection.open_transactions.should == 4
-          ActiveRecord::Base.connection.commit_at_open_transaction_level.should == 3
+          expect(ActiveRecord::Base.connection.open_transactions).to eq(4)
+          expect(ActiveRecord::Base.connection.commit_at_open_transaction_level).to eq(3)
         end
       end
       it_behaves_like "synthetic after_commit"
@@ -142,16 +142,16 @@ describe "Transactional wrapping" do
       [:describe, :context].each do |nesting_method|
         send(nesting_method, "with a nested #{nesting_method}") do
           it "is wrapped in in a new savepoint transaction" do
-            ActiveRecord::Base.connection.current_transaction.should be_a ActiveRecord::ConnectionAdapters::SavepointTransaction
-            ActiveRecord::Base.connection.open_transactions.should == 4
+            expect(ActiveRecord::Base.connection.current_transaction).to be_a ActiveRecord::ConnectionAdapters::SavepointTransaction
+            expect(ActiveRecord::Base.connection.open_transactions).to eq(4)
           end
           it "considers this level as commitable" do
-            ActiveRecord::Base.connection.commit_at_open_transaction_level.should == 4
+            expect(ActiveRecord::Base.connection.commit_at_open_transaction_level).to eq(4)
           end
           it "does not consider a nested transaction to be commitable" do
             ActiveRecord::Base.connection.transaction(:requires_new => true) do
-              ActiveRecord::Base.connection.open_transactions.should == 5
-              ActiveRecord::Base.connection.commit_at_open_transaction_level.should == 4
+              expect(ActiveRecord::Base.connection.open_transactions).to eq(5)
+              expect(ActiveRecord::Base.connection.commit_at_open_transaction_level).to eq(4)
             end
           end
           it_behaves_like "synthetic after_commit"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefactory
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - developers@socialcast.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2014-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec_around_all