activerecord-turntable 3.0.0.alpha3 → 3.0.0

data/spec/active_record/turntable/active_record_ext/persistence_spec.rb

@@ -1,211 +0,0 @@
-require "spec_helper"
-require "logger"
-
-describe ActiveRecord::Turntable::ActiveRecordExt::Persistence 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
-
-  around(:each) do |example|
-    old = ActiveRecord::Base.logger
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
-    example.run
-    ActiveRecord::Base.logger = old
-  end
-
-  let(:user) {
-    u = User.new({ nickname: "foobar" })
-    u.id = 1
-    u.updated_at = Time.current - 1.day
-    u.save
-    u
-  }
-  let(:user_status){
-    stat = user.create_user_status(hp: 10, mp: 10)
-    stat.updated_at = Time.current - 1.day
-    stat.save
-    stat
-  }
-  let(:card){
-    Card.create!(name: "foobar")
-  }
-  let(:cards_user){
-    user.cards_users.create(card: card)
-  }
-  context "When creating record" do
-    context "with blob column" do
-      let(:blob_value) { "\123\123\123" }
-      let(:user) {
-        u = User.new(nickname: "x", blob: blob_value)
-        u.id = 1
-        u.save
-        u
-      }
-      subject { user }
-      its(:blob) { is_expected.to eq(user.reload.blob) }
-    end
-  end
-
-  context "When the model is sharded by surrogate key" do
-    it "should not changed from normal operation when updating" do
-      user.nickname = "fizzbuzz"
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-      expect {
-        user.save!
-      }.to_not raise_error
-      expect(strio.string).to match(/WHERE `users`\.`id` = #{user.id}[^\s]*$/)
-    end
-
-    it "should be saved to target_shard" do
-      expect(user).to be_saved_to(user.turntable_shard)
-    end
-
-    it "should change updated_at when updating" do
-      user.nickname = "fizzbuzz"
-
-      expect { user.save! }.to change(user, :updated_at)
-    end
-
-    it "should not changed from normal operation when destroying" do
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-      expect { user.destroy }.to_not raise_error
-      expect(strio.string).to match(/WHERE `users`\.`id` = #{user.id}[^\s]*$/)
-    end
-  end
-
-  context "When called Callbacks" do
-    before do
-      class ::User
-        after_destroy :on_destroy
-        after_save    :on_update
-
-        def on_destroy
-        end
-
-        def on_update
-        end
-      end
-    end
-
-    context "on update once" do
-      it "callback should be called once" do
-        expect(user).to receive(:on_update).once
-        user.save
-      end
-    end
-    context "on destroy once" do
-      it "callback should be called once" do
-        expect(user).to receive(:on_destroy).once
-        user.destroy
-      end
-    end
-  end
-
-  context "When the model is sharded by other key" do
-    it "should send shard_key condition when updating" do
-      cards_user.num = 10
-
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-      expect {
-        cards_user.save!
-      }.to_not raise_error
-      expect(strio.string).to match(/`cards_users`\.`user_id` = #{cards_user.user_id}[^\s]*($|\s)/)
-    end
-
-    it "should change updated_at when updating" do
-      cards_user
-
-      Timecop.travel(1.day.from_now) do
-        expect {
-          cards_user.num = 2
-          cards_user.save!
-        }.to change(cards_user, :updated_at)
-      end
-    end
-
-    it "should send shard_key condition when destroying" do
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-      expect {
-        cards_user.destroy
-      }.to_not raise_error
-      expect(strio.string).to match(/`cards_users`\.`user_id` = #{cards_user.user_id}[^\s]*($|\s)/)
-    end
-
-    it "should warn when creating without shard_key" do
-      skip "doesn't need to implemented soon"
-    end
-
-    it "should execute one query when reloading" do
-      user; cards_user
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-
-      expect { cards_user.reload }.to_not raise_error
-
-      expect(strio.string.split("\n").select { |stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }).to have(1).items
-    end
-
-    it "should execute one query when touching" do
-      user; cards_user
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-
-      expect { cards_user.touch }.to_not raise_error
-      expect(strio.string.split("\n").select { |stmt| stmt =~ /UPDATE/ and stmt !~ /Turntable/ }).to have(1).items
-    end
-
-    it "should execute one query when locking" do
-      user; cards_user
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-
-      expect { cards_user.lock! }.to_not raise_error
-      expect(strio.string.split("\n").select { |stmt| stmt =~ /SELECT/ and stmt !~ /Turntable/ }).to have(1).items
-    end
-
-    it "should execute one query when update_columns" do
-      user; cards_user
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-
-      expect { cards_user.update_columns(num: 10) }.to_not raise_error
-      expect(strio.string.split("\n").select { |stmt| stmt =~ /UPDATE/ and stmt !~ /Turntable/ }).to have(1).items
-    end
-  end
-
-  context "When the model is not sharded" do
-    it "should not send shard_key condition when updating" do
-      card.name = "barbaz"
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-      expect {
-        card.save!
-      }.to_not raise_error
-      expect(strio.string).to match(/WHERE `cards`\.`id` = #{card.id}[^\s]*$/)
-    end
-
-    it "should not send shard_key condition when destroying" do
-      strio = StringIO.new
-      ActiveRecord::Base.logger = Logger.new(strio)
-      expect {
-        card.destroy
-      }.to_not raise_error
-      expect(strio.string).to match(/WHERE `cards`\.`id` = #{card.id}[^\s]*$/)
-    end
-  end
-
-  context "When call reload" do
-    subject { cards_user.reload }
-    it { is_expected.to be_instance_of(CardsUser) }
-    it { is_expected.to eq(cards_user) }
-  end
-end

data/spec/active_record/turntable/active_record_ext/sequencer_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::ActiveRecordExt::Sequencer 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
-
-  context "With sequencer enabled model" do
-    subject { User }
-    its(:sequence_name) { is_expected.to_not be_nil }
-  end
-
-  context "With sequencer disabled model" do
-    subject { Card }
-    its(:sequence_name) { is_expected.to be_nil }
-  end
-end

data/spec/active_record/turntable/active_record_ext/test_fixtures_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-require "active_record"
-require "active_record/turntable/active_record_ext/fixtures"
-
-describe ActiveRecord::TestFixtures 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(:fixtures_root) { File.join(File.dirname(__FILE__), "../../../fixtures") }
-  let(:fixture_file) { File.join(fixtures_root, "cards.yml") }
-  let(:test_fixture_class) { Class.new(ActiveSupport::TestCase) { include ActiveRecord::TestFixtures } }
-  let(:test_fixture) { test_fixture_class.new("test") }
-  let(:cards) { YAML.load(ERB.new(IO.read(fixture_file)).result) }
-
-  before do
-    test_fixture_class.fixture_path = fixtures_root
-  end
-
-  describe "#setup_fixtures" do
-    after do
-      test_fixture.teardown_fixtures
-    end
-
-    subject { test_fixture.setup_fixtures }
-    it { expect { subject }.not_to raise_error }
-  end
-end

data/spec/active_record/turntable/algorithm/modulo_algorithm_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Algorithm::ModuloAlgorithm do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
-  end
-
-  context "When initialized" do
-    before do
-      @alg = ActiveRecord::Turntable::Algorithm::ModuloAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:mod_cluster])
-    end
-
-    context "#calculate with 1" do
-      subject { @alg.calculate(1) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][1][:connection]) }
-    end
-
-    context "#calculate with 3" do
-      subject { @alg.calculate(3) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][3][:connection]) }
-    end
-
-    context "#calculate with 5" do
-      subject { @alg.calculate(5) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
-    end
-
-    context "#calculate with a value that is not a number" do
-      it "raises ActiveRecord::Turntable::CannotSpecifyShardError" do
-        expect { @alg.calculate("a") }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError)
-      end
-    end
-  end
-end

