mongo-lock 1.0.0

data/spec/configure_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '.configure' do
+
+    after :each do
+      Mongo::Lock.class_variable_set('@@default_configuration',nil)
+    end
+
+    it "Creates a new configuration" do
+      first_configuration = Mongo::Lock.configuration
+      Mongo::Lock.configure
+      expect(Mongo::Lock.configuration).to_not be first_configuration
+    end
+
+    it "passes on options hash" do
+      Mongo::Lock.configure limit: 3
+      Mongo::Lock.configure frequency: 4
+      expect(Mongo::Lock.configuration.limit).to be 3
+      expect(Mongo::Lock.configuration.frequency).to be 4
+    end
+
+    it "passes on block" do
+      Mongo::Lock.configure frequency: 4
+      Mongo::Lock.configure do |config|
+        config.limit = 5
+      end
+      expect(Mongo::Lock.configuration.limit).to be 5
+      expect(Mongo::Lock.configuration.frequency).to be 4
+    end
+
+    context "when provided with nothing" do
+
+      it "sets default limit" do
+        expect(Mongo::Lock.configuration.limit).to be 100
+      end
+
+      it "sets default timeout_in" do
+        expect(Mongo::Lock.configuration.timeout_in).to be 10
+      end
+
+      it "sets default frequency" do
+        expect(Mongo::Lock.configuration.frequency).to be 1
+      end
+
+      it "sets default expires_after" do
+        expect(Mongo::Lock.configuration.expires_after).to be 10
+      end
+
+      it "sets default owner" do
+        expect(Mongo::Lock.configuration.owner).to eql "#{`hostname`.strip}:#{Process.pid}:#{Thread.object_id}"
+      end
+
+      it "sets default raise" do
+        expect(Mongo::Lock.configuration.raise).to be_false
+      end
+
+    end
+
+  end
+
+  describe '#configure' do
+
+    let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence' }
+
+    it "Creates a new configuration" do
+      first_configuration = lock.configuration
+      lock.configure
+      expect(lock.configuration).to_not be first_configuration
+    end
+
+    it "passes on options hash" do
+      lock.configure limit: 3
+      expect(lock.configuration.limit).to be 3
+    end
+
+    it "passes on block" do
+      lock.configure do |config|
+        config.limit = 5
+      end
+      expect(lock.configuration.limit).to be 5
+    end
+
+  end
+
+end

data/spec/ensure_indexes_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '.ensure_indexes' do
+
+    context "when provided with a MongoDB collection" do
+
+      before :each do
+        Mongo::Lock.ensure_indexes
+      end
+
+      it "should build ttl index for each collection" do
+        expect(collection.index_information['ttl_1']).to eql "v"=>1, "key"=> { "ttl"=>1 }, "ns"=>"mongo_lock_tests.locks", "name"=>"ttl_1", "expireAfterSeconds"=>0
+      end
+
+      it "should build an index on key and expires_at for each collection" do
+        expect(collection.index_information['key_1_owner_1_expires_at_1']).to eql "v"=>1, "key"=> { "key"=>1, "owner"=>1, "expires_at"=>1 }, "ns"=>"mongo_lock_tests.locks", "name"=>"key_1_owner_1_expires_at_1"
+      end
+
+    end
+
+  end
+
+end

data/spec/expired_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '#expired?' do
+
+    let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01 }
+
+    context "when the lock has not been acquired" do
+
+      it "returns false" do
+        sleep 0.02
+        expect(lock.expired?).to be_false
+      end
+
+    end
+
+    context "when the lock has expired" do
+
+      it "returns true" do
+        lock.acquire expires_after: 0.01
+        sleep 0.02
+        expect(lock.expired?).to be_true
+      end
+
+    end
+
+    context "when the lock hasn't expired" do
+
+      it "returns false" do
+        lock.acquire expires_after: 0.02
+        sleep 0.01
+        expect(lock.expired?).to be_false
+      end
+
+    end
+
+  end
+
+end

