ros-apartment 2.4.0 → 2.5.0

data/spec/tenant_spec.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Apartment::Tenant do
-  context 'using mysql', database: :mysql do
-    before { subject.reload!(config) }
-
-    describe '#adapter' do
-      it 'should load mysql adapter' do
-        subject.adapter
-        expect(Apartment::Adapters::Mysql2Adapter).to be_a(Class)
-      end
-    end
-
-    # TODO: this doesn't belong here, but there aren't integration tests currently for mysql
-    # where to put???
-    describe 'exception recovery', type: :request do
-      before do
-        subject.create db1
-      end
-      after { subject.drop db1 }
-
-      # it "should recover from incorrect database" do
-      #   session = Capybara::Session.new(:rack_test, Capybara.app)
-      #   session.visit("http://#{db1}.com")
-      #   expect {
-      #     session.visit("http://this-database-should-not-exist.com")
-      #   }.to raise_error
-      #   session.visit("http://#{db1}.com")
-      # end
-    end
-
-    # TODO: re-organize these tests
-    context 'with prefix and schemas' do
-      describe '#create' do
-        before do
-          Apartment.configure do |config|
-            config.prepend_environment = true
-            config.use_schemas = true
-          end
-
-          subject.reload!(config)
-        end
-
-        after do
-          begin
-            subject.drop 'db_with_prefix'
-          rescue StandardError => _e
-            nil
-          end
-        end
-
-        it 'should create a new database' do
-          subject.create 'db_with_prefix'
-        end
-      end
-    end
-  end
-
-  context 'using postgresql', database: :postgresql do
-    before do
-      Apartment.use_schemas = true
-      subject.reload!(config)
-    end
-
-    describe '#adapter' do
-      it 'should load postgresql adapter' do
-        expect(subject.adapter).to be_a(Apartment::Adapters::PostgresqlSchemaAdapter)
-      end
-
-      it 'raises exception with invalid adapter specified' do
-        subject.reload!(config.merge(adapter: 'unknown'))
-
-        expect do
-          Apartment::Tenant.adapter
-        end.to raise_error(RuntimeError)
-      end
-
-      context 'threadsafety' do
-        before { subject.create db1 }
-        after  { subject.drop   db1 }
-
-        it 'has a threadsafe adapter' do
-          subject.switch!(db1)
-          thread = Thread.new { expect(subject.current).to eq(Apartment.default_tenant) }
-          thread.join
-          expect(subject.current).to eq(db1)
-        end
-      end
-    end
-
-    # TODO: above spec are also with use_schemas=true
-    context 'with schemas' do
-      before do
-        Apartment.configure do |config|
-          config.excluded_models = []
-          config.use_schemas = true
-          config.seed_after_create = true
-        end
-        subject.create db1
-      end
-
-      after { subject.drop db1 }
-
-      describe '#create' do
-        it 'should seed data' do
-          subject.switch! db1
-          expect(User.count).to be > 0
-        end
-      end
-
-      describe '#switch!' do
-        let(:x) { rand(3) }
-
-        context 'creating models' do
-          before { subject.create db2 }
-          after { subject.drop db2 }
-
-          it 'should create a model instance in the current schema' do
-            subject.switch! db2
-            db2_count = User.count + x.times { User.create }
-
-            subject.switch! db1
-            db_count = User.count + x.times { User.create }
-
-            subject.switch! db2
-            expect(User.count).to eq(db2_count)
-
-            subject.switch! db1
-            expect(User.count).to eq(db_count)
-          end
-        end
-
-        context 'with excluded models' do
-          before do
-            Apartment.configure do |config|
-              config.excluded_models = ['Company']
-            end
-            subject.init
-          end
-
-          after do
-            # Apartment::Tenant.init creates per model connection.
-            # Remove the connection after testing not to unintentionally keep the connection across tests.
-            Apartment.excluded_models.each do |excluded_model|
-              excluded_model.constantize.remove_connection
-            end
-          end
-
-          it 'should create excluded models in public schema' do
-            subject.reset # ensure we're on public schema
-            count = Company.count + x.times { Company.create }
-
-            subject.switch! db1
-            x.times { Company.create }
-            expect(Company.count).to eq(count + x)
-            subject.reset
-            expect(Company.count).to eq(count + x)
-          end
-        end
-      end
-    end
-
-    context 'seed paths' do
-      before do
-        Apartment.configure do |config|
-          config.excluded_models = []
-          config.use_schemas = true
-          config.seed_after_create = true
-        end
-      end
-
-      after { subject.drop db1 }
-
-      it 'should seed from default path' do
-        subject.create db1
-        subject.switch! db1
-        expect(User.count).to eq(3)
-        expect(User.first.name).to eq('Some User 0')
-      end
-
-      it 'should seed from custom path' do
-        Apartment.configure do |config|
-          config.seed_data_file = Rails.root.join('db', 'seeds', 'import.rb')
-        end
-        subject.create db1
-        subject.switch! db1
-        expect(User.count).to eq(6)
-        expect(User.first.name).to eq('Different User 0')
-      end
-    end
-  end
-end

