ar-octopus 0.8.2 → 0.8.3

data/spec/octopus/relation_proxy_spec.rb

@@ -1,75 +1,75 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Octopus::RelationProxy do
-  describe "shard tracking" do
+  describe 'shard tracking' do
     before :each do
       @client = Client.using(:canada).create!
       @client.items << Item.using(:canada).create!
       @relation = @client.items
     end
 
-    it "remembers the shard on which a relation was created" do
-      @relation.current_shard.should eq(:canada)
+    it 'remembers the shard on which a relation was created' do
+      expect(@relation.current_shard).to eq(:canada)
     end
 
-    context "when comparing to other Relation objects" do
+    context 'when comparing to other Relation objects' do
       before :each do
         @relation.reset
       end
 
-      it "is equal to its clone" do
-        @relation.should eq(@relation.clone)
+      it 'is equal to its clone' do
+        expect(@relation).to eq(@relation.clone)
       end
     end
 
     if Octopus.rails4?
-      context "under Rails 4" do
-        it "is an Octopus::RelationProxy" do
-          @relation.class.should eq(Octopus::RelationProxy)
+      context 'under Rails 4' do
+        it 'is an Octopus::RelationProxy' do
+          expect(@relation.class).to eq(Octopus::RelationProxy)
         end
 
-        it "should be able to return its ActiveRecord::Relation" do
-          @relation.ar_relation.is_a?(ActiveRecord::Relation).should be_true
+        it 'should be able to return its ActiveRecord::Relation' do
+          expect(@relation.ar_relation.is_a?(ActiveRecord::Relation)).to be true
         end
 
-        it "is equal to an identically-defined, but different, RelationProxy" do
+        it 'is equal to an identically-defined, but different, RelationProxy' do
           i = @client.items
-          @relation.should eq(i)
-          @relation.object_id.should_not eq(i.object_id)
+          expect(@relation).to eq(i)
+          expect(@relation.object_id).not_to eq(i.object_id)
         end
 
-        it "is equal to its own underlying ActiveRecord::Relation" do
-          @relation.should eq(@relation.ar_relation)
-          @relation.ar_relation.should eq(@relation)
+        it 'is equal to its own underlying ActiveRecord::Relation' do
+          expect(@relation).to eq(@relation.ar_relation)
+          expect(@relation.ar_relation).to eq(@relation)
         end
       end
     end
 
-    context "when no explicit shard context is provided" do
-      it "uses the correct shard" do
-        @relation.count.should eq(1)
+    context 'when no explicit shard context is provided' do
+      it 'uses the correct shard' do
+        expect(@relation.count).to eq(1)
       end
 
-      it "lazily evaluates on the correct shard" do
+      it 'lazily evaluates on the correct shard' do
         # Do something to force Client.connection_proxy.current_shard to change
-        other_count = Client.using(:brazil).count
-        @relation.select(:client_id).count.should == 1
+        _some_count = Client.using(:brazil).count
+        expect(@relation.select(:client_id).count).to eq(1)
       end
     end
 
-    context "when an explicit, but different, shard context is provided" do
-      it "uses the correct shard" do
-        Item.using(:brazil).count.should eq(0)
-        clients_on_brazil = Client.using(:brazil).all
+    context 'when an explicit, but different, shard context is provided' do
+      it 'uses the correct shard' do
+        expect(Item.using(:brazil).count).to eq(0)
+        _clients_on_brazil = Client.using(:brazil).all
         Client.using(:brazil) do
-          @relation.count.should eq(1)
+          expect(@relation.count).to eq(1)
         end
       end
 
-      it "lazily evaluates on the correct shard" do
-        Item.using(:brazil).count.should eq(0)
+      it 'lazily evaluates on the correct shard' do
+        expect(Item.using(:brazil).count).to eq(0)
         Client.using(:brazil) do
-          @relation.select(:client_id).count.should == 1
+          expect(@relation.select(:client_id).count).to eq(1)
         end
       end
     end

data/spec/octopus/replicated_slave_grouped_spec.rb

@@ -1,14 +1,14 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe "when the database is replicated and has slave groups" do
+describe 'when the database is replicated and has slave groups' do
 
-  it "should pick the slave group based on current_slave_grup when you have a replicated model" do
+  it 'should pick the slave group based on current_slave_grup when you have a replicated model' do
 
     OctopusHelper.using_environment :replicated_slave_grouped do
       # The following two calls of `create!` both creates cats in :master(The database `octopus_shard_1`)
       # which is configured through RAILS_ENV and database.yml
