switchman 1.2.10 → 1.2.11

data/spec/models/shard_spec.rb

@@ -6,52 +6,52 @@ module Switchman
 
     describe ".activate" do
       it "should activate a hash of shard categories" do
-        Shard.current.should == Shard.default
-        Shard.current(:other).should == Shard.default
+        expect(Shard.current).to eq Shard.default
+        expect(Shard.current(:other)).to eq Shard.default
         Shard.activate(:default => @shard1, :other => @shard2) do
-          Shard.current.should == @shard1
-          Shard.current(:other).should == @shard2
+          expect(Shard.current).to eq @shard1
+          expect(Shard.current(:other)).to eq @shard2
         end
-        Shard.current.should == Shard.default
-        Shard.current(:other).should == Shard.default
+        expect(Shard.current).to eq Shard.default
+        expect(Shard.current(:other)).to eq Shard.default
       end
 
       it "should not allow activating the unsharded category" do
-        Shard.current(:unsharded).should == Shard.default
+        expect(Shard.current(:unsharded)).to eq Shard.default
         Shard.activate(:unsharded => @shard1) do
-          Shard.current(:unsharded).should == Shard.default
+          expect(Shard.current(:unsharded)).to eq Shard.default
         end
-        Shard.current(:unsharded).should == Shard.default
+        expect(Shard.current(:unsharded)).to eq Shard.default
       end
     end
 
     describe "#activate" do
       it "should activate the default category when no args are used" do
-        Shard.current.should == Shard.default
+        expect(Shard.current).to eq Shard.default
         @shard1.activate do
-          Shard.current.should == @shard1
+          expect(Shard.current).to eq @shard1
         end
-        Shard.current.should == Shard.default
+        expect(Shard.current).to eq Shard.default
       end
 
       it "should activate other categories" do
-        Shard.current(:other).should == Shard.default
+        expect(Shard.current(:other)).to eq Shard.default
         @shard1.activate(:other) do
-          Shard.current(:other).should == @shard1
-          Shard.current.should == Shard.default
+          expect(Shard.current(:other)).to eq @shard1
+          expect(Shard.current).to eq Shard.default
         end
-        Shard.current(:other).should == Shard.default
+        expect(Shard.current(:other)).to eq Shard.default
       end
 
       it "should activate multiple categories" do
-        Shard.current.should == Shard.default
-        Shard.current(:other).should == Shard.default
+        expect(Shard.current).to eq Shard.default
+        expect(Shard.current(:other)).to eq Shard.default
         @shard1.activate(:default, :other) do
-          Shard.current.should == @shard1
-          Shard.current(:other).should == @shard1
+          expect(Shard.current).to eq @shard1
+          expect(Shard.current(:other)).to eq @shard1
         end
-        Shard.current.should == Shard.default
-        Shard.current(:other).should == Shard.default
+        expect(Shard.current).to eq Shard.default
+        expect(Shard.current(:other)).to eq Shard.default
       end
     end
 
@@ -60,9 +60,9 @@ module Switchman
         # i.e. the instance var would not be set if we got this back from a cache
         # that was populated pre-sharding
         a = User.new
-        a.shard.should == Shard.default
+        expect(a.shard).to eq Shard.default
         a.instance_variable_set(:@shard, nil)
-        a.shard.should == Shard.default
+        expect(a.shard).to eq Shard.default
       end
     end
 
@@ -73,57 +73,57 @@ module Switchman
         shard = server.create_new_shard
         shard.activate do
           User.create!
-          User.count.should == 1
+          expect(User.count).to eq 1
         end
         shard.drop_database
         shard.activate do
-          lambda { User.count }.should raise_error
+          expect { User.count }.to raise_error
         end
       end
     end
 
     describe ".lookup" do
       it "should work with pseudo-ids" do