data/spec/active_record/turntable/algorithm/range_algorithm_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Algorithm::RangeAlgorithm do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
-  end
-
-  context "When initialized" do
-    before do
-      @alg = ActiveRecord::Turntable::Algorithm::RangeAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster])
-    end
-
-    context "#calculate with 1" do
-      subject { @alg.calculate(1) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
-    end
-
-    context "#calculate with 19999" do
-      subject { @alg.calculate(19999) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
-    end
-
-    context "#calculate with 20000" do
-      subject { @alg.calculate(20000) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][1][:connection]) }
-    end
-
-    context "#calculate with 10000000" do
-      it "raises ActiveRecord::Turntable::CannotSpecifyShardError" do
-        expect { @alg.calculate(10_000_000) }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError)
-      end
-    end
-  end
-end

data/spec/active_record/turntable/algorithm/range_bsearch_algorithm_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../../config/turntable.yml"))
-  end
-
-  context "When initialized" do
-    before do
-      @alg = ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster])
-    end
-
-    context "#calculate with 1" do
-      subject { @alg.calculate(1) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
-    end
-
-    context "#calculate with 19999" do
-      subject { @alg.calculate(19999) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][0][:connection]) }
-    end
-
-    context "#calculate with 20000" do
-      subject { @alg.calculate(20000) }
-      it { is_expected.to eq(ActiveRecord::Base.turntable_config[:clusters][:user_cluster][:shards][1][:connection]) }
-    end
-
-    context "#calculate with 10000000" do
-      it "raises ActiveRecord::Turntable::CannotSpecifyShardError" do
-        expect { @alg.calculate(10_000_000) }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError)
-      end
-    end
-  end
-end

