acts_as_tenant 0.2.8 → 0.2.9

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+0.2.9
+-----
+* Added support for many-to-many associations (thx Nucleoid)
+
 0.2.8
 -----
 * Added dependencies to gemspec (thx aaronrenner)

data/lib/acts_as_tenant/model_extensions.rb

@@ -1,117 +1,117 @@
-# ActsAsTenant
-
-
-module ActsAsTenant
-  
-  class << self
-    cattr_accessor :tenant_class
-
-    # This will also work whithin Fibers:
-    # http://devblog.avdi.org/2012/02/02/ruby-thread-locals-are-also-fiber-local/
-    def current_tenant=(tenant)
-      Thread.current[:current_tenant] = tenant
-    end
-
-    def current_tenant
-      Thread.current[:current_tenant]
-    end
-
-    # Sets the current_tenant within the given block
-    def with_tenant(tenant, &block)
-      if block.nil?
-        raise ArgumentError, "block required"
-      end
-
-      old_tenant = self.current_tenant
-      self.current_tenant = tenant
-
-      block.call
-
-      self.current_tenant= old_tenant
-    end
-  end
-  
-  module ModelExtensions
-    extend ActiveSupport::Concern
-  
-    # Alias the v_uniqueness_of method so we can scope it to the current tenant when relevant
-  
-    module ClassMethods
-    
-      def acts_as_tenant(association = :account)
-        
-        # Method that enables checking if a class is scoped by tenant
-        def self.is_scoped_by_tenant?
-          true
-        end
-        
-        ActsAsTenant.tenant_class ||= association
-        
-        # Setup the association between the class and the tenant class
-        belongs_to association
-      
-        # get the tenant model and its foreign key
-        reflection = reflect_on_association association
-        
-        # As the "foreign_key" method changed name in 3.1 we check for backward compatibility 
-        if reflection.respond_to?(:foreign_key)
-          fkey = reflection.foreign_key
-        else
-          fkey = reflection.association_foreign_key
-        end
-    
-        # set the current_tenant on newly created objects
-        before_validation Proc.new {|m|
-          return unless ActsAsTenant.current_tenant
-          m.send "#{association}_id=".to_sym, ActsAsTenant.current_tenant.id
-        }, :on => :create
-    
-        # set the default_scope to scope to current tenant
-        default_scope lambda {
-          where({fkey => ActsAsTenant.current_tenant.id}) if ActsAsTenant.current_tenant
-        }
-    
-        # Rewrite accessors to make tenant foreign_key/association immutable
-        define_method "#{fkey}=" do |integer|  
-          if new_record?
-            write_attribute(fkey, integer)  
-          else
-            raise "#{fkey} is immutable! [ActsAsTenant]"
-          end  
-        end
-      
-        define_method "#{association}=" do |model|  
-          if new_record?
-            super(model) 
-          else
-            raise "#{association} is immutable! [ActsAsTenant]"
-          end  
-        end
-      
-        # add validation of associations against tenant scope
-        # we can't do this for polymorphic associations so we 
-        # exempt them
-        reflect_on_all_associations.each do |a|
-          unless a == reflection || a.macro == :has_many || a.macro == :has_one || a.options[:polymorphic] 
-            # check if the association is aliasing another class, if so 
-            # find the unaliased class name
-            association_class =  a.options[:class_name].nil? ? a.name.to_s.classify.constantize : a.options[:class_name].constantize
-            validates_each a.foreign_key.to_sym do |record, attr, value|
-              # Invalidate the association unless the parent is known to the tenant or no association has
-              # been set.
-              record.errors.add attr, "is invalid [ActsAsTenant]" unless value.nil? || association_class.where(:id => value).present?
-            end
-          end
-        end 
-      end
-      
-      def validates_uniqueness_to_tenant(fields, args ={})
-        raise "[ActsAsTenant] validates_uniqueness_to_tenant: no current tenant" unless respond_to?(:is_scoped_by_tenant?)
-        tenant_id = lambda { "#{ActsAsTenant.tenant_class.to_s.downcase}_id"}.call
-        args[:scope].nil? ? args[:scope] = tenant_id : args[:scope] << tenant_id
-        validates_uniqueness_of(fields, args)
-      end
-      
-    end
-  end
-end
+# ActsAsTenant
+
+
+module ActsAsTenant
+  
+  class << self
+    cattr_accessor :tenant_class
+
+    # This will also work whithin Fibers:
+    # http://devblog.avdi.org/2012/02/02/ruby-thread-locals-are-also-fiber-local/
+    def current_tenant=(tenant)
+      Thread.current[:current_tenant] = tenant
+    end
+
+    def current_tenant
+      Thread.current[:current_tenant]
+    end
+
+    # Sets the current_tenant within the given block
+    def with_tenant(tenant, &block)
+      if block.nil?
+        raise ArgumentError, "block required"
+      end
+
+      old_tenant = self.current_tenant
+      self.current_tenant = tenant
+
+      block.call
+
+      self.current_tenant= old_tenant
+    end
+  end
+  
+  module ModelExtensions
+    extend ActiveSupport::Concern
+  
+    # Alias the v_uniqueness_of method so we can scope it to the current tenant when relevant
+  
+    module ClassMethods
+    
+      def acts_as_tenant(association = :account)
+        
+        # Method that enables checking if a class is scoped by tenant
+        def self.is_scoped_by_tenant?
+          true
+        end
+        
+        ActsAsTenant.tenant_class ||= association
+        
+        # Setup the association between the class and the tenant class
+        belongs_to association
+      
+        # get the tenant model and its foreign key
+        reflection = reflect_on_association association
+        
+        # As the "foreign_key" method changed name in 3.1 we check for backward compatibility 
+        if reflection.respond_to?(:foreign_key)
+          fkey = reflection.foreign_key
+        else
+          fkey = reflection.association_foreign_key
+        end
+    
+        # set the current_tenant on newly created objects
+        before_validation Proc.new {|m|
+          return unless ActsAsTenant.current_tenant
+          m.send "#{association}_id=".to_sym, ActsAsTenant.current_tenant.id
+        }, :on => :create
+    
+        # set the default_scope to scope to current tenant
+        default_scope lambda {
+          where({fkey => ActsAsTenant.current_tenant.id}) if ActsAsTenant.current_tenant
+        }
+    
+        # Rewrite accessors to make tenant foreign_key/association immutable
+        define_method "#{fkey}=" do |integer|  
+          if new_record?
+            write_attribute(fkey, integer)  
+          else
+            raise "#{fkey} is immutable! [ActsAsTenant]"
+          end  
+        end
+      
+        define_method "#{association}=" do |model|  
+          if new_record?
+            super(model) 
+          else
+            raise "#{association} is immutable! [ActsAsTenant]"
+          end  
+        end
+      
+        # add validation of associations against tenant scope
+        # we can't do this for polymorphic associations so we 
+        # exempt them
+        reflect_on_all_associations.each do |a|
+          unless a == reflection || a.macro == :has_many || a.macro == :has_one || a.macro == :has_and_belongs_to_many || a.options[:polymorphic]
+            # check if the association is aliasing another class, if so 
+            # find the unaliased class name
+            association_class =  a.options[:class_name].nil? ? a.name.to_s.classify.constantize : a.options[:class_name].constantize
+            validates_each a.foreign_key.to_sym do |record, attr, value|
+              # Invalidate the association unless the parent is known to the tenant or no association has
+              # been set.
+              record.errors.add attr, "is invalid [ActsAsTenant]" unless value.nil? || association_class.where(:id => value).present?
+            end
+          end
+        end 
+      end
+      
+      def validates_uniqueness_to_tenant(fields, args ={})
+        raise "[ActsAsTenant] validates_uniqueness_to_tenant: no current tenant" unless respond_to?(:is_scoped_by_tenant?)
+        tenant_id = lambda { "#{ActsAsTenant.tenant_class.to_s.downcase}_id"}.call
+        args[:scope].nil? ? args[:scope] = tenant_id : args[:scope] << tenant_id
+        validates_uniqueness_of(fields, args)
+      end
+      
+    end
+  end
+end

