switchman 0.0.1

data/spec/lib/active_record/attribute_methods_spec.rb

@@ -0,0 +1,108 @@
+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!
+          user.id.should < Shard::IDS_PER_SHARD
+          user.local_id.should < Shard::IDS_PER_SHARD
+          user.global_id.should > Shard::IDS_PER_SHARD
+
+          @shard1.activate do
+            user.id.should > Shard::IDS_PER_SHARD
+            user.local_id.should < Shard::IDS_PER_SHARD
+            user.global_id.should > 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
+          appendage.user_id.should == 6
+
+          # (incorrect) self referencing global id; should come out as local
+          appendage.original_user_id = Shard.current.global_id_for(6)
+          appendage.user_id.should == 6
+
+          # global id referencing another shard; should come out unscathed
+          appendage.original_user_id = @shard1.global_id_for(6)
+          appendage.user_id.should == @shard1.global_id_for(6)
+
+          @shard1.activate do
+            # local id in another shard, should be global in this shard
+            appendage.original_user_id = 6
+            appendage.user_id.should == 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)
+            appendage.user_id.should == 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)
+            appendage.user_id.should == 6
+
+            # global id from an unrelated shard; should stay global
+            appendage.original_user_id = @shard2.global_id_for(6)
+            appendage.user_id.should == @shard2.global_id_for(6)
+          end
+
+          # now that we trust the getters, try the setters
+
+          # local stays local
+          appendage.user_id = 6
+          appendage.original_user_id.should == 6
+          appendage.user_id = '6'
+          appendage.original_user_id.should == 6
+
+          # (incorrect) global id to this shard, should become local
+          appendage.user_id = Shard.current.global_id_for(6)
+          appendage.original_user_id.should == 6
+          appendage.user_id = Shard.current.global_id_for(6).to_s
+          appendage.original_user_id.should == 6
+
+          # global id from another shard, should stay global
+          appendage.user_id = @shard1.global_id_for(6)
+          appendage.original_user_id.should == @shard1.global_id_for(6)
+          appendage.local_user_id.should == 6
+          appendage.user_id = @shard1.global_id_for(6).to_s
+          appendage.original_user_id.should == @shard1.global_id_for(6)
+          appendage.local_user_id.should == 6
+
+          @shard1.activate do
+            # local to this shard becomes global
+            appendage.user_id = 6
+            appendage.original_user_id.should == @shard1.global_id_for(6)
+            appendage.user_id = '6'
+            appendage.original_user_id.should == @shard1.global_id_for(6)
+
+            # global id from original shard, should become local
+            appendage.user_id = Shard.default.global_id_for(6)
+            appendage.original_user_id.should == 6
+            appendage.user_id = Shard.default.global_id_for(6).to_s
+            appendage.original_user_id.should == 6
+
+            # global id from this shard, should stay global
+            appendage.user_id = Shard.current.global_id_for(6)
+            appendage.original_user_id.should == @shard1.global_id_for(6)
+            appendage.user_id = Shard.current.global_id_for(6).to_s
+            appendage.original_user_id.should == @shard1.global_id_for(6)
+
+            # global id from unrelated shard, should stay global
+            appendage.user_id = @shard2.global_id_for(6)
+            appendage.original_user_id.should == @shard2.global_id_for(6)
+            appendage.user_id = @shard2.global_id_for(6).to_s
+            appendage.original_user_id.should == @shard2.global_id_for(6)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/active_record/base_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe Base do
+      include RSpecHelper
+
+      describe "to_param" do
+        it "should return nil if not persisted" do
+          user = User.new
+          user.to_param.should be_nil
+        end
+
+        it "should return local id if in the current shard" do
+          user = User.create!
+          user.to_param.should == user.local_id
+          @shard1.activate do
+            user2 = User.create!
+            user2.to_param.should == user2.local_id
+          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
+            user.to_param.should == "#{@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!
+
+            helpers.user_path(user).should == "/users/#{user.local_id}"
+            helpers.user_appendages_path(user).should == "/users/#{user.local_id}/appendages"
+            helpers.user_appendage_path(user, appendage).should == "/users/#{user.local_id}/appendages/#{appendage.local_id}"
+            helpers.user_test1_path(user).should == "/users/#{user.local_id}"
+            helpers.user_test2_path(user).should == "/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}"
+
+            helpers.user_path(user).should == "/users/#{user_short_id}"
+            helpers.user_appendages_path(user).should == "/users/#{user_short_id}/appendages"
+            helpers.user_appendage_path(user, appendage).should == "/users/#{user_short_id}/appendages/#{appendage_short_id}"
+            helpers.user_test1_path(user).should == "/users/#{user_short_id}"
+            helpers.user_test2_path(user).should == "/users/#{user_short_id}/test2"
+
+            appendage2 = Appendage.create!
+            helpers.user_appendage_path(user, appendage2).should == "/users/#{user_short_id}/appendages/#{appendage2.local_id}"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/active_record/calculations_spec.rb

