ar-octopus 0.8.2 → 0.8.3

data/sample_app/features/support/env.rb

@@ -12,8 +12,8 @@ require 'cucumber/rails'
 # Capybara.default_selector = :xpath
 
 # By default, any exception happening in your Rails application will bubble up
-# to Cucumber so that your scenario will fail. This is a different from how 
-# your application behaves in the production environment, where an error page will 
+# to Cucumber so that your scenario will fail. This is a different from how
+# your application behaves in the production environment, where an error page will
 # be rendered instead.
 #
 # Sometimes we want to override this default behaviour and allow Rails to rescue
@@ -33,7 +33,7 @@ ActionController::Base.allow_rescue = false
 begin
   DatabaseCleaner.strategy = :transaction
 rescue NameError
-  raise "You need to add database_cleaner to your Gemfile (in the :test group) if you wish to use it."
+  raise 'You need to add database_cleaner to your Gemfile (in the :test group) if you wish to use it.'
 end
 
 # You may also want to configure DatabaseCleaner to use different strategies for certain features and scenarios.
@@ -55,4 +55,3 @@ end
 # The :transaction strategy is faster, but might give you threading problems.
 # See https://github.com/cucumber/cucumber-rails/blob/master/features/choose_javascript_database_strategy.feature
 Cucumber::Rails::Database.javascript_strategy = :truncation
-

data/sample_app/features/support/paths.rb

@@ -20,10 +20,10 @@ module NavigationHelpers
     else
       begin
         page_name =~ /the (.*) page/
-        path_components = $1.split(/\s+/)
-        self.send(path_components.push('path').join('_').to_sym)
-      rescue Object => e
-        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        path_components = Regexp.last_match[1].split(/\s+/)
+        send(path_components.push('path').join('_').to_sym)
+      rescue
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" \
           "Now, go and add a mapping in #{__FILE__}"
       end
     end

data/sample_app/spec/spec_helper.rb

@@ -1,12 +1,12 @@
 # This file is copied to ~/spec when you run 'ruby script/generate rspec'
 # from the project root directory.
-ENV["RAILS_ENV"] ||= 'test'
-require File.expand_path("../../config/environment", __FILE__)
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../../config/environment', __FILE__)
 require 'rspec/rails'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
   # == Mock Framework

data/spec/migrations/10_create_users_using_replication.rb

@@ -1,9 +1,9 @@
 class CreateUsersUsingReplication < ActiveRecord::Migration
   def self.up
-    Cat.create!(:name => "Replication")
+    Cat.create!(:name => 'Replication')
   end
 
   def self.down
-    Cat.delete_all()
+    Cat.delete_all
   end
-end
+end

data/spec/migrations/11_add_field_in_all_slaves.rb

@@ -2,10 +2,10 @@ class AddFieldInAllSlaves < ActiveRecord::Migration
   using(:slave1, :slave2, :slave3, :slave4)
 
   def self.up
-    Cat.create!(:name => "Slaves")
+    Cat.create!(:name => 'Slaves')
   end
 
   def self.down
-    Cat.delete_all()
+    Cat.delete_all
   end
-end
+end

data/spec/migrations/12_create_users_using_block.rb

@@ -1,23 +1,23 @@
 class CreateUsersUsingBlock < ActiveRecord::Migration
   def self.up
     Octopus.using(:brazil) do
-      User.create!(:name => "UsingBlock1")
-      User.create!(:name => "UsingBlock2")
+      User.create!(:name => 'UsingBlock1')
+      User.create!(:name => 'UsingBlock2')
     end
 
     Octopus.using(:canada) do
-      User.create!(:name => "UsingCanada")
-      User.create!(:name => "UsingCanada2")
+      User.create!(:name => 'UsingCanada')
+      User.create!(:name => 'UsingCanada2')
     end
   end
 
   def self.down
     Octopus.using(:brazil) do
-      User.delete_all()
+      User.delete_all
     end
 
     Octopus.using(:canada) do
-      User.delete_all()
+      User.delete_all
     end
   end
-end
+end

data/spec/migrations/13_create_users_using_block_and_using.rb

@@ -3,13 +3,13 @@ class CreateUsersUsingBlockAndUsing < ActiveRecord::Migration
 
   def self.up
     Octopus.using(:canada) do
-      User.create!(:name => "Canada")
+      User.create!(:name => 'Canada')
     end
 
-    User.create!(:name => "Brazil")
+    User.create!(:name => 'Brazil')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/14_create_users_on_shards_of_a_group_with_versions.rb

@@ -2,10 +2,10 @@ class CreateUsersOnShardsOfAGroupWithVersions < ActiveRecord::Migration
   using_group(:country_shards)
 
   def self.up
-    User.create!(:name => "Group")
+    User.create!(:name => 'Group')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
 end

data/spec/migrations/15_create_user_on_shards_of_default_group_with_versions.rb

@@ -1,9 +1,9 @@
 class CreateUserOnShardsOfDefaultGroupWithVersions < ActiveRecord::Migration
   def self.up
-    User.create!(:name => "Default Group")
+    User.create!(:name => 'Default Group')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
 end

data/spec/migrations/1_create_users_on_master.rb

@@ -1,9 +1,9 @@
 class CreateUsersOnMaster < ActiveRecord::Migration
   def self.up
-    User.create!(:name => "Master")
+    User.create!(:name => 'Master')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/2_create_users_on_canada.rb

@@ -2,10 +2,10 @@ class CreateUsersOnCanada < ActiveRecord::Migration
   using(:canada)
 
   def self.up
-    User.create!(:name => "Sharding")
+    User.create!(:name => 'Sharding')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/3_create_users_on_both_shards.rb

@@ -2,10 +2,10 @@ class CreateUsersOnBothShards < ActiveRecord::Migration
   using(:brazil, :canada)
 
   def self.up
-    User.create!(:name => "Both")
+    User.create!(:name => 'Both')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/4_create_users_on_shards_of_a_group.rb

@@ -2,10 +2,10 @@ class CreateUsersOnShardsOfAGroup < ActiveRecord::Migration
   using_group(:country_shards)
 
   def self.up
-    User.create!(:name => "Group")
+    User.create!(:name => 'Group')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/5_create_users_on_multiples_groups.rb

@@ -2,10 +2,10 @@ class CreateUsersOnMultiplesGroups < ActiveRecord::Migration
   using_group('country_shards', 'history_shards')
 
   def self.up
-    User.create!(:name => "MultipleGroup")
+    User.create!(:name => 'MultipleGroup')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
 end

data/spec/migrations/6_raise_exception_with_invalid_shard_name.rb