data/spec/unit/config_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Apartment do
-  describe '#config' do
-    let(:excluded_models) { ['Company'] }
-    let(:seed_data_file_path) { Rails.root.join('db', 'seeds', 'import.rb') }
-
-    def tenant_names_from_array(names)
-      names.each_with_object({}) do |tenant, hash|
-        hash[tenant] = Apartment.connection_config
-      end.with_indifferent_access
-    end
-
-    it 'should yield the Apartment object' do
-      Apartment.configure do |config|
-        config.excluded_models = []
-        expect(config).to eq(Apartment)
-      end
-    end
-
-    it 'should set excluded models' do
-      Apartment.configure do |config|
-        config.excluded_models = excluded_models
-      end
-      expect(Apartment.excluded_models).to eq(excluded_models)
-    end
-
-    it 'should set use_schemas' do
-      Apartment.configure do |config|
-        config.excluded_models = []
-        config.use_schemas = false
-      end
-      expect(Apartment.use_schemas).to be false
-    end
-
-    it 'should set seed_data_file' do
-      Apartment.configure do |config|
-        config.seed_data_file = seed_data_file_path
-      end
-      expect(Apartment.seed_data_file).to eq(seed_data_file_path)
-    end
-
-    it 'should set seed_after_create' do
-      Apartment.configure do |config|
-        config.excluded_models = []
-        config.seed_after_create = true
-      end
-      expect(Apartment.seed_after_create).to be true
-    end
-
-    context 'databases' do
-      let(:users_conf_hash) { { port: 5444 } }
-
-      before do
-        Apartment.configure do |config|
-          config.tenant_names = tenant_names
-        end
-      end
-
-      context 'tenant_names as string array' do
-        let(:tenant_names) { %w[users companies] }
-
-        it 'should return object if it doesnt respond_to call' do
-          expect(Apartment.tenant_names).to eq(tenant_names_from_array(tenant_names).keys)
-        end
-
-        it 'should set tenants_with_config' do
-          expect(Apartment.tenants_with_config).to eq(tenant_names_from_array(tenant_names))
-        end
-      end
-
-      context 'tenant_names as proc returning an array' do
-        let(:tenant_names) { -> { %w[users companies] } }
-
-        it 'should return object if it doesnt respond_to call' do
-          expect(Apartment.tenant_names).to eq(tenant_names_from_array(tenant_names.call).keys)
-        end
-
-        it 'should set tenants_with_config' do
-          expect(Apartment.tenants_with_config).to eq(tenant_names_from_array(tenant_names.call))
-        end
-      end
-
-      context 'tenant_names as Hash' do
-        let(:tenant_names) { { users: users_conf_hash }.with_indifferent_access }
-
-        it 'should return object if it doesnt respond_to call' do
-          expect(Apartment.tenant_names).to eq(tenant_names.keys)
-        end
-
-        it 'should set tenants_with_config' do
-          expect(Apartment.tenants_with_config).to eq(tenant_names)
-        end
-      end
-
-      context 'tenant_names as proc returning a Hash' do
-        let(:tenant_names) { -> { { users: users_conf_hash }.with_indifferent_access } }
-
-        it 'should return object if it doesnt respond_to call' do
-          expect(Apartment.tenant_names).to eq(tenant_names.call.keys)
-        end
-
-        it 'should set tenants_with_config' do
-          expect(Apartment.tenants_with_config).to eq(tenant_names.call)
-        end
-      end
-    end
-  end
-end

data/spec/unit/elevators/domain_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'apartment/elevators/domain'
-
-describe Apartment::Elevators::Domain do
-  subject(:elevator) { described_class.new(proc {}) }
-
-  describe '#parse_tenant_name' do
-    it 'parses the host for a domain name' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => 'example.com')
-      expect(elevator.parse_tenant_name(request)).to eq('example')
-    end
-
-    it 'ignores a www prefix and domain suffix' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => 'www.example.bc.ca')
-      expect(elevator.parse_tenant_name(request)).to eq('example')
-    end
-
-    it 'returns nil if there is no host' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => '')
-      expect(elevator.parse_tenant_name(request)).to be_nil
-    end
-  end
-
-  describe '#call' do
-    it 'switches to the proper tenant' do
-      expect(Apartment::Tenant).to receive(:switch).with('example')
-
-      elevator.call('HTTP_HOST' => 'www.example.com')
-    end
-  end
-end

