mongoid-locker 0.2.1 → 0.3.0

data/lib/mongoid/locker/wrapper.rb

@@ -10,12 +10,12 @@ module Mongoid
       # @param [Hash] The Mongoid query
       # @param [Hash] The Mongoid setter
       # @return [Boolean] true if the document was successfully updated, false otherwise
-      def self.update klass, query, setter
+      def self.update(klass, query, setter)
         error_obj =
           if IS_OLD_MONGOID
-            klass.collection.update(query, setter, :safe => true)
+            klass.collection.update(query, setter, safe: true)
           else
-            klass.with(:safe => true).collection.find(query).update(setter)
+            klass.with(safe: true).collection.find(query).update(setter)
           end
 
         error_obj['n'] == 1
@@ -25,14 +25,14 @@ module Mongoid
       #
       # @param [Class] The model instance
       # @return [Time] The timestamp of when the document is locked until, nil if not locked.
-      def self.locked_until doc
+      def self.locked_until(doc)
         existing_query = {
-          :_id => doc.id,
-          :locked_until => {'$exists' => true}
+          _id: doc.id,
+          locked_until: { '$exists' => true }
         }
 
         if IS_OLD_MONGOID
-          existing = doc.class.collection.find_one(existing_query, :fields => {:locked_until => 1})
+          existing = doc.class.collection.find_one(existing_query, fields: { locked_until: 1 })
           existing ? existing['locked_until'] : nil
         else
           existing = doc.class.where(existing_query).limit(1).only(:locked_until).first

data/mongoid-locker.gemspec

