dr-apartment 0.14.1

data/spec/integration/middleware/subdomain_elevator_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Apartment::Elevators::Subdomain do
+  
+  let(:company){ mock_model(Company, :subdomain => 'foo').as_null_object }
+  let(:domain){ "http://#{company.subdomain}.domain.com" }
+  
+  before do
+    Apartment.seed_after_create = false
+    Apartment.use_postgres_schemas = true
+    
+    Apartment::Database.create(company.subdomain)
+  end
+  
+  after do
+    Apartment::Test.drop_schema(company.subdomain)
+  end
+  
+  context "single request" do
+    it "should switch the db" do
+      ActiveRecord::Base.connection.schema_search_path.should_not == 'foo'
+      
+      visit(domain)
+      ActiveRecord::Base.connection.schema_search_path.should == company.subdomain
+    end
+  end
+  
+  context "simultaneous requests" do
+    let(:company2){ mock_model(Company, :subdomain => 'bar').as_null_object }
+    let(:domain2){ "http://#{company2.subdomain}.domain.com" }
+    
+    before do
+      Apartment::Database.create(company2.subdomain)
+      # Create some users for each db
+      Apartment::Database.process(company.subdomain) do
+        @c1_user_count = (2 + rand(2)).times{ User.create }
+      end
+      
+      Apartment::Database.process(company2.subdomain) do
+        @c2_user_count = (@c1_user_count + 2).times{ User.create }
+      end
+    end
+
+    after do
+      Apartment::Test.drop_schema(company2.subdomain)
+    end
+    
+    it "should fetch the correct user count for each session based on subdomain" do
+      visit(domain)
+      
+      in_new_session do |session|
+        session.visit(domain2)
+        User.count.should == @c2_user_count
+      end
+      
+      visit(domain)
+      User.count.should == @c1_user_count
+    end
+    
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rspec/rails"
+require 'capybara/rspec'
+require 'capybara/rails'
+
+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.before(:all) do
+    # Ensure that each test starts with a clean connection
+    # Necessary as some tests will leak things like current_schema into the next test
+    ActiveRecord::Base.clear_all_connections!
+  end
+  
+end

data/spec/support/apartment_helpers.rb

@@ -0,0 +1,32 @@
+module Apartment
+  module Test
+    
+    extend self
+    
+    def reset
+      Apartment.excluded_models = nil
+      Apartment.use_postgres_schemas = nil
+    end
+    
+    def drop_schema(schema)
+      ActiveRecord::Base.silence{ ActiveRecord::Base.connection.execute("DROP SCHEMA IF EXISTS #{schema} CASCADE") } rescue true
+    end
+    
+    def create_schema(schema)
+      ActiveRecord::Base.connection.execute("CREATE SCHEMA #{schema}")
+    end
+    
+    def load_schema
+      silence_stream(STDOUT){ load("#{Rails.root}/db/schema.rb") }
+    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

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

@@ -0,0 +1,11 @@
+module Apartment
+  
+  module Test
+    
+    def self.config
+      @config ||= YAML.load_file('spec/config/database.yml')
+    end
+    
+  end
+  
+end