@@ -2,10 +2,10 @@ class RaiseExceptionWithInvalidShardName < ActiveRecord::Migration
   using(:amazing_shard)
 
   def self.up
-    User.create!(:name => "Error")
+    User.create!(:name => 'Error')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/7_raise_exception_with_invalid_multiple_shard_names.rb

@@ -2,10 +2,10 @@ class RaiseExceptionWithInvalidMultipleShardNames < ActiveRecord::Migration
   using(:brazil, :invalid_shard)
 
   def self.up
-    User.create!(:name => "Error")
+    User.create!(:name => 'Error')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/8_raise_exception_with_invalid_group_name.rb

@@ -2,10 +2,10 @@ class RaiseExceptionWithInvalidGroupName < ActiveRecord::Migration
   using_group(:invalid_group)
 
   def self.up
-    User.create!(:name => "Error")
+    User.create!(:name => 'Error')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/migrations/9_raise_exception_with_multiple_invalid_group_names.rb

@@ -1,11 +1,11 @@
 class RaiseExceptionWithMultipleInvalidGroupNames < ActiveRecord::Migration
-  using_group(:country_shards,:invalid_group)
+  using_group(:country_shards, :invalid_group)
 
   def self.up
-    User.create!(:name => "Error")
+    User.create!(:name => 'Error')
   end
 
   def self.down
-    User.delete_all()
+    User.delete_all
   end
-end
+end

data/spec/octopus/association_shard_tracking_spec.rb

@@ -1,430 +1,427 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canada] do
-  describe "when you have a 1 x 1 relationship" do
+  describe 'when you have a 1 x 1 relationship' do
     before(:each) do
-      @computer_brazil = Computer.using(:brazil).create!(:name => "Computer Brazil")
-      @computer_master = Computer.create!(:name => "Computer Brazil")
-      @keyboard_brazil = Keyboard.using(:brazil).create!(:name => "Keyboard Brazil", :computer => @computer_brazil)
-      @keyboard_master = Keyboard.create!(:name => "Keyboard Master", :computer => @computer_master)
+      @computer_brazil = Computer.using(:brazil).create!(:name => 'Computer Brazil')
+      @computer_master = Computer.create!(:name => 'Computer Brazil')
+      @keyboard_brazil = Keyboard.using(:brazil).create!(:name => 'Keyboard Brazil', :computer => @computer_brazil)
+      @keyboard_master = Keyboard.create!(:name => 'Keyboard Master', :computer => @computer_master)
     end
 
-    it "should find the models" do
-      @keyboard_master.computer.should == @computer_master
-      @keyboard_brazil.computer.should == @computer_brazil
+    it 'should find the models' do
+      expect(@keyboard_master.computer).to eq(@computer_master)
+      expect(@keyboard_brazil.computer).to eq(@computer_brazil)
     end
 
-    it "should read correctly the relationed model" do
-      new_computer_brazil = Computer.using(:brazil).create!(:name => "New Computer Brazil")
-      new_computer_master = Computer.create!(:name => "New Computer Brazil")
+    it 'should read correctly the relationed model' do
+      new_computer_brazil = Computer.using(:brazil).create!(:name => 'New Computer Brazil')
+      _new_computer_hello = Computer.create!(:name => 'New Computer Brazil')
       @keyboard_brazil.computer = new_computer_brazil
-      @keyboard_brazil.save()
+      @keyboard_brazil.save
       @keyboard_brazil.reload
-      @keyboard_brazil.computer_id.should ==  new_computer_brazil.id
-      @keyboard_brazil.computer.should ==  new_computer_brazil
-      new_computer_brazil.save()
+      expect(@keyboard_brazil.computer_id).to eq(new_computer_brazil.id)
+      expect(@keyboard_brazil.computer).to eq(new_computer_brazil)
+      new_computer_brazil.save
       new_computer_brazil.reload
-      new_computer_brazil.keyboard.should == @keyboard_brazil
+      expect(new_computer_brazil.keyboard).to eq(@keyboard_brazil)
     end
 
-    it "should work when using #build_computer or #build_keyboard" do
-      c = Computer.using(:brazil).create!(:name => "Computer Brazil")
-      k = c.build_keyboard(:name => "Building keyboard")
-      c.save()
-      k.save()
-      c.keyboard.should == k
-      k.computer_id.should == c.id
-      k.computer.should == c
+    it 'should work when using #build_computer or #build_keyboard' do
+      c = Computer.using(:brazil).create!(:name => 'Computer Brazil')
+      k = c.build_keyboard(:name => 'Building keyboard')
+      c.save
+      k.save
+      expect(c.keyboard).to eq(k)
+      expect(k.computer_id).to eq(c.id)
+      expect(k.computer).to eq(c)
     end
 
-    it "should work when using #create_computer or #create_keyboard" do
-      c = Computer.using(:brazil).create!(:name => "Computer Brazil")
-      k = c.create_keyboard(:name => "Building keyboard")
-      c.save()
-      k.save()
-      c.keyboard.should == k
-      k.computer_id.should == c.id
-      k.computer.should == c
+    it 'should work when using #create_computer or #create_keyboard' do
+      c = Computer.using(:brazil).create!(:name => 'Computer Brazil')
+      k = c.create_keyboard(:name => 'Building keyboard')
+      c.save
+      k.save
+      expect(c.keyboard).to eq(k)
+      expect(k.computer_id).to eq(c.id)
+      expect(k.computer).to eq(c)
     end
 
-    it "should include models" do
-      c = Computer.using(:brazil).create!(:name => "Computer Brazil")
-      k = c.create_keyboard(:name => "Building keyboard")
-      c.save()
-      k.save()
+    it 'should include models' do
+      c = Computer.using(:brazil).create!(:name => 'Computer Brazil')
+      k = c.create_keyboard(:name => 'Building keyboard')
+      c.save
+      k.save
 
-      Computer.using(:brazil).includes(:keyboard).find(c.id).should == c
+      expect(Computer.using(:brazil).includes(:keyboard).find(c.id)).to eq(c)
     end
   end
 
-  describe "when you have a N x N relationship" do
+  describe 'when you have a N x N relationship' do
     before(:each) do
-      @brazil_role = Role.using(:brazil).create!(:name => "Brazil Role")
-      @master_role = Role.create!(:name => "Master Role")
-      @permission_brazil = Permission.using(:brazil).create!(:name => "Brazil Permission")
-      @permission_master = Permission.using(:master).create!(:name => "Master Permission")
+      @brazil_role = Role.using(:brazil).create!(:name => 'Brazil Role')
+      @master_role = Role.create!(:name => 'Master Role')
+      @permission_brazil = Permission.using(:brazil).create!(:name => 'Brazil Permission')
+      @permission_master = Permission.using(:master).create!(:name => 'Master Permission')
       @brazil_role.permissions << @permission_brazil
