mongo-lock 1.1.4 → 1.2.0

data/spec/examples/acquired_example.rb

@@ -0,0 +1,54 @@
+shared_examples "MongoLock driver that can find if a lock is acquired" do
+
+  describe Mongo::Lock do
+
+    describe '#acquired?' do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01 }
+
+      context "when the lock has been acquired" do
+
+        it "returns true" do
+          lock.acquire
+          expect(lock.acquired?).to be_true
+        end
+
+      end
+
+      context "when the lock hasn't been acquired" do
+
+        it "returns false" do
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
+          lock.acquire
+          expect(lock.acquired?).to be_false
+        end
+
+      end
+
+      context "when the lock was acquired but has since expired" do
+
+        let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 0.1 }
+
+        it "returns false" do
+          lock.acquire
+          sleep 0.2
+          expect(lock.acquired?).to be_false
+        end
+
+      end
+
+      context "when the lock was acquired but has since been released" do
+
+        it "returns false" do
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
+          lock.acquire
+          lock.release
+          expect(lock.acquired?).to be_false
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/examples/available_example.rb

@@ -0,0 +1,70 @@
+shared_examples "MongoLock driver that can find if a lock is available" do
+
+  describe Mongo::Lock do
+
+    describe '.available?' do
+
+      it "creates a new Mongo::Lock instance and returns whether it is available" do
+        expect(Mongo::Lock.available? 'my_lock').to be_true
+      end
+
+      it "calls #available?" do
+        expect_any_instance_of(Mongo::Lock).to receive(:available?)
+        Mongo::Lock.available? 'my_lock'
+      end
+
+      context "when options are provided" do
+
+        it "passes them to the new lock" do
+          Mongo::Lock.acquire 'my_lock', { owner: 'spence' }
+          expect(Mongo::Lock.available?('my_lock', { owner: 'spence' })).to be_true
+        end
+
+      end
+
+    end
+
+    describe '#available?' do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01 }
+
+      context "when the lock is available" do
+
+        it "returns true" do
+          expect(lock.available?).to be_true
+        end
+
+      end
+
+      context "when the lock is expired" do
+
+        it "returns true" do
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
+          expect(lock.available?).to be_true
+        end
+
+      end
+
+      context "when the lock is already acquired but by this owner" do
+
+        it "returns true" do
+          my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
+          expect(lock.available?).to be_true
+        end
+
+      end
+
+      context "when the lock is already acquired" do
+
+        it "returns false" do
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
+          expect(lock.available?).to be_false
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/examples/clear_expired_example.rb

@@ -0,0 +1,100 @@
+shared_examples "MongoLock driver that can clear expired locks" do
+
+  describe Mongo::Lock do
+
+    describe '.clear_expired' do
+
+      before :each do
+        Mongo::Lock.configure collections: { default: collection1, other: collection2 }
+      end
+
+      let!(:locks) do
+        my_collection.insert key: 'tobies_lock', owner: 'tobie', expires_at: 1.minute.from_now, ttl: 1.minute.from_now
+        my_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
+        other_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
+        another_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
+      end
+
+      it "deletes expired locks in all reegistered collections" do
+        Mongo::Lock.configure collections: { default: collection1, other: collection2 }
+        other_collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.from_now
+        Mongo::Lock.clear_expired
+        expect(my_collection.find().count).to be 1
+        expect(other_collection.find().count).to be 1
+      end
+
+      context "when a collection is provided" do
+
+        before do
+          Mongo::Lock.clear_expired collection: collection2
+        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 symbol is provided" do
+
+        before do
+          Mongo::Lock.clear_expired 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 collections are provided" do
+
+        before do
+          Mongo::Lock.clear_expired collections: [collection3, collection2]
+        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.clear_expired collections: { another_collection: collection3, other_collection: collection2 }
+          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
+
+end

data/spec/examples/ensure_indexes_example.rb

@@ -0,0 +1,38 @@
+shared_examples "MongoLock driver that can ensure indexes" do
+
+  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
+          sleep 0.1
+          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
+          sleep 0.1
+          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
+
+end

data/spec/examples/expired_example.rb

@@ -0,0 +1,41 @@
+shared_examples "MongoLock driver that can find if a lock have expired" do
+
+  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
+
+end

data/spec/examples/extend_by_example.rb

@@ -0,0 +1,137 @@
+shared_examples "MongoLock driver that can extend locks" do
+
+  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, should_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, should_raise: true }
+
+        it "they override the defaults" do
+          lock
+          expect(lock.extend_by 10, should_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, { should_raise: true })
+        lock.extend should_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, { should_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, { should_raise: true })
+        lock.extend!
+      end
+
+    end
+
+  end
+
+end

data/spec/examples/release_all_example.rb

@@ -0,0 +1,117 @@
+shared_examples "MongoLock driver that can release all locks" do
+
+  describe Mongo::Lock do
+
+    describe '.release_all' do
+
+      before :each do
+        Mongo::Lock.configure collections: { default: collection1, other: collection2 }
+      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: collection2
+        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: [collection3, collection2]
+        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: collection3, other_collection: collection2 }
+          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
+
+end