lockable.rb

require 'active_support/concern'

module Lockable
  @locked = false

  def locked?
    @locked == true
  end

  def lock!
    raise Exception, 'You should define the lock! method inside your class'
  end

  def unlock!
    raise Exception, 'You should define the unlock! method inside your class'
  end

  def while_locked
    return false if locked?

    lock!
    needs_unlock = true

    yield
  ensure
    unlock! if needs_unlock
  end
end

lockable_spec.rb

require 'spec_helper'

class FakeModelWithPersistenceMethods
  include Lockable

  attr_accessor :locked

  def lock!
    @locked = true
  end

  def unlock!
    @locked = false
  end

  def some_method; end
end

class FakeModelWithoutPersistenceMethods
  include Lockable

  attr_accessor :locked
end

describe Lockable do
  context 'model with persistence methods' do
    let(:object) { FakeModelWithPersistenceMethods.new }

    context 'unlocked' do
      before { object.locked = false }

      it 'receive lock! while running the while_locked block' do
        object.should_receive(:lock!)
        object.while_locked do
          object.some_method
        end
      end

      it 'receive unlock! while running the while_locked block' do
        object.should_receive(:unlock!)
        object.while_locked do
          object.some_method
        end
      end

      it 'runs the while_locked block' do
        object.should_receive(:some_method)
        object.while_locked do
          object.some_method
        end
      end
    end

    context 'locked' do
      before { object.locked = true }

      it 'do not receive lock! while running the while_locked block' do
        object.should_not_receive(:lock!)
        object.while_locked do
          object.some_method
        end
      end

      it 'do not receive unlock! while running the while_locked block' do
        object.should_not_receive(:unlock!)
        object.while_locked do
          object.some_method
        end
      end

      it 'do not run the while_locked block' do
        object.should_not_receive(:some_method)
        object.while_locked do
          object.some_method
        end
      end
    end
  end

  context 'model without persistence methods' do
    let(:object) { FakeModelWithoutPersistenceMethods.new }

    it 'raise exception while trying to lock the object' do
      expect do
        object.while_locked do
          object.some_method
        end
      end.to raise_error 'You should define the lock! method inside your class'
    end

    it 'raise exception while trying to unlock the object' do
      object.stub(:lock!)

      expect do
        object.while_locked do
          object.some_method
        end
      end.to raise_error 'You should define the unlock! method inside your class'
    end
  end
end