-      @brazil_role.save()
-      Client.using(:master).create!(:name => "teste")
+      @brazil_role.save
+      Client.using(:master).create!(:name => 'teste')
     end
 
-    it "should find all models in the specified shard" do
-      @brazil_role.permission_ids().should == [@permission_brazil.id]
-      @brazil_role.permissions().should == [@permission_brazil]
+    it 'should find all models in the specified shard' do
+      expect(@brazil_role.permission_ids).to eq([@permission_brazil.id])
+      expect(@brazil_role.permissions).to eq([@permission_brazil])
 
-      @brazil_role.permissions.first.should eq(@permission_brazil)
-      @brazil_role.permissions.last.should eq(@permission_brazil)
+      expect(@brazil_role.permissions.first).to eq(@permission_brazil)
+      expect(@brazil_role.permissions.last).to eq(@permission_brazil)
     end
 
-    it "should finds the client that the item belongs" do
-      @permission_brazil.role_ids.should == [@brazil_role.id]
-      @permission_brazil.roles.should == [@brazil_role]
+    it 'should finds the client that the item belongs' do
+      expect(@permission_brazil.role_ids).to eq([@brazil_role.id])
+      expect(@permission_brazil.roles).to eq([@brazil_role])
 
-      @permission_brazil.roles.first.should eq(@brazil_role)
-      @permission_brazil.roles.last.should eq(@brazil_role)
+      expect(@permission_brazil.roles.first).to eq(@brazil_role)
+      expect(@permission_brazil.roles.last).to eq(@brazil_role)
     end
 
-    it "should update the attribute for the item" do
-      new_brazil_role = Role.using(:brazil).create!(:name => "new Role")
+    it 'should update the attribute for the item' do
+      new_brazil_role = Role.using(:brazil).create!(:name => 'new Role')
       @permission_brazil.roles = [new_brazil_role]
-      @permission_brazil.roles.should == [new_brazil_role]
-      @permission_brazil.save()
+      expect(@permission_brazil.roles).to eq([new_brazil_role])
+      @permission_brazil.save
       @permission_brazil.reload
-      @permission_brazil.role_ids.should == [new_brazil_role.id]
-      @permission_brazil.roles().should == [new_brazil_role]
+      expect(@permission_brazil.role_ids).to eq([new_brazil_role.id])
+      expect(@permission_brazil.roles).to eq([new_brazil_role])
     end
 
-    it "should works for build method" do
-      new_brazil_role = Role.using(:brazil).create!(:name => "Brazil Role")
-      c = new_brazil_role.permissions.create(:name => "new Permission")
-      c.save()
-      new_brazil_role.save()
-      c.roles().should == [new_brazil_role]
-      new_brazil_role.permissions.should == [c]
+    it 'should works for build method' do
+      new_brazil_role = Role.using(:brazil).create!(:name => 'Brazil Role')
+      c = new_brazil_role.permissions.create(:name => 'new Permission')
+      c.save
+      new_brazil_role.save
+      expect(c.roles).to eq([new_brazil_role])
+      expect(new_brazil_role.permissions).to eq([c])
     end
 
-    describe "it should works when using" do
+    describe 'it should works when using' do
       before(:each) do
-        @permission_brazil_2 = Permission.using(:brazil).create!(:name => "Brazil Item 2")
-        @role = Role.using(:brazil).create!(:name => "testes")
+        @permission_brazil_2 = Permission.using(:brazil).create!(:name => 'Brazil Item 2')
+        @role = Role.using(:brazil).create!(:name => 'testes')
       end
 
-      it "update_attributes" do
+      it 'update_attributes' do
         @permission_brazil_2.update_attributes(:role_ids => [@role.id])
-        @permission_brazil_2.roles.to_set.should == [@role].to_set
+        expect(@permission_brazil_2.roles.to_set).to eq([@role].to_set)
       end
 
-      it "update_attribute" do
+      it 'update_attribute' do
         @permission_brazil_2.update_attribute(:role_ids, [@role.id])
-        @permission_brazil_2.roles.to_set.should == [@role].to_set
+        expect(@permission_brazil_2.roles.to_set).to eq([@role].to_set)
       end
 
-      it "<<" do
+      it '<<' do
         @permission_brazil_2.roles << @role
-        @role.save()
-        @permission_brazil_2.save()
+        @role.save
+        @permission_brazil_2.save
         @permission_brazil_2.reload
-        @permission_brazil_2.roles.to_set.should == [@role].to_set
+        expect(@permission_brazil_2.roles.to_set).to eq([@role].to_set)
       end
 
-      it "build" do
-        role = @permission_brazil_2.roles.build(:name => "Builded Role")
-        @permission_brazil_2.save()
-        @permission_brazil_2.roles.to_set.should == [role].to_set
+      it 'build' do
+        role = @permission_brazil_2.roles.build(:name => 'Builded Role')
+        @permission_brazil_2.save
+        expect(@permission_brazil_2.roles.to_set).to eq([role].to_set)
       end
 
-      it "create" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.to_set.should == [role].to_set
+      it 'create' do
+        role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.to_set).to eq([role].to_set)
       end
 
-      it "create" do
-        role = @permission_brazil_2.roles.create!(:name => "Builded Role")
-        @permission_brazil_2.roles.to_set.should == [role].to_set
+      it 'create' do
+        role = @permission_brazil_2.roles.create!(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.to_set).to eq([role].to_set)
       end
 
-      it "count" do
-        @permission_brazil_2.roles.count.should == 0
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.count.should == 1
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.count.should == 2
+      it 'count' do
+        expect(@permission_brazil_2.roles.count).to eq(0)
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.count).to eq(1)
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.count).to eq(2)
       end
 
-      it "size" do
-        @permission_brazil_2.roles.size.should == 0
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.size.should == 1
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.size.should == 2
+      it 'size' do
+        expect(@permission_brazil_2.roles.size).to eq(0)
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.size).to eq(1)
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.size).to eq(2)
       end
 
-      it "length" do
-        @permission_brazil_2.roles.length.should == 0
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.length.should == 1
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.length.should == 2
+      it 'length' do
+        expect(@permission_brazil_2.roles.length).to eq(0)
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.length).to eq(1)
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.length).to eq(2)
       end
 
