connection_manager 1.0.4 → 1.1.0

data/spec/helpers/models_spec_helper.rb

@@ -1,52 +1,63 @@
 class CmReplicationConnection < ActiveRecord::Base
-  establish_managed_connection(:slave_1_cm_test)
+  establish_connection(:test_other)
 end
 
-class CmReplication2Connection < ActiveRecord::Base
-  establish_managed_connection(:slave_2_cm_test)
+class OtherConnection < ActiveRecord::Base
+  establish_connection(:test_other)
 end
 
 class Basket < ActiveRecord::Base
   has_many :fruit_baskets
   has_many :fruit, :through => :fruit_baskets
-  #replicated
+end
+
+class PgFruit < OtherConnection
+  self.table_name = "cm_test.fruits"
 end
 
 class Fruit < ActiveRecord::Base
+  self.table_name_prefix = 'cm_test.'
   belongs_to :region
   has_many :fruit_baskets
   has_many :baskets, :through => :fruit_baskets
-  #replicated
 end
 
 #Join table
 class FruitBasket < ActiveRecord::Base
   belongs_to :fruit
   belongs_to :basket
-  #replicated
 end
 
 class Region < ActiveRecord::Base
   has_one :fruit
-  #replicated
 end
 
 class Type < ActiveRecord::Base;end
 
-class SouthernFruit < Fruit
-  self.table_name = 'fruits'
-end
-
 class CmUser < ActiveRecord::Base
+  self.table_name_prefix = 'cm_user_test.'
   has_many :foos
 end
 
+class CmOtherUser < ActiveRecord::Base
+  self.table_name = 'cm_user_test.cm_users'
+end
+
 class Foo < ActiveRecord::Base
   belongs_to :cm_user
 end
 
+# Subclassed
+class SouthernFruit < Fruit
+  self.table_name = 'fruits'
+end
+
+class FruitCore < Fruit
+  self.table_name = 'fruits'
+end
+
 class ModelsHelper
   def self.models
-    ["Basket", "Fruit", "FruitBasket", "Region","SouthernFruit", "Type", "Foo", "CmUser"]
+    ["Basket", "Fruit", "FruitBasket", "Region","SouthernFruit", "Type", "Foo", "CmUser", "FruitCore"]
   end
 end

data/spec/lib/builder_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+describe ConnectionManager::Builder do
+
+  describe '#connection_class_name' do 
+    it "should return a string for a class name appended with 'Connection' " do
+      expect(ConnectionManager::Builder.send(:connection_class_name,"my_database")).to eql("MyDatabaseConnection")
+    end
+    it "should return remove the appended rails env" do
+      expect(ConnectionManager::Builder.send(:connection_class_name,"my_database_test")).to eql("MyDatabaseConnection")
+    end
+    it "should use the database name from the database.yml if supplied string is only is only the Rails.env" do
+      expect(ConnectionManager::Builder.send(:connection_class_name,"test")).to eql("BaseConnection")
+    end
+  end
+    
+  describe '#build_connection_class' do
+    before(:all) do
+      ConnectionManager::Builder.build_connection_class("MyConnectionClass", :test)
+    end
+    it "should add a class with supplied class name to ConnectionManager::Builder" do
+      expect(defined?(MyConnectionClass)).to be_true
+      expect(MyConnectionClass).to be_a(Class)
+    end
+    it "should have a super class of ActiveRecord::Base" do
+     expect(MyConnectionClass.superclass).to eql(ActiveRecord::Base)
+    end
+    it "should be an abstract class" do
+      expect(MyConnectionClass.abstract_class?).to be_true
+    end
+  end   
+end