data/spec/extend_by_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expires_after: 0.01 }
+
+  describe '#extend_by' do
+
+    context "when a time is provided" do
+
+      it "extends the lock" do
+        lock.acquire
+        lock.extend_by 60
+        expect(collection.find(owner: 'spence', key: 'my_lock').first['expires_at']).to be_within(1.second).of(60.seconds.from_now)
+      end
+
+      it "returns true" do
+        lock.acquire
+        expect(lock.extend_by 50).to be_true
+      end
+
+    end
+
+    context "when the lock has expired" do
+
+      it "returns false" do
+        lock.acquire
+        sleep 0.02
+        expect(lock.extend_by 10).to be_false
+      end
+
+    end
+
+    context "when the lock has not been aquired yet" do
+
+      it "returns false" do
+        lock
+        expect(lock.extend_by 10).to be_false
+      end
+
+    end
+
+    context "when the lock has been released" do
+
+      it "returns false" do
+        lock.acquire
+        lock.release
+        expect(lock.extend_by 10).to be_false
+      end
+
+    end
+
+    context "when the raise option is set to true" do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expires_after: 0.01, raise: true }
+
+      context "and the lock has expired" do
+
+        it "raises a Mongo::Lock::NotExtendedError" do
+          lock.acquire
+          sleep 0.02
+          expect{lock.extend_by 10}.to raise_error Mongo::Lock::NotExtendedError
+        end
+
+      end
+
+      context "and the lock has not been aquired yet" do
+
+        it "raises a Mongo::Lock::NotExtendedError" do
+          lock
+          expect{lock.extend_by 10}.to raise_error Mongo::Lock::NotExtendedError
+        end
+
+      end
+
+      context "and the lock has been released" do
+
+        it "raises a Mongo::Lock::NotExtendedError" do
+          lock.acquire
+          lock.release
+          expect{lock.extend_by 10}.to raise_error Mongo::Lock::NotExtendedError
+        end
+
+      end
+
+    end
+
+    context "when options are provided" do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, raise: true }
+
+      it "they override the defaults" do
+        lock
+        expect(lock.extend_by 10, raise: false).to be_false
+      end
+
+    end
+
+  end
+
+  describe '#extend' do
+
+    it "calls #extend_by with the default expires_after config setting" do
+      expect(lock).to receive(:extend_by).with(lock.configuration.expires_after, {})
+      lock.extend
+    end
+
+    it "also passes options on" do
+      expect(lock).to receive(:extend_by).with(lock.configuration.expires_after, { raise: true })
+      lock.extend raise: true
+    end
+
+  end
+
+  describe '.extend_by!' do
+
+    it "calls .extend_by with raise errors option set to true" do
+      expect(lock).to receive(:extend_by).with( 10, { raise: true })
+      lock.extend_by! 10
+    end
+
+  end
+
+  describe '#extend!' do
+
+    it "calls .extend with raise errors option set to true" do
+      expect(lock).to receive(:extend_by).with(lock.configuration.expires_after, { raise: true })
+      lock.extend!
+    end
+
+  end
+
+end

data/spec/initialise_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '#initialise' do
+
+    let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01 }
+
+    it "creates a new configuration object" do
+      expect(lock.configuration).to be_a Mongo::Lock::Configuration
+    end
+
+    it "passes it the class configuration" do
+      Mongo::Lock.configure limit: 3
+      expect(lock.configuration.limit).to be 3
+    end
+
+    it "allows override of the class configuration" do
+      Mongo::Lock.configure limit: 3
+      lock = Mongo::Lock.new 'my_lock', limit: 4
+      expect(lock.configuration.limit).to be 4
+
+    end
+
+    context "when the key is already acquired by this owner" do
+
+      it "acquires that lock" do
+        collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
+        expect(lock.acquired?).to be_true
+      end
+
+    end
+
+  end
+
+end

