activerecord-multi-tenant 1.2.0 → 2.4.0

data/spec/activerecord-multi-tenant/multi_tenant_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe MultiTenant do
-  describe ".load_current_tenant!" do
+  describe '.load_current_tenant!' do
     let(:fake_tenant) { OpenStruct.new(id: 1) }
     let(:mock_klass) { double(find: fake_tenant) }
 
@@ -14,14 +16,14 @@ RSpec.describe MultiTenant do
       MultiTenant.default_tenant_class = @original_default_class
     end
 
-    it "sets and returns the loaded current_tenant" do
+    it 'sets and returns the loaded current_tenant' do
       expect(mock_klass).to receive(:find).once.with(1)
       MultiTenant.current_tenant = 1
       expect(MultiTenant.load_current_tenant!).to eq(fake_tenant)
       expect(MultiTenant.current_tenant).to eq(fake_tenant)
     end
 
-    it "respects `.with` lifecycle" do
+    it 'respects `.with` lifecycle' do
       expect(mock_klass).to receive(:find).once.with(2)
       expect(MultiTenant.current_tenant).to eq(nil)
       MultiTenant.with(2) do
@@ -31,34 +33,88 @@ RSpec.describe MultiTenant do
       expect(MultiTenant.current_tenant).to eq(nil)
     end
 
-    context "with a loaded current_tenant" do
-      it "returns the tenant without fetching it" do
+    context 'with a loaded current_tenant' do
+      it 'returns the tenant without fetching it' do
         expect(mock_klass).not_to receive(:find)
         MultiTenant.current_tenant = fake_tenant
         expect(MultiTenant.load_current_tenant!).to eq(fake_tenant)
       end
     end
 
-    context "with a nil current_tenant" do
-      it "raises an error, as there is not enough information to load the tenant" do
+    context 'with a nil current_tenant' do
+      it 'raises an error, as there is not enough information to load the tenant' do
         expect(mock_klass).not_to receive(:find)
-        expect {
+        expect do
           MultiTenant.load_current_tenant!
-        }.to raise_error(RuntimeError, 'MultiTenant.current_tenant must be set to load')
+        end.to raise_error(RuntimeError, 'MultiTenant.current_tenant must be set to load')
       end
     end
 
-    context "without a default class set" do
+    context 'without a default class set' do
       before do
         MultiTenant.default_tenant_class = nil
       end
 
-      it "raises an error, as there is not enough information to load the tenant" do
+      it 'raises an error, as there is not enough information to load the tenant' do
         expect(mock_klass).not_to receive(:find)
         MultiTenant.current_tenant = 1
-        expect {
+        expect do
           MultiTenant.load_current_tenant!
-        }.to raise_error(RuntimeError, 'Only have tenant id, and no default tenant class set')
+        end.to raise_error(RuntimeError, 'Only have tenant id, and no default tenant class set')
+      end
+    end
+  end
+
+  describe '.tenant_klass_defined?' do
+    context 'without options' do
+      before(:all) do
+        class SampleTenant < ActiveRecord::Base
+          multi_tenant :sample_tenant
+        end
+      end
+
+      it 'return true with valid tenant_name' do
+        expect(MultiTenant.tenant_klass_defined?(:sample_tenant)).to eq(true)
+      end
+
+      it 'return false with invalid_tenant_name' do
+        invalid_tenant_name = :tenant
+        expect(MultiTenant.tenant_klass_defined?(invalid_tenant_name)).to eq(false)
+      end
+    end
+
+    context 'with options' do
+      context 'and valid class_name' do
+        it 'return true' do
+          class SampleTenant < ActiveRecord::Base
+            multi_tenant :tenant
+          end
+
+          tenant_name = :tenant
+          options = {
+            class_name: 'SampleTenant'
+          }
+          expect(MultiTenant.tenant_klass_defined?(tenant_name, options)).to eq(true)
+        end
+
+        it 'return true when tenant class is nested' do
+          module SampleModule
+            class SampleNestedTenant < ActiveRecord::Base
+              multi_tenant :tenant
+            end
+            # rubocop:disable Layout/TrailingWhitespace
+            # Trailing whitespace is intentionally left here
+            
+            class AnotherTenant < ActiveRecord::Base
+            end
+            # rubocop:enable Layout/TrailingWhitespace
+          end
+          tenant_name = :tenant
+          options = {
+            class_name: 'SampleModule::SampleNestedTenant'
+          }
+          expect(MultiTenant.tenant_klass_defined?(tenant_name, options)).to eq(true)
+        end
       end
     end
   end

