acts_as_tenant 0.4.3 → 0.5.1

data/lib/acts_as_tenant/model_extensions.rb

@@ -1,109 +1,34 @@
 module ActsAsTenant
-  @@tenant_klass = nil
-  @@models_with_global_records = []
-
-  def self.set_tenant_klass(klass)
-    @@tenant_klass = klass
-  end
-
-  def self.tenant_klass
-    @@tenant_klass
-  end
-
-  def self.models_with_global_records
-    @@models_with_global_records
-  end
-
-  def self.add_global_record_model model
-    @@models_with_global_records.push(model)
-  end
-
-  def self.fkey
-    "#{@@tenant_klass.to_s}_id"
-  end
-
-  def self.current_tenant=(tenant)
-    RequestStore.store[:current_tenant] = tenant
-  end
-
-  def self.current_tenant
-    RequestStore.store[:current_tenant] || self.default_tenant
-  end
-
-  def self.unscoped=(unscoped)
-    RequestStore.store[:acts_as_tenant_unscoped] = unscoped
-  end
-
-  def self.unscoped
-    RequestStore.store[:acts_as_tenant_unscoped]
-  end
-
-  def self.unscoped?
-    !!unscoped
-  end
-
-  class << self
-    attr_accessor :default_tenant
-  end
-
-  def self.with_tenant(tenant, &block)
-    if block.nil?
-      raise ArgumentError, "block required"
-    end
-
-    old_tenant = self.current_tenant
-    self.current_tenant = tenant
-    value = block.call
-    return value
-
-  ensure
-    self.current_tenant = old_tenant
-  end
-
-  def self.without_tenant(&block)
-    if block.nil?
-      raise ArgumentError, "block required"
-    end
-
-    old_tenant = current_tenant
-    old_unscoped = unscoped
-
-    self.current_tenant = nil
-    self.unscoped = true
-    value = block.call
-    return value
-
-  ensure
-    self.current_tenant = old_tenant
-    self.unscoped = old_unscoped
-  end
-
   module ModelExtensions
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
-    module ClassMethods
-      def acts_as_tenant(tenant = :account, options = {})
+    class_methods do
+      def acts_as_tenant(tenant = :account, **options)
         ActsAsTenant.set_tenant_klass(tenant)
 
         ActsAsTenant.add_global_record_model(self) if options[:has_global_records]
 
         # Create the association
-        valid_options = options.slice(:foreign_key, :class_name, :inverse_of, :optional)
+        valid_options = options.slice(:foreign_key, :class_name, :inverse_of, :optional, :primary_key, :counter_cache)
         fkey = valid_options[:foreign_key] || ActsAsTenant.fkey
-        belongs_to tenant, valid_options
+        pkey = valid_options[:primary_key] || ActsAsTenant.pkey
+        polymorphic_type = valid_options[:foreign_type] || ActsAsTenant.polymorphic_type
+        belongs_to tenant, **valid_options
 
         default_scope lambda {
           if ActsAsTenant.configuration.require_tenant && ActsAsTenant.current_tenant.nil? && !ActsAsTenant.unscoped?
             raise ActsAsTenant::Errors::NoTenantSet
           end
+
           if ActsAsTenant.current_tenant
-            keys = [ActsAsTenant.current_tenant.id]
+            keys = [ActsAsTenant.current_tenant.send(pkey)].compact
             keys.push(nil) if options[:has_global_records]
-            where(fkey.to_sym => keys)
+
+            query_criteria = {fkey.to_sym => keys}
+            query_criteria[polymorphic_type.to_sym] = ActsAsTenant.current_tenant.class.to_s if options[:polymorphic]
+            where(query_criteria)
           else
-            Rails::VERSION::MAJOR < 4 ? scoped : all
+            all
           end
         }
 
@@ -111,26 +36,30 @@ module ActsAsTenant
         # - new instances should have the tenant set
         # - validate that associations belong to the tenant, currently only for belongs_to
         #
-        before_validation Proc.new {|m|
+        before_validation proc { |m|
           if ActsAsTenant.current_tenant
-            m.send "#{fkey}=".to_sym, ActsAsTenant.current_tenant.id
+            if options[:polymorphic]
+              m.send("#{fkey}=".to_sym, ActsAsTenant.current_tenant.class.to_s) if m.send(fkey.to_s).nil?
+              m.send("#{polymorphic_type}=".to_sym, ActsAsTenant.current_tenant.class.to_s) if m.send(polymorphic_type.to_s).nil?
+            else
+              m.send "#{fkey}=".to_sym, ActsAsTenant.current_tenant.send(pkey)
+            end
           end
-        }, :on => :create
+        }, on: :create
 