-
-      it "empty?" do
-        @permission_brazil_2.roles.empty?.should be_true
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.empty?.should be_false
+      it 'empty?' do
+        expect(@permission_brazil_2.roles.empty?).to be true
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.empty?).to be false
       end
 
-      it "delete_all" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.empty?.should be_false
+      it 'delete_all' do
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.empty?).to be false
         @permission_brazil_2.roles.delete_all
-        @permission_brazil_2.roles.empty?.should be_true
+        expect(@permission_brazil_2.roles.empty?).to be true
       end
 
-      it "destroy_all" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.empty?.should be_false
+      it 'destroy_all' do
+        _role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.empty?).to be false
         @permission_brazil_2.roles.destroy_all
-        @permission_brazil_2.roles.empty?.should be_true
+        expect(@permission_brazil_2.roles.empty?).to be true
       end
 
-      it "find" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.first.should == role
+      it 'find' do
+        role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.first).to eq(role)
         @permission_brazil_2.roles.destroy_all
-        @permission_brazil_2.roles.first.should be_nil
+        expect(@permission_brazil_2.roles.first).to be_nil
       end
 
-      it "exists?" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.exists?(role).should be_true
+      it 'exists?' do
+        role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.exists?(role)).to be true
         @permission_brazil_2.roles.destroy_all
-        @permission_brazil_2.roles.exists?(role).should be_false
+        expect(@permission_brazil_2.roles.exists?(role)).to be false
       end
 
-      it "clear" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.empty?.should be_false
+      it 'clear' do
+        _rol = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.empty?).to be false
         @permission_brazil_2.roles.clear
-        @permission_brazil_2.roles.empty?.should be_true
+        expect(@permission_brazil_2.roles.empty?).to be true
       end
 
-      it "delete" do
-        role = @permission_brazil_2.roles.create(:name => "Builded Role")
-        @permission_brazil_2.roles.empty?.should be_false
+      it 'delete' do
+        role = @permission_brazil_2.roles.create(:name => 'Builded Role')
+        expect(@permission_brazil_2.roles.empty?).to be false
         @permission_brazil_2.roles.delete(role)
         @permission_brazil_2.reload
         @role.reload
-        @role.permissions.should == []
-        @permission_brazil_2.roles.should == []
+        expect(@role.permissions).to eq([])
+        expect(@permission_brazil_2.roles).to eq([])
       end
     end
   end
 
-  describe "when you have has_many :through" do
+  describe 'when you have has_many :through' do
     before(:each) do
-      @programmer = Programmer.using(:brazil).create!(:name => "Thiago")
-      @project = Project.using(:brazil).create!(:name => "RubySoc")
-      @project2 = Project.using(:brazil).create!(:name => "Cobol Application")
+      @programmer = Programmer.using(:brazil).create!(:name => 'Thiago')
+      @project = Project.using(:brazil).create!(:name => 'RubySoc')
+      @project2 = Project.using(:brazil).create!(:name => 'Cobol Application')
       @programmer.projects << @project
-      @programmer.save()
-      Project.using(:master).create!(:name => "Project Master")
+      @programmer.save
+      Project.using(:master).create!(:name => 'Project Master')
     end
 
-    it "should find all models in the specified shard" do
-      @programmer.project_ids().should eq([@project.id])
-      @programmer.projects().should eq([@project])
+    it 'should find all models in the specified shard' do
+      expect(@programmer.project_ids).to eq([@project.id])
+      expect(@programmer.projects).to eq([@project])
 
-      @programmer.projects.first.should eq(@project)
-      @programmer.projects.last.should eq(@project)
+      expect(@programmer.projects.first).to eq(@project)
+      expect(@programmer.projects.last).to eq(@project)
     end
 
-
-    it "should update the attribute for the item" do
-      new_brazil_programmer = Programmer.using(:brazil).create!(:name => "Joao")
+    it 'should update the attribute for the item' do
+      new_brazil_programmer = Programmer.using(:brazil).create!(:name => 'Joao')
       @project.programmers = [new_brazil_programmer]
-      @project.programmers.should == [new_brazil_programmer]
-      @project.save()
+      expect(@project.programmers).to eq([new_brazil_programmer])
+      @project.save
       @project.reload
-      @project.programmer_ids.should == [new_brazil_programmer.id]
-      @project.programmers().should == [new_brazil_programmer]
+      expect(@project.programmer_ids).to eq([new_brazil_programmer.id])
+      expect(@project.programmers).to eq([new_brazil_programmer])
     end
 
-    it "should works for create method" do
-      new_brazil_programmer = Programmer.using(:brazil).create!(:name => "Joao")
-      c = new_brazil_programmer.projects.create(:name => "new Project")
-      c.save()
-      new_brazil_programmer.save()
-      c.programmers().should == [new_brazil_programmer]
-      new_brazil_programmer.projects.should == [c]
+    it 'should works for create method' do
+      new_brazil_programmer = Programmer.using(:brazil).create!(:name => 'Joao')
+      c = new_brazil_programmer.projects.create(:name => 'new Project')
+      c.save
+      new_brazil_programmer.save
+      expect(c.programmers).to eq([new_brazil_programmer])
+      expect(new_brazil_programmer.projects).to eq([c])
     end
 
-    describe "it should works when using" do
+    describe 'it should works when using' do
       before(:each) do
-        @new_brazil_programmer = Programmer.using(:brazil).create!(:name => "Jose")
-        @project = Project.using(:brazil).create!(:name => "VB Application :-(")
+        @new_brazil_programmer = Programmer.using(:brazil).create!(:name => 'Jose')
+        @project = Project.using(:brazil).create!(:name => 'VB Application :-(')
       end
 
-      it "update_attributes" do
+      it 'update_attributes' do
         @new_brazil_programmer.update_attributes(:project_ids => [@project.id])
-        @new_brazil_programmer.projects.to_set.should == [@project].to_set
+        expect(@new_brazil_programmer.projects.to_set).to eq([@project].to_set)
       end
 
-      it "update_attribute" do
+      it 'update_attribute' do
         @new_brazil_programmer.update_attribute(:project_ids, [@project.id])
-        @new_brazil_programmer.projects.to_set.should == [@project].to_set
+        expect(@new_brazil_programmer.projects.to_set).to eq([@project].to_set)
       end
 
-      it "<<" do
+      it '<<' do
         @new_brazil_programmer.projects << @project
-        @project.save()
-        @new_brazil_programmer.save()
+        @project.save
+        @new_brazil_programmer.save
         @new_brazil_programmer.reload
-        @new_brazil_programmer.projects.to_set.should == [@project].to_set
+        expect(@new_brazil_programmer.projects.to_set).to eq([@project].to_set)
       end
 
