ros-apartment 2.3.0.alpha1

data/spec/examples/schema_adapter_examples.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+shared_examples_for "a schema based apartment adapter" do
+  include Apartment::Spec::AdapterRequirements
+
+  let(:schema1){ db1 }
+  let(:schema2){ db2 }
+  let(:public_schema){ default_tenant }
+
+  describe "#init" do
+
+    before do
+      Apartment.configure do |config|
+        config.excluded_models = ["Company"]
+      end
+    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 process model exclusions" do
+      Apartment::Tenant.init
+
+      expect(Company.table_name).to eq("public.companies")
+    end
+
+    context "with a default_schema", :default_schema => true do
+
+      it "should set the proper table_name on excluded_models" do
+        Apartment::Tenant.init
+
+        expect(Company.table_name).to eq("#{default_schema}.companies")
+      end
+
+      it 'sets the search_path correctly' do
+        Apartment::Tenant.init
+
+        expect(User.connection.schema_search_path).to match(%r|#{default_schema}|)
+      end
+    end
+
+    context "persistent_schemas", :persistent_schemas => true do
+      it "sets the persistent schemas in the schema_search_path" do
+        Apartment::Tenant.init
+        expect(connection.schema_search_path).to end_with persistent_schemas.map { |schema| %{"#{schema}"} }.join(', ')
+      end
+    end
+  end
+
+  #
+  #   Creates happen already in our before_filter
+  #
+  describe "#create" do
+
+    it "should load schema.rb to new schema" do
+      connection.schema_search_path = schema1
+      expect(connection.tables).to include('companies')
+    end
+
+    it "should yield to block if passed and reset" do
+      subject.drop(schema2) # so we don't get errors on creation
+
+      @count = 0  # set our variable so its visible in and outside of blocks
+
+      subject.create(schema2) do
+        @count = User.count
+        expect(connection.schema_search_path).to start_with %{"#{schema2}"}
+        User.create
+      end
+
+      expect(connection.schema_search_path).not_to start_with %{"#{schema2}"}
+
+      subject.switch(schema2){ expect(User.count).to eq(@count + 1) }
+    end
+
+    context "numeric database names" do
+      let(:db){ 1234 }
+      it "should allow them" do
+        expect {
+          subject.create(db)
+        }.to_not raise_error
+        expect(tenant_names).to include(db.to_s)
+      end
+
+      after{ subject.drop(db) }
+    end
+
+  end
+
+  describe "#drop" do
+    it "should raise an error for unknown database" do
+      expect {
+        subject.drop "unknown_database"
+      }.to raise_error(Apartment::TenantNotFound)
+    end
+
+    context "numeric database names" do
+      let(:db){ 1234 }
+
+      it "should be able to drop them" do
+        subject.create(db)
+        expect {
+          subject.drop(db)
+        }.to_not raise_error
+        expect(tenant_names).not_to include(db.to_s)
+      end
+
+      after { subject.drop(db) rescue nil }
+    end
+  end
+
+  describe "#switch" do
+    it "connects and resets" do
+      subject.switch(schema1) do
+        expect(connection.schema_search_path).to start_with %{"#{schema1}"}
+      end
+
+      expect(connection.schema_search_path).to start_with %{"#{public_schema}"}
+    end
+  end
+
+  describe "#reset" do
+    it "should reset connection" do
+      subject.switch!(schema1)
+      subject.reset
+      expect(connection.schema_search_path).to start_with %{"#{public_schema}"}
+    end
+
+    context "with default_schema", :default_schema => true do
+      it "should reset to the default schema" do
+        subject.switch!(schema1)
+        subject.reset
+        expect(connection.schema_search_path).to start_with %{"#{default_schema}"}
+      end
+    end
+
+    context "persistent_schemas", :persistent_schemas => true do
+      before do
+        subject.switch!(schema1)
+        subject.reset
+      end
+
+      it "maintains the persistent schemas in the schema_search_path" do
+        expect(connection.schema_search_path).to end_with persistent_schemas.map { |schema| %{"#{schema}"} }.join(', ')
+      end
+
+      context "with default_schema", :default_schema => true do
+        it "prioritizes the switched schema to front of schema_search_path" do
+          subject.reset # need to re-call this as the default_schema wasn't set at the time that the above reset ran
+          expect(connection.schema_search_path).to start_with %{"#{default_schema}"}
+        end
+      end
+    end
+  end
+
+  describe "#switch!" do
+    it "should connect to new schema" do
+      subject.switch!(schema1)
+      expect(connection.schema_search_path).to start_with %{"#{schema1}"}
+    end
+
+    it "should reset connection if database is nil" do
+      subject.switch!
+      expect(connection.schema_search_path).to eq(%{"#{public_schema}"})
+    end
+
+    it "should raise an error if schema is invalid" do
+      expect {
+        subject.switch! 'unknown_schema'
+      }.to raise_error(Apartment::TenantNotFound)
+    end
+
+    context "numeric databases" do
+      let(:db){ 1234 }
+
+      it "should connect to them" do
+        subject.create(db)
+        expect {
+          subject.switch!(db)
+        }.to_not raise_error
+
+        expect(connection.schema_search_path).to start_with %{"#{db.to_s}"}
+      end
+
+      after{ subject.drop(db) }
+    end
+
+    describe "with default_schema specified", :default_schema => true do
+      before do
+        subject.switch!(schema1)
+      end
+
+      it "should switch out the default schema rather than public" do
+        expect(connection.schema_search_path).not_to include default_schema
+      end
+
+      it "should still switch to the switched schema" do
+        expect(connection.schema_search_path).to start_with %{"#{schema1}"}
+      end
+    end
+
+    context "persistent_schemas", :persistent_schemas => true do
+
+      before{ subject.switch!(schema1) }
+
+      it "maintains the persistent schemas in the schema_search_path" do
+        expect(connection.schema_search_path).to end_with persistent_schemas.map { |schema| %{"#{schema}"} }.join(', ')
+      end
+
+      it "prioritizes the switched schema to front of schema_search_path" do
+        expect(connection.schema_search_path).to start_with %{"#{schema1}"}
+      end
+    end
+  end
+
+  describe "#current" do
+    it "should return the current schema name" do
+      subject.switch!(schema1)
+      expect(subject.current).to eq(schema1)
+    end
+
+    context "persistent_schemas", :persistent_schemas => true do
+      it "should exlude persistent_schemas" do
+        subject.switch!(schema1)
+        expect(subject.current).to eq(schema1)
+      end
+    end
+  end
+end

data/spec/integration/apartment_rake_integration_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'rake'
+
+describe "apartment rake tasks", database: :postgresql do
+
+  before do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    Dummy::Application.load_tasks
+
+    # rails tasks running F up the schema...
+    Rake::Task.define_task('db:migrate')
+    Rake::Task.define_task('db:seed')
+    Rake::Task.define_task('db:rollback')
+    Rake::Task.define_task('db:migrate:up')
+    Rake::Task.define_task('db:migrate:down')
+    Rake::Task.define_task('db:migrate:redo')
+
+    Apartment.configure do |config|
+      config.use_schemas = true
+      config.excluded_models = ["Company"]
+      config.tenant_names = lambda{ Company.pluck(:database) }
+    end
+    Apartment::Tenant.reload!(config)
+
+    # fix up table name of shared/excluded models
+    Company.table_name = 'public.companies'
+  end
+
+  after { Rake.application = nil }
+
+  context "with x number of databases" do
+
+    let(:x){ 1 + rand(5) }    # random number of dbs to create
+    let(:db_names){ x.times.map{ Apartment::Test.next_db } }
+    let!(:company_count){ db_names.length }
+
+    before do
+      db_names.collect do |db_name|
+        Apartment::Tenant.create(db_name)
+        Company.create :database => db_name
+      end
+    end
+
+    after do
+      db_names.each{ |db| Apartment::Tenant.drop(db) }
+      Company.delete_all
+    end
+
+    context "with ActiveRecord below 5.2.0" do
+      before do
+        allow(ActiveRecord::Migrator).to receive(:migrations_paths) { %w(spec/dummy/db/migrate) }
+        allow(Apartment::Migrator).to receive(:activerecord_below_5_2?) { true }
+      end
+
+      describe "#migrate" do
+        it "should migrate all databases" do
+          expect(ActiveRecord::Migrator).to receive(:migrate).exactly(company_count).times
+
+          @rake['apartment:migrate'].invoke
+        end
+      end
+
+      describe "#rollback" do
+        it "should rollback all dbs" do
+          expect(ActiveRecord::Migrator).to receive(:rollback).exactly(company_count).times
+
+          @rake['apartment:rollback'].invoke
+        end
+      end
+    end
+
+    context "with ActiveRecord above or equal to 5.2.0" do
+      let(:migration_context_double) { double(:migration_context) }
+
+      before do
+        allow(Apartment::Migrator).to receive(:activerecord_below_5_2?) { false }
+      end
+
+      describe "#migrate" do
+        it "should migrate all databases" do
+          allow(ActiveRecord::Base.connection).to receive(:migration_context) { migration_context_double }
+          expect(migration_context_double).to receive(:migrate).exactly(company_count).times
+
+          @rake['apartment:migrate'].invoke
+        end
+      end
+
+      describe "#rollback" do
+        it "should rollback all dbs" do
+          allow(ActiveRecord::Base.connection).to receive(:migration_context) { migration_context_double }
+          expect(migration_context_double).to receive(:rollback).exactly(company_count).times
+
+          @rake['apartment:rollback'].invoke
+        end
+      end
+    end
+
+    describe "apartment:seed" do
+      it "should seed all databases" do
+        expect(Apartment::Tenant).to receive(:seed).exactly(company_count).times
+
+        @rake['apartment:seed'].invoke
+      end
+    end
+  end
+end

data/spec/integration/query_caching_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe 'query caching' do
+  describe 'when use_schemas = true' do
+    let(:db_names) { [db1, db2] }
+
+    before do
+      Apartment.configure do |config|
+        config.excluded_models = ["Company"]
+        config.tenant_names = lambda{ Company.pluck(:database) }
+        config.use_schemas = true
+      end
+
+      Apartment::Tenant.reload!(config)
+
+      db_names.each do |db_name|
+        Apartment::Tenant.create(db_name)
+        Company.create database: db_name
+      end
+    end
+
+    after do
+      db_names.each{ |db| Apartment::Tenant.drop(db) }
+      Apartment::Tenant.reset
+      Company.delete_all
+    end
+
+    it 'clears the ActiveRecord::QueryCache after switching databases' do
+      db_names.each do |db_name|
+        Apartment::Tenant.switch! db_name
+        User.create! name: db_name
+      end
+
+      ActiveRecord::Base.connection.enable_query_cache!
+
+      Apartment::Tenant.switch! db_names.first
+      expect(User.find_by_name(db_names.first).name).to eq(db_names.first)
+
+      Apartment::Tenant.switch! db_names.last
+      expect(User.find_by_name(db_names.first)).to be_nil
+    end
+  end
+
+  describe 'when use_schemas = false' do
+    let(:db_name) { db1 }
+
+    before do
+      Apartment.configure do |config|
+        config.excluded_models = ["Company"]
+        config.tenant_names = lambda{ Company.pluck(:database) }
+        config.use_schemas = false
+      end
+
+      Apartment::Tenant.reload!(config)
+
+      Apartment::Tenant.create(db_name)
+      Company.create database: db_name
+    end
+
+    after do
+      # Avoid cannot drop the currently open database. Maybe there is a better way to handle this.
+      Apartment::Tenant.switch! 'template1'
+
+      Apartment::Tenant.drop(db_name)
+      Apartment::Tenant.reset
+      Company.delete_all
+    end
+
+    it "configuration value is kept after switching databases" do
+      ActiveRecord::Base.connection.enable_query_cache!
+
+      Apartment::Tenant.switch! db_name
+      expect(Apartment.connection.query_cache_enabled).to be true
+
+      ActiveRecord::Base.connection.disable_query_cache!
+
+      Apartment::Tenant.switch! db_name
+      expect(Apartment.connection.query_cache_enabled).to be false
+    end
+  end
+end

data/spec/integration/use_within_an_engine_spec.rb

@@ -0,0 +1,28 @@
+describe 'using apartment within an engine' do
+
+  before do
+    engine_path = Pathname.new(File.expand_path('../../dummy_engine', __FILE__))
+    require engine_path.join('test/dummy/config/application')
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    stub_const 'APP_RAKEFILE', engine_path.join('test/dummy/Rakefile')
+    load 'rails/tasks/engine.rake'
+  end
+
+  it 'sucessfully runs rake db:migrate in the engine root' do
+    expect{ Rake::Task['db:migrate'].invoke }.to_not raise_error
+  end
+
+  it 'sucessfully runs rake app:db:migrate in the engine root' do
+    expect{ Rake::Task['app:db:migrate'].invoke }.to_not raise_error
+  end
+
+  context 'when Apartment.db_migrate_tenants is false' do
+    it 'should not enhance tasks' do
+      Apartment.db_migrate_tenants = false
+      expect(Apartment::RakeTaskEnhancer).to_not receive(:enhance_task).with('db:migrate')
+      Rake::Task['db:migrate'].invoke
+    end
+  end
+
+end