data/spec/lib/connection_adapters/abstract_adapter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+describe ConnectionManager::AbstractAdapter do
+  before(:each) do
+    @con = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil) # not testing connection so use nil it get an instance
+  end
+
+  describe '#config' do
+    it {expect(@con).to respond_to(:config)}
+  end
+
+  describe '#cross_schema_support?' do
+    it "should be true for Mysql" do
+      @con.stubs(:config).returns({:adapter => 'mysql'})
+      expect(@con.cross_schema_support?).to be_true
+    end
+    it "should be true for Postgres" do
+      @con.stubs(:config).returns({:adapter => 'postgresql'})
+      expect(@con.cross_schema_support?).to be_true
+    end
+    it "should be true for SQL server" do
+      @con.stubs(:config).returns({:adapter => 'sqlserver'})
+      expect(@con.cross_schema_support?).to be_true
+    end
+  end
+
+  describe '#slave_keys' do
+    it "should return slaves from config symbolized" do
+      @con.stubs(:config).returns({:slaves => ['test','foo']})
+      expect(@con.slave_keys).to eql([:test,:foo])
+    end
+  end
+
+  describe '#master_keys' do
+    it "should return slaves from config symbolized" do
+      @con.stubs(:config).returns({:masters => ['bar','baz']})
+      expect(@con.master_keys).to eql([:bar,:baz])
+    end
+  end
+
+  describe '#replications' do
+    it "should return all slaves and master keys set in config" do
+      @con.stubs(:config).returns({:slaves => [:test,:foo],
+                                  :masters => [:bar,:baz]})
+      expect(@con.replications).to eql({:slaves => [:test,:foo],
+                                   :masters => [:bar,:baz]})
+    end
+  end
+end

data/spec/lib/connection_adapters/mysql_adapter_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+# Really an integration/regression test will move once we drop support for <= 3.1
+describe  ActiveRecord::Base do
+  describe '#table_exists?' do
+    it "should return true for unquoted full_names" do
+      expect(Fruit.connection.table_exists?('cm_test.fruits')).to be_true
+    end
+    it "should return true for table only names" do
+      expect(Fruit.connection.table_exists?('fruits')).to be_true
+    end
+  end
+end

data/spec/lib/connection_handling_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+describe ConnectionManager::ConnectionHandling do
+  before(:all) do
+
+    class MyConnectionClass < ActiveRecord::Base
+      self.abstract_class = true
+      establish_connection({
+                             :database => "cm_test",
+                             :adapter => "mysql2",
+                             :username => TestDB.yml["test"]["username"],
+                             :password => TestDB.yml["test"]["password"]
+
+      })
+    end
+
+    class MyManagedConnectionClass < ActiveRecord::Base
+      establish_managed_connection(:test, :schema_name => 'yep')
+    end
+
+    class MySchemaNameConnection < MyManagedConnectionClass
+      self.abstract_class = true
+      self.schema_name = "boo"
+    end
+
+    class Booed < MySchemaNameConnection;end
+
+    class MyFoo < MyManagedConnectionClass
+      self.table_name = 'foo'
+      self.schema_name = 'boo'
+    end
+  end
+
+  describe '#schema_name=' do
+    it "should set the table_name_prefix for a table formatted as a schema" do
+      expect(MyFoo.table_name_prefix).to eql('boo.')
+    end
+    it "should set the table_name using schema" do
+      expect(MyFoo.table_name).to eql('boo.foo')
+    end
+
+    it "should be inherited" do
+      expect(Booed.schema_name).to eql(MySchemaNameConnection.schema_name)
+      expect(Booed.schema_name).to eql('boo')
+      expect(Booed.table_name_prefix).to eql(MySchemaNameConnection.table_name_prefix)
+    end
+  end
+
+  describe '#establish_connection' do
+    it "should register class as connection class" do
+      expect(ActiveRecord::Base.managed_connection_classes.include?("MyConnectionClass")).to be_true
+    end
+  end
+
+  describe '#establish_managed_connection' do
+    context 'the connection class' do
+      it "should create abstract class" do
+        expect(MyManagedConnectionClass.abstract_class).to be_true
+      end
+
+      it "should check in the connection" do
+        expect(ActiveRecord::Base.managed_connection_classes.include?("MyManagedConnectionClass")).to be_true
+      end
+    end
+  end
+end

data/spec/lib/core_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+describe ConnectionManager::Core do
+  describe 'Arel::Table.name' do
+    it "should update as model's table_name update " do
+      expect(FruitCore.arel_table.name).to eql('fruits')
+      FruitCore.table_name = 'cm_test.fruits'
+     expect(FruitCore.arel_table.name).to eql('cm_test.fruits')
+    end
+  end
+end