-        Shard.lookup('default').should == Shard.default
-        Shard.lookup('self').should == Shard.current
+        expect(Shard.lookup('default')).to eq Shard.default
+        expect(Shard.lookup('self')).to eq Shard.current
         @shard1.activate do
-          Shard.lookup('default').should == Shard.default
-          Shard.lookup('self').should == Shard.current
+          expect(Shard.lookup('default')).to eq Shard.default
+          expect(Shard.lookup('self')).to eq Shard.current
         end
       end
 
       it "should work with string ids" do
-        Shard.lookup(Shard.current.id.to_s).should == Shard.current
-        Shard.lookup(@shard1.id.to_s).should == @shard1
+        expect(Shard.lookup(Shard.current.id.to_s)).to eq Shard.current
+        expect(Shard.lookup(@shard1.id.to_s)).to eq @shard1
       end
 
       it "should raise an error for non-ids" do
-        lambda { Shard.lookup('jacob') }.should raise_error(ArgumentError)
+        expect { Shard.lookup('jacob') }.to raise_error(ArgumentError)
       end
     end
 
     describe ".with_each_shard" do
       describe ":exception" do
         it "should default to :raise" do
-          lambda { Shard.with_each_shard { raise "error" } }.should raise_error
+          expect { Shard.with_each_shard { raise "error" } }.to raise_error
         end
 
         it "should :ignore" do
-          Shard.with_each_shard(exception: :ignore) { raise "error" }.should == []
+          expect(Shard.with_each_shard(exception: :ignore) { raise "error" }).to eq []
         end
 
         it "should :defer" do
           counter = 0
-          lambda { Shard.with_each_shard(exception: :defer) { counter += 1; raise "error" } }.should raise_error
+          expect { Shard.with_each_shard(exception: :defer) { counter += 1; raise "error" } }.to raise_error
           # called more than once
-          counter.should > 1
+          expect(counter).to be > 1
         end
 
         it "should call a proc" do
           counter = 0
-          Shard.with_each_shard(exception: -> { counter += 1 }) { raise "error" }.should == []
+          expect(Shard.with_each_shard(exception: -> { counter += 1 }) { raise "error" }).to eq []
           # called more than once
-          counter.should > 1
+          expect(counter).to be > 1
         end
       end
 
@@ -132,23 +132,23 @@ module Switchman
 
         it "should disconnect when switching among different database servers" do
           User.connection
-          User.connected?.should be_true
+          expect(User.connected?).to eq true
           Shard.with_each_shard([Shard.default, @shard2]) {}
-          User.connected?.should be_false
+          expect(User.connected?).to  eq false
         end
 
         it "should not disconnect when it's the current shard" do
           User.connection
-          User.connected?.should be_true
+          expect(User.connected?).to eq true
           Shard.with_each_shard([Shard.default]) {}
-          User.connected?.should be_true
+          expect(User.connected?).to eq true
         end
 
         it "should not disconnect for zero shards" do
           User.connection
-          User.connected?.should be_true
+          expect(User.connected?).to eq true
           Shard.with_each_shard([]) {}
-          User.connected?.should be_true
+          expect(User.connected?).to eq true
         end
       end
     end
@@ -157,35 +157,35 @@ module Switchman
       it "should work" do
         ids = [2, 48, Shard::IDS_PER_SHARD * @shard1.id + 6, Shard::IDS_PER_SHARD * @shard1.id + 8, 10, 12]
         results = Shard.partition_by_shard(ids) do |ids|
-          (ids.length == 4 || ids.length == 2).should be_true
+          expect(ids.length == 4 || ids.length == 2).to eq true
           ids.map { |id| id + 1}
         end
 
         # could have done either shard first, but we can't sort, because we want to see the shards grouped together
