activerecord-turntable 3.0.0.alpha3 → 3.0.0

data/spec/active_record/turntable/connection_proxy_spec.rb

@@ -1,252 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::ConnectionProxy do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  context "When initialized" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-    end
-
-    let(:cluster) { ActiveRecord::Turntable::Cluster.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
-    subject { ActiveRecord::Turntable::ConnectionProxy.new(User, cluster) }
-
-    its(:master_connection) { is_expected.to eql(ActiveRecord::Base.connection) }
-  end
-
-  context "User insert with id" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-    end
-
-    it "should be saved to user_shard_1 with id = 1" do
-      user = User.new
-      user.id = 1
-      expect {
-        user.save!
-      }.not_to raise_error
-    end
-
-    it "should be saved to user_shard_2 with id = 30000" do
-      user = User.new
-      user.id = 30000
-      expect {
-        user.save!
-      }.not_to raise_error
-    end
-
-    it "should be saved to user_shard_2 with id = 30000 with SQL injection attack" do
-      user = User.new
-      user.id = 30000
-      user.nickname = "hogehgoge'00"
-      expect {
-        user.save!
-      }.not_to raise_error
-      user.reload
-    end
-
-    it "should should be saved the same string when includes escaped string" do
-      user = User.new
-      user.id = 30000
-      user.nickname = "hoge@\n@\\@@\\nhoge\\\nhoge\\n"
-      user.save!
-      user.reload
-      expect(user.nickname).to eq("hoge@\n@\\@@\\nhoge\\\nhoge\\n")
-    end
-  end
-
-  context "When have no users" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-    end
-
-    it "User.#count should be zero" do
-      expect(User.count).to be_zero
-    end
-
-    it "User.all should have no item" do
-      expect(User.all.to_a).to have(0).items
-    end
-  end
-
-  context "When have 2 Users in different shards" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.save!
-    end
-
-    it "should be saved to user_shard_1 with id = 1" do
-      @user1.nickname = "foobar"
-      expect {
-        @user1.save!
-      }.not_to raise_error
-    end
-
-    it "should be saved to user_shard_2 with id = 30000" do
-      @user2.nickname = "hogehoge"
-      expect {
-        @user2.save!
-      }.not_to raise_error
-    end
-
-    it "User.where('id IN (1, 30000)') returns 2 record" do
-      expect(User.where(id: [1, 30000]).all.size).to eq(2)
-    end
-
-    it "count should be 2" do
-      expect(User.count).to eq(2)
-    end
-
-    it "User.all returns 2 User object" do
-      expect(User.all.size).to eq(2)
-    end
-  end
-
-  context "When calling with_all" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.nickname = "user1"
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.nickname = "user2"
-      @user2.save!
-    end
-
-    context "do; User.count; end" do
-      subject {
-        User.connection.with_all do
-          User.count
-        end
-      }
-      it { is_expected.to have(3).items }
-
-      it "returns User.count of each shards" do
-        expect(subject[0]).to eq(1)
-        expect(subject[1]).to eq(1)
-        expect(subject[2]).to eq(0)
-      end
-    end
-
-    context "call with true" do
-      context "block raises error" do
-        subject {
-          User.connection.with_all(true) do
-            raise "Unko Error"
-          end
-        }
-        it { expect { subject }.not_to raise_error }
-        it { is_expected.to have(3).items }
-        it "collection " do
-          subject.each do |s|
-            expect(s).to be_instance_of(RuntimeError)
-          end
-        end
-      end
-    end
-  end
-
-  context "When calling exists? with shard_key" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.nickname = "user1"
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.nickname = "user2"
-      @user2.save!
-    end
-
-    subject { User.exists?(id: 1) }
-    it { is_expected.to be_truthy }
-  end
-
-  context "When calling exists? with non-existed shard_key" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.nickname = "user1"
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.nickname = "user2"
-      @user2.save!
-    end
-
-    subject { User.exists?(id: 3) }
-    it { is_expected.to be_falsey }
-  end
-
-  context "When calling exists? with non shard_key" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.nickname = "user1"
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.nickname = "user2"
-      @user2.save!
-    end
-
-    subject { User.exists?(nickname: "user2") }
-    it { is_expected.to be_truthy }
-  end
-
-  context "When calling exists? with non-existed non shard_key" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.nickname = "user1"
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.nickname = "user2"
-      @user2.save!
-    end
-
-    subject { User.exists?(nickname: "user999") }
-    it { is_expected.to be_falsey }
-  end
-
-  context "#table_exists?" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      @user1 = User.new
-      @user1.id = 1
-      @user1.nickname = "user1"
-      @user1.save!
-      @user2 = User.new
-      @user2.id = 30000
-      @user2.nickname = "user2"
-      @user2.save!
-    end
-
-    subject { User.connection.table_exists?(:users) }
-    it { is_expected.to be_truthy }
-  end
-end

data/spec/active_record/turntable/finder_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe "ActiveRecord::FinderMethods" do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  context "User insert with id" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-      user
-    end
-
-    let(:user) {
-      u = User.new
-      u.id = 1
-      u.save
-      u
-    }
-
-    describe "User#find" do
-      context "With existing users.id" do
-        subject { User.find(1) }
-
-        it "#find should be returns user" do
-          is_expected.to eq(user)
-        end
-      end
-
-      context "With users.id not existing" do
-        subject { User.find(2) }
-
-        it "#find should raise error" do
-          expect { subject }.to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/active_record/turntable/mixer/fader_spec.rb

@@ -1,4 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Mixer::Fader do
-end

data/spec/active_record/turntable/mixer_spec.rb

@@ -1,112 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Mixer do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  before do
-    establish_connection_to(:test)
-    truncate_shard
-    @cluster = ActiveRecord::Turntable::Cluster.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster])
-    @connection_proxy = ActiveRecord::Turntable::ConnectionProxy.new(User, @cluster)
-  end
-
-  context "When initialized" do
-    before do
-      @mixer = ActiveRecord::Turntable::Mixer.new(@connection_proxy)
-    end
-
-    context "For Insert SQL" do
-      context "When call divide_insert_values with Single INSERT and shard_key 'id'" do
-        subject {
-          tree = SQLTree["INSERT INTO `users` (id, hp, mp) VALUES (1, 10, 10)"]
-          @mixer.send(:divide_insert_values, tree, "id")
-        }
-
-        it { is_expected.to be_instance_of(Hash) }
-        it { is_expected.to have_key(1) }
-        it { expect([1]).to have(1).item }
-      end
-
-      context "When call divide_insert_values with Bulk INSERT and shard_key 'id'" do
-        subject {
-          tree = SQLTree["INSERT INTO `users` (id, hp, mp) VALUES (1, 10, 10), (2,10,10), (3,10,10)"]
-          @mixer.send(:divide_insert_values, tree, "id")
-        }
-
-        it { is_expected.to be_instance_of(Hash) }
-        it { is_expected.to have_key(3) }
-        it { expect([1]).to have(1).item }
-        it { expect([2]).to have(1).item }
-        it { expect([3]).to have(1).item }
-      end
-    end
-
-    context "For Update SQL" do
-      context "When call find_shard_keys with eql shardkey condition" do
-        subject {
-          tree = SQLTree["UPDATE `users` SET `users`.`hp` = 20 WHERE `users`.`id` = 1"]
-          @mixer.find_shard_keys(tree.where, "users", "id")
-        }
-
-        it { is_expected.to be_instance_of Array }
-        it { is_expected.to eq([1]) }
-      end
-    end
-
-    context "For Delete SQL" do
-      context "When call find_shard_keys with eql shardkey condition" do
-        subject {
-          tree = SQLTree["DELETE FROM `users` WHERE `users`.`id` = 1"]
-          @mixer.find_shard_keys(tree.where, "users", "id")
-        }
-
-        it { is_expected.to be_instance_of Array }
-        it { is_expected.to eq([1]) }
-      end
-    end
-
-    context "For Select SQL" do
-      context "When call find_shard_keys with eql shardkey condition" do
-        subject {
-          tree = SQLTree["SELECT * FROM `users` WHERE `users`.`id` = 1"]
-          @mixer.find_shard_keys(tree.where, "users", "id")
-        }
-
-        it { is_expected.to be_instance_of Array }
-        it { is_expected.to eq([1]) }
-      end
-
-      context "When call find_shard_keys with shardkey collection condition" do
-        subject {
-          tree = SQLTree["SELECT * FROM `users` WHERE `users`.`id` IN (1,2,3,4,5)"]
-          @mixer.find_shard_keys(tree.where, "users", "id")
-        }
-
-        it { is_expected.to be_instance_of Array }
-        it { is_expected.to eq([1, 2, 3, 4, 5]) }
-      end
-
-      context "When call find_shard_keys with not determine shardkey condition" do
-        subject {
-          tree = SQLTree["SELECT * FROM `users` WHERE `users`.`id` = 1 OR 1"]
-          @mixer.find_shard_keys(tree.where, "users", "id")
-        }
-
-        it { is_expected.to be_instance_of Array }
-        it { is_expected.to eq([]) }
-      end
-
-      context "When call find_shard_keys with except table definition SQL" do
-        subject {
-          tree = SQLTree["SELECT * FROM `users` WHERE id = 10"]
-          @mixer.find_shard_keys(tree.where, "users", "id")
-        }
-
-        it { is_expected.to be_instance_of Array }
-        it { is_expected.to eq([]) }
-      end
-    end
-  end
-end