-      it "build" do
-        role = @new_brazil_programmer.projects.build(:name => "New VB App :-/")
-        @new_brazil_programmer.save()
-        @new_brazil_programmer.projects.to_set.should == [role].to_set
+      it 'build' do
+        role = @new_brazil_programmer.projects.build(:name => 'New VB App :-/')
+        @new_brazil_programmer.save
+        expect(@new_brazil_programmer.projects.to_set).to eq([role].to_set)
       end
 
-      it "create" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.to_set.should == [role].to_set
+      it 'create' do
+        role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.to_set).to eq([role].to_set)
       end
 
-      it "create" do
-        role = @new_brazil_programmer.projects.create!(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.to_set.should == [role].to_set
+      it 'create' do
+        role = @new_brazil_programmer.projects.create!(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.to_set).to eq([role].to_set)
       end
 
-      it "count" do
-        @new_brazil_programmer.projects.count.should == 0
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.count.should == 1
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.count.should == 2
+      it 'count' do
+        expect(@new_brazil_programmer.projects.count).to eq(0)
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.count).to eq(1)
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.count).to eq(2)
       end
 
-      it "size" do
-        @new_brazil_programmer.projects.size.should == 0
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.size.should == 1
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.size.should == 2
+      it 'size' do
+        expect(@new_brazil_programmer.projects.size).to eq(0)
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.size).to eq(1)
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.size).to eq(2)
       end
 
-      it "length" do
-        @new_brazil_programmer.projects.length.should == 0
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.length.should == 1
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.length.should == 2
+      it 'length' do
+        expect(@new_brazil_programmer.projects.length).to eq(0)
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.length).to eq(1)
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.length).to eq(2)
       end
 
-
-      it "empty?" do
-        @new_brazil_programmer.projects.empty?.should be_true
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.empty?.should be_false
+      it 'empty?' do
+        expect(@new_brazil_programmer.projects.empty?).to be true
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.empty?).to be false
       end
 
-      it "delete_all" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.empty?.should be_false
+      it 'delete_all' do
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.empty?).to be false
         @new_brazil_programmer.projects.delete_all
-        @new_brazil_programmer.projects.empty?.should be_true
+        expect(@new_brazil_programmer.projects.empty?).to be true
       end
 
-      it "destroy_all" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.empty?.should be_false
+      it 'destroy_all' do
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.empty?).to be false
         @new_brazil_programmer.projects.destroy_all
-        @new_brazil_programmer.projects.empty?.should be_true
+        expect(@new_brazil_programmer.projects.empty?).to be true
       end
 
-      it "find" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.first.should == role
+      it 'find' do
+        role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.first).to eq(role)
         @new_brazil_programmer.projects.destroy_all
-        @new_brazil_programmer.projects.first.should be_nil
+        expect(@new_brazil_programmer.projects.first).to be_nil
       end
 
-      it "exists?" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.exists?(role).should be_true
+      it 'exists?' do
+        role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.exists?(role)).to be true
         @new_brazil_programmer.projects.destroy_all
-        @new_brazil_programmer.projects.exists?(role).should be_false
+        expect(@new_brazil_programmer.projects.exists?(role)).to be false
       end
 
-      it "clear" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.empty?.should be_false
+      it 'clear' do
+        _role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.empty?).to be false
         @new_brazil_programmer.projects.clear
-        @new_brazil_programmer.projects.empty?.should be_true
+        expect(@new_brazil_programmer.projects.empty?).to be true
       end
 
-      it "delete" do
-        role = @new_brazil_programmer.projects.create(:name => "New VB App :-/")
-        @new_brazil_programmer.projects.empty?.should be_false
+      it 'delete' do
+        role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
+        expect(@new_brazil_programmer.projects.empty?).to be false
         @new_brazil_programmer.projects.delete(role)
         @new_brazil_programmer.reload
         @project.reload
-        @project.programmers.should == []
-        @new_brazil_programmer.projects.should == []
+        expect(@project.programmers).to eq([])
+        expect(@new_brazil_programmer.projects).to eq([])
       end
     end
   end
 
-  describe "when you have a 1 x N relationship" do
+  describe 'when you have a 1 x N relationship' do
     before(:each) do
-      @brazil_client = Client.using(:brazil).create!(:name => "Brazil Client")
-      @master_client = Client.create!(:name => "Master Client")
-      @item_brazil = Item.using(:brazil).create!(:name => "Brazil Item", :client => @brazil_client)
-      @item_master = Item.create!(:name => "Master Item", :client => @master_client)
-      @brazil_client = Client.using(:brazil).find_by_name("Brazil Client")
-      Client.using(:master).create!(:name => "teste")
+      @brazil_client = Client.using(:brazil).create!(:name => 'Brazil Client')
+      @master_client = Client.create!(:name => 'Master Client')
+      @item_brazil = Item.using(:brazil).create!(:name => 'Brazil Item', :client => @brazil_client)
+      @item_master = Item.create!(:name => 'Master Item', :client => @master_client)
+      @brazil_client = Client.using(:brazil).find_by_name('Brazil Client')
+      Client.using(:master).create!(:name => 'teste')
     end
 
-    it "should find all models in the specified shard" do
-      @brazil_client.item_ids.should eq([@item_brazil.id]) 
-      @brazil_client.items().should eq([@item_brazil])
+    it 'should find all models in the specified shard' do
+      expect(@brazil_client.item_ids).to eq([@item_brazil.id])
+      expect(@brazil_client.items).to eq([@item_brazil])
 
-      @brazil_client.items.last.should eq(@item_brazil)
-      @brazil_client.items.first.should eq(@item_brazil)
+      expect(@brazil_client.items.last).to eq(@item_brazil)
+      expect(@brazil_client.items.first).to eq(@item_brazil)
     end
 
-    it "should finds the client that the item belongs" do
-      @item_brazil.client.should == @brazil_client
+    it 'should finds the client that the item belongs' do
+      expect(@item_brazil.client).to eq(@brazil_client)
     end
 
-    it "should raise error if you try to add a record from a different shard" do
-      lambda do
-        @brazil_client.items << Item.using(:canada).create!(:name => "New User")
-      end.should raise_error("Association Error: Records are from different shards")
+    it 'should raise error if you try to add a record from a different shard' do
+      expect do
+        @brazil_client.items << Item.using(:canada).create!(:name => 'New User')
+      end.to raise_error('Association Error: Records are from different shards')
     end
 