-        (results == [3, 49, 11, 13, 7, 9] ||
-            results == [7, 9, 3, 49, 11, 13]).should be_true
+        expect(results == [3, 49, 11, 13, 7, 9] ||
+            results == [7, 9, 3, 49, 11, 13]).to eq true
       end
 
       it "should work for a partition_proc that returns a shard" do
         array = [{:id => 1, :shard => @shard1}, {:id => 2, :shard => @shard2}]
         results = Shard.partition_by_shard(array, lambda { |a| a[:shard] }) do |objects|
-          objects.length.should == 1
-          Shard.current.should == objects.first[:shard]
+          expect(objects.length).to eq 1
+          expect(Shard.current).to eq objects.first[:shard]
           objects.first[:id]
         end
-        results.sort.should == [1, 2]
+        expect(results.sort).to eq [1, 2]
       end
 
       it "should support shortened id syntax, and strings" do
         ids = [@shard1.global_id_for(1), "#{@shard2.id}~2"]
         result = Shard.partition_by_shard(ids) do |ids|
-          ids.length.should == 1
-          [@shard1, @shard2].include?(Shard.current).should be_true
-          ids.first.should == 1 if Shard.current == @shard1
-          ids.first.should == 2 if Shard.current == @shard2
+          expect(ids.length).to eq 1
+          expect([@shard1, @shard2].include?(Shard.current)).to eq true
+          expect(ids.first).to eq 1 if Shard.current == @shard1
+          expect(ids.first).to eq 2 if Shard.current == @shard2
           ids.first
         end
-        result.sort.should == [1, 2]
+        expect(result.sort).to eq [1, 2]
       end
 
       it "should partition unrecognized types unchanged into current shard" do
@@ -194,7 +194,7 @@ module Switchman
         result = Shard.partition_by_shard(items) do |shard_items|
           [Shard.current, shard_items]
         end
-        result.should == [expected_shard, items]
+        expect(result).to eq [expected_shard, items]
       end
 
       it "should partition unrecognized strings unchanged into current shard" do
@@ -203,7 +203,7 @@ module Switchman
         result = Shard.partition_by_shard(items) do |shard_items|
           [Shard.current, shard_items]
         end
-        result.should == [expected_shard, items]
+        expect(result).to eq [expected_shard, items]
       end
 
       it "should partition recognized ids with an invalid shard unchanged into current shard" do
@@ -213,28 +213,28 @@ module Switchman
         result = Shard.partition_by_shard(items) do |shard_items|
           [Shard.current, shard_items]
         end
-        result.should == [expected_shard, items]
+        expect(result).to eq [expected_shard, items]
       end
     end
 
     describe "#name" do
       it "the default shard should not be marked as dirty after reading its name" do
         s = Shard.default
-        s.should_not be_new_record
+        expect(s).not_to be_new_record
         s.name
-        s.should_not be_changed
+        expect(s).not_to be_changed
       end
 
       it "should fall back to shard_name in the config if nil" do
         db = DatabaseServer.new(config: { adapter: 'mysql', database: 'canvas', shard_name: 'yoyoyo' })
         shard = Shard.new(database_server: db)
-        shard.name.should == 'yoyoyo'
+        expect(shard.name).to eq 'yoyoyo'
       end
 
       it "should fall back to the database_server if nil" do
         db = DatabaseServer.new(config: { adapter: 'mysql', database: 'canvas' })
         shard = Shard.new(database_server: db)
-        shard.name.should == 'canvas'
+        expect(shard.name).to eq 'canvas'
       end
 
       it "should get it from the postgres connection if not otherwise specified" do
@@ -251,7 +251,7 @@ module Switchman
         connection.stubs(:run_callbacks).returns(nil)
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.any_instance.stubs(:checkout).returns(connection)
         begin
-          shard.name.should == 'canvas'
+          expect(shard.name).to eq 'canvas'
         ensure
           shard.activate { ::ActiveRecord::Base.connection_pool.current_pool.disconnect! }
         end
@@ -260,12 +260,12 @@ module Switchman
 
     describe ".shard_for" do
       it "should work" do
