switchman 1.2.10 → 1.2.11

data/spec/lib/active_record/attribute_methods_spec.rb

@@ -8,14 +8,14 @@ module Switchman
       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
+          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
-            user.id.should > Shard::IDS_PER_SHARD
-            user.local_id.should < Shard::IDS_PER_SHARD
-            user.global_id.should > Shard::IDS_PER_SHARD
+            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
 
@@ -26,80 +26,80 @@ module Switchman
 
           # local id, should stay local
           appendage.original_user_id = 6
-          appendage.user_id.should == 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)
-          appendage.user_id.should == 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)
-          appendage.user_id.should == @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
-            appendage.user_id.should == Shard.default.global_id_for(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)
-            appendage.user_id.should == 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)
-            appendage.user_id.should == 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)
-            appendage.user_id.should == @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
-          appendage.original_user_id.should == 6
+          expect(appendage.original_user_id).to eq 6
           appendage.user_id = '6'
-          appendage.original_user_id.should == 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)
-          appendage.original_user_id.should == 6
+          expect(appendage.original_user_id).to eq 6
           appendage.user_id = Shard.current.global_id_for(6).to_s
-          appendage.original_user_id.should == 6
+          expect(appendage.original_user_id).to eq 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
+          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
-          appendage.original_user_id.should == @shard1.global_id_for(6)
-          appendage.local_user_id.should == 6
+          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
-            appendage.original_user_id.should == @shard1.global_id_for(6)
+            expect(appendage.original_user_id).to eq @shard1.global_id_for(6)
             appendage.user_id = '6'
-            appendage.original_user_id.should == @shard1.global_id_for(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)
-            appendage.original_user_id.should == 6
+            expect(appendage.original_user_id).to eq 6
             appendage.user_id = Shard.default.global_id_for(6).to_s
-            appendage.original_user_id.should == 6
+            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)
-            appendage.original_user_id.should == @shard1.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
-            appendage.original_user_id.should == @shard1.global_id_for(6)
+            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)
-            appendage.original_user_id.should == @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
-            appendage.original_user_id.should == @shard2.global_id_for(6)
+            expect(appendage.original_user_id).to eq @shard2.global_id_for(6)
           end
         end
 

data/spec/lib/active_record/base_spec.rb

@@ -8,21 +8,21 @@ module Switchman
       describe "to_param" do
         it "should return nil if no id" do
           user = User.new
-          user.to_param.should be_nil
+          expect(user.to_param).to be_nil
         end
 
         it "should return the id even if not persisted" do
           user = User.new
           user.id = 1
-          user.to_param.should == '1'
+          expect(user.to_param).to eq '1'
         end
 
         it "should return local id if in the current shard" do
           user = User.create!
-          user.to_param.should == user.local_id.to_s
+          expect(user.to_param).to eq user.local_id.to_s
           @shard1.activate do
             user2 = User.create!
-            user2.to_param.should == user2.local_id.to_s
+            expect(user2.to_param).to eq user2.local_id.to_s
           end
         end
 
@@ -32,7 +32,7 @@ module Switchman
             user = User.create!
           end
           @shard2.activate do
-            user.to_param.should == "#{@shard1.id}~#{user.local_id}"
+            expect(user.to_param).to eq "#{@shard1.id}~#{user.local_id}"
           end
         end
 
@@ -45,25 +45,25 @@ module Switchman
             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"
+            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}"
 
-            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"
+            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!
-            helpers.user_appendage_path(user, appendage2).should == "/users/#{user_short_id}/appendages/#{appendage2.local_id}"
+            expect(helpers.user_appendage_path(user, appendage2)).to eq "/users/#{user_short_id}/appendages/#{appendage2.local_id}"
           end
         end
       end
@@ -74,21 +74,21 @@ module Switchman
           appendage = Appendage.new
           appendage.user_id = user.id
           appendage.shard = @shard1
-          appendage.attributes["user_id"].should == user.global_id
+          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
-          pending "remove_connection working properly"
+          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)
 
-            MirrorUser.connection.should_not == ::ActiveRecord::Base.connection
+            expect(MirrorUser.connection).not_to eq ::ActiveRecord::Base.connection
             ::Shackles.activate(:slave) do
-              MirrorUser.connection.should_not == ::ActiveRecord::Base.connection
+              expect(MirrorUser.connection).not_to eq ::ActiveRecord::Base.connection
             end
           ensure
             MirrorUser.remove_connection