data/spec/activerecord-multi-tenant/query_rewriter_spec.rb

@@ -1,112 +1,113 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe "Query Rewriter" do
+require 'spec_helper'
 
-  context "when bulk updating" do
-    let!(:account) { Account.create!(name: "Test Account") }
-    let!(:project) { Project.create(name: "Project 1", account: account) }
-    let!(:manager) { Manager.create(name: "Manager", project: project, account: account) }
+describe 'Query Rewriter' do
+  context 'when bulk updating' do
+    let!(:account) { Account.create!(name: 'Test Account') }
+    let!(:project) { Project.create(name: 'Project 1', account: account) }
+    let!(:manager) { Manager.create(name: 'Manager', project: project, account: account) }
 
-    it "updates the records" do
-      expect {
+    it 'updates the records' do
+      expect do
         MultiTenant.with(account) do
-          Project.joins(:manager).update_all(name: "New Name")
+          Project.joins(:manager).update_all(name: 'New Name')
         end
-      }.to change { project.reload.name }.from("Project 1").to("New Name")
+      end.to change { project.reload.name }.from('Project 1').to('New Name')
     end
 
-    it "updates the records without a current tenant" do
-      expect {
-        Project.joins(:manager).update_all(name: "New Name")
-      }.to change { project.reload.name }.from("Project 1").to("New Name")
+    it 'updates the records without a current tenant' do
+      expect do
+        Project.joins(:manager).update_all(name: 'New Name')
+      end.to change { project.reload.name }.from('Project 1').to('New Name')
     end
 
-    it "update the record" do
-      expect {
+    it 'update the record' do
+      expect do
         MultiTenant.with(account) do
-          project.update(name: "New Name")
+          project.update(name: 'New Name')
         end
-      }.to change { project.reload.name }.from("Project 1").to("New Name")
+      end.to change { project.reload.name }.from('Project 1').to('New Name')
     end
 
-    it "update the record without a current tenant" do
-      expect {
-        project.update(name: "New Name")
-      }.to change { project.reload.name }.from("Project 1").to("New Name")
+    it 'update the record without a current tenant' do
+      expect do
+        project.update(name: 'New Name')
+      end.to change { project.reload.name }.from('Project 1').to('New Name')
     end
   end
 
-  context "when bulk deleting" do
-    let!(:account) { Account.create!(name: "Test Account") }
-    let!(:project1) { Project.create(name: "Project 1", account: account) }
-    let!(:project2) { Project.create(name: "Project 2", account: account) }
-    let!(:project3) { Project.create(name: "Project 3", account: account) }
-    let!(:manager1) { Manager.create(name: "Manager 1", project: project1, account: account) }
-    let!(:manager2) { Manager.create(name: "Manager 2", project: project2, account: account) }
+  context 'when bulk deleting' do
+    let!(:account) { Account.create!(name: 'Test Account') }
+    let!(:project1) { Project.create(name: 'Project 1', account: account) }
+    let!(:project2) { Project.create(name: 'Project 2', account: account) }
+    let!(:project3) { Project.create(name: 'Project 3', account: account) }
+    let!(:manager1) { Manager.create(name: 'Manager 1', project: project1, account: account) }
+    let!(:manager2) { Manager.create(name: 'Manager 2', project: project2, account: account) }
 
-    it "delete_all the records" do
-      expect {
+    it 'delete_all the records' do
+      expect do
         MultiTenant.with(account) do
           Project.joins(:manager).delete_all
         end
-      }.to change { Project.count }.from(3).to(1)
+      end.to change { Project.count }.from(3).to(1)
     end
 
-    it "delete_all the records without a current tenant" do
-      expect {
+    it 'delete_all the records without a current tenant' do
+      expect do
         Project.joins(:manager).delete_all
-      }.to change { Project.count }.from(3).to(1)
+      end.to change { Project.count }.from(3).to(1)
     end
 
-    it "delete the record" do
-      expect {
+    it 'delete the record' do
+      expect do
         MultiTenant.with(account) do
           project1.delete
           Project.delete(project2.id)
         end
-      }.to change { Project.count }.from(3).to(1)
+      end.to change { Project.count }.from(3).to(1)
     end
 
-    it "delete the record without a current tenant" do
-      expect {
+    it 'delete the record without a current tenant' do
+      expect do
         project1.delete
         Project.delete(project2.id)
-      }.to change { Project.count }.from(3).to(1)
+      end.to change { Project.count }.from(3).to(1)
     end
 