-      Cat.create!(:name => "Thiago1")
-      Cat.create!(:name => "Thiago2")
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
 
       # See "replicated_slave_grouped" defined in shards.yml
       # We have:
@@ -18,47 +18,47 @@ describe "when the database is replicated and has slave groups" do
       # When a select-count query is sent to `octopus_shard_2`, it should return 0.
 
       # The query goes to `octopus_shard_1`
-      Cat.using(:master).count.should == 2
+      expect(Cat.using(:master).count).to eq(2)
       # The query goes to `octopus_shard_1`
-      Cat.count.should == 2
+      expect(Cat.count).to eq(2)
       # The query goes to `octopus_shard_2`
-      Cat.using(slave_group: :slaves1).count.should == 0
+      expect(Cat.using(:slave_group => :slaves1).count).to eq(0)
       # The query goes to `octopus_shard_1`
-      Cat.using(slave_group: :slaves2).count.should == 2
+      expect(Cat.using(:slave_group => :slaves2).count).to eq(2)
     end
   end
 
-  it "should distribute queries between slaves in a slave group in round-robin" do
+  it 'should distribute queries between slaves in a slave group in round-robin' do
     OctopusHelper.using_environment :replicated_slave_grouped do
       # The query goes to :master(`octopus_shard_1`)
-      Cat.create!(:name => "Thiago1")
+      Cat.create!(:name => 'Thiago1')
       # The query goes to :master(`octopus_shard_1`)
-      Cat.create!(:name => "Thiago2")
+      Cat.create!(:name => 'Thiago2')
 
       # The query goes to :slave32(`octopus_shard_2`)
-      Cat.using(slave_group: :slaves3).count.should == 0
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(0)
       # The query goes to :slave31(`octopus_shard_1`)
-      Cat.using(slave_group: :slaves3).count.should == 2
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(2)
       # The query goes to :slave32(`octopus_shard_2`)
-      Cat.using(slave_group: :slaves3).count.should == 0
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(0)
     end
   end
 
-  it "should make queries to master when slave groups are configured but not selected" do
+  it 'should make queries to master when slave groups are configured but not selected' do
     OctopusHelper.using_environment :replicated_slave_grouped do
       # All the queries go to :master(`octopus_shard_1`)
 
-      Cat.create!(:name => "Thiago1")
-      Cat.create!(:name => "Thiago2")
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
 
       # In `database.yml` and `shards.yml`, we have configured 1 master and 4 slaves.
       # So we can ensure Octopus is not distributing queries between them
       # by asserting 1 + 4 = 5 queries go to :master(`octopus_shard_1`)
-      Cat.count.should == 2
-      Cat.count.should == 2
-      Cat.count.should == 2
-      Cat.count.should == 2
-      Cat.count.should == 2
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
+      expect(Cat.count).to eq(2)
     end
   end
 end

data/spec/octopus/replication_spec.rb

@@ -1,69 +1,69 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe "when the database is replicated" do
-  it "should send all writes/reads queries to master when you have a non replicated model" do
+describe 'when the database is replicated' do
+  it 'should send all writes/reads queries to master when you have a non replicated model' do
     OctopusHelper.using_environment :production_replicated do
-      u = User.create!(:name => "Replicated")
-      User.count.should == 1
-      User.find(u.id).should == u
+      u = User.create!(:name => 'Replicated')
+      expect(User.count).to eq(1)
+      expect(User.find(u.id)).to eq(u)
     end
   end
 
-  it "should send all writes queries to master" do
+  it 'should send all writes queries to master' do
     OctopusHelper.using_environment :production_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.find_by_name("Slave Cat").should be_nil
-      Client.create!(:name => "Slave Client")
-      Client.find_by_name("Slave Client").should_not be_nil
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.find_by_name('Slave Cat')).to be_nil
+      Client.create!(:name => 'Slave Client')
+      expect(Client.find_by_name('Slave Client')).not_to be_nil
     end
   end
 
-  it "should allow to create multiple models on the master" do
+  it 'should allow to create multiple models on the master' do
     OctopusHelper.using_environment :production_replicated do
-      Cat.create!([{:name => "Slave Cat 1"}, {:name => "Slave Cat 2"}])
-      Cat.find_by_name("Slave Cat 1").should be_nil
-      Cat.find_by_name("Slave Cat 2").should be_nil
+      Cat.create!([{ :name => 'Slave Cat 1' }, { :name => 'Slave Cat 2' }])
+      expect(Cat.find_by_name('Slave Cat 1')).to be_nil
+      expect(Cat.find_by_name('Slave Cat 2')).to be_nil
     end
   end
 