data/spec/lib/active_record/calculations_spec.rb

@@ -18,32 +18,32 @@ module Switchman
         end
 
         it "should return non-id columns" do
-          User.where(:id => [@user1.id, @user2.id]).pluck(:name).sort.should == ["user1", "user2"]
+          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
-          Appendage.where(:id => @appendage1).pluck(:id).should == [@appendage1.global_id]
-          Appendage.where(:id => @appendage2).pluck(:id).should == [@appendage2.global_id]
+          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
-            Appendage.where(:id => @appendage1).pluck(:id).should == [@appendage1.local_id]
-            Appendage.where(:id => @appendage2).pluck(:id).should == [@appendage2.global_id]
+            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
-            Appendage.where(:id => @appendage1).pluck(:id).should == [@appendage1.global_id]
-            Appendage.where(:id => @appendage2).pluck(:id).should == [@appendage2.local_id]
+            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
-          Appendage.where(:id => @appendage1).pluck(:user_id).should == [@user1.global_id]
-          Appendage.where(:id => @appendage2).pluck(:user_id).should == [@user2.global_id]
+          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
-            Appendage.where(:id => @appendage1).pluck(:user_id).should == [@user1.local_id]
-            Appendage.where(:id => @appendage2).pluck(:user_id).should == [@user2.global_id]
+            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
-            Appendage.where(:id => @appendage1).pluck(:user_id).should == [@user1.global_id]
-            Appendage.where(:id => @appendage2).pluck(:user_id).should == [@user2.local_id]
+            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
       end
@@ -65,53 +65,53 @@ module Switchman
         end
 
         it "should calculate average across shards" do
-          @user1.appendages.average(:value).should == 1.5
-          @shard1.activate {Appendage.average(:value)}.should == 1.5
+          expect(@user1.appendages.average(:value)).to eq 1.5
+          expect(@shard1.activate {Appendage.average(:value)}).to eq 1.5
 
-          @user2.appendages.average(:value).should == 4
-          @shard2.activate {Appendage.average(:value)}.should == 4
+          expect(@user2.appendages.average(:value)).to eq 4
+          expect(@shard2.activate {Appendage.average(:value)}).to eq 4
 
-          Appendage.where(:id => @appendages).average(:value).should == 3
+          expect(Appendage.where(:id => @appendages).average(:value)).to eq 3
         end
 
         it "should count across shards" do
-          @user1.appendages.count.should == 2
-          @shard1.activate {Appendage.count}.should == 2
+          expect(@user1.appendages.count).to eq 2
+          expect(@shard1.activate {Appendage.count}).to eq 2
 
-          @user2.appendages.count.should == 3
-          @shard2.activate {Appendage.count}.should == 3
+          expect(@user2.appendages.count).to eq 3
+          expect(@shard2.activate {Appendage.count}).to eq 3
 
-          Appendage.where(:id => @appendages).count.should == 5
+          expect(Appendage.where(:id => @appendages).count).to eq 5
         end
 
         it "should calculate minimum across shards" do
-          @user1.appendages.minimum(:value).should == 1
-          @shard1.activate {Appendage.minimum(:value)}.should == 1
+          expect(@user1.appendages.minimum(:value)).to eq 1
+          expect(@shard1.activate {Appendage.minimum(:value)}).to eq 1
 
-          @user2.appendages.minimum(:value).should == 3
-          @shard2.activate {Appendage.minimum(:value)}.should == 3
+          expect(@user2.appendages.minimum(:value)).to eq 3
+          expect(@shard2.activate {Appendage.minimum(:value)}).to eq 3
 
-          Appendage.where(:id => @appendages).minimum(:value).should == 1
+          expect(Appendage.where(:id => @appendages).minimum(:value)).to eq 1
         end
 
         it "should calculate maximum across shards" do
-          @user1.appendages.maximum(:value).should == 2
-          @shard1.activate {Appendage.maximum(:value)}.should == 2
+          expect(@user1.appendages.maximum(:value)).to eq 2
+          expect(@shard1.activate {Appendage.maximum(:value)}).to eq 2
 
-          @user2.appendages.maximum(:value).should == 5
-          @shard2.activate {Appendage.maximum(:value)}.should == 5
+          expect(@user2.appendages.maximum(:value)).to eq 5
+          expect(@shard2.activate {Appendage.maximum(:value)}).to eq 5
 