data/spec/active_record/turntable/query_cache_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-require "active_support/executor"
-
-describe ActiveRecord::Turntable::QueryCache do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  before do
-    establish_connection_to(:test)
-    truncate_shard
-  end
-
-  let(:mw) {
-    executor = Class.new(ActiveSupport::Executor)
-    ActiveRecord::Turntable::QueryCache.install_executor_hooks executor
-    lambda { |env|
-      executor.wrap {
-        [200, {}, nil]
-      }
-    }
-  }
-  subject { mw.call({}) }
-
-  it "should returns 200 response" do
-    expect(subject.first).to eq(200)
-  end
-end

data/spec/active_record/turntable/sequencer/api_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Sequencer::Api do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
-  end
-
-  let(:sequencer) { ActiveRecord::Turntable::Sequencer::Api.new(klass, options) }
-  let(:sequence_name) { "hogefuga" }
-  let(:klass) { Class.new }
-  let(:api_host) { "example.example" }
-  let(:api_port) { 80 }
-  let(:options) { { api_host: api_host, api_port: api_port }.with_indifferent_access }
-  let(:api_response) { 1024 }
-
-  let(:next_sequence_uri) { "http://#{api_host}/sequences/#{sequence_name}/new" }
-  let(:current_sequence_uri) { "http://#{api_host}/sequences/#{sequence_name}" }
-
-  describe "#next_sequence_value" do
-    before do
-      stub_request(:get, next_sequence_uri).to_return(body: api_response.to_s)
-    end
-
-    subject { sequencer.next_sequence_value(sequence_name) }
-    it { is_expected.to be_kind_of(Integer) }
-    it { is_expected.to eq api_response }
-  end
-
-  describe "#current_sequence_value" do
-    before do
-      stub_request(:get, current_sequence_uri).to_return(body: api_response.to_s)
-    end
-
-    subject { sequencer.current_sequence_value(sequence_name) }
-    it { is_expected.to be_kind_of(Integer) }
-    it { is_expected.to eq api_response }
-  end
-end