@@ -2,14 +2,15 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: mongoid-locker 0.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "mongoid-locker"
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aidan Feldman"]
-  s.date = "2012-11-28"
+  s.date = "2014-07-01"
   s.description = "Allows multiple processes to operate on individual documents in MongoDB while ensuring that only one can act at a time."
   s.email = "aidan.feldman@gmail.com"
   s.extra_rdoc_files = [
@@ -19,11 +20,11 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
+    ".rubocop.yml",
     ".travis.yml",
-    "Appraisals",
     "CHANGELOG.md",
+    "CONTRIBUTING.md",
     "Gemfile",
-    "Gemfile.lock",
     "Guardfile",
     "LICENSE.txt",
     "README.md",
@@ -35,53 +36,53 @@ Gem::Specification.new do |s|
     "demo/instagram.png",
     "demo/showoff.css",
     "demo/showoff.md",
-    "gemfiles/mongoid2.gemfile",
-    "gemfiles/mongoid3.gemfile",
     "lib/mongoid-locker.rb",
     "lib/mongoid/locker.rb",
     "lib/mongoid/locker/wrapper.rb",
     "mongoid-locker.gemspec",
-    "spec/database.yml",
+    "spec/database2.yml",
+    "spec/database3.yml",
+    "spec/database4.yml",
     "spec/mongoid-locker_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/afeld/mongoid-locker"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "2.1.11"
   s.summary = "Document-level locking for MongoDB via Mongoid"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<mongoid>, ["<= 3.1", ">= 2.4"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.8"])
+      s.add_runtime_dependency(%q<mongoid>, ["~> 4.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.1"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8"])
       s.add_development_dependency(%q<guard-rspec>, [">= 0"])
-      s.add_development_dependency(%q<bson_ext>, [">= 0"])
+      s.add_development_dependency(%q<rb-fsevent>, ["~> 0.9.1"])
       s.add_development_dependency(%q<rake>, [">= 0"])
-      s.add_development_dependency(%q<appraisal>, [">= 0"])
+      s.add_development_dependency(%q<rubocop>, ["= 0.24.0"])
     else
-      s.add_dependency(%q<mongoid>, ["<= 3.1", ">= 2.4"])
-      s.add_dependency(%q<rspec>, ["~> 2.8"])
+      s.add_dependency(%q<mongoid>, ["~> 4.0"])
+      s.add_dependency(%q<rspec>, ["~> 3.0"])
       s.add_dependency(%q<bundler>, ["~> 1.1"])
       s.add_dependency(%q<jeweler>, ["~> 1.8"])
       s.add_dependency(%q<guard-rspec>, [">= 0"])
-      s.add_dependency(%q<bson_ext>, [">= 0"])
+      s.add_dependency(%q<rb-fsevent>, ["~> 0.9.1"])
       s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<appraisal>, [">= 0"])
+      s.add_dependency(%q<rubocop>, ["= 0.24.0"])
     end
   else
-    s.add_dependency(%q<mongoid>, ["<= 3.1", ">= 2.4"])
-    s.add_dependency(%q<rspec>, ["~> 2.8"])
+    s.add_dependency(%q<mongoid>, ["~> 4.0"])
+    s.add_dependency(%q<rspec>, ["~> 3.0"])
     s.add_dependency(%q<bundler>, ["~> 1.1"])
     s.add_dependency(%q<jeweler>, ["~> 1.8"])
     s.add_dependency(%q<guard-rspec>, [">= 0"])
-    s.add_dependency(%q<bson_ext>, [">= 0"])
+    s.add_dependency(%q<rb-fsevent>, ["~> 0.9.1"])
     s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<appraisal>, [">= 0"])
+    s.add_dependency(%q<rubocop>, ["= 0.24.0"])
   end
 end
 

data/spec/database2.yml

@@ -0,0 +1,4 @@
+test:
+  # for Mongoid 2
+  host: localhost
+  database: mongoid_locker_test

data/spec/{database.yml → database3.yml}

@@ -1,8 +1,4 @@
 test:
-  # for Mongoid 2
-  host: localhost
-  database: mongoid_locker_test
-
   # for Mongoid 3
   sessions:
     default:

data/spec/database4.yml

@@ -0,0 +1,7 @@
+test:
+  # for Mongoid 4
+  sessions:
+    default:
+      database: mongoid_locker_test
+      hosts:
+        - localhost:27017

data/spec/mongoid-locker_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe Mongoid::Locker do
-  def remove_class klass
+  def remove_class(klass)
     Object.send :remove_const, klass.to_s.to_sym
   end
 
@@ -11,10 +11,10 @@ describe Mongoid::Locker do
       include Mongoid::Document
       include Mongoid::Locker
 
-      field :account_balance, :type => Integer # easier to test than Float
+      field :account_balance, type: Integer # easier to test than Float
     end
 
-    @user = User.create! :account_balance => 20
+    @user = User.create! account_balance: 20
   end
 
   after do
@@ -22,70 +22,69 @@ describe Mongoid::Locker do
     remove_class User
   end
 
-
-  describe "#locked?" do
+  describe '#locked?' do
     it "shouldn't be locked when created" do
-      @user.locked?.should be_false
+      expect(@user.locked?).to be false
     end
 
-    it "should be true when locked" do
+    it 'should be true when locked' do
       @user.with_lock do
-        @user.locked?.should be_true
+        expect(@user.locked?).to be true
       end
     end
 
-    it "should respect the expiration" do
+    it 'should respect the expiration' do
       User.timeout_lock_after 1
 
       @user.with_lock do
         sleep 2
-        @user.locked?.should be_false
+        expect(@user.locked?).to be false
       end
     end
 
-    it "should be true for a different instance" do
+    it 'should be true for a different instance' do
       @user.with_lock do
-        User.first.locked?.should be_true
+        expect(User.first.locked?).to be true
       end
     end
   end
 
-  describe "#has_lock?" do
+  describe '#has_lock?' do
     it "shouldn't be has_lock when created" do
-      @user.has_lock?.should be_false
+      expect(@user.has_lock?).to be false
     end
 
-    it "should be true when has_lock" do
+    it 'should be true when has_lock' do
       @user.with_lock do
-        @user.has_lock?.should be_true
+        expect(@user.has_lock?).to be true
       end
     end
 
-    it "should respect the expiration" do
+    it 'should respect the expiration' do
       User.timeout_lock_after 1
 
       @user.with_lock do
         sleep 2
-        @user.has_lock?.should be_false
+        expect(@user.has_lock?).to be false
       end
     end
 
-    it "should be false for a different instance" do
+    it 'should be false for a different instance' do
       @user.with_lock do
-        User.first.has_lock?.should be_false
+        expect(User.first.has_lock?).to be false
       end
     end
   end
 
-  describe "#with_lock" do
-    it "should lock and unlock the user" do
+  describe '#with_lock' do
+    it 'should lock and unlock the user' do
       @user.with_lock do
-        @user.should be_locked
-        User.first.should be_locked
+        expect(@user).to be_locked
+        expect(User.first).to be_locked
       end
 
-      @user.should_not be_locked
-      @user.reload.should_not be_locked
+      expect(@user).to_not be_locked
+      expect(@user.reload).to_not be_locked
     end
 
     it "shouldn't save the full document" do
@@ -93,21 +92,21 @@ describe Mongoid::Locker do
         @user.account_balance = 10
       end
 
-      @user.account_balance.should eq(10)
-      User.first.account_balance.should eq(20)
+      expect(@user.account_balance).to eq(10)
+      expect(User.first.account_balance).to eq(20)
     end
 
-    it "should handle errors gracefully" do
+    it 'should handle errors gracefully' do
       expect {
         @user.with_lock do
-          raise "booyah!"
+          fail 'booyah!'
         end
       }.to raise_error
 
-      @user.reload.should_not be_locked
+      expect(@user.reload).to_not be_locked
     end
 
-    it "should complain if trying to lock locked doc" do
+    it 'should complain if trying to lock locked doc' do
       @user.with_lock do
         user_dup = User.first
 
@@ -115,45 +114,105 @@ describe Mongoid::Locker do
           user_dup.with_lock do
             fail "shouldn't get the lock"
           end
-        }.to raise_error(Mongoid::LockError)
+        }.to raise_error(Mongoid::Locker::LockError)
       end
     end
 