-        Shard.shard_for(1).should == Shard.default
-        Shard.shard_for(1, @shard1).should == @shard1
-        Shard.shard_for(@shard1.global_id_for(1)).should == @shard1
-        Shard.shard_for(Shard.default.global_id_for(1)).should == Shard.default
-        Shard.shard_for(@shard1.global_id_for(1), @shard1).should == @shard1
-        Shard.shard_for(Shard.default.global_id_for(1), @shard1).should == Shard.default
+        expect(Shard.shard_for(1)).to eq Shard.default
+        expect(Shard.shard_for(1, @shard1)).to eq @shard1
+        expect(Shard.shard_for(@shard1.global_id_for(1))).to eq @shard1
+        expect(Shard.shard_for(Shard.default.global_id_for(1))).to eq Shard.default
+        expect(Shard.shard_for(@shard1.global_id_for(1), @shard1)).to eq @shard1
+        expect(Shard.shard_for(Shard.default.global_id_for(1), @shard1)).to eq Shard.default
       end
     end
 
@@ -274,36 +274,36 @@ module Switchman
         expected_id = 1
         expected_shard = @shard2
         id, shard = Shard.local_id_for("#{expected_shard.id}~#{expected_id}")
-        id.should == expected_id
-        shard.should == expected_shard
+        expect(id).to eq expected_id
+        expect(shard).to eq expected_shard
       end
 
       it "should recognize global ids" do
         expected_id = 1
         expected_shard = @shard2
         id, shard = Shard.local_id_for(Shard::IDS_PER_SHARD * expected_shard.id + expected_id)
-        id.should == expected_id
-        shard.should == expected_shard
+        expect(id).to eq expected_id
+        expect(shard).to eq expected_shard
       end
 
       it "should recognize local ids with no shard" do
         expected_id = 1
         id, shard = Shard.local_id_for(expected_id)
-        id.should == expected_id
-        shard.should be_nil
+        expect(id).to eq expected_id
+        expect(shard).to be_nil
       end
 
       it "should return nil for unrecognized input" do
         id, shard = Shard.local_id_for("not an id")
-        id.should be_nil
-        shard.should be_nil
+        expect(id).to be_nil
+        expect(shard).to be_nil
       end
 
       it "should return nil for ids with bad shard values" do
         bad_shard_id = @shard2.id + 10000
         id, shard = Shard.local_id_for("#{bad_shard_id}~1")
-        id.should be_nil
-        shard.should be_nil
+        expect(id).to be_nil
+        expect(shard).to be_nil
       end
     end
 
@@ -315,69 +315,69 @@ module Switchman
 
       describe ".integral_id" do
         it "should return recognized ids" do
-          Shard.integral_id_for(@local_id).should == @local_id
-          Shard.integral_id_for(@local_id.to_s).should == @local_id
-          Shard.integral_id_for(@global_id).should == @global_id
-          Shard.integral_id_for(@global_id.to_s).should == @global_id
-          Shard.integral_id_for("#{@shard1.id}~#{@local_id}").should == @global_id
+          expect(Shard.integral_id_for(@local_id)).to eq @local_id
+          expect(Shard.integral_id_for(@local_id.to_s)).to eq @local_id
+          expect(Shard.integral_id_for(@global_id)).to eq @global_id
+          expect(Shard.integral_id_for(@global_id.to_s)).to eq @global_id
+          expect(Shard.integral_id_for("#{@shard1.id}~#{@local_id}")).to eq @global_id
         end
 
         it "should work even for shards that don't exist" do
           shard = Shard.create!
           shard.destroy
           global_id = shard.global_id_for(1)
-          Shard.integral_id_for(global_id).should == global_id
-          Shard.integral_id_for(global_id.to_s).should == global_id
-          Shard.integral_id_for("#{shard.id}~1").should == global_id
+          expect(Shard.integral_id_for(global_id)).to eq global_id
+          expect(Shard.integral_id_for(global_id.to_s)).to eq global_id
+          expect(Shard.integral_id_for("#{shard.id}~1")).to eq global_id
         end
 
         it "should return nil for unrecognized ids" do
