acts_as_tenant 0.4.4 → 0.5.0

data/.gitignore

@@ -1,7 +0,0 @@
-.rvmrc
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
-spec/*.sqlite3
-spec/*.log

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-before_install:
-  - gem update bundler
-script: bundle exec rake spec

data/CHANGELOG.md

@@ -1,119 +0,0 @@
-0.4.4
------
-* Implement support for polymorphic tenant
-* Ability to use acts_as_tenant with only ActiveRecord (no Rails)
-* Allow setting of custom primary key
-* Bug fixes
-
-0.4.3
------
-* allow 'optional' relations
-* Sidekiq fixes
-* Replace all `before_filter` with `before_action` for Rails 5.1 compatibility
-
-0.4.1
-------
-* Removed (stale, no longer working) MongoDB support; moved code to separate branch
-* Added without_tenant option (see readme, thx duboff)
-
-0.4.0
-------
-* (Sub)domain lookup is no longer case insensitive
-* Added ability to use inverse_of (thx lowjoel)
-* Added ability to disable tenant checking for a block (thx duboff)
-* Allow for validation that associations belong to the tenant to reflect on associations which return an Array from `where` (thx ludamillion)
-
-0.3.9
------
-* Added ability to configure a default tenant for testing purposes. (thx iangreenleaf)
-* AaT will now accept a string for a tenant_id (thx calebthompson)
-* Improvements to readme (thx stgeneral)
-
-0.3.8
------
-* Added Mongoid compatibility [thx iangreenleaf]
-
-0.3.7
------
-* Fix for proper handling of polymorphic associations (thx sol1dus)
-* Fix fefault scope to generate correct sql when using database prefix (thx IgorDobryn)
-* Added ability to specify a custom Primary Key (thx matiasdim)
-* Sidekiq 3.2.2+ no longer supports Ruby 1.9. Locking Sidekiq in gemspec at 3.2.1.
-* Update RSPEC to 3.0. Convert all specs (thx petergoldstein)
-* support sidekiq 3 interface (thx davekaro)
-
-0.3.6
------
-* Added method `set_current_tenant_by_subdomain_or_domain` (thx preth00nker)
-
-0.3.5
------
-* Fix to degredation introduced after 3.1 that prevented tenant_id from being set during initialization (thx jorgevaldivia)
-
-0.3.4
------
-* Fix to a bug introduced in 0.3.2
-
-0.3.3
------
-* Support user defined foreign keys on scoped models
-
-0.3.2
------
-* correctly support nested models with has_many :through (thx dexion)
-* Support 'www.subdomain.example.com' (thx wtfiwtz)
-* Support setting `tenant_id` on scoped models if the `tenant_id` is nil (thx Matt Wilson)
-
-0.3.1
------
-* Added support for Rails 4
-
-0.3.0
------
-* You can now raise an exception if a query on a scope model is made without a tenant set. Adding an initializer that sets config.require_tenant to true will accomplish this. See readme for more details.
-* `ActsAsTenant.with_tenant` will now return the value of the block it evaluates instead of the original tenant. The original tenant is restored automatically.
-* acts_as_tenant now raises standard errors which can be caught individually.
-* `set_current_tenant_to`, which was deprecated some versions ago and could lead to weird errors, has been removed.
-
-
-0.2.9
------
-* Added support for many-to-many associations (thx Nucleoid)
-
-0.2.8
------
-* Added dependencies to gemspec (thx aaronrenner)
-* Added the `ActsAsTenant.with_tenant` block method (see readme) (thx aaronrenner)
-* Acts_as_Tenant is now thread safe (thx davide)
-
-0.2.7
------
-* Changed the interface for passing in the current_tenant manually in the controller. `set_current_tenant_to` has been deprecated and replaced by `set_current_tenant_through_filter` declaration and the `set_current_tenant` method. See readme for details.
-
-0.2.6
------
-* Fixed a bug with resolving the tenant model name (thx devton!)
-* Added support for using relations: User.create(:account => Account.first) now works, while it wouldn't before (thx bnmrrs)
-
-0.2.5
------
-* Added Rails 3.2 compatibility (thx nickveys!)
-
-0.2.4
------
-* Added correct handling of child models that do not have their parent set (foreign key == nil)
-
-
-0.2.3
------
-* Added support for models that declare a has_one relationships, these would error out in the previous versions.
-
-
-0.2.2
------
-* Enhancements
-  * Added support for aliased associations ( belongs_to :something, :class_name => 'SomethingElse'). In previous version these would raise an 'uninitialized constant' error.
-
-0.2.1
------
-* Initial release

data/Gemfile

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in acts_as_tenant.gemspec
-gemspec

data/_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-tactile

data/acts_as_tenant.gemspec

@@ -1,32 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "acts_as_tenant/version"
-
-Gem::Specification.new do |s|
-  s.name        = "acts_as_tenant"
-  s.version     = ActsAsTenant::VERSION
-  s.authors     = ["Erwin Matthijssen"]
-  s.email       = ["erwin.matthijssen@gmail.com"]
-  s.homepage    = "http://www.rollcallapp.com/blog"
-  s.summary     = %q{Add multi-tenancy to Rails applications using a shared db strategy}
-  s.description = %q{Integrates multi-tenancy into a Rails application in a convenient and out-of-your way manner}
-
-  s.rubyforge_project = "acts_as_tenant"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_runtime_dependency('request_store', '>= 1.0.5')
-  s.add_dependency('rails','>= 4.0')
-  #s.add_dependency('request_store', '>= 1.0.5')
-
-  s.add_development_dependency('rspec', '>=3.0')
-  s.add_development_dependency('rspec-rails')
-  s.add_development_dependency('database_cleaner', '~> 1.7')
-  s.add_development_dependency('sqlite3')
-  #s.add_development_dependency('mongoid', '~> 4.0')
-
-  s.add_development_dependency('sidekiq', '3.2.1')
-end

data/docs/blog_post.md

@@ -1,67 +0,0 @@
-<h2> Adding multi-tenancy to your Rails app: acts_as_tenant </h2>
-Roll Call is implemented as a multi-tenant application: each user gets their own instance of the app, content is strictly scoped to a user&#8217;s instance. In Rails, this can be achieved in various ways. Guy Naor did a great job of diving into the pros and cons of each option in his <a href="http://confreaks.net/videos/111-aac2009-writing-multi-tenant-applications-in-rails">2009 Acts As Conference talk</a>. If you are doing multi-tenancy in Rails, you should watch his video.</p>
-<p>With a multi-db or multi-schema approach, you only deal with the multi-tenancy-aspect in a few specific spots in your app (Jerod Santo recently wrote an excellent post on implementing a <a href="http://blog.jerodsanto.net/2011/07/building-multi-tenant-rails-apps-with-postgresql-schemas/">multi-schema strategy</a>). Compared to the previous two strategies, a <strong>shared database</strong> strategy has the downside that the &#8216;multi-tenancy&#8217;-logic is something you need to actively be aware of and manage in almost every part of your app.</p>
-<h4>Using a Shared Database strategy is alot of work!</h4>
-<p>For various other reasons we opted for a <strong>shared database</strong> strategy. However, for us the prospect of dealing with the multi-tenancy-logic throughout our app, was not appealing. Worse, we run the risk of accidently exposing content of one tenant to another one, if we mismanage this logic. While researching this topic I noticed there are no real ready made solutions available that get you on your way, <a href="http://github.com/wireframe/multitenant">Ryan Sonnek</a> wrote his &#8216;multitenant&#8217; gem and <a href="http://github.com/mconnell/multi_tenant">Mark Connel</a> did the same. Neither of these solution seemed &#8220;finished&#8221; to us. So, we wrote our own implementation.</p>
-<h4>First, how does multi-tenancy with a shared database strategy work</h4>
-<p>A shared database strategy manages the multi-tenancy-logic through Rails associations. A tenant is represented by an object, for example an <code>Account</code>. All other objects are associated with a tenant: <code>belongs_to :account</code>. Each request starts with finding the <code>@current_account</code>. After that, each find is scoped through the tenant object: <code>current_account.projects.all</code>. This has to be remembered everywhere: in model method declarations and in controller actions. Otherwise, you&#8217;re exposing content of other tenants.</p>
-<p>In addition, you have to actively babysit other parts of your app: <code>validates_uniqueness_of</code> requires you to scope it to the current tenant. You also have to protect agaist all sorts of form-injections that could allow one tenant to gain access or temper with the content of another tenant (see <a href="http://www.slideshare.net/tardate/multitenancy-with-rails">Paul Gallaghers</a> presentation for more on these dangers).</p>
-<h4>Enter acts_as_tenant</h4>
-<p>I wanted to implement all the concerns above in an easy to manage, out of the way fashion. We should be able to add a single declaration to our model and that should implement:</p>
-<ol>
-	<li>scoping all searches to the current <code>Account</code></li>
-	<li>scoping the uniqueness validator to the current <code>Account</code></li>
-	<li>protecting against various nastiness trying to circumvent the scoping.</li>
-</ol>
-<p>The result is <code>acts_as_tenant</code> (<a href="https://github.com/ErwinM/acts_as_tenant">github</a>), a rails gem that will add multi tenancy using a shared database to your rails app in an out-of-your way fashion.</p>
-<p>In the <span class="caps">README</span>, you will find more information on using <code>acts_as_tenant</code> in your projects, so we&#8217;ll give you a high-level overview here. Let&#8217;s suppose that you have an app to which you want to add multi tenancy, tenants are represented by the <code>Account</code> model and <code>Project</code> is one of the models that should be scoped by tenant:</p>
-
-```ruby
-  class Addaccounttoproject < ActiveRecord::Migration
-    def change
-      add_column :projects, :account_id, :integer
-    end
-  end
-
-  class Project < ActiveRecord::Base
-    acts_as_tenant(:account)
-    validates_uniqueness_to_tenant :name
-  end
-```
-What does adding these two methods accomplish:
-<ol>
-	<li>it ensures every search on the project model will be scoped to the current tenant,</li>
-	<li>it adds validation for every association confirming the associated object does indeed belong to the current tenant,</li>
-	<li>it validates the uniqueness of `:name` to the current tenant,</li>
-	<li>it implements a bunch of safeguards preventing all kinds of nastiness from exposing other tenants data (mainly form-injection attacks).</li>
-</ol>
-<p>Ofcourse, all the above assumes `acts_as_tenant` actually knows who the current tenant is. Two strategies are implemented to help with this.</p>
-<p><strong>Using the subdomain to workout the current tenant</strong></p>
-
-```ruby
-  class ApplicationController < ActionController::Base
-    set_current_tenant_by_subdomain(:account, :subdomain)
-  end
-```
-<p>Adding the above method to your `application_controller` tells `acts_as_tenant`:</p>
-<ol>
-	<li>the current tenant should be found based on the subdomain (e.g. account1.myappdomain.com),</li>
-	<li>tenants are represented by the `Account`-model and</li>
-	<li>the `Account` model has a column named `subdomain` that should be used the lookup the current account, using the current subdomain.</li>
-</ol>
-<p><strong>Passing the current account to acts_as_tenant yourself</strong></p>
-
-```ruby
-  class ApplicationController < ActionController::Base
-    current_account = Account.method_to_find_the_current_account
-    set_current_tenant_to(current_account)
-  end
-```
-<p>`Acts_as_tenant` also adds a handy helper to your controllers `current_tenant`, containing the current tenant object.</p>
-<h4>Great! Anything else I should know? A few caveats:</h4>
-<ul>
-	<li>scoping of models *only* works if `acts_as_tenant` has a current_tenant available. If you do not set one by one of the methods described above, *no scope* will be applied!</li>
-	<li>for validating uniqueness within a tenant scope you must use the `validates_uniqueness_to_tenant`method. This method takes all the options the regular `validates_uniqueness_of` method takes.</li>
-	<li>it is probably best to add the `acts_as_tenant` declaration after any other `default_scope` declarations you add to a model (I am not exactly sure how rails 3 handles the chaining. If someone can enlighten me, thanks!).</li>
-</ul>
-<p>We have been testing <a href="https://github.com/ErwinM/acts_as_tenant">acts_as_tenant</a> within Roll Call during recent weeks and it seems to be behaving well. Having said that, we welcome any feedback. This is my first real attempt at a plugin and the possibility of various improvements is almost a given.</p>

data/rails/init.rb

@@ -1,2 +0,0 @@
-ActiveRecord::Base.send(:include, ActsAsTenant::ModelExtensions)
-ActionController::Base.extend ActsAsTenant::ControllerExtensions

data/spec/active_record_helper.rb

@@ -1,22 +0,0 @@
-require 'rails/all'
-require 'database_cleaner'
-require 'yaml'
-
-dbconfig = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'database.yml')))
-ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
-ActiveRecord::Base.establish_connection(dbconfig[ENV['DB'] || 'sqlite'])
-
-RSpec.configure do |config|
-  config.before(:suite) do
-    DatabaseCleaner[:active_record].strategy = :transaction
-    DatabaseCleaner[:active_record].clean_with(:truncation)
-  end
-
-  config.before(:each) do
-    DatabaseCleaner[:active_record].start
-  end
-
-  config.after(:each) do
-    DatabaseCleaner[:active_record].clean
-  end
-end

data/spec/active_record_models.rb

@@ -1,143 +0,0 @@
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :accounts, :force => true do |t|
-    t.column :name, :string
-    t.column :subdomain, :string
-    t.column :domain, :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 :unscoped_models, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :aliased_tasks, :force => true do |t|
-    t.column :name, :string
-    t.column :project_alias_id, :integer
-    t.column :account_id, :integer
-  end
-
-  create_table :unique_tasks, :force => true do |t|
-    t.column :name, :string
-    t.column :user_defined_scope, :string
-    t.column :project_id, :integer
-    t.column :account_id, :integer
-  end
-
-  create_table :custom_foreign_key_tasks, :force => true do |t|
-    t.column :name, :string
-    t.column :accountID, :integer
-  end
-
-  create_table :articles, :force => true do |t|
-    t.column :title, :string
-  end
-
-  create_table :comments, :force => true do |t|
-    t.column :commentable_id, :integer
-    t.column :commentable_type, :string
-    t.column :account_id, :integer
-  end
-
-  create_table :polymorphic_tenant_comments, :force => true do |t|
-    t.column :polymorphic_tenant_commentable_id, :integer
-    t.column :polymorphic_tenant_commentable_type, :string
-    t.column :account_id, :integer
-  end
-
-end
-
-class Account < ActiveRecord::Base
-  has_many :projects
-end
-
-class Project < ActiveRecord::Base
-  has_one :manager
-  has_many :tasks
-  has_many :polymorphic_tenant_comments, as: :polymorphic_tenant_commentable
-  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 -> { where(:completed => nil).order("name") }
-
-  acts_as_tenant :account
-  validates_uniqueness_of :name
-end
-
-class UnscopedModel < ActiveRecord::Base
-  validates_uniqueness_of :name
-end
-
-class AliasedTask < ActiveRecord::Base
-  acts_as_tenant(:account)
-  belongs_to :project_alias, :class_name => "Project"
-end
-
-class UniqueTask < ActiveRecord::Base
-  acts_as_tenant(:account)
-  belongs_to :project
-  validates_uniqueness_to_tenant :name, scope: :user_defined_scope
-end
-
-class CustomForeignKeyTask < ActiveRecord::Base
-  acts_as_tenant(:account, :foreign_key => "accountID")
-  validates_uniqueness_to_tenant :name
-end
-
-class CustomPrimaryKeyTask < ActiveRecord::Base
-  self.table_name = 'projects'
-  acts_as_tenant(:account, :foreign_key => "name", :primary_key => "name")
-  validates_presence_of :name
-end
-
-class Comment < ActiveRecord::Base
-  belongs_to :commentable, polymorphic: true
-  belongs_to :task, -> { where(comments: { commentable_type: 'Task'  })  }, foreign_key: 'commentable_id'
-  acts_as_tenant :account
-end
-
-class Article < ActiveRecord::Base
-  has_many :polymorphic_tenant_comments, as: :polymorphic_tenant_commentable
-end
-
-class PolymorphicTenantComment < ActiveRecord::Base
-  belongs_to :polymorphic_tenant_commentable, polymorphic: true
-  belongs_to :account
-  acts_as_tenant :polymorphic_tenant_commentable, polymorphic: true
-end
-
-class GlobalProject < ActiveRecord::Base
-  self.table_name = 'projects'
-
-  acts_as_tenant :account, has_global_records: true
-  validates_uniqueness_to_tenant :name
-end

data/spec/acts_as_tenant/model_extensions_spec.rb

@@ -1,476 +0,0 @@
-require 'spec_helper'
-require 'active_record_models'
-
-describe ActsAsTenant do
-  after { ActsAsTenant.current_tenant = nil }
-
-  # Setting and getting
-  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 when true' do
-    it {expect(Project.respond_to?(:scoped_by_tenant?)).to eq(true)}
-  end
-
-  describe 'is_scoped_as_tenant should return the correct value when false' do
-    it {expect(UnscopedModel.respond_to?(:scoped_by_tenant?)).to eq(false)}
-  end
-
-  describe 'tenant_id should be immutable, if already set' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = @account.projects.create!(:name => 'bar')
-    end
-
-    it { expect {@project.account_id = @account.id + 1}.to raise_error(ActsAsTenant::Errors::TenantIsImmutable) }
-  end
-
-  describe 'setting tenant_id to the same value should not error' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = @account.projects.create!(:name => 'bar')
-    end
-
-    it { expect {@project.account_id = @account.id}.not_to raise_error }
-  end
-
-  describe 'setting tenant_id to a string with same to_i value should not error' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = @account.projects.create!(:name => 'bar')
-    end
-
-    it { expect {@project.account_id = @account.id.to_s}.not_to raise_error }
-  end
-
-  describe 'tenant_id should be mutable, if not already set' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = Project.create!(:name => 'bar')
-    end
-
-    it { expect(@project.account_id).to be_nil }
-    it { expect { @project.account = @account }.not_to raise_error }
-  end
-
-  describe 'tenant_id should auto populate after initialization' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      ActsAsTenant.current_tenant = @account
-    end
-    it {expect(Project.new.account_id).to eq(@account.id)}
-  end
-
-  describe 'Handles custom foreign_key on tenant model' do
-    before do
-      @account  = Account.create!(:name => 'foo')
-      ActsAsTenant.current_tenant = @account
-      @custom_foreign_key_task = CustomForeignKeyTask.create!(:name => 'foo')
-    end
-
-    it { expect(@custom_foreign_key_task.account).to eq(@account) }
-  end
-
-  describe 'Handles custom primary_key on tenant model' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      CustomPrimaryKeyTask.create!(name: 'bar')
-      ActsAsTenant.current_tenant = @account
-      @custom_primary_key_task = CustomPrimaryKeyTask.create!
-    end
-
-    it { expect(@custom_primary_key_task.account).to eq(@account) }
-    it { expect(CustomPrimaryKeyTask.count).to eq(1) }
-  end
-
-  # Scoping models
-  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 { expect(@projects.length).to eq(1) }
-    it { expect(@projects).to eq([@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
-    end
-
-    it { expect(@projects.count).to eq(2) }
-  end
-
-  describe 'Querying the tenant from a scoped model without a tenant set' do
-    before do
-      @project = Project.create!(:name => 'bar')
-    end
-
-    it { @project.account }
-  end
-
-  describe 'Querying the tenant from a scoped model with a tenant set' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = @account.projects.create!(:name => 'foobar')
-      ActsAsTenant.current_tenant= @account1
-    end
-
-    it { @project.account }
-  end
-
-  describe 'A tenant model with global records' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project1 = GlobalProject.create!(:name => 'foobar global')
-      @project2 = GlobalProject.create!(:name => 'unaccessible project', :account => Account.create!)
-      ActsAsTenant.current_tenant = @account
-      @project3 = GlobalProject.create!(:name => 'foobar')
-    end
-
-    it 'should return two projects' do
-      expect(GlobalProject.all.count).to eq(2)
-    end
-
-    it 'should validate the project name against the global records too' do
-      expect(GlobalProject.new(:name => 'foobar').valid?).to be(false)
-      expect(GlobalProject.new(:name => 'foobar new').valid?).to be(true)
-      expect(GlobalProject.new(:name => 'foobar global').valid?).to be(false)
-      expect(@project1.valid?).to be(true)
-    end
-
-    it 'should add the model to ActsAsTenant.models_with_global_records' do
-      expect(ActsAsTenant.models_with_global_records.include?(GlobalProject)).to be(true)
-      expect(ActsAsTenant.models_with_global_records.include?(Project)).to be(false)
-    end
-  end
-
-  # Associations
-  describe 'Associations should be correctly scoped by current tenant' do
-    before do
-      @account = Account.create!(:name => 'foo')
-      @project = Project.create!(:name => 'foobar', :account => @account )
-      # the next line should 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')
-
-      @project.reload
-    end
-
-    it 'should correctly set the tenant on the task created with current_tenant set' do
-      expect(@task2.account).to eq(@account)
-    end
-
-    it 'should filter out the non-tenant task from the project' do
-      expect(@project.tasks.length).to eq(1)
-    end
-  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 => Account.create!)
-      ActsAsTenant.current_tenant = @account
-
-      @project2 = Project.create!(:name => 'accessible_project')
-      @task = @project2.tasks.create!(:name => 'bar')
-    end
-
-    it { expect(@task.update_attributes(:project_id => @project1.id)).to eq(false) }
-  end
-
-  describe "Create and save an AaT-enabled child without it having a parent" do
-    before do
-      @account = Account.create!(:name => 'baz')
-      ActsAsTenant.current_tenant = @account
-    end
-    it { expect(Task.create(:name => 'bar').valid?).to eq(true) }
-  end
-
-  describe "It should be possible to use aliased associations" do
-    it { expect(AliasedTask.create(:name => 'foo', :project_alias => @project2).valid?).to eq(true) }
-  end
-
-  describe "It should be possible to use associations with foreign_key from polymorphic" do
-    context 'tenanted objects have a polymorphic association' do
-      before do
-        @account = Account.create!(name: 'foo')
-        ActsAsTenant.current_tenant = @account
-        @project = Project.create!(name: 'project', account: @account)
-        @comment = Comment.new commentable: @project, account: @account
-      end
-
-      it { expect(@comment.save!).to eq(true) }
-    end
-
-    context 'tenant is polymorphic' do
-      before do
-        @account = Account.create!(name: 'foo')
-        @project = Project.create!(name: 'polymorphic project')
-        ActsAsTenant.current_tenant = @project
-        @comment = PolymorphicTenantComment.new(account: @account)
-      end
-
-      it 'populates commentable_type with the current tenant' do
-        expect(@comment.polymorphic_tenant_commentable_id).to eql(@project.id)
-        expect(@comment.polymorphic_tenant_commentable_type).to eql(@project.class.to_s)
-      end
-
-      context 'with another type of tenant, same id' do
-        before do
-          @comment.save!
-          @article = Article.create!(id: @project.id, title: 'article title')
-          @comment_on_article = @article.polymorphic_tenant_comments.create!
-        end
-
-        it 'correctly scopes to the current tenant type' do
-          expect(@comment_on_article).to be_persisted
-          expect(@comment).to be_persisted
-          expect(PolymorphicTenantComment.count).to eql(1)
-          expect(PolymorphicTenantComment.all.first.attributes).to eql(@comment.attributes)
-        end
-      end
-
-    end
-  end
-
-  # Additional default_scopes
-  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
-      expect(@tasks.length).to eq(3)
-      expect(@tasks).to eq([@task2, @task3, @task4])
-    end
-  end
-
-  # Validates_uniqueness
-  describe 'When using validates_uniqueness_to_tenant in a aat model' do
-    before do
-      account = Account.create!(:name => 'foo')
-      ActsAsTenant.current_tenant = account
-      Project.create!(:name => 'existing_name')
-    end
-
-    it 'should not be possible to create a duplicate within the same tenant' do
-      expect(Project.create(:name => 'existing_name').valid?).to eq(false)
-    end
-
-    it 'should be possible to create a duplicate outside the tenant scope' do
-      account = Account.create!(:name => 'baz')
-      ActsAsTenant.current_tenant = account
-      expect(Project.create(:name => 'bar').valid?).to eq(true)
-    end
-  end
-
-  describe 'Handles user defined scopes' do
-    before do
-      UniqueTask.create!(:name => 'foo', :user_defined_scope => 'unique_scope')
-    end
-
-    it { expect(UniqueTask.create(:name => 'foo', :user_defined_scope => 'another_scope')).to be_valid }
-    it { expect(UniqueTask.create(:name => 'foo', :user_defined_scope => 'unique_scope')).not_to be_valid }
-  end
-
-  describe 'When using validates_uniqueness_of in a NON-aat model' do
-    before do
-      UnscopedModel.create!(:name => 'foo')
-    end
-    it 'should not be possible to create duplicates' do
-      expect(UnscopedModel.create(:name => 'foo').valid?).to eq(false)
-    end
-  end
-
-  # ::with_tenant
-  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
-        expect(ActsAsTenant.current_tenant).to eq(@account)
-      end
-    end
-
-    it "should reset 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
-
-      expect(ActsAsTenant.current_tenant).to eq(@account1)
-    end
-
-    it "should return the value of the block" do
-      @account1 = Account.create!(:name => 'foo')
-      @account2 = Account.create!(:name => 'bar')
-
-      ActsAsTenant.current_tenant = @account1
-      value = ActsAsTenant.with_tenant @account2 do
-        "something"
-      end
-
-      expect(value).to eq "something"
-    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
-
-  describe "::without_tenant" do
-    it "should set current_tenant to nil inside the block" do
-      ActsAsTenant.without_tenant do
-        expect(ActsAsTenant.current_tenant).to be_nil
-      end
-    end
-
-    it "should set current_tenant to nil even if default_tenant is set" do
-      begin
-        old_default_tenant = ActsAsTenant.default_tenant
-        ActsAsTenant.default_tenant = Account.create!(name: 'foo')
-        ActsAsTenant.without_tenant do
-          expect(ActsAsTenant.current_tenant).to be_nil
-        end
-      ensure
-        ActsAsTenant.default_tenant = old_default_tenant
-      end
-    end
-
-    it "should reset current_tenant to the previous tenant once exiting the block" do
-      @account1 = Account.create!(:name => 'foo')
-
-      ActsAsTenant.current_tenant = @account1
-      ActsAsTenant.without_tenant do
-      end
-
-      expect(ActsAsTenant.current_tenant).to eq(@account1)
-    end
-
-    it "should return the value of the block" do
-      value = ActsAsTenant.without_tenant do
-        "something"
-      end
-
-      expect(value).to eq "something"
-    end
-
-    it "should raise an error when no block is provided" do
-      expect { ActsAsTenant.without_tenant }.to raise_error(ArgumentError, /block required/)
-    end
-  end
-
-  # Tenant required
-  context "tenant required" do
-    before do
-      @account1 = Account.create!(:name => 'foo')
-      @project1 = @account1.projects.create!(:name => 'foobar')
-      allow(ActsAsTenant.configuration).to receive_messages(require_tenant: true)
-    end
-
-    describe "raises exception if no tenant specified" do
-      it "should raise an error when no tenant is provided" do
-        expect { Project.all }.to raise_error(ActsAsTenant::Errors::NoTenantSet)
-      end
-    end
-
-    describe "does not raise exception when run in unscoped mode" do
-      it "should not raise an error when no tenant is provided" do
-        expect do
-          ActsAsTenant.without_tenant { Project.all }
-        end.to_not raise_error
-      end
-    end
-  end
-
-  context "no tenant required" do
-    describe "does not raise exception if no tenant specified" do
-      before do
-        @account1 = Account.create!(:name => 'foo')
-        @project1 = @account1.projects.create!(:name => 'foobar')
-      end
-
-      it "should not raise an error when no tenant is provided" do
-        expect { Project.all }.to_not raise_error
-      end
-    end
-  end
-
-  describe "ActsAsTenant.default_tenant=" do
-    before(:each) do
-      @account = Account.create!
-    end
-
-    after(:each) do
-      ActsAsTenant.default_tenant = nil
-    end
-
-    it "provides current_tenant" do
-      ActsAsTenant.default_tenant = @account
-      expect(ActsAsTenant.current_tenant).to eq(@account)
-    end
-
-    it "can be overridden by assignment" do
-      ActsAsTenant.default_tenant = @account
-      @account2 = Account.create!
-      ActsAsTenant.current_tenant = @account2
-      expect(ActsAsTenant.current_tenant).not_to eq(@account)
-    end
-
-    it "can be overridden by with_tenant" do
-      ActsAsTenant.default_tenant = @account
-      @account2 = Account.create!
-      ActsAsTenant.with_tenant @account2 do
-        expect(ActsAsTenant.current_tenant).to eq(@account2)
-      end
-      expect(ActsAsTenant.current_tenant).to eq(@account)
-    end
-
-    it "doesn't override existing current_tenant" do
-      @account2 = Account.create!
-      ActsAsTenant.current_tenant = @account2
-      ActsAsTenant.default_tenant = @account
-      expect(ActsAsTenant.current_tenant).to eq(@account2)
-    end
-
-    it "survives request resets" do
-      ActsAsTenant.default_tenant = @account
-      RequestStore.clear!
-      expect(ActsAsTenant.current_tenant).to eq(@account)
-    end
-  end
-end