-  describe "When enabling the query cache" do
-    include_context "with query cache enabled"
+  describe 'When enabling the query cache' do
+    include_context 'with query cache enabled'
 
-    it "should do the queries with cache" do
+    it 'should do the queries with cache' do
       OctopusHelper.using_environment :replicated_with_one_slave  do
-        cat1 = Cat.using(:master).create!(:name => "Master Cat 1")
-        cat2 = Cat.using(:master).create!(:name => "Master Cat 2")
-        Cat.using(:master).find(cat1.id).should eq(cat1)
-        Cat.using(:master).find(cat1.id).should eq(cat1)
-        Cat.using(:master).find(cat1.id).should eq(cat1)
-
-        cat3 = Cat.using(:slave1).create!(:name => "Slave Cat 3")
-        cat4 = Cat.using(:slave1).create!(:name => "Slave Cat 4")
-        Cat.find(cat3.id).id.should eq(cat3.id)
-        Cat.find(cat3.id).id.should eq(cat3.id)
-        Cat.find(cat3.id).id.should eq(cat3.id)
-
-        counter.query_count.should eq(16)
+        cat1 = Cat.using(:master).create!(:name => 'Master Cat 1')
+        _ct2 = Cat.using(:master).create!(:name => 'Master Cat 2')
+        expect(Cat.using(:master).find(cat1.id)).to eq(cat1)
+        expect(Cat.using(:master).find(cat1.id)).to eq(cat1)
+        expect(Cat.using(:master).find(cat1.id)).to eq(cat1)
+
+        cat3 = Cat.using(:slave1).create!(:name => 'Slave Cat 3')
+        _ct4 = Cat.using(:slave1).create!(:name => 'Slave Cat 4')
+        expect(Cat.find(cat3.id).id).to eq(cat3.id)
+        expect(Cat.find(cat3.id).id).to eq(cat3.id)
+        expect(Cat.find(cat3.id).id).to eq(cat3.id)
+
+        expect(counter.query_count).to eq(16)
       end
     end
   end
 
-  it "should allow #using syntax to send queries to master" do
-    Cat.create!(:name => "Master Cat")
+  it 'should allow #using syntax to send queries to master' do
+    Cat.create!(:name => 'Master Cat')
 
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.using(:master).find_by_name("Master Cat").should_not be_nil
+      expect(Cat.using(:master).find_by_name('Master Cat')).not_to be_nil
     end
   end
 
-  it "should send the count query to a slave" do
+  it 'should send the count query to a slave' do
     OctopusHelper.using_environment :production_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.count.should == 0
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.count).to eq(0)
     end
   end
 
-  def active_support_subscribed(callback, *args, &block)
+  def active_support_subscribed(callback, *args, &_block)
     subscriber = ActiveSupport::Notifications.subscribe(*args, &callback)
     yield
   ensure
@@ -71,51 +71,46 @@ describe "when the database is replicated" do
   end
 end
 
-
-describe "when the database is replicated and the entire application is replicated" do
+describe 'when the database is replicated and the entire application is replicated' do
   before(:each) do
-    Octopus.stub(:env).and_return("production_fully_replicated")
-    OctopusHelper.clean_connection_proxy()
+    allow(Octopus).to receive(:env).and_return('production_fully_replicated')
+    OctopusHelper.clean_connection_proxy
   end
 
-  it "should send all writes queries to master" do
+  it 'should send all writes queries to master' do
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.find_by_name("Slave Cat").should be_nil
-      Client.create!(:name => "Slave Client")
-      Client.find_by_name("Slave Client").should be_nil
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.find_by_name('Slave Cat')).to be_nil
+      Client.create!(:name => 'Slave Client')
+      expect(Client.find_by_name('Slave Client')).to be_nil
     end
   end
 
-  it "should send all writes queries to master" do
+  it 'should send all writes queries to master' do
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.find_by_name("Slave Cat").should be_nil
-      Client.create!(:name => "Slave Client")
-      Client.find_by_name("Slave Client").should be_nil
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.find_by_name('Slave Cat')).to be_nil
+      Client.create!(:name => 'Slave Client')
+      expect(Client.find_by_name('Slave Client')).to be_nil
     end
   end
 
