dynashard 0.1.0

data/spec/associations_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe 'Dynashard::ProxyExtensions' do
+  before(:each) do
+    Dynashard.enable
+  end
+
+  context 'with a sharding proxy owner' do
+    before(:each) do
+      @owner = Factory(:sharding_owner)
+      @shard = @owner.shard_dsn
+    end
+
+    context 'and a sharding proxy target' do
+      it 'uses a sharded reflection class' do
+        orig_reflection = @owner.class.reflections[:sharded_has_manys]
+        new_reflection  = Dynashard.reflection_for(@owner, orig_reflection)
+        Dynashard.should_receive(:reflection_for).once.and_return(new_reflection)
+        proxy = @owner.sharded_has_manys
+        proxy.proxy_reflection.klass.dynashard_klass.should_not be_nil
+        proxy.proxy_reflection.should == new_reflection
+      end
+
+      context 'using a :has_one reflection' do
+        before(:each) do
+          # Ensure that all sharded model connections happen on the owner shard
+          Dynashard.shard_context[:owner] = @shard
+
+          @has_one = Factory(:sharded_has_one, :sharding_owner => @owner, :name => "Owned by #{@owner.name}")
+        end
+
+        after(:each) do
+          Dynashard.shard_context.clear
+        end
+
+        # TODO: figure out what to do about the classes being different
+        it 'reads from the shard' do
+          @owner.sharded_has_one.attributes.should == @has_one.attributes
+        end
+
+        it 'destroys from the shard' do
+          lambda do
+            @owner.sharded_has_one.destroy
+          end.should change(ShardedHasOne, :count).by(-1)
+        end
+
+        it 'creates_other on the shard' do
+          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+          lambda do
+            new_owner.create_sharded_has_one(:name => "Owned by #{new_owner.name}")
+          end.should change(ShardedHasOne, :count).by(1)
+        end
+
+        it 'saves built associations on the shard' do
+          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+          new_sharded_has_one = new_owner.build_sharded_has_one(:name => "Owned by #{new_owner.name}")
+          lambda do
+            new_sharded_has_one.save
+          end.should change(ShardedHasOne, :count).by(1)
+        end
+      end
+
+      context 'using a :has_many reflection' do
+        before(:each) do
+          # Ensure that all sharded model connections happen on the owner shard
+          Dynashard.shard_context[:owner] = @shard
+
+          @one_of_many = Factory(:sharded_has_many, :sharding_owner => @owner, :name => "Owned by #{@owner.name}")
+        end
+
+        after(:each) do
+          Dynashard.shard_context.clear
+        end
+
+        # TODO: figure out what to do about the classes being different
+        it 'reads from the shard' do
+          @owner.sharded_has_manys.detect{|m| m.attributes == @one_of_many.attributes}.should_not be_nil
+        end
+
+        it 'destroys from the shard' do
+          lambda do
+            one_of_many = @owner.sharded_has_manys.detect{|m| m.attributes == @one_of_many.attributes}
+            one_of_many.destroy
+          end.should change(ShardedHasMany, :count).by(-1)
+        end
+
+        it 'creates_other on the shard' do
+          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+          lambda do
+            new_owner.sharded_has_manys.create(:name => "Owned by #{new_owner.name}")
+          end.should change(ShardedHasMany, :count).by(1)
+        end
+
+        it 'saves built associations on the shard' do
+          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+          new_one_of_many = new_owner.sharded_has_manys.build(:name => "Owned by #{new_owner.name}")
+          lambda do
+            new_one_of_many.save
+          end.should change(ShardedHasMany, :count).by(1)
+        end
+      end
+
+      context 'using a :has_many_through reflection' do
+        before(:each) do
+          # Ensure that all sharded model connections happen on the owner shard
+          Dynashard.shard_context[:owner] = @shard
+
+          @one_of_many = Factory(:sharded_has_many_through, :name => "Owned by #{@owner.name}")
+          join = Factory(:sharded_join, :sharding_owner => @owner, :sharded_has_many_through => @one_of_many)
+        end
+
+        after(:each) do
+          Dynashard.shard_context.clear
+        end
+
+        # TODO: figure out what to do about the classes being different
+        it 'reads from the shard' do
+          @owner.sharded_has_many_throughs.detect{|m| m.attributes == @one_of_many.attributes}.should_not be_nil
+        end
+
+        it 'destroys from the shard' do
+          lambda do
+            one_of_many = @owner.sharded_has_many_throughs.detect{|m| m.attributes == @one_of_many.attributes}
+            one_of_many.destroy
+          end.should change(ShardedHasManyThrough, :count).by(-1)
+        end
+
+        it 'creates_other on the shard' do
+          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+          lambda do
+            new_owner.sharded_has_many_throughs.create(:name => "Owned by #{new_owner.name}")
+          end.should change(ShardedHasManyThrough, :count).by(1)
+        end
+
+        it 'saves built associations on the shard' do
+          new_owner = Factory(:sharding_owner, :shard => @owner.shard)
+          new_one_of_many = new_owner.sharded_has_many_throughs.build(:name => "Owned by #{new_owner.name}")
+          lambda do
+            new_one_of_many.save
+          end.should change(ShardedHasManyThrough, :count).by(1)
+        end
+      end
+    end
+
+    context 'and a non-sharding proxy target' do
+      it 'uses a non-sharded reflection class' do
+        orig_reflection = @owner.class.reflections[:non_sharded_has_manys]
+        Dynashard.should_receive(:reflection_for).never
+        proxy = @owner.non_sharded_has_manys
+        proxy.proxy_reflection.klass.should_not respond_to(:dynashard_klass)
+        proxy.proxy_reflection.should == orig_reflection
+      end
+    end
+
+  end
+
+  context 'with a non-sharding proxy owner' do
+    before(:each) do
+      @owner = Factory(:non_sharding_owner)
+    end
+
+    context 'and a sharding proxy target' do
+      it 'uses a non-sharded reflection class' do
+        orig_reflection = @owner.class.reflections[:sharded_has_manys]
+        Dynashard.should_receive(:reflection_for).never
+        proxy = Dynashard.with_context(:owner => Shard.find(:first).dsn){@owner.sharded_has_manys}
+        proxy.proxy_reflection.klass.should_not respond_to(:dynashard_klass)
+        proxy.proxy_reflection.should == orig_reflection
+      end
+    end
+
+    context 'and a non-sharding proxy target' do
+      it 'uses a non-sharded reflection class' do
+        orig_reflection = @owner.class.reflections[:non_sharded_has_manys]
+        Dynashard.should_receive(:reflection_for).never
+        proxy = @owner.non_sharded_has_manys
+        proxy.proxy_reflection.klass.should_not respond_to(:dynashard_klass)
+        proxy.proxy_reflection.should == orig_reflection
+      end
+    end
+  end
+end

