ros-apartment 2.3.0 → 2.11.0

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

data/spec/schemas/v1.rb

@@ -1,16 +0,0 @@
-# encoding: UTF-8
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
-#
-# It's strongly recommended to check this file into your version control system.
-
-ActiveRecord::Schema.define(:version => 0) do
-
-end

data/spec/schemas/v2.rb

@@ -1,43 +0,0 @@
-# encoding: UTF-8
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
-#
-# It's strongly recommended to check this file into your version control system.
-
-ActiveRecord::Schema.define(:version => 20110613152810) do
-
-  create_table "companies", :force => true do |t|
-    t.boolean "dummy"
-    t.string  "database"
-  end
-
-  create_table "delayed_jobs", :force => true do |t|
-    t.integer  "priority",   :default => 0
-    t.integer  "attempts",   :default => 0
-    t.text     "handler"
-    t.text     "last_error"
-    t.datetime "run_at"
-    t.datetime "locked_at"
-    t.datetime "failed_at"
-    t.string   "locked_by"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-    t.string   "queue"
-  end
-
-  add_index "delayed_jobs", ["priority", "run_at"], :name => "delayed_jobs_priority"
-
-  create_table "users", :force => true do |t|
-    t.string   "name"
-    t.datetime "birthdate"
-    t.string   "sex"
-  end
-
-end

data/spec/schemas/v3.rb

@@ -1,49 +0,0 @@
-# encoding: UTF-8
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
-#
-# It's strongly recommended to check this file into your version control system.
-
-ActiveRecord::Schema.define(:version => 20111202022214) do
-
-  create_table "books", :force => true do |t|
-    t.string   "name"
-    t.integer  "pages"
-    t.datetime "published"
-  end
-
-  create_table "companies", :force => true do |t|
-    t.boolean "dummy"
-    t.string  "database"
-  end
-
-  create_table "delayed_jobs", :force => true do |t|
-    t.integer  "priority",   :default => 0
-    t.integer  "attempts",   :default => 0
-    t.text     "handler"
-    t.text     "last_error"
-    t.datetime "run_at"
-    t.datetime "locked_at"
-    t.datetime "failed_at"
-    t.string   "locked_by"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-    t.string   "queue"
-  end
-
-  add_index "delayed_jobs", ["priority", "run_at"], :name => "delayed_jobs_priority"
-
-  create_table "users", :force => true do |t|
-    t.string   "name"
-    t.datetime "birthdate"
-    t.string   "sex"
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,61 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-
-require File.expand_path("../dummy/config/environment.rb", __FILE__)
-
-# Loading dummy applications affects table_name of each excluded models
-# defined in `spec/dummy/config/initializers/apartment.rb`.
-# To make them pristine, we need to execute below lines.
-Apartment.excluded_models.each do |model|
-  klass = model.constantize
-
-  Apartment.connection_class.remove_connection(klass)
-  klass.clear_all_connections!
-  klass.reset_table_name
-end
-
-require "rspec/rails"
-require 'capybara/rspec'
-require 'capybara/rails'
-
-begin
-  require 'pry'
-  silence_warnings{ IRB = Pry }
-rescue LoadError
-end
-
-ActionMailer::Base.delivery_method = :test
-ActionMailer::Base.perform_deliveries = true
-ActionMailer::Base.default_url_options[:host] = "test.com"
-
-Rails.backtrace_cleaner.remove_silencers!
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-RSpec.configure do |config|
-
-  config.include RSpec::Integration::CapybaraSessions, type: :request
-  config.include Apartment::Spec::Setup
-
-  # Somewhat brutal hack so that rails 4 postgres extensions don't modify this file
-  config.after(:all) do
-    `git checkout -- spec/dummy/db/schema.rb`
-  end
-
-  # rspec-rails 3 will no longer automatically infer an example group's spec type
-  # from the file location. You can explicitly opt-in to the feature using this
-  # config option.
-  # To explicitly tag specs without using automatic inference, set the `:type`
-  # metadata manually:
-  #
-  #     describe ThingsController, :type => :controller do
-  #       # Equivalent to being in spec/controllers
-  #     end
-  config.infer_spec_type_from_file_location!
-end
-
-# Load shared examples, must happen after configure for RSpec 3
-Dir["#{File.dirname(__FILE__)}/examples/**/*.rb"].each { |f| require f }

data/spec/support/apartment_helpers.rb

@@ -1,43 +0,0 @@
-module Apartment
-  module Test
-
-    extend self
-
-    def reset
-      Apartment.excluded_models = nil
-      Apartment.use_schemas = nil
-      Apartment.seed_after_create = nil
-      Apartment.default_schema = nil
-    end
-
-    def next_db
-      @x ||= 0
-      "db%d" % @x += 1
-    end
-
-    def drop_schema(schema)
-      ActiveRecord::Base.connection.execute("DROP SCHEMA IF EXISTS #{schema} CASCADE") rescue true
-    end
-
-    # Use this if you don't want to import schema.rb etc... but need the postgres schema to exist
-    # basically for speed purposes
-    def create_schema(schema)
-      ActiveRecord::Base.connection.execute("CREATE SCHEMA #{schema}")
-    end
-
-    def load_schema(version = 3)
-      file = File.expand_path("../../schemas/v#{version}.rb", __FILE__)
-
-      silence_warnings{ load(file) }
-    end
-
-    def migrate
-      ActiveRecord::Migrator.migrate(Rails.root + ActiveRecord::Migrator.migrations_path)
-    end
-
-    def rollback
-      ActiveRecord::Migrator.rollback(Rails.root + ActiveRecord::Migrator.migrations_path)
-    end
-
-  end
-end

data/spec/support/capybara_sessions.rb

@@ -1,15 +0,0 @@
-module RSpec
-  module Integration
-    module CapybaraSessions
-      
-      def in_new_session(&block)
-        yield new_session
-      end
-      
-      def new_session
-        Capybara::Session.new(Capybara.current_driver, Capybara.app)
-      end
-      
-    end
-  end
-end

data/spec/support/config.rb

@@ -1,10 +0,0 @@
-require 'yaml'
-
-module Apartment
-  module Test
-
-    def self.config
-      @config ||= YAML.load(ERB.new(IO.read('spec/config/database.yml')).result)
-    end
-  end
-end