switchman 1.5.2 → 1.5.3

data/spec/lib/active_record/attribute_methods_spec.rb

@@ -1,122 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe AttributeMethods do
-      include RSpecHelper
-
-      describe "ids" do
-        it "should return id relative to the current shard" do
-          user = User.create!
-          expect(user.id).to be < Shard::IDS_PER_SHARD
-          expect(user.local_id).to be < Shard::IDS_PER_SHARD
-          expect(user.global_id).to be > Shard::IDS_PER_SHARD
-
-          @shard1.activate do
-            expect(user.id).to be > Shard::IDS_PER_SHARD
-            expect(user.local_id).to be < Shard::IDS_PER_SHARD
-            expect(user.global_id).to be > Shard::IDS_PER_SHARD
-          end
-        end
-
-        it "should return foreign keys relative to the current shard" do
-          appendage = Appendage.create!
-
-          # bypass the setter; we're going to test it in just a minute
-
-          # local id, should stay local
-          appendage.original_user_id = 6
-          expect(appendage.user_id).to eq 6
-
-          # (incorrect) self referencing global id; should come out as local
-          appendage.original_user_id = Shard.current.global_id_for(6)
-          expect(appendage.user_id).to eq 6
-
-          # global id referencing another shard; should come out unscathed
-          appendage.original_user_id = @shard1.global_id_for(6)
-          expect(appendage.user_id).to eq @shard1.global_id_for(6)
-
-          @shard1.activate do
-            # local id in another shard, should be global in this shard
-            appendage.original_user_id = 6
-            expect(appendage.user_id).to eq Shard.default.global_id_for(6)
-
-            # (incorrect) self referencing global id; should come out as global in this shard
-            appendage.original_user_id = Shard.default.global_id_for(6)
-            expect(appendage.user_id).to eq Shard.default.global_id_for(6)
-
-            # global id referencing this shard; should come out as a local id in this shard
-            appendage.original_user_id = @shard1.global_id_for(6)
-            expect(appendage.user_id).to eq 6
-
-            # global id from an unrelated shard; should stay global
-            appendage.original_user_id = @shard2.global_id_for(6)
-            expect(appendage.user_id).to eq @shard2.global_id_for(6)
-          end
-
-          # now that we trust the getters, try the setters
-
-          # local stays local
-          appendage.user_id = 6
-          expect(appendage.original_user_id).to eq 6
-          appendage.user_id = '6'
-          expect(appendage.original_user_id).to eq 6
-
-          # (incorrect) global id to this shard, should become local
-          appendage.user_id = Shard.current.global_id_for(6)
-          expect(appendage.original_user_id).to eq 6
-          appendage.user_id = Shard.current.global_id_for(6).to_s
-          expect(appendage.original_user_id).to eq 6
-
-          # global id from another shard, should stay global
-          appendage.user_id = @shard1.global_id_for(6)
-          expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
-          expect(appendage.local_user_id).to eq 6
-          appendage.user_id = @shard1.global_id_for(6).to_s
-          expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
-          expect(appendage.local_user_id).to eq 6
-
-          @shard1.activate do
-            # local to this shard becomes global
-            appendage.user_id = 6
-            expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
-            appendage.user_id = '6'
-            expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
-
-            # global id from original shard, should become local
-            appendage.user_id = Shard.default.global_id_for(6)
-            expect(appendage.original_user_id).to eq 6
-            appendage.user_id = Shard.default.global_id_for(6).to_s
-            expect(appendage.original_user_id).to eq 6
-
-            # global id from this shard, should stay global
-            appendage.user_id = Shard.current.global_id_for(6)
-            expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
-            appendage.user_id = Shard.current.global_id_for(6).to_s
-            expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
-
-            # global id from unrelated shard, should stay global
-            appendage.user_id = @shard2.global_id_for(6)
-            expect(appendage.original_user_id).to eq @shard2.global_id_for(6)
-            appendage.user_id = @shard2.global_id_for(6).to_s
-            expect(appendage.original_user_id).to eq @shard2.global_id_for(6)
-          end
-        end
-
-        it "should not choke on polymorphic associations that are missing their type" do
-          f = Feature.create!(owner: User.create!)
-          f = Feature.select(:owner_id).where(id: f).first
-          f.owner_id
-        end
-
-        it "gives a useful error if the association doesn't exist" do
-          u = User.new
-          expect { u.global_broken_id }.to raise_error do |error|
-            expect(error).to be_a(NoMethodError)
-            expect(error.to_s).to eq "undefined method `global_broken_id'; are you missing an association?"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/base_spec.rb