data/spec/release_all_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  describe '.release_all' do
+
+    before :each do
+      Mongo::Lock.configure collections: { default: collection, other: other_collection }
+    end
+
+    let!(:locks) do
+      collection.insert key: 'tobies_lock', owner: 'tobie'
+      collection.insert key: 'spences_lock', owner: 'spence'
+      other_collection.insert key: 'spences_lock', owner: 'spence'
+    end
+
+    it "removes all locks from the database" do
+      Mongo::Lock.release_all
+      expect(collection.count({ key: 'spences_lock', owner: 'spence'})).to eql 0
+      expect(collection.count({ key: 'tobies_lock', owner: 'tobie'})).to eql 0
+      expect(other_collection.count({ key: 'spences_lock', owner: 'spence'})).to eql 0
+    end
+
+    context "when an owner is provided" do
+
+      before do
+        Mongo::Lock.release_all owner: 'spence'
+      end
+
+      it "doesn't release locks belonging to other owners" do
+        expect(collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+      it "does release locks belonging to that owner" do
+        Mongo::Lock.release_all owner: 'spence'
+        expect(collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+    end
+
+    context "when a collection symbol is provided" do
+
+      before do
+        Mongo::Lock.release_all collection: :other
+      end
+
+      it "does release locks in that collection" do
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+      it "doesn't release locks in other collections" do
+        expect(collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+    end
+
+    context "when a collection is provided" do
+
+      before do
+        Mongo::Lock.release_all collection: other_collection
+      end
+
+      it "does release locks in that collection" do
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+      it "doesn't release locks in other collections" do
+        expect(collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+    end
+
+  end
+
+end

data/spec/release_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe Mongo::Lock do
+
+  let(:lock) { Mongo::Lock.acquire('my_lock', owner: 'spence', expires_after: 0.1.seconds, timeout_in: 0.01, frequency: 0.01) }
+
+  describe '.release' do
+
+    it "creates a new Mongo::Lock instance" do
+      lock
+      expect(Mongo::Lock.release 'my_lock', owner: 'spence').to be_a Mongo::Lock
+    end
+
+    it "calls #release to release the lock" do
+      expect_any_instance_of(Mongo::Lock).to receive(:release)
+      Mongo::Lock.release 'my_lock', owner: 'spence'
+    end
+
+    context "when options are provided" do
+
+      it "passes them to the new lock" do
+        l = Mongo::Lock.release 'my_lock', owner: 'spence'
+        # expect(l.configuration.owner).to eql 'spence'
+      end
+
+    end
+
+  end
+
+  describe '#release' do
+
+    context "when lock is acquired" do
+
+      before :each do
+        collection.insert key: 'my_lock', owner: 'spence'
+      end
+
+      let(:lock) { Mongo::Lock.acquire 'my_lock', owner: 'spence' }
+
+      it "releases the lock" do
+        lock.release
+        expect(collection.find(key: 'my_lock', owner: 'spence').count).to be 0
+      end
+
+      it "returns true" do
+        expect(lock.release).to be_true
+      end
+
+    end
+
+    context "when the lock isn't acquired" do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', timeout_in: 0.01, frequency: 0.01 }
+
+      it "acquires the lock first" do
+        expect(lock).to receive(:acquire).and_call_original
+        lock.release
+      end
+
+      it "returns true" do
+        expect(lock.release).to be_true
+      end
+
+    end
+
+    context "when the lock isn't acquired and cant be" do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', timeout_in: 1, frequency: 0.01 }
+
+      it "returns false" do
+        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+        expect(lock.release timeout_in: 0.01).to be_false
+      end
+
+      it "doesn't release the lock" do
+        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+        lock.release timeout_in: 0.01
+        expect(collection.find(key: 'my_lock', owner: 'tobie').count).to be 1
+      end
+
+    end
+
+    context "when the lock was acquired but has since expired" do
+
+      it "returns true" do
+        lock
+        sleep 0.2
+        expect(lock.release).to be_true
+      end
+
+    end
+
+    context "when the lock was acquired but has already been released" do
+
+      it "returns true" do
+        lock.release
+        expect(lock.release).to be_true
+      end
+
+    end
+
+    context "when the lock is already acquired but by the same owner in a different instance" do
+
+      let (:different_instance) { Mongo::Lock.release 'my_lock', owner: 'spence' }
+
+      it "releases the lock" do
+        lock
+        different_instance.release
+        expect(collection.find(key: 'my_lock', owner: 'spence').count).to be 0
+      end
+
+      it "returns true" do
+        lock
+        expect(different_instance.release).to be_true
+      end
+
+    end
+
+    context "when the raise option is set to true" do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', raise: true, timeout_in: 0.1, frequency: 0.01  }
+
+      context "when the lock isn't acquired and cant be" do
+
+        it "raises Mongo::Lock::NotReleasedError" do
+          collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+          expect{ lock.release }.to raise_error Mongo::Lock::NotReleasedError
+        end
+
+      end
+
+    end
+
+    context "when options are provided" do
+
+      it "they override the defaults" do
+        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+        expect(lock.release owner: 'tobie').to be_true
+        expect(collection.find(key: 'my_lock', owner: 'tobie').count).to be 0
+      end
+
+    end
+
+  end
+
+  describe '.release!' do
+
+    it "calls .release with raise errors option set to true" do
+      expect(Mongo::Lock).to receive(:init_and_send).with('my_lock', { owner: 'tobie' }, :release!)
+      Mongo::Lock.release! 'my_lock', owner: 'tobie'
+    end
+
+  end
+
+  describe '#release!' do
+
+    it "calls .release with raise errors option set to true" do
+      expect(lock).to receive(:release).with({ limit: 3, raise: true })
+      lock.release! limit: 3
+    end
+
+  end
+
+end