-        polymorphic_foreign_keys = reflect_on_all_associations(:belongs_to).select do |a|
+        polymorphic_foreign_keys = reflect_on_all_associations(:belongs_to).select { |a|
           a.options[:polymorphic]
-        end.map { |a| a.foreign_key }
+        }.map { |a| a.foreign_key }
 
         reflect_on_all_associations(:belongs_to).each do |a|
           unless a == reflect_on_association(tenant) || polymorphic_foreign_keys.include?(a.foreign_key)
-            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|
-              primary_key = if association_class.respond_to?(:primary_key)
-                              association_class.primary_key
-                            else
-                              a.primary_key
-                            end.to_sym
-              record.errors.add attr, "association is invalid [ActsAsTenant]" unless value.nil? || association_class.where(primary_key => value).any?
+              primary_key = if a.respond_to?(:active_record_primary_key)
+                a.active_record_primary_key
+              else
+                a.primary_key
+              end.to_sym
+              record.errors.add attr, "association is invalid [ActsAsTenant]" unless value.nil? || a.klass.where(primary_key => value).any?
             end
           end
         end
@@ -139,27 +68,19 @@ module ActsAsTenant
         # - Rewrite the accessors to make tenant immutable
         # - Add an override to prevent unnecessary db hits
         # - Add a helper method to verify if a model has been scoped by AaT
-        to_include = Module.new do
+        to_include = Module.new {
           define_method "#{fkey}=" do |integer|
-            write_attribute("#{fkey}", integer)
+            write_attribute(fkey.to_s, integer)
             raise ActsAsTenant::Errors::TenantIsImmutable if send("#{fkey}_changed?") && persisted? && !send("#{fkey}_was").nil?
             integer
           end
 
-          define_method "#{ActsAsTenant.tenant_klass.to_s}=" do |model|
+          define_method "#{ActsAsTenant.tenant_klass}=" do |model|
             super(model)
             raise ActsAsTenant::Errors::TenantIsImmutable if send("#{fkey}_changed?") && persisted? && !send("#{fkey}_was").nil?
             model
           end
-
-          define_method "#{ActsAsTenant.tenant_klass.to_s}" do
-            if !ActsAsTenant.current_tenant.nil? && send(fkey) == ActsAsTenant.current_tenant.id
-              return ActsAsTenant.current_tenant
-            else
-              super()
-            end
-          end
-        end
+        }
         include to_include
 
         class << self
@@ -169,36 +90,38 @@ module ActsAsTenant
         end
       end
 
-      def validates_uniqueness_to_tenant(fields, args ={})
+      def validates_uniqueness_to_tenant(fields, args = {})
         raise ActsAsTenant::Errors::ModelNotScopedByTenant unless respond_to?(:scoped_by_tenant?)
+
         fkey = reflect_on_association(ActsAsTenant.tenant_klass).foreign_key
-        #tenant_id = lambda { "#{ActsAsTenant.fkey}"}.call
-        if args[:scope]
-          args[:scope] = Array(args[:scope]) << fkey
+
+        validation_args = args.clone
+        validation_args[:scope] = if args[:scope]
+          Array(args[:scope]) << fkey
         else
-          args[:scope] = fkey
+          fkey
         end
 
-        validates_uniqueness_of(fields, args)
+        # validating within tenant scope
+        validates_uniqueness_of(fields, validation_args)
 
         if ActsAsTenant.models_with_global_records.include?(self)
-          validate do |instance|
-            Array(fields).each do |field|
-              if instance.new_record?
-                unless self.class.where(fkey.to_sym => [nil, instance[fkey]],
-                                        field.to_sym => instance[field]).empty?
-                  errors.add(field, 'has already been taken') 
-                end
-              else
-                unless self.class.where(fkey.to_sym => [nil, instance[fkey]],
-                                        field.to_sym => instance[field])
-                                 .where.not(:id => instance.id).empty?
-                  errors.add(field, 'has already been taken') 
-                end
-
-              end
-            end
-          end
+          arg_if = args.delete(:if)
+          arg_condition = args.delete(:conditions)
+
+          # if tenant is not set (instance is global) - validating globally
+          global_validation_args = args.merge(
+            if: ->(instance) { instance[fkey].blank? && (arg_if.blank? || arg_if.call(instance)) }
+          )
+          validates_uniqueness_of(fields, global_validation_args)
+
+          # if tenant is set (instance is not global) and records can be global - validating within records with blank tenant
+          blank_tenant_validation_args = args.merge({
+            conditions: -> { arg_condition.blank? ? where(fkey => nil) : arg_condition.call.where(fkey => nil) },
+            if: ->(instance) { instance[fkey].present? && (arg_if.blank? || arg_if.call(instance)) }
+          })
+
+          validates_uniqueness_of(fields, blank_tenant_validation_args)
         end
       end
     end