data/spec/lib/integration/cross_schema_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+describe ActiveRecord::Base do
+  before :each do
+    @user = CmUser.new(:name => "Testing")
+    @user.save
+    @foo = Foo.new(:cm_user_id => @user.id)
+    @foo.save
+  end
+
+  describe '#joins' do
+    it "should work" do
+      @user.foos.blank?.should be_false
+      found = Foo.joins(:cm_user).select('cm_users.name AS user_name').where('cm_users.id = ?',@user.id).first
+      expect(found.user_name).to_not be_blank
+    end
+  end
+  describe '#includes' do
+    before(:each) do
+      @user.foos.blank?.should be_false
+      search = Foo.includes(:cm_user).where('cm_users.id = ?',@user.id)
+      search = search.references(:cm_user) if search.respond_to?(:references)
+      @found = search.first
+    end
+    it "should return a results" do
+      expect(@found).to be_a(Foo) # Make sure results are returns
+    end
+    it "should load associations" do
+      if @found.respond_to?(:association)
+        expect(@found.association(:cm_user)).to be_loaded
+      else
+        expect(@found.cm_user).to be_loaded
+      end
+    end
+  end
+end

data/spec/lib/querying_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+describe ConnectionManager::Querying  do
+  describe '#using' do
+    it "should be defined" do
+      expect(Fruit).to respond_to(:using)
+    end
+  end
+  describe '#slaves' do
+    it "should be defined" do
+      expect(Fruit).to respond_to(:slaves)
+    end
+  end
+
+  describe '#masters' do
+    it "should be defined" do
+      expect(Fruit).to respond_to(:masters)
+    end
+  end
+end

data/spec/lib/relation_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+describe ConnectionManager::Relation  do
+  context 'ActiveRecord::Relation' do
+    describe '#using' do
+      it "should be defined" do
+        expect(Fruit.where(:id => 1)).to respond_to(:using)
+      end
+    end
+    describe '#slaves' do
+      it "should be defined" do
+        expect(Fruit.where(:id => 1)).to respond_to(:slaves)
+      end
+    end
+
+    describe '#masters' do
+      it "should be defined" do
+        expect(Fruit.where(:id => 1)).to respond_to(:masters)
+      end
+    end
+  end
+end

data/spec/lib/replication_spec.rb

@@ -1,88 +1,50 @@
 require 'spec_helper'
 describe ConnectionManager::Replication do
 
-  describe '#database_name' do
+  describe '#arel_table' do
     it "should return the name of the database the model is using" do
-      Fruit.current_database_name.should eql('cm_test')
+      expect(Fruit.arel_table.name).to eql('cm_test.fruits')
     end
   end
 
   describe '#replicated' do
     it "should raise an exception if no connections are empty, and connection.replication_keys are blank" do
-      Fruit.connection.stubs(:replication_keys).returns([])
-      lambda { Fruit.replicated }.should raise_error
+      ActiveRecord::Base.stubs(:replication_connections).returns({:masters => [], :slaves => []})
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.any_instance.stubs(:slave_keys).returns([])
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.any_instance.stubs(:master_keys).returns([])
+      expect(lambda { Fruit.replicated }).to raise_error
     end
 
     it "should not raise an exception if no connections are empty, but connection.replication_keys are not blank" do
       Fruit.connection.stubs(:replication_keys).returns([:slave_1_cm_test])