-          Appendage.where(:id => @appendages).maximum(:value).should == 5
+          expect(Appendage.where(:id => @appendages).maximum(:value)).to eq 5
         end
 
         it "should calculate sum across shards" do
-          @user1.appendages.sum(:value).should == 3
-          @shard1.activate {Appendage.sum(:value)}.should == 3
+          expect(@user1.appendages.sum(:value)).to eq 3
+          expect(@shard1.activate {Appendage.sum(:value)}).to eq 3
 
-          @user2.appendages.sum(:value).should == 12
-          @shard2.activate {Appendage.sum(:value)}.should == 12
+          expect(@user2.appendages.sum(:value)).to eq 12
+          expect(@shard2.activate {Appendage.sum(:value)}).to eq 12
 
-          Appendage.where(:id => @appendages).sum(:value).should == 15
+          expect(Appendage.where(:id => @appendages).sum(:value)).to eq 15
         end
       end
 
@@ -133,93 +133,113 @@ module Switchman
         end
 
         it "should calculate average across shards" do
-          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value).should ==
+          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
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value).should ==
+            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
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value).should ==
+            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value)).to eq(
                 {@user1.global_id => 1.5, @user2.local_id => 4}
+            )
           end
 
-          Appendage.shard([@shard1, @shard2]).group(:user).average(:value).should ==
+          expect(Appendage.shard([@shard1, @shard2]).group(:user).average(:value)).to eq(
               {@user1 => 1.5, @user2 => 4}
+          )
         end
 
         it "should count across shards" do
-          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count.should ==
+          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
               {@user1.global_id => 2, @user2.global_id => 3}
+          )
 
           @shard1.activate do
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count.should ==
+            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
                 {@user1.local_id => 2, @user2.global_id => 3}
+            )
           end
 
           @shard2.activate do
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count.should ==
+            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count).to eq(
                 {@user1.global_id => 2, @user2.local_id => 3}
+            )
           end
 
-          Appendage.shard([@shard1, @shard2]).group(:user).count.should ==
+          expect(Appendage.shard([@shard1, @shard2]).group(:user).count).to eq(
               {@user1 => 2, @user2 => 3}
+          )
         end
 
         it "should calculate minimum across shards" do
-          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value).should ==
+          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
               {@user1.global_id => 1, @user2.global_id => 3}
+          )
 
           @shard1.activate do
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value).should ==
+            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
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value).should ==
+            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value)).to eq(
                 {@user1.global_id => 1, @user2.local_id => 3}
+            )
           end
 
-          Appendage.shard([@shard1, @shard2]).group(:user).minimum(:value).should ==
+          expect(Appendage.shard([@shard1, @shard2]).group(:user).minimum(:value)).to eq(
               {@user1 => 1, @user2 => 3}
+          )
         end
 
         it "should calculate maximum across shards" do
-          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value).should ==
+          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
               {@user1.global_id => 2, @user2.global_id => 5}
+          )
 
           @shard1.activate do
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value).should ==
+            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
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value).should ==
+            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value)).to eq(
                 {@user1.global_id => 2, @user2.local_id => 5}
+            )
           end
 
-          Appendage.shard([@shard1, @shard2]).group(:user).maximum(:value).should ==
+          expect(Appendage.shard([@shard1, @shard2]).group(:user).maximum(:value)).to eq(
               {@user1 => 2, @user2 => 5}
+          )
         end
 
         it "should calculate sum across shards" do
-          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value).should ==
+          expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
               {@user1.global_id => 3, @user2.global_id => 12}
+          )
 
           @shard1.activate do
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value).should ==
+            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
-            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value).should ==
+            expect(Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value)).to eq(
                 {@user1.global_id => 3, @user2.local_id => 12}
+            )
           end
 
-          Appendage.shard([@shard1, @shard2]).group(:user).sum(:value).should ==
+          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
@@ -227,7 +247,7 @@ module Switchman
             @user1.appendages.create!
             user2 = User.create!
             user2.appendages.create!
-            Appendage.group(:user_id).order("COUNT(*) DESC").limit(1).count.should == { @user1.id => 2 }
+            expect(Appendage.group(:user_id).order("COUNT(*) DESC").limit(1).count).to eq({ @user1.id => 2 })
           end
         end
       end