apartment 0.1.3 → 0.5.0

data/spec/integration/database_integration_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Apartment::Database do
+  
+  context "using postgresql" do
+    
+    # See apartment.yml file in dummy app config
+    
+    let(:config){ Apartment::Test.config['connections']['postgresql'].symbolize_keys }
+    let(:database){ "some_new_database" }
+    
+    before do
+      ActiveRecord::Base.establish_connection config
+      Apartment::Database.stub(:config).and_return config   # Use postgresql database config for this test
+      @schema_search_path = ActiveRecord::Base.connection.schema_search_path
+    end
+    
+    after do
+      Apartment::Test.reset
+    end
+    
+    describe "#init" do
+      
+      it "should process model exclusions" do
+        Company.should_receive(:establish_connection).with( config )
+        
+        Apartment.configure do |config|
+          config.excluded_models = [Company]
+        end
+      end
+      
+    end
+    
+    describe "#adapter" do
+      before do
+        Apartment::Database.reload!
+      end
+      
+      it "should load postgresql adapter" do
+        Apartment::Database.adapter
+        Apartment::Adapters::PostgresqlAdapter.should be_a(Class)
+        
+      end
+      
+      it "should raise exception with invalid adapter specified" do
+        Apartment::Database.stub(:config).and_return config.merge(:adapter => 'unkown')
+        
+        expect {
+          Apartment::Database.adapter
+        }.to raise_error
+      end
+      
+    end
+    
+    context "with schemas" do
+      
+      before do
+        Apartment.configure do |config|
+          config.excluded_models = []
+          config.use_postgres_schemas = true
+          config.seed_after_create = true
+        end
+        Apartment::Database.create database
+      end
+      
+      after do
+        Apartment::Test.drop_schema(database)
+      end
+      
+      describe "#create" do
+        it "should create new postgres schema" do
+          ActiveRecord::Base.connection.execute("SELECT nspname FROM pg_namespace;").collect{|row| row['nspname']}.should include(database)
+        end
+        
+        it "should seed data" do
+          Apartment::Database.switch database
+          User.count.should be > 0
+        end
+      end
+    
+      describe "#switch" do
+        
+        it "should connect to new schema" do
+          Apartment::Database.switch database
+          ActiveRecord::Base.connection.schema_search_path.should == database
+        end
+        
+        it "should ignore excluded models" do
+          Apartment.configure do |config|
+            config.excluded_models = [Company]
+          end
+          
+          Apartment::Database.switch database
+          Company.connection.schema_search_path.should == @schema_search_path
+        end
+        
+        it "should fail with invalid schema" do
+          expect {
+            Apartment::Database.switch('some_nonexistent_schema')
+          }.to raise_error Apartment::SchemaNotFound
+        end
+      end
+      
+    end
+    
+  end
+end

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::Test.in_database(company.subdomain) do
+        @c1_user_count = (2 + rand(2)).times{ User.create }
+      end
+      
+      Apartment::Test.in_database(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/integration/setup_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "Setup" do
+  
+  it "should be a valid app" do
+    ::Rails.application.should be_a(Dummy::Application)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$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
+  
+end

data/spec/support/apartment_helpers.rb

@@ -0,0 +1,24 @@
+module Apartment
+  module Test
+    def self.reset
+      Apartment::Database.instance_variable_set :@initialized, nil
+      Apartment.excluded_models = nil
+      Apartment.use_postgres_schemas = nil
+    end
+    
+    def self.drop_schema(schema)
+      ActiveRecord::Base.connection.execute("DROP SCHEMA IF EXISTS #{schema} CASCADE")
+    end
+    
+    def self.create_schema(schema)
+      ActiveRecord::Base.connection.execute("CREATE SCHEMA #{schema}")
+    end
+    
+    def self.in_database(db)
+      Apartment::Database.switch db
+      yield if block_given?
+      Apartment::Database.reset
+    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/support/migrate.rb

@@ -0,0 +1,9 @@
+module Apartment
+  
+  module Test
+    
+    def self.migrate
+      ActiveRecord::Migrator.migrate Rails.root + ActiveRecord::Migrator.migrations_path
+    end
+  end
+end

data/spec/tasks/apartment_rake_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'rake'
+
+describe "apartment rake tasks" do
+  
+  before do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    load 'tasks/apartment.rake'
+    Rake::Task.define_task(:environment)    # stub out loading rails environment
+  end
+  
+  after do
+    Rake.application = nil
+  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 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,84 @@
+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 initialize Database" do
+      Apartment::Database.should_receive(:init).once
+      Apartment.configure
+    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