ros-apartment 2.3.0.alpha1

data/spec/tenant_spec.rb

@@ -0,0 +1,190 @@
+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 { subject.drop "db_with_prefix" rescue nil }
+
+        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 {
+          Apartment::Tenant.adapter
+        }.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}/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

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Apartment do
+
+  describe "#config" do
+
+    let(:excluded_models){ ["Company"] }
+    let(:seed_data_file_path){ "#{Rails.root}/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) { ['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) { lambda { ['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) { lambda { { 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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'apartment/elevators/domain'
+
+describe Apartment::Elevators::Domain do
+
+  subject(:elevator){ described_class.new(Proc.new{}) }
+
+  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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,54 @@
+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.new{}) }
+
+  describe "#call" do
+    it "calls the processor if given" do
+      elevator = described_class.new(Proc.new{}, Proc.new{'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 {
+        elevator.call('HTTP_HOST' => 'foo.bar.com')
+      }.to raise_error(RuntimeError)
+    end
+
+    it "switches to the parsed db_name" do
+      elevator = MyElevator.new(Proc.new{})
+
+      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.new{}, Proc.new{'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.new{}
+      elevator = MyElevator.new(app, Proc.new{})
+
+      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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'apartment/elevators/host_hash'
+
+describe Apartment::Elevators::HostHash do
+
+  subject(:elevator){ Apartment::Elevators::HostHash.new(Proc.new{}, '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