-      lambda { Fruit.replicated }.should_not raise_error
-    end
-
-    context "the methods created from #replicated" do
-      it "should create a method with the name given for the :name option" do
-        Fruit.replicated(:name => 'foozle')
-        Fruit.respond_to?(:foozle).should be_true
-      end
-
-      it "should create a method in ActiveRecord::QueryMethods with the name given for the :name option" do
-        f = FactoryGirl.create(:fruit)
-        Fruit.replicated(:name => 'fizzle')
-        ActiveRecord::QueryMethods.instance_methods.include?(:fizzle).should be_true
-      end
-
-      it "should return an ActiveRecord::Relation" do
-        Fruit.replicated(:name => 'slaves')
-        Fruit.slaves.should be_kind_of(ActiveRecord::Relation)
-      end
-
-      it "should have a different connection" do
-        Fruit.replicated
-        Fruit.slaves.connection.config.should_not eql(Fruit.connection.config)
-      end
-
-      it "should work" do
-        Fruit.replicated
-        Fruit.slaves.joins(:region).joins("LEFT OUTER JOIN `fruit_baskets` ON `fruit_baskets`.`fruit_id` = `cm_test`.`fruits`.`id`").to_sql.should eql(Fruit.joins(:region).joins("LEFT OUTER JOIN `fruit_baskets` ON `fruit_baskets`.`fruit_id` = `cm_test`.`fruits`.`id`").to_sql)
-      end
-
-      it "should produce the same query string" do
-        Fruit.replicated
-        Fruit.slaves.joins(:region).to_sql.should eql(Fruit.joins(:region).to_sql)
-        Fruit.slaves.joins(:fruit_baskets).to_sql.should eql(Fruit.joins(:fruit_baskets).to_sql)
-        Fruit.slaves.includes(:fruit_baskets).to_sql.should eql(Fruit.includes(:fruit_baskets).to_sql)
-        Fruit.slaves.includes(:region).to_sql.should eql(Fruit.includes(:region).to_sql)
-      end
-
-      context '#slaves' do
-        it "should have the same quoted_table_name" do
-          Fruit.replicated
-
-          Fruit.slaves.quoted_table_name.should eql(Fruit.quoted_table_name)
-        end
-        it "should have the same table_name_prefix"do
-          Fruit.replicated
-          Fruit.slaves.table_name_prefix.should eql(Fruit.table_name_prefix)
-        end
-      end
+      expect(lambda { Fruit.replicated }).to_not raise_error
     end
 
     context "the objects return from a query" do
       it "should not have the same connection as the master class" do
         Fruit.replicated
         FactoryGirl.create(:fruit)
-        Fruit.slaves.connection.config.should_not eql(Fruit.connection.config)
-        Fruit.slaves.first.should_not be_nil
+        expect(Fruit.slaves.connection.config).to_not eql(Fruit.connection.config)
+        expect(Fruit.slaves.first).to_not be_nil
       end
     end
   end
 
   describe'#replicated?' do
     it "should be false if not replicated" do
-      Fruit.replicated?.should be_false
+      expect(Fruit).to_not be_replicated
     end
     it "should be true if replicated" do
       Fruit.replicated
-      Fruit.replicated?.should be_true
+      expect(Fruit).to be_replicated
     end
   end
+
+  it "should produce the same SQL string" do
+    Fruit.replicated
+    expect(Fruit.slaves.joins(:region).to_sql).to eql(Fruit.joins(:region).to_sql)
+    expect(Fruit.slaves.joins(:fruit_baskets).to_sql).to eql(Fruit.joins(:fruit_baskets).to_sql)
+    expect(Fruit.slaves.includes(:fruit_baskets).to_sql).to eql(Fruit.includes(:fruit_baskets).to_sql)
+    expect(Fruit.slaves.includes(:region).to_sql).to eql(Fruit.includes(:region).to_sql)
+  end
 end

data/spec/lib/shards_spec.rb

@@ -8,7 +8,7 @@ describe ConnectionManager::Shards do
       a = Fruit.shards do |shard|
         shard.first
       end
-      a.should be_a_kind_of(Array)
+      expect(a).to be_a(Array)
     end
     
     it "should execute the active record methods on the the provided models" do
@@ -17,7 +17,7 @@ describe ConnectionManager::Shards do
       a = Fruit.shards do |shard|
         shard.where(:id => fruit.id).first
       end
-      klasses.include?(a[0].class.name).should be_true
+      expect(klasses.include?(a[0].class.name)).to be_true
     end
    
       
@@ -34,7 +34,7 @@ describe ConnectionManager::Shards do
       cfruit = Fruit.shards do |shard|
         shard.where('id = ?', fruit.id).first    
       end
-      (afruit == bfruit && bfruit == cfruit).should be_true
+      expect((afruit == bfruit && bfruit == cfruit)).to be_true
     end
   end
 end

data/spec/lib/using_proxy_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+describe ConnectionManager::Using::Proxy do
+  before(:each) do
+    @proxy =  ConnectionManager::Using::Proxy.new(Fruit, OtherConnection)
+  end
+
+  describe '#connection' do
+    it 'returns connection from connection_class' do
+      expect(@proxy.connection.config).to eql(OtherConnection.connection.config)
+    end
+  end
+  describe '#superclass' do
+    it "should return the @klass's superclass" do
+      expect(@proxy.superclass).to eql(Fruit.superclass)
+    end
+  end
+  describe '#method_missing' do
+    it "should direct to @klass" do
+      expect(@proxy.table_name).to eql(Fruit.table_name)
+    end
+  end
+  describe '#responds_to?' do
+  	it "should direct to @klass" do
+  		expect(@proxy).to respond_to(:where)
+  	end
+  end
+end