@@ -0,0 +1,119 @@
+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
+          User.where(:id => [@user1.id, @user2.id]).pluck(:name).sort.should == ["user1", "user2"]
+        end
+
+        it "should return primary ids relative to current shard" do
+          Appendage.where(:id => @appendage1).pluck(:id).should == [@appendage1.global_id]
+          Appendage.where(:id => @appendage2).pluck(:id).should == [@appendage2.global_id]
+          @shard1.activate do
+            Appendage.where(:id => @appendage1).pluck(:id).should == [@appendage1.local_id]
+            Appendage.where(:id => @appendage2).pluck(:id).should == [@appendage2.global_id]
+          end
+          @shard2.activate do
+            Appendage.where(:id => @appendage1).pluck(:id).should == [@appendage1.global_id]
+            Appendage.where(:id => @appendage2).pluck(:id).should == [@appendage2.local_id]
+          end
+        end
+
+        it "should return foreign ids relative to current shard" do
+          Appendage.where(:id => @appendage1).pluck(:user_id).should == [@user1.global_id]
+          Appendage.where(:id => @appendage2).pluck(:user_id).should == [@user2.global_id]
+          @shard1.activate do
+            Appendage.where(:id => @appendage1).pluck(:user_id).should == [@user1.local_id]
+            Appendage.where(:id => @appendage2).pluck(:user_id).should == [@user2.global_id]
+          end
+          @shard2.activate do
+            Appendage.where(:id => @appendage1).pluck(:user_id).should == [@user1.global_id]
+            Appendage.where(:id => @appendage2).pluck(:user_id).should == [@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
+          @user1.appendages.average(:value).should == 1.5
+          @shard1.activate {Appendage.average(:value)}.should == 1.5
+
+          @user2.appendages.average(:value).should == 4
+          @shard2.activate {Appendage.average(:value)}.should == 4
+
+          Appendage.where(:id => @appendages).average(:value).should == 3
+        end
+
+        it "should count across shards" do
+          @user1.appendages.count.should == 2
+          @shard1.activate {Appendage.count}.should == 2
+
+          @user2.appendages.count.should == 3
+          @shard2.activate {Appendage.count}.should == 3
+
+          Appendage.where(:id => @appendages).count.should == 5
+        end
+
+        it "should calculate minimum across shards" do
+          @user1.appendages.minimum(:value).should == 1
+          @shard1.activate {Appendage.minimum(:value)}.should == 1
+
+          @user2.appendages.minimum(:value).should == 3
+          @shard2.activate {Appendage.minimum(:value)}.should == 3
+
+          Appendage.where(:id => @appendages).minimum(:value).should == 1
+        end
+
+        it "should calculate maximum across shards" do
+          @user1.appendages.maximum(:value).should == 2
+          @shard1.activate {Appendage.maximum(:value)}.should == 2
+
+          @user2.appendages.maximum(:value).should == 5
+          @shard2.activate {Appendage.maximum(:value)}.should == 5
+
+          Appendage.where(:id => @appendages).maximum(:value).should == 5
+        end
+
+        it "should calculate sum across shards" do
+          @user1.appendages.sum(:value).should == 3
+          @shard1.activate {Appendage.sum(:value)}.should == 3
+
+          @user2.appendages.sum(:value).should == 12
+          @shard2.activate {Appendage.sum(:value)}.should == 12
+
+          Appendage.where(:id => @appendages).sum(:value).should == 15
+        end
+      end
+    end
+  end
+end

data/spec/lib/active_record/connection_handler_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe ConnectionHandler do
+      include RSpecHelper
+
+      it "should use different proxies for different categories" do
+        Shard.connection_pool.should_not == User.connection_pool
+      end
+
+      it "should share underlying pools for different categories on the same shard" do
+        Shard.connection_pool.current_pool.should == User.connection_pool.current_pool
+      end
+
+      it "should insert sharding for connections established after initialization" do
+        User.connection_pool.should == ::ActiveRecord::Base.connection_pool
+        begin
+          config = { :adapter => 'sqlite3', :database => ':memory:', :something_unique_in_the_spec => true }
+          User.establish_connection(config)
+          User.connection_pool.should_not == ::ActiveRecord::Base.connection_pool
+          User.connection_pool.spec.config.should == config
+          User.connection_pool.should be_is_a(ConnectionPoolProxy)
+          @shard2.activate do
+            User.connection_pool.spec.config.should == ::ActiveRecord::Base.connection_pool.spec.config
+            User.connection_pool.spec.config.should_not == config
+          end
+        ensure
+          User.remove_connection
+          User.connection_pool.should == ::ActiveRecord::Base.connection_pool
+          User.connection_pool.should be_is_a(ConnectionPoolProxy)
+        end
+      end
+
+      it "should set up separate pools for different categories" do
+        User.connection_pool.should_not == MirrorUser.connection_pool
+        mu = MirrorUser.create!
+        MirrorUser.find(mu.local_id).should == mu
+        # didn't activate the :mirror_universe category
+        @shard1.activate { MirrorUser.find(mu.local_id).should == mu }
+        @shard1.activate(:mirror_universe) { MirrorUser.find_by_id(mu.local_id).should == nil }
+      end
+    end
+  end
+end

data/spec/lib/active_record/connection_pool_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe ConnectionPool do
+      it "should be able to access another shard on a db server after the 'primary' shard is gone" do
+        pending 'A "real" database"' unless Shard.default.database_server.shareable?
+        # separate connections
+        server = DatabaseServer.create(:config => Shard.default.database_server.config.dup)
+        s1 = server.shards.create!(:name => 'non_existent_shard') # don't actually create any schema
+        s2 = server.shards.create! # inherit's the default shard's config, which is functional
+        s1.activate do
+          lambda { User.count }.should raise_exception
+        end
+        # the config for s1 should not be the permanent default for all new
+        # connections now
+        s2.activate do
+          lambda { User.count }.should_not raise_exception
+        end
+      end
+    end
+  end
+end

data/spec/lib/active_record/finder_methods_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe FinderMethods do
+      include RSpecHelper
+
+      before do
+        @user = @shard1.activate { User.create! }
+      end
+
+      describe "#find_one" do
+        it "should find with a global id" do
+          User.find(@user.global_id).should == @user
+        end
+      end
+
+      describe "#find_by_attributes" do
+        it "should find with a global id" do
+          User.find_by_id(@user.global_id).should == @user
+        end
+
+        it "should find with an array of global ids" do
+          User.find_by_id([@user.global_id]).should == @user
+        end
+      end
+    end
+  end
+end

data/spec/lib/active_record/query_cache_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe QueryCache do
+      include RSpecHelper
+
+      it "should isolate queries to multiple shards on the same server" do
+        @shard1.activate do
+          User.create!
+          User.create!
+        end
+        @shard3.activate do
+          User.create!
+        end
+        @shard1.activate { User.all }.should_not == @shard3.activate { User.all }
+      end
+    end
+  end
+end

data/spec/lib/active_record/query_methods_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe QueryMethods do
+      include RSpecHelper
+
+      before do
+        @user1 = User.create!
+        @appendage1 = @user1.appendages.create!
+        @user2 = @shard1.activate { User.create! }
+        @appendage2 = @user2.appendages.create!
+        @user3 = @shard2.activate { User.create! }
+        @appendage3 = @user3.appendages.create!
+      end
+
+      describe "#primary_shard" do
+        it "should be the shard if it's a shard" do
+          User.shard(Shard.default).primary_shard.should == Shard.default
+          User.shard(@shard1).primary_shard.should == @shard1
+        end
+
+        it "should be the first shard of an array of shards" do
+          User.shard([Shard.default, @shard1]).primary_shard.should == Shard.default
+          User.shard([@shard1, Shard.default]).primary_shard.should == @shard1
+        end
+
+        it "should be the object's shard if it's a model" do
+          User.shard(@user1).primary_shard.should == Shard.default
+          User.shard(@user2).primary_shard.should == @shard1
+        end
+
+        it "should be the default shard if it's a scope of Shard" do
+          User.shard(Shard.scoped).primary_shard.should == Shard.default
+          @shard1.activate do
+            User.shard(Shard.scoped).primary_shard.should == Shard.default
+          end
+        end
+      end
+
+      it "should default to the current shard" do
+        relation = User.scoped
+        relation.shard_value.should == Shard.default
+        relation.shard_source_value.should == :implicit
+
+        @shard1.activate do
+          relation.shard_value.should == Shard.default
+
+          relation = User.scoped
+          relation.shard_value.should == @shard1
+          relation.shard_source_value.should == :implicit
+        end
+        relation.shard_value.should == @shard1
+      end
+
+      describe "with primary key conditions" do
+        it "should be changeable, and change conditions when it is changed" do
+          relation = User.where(:id => @user1).shard(@shard1)
+          relation.shard_value.should == @shard1
+          relation.shard_source_value.should == :explicit
+          relation.where_values.first.right.should == @user1.global_id
+        end
+
+        it "should infer the shard from a single argument" do
+          relation = User.where(:id => @user2)
+          # execute on @shard1, with id local to that shard
+          relation.shard_value.should == @shard1
+          relation.where_values.first.right.should == @user2.local_id
+        end
+
+        it "should infer the shard from multiple arguments" do
+          relation = User.where(:id => [@user2, @user2])
+          # execute on @shard1, with id local to that shard
+          relation.shard_value.should == @shard1
+          relation.where_values.first.right.should == [@user2.local_id, @user2.local_id]
+        end
+
+        it "should infer the correct shard from an array of 1" do
+          relation = User.where(:id => [@user2])
+          # execute on @shard1, with id local to that shard
+          relation.shard_value.should == @shard1
+          relation.where_values.first.right.should == [@user2.local_id]
+        end
+
+        it "should do nothing when it's an array of 0" do
+          relation = User.where(:id => [])
+          # execute on @shard1, with id local to that shard
+          relation.shard_value.should == Shard.default
+          relation.where_values.first.right.should == []
+        end
+
+        it "should order the shards preferring the shard it already had as primary" do
+          relation = User.where(:id => [@user1, @user2])
+          relation.shard_value.should == [Shard.default, @shard1]
+          relation.where_values.first.right.should == [@user1.local_id, @user2.global_id]
+
+          @shard1.activate do
+            relation = User.where(:id => [@user1, @user2])
+            relation.shard_value.should == [@shard1, Shard.default]
+            relation.where_values.first.right.should == [@user1.global_id, @user2.local_id]
+          end
+        end
+      end
+
+      describe "with foreign key conditions" do
+        it "should be changeable, and change conditions when it is changed" do
+          relation = Appendage.where(:user_id => @user1)
+          relation.shard_value.should == Shard.default
+          relation.shard_source_value.should == :implicit
+          relation.where_values.first.right.should == @user1.local_id
+
+          relation = relation.shard(@shard1)
+          relation.shard_value.should == @shard1
+          relation.shard_source_value.should == :explicit
+          relation.where_values.first.right.should == @user1.global_id
+        end
+
+        it "should translate ids based on current shard" do
+          relation = Appendage.where(:user_id => [@user1, @user2])
+          relation.where_values.first.right.should == [@user1.local_id, @user2.global_id]
+
+          @shard1.activate do
+            relation = Appendage.where(:user_id => [@user1, @user2])
+            relation.where_values.first.right.should == [@user1.global_id, @user2.local_id]
+          end
+        end
+      end
+    end
+  end
+end