data/spec/unit/elevators/first_subdomain_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'apartment/elevators/first_subdomain'
-
-describe Apartment::Elevators::FirstSubdomain do
-  describe 'subdomain' do
-    subject { described_class.new('test').parse_tenant_name(request) }
-    let(:request) { double(:request, host: "#{subdomain}.example.com") }
-
-    context 'one subdomain' do
-      let(:subdomain) { 'test' }
-      it { is_expected.to eq('test') }
-    end
-
-    context 'nested subdomains' do
-      let(:subdomain) { 'test1.test2' }
-      it { is_expected.to eq('test1') }
-    end
-
-    context 'no subdomain' do
-      let(:subdomain) { nil }
-      it { is_expected.to eq(nil) }
-    end
-  end
-end

data/spec/unit/elevators/generic_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'apartment/elevators/generic'
-
-describe Apartment::Elevators::Generic do
-  class MyElevator < described_class
-    def parse_tenant_name(*)
-      'tenant2'
-    end
-  end
-
-  subject(:elevator) { described_class.new(proc {}) }
-
-  describe '#call' do
-    it 'calls the processor if given' do
-      elevator = described_class.new(proc {}, proc { 'tenant1' })
-
-      expect(Apartment::Tenant).to receive(:switch).with('tenant1')
-
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-    end
-
-    it 'raises if parse_tenant_name not implemented' do
-      expect do
-        elevator.call('HTTP_HOST' => 'foo.bar.com')
-      end.to raise_error(RuntimeError)
-    end
-
-    it 'switches to the parsed db_name' do
-      elevator = MyElevator.new(proc {})
-
-      expect(Apartment::Tenant).to receive(:switch).with('tenant2')
-
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-    end
-
-    it 'calls the block implementation of `switch`' do
-      elevator = MyElevator.new(proc {}, proc { 'tenant2' })
-
-      expect(Apartment::Tenant).to receive(:switch).with('tenant2').and_yield
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-    end
-
-    it 'does not call `switch` if no database given' do
-      app = proc {}
-      elevator = MyElevator.new(app, proc {})
-
-      expect(Apartment::Tenant).not_to receive(:switch)
-      expect(app).to receive :call
-
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-    end
-  end
-end

data/spec/unit/elevators/host_hash_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'apartment/elevators/host_hash'
-
-describe Apartment::Elevators::HostHash do
-  subject(:elevator) { Apartment::Elevators::HostHash.new(proc {}, 'example.com' => 'example_tenant') }
-
-  describe '#parse_tenant_name' do
-    it 'parses the host for a domain name' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => 'example.com')
-      expect(elevator.parse_tenant_name(request)).to eq('example_tenant')
-    end
-
-    it 'raises TenantNotFound exception if there is no host' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => '')
-      expect { elevator.parse_tenant_name(request) }.to raise_error(Apartment::TenantNotFound)
-    end
-
-    it 'raises TenantNotFound exception if there is no database associated to current host' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => 'example2.com')
-      expect { elevator.parse_tenant_name(request) }.to raise_error(Apartment::TenantNotFound)
-    end
-  end
-
-  describe '#call' do
-    it 'switches to the proper tenant' do
-      expect(Apartment::Tenant).to receive(:switch).with('example_tenant')
-
-      elevator.call('HTTP_HOST' => 'example.com')
-    end
-  end
-end