-    it "should update the attribute for the item" do
-      new_brazil_client = Client.using(:brazil).create!(:name => "new Client")
+    it 'should update the attribute for the item' do
+      new_brazil_client = Client.using(:brazil).create!(:name => 'new Client')
       @item_brazil.client = new_brazil_client
-      @item_brazil.client.should == new_brazil_client
-      @item_brazil.save()
+      expect(@item_brazil.client).to eq(new_brazil_client)
+      @item_brazil.save
       @item_brazil.reload
-      @item_brazil.client_id.should == new_brazil_client.id
-      @item_brazil.client().should == new_brazil_client
+      expect(@item_brazil.client_id).to eq(new_brazil_client.id)
+      expect(@item_brazil.client).to eq(new_brazil_client)
     end
 
-    it "should works for build method" do
-      item2 = Item.using(:brazil).create!(:name => "Brazil Item")
-      c = item2.create_client(:name => "new Client")
-      c.save()
-      item2.save()
-      item2.client.should == c
-      c.items().should == [item2]
+    it 'should works for build method' do
+      item2 = Item.using(:brazil).create!(:name => 'Brazil Item')
+      c = item2.create_client(:name => 'new Client')
+      c.save
+      item2.save
+      expect(item2.client).to eq(c)
+      expect(c.items).to eq([item2])
     end
 
-    context "when calling methods on a collection generated by an association" do
+    context 'when calling methods on a collection generated by an association' do
       let(:collection) { @brazil_client.items }
       before :each do
         @brazil_client.items.create(:name => 'Brazil Item #2')
@@ -432,281 +429,280 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
 
       it "can call collection indexes directly without resetting the collection's current_shard" do
         last_item = collection[1]
-        collection.length.should == 2
-        collection.should eq([ collection[0], last_item ])
+        expect(collection.length).to eq(2)
+        expect(collection).to eq([collection[0], last_item])
       end
 
       it "can call methods on the collection without resetting the collection's current_shard" do
-        last_item = collection[collection.size-1]
-        collection.length.should == 2
-        collection.should eq([ collection[0], last_item ])
+        last_item = collection[collection.size - 1]
+        expect(collection.length).to eq(2)
+        expect(collection).to eq([collection[0], last_item])
       end
     end
 
-    describe "it should works when using" do
+    describe 'it should works when using' do
       before(:each) do
-        @item_brazil_2 = Item.using(:brazil).create!(:name => "Brazil Item 2")
-        @brazil_client.items.to_set.should == [@item_brazil].to_set
+        @item_brazil_2 = Item.using(:brazil).create!(:name => 'Brazil Item 2')
+        expect(@brazil_client.items.to_set).to eq([@item_brazil].to_set)
       end
 
-
-      it "update_attributes" do
+      it 'update_attributes' do
         @brazil_client.update_attributes(:item_ids => [@item_brazil_2.id, @item_brazil.id])
-        @brazil_client.items.to_set.should == [@item_brazil, @item_brazil_2].to_set
+        expect(@brazil_client.items.to_set).to eq([@item_brazil, @item_brazil_2].to_set)
       end
 
-      it "update_attribute" do
+      it 'update_attribute' do
         @brazil_client.update_attribute(:item_ids, [@item_brazil_2.id, @item_brazil.id])
-        @brazil_client.items.to_set.should == [@item_brazil, @item_brazil_2].to_set
+        expect(@brazil_client.items.to_set).to eq([@item_brazil, @item_brazil_2].to_set)
       end
 
-      it "<<" do
+      it '<<' do
         @brazil_client.items << @item_brazil_2
-        @brazil_client.items.to_set.should == [@item_brazil, @item_brazil_2].to_set
+        expect(@brazil_client.items.to_set).to eq([@item_brazil, @item_brazil_2].to_set)
       end
 
-      it "all" do
-        item = @brazil_client.items.build(:name => "Builded Item")
-        item.save()
+      it 'all' do
+        item = @brazil_client.items.build(:name => 'Builded Item')
+        item.save
         i = @brazil_client.items
-        i.to_set.should == [@item_brazil, item].to_set
-        i.reload.all.to_set.should == [@item_brazil, item].to_set
+        expect(i.to_set).to eq([@item_brazil, item].to_set)
+        expect(i.reload.all.to_set).to eq([@item_brazil, item].to_set)
       end
 
-      it "build" do
-        item = @brazil_client.items.build(:name => "Builded Item")
-        item.save()
-        @brazil_client.items.to_set.should == [@item_brazil, item].to_set
+      it 'build' do
+        item = @brazil_client.items.build(:name => 'Builded Item')
+        item.save
+        expect(@brazil_client.items.to_set).to eq([@item_brazil, item].to_set)
       end
 
-      it "create" do
-        item = @brazil_client.items.create(:name => "Builded Item")
-        @brazil_client.items.to_set.should == [@item_brazil, item].to_set
+      it 'create' do
+        item = @brazil_client.items.create(:name => 'Builded Item')
+        expect(@brazil_client.items.to_set).to eq([@item_brazil, item].to_set)
       end
 
-      it "count" do
-        @brazil_client.items.count.should == 1
-        item = @brazil_client.items.create(:name => "Builded Item")
-        @brazil_client.items.count.should == 2
+      it 'count' do
+        expect(@brazil_client.items.count).to eq(1)
+        _itm = @brazil_client.items.create(:name => 'Builded Item')
+        expect(@brazil_client.items.count).to eq(2)
       end
 
-      it "size" do
-        @brazil_client.items.size.should == 1
-        item = @brazil_client.items.create(:name => "Builded Item")
-        @brazil_client.items.size.should == 2
+      it 'size' do
+        expect(@brazil_client.items.size).to eq(1)
+        _itm = @brazil_client.items.create(:name => 'Builded Item')
+        expect(@brazil_client.items.size).to eq(2)
       end
 
-      it "create!" do
-        item = @brazil_client.items.create!(:name => "Builded Item")
-        @brazil_client.items.to_set.should == [@item_brazil, item].to_set
+      it 'create!' do
+        item = @brazil_client.items.create!(:name => 'Builded Item')
+        expect(@brazil_client.items.to_set).to eq([@item_brazil, item].to_set)
       end
 
-      it "length" do
-        @brazil_client.items.length.should == 1
-        item = @brazil_client.items.create(:name => "Builded Item")
-        @brazil_client.items.length.should == 2
+      it 'length' do
+        expect(@brazil_client.items.length).to eq(1)
+        _itm = @brazil_client.items.create(:name => 'Builded Item')
+        expect(@brazil_client.items.length).to eq(2)
       end
 