-  it "should work with validate_uniquess_of" do
-    Keyboard.create!(:name => "thiago")
+  it 'should work with validate_uniquess_of' do
+    Keyboard.create!(:name => 'thiago')
 
     OctopusHelper.using_environment :production_fully_replicated do
-      k = Keyboard.new(:name => "thiago")
-      k.save.should be_false
-      k.errors.full_messages.should == ["Name has already been taken"]
+      k = Keyboard.new(:name => 'thiago')
+      expect(k.save).to be false
+      expect(k.errors.full_messages).to eq(['Name has already been taken'])
     end
   end
 
-  it "should reset current shard if slave throws an exception" do
+  it 'should reset current shard if slave throws an exception' do
     OctopusHelper.using_environment :production_fully_replicated do
-      Cat.create!(:name => "Slave Cat")
-      Cat.connection.current_shard.should eql(:master)
-      begin
-        Cat.where(:rubbish => true)
-      rescue
-      end
-      Cat.connection.current_shard.should eql(:master)
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.connection.current_shard).to eql(:master)
+      Cat.where(:rubbish => true)
+      expect(Cat.connection.current_shard).to eql(:master)
     end
   end
 end
-

data/spec/octopus/scope_proxy_spec.rb

@@ -1,17 +1,63 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Octopus::ScopeProxy do
-  it "should allow nested queries" do
-    @user1 = User.using(:brazil).create!(:name => "Thiago P", :number => 3)
-    @user2 = User.using(:brazil).create!(:name => "Thiago", :number => 1)
-    @user3 = User.using(:brazil).create!(:name => "Thiago", :number => 2)
-
-    User.using(:brazil).where(:name => "Thiago").where(:number => 4).order(:number).all.should == []
-    User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 2).using(:brazil).order(:number).all.should == [@user3]
-    User.using(:brazil).where(:name => "Thiago").using(:canada).where(:number => 4).using(:brazil).order(:number).all.should == []
+  it 'should allow nested queries' do
+    @user1 = User.using(:brazil).create!(:name => 'Thiago P', :number => 3)
+    @user2 = User.using(:brazil).create!(:name => 'Thiago', :number => 1)
+    @user3 = User.using(:brazil).create!(:name => 'Thiago', :number => 2)
+
+    expect(User.using(:brazil).where(:name => 'Thiago').where(:number => 4).order(:number).all).to eq([])
+    expect(User.using(:brazil).where(:name => 'Thiago').using(:canada).where(:number => 2).using(:brazil).order(:number).all).to eq([@user3])
+    expect(User.using(:brazil).where(:name => 'Thiago').using(:canada).where(:number => 4).using(:brazil).order(:number).all).to eq([])
+  end
+
+  context "When array-like-selecting an item in a group" do
+    before(:each) do
+      User.using(:brazil).create!(:name => "Evan", :number => 1)
+      User.using(:brazil).create!(:name => "Evan", :number => 2)
+      User.using(:brazil).create!(:name => "Evan", :number => 3)
+      @evans = User.using(:brazil).where(:name => "Evan")
+    end
+
+    it "allows a block to select an item" do
+      @evans.select{|u| u.number == 2}.first.number.should eq(2)
+    end
+  end
+
+  context "When selecting a field within a scope" do
+    before(:each) do
+      User.using(:brazil).create!(:name => "Evan", :number => 4)
+      @evan = User.using(:brazil).where(:name => "Evan")
+    end
+
+    it "allows single field selection" do
+      @evan.select("name").first.name.should eq("Evan")
+    end
+
+    it "allows selection by array" do
+      @evan.select(["name"]).first.name.should eq("Evan")
+    end
+
+    it "allows multiple selection by string" do
+      @evan.select("id, name").first.id.should be_a Fixnum
+    end
+
+    it "allows multiple selection by array" do
+      @evan.select(["id", "name"]).first.id.should be_a Fixnum
+    end
+
+    if Octopus.rails4?
+      it "allows multiple selection by symbol" do
+        @evan.select(:id, :name).first.id.should be_a Fixnum
+      end
+
+      it "allows multiple selection by string and symbol" do
+        @evan.select(:id, "name").first.id.should be_a Fixnum
+      end
+    end
   end
 
   it "should raise a exception when trying to send a query to a shard that don't exists" do
-    lambda { User.using(:dont_exists).all }.should raise_exception("Nonexistent Shard Name: dont_exists")
+    expect { User.using(:dont_exists).all }.to raise_exception('Nonexistent Shard Name: dont_exists')
   end
 end