data/spec/active_record/turntable/algorithm_spec.rb

@@ -1,100 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Algorithm do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  describe ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm do
-    let(:algorithm) { ActiveRecord::Turntable::Algorithm::RangeBsearchAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
-    context "#calculate" do
-      it "called with 1 returns user_shard_1" do
-        expect(algorithm.calculate(1)).to eq("user_shard_1")
-      end
-
-      it "called with 19999 returns user_shard_1" do
-        expect(algorithm.calculate(19999)).to eq("user_shard_1")
-      end
-
-      it "called with 20000 returns user_shard_2" do
-        expect(algorithm.calculate(20000)).to eq("user_shard_2")
-      end
-
-      it "called with 100000 returns user_shard_3" do
-        expect(algorithm.calculate(100000)).to eq("user_shard_3")
-      end
-    end
-
-    context "#calculate_used_shards_with_weight" do
-      it "called with 10 returns 1 item" do
-        expect(algorithm.calculate_used_shards_with_weight(10)).to have(1).items
-      end
-
-      it "called with 10 returns {\"user_shard_1\" => 10}" do
-        expect(algorithm.calculate_used_shards_with_weight(10)).to eq({ "user_shard_1" => 10 })
-      end
-
-      it "called with 65000 returns 2 items" do
-        expect(algorithm.calculate_used_shards_with_weight(65000)).to have(2).items
-      end
-
-      it "called with 65000 returns {\"user_shard_1\" => 39999, \"user_shard_2\" => 25001}" do
-        expect(algorithm.calculate_used_shards_with_weight(65000)).to eq({ "user_shard_1" => 39999, "user_shard_2" => 25001 })
-      end
-    end
-  end
-
-  describe ActiveRecord::Turntable::Algorithm::RangeAlgorithm do
-    let(:algorithm) { ActiveRecord::Turntable::Algorithm::RangeAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:user_cluster]) }
-    context "#calculate" do
-      it "called with 1 returns user_shard_1" do
-        expect(algorithm.calculate(1)).to eq("user_shard_1")
-      end
-
-      it "called with 19999 returns user_shard_1" do
-        expect(algorithm.calculate(19999)).to eq("user_shard_1")
-      end
-
-      it "called with 20000 returns user_shard_2" do
-        expect(algorithm.calculate(20000)).to eq("user_shard_2")
-      end
-
-      it "called with 100000 returns user_shard_3" do
-        expect(algorithm.calculate(100000)).to eq("user_shard_3")
-      end
-    end
-
-    context "#calculate_used_shards_with_weight" do
-      it "called with 10 returns 1 item" do
-        expect(algorithm.calculate_used_shards_with_weight(10)).to have(1).items
-      end
-
-      it "called with 10 returns {\"user_shard_1\" => 10}" do
-        expect(algorithm.calculate_used_shards_with_weight(10)).to eq({ "user_shard_1" => 10 })
-      end
-
-      it "called with 65000 returns 2 items" do
-        expect(algorithm.calculate_used_shards_with_weight(65000)).to have(2).items
-      end
-
-      it "called with 65000 returns {\"user_shard_1\" => 39999, \"user_shard_2\" => 25001}" do
-        expect(algorithm.calculate_used_shards_with_weight(65000)).to eq({ "user_shard_1" => 39999, "user_shard_2" => 25001 })
-      end
-    end
-  end
-
-  describe ActiveRecord::Turntable::Algorithm::ModuloAlgorithm do
-    let(:algorithm) { ActiveRecord::Turntable::Algorithm::ModuloAlgorithm.new(ActiveRecord::Base.turntable_config[:clusters][:mod_cluster]) }
-    context "#calculate" do
-      it "called with 1 return user_shard_2" do
-        expect(algorithm.calculate(1)).to eq("user_shard_2")
-      end
-      it "called with 3 return user_shard_2" do
-        expect(algorithm.calculate(3)).to eq("user_shard_2")
-      end
-      it "called with 5 return user_shard_1" do
-        expect(algorithm.calculate(5)).to eq("user_shard_1")
-      end
-    end
-  end
-end