data/spec/lib/using_spec.rb

@@ -1,37 +1,50 @@
 require 'spec_helper'
 class CmFooSlaveConnection < ActiveRecord::Base
-  establish_managed_connection(:slave_1_cm_test)
+  establish_connection(:slave_test)
 end
 
 describe ConnectionManager::Using do
-
   describe '#using' do
     it "should return an ActiveRecord::Relation" do
-      Fruit.using("CmFooSlaveConnection").should be_kind_of(ActiveRecord::Relation)
+      expect(Fruit.using("CmFooSlaveConnection")).to be_kind_of(ActiveRecord::Relation)
     end
     it "should change the connection" do
-      Fruit.using("CmFooSlaveConnection").connection.config.should_not eql(Fruit.connection.config)
+      expect(Fruit.using("CmFooSlaveConnection").connection.config).to_not eql(Fruit.connection.config)
     end
 
     it "should create the exact same sql if called from model or from relation" do
       class_sql = Fruit.using("CmFooSlaveConnection").where(:name => "malarky").to_sql
       relation_sql = Fruit.where(:name => "malarky").using("CmFooSlaveConnection").to_sql
-      class_sql.should eql(relation_sql)
+      expect(class_sql).to eql(relation_sql)
     end
 
     it "should have the same connection if called from model or from relation" do
-      Fruit.where(:name => "malarky").using("CmFooSlaveConnection").connection.config.should eql(
-      Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.config)
-      Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.config.should_not eql(
-      Fruit.where(:name => "malarky").connection.config)
-      Fruit.where(:name => "malarky").using("CmFooSlaveConnection").connection.config.should_not eql(
-      Fruit.where(:name => "malarky").connection.config)
+      expect(Fruit.where(:name => "malarky").using("CmFooSlaveConnection").connection.
+        config).to eql(Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.config)
+      expect(Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.
+        config).to_not eql(Fruit.where(:name => "malarky").connection.config)
+      expect(Fruit.where(:name => "malarky").using("CmFooSlaveConnection").connection.
+        config).to_not eql(Fruit.where(:name => "malarky").connection.config)
     end
 
-    it "should return same record" do
-      fruit = FactoryGirl.create(:fruit)
-      Fruit.using("CmFooSlaveConnection").where(:id => fruit.id).first.should eql(fruit)
+    context "A replication like connection" do
+      it "should return same record" do
+        fruit = FactoryGirl.create(:fruit)
+        expect(Fruit.using("CmFooSlaveConnection").where(:id => fruit.id).first).to eql(fruit)
+      end
+
+      it "should work" do
+        fb = FactoryGirl.create(:fruit_basket)
+        expect(lambda {FruitBasket.using("CmFooSlaveConnection").
+          joins(:fruit,:basket).includes(:fruit,:basket).where(:id => fb.id).first}).to_not raise_error
+      end
+    end
+
+    context 'A shard like connection' do
+      it "should use other connection" do
+        fruit = FactoryGirl.create(:fruit)
+        expect(Fruit.using("OtherConnection").where(:name => fruit.name).exists?).to be_false
+      end
     end
   end
 end
-

data/spec/spec_helper.rb

@@ -7,26 +7,18 @@ require 'active_support'
 require 'logger'
 require 'factory_girl'
 require 'helpers/database_spec_helper'
-if(defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
-  TestDB.connect('jdbcmysql')
-else
-  TestDB.connect('mysql2')
-end
 
+TestDB.connect#(true)
 TestMigrations.down
 TestMigrations.up
 FactoryGirl.find_definitions
-# ActiveRecord::Base.logger = Logger.new(STDOUT)
 RSpec.configure do |config|
   config.mock_with :mocha
   # Loads database.yml and establishes primary connection
   # Create tables when tests are completed
   config.before(:suite) {
     require 'helpers/models_spec_helper.rb'
-  }
-  # Drops tables when tests are completed
-  config.after(:suite){
-    TestDB.clean
+    ConnectionManager::Builder.build_connection_classes(TestDB.yml.select{ |k,v| v['build_connection_class'] && k.match(ConnectionManager::Builder.env_regex)}.keys)
   }
   # Make sure every test is isolated.
   config.before(:each){