octoball 0.1.0

data/spec/octoball/collection_proxy_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Octoball do
+  describe 'method dispatch' do
+    before :each do
+      @client = Client.using(:canada).create!
+      @client.items << Item.using(:canada).create!
+      @client.reload
+    end
+
+    it 'computes the size of the collection without loading it' do
+      expect(@client.items.size).to eq(1)
+
+      expect(@client.items.loaded?).to be false
+    end
+  end
+end

data/spec/octoball/log_subscriber_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Octoball::LogSubscriber, :shards => [:canada] do
+  before :each do
+    @out = StringIO.new
+    @log = Logger.new(@out)
+    ActiveRecord::Base.logger = @log
+    ActiveRecord::Base.logger.level = Logger::DEBUG
+  end
+
+  after :each do
+    ActiveRecord::Base.logger = Logger.new(File.open('database.log', 'a'))
+  end
+
+  it 'should add to the default logger the shard name the query was sent to' do
+    User.using(:canada).create!(:name => 'test')
+    expect(@out.string).to match(/Shard: canada/)
+  end
+end

data/spec/octoball/model_spec.rb

@@ -0,0 +1,688 @@
+require 'spec_helper'
+
+describe Octoball do
+  describe '#using method' do
+    it 'should allow to send a block to the master shard' do
+      Octoball.using(:master) do
+        User.create!(:name => 'Block test')
+      end
+
+      expect(User.using(:master).find_by_name('Block test')).not_to be_nil
+    end
+
+    it 'should allow to pass a string as the shard name to a AR subclass' do
+      User.using('canada').create!(:name => 'Rafael Pilha')
+
+      expect(User.using('canada').find_by_name('Rafael Pilha')).not_to be_nil
+    end
+
+    it 'should allow comparison of a string shard name with symbol shard name' do
+      u = User.using('canada').create!(:name => 'Rafael Pilha')
+      expect(u).to eq(User.using(:canada).find_by_name('Rafael Pilha'))
+    end
+
+    it 'should allow comparison of a symbol shard name with string shard name' do
+      u = User.using(:canada).create!(:name => 'Rafael Pilha')
+      expect(u).to eq(User.using('canada').find_by_name('Rafael Pilha'))
+    end
+
+    it 'should allow to pass a string as the shard name to a block' do
+      Octoball.using('canada') do
+        User.create!(:name => 'Rafael Pilha')
+      end
+
+      expect(User.using('canada').find_by_name('Rafael Pilha')).not_to be_nil
+    end
+
+    it 'should allow selecting the shards on scope' do
+      User.using(:canada).create!(:name => 'oi')
+      expect(User.using(:canada).count).to eq(1)
+      expect(User.count).to eq(0)
+    end
+
+    it 'should allow selecting the shard using #new' do
+      u = User.using(:canada).new
+      u.name = 'Thiago'
+      u.save
+
+      expect(User.using(:canada).count).to eq(1)
+      expect(User.using(:brazil).count).to eq(0)
+
+      u1 = User.new
+      u1.name = 'Joaquim'
+      u2 = User.using(:canada).new
+      u2.name = 'Manuel'
+      u1.save
+      u2.save
+
+      expect(User.using(:canada).all).to eq([u, u2])
+      expect(User.all).to eq([u1])
+    end
+
+    it "should allow the #select method to fetch the correct data when using a block" do
+      canadian_user = User.using(:canada).create!(:name => 'Rafael Pilha')
+
+      Octoball.using('canada') do
+        @all_canadian_user_ids = User.select('id').to_a
+      end
+
+      expect(@all_canadian_user_ids).to eq([canadian_user])
+    end
+
+    it "should allow objects to be fetch using different blocks - GH #306" do
+      canadian_user = User.using(:canada).create!(:name => 'Rafael Pilha')
+
+      Octoball.using(:canada) { @users = User.where('id is not null') }
+      Octoball.using(:canada) { @user = @users.first }
+
+      Octoball.using(:canada) { @user2 = User.where('id is not null').first }
+
+      expect(@user).to eq(canadian_user)
+      expect(@user2).to eq(canadian_user)
+    end
+
+    describe 'multiple calls to the same scope' do
+      it 'works with nil response' do
+        scope = User.using(:canada)
+        expect(scope.count).to eq(0)
+        expect(scope.first).to be_nil
+      end
+
+      it 'works with non-nil response' do
+        user = User.using(:canada).create!(:name => 'oi')
+        scope = User.using(:canada)
+        expect(scope.count).to eq(1)
+        expect(scope.first).to eq(user)
+      end
+    end
+
+    it 'should select the correct shard' do
+      User.using(:canada)
+      User.create!(:name => 'oi')
+      expect(User.count).to eq(1)
+    end
+
+    it 'should ensure that the connection will be cleaned' do
+      expect(ActiveRecord::Base.connection.current_shard).to eq(:default)
+      expect do
+        Octoball.using(:canada) do
+          fail 'Some Exception'
+        end
+      end.to raise_error(RuntimeError)
+
+      expect(ActiveRecord::Base.connection.current_shard).to eq(:default)
+    end
+
+    it 'should allow creating more than one user' do
+      User.using(:canada).create([{ :name => 'America User 1' }, { :name => 'America User 2' }])
+      User.create!(:name => 'Thiago')
+      expect(User.using(:canada).find_by_name('America User 1')).not_to be_nil
+      expect(User.using(:canada).find_by_name('America User 2')).not_to be_nil
+      expect(User.using(:master).find_by_name('Thiago')).not_to be_nil
+    end
+
+    it 'should clean #current_shard from proxy when using execute' do
+      User.using(:canada).connection.execute('select * from users limit 1;')
+      expect(User.connection.current_shard).to eq(:default)
+    end
+
+    it 'should allow scoping dynamically' do
+      User.using(:canada).using(:master).using(:canada).create!(:name => 'oi')
+      expect(User.using(:canada).using(:master).count).to eq(0)
+      expect(User.using(:master).using(:canada).count).to eq(1)
+    end
+
+    it 'should allow find inside blocks' do
+      @user = User.using(:brazil).create!(:name => 'Thiago')
+
+      Octoball.using(:brazil) do
+        expect(User.first).to eq(@user)
+      end
+
+      expect(User.using(:brazil).find_by_name('Thiago')).to eq(@user)
+    end
+
+    it 'should clean the current_shard after executing the current query' do
+      User.using(:canada).create!(:name => 'oi')
+      expect(User.count).to eq(0)
+    end
+
+    it 'should support both groups and alone shards' do
+      _u = User.using(:alone_shard).create!(:name => 'Alone')
+      expect(User.using(:alone_shard).count).to eq(1)
+      expect(User.using(:canada).count).to eq(0)
+      expect(User.using(:brazil).count).to eq(0)
+      expect(User.count).to eq(0)
+    end
+
+    it 'should work with named scopes' do
+      u = User.using(:brazil).create!(:name => 'Thiago')
+
+      expect(User.thiago.using(:brazil).first).to eq(u)
+      expect(User.using(:brazil).thiago.first).to eq(u)
+
+      Octoball.using(:brazil) do
+        expect(User.thiago.first).to eq(u)
+      end
+    end
+
+    describe '#current_shard attribute' do
+      it 'should store the attribute when you create or find an object' do
+        u = User.using(:alone_shard).create!(:name => 'Alone')
+        expect(u.current_shard).to eq(:alone_shard)
+        User.using(:canada).create!(:name => 'oi')
+        u = User.using(:canada).find_by_name('oi')
+        expect(u.current_shard).to eq(:canada)
+      end
+
+      it 'should store the attribute when you find multiple instances' do
+        5.times { User.using(:alone_shard).create!(:name => 'Alone') }
+
+        User.using(:alone_shard).all.each do |u|
+          expect(u.current_shard).to eq(:alone_shard)
+        end
+      end
+
+      it 'should works when you find, and after that, alter that object' do
+        alone_user = User.using(:alone_shard).create!(:name => 'Alone')
+        _mstr_user = User.using(:master).create!(:name => 'Master')
+        alone_user.name = 'teste'
+        alone_user.save
+        expect(User.using(:master).first.name).to eq('Master')
+        expect(User.using(:alone_shard).first.name).to eq('teste')
+      end
+
+      it 'should work for the reload method' do
+        User.using(:alone_shard).create!(:name => 'Alone')
+        u = User.using(:alone_shard).find_by_name('Alone')
+        u.reload
+        expect(u.name).to eq('Alone')
+      end
+
+      it 'should work passing some arguments to reload method' do
+        User.using(:alone_shard).create!(:name => 'Alone')
+        u = User.using(:alone_shard).find_by_name('Alone')
+        u.reload(:lock => true)
+        expect(u.name).to eq('Alone')
+      end
+    end
+
+    describe 'passing a block' do
+      it 'should allow queries be executed inside the block, ponting to a specific shard' do
+        Octoball.using(:canada) do
+          User.create(:name => 'oi')
+        end
+
+        expect(User.using(:canada).count).to eq(1)
+        expect(User.using(:master).count).to eq(0)
+        expect(User.count).to eq(0)
+      end
+
+      it 'should allow execute queries inside a model' do
+        u = User.new
+        u.awesome_queries
+        expect(User.using(:canada).count).to eq(1)
+        expect(User.count).to eq(0)
+      end
+    end
+
+    describe 'raising errors' do
+      it "should raise a error when you specify a shard that doesn't exist" do
+        expect { User.using(:crazy_shard).create!(:name => 'Thiago') }.to raise_error(ActiveRecord::ConnectionNotEstablished)
+      end
+    end
+
+    describe 'equality' do
+      let(:canada1) do
+        User.using(:canada).new(id: 1)
+      end
+
+      let(:canada1_dup) do
+        User.using(:canada).new(id: 1)
+      end
+
+      let(:brazil1) do
+        User.using(:brazil).new(id: 1)
+      end
+
+      it 'should work with persisted objects' do
+        u = User.using(:brazil).create(:name => 'Mike')
+        expect(User.using(:brazil).find_by_name('Mike')).to eq(u)
+      end
+
+      it 'should check current_shard when determining equality' do
+        expect(canada1).not_to eq(brazil1)
+        expect(canada1).to eq(canada1_dup)
+      end
+
+      it 'delegates equality check on scopes' do
+        u = User.using(:brazil).create!(:name => 'Mike')
+        expect(User.using(:brazil).where(:name => 'Mike')).to eq([u])
+      end
+    end
+  end
+
+  describe 'AR basic methods' do
+    it 'connects_to' do
+      expect(CustomConnection.connection.current_database).to eq('octoball_shard_2')
+    end
+
+    it 'reuses parent model connection' do
+      klass = Class.new(CustomConnection)
+
+      expect(klass.connection).to be klass.connection
+    end
+
+    it 'should not mess with custom connection table names' do
+      expect(Advert.connection.current_database).to eq('octoball_shard_1')
+      Advert.create!(:name => 'Teste')
+    end
+
+    it 'increment' do
+      _ = User.using(:brazil).create!(:name => 'Teste', :number => 10)
+      u = User.using(:brazil).find_by_number(10)
+      u.increment(:number)
+      u.save
+      expect(User.using(:brazil).find_by_number(11)).not_to be_nil
+    end
+
+    it 'increment!' do
+      _ = User.using(:brazil).create!(:name => 'Teste', :number => 10)
+      u = User.using(:brazil).find_by_number(10)
+      u.increment!(:number)
+      expect(User.using(:brazil).find_by_number(11)).not_to be_nil
+    end
+
+    it 'decrement' do
+      _ = User.using(:brazil).create!(:name => 'Teste', :number => 10)
+      u = User.using(:brazil).find_by_number(10)
+      u.decrement(:number)
+      u.save
+      expect(User.using(:brazil).find_by_number(9)).not_to be_nil
+    end
+
+    it 'decrement!' do
+      _ = User.using(:brazil).create!(:name => 'Teste', :number => 10)
+      u = User.using(:brazil).find_by_number(10)
+      u.decrement!(:number)
+      expect(User.using(:brazil).find_by_number(9)).not_to be_nil
+    end
+
+    it 'toggle' do
+      _ = User.using(:brazil).create!(:name => 'Teste', :admin => false)
+      u = User.using(:brazil).find_by_name('Teste')
+      u.toggle(:admin)
+      u.save
+      expect(User.using(:brazil).find_by_name('Teste').admin).to be true
+    end
+
+    it 'toggle!' do
+      _ = User.using(:brazil).create!(:name => 'Teste', :admin => false)
+      u = User.using(:brazil).find_by_name('Teste')
+      u.toggle!(:admin)
+      expect(User.using(:brazil).find_by_name('Teste').admin).to be true
+    end
+
+    it 'count' do
+      _u = User.using(:brazil).create!(:name => 'User1')
+      _v = User.using(:brazil).create!(:name => 'User2')
+      _w = User.using(:brazil).create!(:name => 'User3')
+      expect(User.using(:brazil).where(:name => 'User2').all.count).to eq(1)
+    end
+
+    it 'maximum' do
+      _u = User.using(:brazil).create!(:name => 'Teste', :number => 11)
+      _v = User.using(:master).create!(:name => 'Teste', :number => 12)
+
+      expect(User.using(:brazil).maximum(:number)).to eq(11)
+      expect(User.using(:master).maximum(:number)).to eq(12)
+    end
+
+    it 'sum' do
+      u = User.using(:brazil).create!(:name => 'Teste', :number => 11)
+      v = User.using(:master).create!(:name => 'Teste', :number => 12)
+
+      expect(User.using(:master).sum(:number)).to eq(12)
+      expect(User.using(:brazil).sum(:number)).to eq(11)
+
+      expect(User.where(id: v.id).sum(:number)).to eq(12)
+      expect(User.using(:brazil).where(id: u.id).sum(:number)).to eq(11)
+      expect(User.using(:master).where(id: v.id).sum(:number)).to eq(12)
+    end
+
+    describe 'any?' do
+      before { User.using(:brazil).create!(:name => 'User1') }
+
+      it 'works when true' do
+        scope = User.using(:brazil).where(:name => 'User1')
+        expect(scope.any?).to be true
+      end
+
+      it 'works when false' do
+        scope = User.using(:brazil).where(:name => 'User2')
+        expect(scope.any?).to be false
+      end
+    end
+
+    it 'exists?' do
+      @user = User.using(:brazil).create!(:name => 'User1')
+
+      expect(User.using(:brazil).where(:name => 'User1').exists?).to be true
+      expect(User.using(:brazil).where(:name => 'User2').exists?).to be false
+    end
+
+    describe 'touch' do
+      it 'updates updated_at by default' do
+        @user = User.using(:brazil).create!(:name => 'User1')
+        User.using(:brazil).where(:id => @user.id).update_all(:updated_at => Time.now - 3.months)
+        @user.touch
+        expect(@user.reload.updated_at.in_time_zone('GMT').to_date).to eq(Time.now.in_time_zone('GMT').to_date)
+      end
+
+      it 'updates passed in attribute name' do
+        @user = User.using(:brazil).create!(:name => 'User1')
+        User.using(:brazil).where(:id => @user.id).update_all(:created_at => Time.now - 3.months)
+        @user.touch(:created_at)
+        expect(@user.reload.created_at.in_time_zone('GMT').to_date).to eq(Time.now.in_time_zone('GMT').to_date)
+      end
+    end
+
+    describe '#pluck' do
+      before { User.using(:brazil).create!(:name => 'User1') }
+
+      it 'should works from scope proxy' do
+        names = User.using(:brazil).pluck(:name)
+        expect(names).to eq(['User1'])
+        expect(User.using(:master).pluck(:name)).to eq([])
+      end
+    end
+
+    it 'update_column' do
+      @user = User.using(:brazil).create!(:name => 'User1')
+      @user2 = User.using(:brazil).find(@user.id)
+      @user2.update_column(:name, 'Joaquim Shard Brazil')
+      expect(User.using(:brazil).find_by_name('Joaquim Shard Brazil')).not_to be_nil
+    end
+
+    it 'update' do
+      @user = User.using(:brazil).create!(:name => 'User1')
+      @user2 = User.using(:brazil).find(@user.id)
+      @user2.update(:name => 'Joaquim')
+      expect(User.using(:brazil).find_by_name('Joaquim')).not_to be_nil
+    end
+
+    it 'using update inside a block' do
+      Octoball.using(:brazil) do
+        @user = User.create!(:name => 'User1')
+        @user2 = User.find(@user.id)
+        @user2.update(:name => 'Joaquim')
+      end
+
+      expect(User.find_by_name('Joaquim')).to be_nil
+      expect(User.using(:brazil).find_by_name('Joaquim')).not_to be_nil
+    end
+
+    it 'update' do
+      @user = User.using(:brazil).create!(:name => 'User1')
+      @user2 = User.using(:brazil).find(@user.id)
+      @user2.update(:name => 'Joaquim')
+      expect(User.using(:brazil).find_by_name('Joaquim')).not_to be_nil
+    end
+
+    it 'as_json' do
+      ActiveRecord::Base.include_root_in_json = false
+
+      Octoball.using(:brazil) do
+        User.create!(:name => 'User1')
+      end
+
+      user = User.using(:brazil).where(:name => 'User1').first
+      expect(user.as_json(:except => [:created_at, :updated_at, :id])).to eq('admin' => nil, 'name' => 'User1', 'number' => nil)
+    end
+
+    describe 'transaction' do
+      context 'without assigning a database' do
+        it 'works as expected' do
+          _u = User.create!(:name => 'Thiago')
+
+          expect(User.using(:brazil).count).to eq(0)
+          expect(User.using(:master).count).to eq(1)
+
+          User.using(:brazil).transaction do
+            expect(User.find_by_name('Thiago')).to be_nil
+            User.create!(:name => 'Brazil')
+          end
+
+          expect(User.using(:brazil).count).to eq(1)
+          expect(User.using(:master).count).to eq(1)
+        end
+      end
+
+      context 'when assigning a database' do
+        it 'works as expected' do
+          klass = User.using(:brazil)
+
+          klass.transaction do
+            klass.create!(:name => 'Brazil')
+          end
+
+          expect(klass.find_by_name('Brazil')).to be_present
+        end
+      end
+    end
+
+    describe "#finder methods" do
+      before(:each) do
+        @user1 = User.using(:brazil).create!(:name => 'User1')
+        @user2 = User.using(:brazil).create!(:name => 'User2')
+        @user3 = User.using(:brazil).create!(:name => 'User3')
+      end
+
+      it "#find_each should work with a block" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user2, @user3])
+      end
+
+      it "#find_each should work with a where.not(...)" do
+        result_array = []
+
+        User.using(:brazil).where.not(:name => 'User2').find_each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user3])
+      end
+
+      it "#find_each should work as an enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_each.each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user2, @user3])
+      end
+
+      it "#find_each should work as a lazy enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_each.lazy.each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([@user1, @user2, @user3])
+      end
+
+      it "#find_in_batches should work with a block" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_in_batches(batch_size: 1) do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([[@user1], [@user2], [@user3]])
+      end
+
+      it "#find_in_batches should work as an enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_in_batches(batch_size: 1).each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([[@user1], [@user2], [@user3]])
+      end
+
+      it "#find_in_batches should work as a lazy enumerator" do
+        result_array = []
+
+        User.using(:brazil).where("name is not NULL").find_in_batches(batch_size: 1).lazy.each do |user|
+          result_array << user
+        end
+
+        expect(result_array).to eq([[@user1], [@user2], [@user3]])
+      end
+    end
+
+    describe 'deleting a record' do
+      before(:each) do
+        @user = User.using(:brazil).create!(:name => 'User1')
+        @user2 = User.using(:brazil).find(@user.id)
+      end
+
+      it 'delete' do
+        @user2.delete
+        expect { User.using(:brazil).find(@user2.id) }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+
+      it "delete within block shouldn't lose shard" do
+        Octoball.using(:brazil) do
+          @user2.delete
+          @user3 = User.create(:name => 'User3')
+
+          expect(User.connection.current_shard).to eq(:brazil)
+          expect(User.find(@user3.id)).to eq(@user3)
+        end
+      end
+
+      it 'destroy' do
+        @user2.destroy
+        expect { User.using(:brazil).find(@user2.id) }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+
+      it "destroy within block shouldn't lose shard" do
+        Octoball.using(:brazil) do
+          @user2.destroy
+          @user3 = User.create(:name => 'User3')
+
+          expect(User.connection.current_shard).to eq(:brazil)
+          expect(User.find(@user3.id)).to eq(@user3)
+        end
+      end
+    end
+  end
+
+  describe 'custom connection' do
+    context 'by default' do
+      it 'with plain call should use custom connection' do
+        expect(CustomConnection.connection.current_database).to eq('octoball_shard_2')
+      end
+
+      it 'should use model-specific shard' do
+        expect(CustomConnection.using(:custom_shard).connection.current_database).to eq('octoball_shard_3')
+      end
+
+      it 'should use model-specific shard by Octoball.using block' do
+        Octoball.using(:custom_shard) do
+          expect(CustomConnection.connection.current_database).to eq('octoball_shard_3')
+        end
+      end
+
+      it 'should save to correct shard' do
+        expect { CustomConnection.create(:value => 'custom value') }.to change {
+          CustomConnection
+            .connection
+            .execute("select count(*) as ct from custom where value = 'custom value'")
+            .to_a.first.first
+        }.by 1
+      end
+    end
+
+    describe 'clear_active_connections!' do
+      it 'should not leak connection' do
+        CustomConnection.create(:value => 'custom value')
+
+        # This is what Rails, Sidekiq etc call--this normally handles all connection pools in the app
+        expect { ActiveRecord::Base.clear_active_connections! }
+          .to change { CustomConnection.connection_pool.active_connection? }
+
+        expect(CustomConnection.connection_pool.active_connection?).to be_falsey
+      end
+    end
+  end
+
+  describe 'when using set_table_name' do
+    it 'should work correctly' do
+      Bacon.using(:brazil).create!(:name => 'YUMMMYYYY')
+    end
+
+    it 'should work correctly with a block' do
+      Cheese.using(:brazil).create!(:name => 'YUMMMYYYY')
+    end
+  end
+
+  describe 'when using table_name=' do
+    it 'should work correctly' do
+      Ham.using(:brazil).create!(:name => 'YUMMMYYYY')
+    end
+  end
+
+  describe 'when you have joins/include' do
+    before(:each) do
+      @client1 = Client.using(:brazil).create(:name => 'Thiago')
+
+      Octoball.using(:canada) do
+        @client2 = Client.create(:name => 'Mike')
+        @client3 = Client.create(:name => 'Joao')
+        @item1 = Item.create(:client => @client2, :name => 'Item 1')
+        @item2 = Item.create(:client => @client2, :name => 'Item 2')
+        @item3 = Item.create(:client => @client3, :name => 'Item 3')
+        @part1 = Part.create(:item => @item1, :name => 'Part 1')
+        @part2 = Part.create(:item => @item1, :name => 'Part 2')
+        @part3 = Part.create(:item => @item2, :name => 'Part 3')
+      end
+
+      @item4 = Item.using(:brazil).create(:client => @client1, :name => 'Item 4')
+    end
+
+    it 'should work using the rails 3.x syntax' do
+      items = Item.using(:canada).joins(:client).where("clients.id = #{@client2.id}").all
+      expect(items).to eq([@item1, @item2])
+    end
+
+    it 'should work for include also, rails 3.x syntax' do
+      items = Item.using(:canada).includes(:client).where(:clients => { :id => @client2.id }).all
+      expect(items).to eq([@item1, @item2])
+    end
+  end
+
+  describe 'ActiveRecord::Base Validations' do
+    it 'should work correctly when using validations' do
+      @key = Keyboard.create!(:name => 'Key')
+      expect { Keyboard.using(:brazil).create!(:name => 'Key') }.not_to raise_error
+      expect { Keyboard.create!(:name => 'Key') }.to raise_error(ActiveRecord::RecordInvalid)
+    end
+
+    it 'should work correctly when using validations with using syntax' do
+      @key = Keyboard.using(:brazil).create!(:name => 'Key')
+      expect { Keyboard.create!(:name => 'Key') }.not_to raise_error
+      expect { Keyboard.using(:brazil).create!(:name => 'Key') }
+        .to raise_error(ActiveRecord::RecordInvalid)
+    end
+  end
+end