data/spec/active_record/turntable/base_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Base do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  context "When installed to ActiveRecord::Base" do
-    it "ActiveRecord::Base respond_to 'turntable'" do
-      expect(ActiveRecord::Base).to respond_to(:turntable)
-    end
-  end
-end

data/spec/active_record/turntable/cluster_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Cluster 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(:cluster_config) { ActiveRecord::Base.turntable_config[:clusters][:user_cluster] }
-  let(:cluster) { ActiveRecord::Turntable::Cluster.new(cluster_config) }
-  let(:mysql_mod_cluster_config) { ActiveRecord::Base.turntable_config[:clusters][:mysql_mod_cluster] }
-  let(:mysql_mod_cluster) { ActiveRecord::Turntable::Cluster.new(mysql_mod_cluster_config) }
-  let(:in_range_shard_key_value) { cluster_config[:shards].last[:less_than] - 1 }
-  let(:out_of_range_shard_key_value) { cluster_config[:shards].last[:less_than] }
-
-  context "When initialized" do
-    subject { cluster }
-
-    its(:shards) { should have(3).items }
-  end
-
-  context "When initialized mysql sequencer type cluster" do
-    subject { mysql_mod_cluster }
-
-    its(:shards) { should have(2).items }
-    its(:seq)    { is_expected.not_to be nil }
-  end
-
-  describe "#shard_for" do
-    subject { cluster.shard_for(value) }
-
-    context "with argument in shard range value" do
-      let(:value) { in_range_shard_key_value }
-      let(:expected_shard_name) { cluster_config[:shards].last[:connection] }
-
-      it { is_expected.to be_instance_of(ActiveRecord::Turntable::Shard) }
-      its(:name) { is_expected.to eq expected_shard_name }
-    end
-
-    context "with argument out of shard range value" do
-      let(:value) { out_of_range_shard_key_value }
-      it { expect { subject }.to raise_error(ActiveRecord::Turntable::CannotSpecifyShardError) }
-    end
-  end
-end

data/spec/active_record/turntable/config_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe ActiveRecord::Turntable::Config do
-  before(:all) do
-    reload_turntable!(File.join(File.dirname(__FILE__), "../../config/turntable.yml"))
-  end
-
-  subject { ActiveRecord::Turntable::Config }
-
-  it "has config hash" do
-    expect(subject.instance.instance_variable_get(:@config)).to be_an_kind_of(Hash)
-  end
-
-  it "has cluster setting" do
-    expect(subject[:clusters][:user_cluster]).to be_instance_of(ActiveSupport::HashWithIndifferentAccess)
-  end
-end