-      it "empty?" do
-        @brazil_client.items.empty?.should be_false
-        c = Client.create!(:name => "Client1")
-        c.items.empty?.should be_true
+      it 'empty?' do
+        expect(@brazil_client.items.empty?).to be false
+        c = Client.create!(:name => 'Client1')
+        expect(c.items.empty?).to be true
       end
 
-      it "delete" do
-        @brazil_client.items.empty?.should be_false
+      it 'delete' do
+        expect(@brazil_client.items.empty?).to be false
         @brazil_client.items.delete(@item_brazil)
         @brazil_client.reload
         @item_brazil.reload
-        @item_brazil.client.should be_nil
-        @brazil_client.items.should == []
-        @brazil_client.items.empty?.should be_true
+        expect(@item_brazil.client).to be_nil
+        expect(@brazil_client.items).to eq([])
+        expect(@brazil_client.items.empty?).to be true
       end
 
-      it "delete_all" do
-        @brazil_client.items.empty?.should be_false
+      it 'delete_all' do
+        expect(@brazil_client.items.empty?).to be false
         @brazil_client.items.delete_all
-        @brazil_client.items.empty?.should be_true
+        expect(@brazil_client.items.empty?).to be true
       end
 
-      it "destroy_all" do
-        @brazil_client.items.empty?.should be_false
+      it 'destroy_all' do
+        expect(@brazil_client.items.empty?).to be false
         @brazil_client.items.destroy_all
-        @brazil_client.items.empty?.should be_true
+        expect(@brazil_client.items.empty?).to be true
       end
 
-      it "find" do
-        @brazil_client.items.first.should == @item_brazil
+      it 'find' do
+        expect(@brazil_client.items.first).to eq(@item_brazil)
         @brazil_client.items.destroy_all
-        @brazil_client.items.first.should be_nil
+        expect(@brazil_client.items.first).to be_nil
       end
 
-      it "exists?" do
-        @brazil_client.items.exists?(@item_brazil).should be_true
+      it 'exists?' do
+        expect(@brazil_client.items.exists?(@item_brazil)).to be true
         @brazil_client.items.destroy_all
-        @brazil_client.items.exists?(@item_brazil).should be_false
+        expect(@brazil_client.items.exists?(@item_brazil)).to be false
       end
 
-      it "uniq" do
-        @brazil_client.items.uniq.should == [@item_brazil]
+      it 'uniq' do
+        expect(@brazil_client.items.uniq).to eq([@item_brazil])
       end
 
-      it "clear" do
-        @brazil_client.items.empty?.should be_false
+      it 'clear' do
+        expect(@brazil_client.items.empty?).to be false
         @brazil_client.items.clear
-        @brazil_client.items.empty?.should be_true
+        expect(@brazil_client.items.empty?).to be true
       end
     end
   end
 
-  describe "when you have a 1 x N polymorphic relationship" do
+  describe 'when you have a 1 x N polymorphic relationship' do
     before(:each) do
-      @brazil_client = Client.using(:brazil).create!(:name => "Brazil Client")
-      @master_client = Client.create!(:name => "Master Client")
-      @comment_brazil = Comment.using(:brazil).create!(:name => "Brazil Comment", :commentable => @brazil_client)
-      @comment_master = Comment.create!(:name => "Master Comment", :commentable => @master_client)
-      @brazil_client = Client.using(:brazil).find_by_name("Brazil Client")
-      Client.using(:master).create!(:name => "teste")
+      @brazil_client = Client.using(:brazil).create!(:name => 'Brazil Client')
+      @master_client = Client.create!(:name => 'Master Client')
+      @comment_brazil = Comment.using(:brazil).create!(:name => 'Brazil Comment', :commentable => @brazil_client)
+      @comment_master = Comment.create!(:name => 'Master Comment', :commentable => @master_client)
+      @brazil_client = Client.using(:brazil).find_by_name('Brazil Client')
+      Client.using(:master).create!(:name => 'teste')
     end
 
-    it "should find all models in the specified shard" do
-      @brazil_client.comment_ids.should == [@comment_brazil.id]
-      @brazil_client.comments().should == [@comment_brazil]
+    it 'should find all models in the specified shard' do
+      expect(@brazil_client.comment_ids).to eq([@comment_brazil.id])
+      expect(@brazil_client.comments).to eq([@comment_brazil])
     end
 
-    it "should finds the client that the comment belongs" do
-      @comment_brazil.commentable.should == @brazil_client
+    it 'should finds the client that the comment belongs' do
+      expect(@comment_brazil.commentable).to eq(@brazil_client)
     end
 
-    it "should update the attribute for the comment" do
-      new_brazil_client = Client.using(:brazil).create!(:name => "new Client")
+    it 'should update the attribute for the comment' do
+      new_brazil_client = Client.using(:brazil).create!(:name => 'new Client')
       @comment_brazil.commentable = new_brazil_client
-      @comment_brazil.commentable.should == new_brazil_client
-      @comment_brazil.save()
+      expect(@comment_brazil.commentable).to eq(new_brazil_client)
+      @comment_brazil.save
       @comment_brazil.reload
-      @comment_brazil.commentable_id.should == new_brazil_client.id
-      @comment_brazil.commentable().should == new_brazil_client
+      expect(@comment_brazil.commentable_id).to eq(new_brazil_client.id)
+      expect(@comment_brazil.commentable).to eq(new_brazil_client)
     end
 
-    describe "it should works when using" do
+    describe 'it should works when using' do
       before(:each) do
-        @comment_brazil_2 = Comment.using(:brazil).create!(:name => "Brazil Comment 2")
-        @brazil_client.comments.to_set.should == [@comment_brazil].to_set
+        @comment_brazil_2 = Comment.using(:brazil).create!(:name => 'Brazil Comment 2')
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil].to_set)
       end
 
-      it "update_attributes" do
+      it 'update_attributes' do
         @brazil_client.update_attributes(:comment_ids => [@comment_brazil_2.id, @comment_brazil.id])
-        @brazil_client.comments.to_set.should == [@comment_brazil, @comment_brazil_2].to_set
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil, @comment_brazil_2].to_set)
       end
 
-      it "update_attribute" do
+      it 'update_attribute' do
         @brazil_client.update_attribute(:comment_ids, [@comment_brazil_2.id, @comment_brazil.id])
-        @brazil_client.comments.to_set.should == [@comment_brazil, @comment_brazil_2].to_set
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil, @comment_brazil_2].to_set)
       end
 
-      it "<<" do
+      it '<<' do
         @brazil_client.comments << @comment_brazil_2
-        @brazil_client.comments.to_set.should == [@comment_brazil, @comment_brazil_2].to_set
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil, @comment_brazil_2].to_set)
       end
 
