ros-apartment 2.3.0 → 2.11.0

data/spec/support/contexts.rb

@@ -1,52 +0,0 @@
-#   Some shared contexts for specs
-
-shared_context "with default schema", :default_schema => true do
-  let(:default_schema){ Apartment::Test.next_db }
-
-  before do
-    Apartment::Test.create_schema(default_schema)
-    Apartment.default_schema = default_schema
-  end
-
-  after do
-    # resetting default_schema so we can drop and any further resets won't try to access droppped schema
-    Apartment.default_schema = nil
-    Apartment::Test.drop_schema(default_schema)
-  end
-end
-
-# Some default setup for elevator specs
-shared_context "elevators", elevator: true do
-  let(:company1)  { mock_model(Company, database: db1).as_null_object }
-  let(:company2)  { mock_model(Company, database: db2).as_null_object }
-
-  let(:api)       { Apartment::Tenant }
-
-  before do
-    Apartment.reset # reset all config
-    Apartment.seed_after_create = false
-    Apartment.use_schemas = true
-    api.reload!(config)
-    api.create(db1)
-    api.create(db2)
-  end
-
-  after do
-    api.drop(db1)
-    api.drop(db2)
-  end
-end
-
-shared_context "persistent_schemas", :persistent_schemas => true do
-  let(:persistent_schemas){ ['hstore', 'postgis'] }
-
-  before do
-    persistent_schemas.map{|schema| subject.create(schema) }
-    Apartment.persistent_schemas = persistent_schemas
-  end
-
-  after do
-    Apartment.persistent_schemas = []
-    persistent_schemas.map{|schema| subject.drop(schema) }
-  end
-end

data/spec/support/requirements.rb

@@ -1,35 +0,0 @@
-module Apartment
-  module Spec
-
-    #
-    #   Define the interface methods required to
-    #   use an adapter shared example
-    #
-    #
-    module AdapterRequirements
-      extend ActiveSupport::Concern
-
-      included do
-        before do
-          subject.create(db1)
-          subject.create(db2)
-        end
-
-        after do
-          # Reset before dropping (can't drop a db you're connected to)
-          subject.reset
-
-          # sometimes we manually drop these schemas in testing, don't care if we can't drop, hence rescue
-          subject.drop(db1) rescue true
-          subject.drop(db2) rescue true
-        end
-      end
-
-      %w{subject tenant_names default_tenant}.each do |method|
-        define_method method do
-          raise "You must define a `#{method}` method in your host group"
-        end unless defined?(method)
-      end
-    end
-  end
-end

data/spec/support/setup.rb

@@ -1,46 +0,0 @@
-module Apartment
-  module Spec
-    module Setup
-
-      def self.included(base)
-        base.instance_eval do
-          let(:db1){ Apartment::Test.next_db }
-          let(:db2){ Apartment::Test.next_db }
-          let(:connection){ ActiveRecord::Base.connection }
-
-          # This around ensures that we run these hooks before and after
-          # any before/after hooks defined in individual tests
-          # Otherwise these actually get run after test defined hooks
-          around(:each) do |example|
-
-            def config
-              db = RSpec.current_example.metadata.fetch(:database, :postgresql)
-
-              Apartment::Test.config['connections'][db.to_s].symbolize_keys
-            end
-
-            # before
-            Apartment::Tenant.reload!(config)
-            ActiveRecord::Base.establish_connection config
-
-            example.run
-
-            # after
-            Rails.configuration.database_configuration = {}
-            ActiveRecord::Base.clear_all_connections!
-
-            Apartment.excluded_models.each do |model|
-              klass = model.constantize
-
-              Apartment.connection_class.remove_connection(klass)
-              klass.clear_all_connections!
-              klass.reset_table_name
-            end
-            Apartment.reset
-            Apartment::Tenant.reload!
-          end
-        end
-      end
-    end
-  end
-end

data/spec/tasks/apartment_rake_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-require 'rake'
-require 'apartment/migrator'
-require 'apartment/tenant'
-
-describe "apartment rake tasks" do
-
-  before do
-    @rake = Rake::Application.new
-    Rake.application = @rake
-    load 'tasks/apartment.rake'
-    # stub out rails tasks
-    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')
-  end
-
-  after do
-    Rake.application = nil
-    ENV['VERSION'] = nil    # linux users reported env variable carrying on between tests
-  end
-
-  after(:all) do
-    Apartment::Test.load_schema
-  end
-
-  let(:version){ '1234' }
-
-  context 'database migration' do
-
-    let(:tenant_names){ 3.times.map{ Apartment::Test.next_db } }
-    let(:tenant_count){ tenant_names.length }
-
-    before do
-      allow(Apartment).to receive(:tenant_names).and_return tenant_names
-    end
-
-    describe "apartment:migrate" do
-      before do
-        allow(ActiveRecord::Migrator).to receive(:migrate)   # don't care about this
-      end
-
-      it "should migrate public and all multi-tenant dbs" do
-        expect(Apartment::Migrator).to receive(:migrate).exactly(tenant_count).times
-        @rake['apartment:migrate'].invoke
-      end
-    end
-
-    describe "apartment:migrate:up" do
-
-      context "without a version" do
-        before do
-          ENV['VERSION'] = nil
-        end
-
-        it "requires a version to migrate to" do
-          expect{
-            @rake['apartment:migrate:up'].invoke
-          }.to raise_error("VERSION is required")
-        end
-      end
-
-      context "with version" do
-
-        before do
-          ENV['VERSION'] = version
-        end
-
-        it "migrates up to a specific version" do
-          expect(Apartment::Migrator).to receive(:run).with(:up, anything, version.to_i).exactly(tenant_count).times
-          @rake['apartment:migrate:up'].invoke
-        end
-      end
-    end
-
-    describe "apartment:migrate:down" do
-
-      context "without a version" do
-        before do
-          ENV['VERSION'] = nil
-        end
-
-        it "requires a version to migrate to" do
-          expect{
-            @rake['apartment:migrate:down'].invoke
-          }.to raise_error("VERSION is required")
-        end
-      end
-
-      context "with version" do
-
-        before do
-          ENV['VERSION'] = version
-        end
-
-        it "migrates up to a specific version" do
-          expect(Apartment::Migrator).to receive(:run).with(:down, anything, version.to_i).exactly(tenant_count).times
-          @rake['apartment:migrate:down'].invoke
-        end
-      end
-    end
-
-    describe "apartment:rollback" do
-      let(:step){ '3' }
-
-      it "should rollback dbs" do
-        expect(Apartment::Migrator).to receive(:rollback).exactly(tenant_count).times
-        @rake['apartment:rollback'].invoke
-      end
-
-      it "should rollback dbs STEP amt" do
-        expect(Apartment::Migrator).to receive(:rollback).with(anything, step.to_i).exactly(tenant_count).times
-        ENV['STEP'] = step
-        @rake['apartment:rollback'].invoke
-      end
-    end
-
-    describe "apartment:drop" do
-      it "should migrate public and all multi-tenant dbs" do
-        expect(Apartment::Tenant).to receive(:drop).exactly(tenant_count).times
-        @rake['apartment:drop'].invoke
-      end
-    end
-
-  end
-end

data/spec/tenant_spec.rb

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

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

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

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