data/spec/unit/elevators/host_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'apartment/elevators/host'
-
-describe Apartment::Elevators::Host do
-  subject(:elevator) { described_class.new(proc {}) }
-
-  describe '#parse_tenant_name' do
-    it 'should return nil when no host' do
-      request = ActionDispatch::Request.new('HTTP_HOST' => '')
-      expect(elevator.parse_tenant_name(request)).to be_nil
-    end
-
-    context 'assuming no ignored_first_subdomains' do
-      before { allow(described_class).to receive(:ignored_first_subdomains).and_return([]) }
-
-      context 'with 3 parts' do
-        it 'should return the whole host' do
-          request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.bar.com')
-          expect(elevator.parse_tenant_name(request)).to eq('foo.bar.com')
-        end
-      end
-
-      context 'with 6 parts' do
-        it 'should return the whole host' do
-          request = ActionDispatch::Request.new('HTTP_HOST' => 'one.two.three.foo.bar.com')
-          expect(elevator.parse_tenant_name(request)).to eq('one.two.three.foo.bar.com')
-        end
-      end
-    end
-
-    context 'assuming ignored_first_subdomains is set' do
-      before { allow(described_class).to receive(:ignored_first_subdomains).and_return(%w[www foo]) }
-
-      context 'with 3 parts' do
-        it 'should return host without www' do
-          request = ActionDispatch::Request.new('HTTP_HOST' => 'www.bar.com')
-          expect(elevator.parse_tenant_name(request)).to eq('bar.com')
-        end
-
-        it 'should return host without foo' do
-          request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.bar.com')
-          expect(elevator.parse_tenant_name(request)).to eq('bar.com')
-        end
-      end
-
-      context 'with 6 parts' do
-        it 'should return host without www' do
-          request = ActionDispatch::Request.new('HTTP_HOST' => 'www.one.two.three.foo.bar.com')
-          expect(elevator.parse_tenant_name(request)).to eq('one.two.three.foo.bar.com')
-        end
-
-        it 'should return host without www' do
-          request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.one.two.three.bar.com')
-          expect(elevator.parse_tenant_name(request)).to eq('one.two.three.bar.com')
-        end
-      end
-    end
-
-    context 'assuming localhost' do
-      it 'should return localhost' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'localhost')
-        expect(elevator.parse_tenant_name(request)).to eq('localhost')
-      end
-    end
-
-    context 'assuming ip address' do
-      it 'should return the ip address' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => '127.0.0.1')
-        expect(elevator.parse_tenant_name(request)).to eq('127.0.0.1')
-      end
-    end
-  end
-
-  describe '#call' do
-    it 'switches to the proper tenant' do
-      allow(described_class).to receive(:ignored_first_subdomains).and_return([])
-      expect(Apartment::Tenant).to receive(:switch).with('foo.bar.com')
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-    end
-
-    it 'ignores ignored_first_subdomains' do
-      allow(described_class).to receive(:ignored_first_subdomains).and_return(%w[foo])
-      expect(Apartment::Tenant).to receive(:switch).with('bar.com')
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-    end
-  end
-end

data/spec/unit/elevators/subdomain_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'apartment/elevators/subdomain'
-
-describe Apartment::Elevators::Subdomain do
-  subject(:elevator) { described_class.new(proc {}) }
-
-  describe '#parse_tenant_name' do
-    context 'assuming one tld' do
-      it 'should parse subdomain' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.bar.com')
-        expect(elevator.parse_tenant_name(request)).to eq('foo')
-      end
-
-      it 'should return nil when no subdomain' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'bar.com')
-        expect(elevator.parse_tenant_name(request)).to be_nil
-      end
-    end
-
-    context 'assuming two tlds' do
-      it 'should parse subdomain in the third level domain' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.bar.co.uk')
-        expect(elevator.parse_tenant_name(request)).to eq('foo')
-      end
-
-      it 'should return nil when no subdomain in the third level domain' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'bar.co.uk')
-        expect(elevator.parse_tenant_name(request)).to be_nil
-      end
-    end
-
-    context 'assuming two subdomains' do
-      it 'should parse two subdomains in the two level domain' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.xyz.bar.com')
-        expect(elevator.parse_tenant_name(request)).to eq('foo')
-      end
-
-      it 'should parse two subdomains in the third level domain' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.xyz.bar.co.uk')
-        expect(elevator.parse_tenant_name(request)).to eq('foo')
-      end
-    end
-
-    context 'assuming localhost' do
-      it 'should return nil for localhost' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => 'localhost')
-        expect(elevator.parse_tenant_name(request)).to be_nil
-      end
-    end
-
-    context 'assuming ip address' do
-      it 'should return nil for an ip address' do
-        request = ActionDispatch::Request.new('HTTP_HOST' => '127.0.0.1')
-        expect(elevator.parse_tenant_name(request)).to be_nil
-      end
-    end
-  end
-
-  describe '#call' do
-    it 'switches to the proper tenant' do
-      expect(Apartment::Tenant).to receive(:switch).with('tenant1')
-      elevator.call('HTTP_HOST' => 'tenant1.example.com')
-    end
-
-    it 'ignores excluded subdomains' do
-      described_class.excluded_subdomains = %w[foo]
-
-      expect(Apartment::Tenant).not_to receive(:switch)
-
-      elevator.call('HTTP_HOST' => 'foo.bar.com')
-
-      described_class.excluded_subdomains = nil
-    end
-  end
-end