data/spec/connection_handler_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'Dynashard::ConnectionHandlerExtensions' do
+  before(:each) do
+    Dynashard.enable
+  end
+
+  context 'defining connection pool aliases' do
+    after(:each) do
+      ActiveRecord::Base.connection_handler.connection_pools.delete('Foo')
+    end
+
+    it 'succeeds' do
+      connection_handler = ActiveRecord::Base.connection_handler
+      connection_handler.dynashard_pool_alias('Foo', 'ActiveRecord::Base')
+      connection_handler.connection_pools['Foo'].should == connection_handler.connection_pools['ActiveRecord::Base']
+    end
+  end
+
+  context 'with a sharded association reflection' do
+    it 'retrieves the connection pool' do
+      owner = Factory(:sharding_owner)
+      reflection = Dynashard.reflection_for(owner, ShardingOwner.reflections[:sharded_has_one])
+      dynashard_klass = reflection.klass.dynashard_klass
+      pool = ActiveRecord::Base.connection_handler.connection_pools['ActiveRecord::Base']
+      ActiveRecord::Base.connection_handler.should_receive(:retrieve_connection_pool_without_dynashard).with(dynashard_klass).and_return(pool)
+      reflection.klass.connection.should be_kind_of(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+    end
+  end
+
+  context 'with a sharded model' do
+    before(:each) do
+      @shard_klass = Dynashard.class_for('shard1')
+    end
+
+    it 'retrieves the connection' do
+      dsn = Shard.find(:first).dsn
+      shard_klass = Dynashard.class_for(dsn)
+      pool = ActiveRecord::Base.connection_handler.connection_pools['ActiveRecord::Base']
+      ActiveRecord::Base.connection_handler.should_receive(:retrieve_connection_pool_without_dynashard).with(shard_klass).and_return(pool)
+      connection = Dynashard.with_context(:owner => dsn) {ShardedHasOne.connection}
+      connection.should be_kind_of(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+    end
+
+    it 'requires a defined shard context' do
+      Dynashard.shard_context.clear
+      ShardedHasOne.sharding_enabled?.should be_true
+      lambda do
+        connection = ShardedHasOne.find(:first)
+      end.should raise_error(RuntimeError)
+    end
+  end
+
+  context 'with a non-sharded model' do
+    it 'retrieves the connection' do
+      pool = ActiveRecord::Base.connection_handler.connection_pools['ActiveRecord::Base']
+      ActiveRecord::Base.connection_handler.should_receive(:retrieve_connection_pool_without_dynashard).with(NonShardedHasOne).and_return(pool)
+      NonShardedHasOne.connection.should be_kind_of(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+    end
+  end
+end

data/spec/db/schema.rb

@@ -0,0 +1,67 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "shards", :force => true do |t|
+    t.string  "name"
+    t.string  "adapter"
+    t.string  "host"
+    t.string  "username"
+    t.string  "password"
+    t.string  "database"
+    t.integer "port"
+    t.integer "pool"
+    t.integer "timeout"
+  end
+
+  create_table "non_sharding_owners", :force => true do |t|
+    t.string "name"
+  end
+
+  create_table "sharding_owners", :force => true do |t|
+    t.string  "name"
+    t.integer "shard_id"
+  end
+
+  create_table "non_sharded_has_ones", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.string  "name"
+  end
+
+  create_table "non_sharded_has_manies", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.string  "name"
+  end
+
+  create_table "non_sharded_joins", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.integer "non_sharded_has_many_through_id"
+  end
+
+  create_table "non_sharded_has_many_throughs", :force => true do |t|
+    t.string  "name"
+  end
+
+  create_table "sharded_has_ones", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.string  "name"
+  end
+
+  create_table "sharded_has_manies", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.string  "name"
+  end
+
+  create_table "sharded_joins", :force => true do |t|
+    t.integer "sharding_owner_id"
+    t.integer "non_sharding_owner_id"
+    t.integer "sharded_has_many_through_id"
+  end
+
+  create_table "sharded_has_many_throughs", :force => true do |t|
+    t.string  "name"
+  end
+end

data/spec/dynashard_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe 'Dynashard' do
+  it 'can be enabled' do
+    Dynashard.should respond_to(:enable)
+    Dynashard.enable
+    Dynashard.should be_enabled
+  end
+
+  it 'can be disabled' do
+    Dynashard.should respond_to(:disable)
+    Dynashard.disable
+    Dynashard.should_not be_enabled
+  end
+
+  describe '#shard_context' do
+    it 'is threadsafe' do
+      Dynashard.shard_context[:test] = true
+      t = Thread.new {Dynashard.shard_context[:test] = false}
+      t.join
+      Dynashard.shard_context[:test].should be_true
+    end
+  end
+
+  describe '#class_for' do
+    before(:each) do
+      @shard_klass = Dynashard.class_for('shard1')
+    end
+
+    it 'returns a class' do
+      @shard_klass.should be_a(Class)
+    end
+
+    it 'has an established connection' do
+      ActiveRecord::Base.connection_handler.connection_pools.should have_key(@shard_klass.name)
+    end
+
+    it 'does not regenerate existing classes' do
+      other_klass = Dynashard.class_for('shard1')
+      other_klass.should == @shard_klass
+    end
+
+    # Ie. from config/database.yml
+    it 'accepts a string reference to a configured database' do
+      lambda do
+        Dynashard.class_for('shard2')
+      end.should_not raise_error
+    end
+
+    it 'accepts a hash with valid database connection parameters' do
+      lambda do
+        Dynashard.class_for({:adapter => 'sqlite3', :database => 'db/shard3.sqlite3'})
+      end.should_not raise_error
+    end
+  end
+
+  describe '#reflection_for' do
+    before(:each) do
+      @owner = Factory(:sharding_owner)
+      @reflection = Dynashard.reflection_for(@owner, ShardingOwner.reflections[:sharded_has_one])
+      @shard_klass = Dynashard.class_for(@owner.shard_dsn)
+    end
+
+    it 'returns a reflection' do
+      @reflection.should be_kind_of(ActiveRecord::Reflection::MacroReflection)
+    end
+
+    it 'has a sharded class' do
+      @reflection.klass.should respond_to(:dynashard_klass)
+    end
+  end
+
+  describe '#sharded_model_class' do
+    before(:each) do
+      @owner = Factory(:sharding_owner)
+      @reflection = Dynashard.reflection_for(@owner, ShardingOwner.reflections[:sharded_has_one])
+      @shard_klass = Dynashard.class_for(@owner.shard_dsn)
+    end
+
+    it 'identifies as a sharded model' do
+      @reflection.klass.should respond_to(:dynashard_model?)
+      @reflection.klass.dynashard_model?.should be_true
+    end
+
+    it 'returns the shard class' do
+      @reflection.klass.dynashard_klass.should == @shard_klass
+    end
+
+    it 'returns the shard class connection' do
+      @reflection.klass.connection.should == @shard_klass.connection
+    end
+
+    it 'are not regenerated' do
+      other_reflection = Dynashard.reflection_for(@owner, ShardingOwner.reflections[:sharded_has_one])
+      other_reflection.klass.should == @reflection.klass
+    end
+  end
+
+  describe '#with_context' do
+    before(:each) do
+      @test_context = {:foo => 'shard1'}
+    end
+
+    it 'sets the shard context for the given block' do
+      Dynashard.with_context(@test_context) do
+        Dynashard.shard_context[:foo].should == 'shard1'
+      end
+    end
+
+    it 'resets the shard context' do
+      Dynashard.with_context(@test_context) {}
+      Dynashard.shard_context.should_not have_key(:foo)
+    end
+
+    it 'returns the block result' do
+      Dynashard.with_context(@test_context) { 'foo' }.should == 'foo'
+    end
+
+    context 'when the block raises an exception' do
+      it 'resets the shard context' do
+        Dynashard.with_context(@test_context) { raise 'Aah!' } rescue nil
+        Dynashard.shard_context.should_not have_key(:foo)
+      end
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'ActiveRecord Models' do
+
+  context 'with invalid sharding arguments' do
+    after(:each) do
+      Object.send(:remove_const, :DynashardTestClass) if Object.const_defined?(:DynashardTestClass)
+    end
+
+    context 'for association owners' do
+      it 'raises an exception' do
+        lambda do
+          class DynashardTestClass < ActiveRecord::Base
+            shard :associated, :without_using_arg => true
+          end
+        end.should raise_error(ArgumentError)
+      end
+    end
+
+    context 'for sharded models' do
+      it 'raises an exception' do
+        lambda do
+          class DynashardTestClass < ActiveRecord::Base
+            shard :without_using_by => true
+          end
+        end.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'with Dynashard disabled' do
+    before(:each) do
+      Dynashard.disable
+    end
+
+    after(:each) do
+      Dynashard.enable
+    end
+
+    it 'uses the ActiveRecord::Base connection' do
+      ShardedHasOne.connection.should == ActiveRecord::Base.connection
+    end
+
+    it 'do not shard' do
+      ShardedHasOne.sharding_enabled?.should be_false
+    end
+
+    it 'do not shard associations' do
+      ShardingOwner.shards_associated?.should be_false
+    end
+  end
+
+  context 'with Dynashard enabled' do
+    before(:each) do
+      Dynashard.enable
+    end
+
+    it 'can be sharded' do
+      ShardedHasOne.sharding_enabled?.should be_true
+    end
+
+    it 'can have sharded associations' do
+      ShardingOwner.shards_associated?.should be_true
+    end
+
+    it 'shards associations using a specified arg' do
+      class DynashardTestClass < ActiveRecord::Base
+        shard :associated, :using => :foo
+      end
+      DynashardTestClass.dynashard_association_using.should == :foo
+      Object.send(:remove_const, :DynashardTestClass)
+    end
+
+    it 'shards models using a specified context' do
+      class DynashardTestClass < ActiveRecord::Base
+        shard :by => :foo
+      end
+      DynashardTestClass.dynashard_context.should == :foo
+      Object.send(:remove_const, :DynashardTestClass)
+    end
+
+    context 'and no shard context defined' do
+      it 'raises an exception' do
+        lambda do
+          ShardedHasOne.connection
+        end.should raise_error
+      end
+    end
+
+    context 'and the shard context defined' do
+      it 'uses the sharded connection' do
+        test_shard = 'shard1'
+        Dynashard.with_context(:owner => test_shard) do
+          shard_class  = Dynashard.class_for(test_shard)
+          shard_config = shard_class.connection.instance_variable_get('@config')
+          ar_config    = ActiveRecord::Base.connection.instance_variable_get('@config')
+          model_config = ShardedHasOne.connection.instance_variable_get('@config')
+          model_config.should_not == ar_config
+          model_config.should     == shard_config
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+plugin_test_dir = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+require 'erb'
+
+require 'rspec'
+require 'logger'
+
+require 'active_record'
+require 'factory_girl_rails'
+
+require 'dynashard'
+
+ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
+
+ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result(binding))
+ActiveRecord::Base.establish_connection("test")
+ActiveRecord::Migration.verbose = false
+
+test_database = ActiveRecord::Base.configurations['test']['database']
+File.unlink(test_database) if File.exists?(test_database)
+load(File.join(plugin_test_dir, "db", "schema.rb"))
+
+# create shards and databases that they point to
+base_config = ActiveRecord::Base.configurations['test']
+%w{shard1 shard2 shard3}.each do |shard|
+  database = "#{plugin_test_dir}/db/#{shard}.sqlite3"
+  File.unlink(database) if File.exists?(database)
+  shard_config = base_config.merge('database' => database)
+  ActiveRecord::Base.configurations['test'] = shard_config
+  ActiveRecord::Base.establish_connection("test")
+  load(File.join(plugin_test_dir, "db", "schema.rb"))
+end
+ActiveRecord::Base.configurations['test'] = base_config
+ActiveRecord::Base.establish_connection("test")
+
+require 'support/models'
+
+%w{shard1 shard2 shard3}.each do |shard|
+  Shard.create(:adapter => 'sqlite3', :database => "#{plugin_test_dir}/db/#{shard}.sqlite3")
+end
+
+# This has to happen after the models have been defined and the shards have been created
+require 'support/factories'

data/spec/support/factories.rb

@@ -0,0 +1,32 @@
+# Sequence for generating unique names
+Factory.sequence :name do |n|
+  "Test Owner #{n}"
+end
+
+Factory.define(:sharding_owner) do |owner|
+  owner.name {Factory.next :name}
+  owner.shard Shard.find(:first)
+end
+
+Factory.define(:non_sharding_owner) do |owner|
+  owner.name {Factory.next :name}
+end
+
+Factory.define(:sharded_has_one) do |one|
+  one.name {Factory.next :name}
+  one.sharding_owner
+end
+
+Factory.define(:sharded_has_many) do |one_of_many|
+  one_of_many.name {Factory.next :name}
+  one_of_many.sharding_owner
+end
+
+Factory.define(:sharded_join) do |join|
+  join.sharding_owner
+  join.sharded_has_many_through
+end
+
+Factory.define(:sharded_has_many_through) do |one_of_many|
+  one_of_many.name {Factory.next :name}
+end