-      it "all" do
-        comment = @brazil_client.comments.build(:name => "Builded Comment")
-        comment.save()
+      it 'all' do
+        comment = @brazil_client.comments.build(:name => 'Builded Comment')
+        comment.save
         c = @brazil_client.comments
-        c.to_set.should == [@comment_brazil, comment].to_set
-        c.reload.all.to_set.should == [@comment_brazil, comment].to_set
+        expect(c.to_set).to eq([@comment_brazil, comment].to_set)
+        expect(c.reload.all.to_set).to eq([@comment_brazil, comment].to_set)
       end
 
-      it "build" do
-        comment = @brazil_client.comments.build(:name => "Builded Comment")
-        comment.save()
-        @brazil_client.comments.to_set.should == [@comment_brazil, comment].to_set
+      it 'build' do
+        comment = @brazil_client.comments.build(:name => 'Builded Comment')
+        comment.save
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil, comment].to_set)
       end
 
-      it "create" do
-        comment = @brazil_client.comments.create(:name => "Builded Comment")
-        @brazil_client.comments.to_set.should == [@comment_brazil, comment].to_set
+      it 'create' do
+        comment = @brazil_client.comments.create(:name => 'Builded Comment')
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil, comment].to_set)
       end
 
-      it "count" do
-        @brazil_client.comments.count.should == 1
-        comment = @brazil_client.comments.create(:name => "Builded Comment")
-        @brazil_client.comments.count.should == 2
+      it 'count' do
+        expect(@brazil_client.comments.count).to eq(1)
+        _cmt = @brazil_client.comments.create(:name => 'Builded Comment')
+        expect(@brazil_client.comments.count).to eq(2)
       end
 
-      it "size" do
-        @brazil_client.comments.size.should == 1
-        comment = @brazil_client.comments.create(:name => "Builded Comment")
-        @brazil_client.comments.size.should == 2
+      it 'size' do
+        expect(@brazil_client.comments.size).to eq(1)
+        _cmt = @brazil_client.comments.create(:name => 'Builded Comment')
+        expect(@brazil_client.comments.size).to eq(2)
       end
 
-      it "create!" do
-        comment = @brazil_client.comments.create!(:name => "Builded Comment")
-        @brazil_client.comments.to_set.should == [@comment_brazil, comment].to_set
+      it 'create!' do
+        comment = @brazil_client.comments.create!(:name => 'Builded Comment')
+        expect(@brazil_client.comments.to_set).to eq([@comment_brazil, comment].to_set)
       end
 
-      it "length" do
-        @brazil_client.comments.length.should == 1
-        comment = @brazil_client.comments.create(:name => "Builded Comment")
-        @brazil_client.comments.length.should == 2
+      it 'length' do
+        expect(@brazil_client.comments.length).to eq(1)
+        _cmt = @brazil_client.comments.create(:name => 'Builded Comment')
+        expect(@brazil_client.comments.length).to eq(2)
       end
 
-      it "empty?" do
-        @brazil_client.comments.empty?.should be_false
-        c = Client.create!(:name => "Client1")
-        c.comments.empty?.should be_true
+      it 'empty?' do
+        expect(@brazil_client.comments.empty?).to be false
+        c = Client.create!(:name => 'Client1')
+        expect(c.comments.empty?).to be true
       end
 
-      it "delete" do
-        @brazil_client.comments.empty?.should be_false
+      it 'delete' do
+        expect(@brazil_client.comments.empty?).to be false
         @brazil_client.comments.delete(@comment_brazil)
         @brazil_client.reload
         @comment_brazil.reload
-        @comment_brazil.commentable.should be_nil
-        @brazil_client.comments.should == []
-        @brazil_client.comments.empty?.should be_true
+        expect(@comment_brazil.commentable).to be_nil
+        expect(@brazil_client.comments).to eq([])
+        expect(@brazil_client.comments.empty?).to be true
       end
 
-      it "delete_all" do
-        @brazil_client.comments.empty?.should be_false
+      it 'delete_all' do
+        expect(@brazil_client.comments.empty?).to be false
         @brazil_client.comments.delete_all
-        @brazil_client.comments.empty?.should be_true
+        expect(@brazil_client.comments.empty?).to be true
       end
 
-      it "destroy_all" do
-        @brazil_client.comments.empty?.should be_false
+      it 'destroy_all' do
+        expect(@brazil_client.comments.empty?).to be false
         @brazil_client.comments.destroy_all
-        @brazil_client.comments.empty?.should be_true
+        expect(@brazil_client.comments.empty?).to be true
       end
 
-      it "find" do
-        @brazil_client.comments.first.should == @comment_brazil
+      it 'find' do
+        expect(@brazil_client.comments.first).to eq(@comment_brazil)
         @brazil_client.comments.destroy_all
-        @brazil_client.comments.first.should be_nil
+        expect(@brazil_client.comments.first).to be_nil
       end
 
-      it "exists?" do
-        @brazil_client.comments.exists?(@comment_brazil).should be_true
+      it 'exists?' do
+        expect(@brazil_client.comments.exists?(@comment_brazil)).to be true
         @brazil_client.comments.destroy_all
-        @brazil_client.comments.exists?(@comment_brazil).should be_false
+        expect(@brazil_client.comments.exists?(@comment_brazil)).to be false
       end
 
-      it "uniq" do
-        @brazil_client.comments.uniq.should == [@comment_brazil]
+      it 'uniq' do
+        expect(@brazil_client.comments.uniq).to eq([@comment_brazil])
       end
 
-      it "clear" do
-        @brazil_client.comments.empty?.should be_false
+      it 'clear' do
+        expect(@brazil_client.comments.empty?).to be false
         @brazil_client.comments.clear
-        @brazil_client.comments.empty?.should be_true
+        expect(@brazil_client.comments.empty?).to be true
       end
     end
   end
 
-  it "block" do
-    @brazil_role = Role.using(:brazil).create!(:name => "Brazil Role")
-    @brazil_role.permissions.build(:name => "ok").name.should == "ok"
-    @brazil_role.permissions.create(:name => "ok").name.should == "ok"
-    @brazil_role.permissions.create!(:name => "ok").name.should == "ok"
+  it 'block' do
+    @brazil_role = Role.using(:brazil).create!(:name => 'Brazil Role')
+    expect(@brazil_role.permissions.build(:name => 'ok').name).to eq('ok')
+    expect(@brazil_role.permissions.create(:name => 'ok').name).to eq('ok')
+    expect(@brazil_role.permissions.create!(:name => 'ok').name).to eq('ok')
   end
 end