data/spec/active_record/turntable/sequencer/barrage_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Sequencer::Barrage do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
-  end
-
-  let(:sequencer) { ActiveRecord::Turntable::Sequencer::Barrage.new(klass, options) }
-  let(:sequence_name) { "hogefuga" }
-  let(:options) { { options: { generators: [{ name: "sequence", length: 16 }] } }.with_indifferent_access }
-  let(:klass) { Class.new }
-
-  describe "#next_sequence_value" do
-    subject { sequencer.next_sequence_value("hogefuga") }
-    it { is_expected.to be_kind_of(Integer) }
-  end
-
-  describe "#current_sequence_value" do
-    subject { sequencer.current_sequence_value("hogefuga") }
-    it { is_expected.to be_kind_of(Integer) }
-  end
-end

data/spec/active_record/turntable/sequencer/mysql_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Sequencer::Mysql do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
-  end
-
-  let(:sequencer) { ActiveRecord::Turntable::Sequencer::Mysql.new(klass, options) }
-  let(:sequence_name) { "users_id_seq" }
-  let(:options) { {} }
-  let(:klass) { User }
-
-  describe "#next_sequence_value" do
-    subject { sequencer.next_sequence_value(sequence_name) }
-    it { is_expected.to be_kind_of(Integer) }
-  end
-
-  describe "#current_sequence_value" do
-    subject { sequencer.current_sequence_value(sequence_name) }
-    it { is_expected.to be_kind_of(Integer) }
-  end
-end

data/spec/active_record/turntable/shard_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Shard do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  context "When initialized" do
-    before do
-      establish_connection_to(:test)
-      truncate_shard
-    end
-
-    subject {
-      ActiveRecord::Turntable::Shard.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0])
-    }
-    its(:name) { should == ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection] }
-    its(:connection) { should be_instance_of(ActiveRecord::ConnectionAdapters::Mysql2Adapter) }
-    its(:connection_pool) { should be_instance_of(ActiveRecord::ConnectionAdapters::ConnectionPool) }
-  end
-end