@@ -1,130 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe Base do
-      include RSpecHelper
-
-      describe "hash" do
-        it "should work with unsharded models" do
-          root = Root.create!
-          expect(root.hash).to eq root.id.hash
-        end
-      end
-
-      describe "to_param" do
-        it "should return nil if no id" do
-          user = User.new
-          expect(user.to_param).to be_nil
-        end
-
-        it "should return the id even if not persisted" do
-          user = User.new
-          user.id = 1
-          expect(user.to_param).to eq '1'
-        end
-
-        it "should return local id if in the current shard" do
-          user = User.create!
-          expect(user.to_param).to eq user.local_id.to_s
-          @shard1.activate do
-            user2 = User.create!
-            expect(user2.to_param).to eq user2.local_id.to_s
-          end
-        end
-
-        it "should return a short form global id if not in the current shard" do
-          user = nil
-          @shard1.activate do
-            user = User.create!
-          end
-          @shard2.activate do
-            expect(user.to_param).to eq "#{@shard1.id}~#{user.local_id}"
-          end
-        end
-
-        it "should use to_param in url helpers" do
-          helpers = ::Rails.application.routes.url_helpers
-          user = nil
-          appendage = nil
-
-          @shard1.activate do
-            user = User.create!
-            appendage = Appendage.create!
-
-            expect(helpers.user_path(user)).to eq "/users/#{user.local_id}"
-            expect(helpers.user_appendages_path(user)).to eq "/users/#{user.local_id}/appendages"
-            expect(helpers.user_appendage_path(user, appendage)).to eq "/users/#{user.local_id}/appendages/#{appendage.local_id}"
-            expect(helpers.user_test1_path(user)).to eq "/users/#{user.local_id}"
-            expect(helpers.user_test2_path(user)).to eq "/users/#{user.local_id}/test2"
-          end
-
-          @shard2.activate do
-            user_short_id = "#{@shard1.id}~#{user.local_id}"
-            appendage_short_id = "#{@shard1.id}~#{appendage.local_id}"
-
-            expect(helpers.user_path(user)).to eq "/users/#{user_short_id}"
-            expect(helpers.user_appendages_path(user)).to eq "/users/#{user_short_id}/appendages"
-            expect(helpers.user_appendage_path(user, appendage)).to eq "/users/#{user_short_id}/appendages/#{appendage_short_id}"
-            expect(helpers.user_test1_path(user)).to eq "/users/#{user_short_id}"
-            expect(helpers.user_test2_path(user)).to eq "/users/#{user_short_id}/test2"
-
-            appendage2 = Appendage.create!
-            expect(helpers.user_appendage_path(user, appendage2)).to eq "/users/#{user_short_id}/appendages/#{appendage2.local_id}"
-          end
-        end
-      end
-
-      describe "shard=" do
-        it "should adjust foreign ids when shard is changed" do
-          user = User.create!
-          appendage = Appendage.new
-          appendage.user_id = user.id
-          appendage.shard = @shard1
-          expect(appendage.attributes["user_id"]).to eq user.global_id
-        end
-      end
-
-      describe ".shard_category=" do
-        it "should set up connection pools correctly for a model on a different db in the default shard" do
-          skip "remove_connection working properly"
-          ::Rails.env.stubs(:test?).returns(false)
-          begin
-            config = { :adapter => 'sqlite3', :database => ':memory:', :something_unique_in_the_spec => true }
-            MirrorUser.establish_connection(config)
-
-            expect(MirrorUser.connection).not_to eq ::ActiveRecord::Base.connection
-            ::Shackles.activate(:slave) do
-              expect(MirrorUser.connection).not_to eq ::ActiveRecord::Base.connection
-            end
-          ensure
-            MirrorUser.remove_connection
-          end
-        end
-      end
-
-      describe ".unscoped" do
-        it "doesn't capture the shard permanently (block form)" do
-          @shard1.activate do
-            User.unscoped do
-              Shard.default.activate do
-                expect(User.all.shard_value).to eq Shard.default
-              end
-            end
-          end
-        end
-
-        it "doesn't capture the shard permanently" do
-          @shard1.activate do
-            scope = User.unscoped
-            scope.scoping do
-              Shard.default.activate do
-                expect(User.all.shard_value).to eq Shard.default
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_record/calculations_spec.rb