data/lib/acts_as_tenant/version.rb

@@ -1,3 +1,3 @@
 module ActsAsTenant
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/spec/model_extensions_spec.rb

@@ -1,250 +1,298 @@
-require 'spec_helper'
-
-# Setup the db
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :accounts, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :projects, :force => true do |t|
-    t.column :name, :string
-    t.column :account_id, :integer
-  end
-  
-  create_table :managers, :force => true do |t|
-    t.column :name, :string
-    t.column :project_id, :integer
-    t.column :account_id, :integer
-  end
-  
-  create_table :tasks, :force => true do |t|
-    t.column :name, :string
-    t.column :account_id, :integer
-    t.column :project_id, :integer
-    t.column :completed, :boolean
-  end
-  
-  create_table :countries, :force => true do |t|
-    t.column :name, :string
-  end
-  
-  create_table :cities, :force => true do |t|
-    t.column :name, :string
-  end
-  
-  create_table :sub_tasks, :force => true do |t|
-    t.column :name, :string
-    t.column :something_else, :integer
-  end
-  
-end
-
-# Setup the models
-class Account < ActiveRecord::Base
-  has_many :projects
-end
-
-class Project < ActiveRecord::Base
-  has_one :manager
-  has_many :tasks
-  acts_as_tenant :account
-  
-  validates_uniqueness_to_tenant :name
-end
-
-class Manager < ActiveRecord::Base
-  belongs_to :project
-  acts_as_tenant :account
-end
-
-class Task < ActiveRecord::Base
-  belongs_to :project
-  default_scope :conditions => { :completed => nil }, :order => "name"
-  
-  acts_as_tenant :account
-  validates_uniqueness_of :name
-end
-
-class City < ActiveRecord::Base
-  validates_uniqueness_of :name
-end
-
-class SubTask < ActiveRecord::Base
-  acts_as_tenant :account
-  belongs_to :something_else, :class_name => "Project"
-end
-
-# Start testing!
-describe ActsAsTenant do
-  after { ActsAsTenant.current_tenant = nil }
-
-  describe 'Setting the current tenant' do
-    before { ActsAsTenant.current_tenant = :foo }
-    it { ActsAsTenant.current_tenant == :foo }
-  end
-  
-  describe 'is_scoped_as_tenant should return the correct value' do
-    it {Project.respond_to?(:is_scoped_by_tenant?).should == true}
-  end
-  
-  describe 'Project.all should be scoped to the current tenant if set' do
-    before do
-      @account1 = Account.create!(:name => 'foo')
-      @account2 = Account.create!(:name => 'bar')
-
-      @project1 = @account1.projects.create!(:name => 'foobar')
-      @project2 = @account2.projects.create!(:name => 'baz')
-      
-      ActsAsTenant.current_tenant= @account1
-      @projects = Project.all
-    end
-    
-    it { @projects.length.should == 1 }
-    it { @projects.should == [@project1] }
-  end
-  
-  describe 'Project.unscoped.all should return the unscoped value' do
-    before do
-      @account1 = Account.create!(:name => 'foo')
-      @account2 = Account.create!(:name => 'bar')
-
-      @project1 = @account1.projects.create!(:name => 'foobar')
-      @project2 = @account2.projects.create!(:name => 'baz')
-      
-      ActsAsTenant.current_tenant= @account1
-      @projects = Project.unscoped.all
-    end
-    
-    it { @projects.length.should == 2 }
-  end
-  
-  describe 'Associations should be correctly scoped by current tenant' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = @account.projects.create!(:name => 'foobar', :account_id => @account.id )
-      # the next line would normally be nearly impossible: a task assigned to a tenant project, 
-      # but the task has no tenant assigned
-      @task1 = Task.create!(:name => 'no_tenant', :project => @project) 
-      
-      ActsAsTenant.current_tenant = @account
-      @task2 = @project.tasks.create!(:name => 'baz')
-      @tasks = @project.tasks
-    end
-    
-    it 'should correctly set the tenant on the task created with current_tenant set' do
-      @task2.account.should == @account
-    end
-    
-    it 'should filter out the non-tenant task from the project' do
-      @tasks.length.should == 1
-    end
-  end
-  
-  describe 'When dealing with a user defined default_scope' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project1 = Project.create!(:name => 'inaccessible')
-      @task1 = Task.create!(:name => 'no_tenant', :project => @project1)
-      
-      ActsAsTenant.current_tenant = @account
-      @project2 = Project.create!(:name => 'accessible')
-      @task2 = @project2.tasks.create!(:name => 'bar')
-      @task3 = @project2.tasks.create!(:name => 'baz')
-      @task4 = @project2.tasks.create!(:name => 'foo')
-      @task5 = @project2.tasks.create!(:name => 'foobar', :completed => true )
-      
-      @tasks= Task.all
-    end
-    
-    it 'should apply both the tenant scope and the user defined default_scope, including :order' do
-      @tasks.length.should == 3 
-      @tasks.should == [@task2, @task3, @task4] 
-    end
-  end
-  
-  describe 'tenant_id should be immutable' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = @account.projects.create!(:name => 'bar')
-    end
-    
-    it { lambda {@project.account_id = @account.id + 1}.should raise_error }
-  end
-    
-  describe 'Associations can only be made with in-scope objects' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project1 = Project.create!(:name => 'inaccessible_project', :account_id => @account.id + 1)
-      
-      ActsAsTenant.current_tenant = @account
-      @project2 = Project.create!(:name => 'accessible_project')
-      @task = @project2.tasks.create!(:name => 'bar')
-    end
-  
-    it { @task.update_attributes(:project_id => @project1.id).should == false }
-  end
-  
-  describe 'When using validates_uniqueness_to_tenant in a aat model' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      ActsAsTenant.current_tenant = @account
-      @project1 = Project.create!(:name => 'bar')
-    end
-    
-    it 'should not be possible to create a duplicate within the same tenant' do
-      @project2 = Project.create(:name => 'bar').valid?.should == false
-    end
-    
-    it 'should be possible to create a duplicate outside the tenant scope' do
-      @account = Account.create!(:name => 'baz')
-      ActsAsTenant.current_tenant = @account
-      @project2 = Project.create(:name => 'bar').valid?.should == true
-    end
-  end
-  
-  describe 'When using validates_uniqueness_of in a NON-aat model' do
-    before do
-      @city1 = City.create!(:name => 'foo')
-    end
-    it 'should not be possible to create duplicates' do
-      @city2 = City.create(:name => 'foo').valid?.should == false
-    end
-  end
-  
-  describe "It should be possible to use aliased associations" do
-    it { @sub_task = SubTask.create(:name => 'foo').valid?.should == true }
-  end
-  
-  describe "It should be possible to create and save an AaT-enabled child without it having a parent" do
-      @account = Account.create!(:name => 'baz')
-      ActsAsTenant.current_tenant = @account
-      Task.create(:name => 'bar').valid?.should == true
-  end
-
-  describe "::with_tenant" do
-    it "should set current_tenant to the specified tenant inside the block" do
-      @account = Account.create!(:name => 'baz')
-
-      ActsAsTenant.with_tenant(@account) do
-        ActsAsTenant.current_tenant.should eq(@account)
-      end
-    end
-
-
-    it "should return current_tenant to the previous tenant once exiting the block" do
-      @account1 = Account.create!(:name => 'foo')
-      @account2 = Account.create!(:name => 'bar')
-      
-      ActsAsTenant.current_tenant = @account1
-      ActsAsTenant.with_tenant @account2 do
-
-      end
-
-      ActsAsTenant.current_tenant.should eq(@account1)
-    end
-
-    it "should raise an error when no block is provided" do
-      expect { ActsAsTenant.with_tenant(nil) }.to raise_error(ArgumentError, /block required/)
-    end
-  end
-end
+require 'spec_helper'
+
+# Setup the db
+ActiveRecord::Schema.define(:version => 2) do
+  create_table :accounts, :force => true do |t|
+    t.column :name, :string
+  end
+
+  create_table :projects, :force => true do |t|
+    t.column :name, :string
+    t.column :account_id, :integer
+  end
+  
+  create_table :managers, :force => true do |t|
+    t.column :name, :string
+    t.column :project_id, :integer
+    t.column :account_id, :integer
+  end
+  
+  create_table :tasks, :force => true do |t|
+    t.column :name, :string
+    t.column :account_id, :integer
+    t.column :project_id, :integer
+    t.column :completed, :boolean
+  end
+  
+  create_table :countries, :force => true do |t|
+    t.column :name, :string
+  end
+  
+  create_table :cities, :force => true do |t|
+    t.column :name, :string
+  end
+  
+  create_table :sub_tasks, :force => true do |t|
+    t.column :name, :string
+    t.column :something_else, :integer
+  end
+
+  create_table :tools, :force => true do |t|
+    t.column :name, :string
+    t.column :account_id, :integer
+  end
+
+  create_table :managers_tools, {:force => true, id: false} do |t|
+    t.integer :manager_id
+    t.integer :tool_id
+  end
+  
+end
+
+# Setup the models
+class Account < ActiveRecord::Base
+  has_many :projects
+end
+
+class Project < ActiveRecord::Base
+  has_one :manager
+  has_many :tasks
+  acts_as_tenant :account
+  
+  validates_uniqueness_to_tenant :name
+end
+
+class Manager < ActiveRecord::Base
+  belongs_to :project
+  has_and_belongs_to_many :tools
+
+  acts_as_tenant :account
+end
+
+class Task < ActiveRecord::Base
+  belongs_to :project
+  default_scope :conditions => { :completed => nil }, :order => "name"
+  
+  acts_as_tenant :account
+  validates_uniqueness_of :name
+end
+
+class City < ActiveRecord::Base
+  validates_uniqueness_of :name
+end
+
+class SubTask < ActiveRecord::Base
+  acts_as_tenant :account
+  belongs_to :something_else, :class_name => "Project"
+end
+
+class Tool < ActiveRecord::Base
+  has_and_belongs_to_many :managers
+
+  acts_as_tenant :account
+end
+
+# Start testing!
+describe ActsAsTenant do
+  after { ActsAsTenant.current_tenant = nil }
+
+  describe 'Setting the current tenant' do
+    before { ActsAsTenant.current_tenant = :foo }
+    it { ActsAsTenant.current_tenant == :foo }
+  end
+  
+  describe 'is_scoped_as_tenant should return the correct value' do
+    it {Project.respond_to?(:is_scoped_by_tenant?).should == true}
+  end
+  
+  describe 'Project.all should be scoped to the current tenant if set' do
+    before do
+      @account1 = Account.create!(:name => 'foo')
+      @account2 = Account.create!(:name => 'bar')
+
+      @project1 = @account1.projects.create!(:name => 'foobar')
+      @project2 = @account2.projects.create!(:name => 'baz')
+      
+      ActsAsTenant.current_tenant= @account1
+      @projects = Project.all
+    end
+    
+    it { @projects.length.should == 1 }
+    it { @projects.should == [@project1] }
+  end
+  
+  describe 'Project.unscoped.all should return the unscoped value' do
+    before do
+      @account1 = Account.create!(:name => 'foo')
+      @account2 = Account.create!(:name => 'bar')
+
+      @project1 = @account1.projects.create!(:name => 'foobar')
+      @project2 = @account2.projects.create!(:name => 'baz')
+      
+      ActsAsTenant.current_tenant= @account1
+      @projects = Project.unscoped.all
+    end
+    
+    it { @projects.length.should == 2 }
+  end
+  
+  describe 'Associations should be correctly scoped by current tenant' do
+    before do
+      @account = Account.create!(:name => 'foo')
+      @project = @account.projects.create!(:name => 'foobar', :account_id => @account.id )
+      # the next line would normally be nearly impossible: a task assigned to a tenant project, 
+      # but the task has no tenant assigned
+      @task1 = Task.create!(:name => 'no_tenant', :project => @project) 
+      
+      ActsAsTenant.current_tenant = @account
+      @task2 = @project.tasks.create!(:name => 'baz')
+      @tasks = @project.tasks
+    end
+    
+    it 'should correctly set the tenant on the task created with current_tenant set' do
+      @task2.account.should == @account
+    end
+    
+    it 'should filter out the non-tenant task from the project' do
+      @tasks.length.should == 1
+    end
+  end
+  
+  describe 'When dealing with a user defined default_scope' do
+    before do
+      @account = Account.create!(:name => 'foo')
+      @project1 = Project.create!(:name => 'inaccessible')
+      @task1 = Task.create!(:name => 'no_tenant', :project => @project1)
+      
+      ActsAsTenant.current_tenant = @account
+      @project2 = Project.create!(:name => 'accessible')
+      @task2 = @project2.tasks.create!(:name => 'bar')
+      @task3 = @project2.tasks.create!(:name => 'baz')
+      @task4 = @project2.tasks.create!(:name => 'foo')
+      @task5 = @project2.tasks.create!(:name => 'foobar', :completed => true )
+      
+      @tasks= Task.all
+    end
+    
+    it 'should apply both the tenant scope and the user defined default_scope, including :order' do
+      @tasks.length.should == 3 
+      @tasks.should == [@task2, @task3, @task4] 
+    end
+  end
+  
+  describe 'tenant_id should be immutable' do
+    before do
+      @account = Account.create!(:name => 'foo')
+      @project = @account.projects.create!(:name => 'bar')
+    end
+    
+    it { lambda {@project.account_id = @account.id + 1}.should raise_error }
+  end
+    
+  describe 'Associations can only be made with in-scope objects' do
+    before do
+      @account = Account.create!(:name => 'foo')
+      @project1 = Project.create!(:name => 'inaccessible_project', :account_id => @account.id + 1)
+      
+      ActsAsTenant.current_tenant = @account
+      @project2 = Project.create!(:name => 'accessible_project')
+      @task = @project2.tasks.create!(:name => 'bar')
+    end
+  
+    it { @task.update_attributes(:project_id => @project1.id).should == false }
+  end
+  
+  describe 'When using validates_uniqueness_to_tenant in a aat model' do
+    before do
+      @account = Account.create!(:name => 'foo')
+      ActsAsTenant.current_tenant = @account
+      @project1 = Project.create!(:name => 'bar')
+    end
+    
+    it 'should not be possible to create a duplicate within the same tenant' do
+      @project2 = Project.create(:name => 'bar').valid?.should == false
+    end
+    
+    it 'should be possible to create a duplicate outside the tenant scope' do
+      @account = Account.create!(:name => 'baz')
+      ActsAsTenant.current_tenant = @account
+      @project2 = Project.create(:name => 'bar').valid?.should == true
+    end
+  end
+  
+  describe 'When using validates_uniqueness_of in a NON-aat model' do
+    before do
+      @city1 = City.create!(:name => 'foo')
+    end
+    it 'should not be possible to create duplicates' do
+      @city2 = City.create(:name => 'foo').valid?.should == false
+    end
+  end
+  
+  describe "It should be possible to use aliased associations" do
+    it { @sub_task = SubTask.create(:name => 'foo').valid?.should == true }
+  end
+  
+  describe "It should be possible to create and save an AaT-enabled child without it having a parent" do
+      @account = Account.create!(:name => 'baz')
+      ActsAsTenant.current_tenant = @account
+      Task.create(:name => 'bar').valid?.should == true
+  end
+
+  describe "It should be possible to use direct many-to-many associations" do
+      @manager = Manager.create!(:name => 'fool')
+      @manager.tools.new(:name => 'golden hammer')
+      @manager.save.should == true
+  end
+
+  describe "It should be possible to use direct many-to-many associations" do
+    @manager = Manager.create!(:name => 'fool')
+    @manager.tools.new(:name => 'golden hammer')
+    @manager.save.should == true
+  end
+
+  describe "When using direct many-to-many associations they are correctly scoped to the tenant" do
+    before do
+      @account1 = Account.create!(:name => 'foo')
+      @account2 = Account.create!(:name => 'bar')
+
+      ActsAsTenant.current_tenant= @account1
+      @manager1 = Manager.create!(:name => 'fool')
+      @tool1 = @manager1.tools.create!(:name => 'golden hammer')
+
+      ActsAsTenant.current_tenant= @account2
+      @manager2 = Manager.create!(:name => 'pitty')
+      @tool2 = @manager2.tools.create!(:name => 'golden saw')
+
+      @tools = Tool.all
+    end
+    it { @tools.should == [@tool2] }
+  end
+
+  describe "::with_tenant" do
+    it "should set current_tenant to the specified tenant inside the block" do
+      @account = Account.create!(:name => 'baz')
+
+      ActsAsTenant.with_tenant(@account) do
+        ActsAsTenant.current_tenant.should eq(@account)
+      end
+    end
+
+
+    it "should return current_tenant to the previous tenant once exiting the block" do
+      @account1 = Account.create!(:name => 'foo')
+      @account2 = Account.create!(:name => 'bar')
+      
+      ActsAsTenant.current_tenant = @account1
+      ActsAsTenant.with_tenant @account2 do
+
+      end
+
+      ActsAsTenant.current_tenant.should eq(@account1)
+    end
+
+    it "should raise an error when no block is provided" do
+      expect { ActsAsTenant.with_tenant(nil) }.to raise_error(ArgumentError, /block required/)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_tenant
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70247831625340 !ruby/object:Gem::Requirement
+  requirement: &70124434956940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *70247831625340
+  version_requirements: *70124434956940
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70247831624140 !ruby/object:Gem::Requirement
+  requirement: &70124434955660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70247831624140
+  version_requirements: *70124434955660
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &70247831623580 !ruby/object:Gem::Requirement
+  requirement: &70124434955020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70247831623580
+  version_requirements: *70124434955020
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70247831622820 !ruby/object:Gem::Requirement
+  requirement: &70124434954400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70247831622820
+  version_requirements: *70124434954400
 description: Integrates multi-tenancy into a Rails application in a convenient and
   out-of-your way manner
 email: