ros-apartment 2.3.0.alpha2 → 2.6.1

data/spec/examples/schema_adapter_examples.rb

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

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

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

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