data/spec/tasks/apartment_rake_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'rake'
+
+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
+  
+  let(:version){ '1234' }
+  
+  context 'database migration' do
+    
+    let(:database_names){ ['company1', 'company2', 'company3'] }
+    let(:db_count){ database_names.length }
+    
+    before do
+      Apartment.stub(:database_names).and_return database_names
+    end
+    
+    describe "apartment:migrate" do
+      before do
+        ActiveRecord::Migrator.stub(:migrate)   # don't care about this
+      end
+      
+      it "should migrate public and all multi-tenant dbs" do
+        Apartment::Migrator.should_receive(:migrate).exactly(db_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
+          lambda{
+            @rake['apartment:migrate:up'].invoke
+          }.should 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
+          Apartment::Migrator.should_receive(:run).with(:up, anything, version.to_i).exactly(db_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
+          lambda{
+            @rake['apartment:migrate:down'].invoke
+          }.should 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
+          Apartment::Migrator.should_receive(:run).with(:down, anything, version.to_i).exactly(db_count).times
+          @rake['apartment:migrate:down'].invoke
+        end
+      end
+    end
+    
+    describe "apartment:rollback" do
+      
+      let(:step){ '3' }
+      
+      it "should rollback dbs" do
+        Apartment::Migrator.should_receive(:rollback).exactly(db_count).times
+        @rake['apartment:rollback'].invoke
+      end
+      
+      it "should rollback dbs STEP amt" do
+        Apartment::Migrator.should_receive(:rollback).with(anything, step.to_i).exactly(db_count).times
+        ENV['STEP'] = step
+        @rake['apartment:rollback'].invoke
+      end
+    end
+    
+  end
+  
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Apartment do
+  
+  describe "#config" do
+    
+    let(:excluded_models){ [Company] }
+    
+    after do
+      Apartment::Test.reset
+    end
+    
+    it "should yield the Apartment object" do
+      Apartment.configure do |config|
+        config.excluded_models = []
+        config.should == Apartment
+      end
+    end
+    
+    it "should set excluded models" do
+      Apartment.configure do |config|
+        config.excluded_models = excluded_models
+      end
+      Apartment.excluded_models.should == excluded_models
+    end
+    
+    it "should set postgres_schemas" do
+      Apartment.configure do |config|
+        config.excluded_models = []
+        config.use_postgres_schemas = false
+      end
+      Apartment.use_postgres_schemas.should be_false
+    end
+    
+    it "should set seed_after_create" do
+      Apartment.configure do |config|
+        config.excluded_models = []
+        config.seed_after_create = true
+      end
+      Apartment.seed_after_create.should be_true
+    end
+    
+    context "databases" do
+      it "should return object if it doesnt respond_to call" do
+        database_names = ['users', 'companies']
+        
+        Apartment.configure do |config|
+          config.excluded_models = []
+          config.database_names = database_names
+        end
+        Apartment.database_names.should == database_names
+      end
+      
+      it "should invoke the proc if appropriate" do
+        database_names = lambda{ ['users', 'users'] }
+        database_names.should_receive(:call)
+        
+        Apartment.configure do |config|
+          config.excluded_models = []
+          config.database_names = database_names
+        end
+        Apartment.database_names
+      end
+      
+      it "should return the invoked proc if appropriate" do
+        dbs = lambda{ Company.scoped }
+        
+        Apartment.configure do |config|
+          config.excluded_models = []
+          config.database_names = dbs
+        end
+        
+        Apartment.database_names.should == Company.scoped
+      end
+    end
+    
+  end
+end

data/spec/unit/middleware/subdomain_elevator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Apartment::Elevators::Subdomain do
+  
+  describe "#subdomain" do
+    it "should parse subdomain" do
+      request = ActionDispatch::Request.new('HTTP_HOST' => 'foo.bar.com')
+      elevator = Apartment::Elevators::Subdomain.new(nil)
+      elevator.subdomain(request).should == 'foo'
+    end
+    
+    it "should return nil when no subdomain" do
+      request = ActionDispatch::Request.new('HTTP_HOST' => 'bar.com')
+      elevator = Apartment::Elevators::Subdomain.new(nil)
+      elevator.subdomain(request).should be_nil
+    end
+    
+  end
+  
+end

data/spec/unit/migrator_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Apartment::Migrator do
+  
+  let(:config){ Apartment::Test.config['connections']['postgresql'].symbolize_keys }
+  let(:schema_name){ 'some_db_schema' }
+  let(:version){ 20110613152810 }     # note this is brittle!  I've literally just taken the version of the one migration I made...  don't change this version
+  
+  before do
+    ActiveRecord::Base.establish_connection config
+    Apartment::Database.stub(:config).and_return config   # Use postgresql config for this test
+    @original_schema = ActiveRecord::Base.connection.schema_search_path
+    
+    Apartment.configure do |config|
+      config.use_postgres_schemas = true
+      config.excluded_models = []
+      config.database_names = [schema_name]
+    end
+    
+    Apartment::Database.create schema_name    # create the schema
+    migrations_path = Rails.root + ActiveRecord::Migrator.migrations_path     # tell AR where the real migrations are
+    ActiveRecord::Migrator.stub(:migrations_path).and_return(migrations_path)
+  end
+  
+  after do
+    Apartment::Test.drop_schema(schema_name)
+  end
+  
+  context "postgresql" do
+
+    context "using schemas" do
+      
+      describe "#migrate" do
+        it "should connect to new db, then reset when done" do
+          ActiveRecord::Base.connection.should_receive(:schema_search_path=).with(schema_name).once
+          ActiveRecord::Base.connection.should_receive(:schema_search_path=).with(@original_schema).once
+          Apartment::Migrator.migrate(schema_name)
+        end
+  
+        it "should migrate db" do
+          ActiveRecord::Migrator.should_receive(:migrate)
+          Apartment::Migrator.migrate(schema_name)
+        end
+      end
+  
+      describe "#run" do
+        context "up" do
+    
+          it "should connect to new db, then reset when done" do
+            ActiveRecord::Base.connection.should_receive(:schema_search_path=).with(schema_name).once
+            ActiveRecord::Base.connection.should_receive(:schema_search_path=).with(@original_schema).once
+            Apartment::Migrator.run(:up, schema_name, version)
+          end
+  
+          it "should migrate to a version" do
+            ActiveRecord::Migrator.should_receive(:run).with(:up, anything, version)
+            Apartment::Migrator.run(:up, schema_name, version)
+          end
+        end
+
+        describe "down" do
+    
+          it "should connect to new db, then reset when done" do
+            ActiveRecord::Base.connection.should_receive(:schema_search_path=).with(schema_name).once
+            ActiveRecord::Base.connection.should_receive(:schema_search_path=).with(@original_schema).once
+            Apartment::Migrator.run(:down, schema_name, version)
+          end
+
+          it "should migrate to a version" do
+            ActiveRecord::Migrator.should_receive(:run).with(:down, anything, version)
+            Apartment::Migrator.run(:down, schema_name, version)
+          end
+        end
+      end
+
+      describe "#rollback" do
+        let(:steps){ 3 }
+  
+        it "should rollback the db" do
+          ActiveRecord::Migrator.should_receive(:rollback).with(anything, steps)
+          Apartment::Migrator.rollback(schema_name, steps)
+        end
+      end
+    end
+  end
+  
+end