data/lib/acts_as_tenant/sidekiq.rb

@@ -2,11 +2,13 @@ module ActsAsTenant::Sidekiq
   # Get the current tenant and store in the message to be sent to Sidekiq.
   class Client
     def call(worker_class, msg, queue, redis_pool)
-      msg['acts_as_tenant'] ||=
-        {
-            'class' => ActsAsTenant.current_tenant.class.name,
-            'id' => ActsAsTenant.current_tenant.id
-        } if ActsAsTenant.current_tenant.present?
+      if ActsAsTenant.current_tenant.present?
+        msg["acts_as_tenant"] ||=
+          {
+            "class" => ActsAsTenant.current_tenant.class.name,
+            "id" => ActsAsTenant.current_tenant.id
+          }
+      end
 
       yield
     end
@@ -15,8 +17,8 @@ module ActsAsTenant::Sidekiq
   # Pull the tenant out and run the current thread with it.
   class Server
     def call(worker_class, msg, queue)
-      if msg.has_key?('acts_as_tenant')
-        account = msg['acts_as_tenant']['class'].constantize.find msg['acts_as_tenant']['id']
+      if msg.has_key?("acts_as_tenant")
+        account = msg["acts_as_tenant"]["class"].constantize.find msg["acts_as_tenant"]["id"]
         ActsAsTenant.with_tenant account do
           yield
         end
@@ -40,6 +42,8 @@ Sidekiq.configure_server do |config|
   config.server_middleware do |chain|
     if defined?(Sidekiq::Middleware::Server::RetryJobs)
       chain.insert_before Sidekiq::Middleware::Server::RetryJobs, ActsAsTenant::Sidekiq::Server
+    elsif defined?(Sidekiq::Batch::Server)
+      chain.insert_before Sidekiq::Batch::Server, ActsAsTenant::Sidekiq::Server
     else
       chain.add ActsAsTenant::Sidekiq::Server
     end

data/lib/acts_as_tenant/tenant_helper.rb

@@ -0,0 +1,7 @@
+module ActsAsTenant
+  module TenantHelper
+    def current_tenant
+      ActsAsTenant.current_tenant
+    end
+  end
+end

data/lib/acts_as_tenant/test_tenant_middleware.rb

@@ -0,0 +1,15 @@
+module ActsAsTenant
+  class TestTenantMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      previously_set_test_tenant = ActsAsTenant.test_tenant
+      ActsAsTenant.test_tenant = nil
+      @app.call(env)
+    ensure
+      ActsAsTenant.test_tenant = previously_set_test_tenant
+    end
+  end
+end

data/lib/acts_as_tenant/version.rb

@@ -1,3 +1,3 @@
 module ActsAsTenant
-  VERSION = "0.4.3"
+  VERSION = "0.5.1"
 end

data/lib/acts_as_tenant.rb

@@ -1,27 +1,125 @@
 require "request_store"
 
-#$LOAD_PATH.unshift(File.dirname(__FILE__))
-
 require "acts_as_tenant/version"
 require "acts_as_tenant/errors"
-require "acts_as_tenant/configuration"
-require "acts_as_tenant/controller_extensions"
-require "acts_as_tenant/model_extensions"
 