@@ -1,282 +0,0 @@
-require "spec_helper"
-
-module Switchman
-  module ActiveRecord
-    describe Calculations do
-      include RSpecHelper
-
-      describe "#pluck" do
-        before do
-          @shard1.activate do
-            @user1 = User.create!(:name => "user1")
-            @appendage1 = @user1.appendages.create!
-          end
-          @shard2.activate do
-            @user2 = User.create!(:name => "user2")
-            @appendage2 = @user2.appendages.create!
-          end
-        end
-
-        it "should return non-id columns" do
-          expect(User.where(:id => [@user1.id, @user2.id]).pluck(:name).sort).to eq ["user1", "user2"]
-        end
-
-        it "should return primary ids relative to current shard" do
-          expect(Appendage.where(:id => @appendage1).pluck(:id)).to eq [@appendage1.global_id]
-          expect(Appendage.where(:id => @appendage2).pluck(:id)).to eq [@appendage2.global_id]
-          @shard1.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id)).to eq [@appendage1.local_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:id)).to eq [@appendage2.global_id]
-          end
-          @shard2.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id)).to eq [@appendage1.global_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:id)).to eq [@appendage2.local_id]
-          end
-        end
-
-        it "should return foreign ids relative to current shard" do
-          expect(Appendage.where(:id => @appendage1).pluck(:user_id)).to eq [@user1.global_id]
-          expect(Appendage.where(:id => @appendage2).pluck(:user_id)).to eq [@user2.global_id]
-          @shard1.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:user_id)).to eq [@user1.local_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:user_id)).to eq [@user2.global_id]
-          end
-          @shard2.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:user_id)).to eq [@user1.global_id]
-            expect(Appendage.where(:id => @appendage2).pluck(:user_id)).to eq [@user2.local_id]
-          end
-        end
-
-        it "should post-uniq multi-shard" do
-          user3 = User.create!(name: 'user2')
-          expect(User.where(id: [@user1.id, @user2.id, user3.id]).distinct.pluck(:name).sort).to match_array ["user1", "user2"]
-        end
-
-        it "should work when setting an AR shard value" do
-          expect(Appendage.shard(@user1).pluck(:user_id)).to eq [@user1.global_id]
-        end
-
-        it "should work with multi-column plucking" do
-          expect(Appendage.where(:id => @appendage1).pluck(:id, :user_id)).to eq [[@appendage1.global_id, @user1.global_id]]
-          expect(Appendage.where(:id => @appendage2).pluck(:id, :user_id)).to eq [[@appendage2.global_id, @user2.global_id]]
-          @shard1.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id, :user_id)).to eq [[@appendage1.local_id, @user1.local_id]]
-            expect(Appendage.where(:id => @appendage2).pluck(:id, :user_id)).to eq [[@appendage2.global_id, @user2.global_id]]
-          end
-          @shard2.activate do
-            expect(Appendage.where(:id => @appendage1).pluck(:id, :user_id)).to eq [[@appendage1.global_id, @user1.global_id]]
-            expect(Appendage.where(:id => @appendage2).pluck(:id, :user_id)).to eq [[@appendage2.local_id, @user2.local_id]]
-          end
-        end
-      end
-
-      describe "#execute_simple_calculation" do
-        before do
-          @appendages = []
-          @shard1.activate do
-            @user1 = User.create!(:name => "user1")
-            @appendages << @user1.appendages.create!(:value => 1)
-            @appendages << @user1.appendages.create!(:value => 2)
-          end
-          @shard2.activate do
-            @user2 = User.create!(:name => "user2")
-            @appendages << @user2.appendages.create!(:value => 3)
-            @appendages << @user2.appendages.create!(:value => 4)
-            @appendages << @user2.appendages.create!(:value => 5)
-          end
-        end
-
-        it "should calculate average across shards" do
-          expect(@user1.appendages.average(:value)).to eq 1.5
-          expect(@shard1.activate {Appendage.average(:value)}).to eq 1.5
-
-          expect(@user2.appendages.average(:value)).to eq 4
-          expect(@shard2.activate {Appendage.average(:value)}).to eq 4
-
-          expect(Appendage.where(:id => @appendages).average(:value)).to eq 3
-        end
-
-        it "should count across shards" do
-          expect(@user1.appendages.count).to eq 2
-          expect(@shard1.activate {Appendage.count}).to eq 2
-
-          expect(@user2.appendages.count).to eq 3
-          expect(@shard2.activate {Appendage.count}).to eq 3
-
-          expect(Appendage.where(:id => @appendages).count).to eq 5
-        end
-
-        it "should calculate minimum across shards" do
-          expect(@user1.appendages.minimum(:value)).to eq 1
-          expect(@shard1.activate {Appendage.minimum(:value)}).to eq 1
-
-          expect(@user2.appendages.minimum(:value)).to eq 3
-          expect(@shard2.activate {Appendage.minimum(:value)}).to eq 3
-
-          expect(Appendage.where(:id => @appendages).minimum(:value)).to eq 1
-        end
-
-        it "should calculate maximum across shards" do
-          expect(@user1.appendages.maximum(:value)).to eq 2
-          expect(@shard1.activate {Appendage.maximum(:value)}).to eq 2
-
-          expect(@user2.appendages.maximum(:value)).to eq 5
-          expect(@shard2.activate {Appendage.maximum(:value)}).to eq 5
-
-          expect(Appendage.where(:id => @appendages).maximum(:value)).to eq 5
-        end
-
-        it "should work with dates across shards" do
-          expect(Appendage.where(:id => @appendages).maximum(:created_at).to_i).to eq @appendages.map(&:created_at).map(&:to_i).max
-        end
-
-        it "should calculate sum across shards" do
-          expect(@user1.appendages.sum(:value)).to eq 3
-          expect(@shard1.activate {Appendage.sum(:value)}).to eq 3
-
-          expect(@user2.appendages.sum(:value)).to eq 12
-          expect(@shard2.activate {Appendage.sum(:value)}).to eq 12
-
-          expect(Appendage.where(:id => @appendages).sum(:value)).to eq 15
-        end
-      end
-
-      describe "#execute_grouped_calculation" do
-        before do
-          @appendages = []
-          @shard1.activate { @user1 = User.create!(:name => "user1") }
-          @shard2.activate { @user2 = User.create!(:name => "user2") }
-
-          @shard1.activate do
-            @appendages << Appendage.create!(:user_id => @user1.id, :value => 1)
-            @appendages << Appendage.create!(:user_id => @user2.id, :value => 3)
-          end
-          @shard2.activate do
-            @appendages << Appendage.create!(:user_id => @user1.id, :value => 2)
-            @appendages << Appendage.create!(:user_id => @user2.id, :value => 4)
-            @appendages << Appendage.create!(:user_id => @user2.id, :value => 5)
-          end
-        end
-
-        it "should calculate average across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
-              {@user1.global_id => 1.5, @user2.global_id => 4}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
-                {@user1.local_id => 1.5, @user2.global_id => 4}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
-                {@user1.global_id => 1.5, @user2.local_id => 4}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).average(:value)).to eq(
-              {@user1 => 1.5, @user2 => 4}
-          )
-        end
-
-        it "should count across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
-              {@user1.global_id => 2, @user2.global_id => 3}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
-                {@user1.local_id => 2, @user2.global_id => 3}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
-                {@user1.global_id => 2, @user2.local_id => 3}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).count).to eq(
-              {@user1 => 2, @user2 => 3}
-          )
-        end
-
-        it "should calculate minimum across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
-              {@user1.global_id => 1, @user2.global_id => 3}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
-                {@user1.local_id => 1, @user2.global_id => 3}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
-                {@user1.global_id => 1, @user2.local_id => 3}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).minimum(:value)).to eq(
-              {@user1 => 1, @user2 => 3}
-          )
-        end
-
-        it "should calculate maximum across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
-              {@user1.global_id => 2, @user2.global_id => 5}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
-                {@user1.local_id => 2, @user2.global_id => 5}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
-                {@user1.global_id => 2, @user2.local_id => 5}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).maximum(:value)).to eq(
-              {@user1 => 2, @user2 => 5}
-          )
-        end
-
-        it "should calculate sum across shards" do
-          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
-              {@user1.global_id => 3, @user2.global_id => 12}
-          )
-
-          @shard1.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
-                {@user1.local_id => 3, @user2.global_id => 12}
-            )
-          end
-
-          @shard2.activate do
-            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
-                {@user1.global_id => 3, @user2.local_id => 12}
-            )
-          end
-
-          expect(Appendage.shard([@shard1, @shard2]).group(:user).sum(:value)).to eq(
-              {@user1 => 3, @user2 => 12}
-          )
-        end
-
-        it "should respect order for a single shard" do
-          @shard1.activate do
-            @user1.appendages.create!
-            user2 = User.create!
-            user2.appendages.create!
-            expect(Appendage.group(:user_id).order("COUNT(*) DESC").limit(1).count).to eq({ @user1.id => 2 })
-          end
-        end
-      end
-    end
-  end
-end