-    it "should handle recursive calls" do
+    it 'should handle recursive calls' do
       @user.with_lock do
         @user.with_lock do
           @user.account_balance = 10
         end
       end
 
-      @user.account_balance.should eq(10)
+      expect(@user.account_balance).to eq(10)
     end
 
-    it "should wait until the lock times out, if desired" do
+    it 'should wait until the lock times out, if desired' do
       User.timeout_lock_after 1
 
       @user.with_lock do
         user_dup = User.first
 
-        user_dup.with_lock :wait => true do
+        user_dup.with_lock wait: true do
           user_dup.account_balance = 10
           user_dup.save!
         end
       end
 
-      @user.reload.account_balance.should eq(10)
+      expect(@user.reload.account_balance).to eq(10)
+    end
+
+    it 'should, by default, reload the row after acquiring the lock' do
+      expect(@user).to receive(:reload)
+      @user.with_lock do
+        # no-op
+      end
+    end
+
+    it 'should allow override of the default reload behavior' do
+      expect(@user).to_not receive(:reload)
+      @user.with_lock reload: false do
+        # no-op
+      end
+    end
+
+    it 'should, by default, not retry' do
+      expect(@user).to receive(:acquire_lock).once.and_return(true)
+      @user.with_lock do
+        user_dup = User.first
+
+        user_dup.with_lock do
+          # no-op
+        end
+      end
+    end
+
+    it 'should retry the number of times given, if desired' do
+      allow(@user).to receive(:acquire_lock).and_return(false)
+      allow(Mongoid::Locker::Wrapper).to receive(:locked_until).and_return(Time.now)
+
+      expect(@user).to receive(:acquire_lock).exactly(6).times
+      expect {
+        @user.with_lock retries: 5 do
+          # no-op
+        end
+      }.to raise_error(Mongoid::Locker::LockError)
+    end
+
+    it 'should, by default, when retrying, sleep until the lock expires' do
+      allow(@user).to receive(:acquire_lock).and_return(false)
+      allow(Mongoid::Locker::Wrapper).to receive(:locked_until).and_return(Time.now + 5.seconds)
+      allow(@user).to receive(:sleep) { |time| expect(time).to be_within(0.1).of(5) }
+
+      expect {
+        @user.with_lock retries: 1 do
+          # no-op
+        end
+      }.to raise_error(Mongoid::Locker::LockError)
+    end
+
+    it 'should sleep for the time given, if desired' do
+      allow(@user).to receive(:acquire_lock).and_return(false)
+      allow(@user).to receive(:sleep) { |time| expect(time).to be_within(0.1).of(3) }
+
+      expect {
+        @user.with_lock(retries: 1, retry_sleep: 3) do
+          # no-op
+        end
+      }.to raise_error(Mongoid::Locker::LockError)
     end
 