-#$LOAD_PATH.shift
+module ActsAsTenant
+  autoload :Configuration, "acts_as_tenant/configuration"
+  autoload :ControllerExtensions, "acts_as_tenant/controller_extensions"
+  autoload :ModelExtensions, "acts_as_tenant/model_extensions"
+  autoload :TenantHelper, "acts_as_tenant/tenant_helper"
+
+  @@configuration = nil
+  @@tenant_klass = nil
+  @@models_with_global_records = []
+
+  class << self
+    attr_accessor :test_tenant
+    attr_writer :default_tenant
+  end
+
+  def self.configure
+    @@configuration = Configuration.new
+    yield configuration if block_given?
+    configuration
+  end
+
+  def self.configuration
+    @@configuration || configure
+  end
+
+  def self.set_tenant_klass(klass)
+    @@tenant_klass = klass
+  end
+
+  def self.tenant_klass
+    @@tenant_klass
+  end
+
+  def self.models_with_global_records
+    @@models_with_global_records
+  end
+
+  def self.add_global_record_model model
+    @@models_with_global_records.push(model)
+  end
+
+  def self.fkey
+    "#{@@tenant_klass}_id"
+  end
+
+  def self.pkey
+    ActsAsTenant.configuration.pkey
+  end
 
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.send(:include, ActsAsTenant::ModelExtensions)
+  def self.polymorphic_type
+    "#{@@tenant_klass}_type"
+  end
+
+  def self.current_tenant=(tenant)
+    RequestStore.store[:current_tenant] = tenant
+  end
+
+  def self.current_tenant
+    RequestStore.store[:current_tenant] || test_tenant || default_tenant
+  end
+
+  def self.unscoped=(unscoped)
+    RequestStore.store[:acts_as_tenant_unscoped] = unscoped
+  end
+
+  def self.unscoped
+    RequestStore.store[:acts_as_tenant_unscoped]
+  end
+
+  def self.unscoped?
+    !!unscoped
+  end
+
+  def self.default_tenant
+    @default_tenant unless unscoped
+  end
+
+  def self.with_tenant(tenant, &block)
+    if block.nil?
+      raise ArgumentError, "block required"
+    end
+
+    old_tenant = current_tenant
+    self.current_tenant = tenant
+    value = block.call
+    value
+  ensure
+    self.current_tenant = old_tenant
+  end
+
+  def self.without_tenant(&block)
+    if block.nil?
+      raise ArgumentError, "block required"
+    end
+
+    old_tenant = current_tenant
+    old_unscoped = unscoped
+
+    self.current_tenant = nil
+    self.unscoped = true
+    value = block.call
+    value
+  ensure
+    self.current_tenant = old_tenant
+    self.unscoped = old_unscoped
+  end
 end
 
-if defined?(ActionController::Base)
-  ActionController::Base.extend ActsAsTenant::ControllerExtensions
+ActiveSupport.on_load(:active_record) do |base|
+  base.include ActsAsTenant::ModelExtensions
 end
 
-if defined?(ActionController::API)
-  ActionController::API.extend ActsAsTenant::ControllerExtensions
+ActiveSupport.on_load(:action_controller) do |base|
+  base.extend ActsAsTenant::ControllerExtensions
+  base.include ActsAsTenant::TenantHelper
 end
 
-module ActsAsTenant
+ActiveSupport.on_load(:action_view) do |base|
+  base.include ActsAsTenant::TenantHelper
 end
-  

data/spec/acts_as_tenant/configuration_spec.rb

@@ -1,28 +1,17 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ActsAsTenant::Configuration do
-  describe 'no configuration given' do
-    before do
-      ActsAsTenant.configure
-    end
+  after { ActsAsTenant.configure }
 
-    it 'provides defaults' do
-      expect(ActsAsTenant.configuration.require_tenant).not_to be_truthy
-    end
+  it "provides defaults" do
+    expect(ActsAsTenant.configuration.require_tenant).not_to be_truthy
   end
 
-  describe 'with config block' do
-    after do
-      ActsAsTenant.configure
-    end
-
-    it 'stores config' do
-      ActsAsTenant.configure do |config|
-        config.require_tenant = true
-      end
-
-      expect(ActsAsTenant.configuration.require_tenant).to eq(true)
+  it "stores config" do
+    ActsAsTenant.configure do |config|
+      config.require_tenant = true
     end
 
+    expect(ActsAsTenant.configuration.require_tenant).to eq(true)
   end
 end

data/spec/acts_as_tenant/sidekiq_spec.rb

@@ -1,28 +1,27 @@
-require 'spec_helper'
-require 'sidekiq'
-require 'acts_as_tenant/sidekiq'
+require "spec_helper"
+require "sidekiq"
+require "acts_as_tenant/sidekiq"
 
 describe ActsAsTenant::Sidekiq do
-  after { ActsAsTenant.current_tenant = nil }
   let(:account) { Account.new(id: 1234) }
-  let(:message) { { 'acts_as_tenant' => { 'class' => 'Account', 'id' => 1234 } } }
+  let(:message) { {"acts_as_tenant" => {"class" => "Account", "id" => 1234}} }
 
   describe ActsAsTenant::Sidekiq::Client do
     subject { ActsAsTenant::Sidekiq::Client.new }
 
-    it 'saves tenant if present' do
+    it "saves tenant if present" do
       ActsAsTenant.current_tenant = account
 
       msg = {}
-      subject.call(nil, msg, nil, nil) { }
+      subject.call(nil, msg, nil, nil) {}
       expect(msg).to eq message
     end
 
-    it 'does not set tenant if not present' do
+    it "does not set tenant if not present" do
       expect(ActsAsTenant.current_tenant).to be_nil
 
       msg = {}