-          Shard.integral_id_for('not an id').should == nil
+          expect(Shard.integral_id_for('not an id')).to eq nil
         end
       end
 
       describe ".local_id_for" do
         it "should return id without shard for local id" do
-          Shard.local_id_for(@local_id).should == [@local_id, nil]
+          expect(Shard.local_id_for(@local_id)).to eq [@local_id, nil]
         end
 
         it "should return id with shard for global id" do
-          Shard.local_id_for(@global_id).should == [@local_id, @shard1]
+          expect(Shard.local_id_for(@global_id)).to eq [@local_id, @shard1]
         end
 
         it "should return nil for shards that don't exist" do
           shard = Shard.create!
           shard.destroy
-          Shard.local_id_for(shard.global_id_for(1)).should == [nil, nil]
+          expect(Shard.local_id_for(shard.global_id_for(1))).to eq [nil, nil]
         end
 
         it "should return nil for unrecognized ids" do
-          Shard.local_id_for('not an id').should == [nil, nil]
+          expect(Shard.local_id_for('not an id')).to eq [nil, nil]
         end
       end
 
       describe ".relative_id_for" do
         it "should return recognized ids relative to the target shard" do
-          Shard.relative_id_for(@local_id, @shard1, @shard2).should == @global_id
-          Shard.relative_id_for(@local_id, @shard2, @shard2).should == @local_id
-          Shard.relative_id_for(@global_id, @shard1, @shard2).should == @global_id
-          Shard.relative_id_for(@global_id, @shard2, @shard2).should == @global_id
+          expect(Shard.relative_id_for(@local_id, @shard1, @shard2)).to eq @global_id
+          expect(Shard.relative_id_for(@local_id, @shard2, @shard2)).to eq @local_id
+          expect(Shard.relative_id_for(@global_id, @shard1, @shard2)).to eq @global_id
+          expect(Shard.relative_id_for(@global_id, @shard2, @shard2)).to eq @global_id
         end
 
         it "should return the original id for unrecognized ids" do
-          Shard.relative_id_for('not an id', @shard1, @shard2).should == 'not an id'
+          expect(Shard.relative_id_for('not an id', @shard1, @shard2)).to eq 'not an id'
         end
       end
 
       describe ".short_id_for" do
         it "should return shorted strings for global ids" do
-          Shard.short_id_for(@local_id).should == @local_id
-          Shard.short_id_for("#{@local_id}").should == @local_id
-          Shard.short_id_for(@global_id).should == "#{@shard1.id}~#{@local_id}"
+          expect(Shard.short_id_for(@local_id)).to eq @local_id
+          expect(Shard.short_id_for("#{@local_id}")).to eq @local_id
+          expect(Shard.short_id_for(@global_id)).to eq "#{@shard1.id}~#{@local_id}"
         end
 
         it "should return the original id for unrecognized ids" do
-          Shard.short_id_for('not an id').should == 'not an id'
+          expect(Shard.short_id_for('not an id')).to eq 'not an id'
         end
       end
 
@@ -386,7 +386,7 @@ module Switchman
           local_id = 5
           Shard.with_each_shard do
             global_id = Shard.current.global_id_for(local_id)
-            Shard.global_id_for(global_id).should == global_id
+            expect(Shard.global_id_for(global_id)).to eq global_id
           end
         end
 
@@ -394,7 +394,7 @@ module Switchman
           local_id = 5
           Shard.with_each_shard do
             next if Shard.current == Shard.default
-            Shard.shard_for(Shard.global_id_for(local_id)).should == Shard.current
+            expect(Shard.shard_for(Shard.global_id_for(local_id))).to eq Shard.current
           end
         end
       end