mongo-lock 1.1.4 → 1.2.0

data/spec/ensure_indexes_spec.rb

@@ -1,34 +0,0 @@
-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(my_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(my_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
-
-      it "should mean expired locks are automatically cleaned", :slow do
-        Mongo::Lock.acquire 'my_lock', owner: 'spence', expire_in: 0
-        Mongo::Lock.acquire 'other_lock', owner: 'spence', expire_in: 500
-        while my_collection.find(owner: 'spence').count != 1
-          sleep 1
-        end
-        expect(my_collection.find(owner: 'spence').count).to be 1
-      end
-
-    end
-
-  end
-
-end

data/spec/expired_spec.rb

@@ -1,39 +0,0 @@
-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 expire_in: 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 expire_in: 0.1
-        expect(lock.expired?).to be_false
-      end
-
-    end
-
-  end
-
-end

data/spec/extend_by_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Lock do
-
-  let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 1 }
-
-  describe '#extend_by' do
-
-    context "when a time is provided" do
-
-      it "extends the lock" do
-        lock.acquire
-        lock.extend_by 60
-        expect(my_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
-
-      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 0.11 }
-
-      it "returns false" do
-        lock.acquire
-        sleep 0.11
-        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, expire_in: 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 expire_in config setting" do
-      expect(lock).to receive(:extend_by).with(lock.configuration.expire_in, {})
-      lock.extend
-    end
-
-    it "also passes options on" do
-      expect(lock).to receive(:extend_by).with(lock.configuration.expire_in, { 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.expire_in, { raise: true })
-      lock.extend!
-    end
-
-  end
-
-end

data/spec/release_all_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Lock do
-
-  describe '.release_all' do
-
-    before :each do
-      Mongo::Lock.configure collections: { default: my_collection, other: other_collection }
-    end
-
-    let!(:locks) do
-      my_collection.insert key: 'tobies_lock', owner: 'tobie'
-      my_collection.insert key: 'spences_lock', owner: 'spence'
-      other_collection.insert key: 'spences_lock', owner: 'spence'
-      another_collection.insert key: 'spences_lock', owner: 'spence'
-    end
-
-    it "removes all locks from the database" do
-      Mongo::Lock.release_all
-      expect(my_collection.count({ key: 'spences_lock', owner: 'spence'})).to eql 0
-      expect(my_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(my_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(my_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(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(my_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(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-      end
-
-    end
-
-    context "when collections are provided" do
-
-      before do
-        Mongo::Lock.release_all collections: [another_collection, other_collection]
-      end
-
-      it "does release locks in those collection" do
-        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-        expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-      end
-
-      it "doesn't release locks in other collections" do
-        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-      end
-
-      context "when collections is provided as a hash" do
-
-        before do
-          Mongo::Lock.release_all collections: { another_collection: another_collection, other_collection: other_collection }
-        end
-
-        it "does release locks in those collection" do
-          expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-          expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
-        end
-
-        it "doesn't release locks in other collections" do
-          expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-          expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/spec/release_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Lock do
-
-  let(:lock) { Mongo::Lock.acquire('my_lock', owner: 'spence', expire_in: 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
-        my_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(my_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
-        my_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
-        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
-        lock.release timeout_in: 0.01
-        expect(my_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(my_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
-          my_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
-        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
-        expect(lock.release owner: 'tobie').to be_true
-        expect(my_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