-      subject.call(nil, msg, nil, nil) { }
+      subject.call(nil, msg, nil, nil) {}
       expect(msg).not_to eq message
     end
   end
@@ -30,7 +29,7 @@ describe ActsAsTenant::Sidekiq do
   describe ActsAsTenant::Sidekiq::Server do
     subject { ActsAsTenant::Sidekiq::Server.new }
 
-    it 'restores tenant if tenant saved' do
+    it "restores tenant if tenant saved" do
       expect(Account).to receive(:find).with(1234).once { account }
 
       msg = message
@@ -40,7 +39,7 @@ describe ActsAsTenant::Sidekiq do
       expect(ActsAsTenant.current_tenant).to be_nil
     end
 
-    it 'runs without tenant if no tenant saved' do
+    it "runs without tenant if no tenant saved" do
       expect(Account).not_to receive(:find)
 
       msg = {}
@@ -51,13 +50,9 @@ describe ActsAsTenant::Sidekiq do
     end
   end
 
-  describe 'Sidekiq configuration' do
-    describe 'client configuration' do
-      it 'includes ActsAsTenant client' do
-        expect(Sidekiq.client_middleware.exists?(ActsAsTenant::Sidekiq::Client)).to eq(true)
-      end
-    end
-
-    # unable to test server configuration
+  it "includes ActsAsTenant client middleware" do
+    expect(Sidekiq.client_middleware.exists?(ActsAsTenant::Sidekiq::Client)).to eq(true)
   end
+
+  # unable to test server configuration
 end

data/spec/{acts_as_tenant/tenant_by_filter_spec.rb → controllers/filter_spec.rb}

@@ -1,33 +1,28 @@
 require "spec_helper"
 
-#Setup test specific ApplicationController
-class Account
-  attr_accessor :name
-end
-
 class ApplicationController2 < ActionController::Base
   include Rails.application.routes.url_helpers
   set_current_tenant_through_filter
   before_action :your_method_that_finds_the_current_tenant
 
   def your_method_that_finds_the_current_tenant
-    current_account = Account.new
-    current_account.name = 'account1'
+    current_account = Account.new(name: "account1")
     set_current_tenant(current_account)
   end
-
 end
 
 # Start testing
-describe ApplicationController2, :type => :controller do
+describe ApplicationController2, type: :controller do
   controller do
     def index
-      render :plain => "custom called"
+      # Exercise current_tenant helper method
+      render plain: current_tenant.name
     end
   end
 
-  it 'Finds the correct tenant using the filter command' do
+  it "Finds the correct tenant using the filter command" do
     get :index
-    expect(ActsAsTenant.current_tenant.name).to eq 'account1'
+    expect(ActsAsTenant.current_tenant.name).to eq "account1"
+    expect(response.body).to eq "account1"
   end
 end

data/spec/controllers/subdomain_or_domain_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+class DomainController < ActionController::Base
+  include Rails.application.routes.url_helpers
+  set_current_tenant_by_subdomain_or_domain
+end
+
+describe DomainController, type: :controller do
+  let(:account) { accounts(:with_domain) }
+
+  controller do
+    def index
+      # Exercise current_tenant helper method
+      render plain: current_tenant.name
+    end
+  end
+
+  it "finds the correct tenant with a example1.com" do
+    @request.host = account.domain
+    get :index
+    expect(ActsAsTenant.current_tenant).to eq account
+    expect(response.body).to eq account.name
+  end
+
+  it "finds the correct tenant with a subdomain.example.com" do
+    @request.host = "#{account.subdomain}.example.com"
+    get :index
+    expect(ActsAsTenant.current_tenant).to eq account
+    expect(response.body).to eq account.name
+  end
+
+  it "finds the correct tenant with a www.subdomain.example.com" do
+    @request.host = "www.#{account.subdomain}.example.com"
+    get :index
+    expect(ActsAsTenant.current_tenant).to eq account
+  end
+
+  it "ignores case when finding tenant by subdomain" do
+    @request.host = "#{account.subdomain.upcase}.example.com"
+    get :index
+    expect(ActsAsTenant.current_tenant).to eq account
+  end
+
+  context "overriding subdomain lookup" do
+    after { controller.subdomain_lookup = :last }
+
+    it "allows overriding the subdomain lookup" do
+      controller.subdomain_lookup = :first
+      @request.host = "#{account.subdomain}.another.example.com"
+      get :index
+      expect(ActsAsTenant.current_tenant).to eq account
+      expect(response.body).to eq(account.subdomain)
+    end
+  end
+end