data/spec/active_record/turntable/sql_tree_patch_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "active_record/turntable/sql_tree_patch"
-
-describe SQLTree do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  context "Insert query with binary string" do
-    subject { SQLTree["INSERT INTO `hogehoge` (`name`) VALUES (x'deadbeef')"] }
-    it { expect { subject }.to_not raise_error }
-    its(:to_sql) { is_expected.to include("x'deadbeef") }
-  end
-
-  context "Select query with index hint" do
-    ["FORCE INDEX", "IGNORE INDEX", "USE INDEX"].each do |hint|
-      context hint do
-        subject { SQLTree["SELECT * FROM table #{hint} (`foo`) WHERE field = 'value'"] }
-        it { expect { subject }.to_not raise_error }
-        its(:to_sql) { is_expected.to include("#{hint} (`foo`)") }
-      end
-    end
-  end
-
-  context "Select query without index hint" do
-    subject { SQLTree["SELECT * FROM table WHERE field = 'value'"] }
-    it { expect { subject }.to_not raise_error }
-  end
-
-  context "Delete query" do
-    subject { SQLTree["DELETE FROM table"] }
-    it { expect { subject }.to_not raise_error }
-  end
-end

data/spec/active_record/turntable/transaction_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe "transaction" do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  before(:each) do
-    establish_connection_to(:test)
-    truncate_shard
-  end
-  let(:clusters) { ActiveRecord::Base.turntable_clusters }
-
-  describe "all_cluster_transaction" do
-    let(:all_clusters) { clusters.values }
-    let(:shards) { all_clusters.flat_map { |c| c.shards.values } }
-
-    it "all shards should begin transaction" do
-      User.all_cluster_transaction {
-        expect(shards.map(&:connection).map(&:open_transactions)).to all(be == 1)
-      }
-    end
-  end
-
-  describe "cluster_transaction" do
-    let(:cluster) { clusters[:user_cluster] }
-    let(:shards) { cluster.shards.values }
-
-    it "all shards in the cluster should begin transaction" do
-      User.user_cluster_transaction {
-        expect(shards.map(&:connection).map(&:open_transactions)).to all(be == 1)
-      }
-    end
-  end
-end

data/spec/active_record/turntable_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable do
-  before(:all) do
-    ActiveRecord::Base.include(ActiveRecord::Turntable)
-  end
-
-  context "#config_file" do
-    it "should return Rails.root/config/turntable.yml default" do
-      unless defined?(::Rails); class ::Rails; end; end
-      allow(Rails).to receive(:root) { "/path/to/rails_root" }
-      ActiveRecord::Base.turntable_config_file = nil
-      expect(ActiveRecord::Base.turntable_config_file).to eq("/path/to/rails_root/config/turntable.yml")
-    end
-  end
-
-  context "#config_file=" do
-    it "should set config_file" do
-      ActiveRecord::Base.include(ActiveRecord::Turntable)
-      filename = "hogefuga"
-      ActiveRecord::Base.turntable_config_file = filename
-      expect(ActiveRecord::Base.turntable_config_file).to eq(filename)
-    end
-  end
-
-  context "#config" do
-    subject { ActiveRecord::Base.turntable_config }
-    it { is_expected.to be_instance_of(ActiveRecord::Turntable::Config) }
-  end
-end

data/spec/config/database.yml

@@ -1,35 +0,0 @@
-default: &default
-  adapter: mysql2
-  username: root
-  password:
-  host: localhost
-  port: 3306
-  encoding: utf8
-  database: turntable_test
-
-test:
-  <<: *default
-  database: turntable_test
-  seq:
-    user_seq:
-      <<: *default
-      database: turntable_user_seq_test
-  shards:
-    user_shard_1:
-      <<: *default
-      database: turntable_user_shard_1_test
-    user_shard_2:
-      <<: *default
-      database: turntable_user_shard_2_test
-    user_shard_3:
-      <<: *default
-      database: turntable_user_shard_3_test
-    user_shard_4:
-      <<: *default
-      database: turntable_user_shard_4_test
-    user_shard_5:
-      <<: *default
-      database: turntable_user_shard_5_test
-    user_shard_6:
-      <<: *default
-      database: turntable_user_shard_6_test