-    it "should override the default timeout" do
+    it 'should override the default timeout' do
       User.timeout_lock_after 1
 
       expiration = (Time.now + 3).to_i
-      @user.with_lock :timeout => 3 do
-        @user.locked_until.to_i.should eq(expiration)
+      @user.with_lock timeout: 3 do
+        expect(@user.locked_until.to_i).to eq(expiration)
       end
     end
 
-    it "should reload the document if it needs to wait for a lock" do
+    it 'should reload the document if it needs to wait for a lock' do
       User.timeout_lock_after 1
 
       @user.with_lock do
@@ -162,33 +221,33 @@ describe Mongoid::Locker do
         @user.account_balance = 10
         @user.save!
 
-        user_dup.account_balance.should eq(20)
-        user_dup.with_lock :wait => true do
-          user_dup.account_balance.should eq(10)
+        expect(user_dup.account_balance).to eq(20)
+        user_dup.with_lock wait: true do
+          expect(user_dup.account_balance).to eq(10)
         end
       end
     end
 
-    it "should succeed for subclasses" do
+    it 'should succeed for subclasses' do
       class Admin < User
       end
 
       admin = Admin.create!
 
       admin.with_lock do
-        admin.should be_locked
-        Admin.first.should be_locked
+        expect(admin).to be_locked
+        expect(Admin.first).to be_locked
       end
 
-      admin.should_not be_locked
-      admin.reload.should_not be_locked
+      expect(admin).to_not be_locked
+      expect(admin.reload).to_not be_locked
 
       remove_class Admin
     end
   end
 
-  describe ".timeout_lock_after" do
-    it "should ignore the lock if it has timed out" do
+  describe '.timeout_lock_after' do
+    it 'should ignore the lock if it has timed out' do
       User.timeout_lock_after 1
 
       @user.with_lock do
@@ -201,10 +260,10 @@ describe Mongoid::Locker do
         end
       end
 
-      @user.reload.account_balance.should eq(10)
+      expect(@user.reload.account_balance).to eq(10)
     end
 
-    it "should be independent for different classes" do
+    it 'should be independent for different classes' do
       class Account
         include Mongoid::Document
         include Mongoid::Locker
@@ -213,28 +272,28 @@ describe Mongoid::Locker do
       User.timeout_lock_after 1
       Account.timeout_lock_after 2
 
-      User.lock_timeout.should eq(1)
+      expect(User.lock_timeout).to eq(1)
 
       remove_class Account
     end
   end
 
-  describe ".locked" do
-    it "should return the locked documents" do
-      user2 = User.create!
+  describe '.locked' do
+    it 'should return the locked documents' do
+      User.create!
 
       @user.with_lock do
-        User.locked.to_a.should eq([@user])
+        expect(User.locked.to_a).to eq([@user])
       end
     end
   end
 
-  describe ".unlocked" do
-    it "should return the unlocked documents" do
+  describe '.unlocked' do
+    it 'should return the unlocked documents' do
       user2 = User.create!
 
       @user.with_lock do
-        User.unlocked.to_a.should eq([user2])
+        expect(User.unlocked.to_a).to eq([user2])
       end
     end
   end