-    it "destroy the record" do
-      expect {
+    it 'destroy the record' do
+      expect do
         MultiTenant.with(account) do
           project1.destroy
           Project.destroy(project2.id)
         end
-      }.to change { Project.count }.from(3).to(1)
+      end.to change { Project.count }.from(3).to(1)
     end
 
-    it "destroy the record without a current tenant" do
-      expect {
+    it 'destroy the record without a current tenant' do
+      expect do
         project1.destroy
         Project.destroy(project2.id)
-      }.to change { Project.count }.from(3).to(1)
+      end.to change { Project.count }.from(3).to(1)
     end
   end
 
-  context "when update without arel" do
-    it "can call method" do
-      expect {
-        ActiveRecord::Base.connection.update("SELECT 1")
-      }.not_to raise_error
+  context 'when update without arel' do
+    it 'can call method' do
+      expect do
+        ActiveRecord::Base.connection.update('SELECT 1')
+      end.not_to raise_error
     end
   end
 
-  context "when joining with a model with a default scope" do
-    let!(:account) { Account.create!(name: "Test Account") }
+  context 'when joining with a model with a default scope' do
+    let!(:account) { Account.create!(name: 'Test Account') }
 
-    it "fetches only records within the default scope" do
-      alive = Domain.create(name: "alive", account: account)
-      deleted = Domain.create(name: "deleted", deleted: true, account: account)
-      page_in_alive_domain = Page.create(name: "alive", account: account, domain: alive)
-      page_in_deleted_domain = Page.create(name: "deleted", account: account, domain: deleted)
+    it 'fetches only records within the default scope' do
+      alive = Domain.create(name: 'alive', account: account)
+      deleted = Domain.create(name: 'deleted', deleted: true, account: account)
+      page_in_alive_domain = Page.create(name: 'alive', account: account, domain: alive)
+      Page.create(name: 'deleted', account: account, domain: deleted)
 
       expect(
         MultiTenant.with(account) do

data/spec/activerecord-multi-tenant/record_finding_spec.rb

@@ -61,36 +61,36 @@ describe MultiTenant, 'Record finding' do
   end
 
   context 'model with has_many relation through multi-tenant model' do
-    let(:tenant_1) { Account.create! name: 'Tenant 1' }
-    let(:project_1) { tenant_1.projects.create! }
+    let(:tenant1) { Account.create! name: 'Tenant 1' }
+    let(:project1) { tenant1.projects.create! }
 
-    let(:tenant_2) { Account.create! name: 'Tenant 2' }
-    let(:project_2) { tenant_2.projects.create! }
+    let(:tenant2) { Account.create! name: 'Tenant 2' }
+    let(:project2) { tenant2.projects.create! }
 
     let(:category) { Category.create! name: 'Category' }
 
     before do
-      ProjectCategory.create! account: tenant_1, name: '1', project: project_1, category: category
-      ProjectCategory.create! account: tenant_2, name: '2', project: project_2, category: category
+      ProjectCategory.create! account: tenant1, name: '1', project: project1, category: category
+      ProjectCategory.create! account: tenant2, name: '2', project: project2, category: category
     end
 
     it 'can get model without creating query cache' do
-      MultiTenant.with(tenant_1) do
-        found_category = Project.find(project_1.id).categories.to_a.first
+      MultiTenant.with(tenant1) do
+        found_category = Project.find(project1.id).categories.to_a.first
         expect(found_category).to eq(category)
       end
     end
 
     it 'can get model for other tenant' do
-      MultiTenant.with(tenant_2) do
-        found_category = Project.find(project_2.id).categories.to_a.first
+      MultiTenant.with(tenant2) do
+        found_category = Project.find(project2.id).categories.to_a.first
         expect(found_category).to eq(category)
       end
     end
 
     it 'can get model without current_tenant' do
       MultiTenant.without do
-        found_category = Project.find(project_2.id).categories.to_a.first
+        found_category = Project.find(project2.id).categories.to_a.first
         expect(found_category).to eq(category)
       end
     end

data/spec/activerecord-multi-tenant/record_modifications_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe MultiTenant, 'Record modifications' do
@@ -6,7 +8,6 @@ describe MultiTenant, 'Record modifications' do
   let(:project) { Project.create! name: 'something', account: account }
   let(:project2) { Project.create! name: 'something2', account: account2, id: project.id }
 
-
   it 'includes the tenant_id in DELETEs when using object.destroy' do
     # two records with same id but different account_id
     # when doing project.destroy it should delete only the current one
@@ -16,7 +17,7 @@ describe MultiTenant, 'Record modifications' do
     expect(project2.account).to eq(account2)
     expect(project.id).to eq(project2.id)
 
-    MultiTenant.without() do
+    MultiTenant.without do
       expect(Project.count).to eq(2)
       project.destroy
       expect(Project.count).to eq(1)
@@ -28,7 +29,6 @@ describe MultiTenant, 'Record modifications' do
     MultiTenant.with(account2) do
       expect(Project.where(id: project2.id).first).to be_present
     end
-
   end
 
   it 'includes the tenant_id in DELETEs when using object.delete' do
@@ -40,7 +40,7 @@ describe MultiTenant, 'Record modifications' do
     expect(project2.account).to eq(account2)
     expect(project.id).to eq(project2.id)
 
-    MultiTenant.without() do
+    MultiTenant.without do
       expect(Project.count).to eq(2)
       project.delete
       expect(Project.count).to eq(1)
@@ -54,6 +54,25 @@ describe MultiTenant, 'Record modifications' do
     end
   end
 
+  it 'should not update other objects with same id when calling object.update_columns' do
+    # When two records with same id but different account_id are updated, it should only update the current one
+    expect(project.account).to eq(account)
+    expect(project2.account).to eq(account2)
+    expect(project.id).to eq(project2.id)
+
+    MultiTenant.without do
+      project2.update_columns(name: 'newthing2')
+      expect(project.reload.name).to eq('something')
+      expect(project2.reload.name).to eq('newthing2')
+    end
+  end
+
+  it 'should return the same object when calling object.reload' do
+    # When two records with same id but different account_id are updated, it should not return the other object
+    expect(project.reload.account_id).to eq(account.id)
+    expect(project2.reload.account_id).to eq(account2.id)
+  end
+
   it 'test delete for reference tables' do
     category1 = Category.create! name: 'Category 1'
     expect(Category.count).to eq(1)

data/spec/activerecord-multi-tenant/sidekiq_spec.rb

@@ -5,29 +5,29 @@ require 'activerecord-multi-tenant/sidekiq'
 describe MultiTenant, 'Sidekiq' do
   let(:server) { Sidekiq::Middleware::MultiTenant::Server.new }
   let(:account) { Account.create(name: 'test') }
-  let(:deleted_acount) { Account.create(name: 'deleted') }
+  let(:deleted_account) { Account.create(name: 'deleted') }
 
-  before { deleted_acount.destroy! }
+  before { deleted_account.destroy! }
 
   describe 'server middleware' do
     it 'sets the multitenant context when provided in message' do
-      server.call(double,{'bogus' => 'message',
-        'multi_tenant' => { 'class' => account.class.name, 'id' => account.id}},
-        'bogus_queue') do
+      server.call(double, { 'bogus' => 'message',
+                            'multi_tenant' => { 'class' => account.class.name, 'id' => account.id } },
+                  'bogus_queue') do
         expect(MultiTenant.current_tenant).to eq(account)
       end
     end
 
     it 'sets the multitenant context (id) even if tenant not found' do
-      server.call(double,{'bogus' => 'message',
-        'multi_tenant' => { 'class' => deleted_acount.class.name, 'id' => deleted_acount.id}},
-        'bogus_queue') do
-        expect(MultiTenant.current_tenant).to eq(deleted_acount.id)
+      server.call(double, { 'bogus' => 'message',
+                            'multi_tenant' => { 'class' => deleted_account.class.name, 'id' => deleted_account.id } },
+                  'bogus_queue') do
+        expect(MultiTenant.current_tenant).to eq(deleted_account.id)
       end
     end
 
     it 'does not set the multitenant context when no tenant provided' do
-      server.call(double, {'bogus' => 'message'}, 'bogus_queue') do
+      server.call(double, { 'bogus' => 'message' }, 'bogus_queue') do
         expect(MultiTenant.current_tenant).to be_nil
       end
     end

data/spec/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Resets the database, except when we are only running a specific spec
 ARGV.grep(/\w+_spec\.rb/).empty? && ActiveRecord::Schema.define(version: 1) do
   enable_extension_on_all_nodes 'uuid-ossp'
@@ -7,6 +9,7 @@ ARGV.grep(/\w+_spec\.rb/).empty? && ActiveRecord::Schema.define(version: 1) do
     t.column :name, :string
     t.column :subdomain, :string
     t.column :domain, :string
+    t.column :password, :string
   end
 
   create_table :projects, force: true, partition_key: :account_id do |t|
@@ -27,6 +30,17 @@ ARGV.grep(/\w+_spec\.rb/).empty? && ActiveRecord::Schema.define(version: 1) do
     t.column :completed, :boolean
   end
 
+  create_table :managers_tasks, force: true, partition_key: :account_id do |t|
+    t.column :account_id, :integer
+    t.column :manager_id, :integer
+    t.column :task_id, :integer
+  end
+
+  create_table :managers_projects, force: true do |t|
+    t.column :project_id, :integer
+    t.column :manager_id, :integer
+  end
+
   create_table :sub_tasks, force: true, partition_key: :account_id do |t|
     t.column :account_id, :integer
     t.column :name, :string
@@ -34,6 +48,13 @@ ARGV.grep(/\w+_spec\.rb/).empty? && ActiveRecord::Schema.define(version: 1) do
     t.column :type, :string
   end
 
+  create_table :optional_sub_tasks, force: true do |t|
+    t.references :account, :integer
+    t.column :sub_task_id, :integer
+    t.column :name, :string
+    t.column :type, :string
+  end
+
   create_table :countries, force: true do |t|
     t.column :name, :string
   end
@@ -106,6 +127,11 @@ ARGV.grep(/\w+_spec\.rb/).empty? && ActiveRecord::Schema.define(version: 1) do
     t.column :domain_id, :integer
   end
 
+  create_table :posts, force: true, partition_key: :account_id do |t|
+    t.column :account_id, :integer
+    t.column :name, :string
+  end
+
   create_distributed_table :accounts, :id
   create_distributed_table :projects, :account_id
   create_distributed_table :managers, :account_id
@@ -121,6 +147,7 @@ ARGV.grep(/\w+_spec\.rb/).empty? && ActiveRecord::Schema.define(version: 1) do
   create_distributed_table :allowed_places, :account_id
   create_distributed_table :domains, :account_id
   create_distributed_table :pages, :account_id
+  create_distributed_table :posts, :account_id
   create_reference_table :categories
 end
 
@@ -128,6 +155,7 @@ class Account < ActiveRecord::Base
   multi_tenant :account
   has_many :projects
   has_one :manager, inverse_of: :account
+  has_many :optional_sub_tasks
 end
 
 class Project < ActiveRecord::Base
@@ -138,6 +166,7 @@ class Project < ActiveRecord::Base
 
   has_many :project_categories
   has_many :categories, through: :project_categories
+  has_and_belongs_to_many :managers
 
   validates_uniqueness_of :name, scope: [:account]
 end
@@ -145,12 +174,15 @@ end
 class Manager < ActiveRecord::Base
   multi_tenant :account
   belongs_to :project
+  has_and_belongs_to_many :tasks, tenant_column: :account_id, tenant_enabled: true,
+                                  tenant_class_name: 'Account'
 end
 
 class Task < ActiveRecord::Base
   multi_tenant :account
   belongs_to :project
   has_many :sub_tasks
+  has_and_belongs_to_many :managers, tenant_column: :account_id, tenant_enabled: true
 
   validates_uniqueness_of :name
 end
@@ -159,6 +191,14 @@ class SubTask < ActiveRecord::Base
   multi_tenant :account
   belongs_to :task
   has_one :project, through: :task
+  has_many :optional_sub_tasks
+end
+
+with_belongs_to_required_by_default do
+  class OptionalSubTask < ActiveRecord::Base
+    multi_tenant :account, optional: true
+    belongs_to :sub_task
+  end
 end
 
 class StiSubTask < SubTask
@@ -194,10 +234,11 @@ end
 class Comment < ActiveRecord::Base
   multi_tenant :account
   belongs_to :commentable, polymorphic: true
-  belongs_to :task, -> { where(comments: { commentable_type: 'Task'  }) }, foreign_key: 'commentable_id'
+  belongs_to :task, -> { where(comments: { commentable_type: 'Task' }) }, foreign_key: 'commentable_id'
 end
 
 class Organization < ActiveRecord::Base
+  multi_tenant :organization
   has_many :uuid_records
 end
 
@@ -206,7 +247,7 @@ class UuidRecord < ActiveRecord::Base
 end
 
 class Category < ActiveRecord::Base
-  has_many  :project_categories
+  has_many :project_categories
   has_many :projects, through: :project_categories
 end