ar-octopus 0.8.2 → 0.8.3

data/spec/octopus/octopus_spec.rb

@@ -1,64 +1,63 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Octopus, :shards => [] do
-  describe "#config" do
-    it "should load shards.yml file to start working" do
-      Octopus.config().should be_kind_of(HashWithIndifferentAccess)
+  describe '#config' do
+    it 'should load shards.yml file to start working' do
+      expect(Octopus.config).to be_kind_of(HashWithIndifferentAccess)
     end
 
     describe "when config file doesn't exist" do
       before(:each) do
-        Octopus.stub(:directory).and_return('/tmp')
+        allow(Octopus).to receive(:directory).and_return('/tmp')
         Octopus.instance_variable_set(:@config, nil)
       end
 
-      it "should return an empty HashWithIndifferentAccess" do
-        Octopus.config().should == HashWithIndifferentAccess.new
+      it 'should return an empty HashWithIndifferentAccess' do
+        expect(Octopus.config).to eq(HashWithIndifferentAccess.new)
       end
     end
   end
 
-  describe "#directory" do
-    it "should return the directory that contains the shards.yml file" do
-      Octopus.directory().should == File.expand_path(File.dirname(__FILE__) + "/../")
+  describe '#directory' do
+    it 'should return the directory that contains the shards.yml file' do
+      expect(Octopus.directory).to eq(File.expand_path(File.dirname(__FILE__) + '/../'))
     end
   end
 
-  describe "#env" do
+  describe '#env' do
     it "should return 'production' when is outside of a rails application" do
-      Octopus.env().should == 'octopus'
+      expect(Octopus.env).to eq('octopus')
     end
   end
 
-
-  describe "#shards=" do
+  describe '#shards=' do
     after(:each) do
       Octopus.instance_variable_set(:@config, nil)
       Octopus::Model.send(:class_variable_set, :@@connection_proxy, nil)
     end
 
-    it "should permit users to configure shards on initializer files, instead of on a yml file." do
-      lambda { User.using(:crazy_shard).create!(:name => "Joaquim") }.should raise_error
+    it 'should permit users to configure shards on initializer files, instead of on a yml file.' do
+      expect { User.using(:crazy_shard).create!(:name => 'Joaquim') }.to raise_error
 
       Octopus.setup do |config|
-        config.shards = {:crazy_shard => {:adapter => "mysql2", :database => "octopus_shard_5", :username => "root", :password => ""}}
+        config.shards = { :crazy_shard => { :adapter => 'mysql2', :database => 'octopus_shard_5', :username => 'root', :password => '' } }
       end
 
-      lambda { User.using(:crazy_shard).create!(:name => "Joaquim")  }.should_not raise_error
+      expect { User.using(:crazy_shard).create!(:name => 'Joaquim')  }.not_to raise_error
     end
   end
 
-  describe "#setup" do
-    it "should have the default octopus environment as production" do
-      Octopus.environments.should == ["production"]
+  describe '#setup' do
+    it 'should have the default octopus environment as production' do
+      expect(Octopus.environments).to eq(['production'])
     end
 
-    it "should allow the user to configure the octopus environments" do
+    it 'should allow the user to configure the octopus environments' do
       Octopus.setup do |config|
         config.environments = [:production, :staging]
       end
 
-      Octopus.environments.should == ['production', 'staging']
+      expect(Octopus.environments).to eq(%w(production staging))
 
       Octopus.setup do |config|
         config.environments = [:production]
@@ -66,57 +65,57 @@ describe Octopus, :shards => [] do
     end
   end
 
-  describe "#enabled?" do
+  describe '#enabled?' do
     before do
-      Rails = double()
+      Rails = double
     end
 
     after do
       Object.send(:remove_const, :Rails)
     end
 
-    it "should be if octopus is configured and should hook into current environment" do
-      Rails.stub(:env).and_return('production')
+    it 'should be if octopus is configured and should hook into current environment' do
+      allow(Rails).to receive(:env).and_return('production')
 
-      Octopus.should be_enabled
+      expect(Octopus).to be_enabled
     end
 
-    it "should not be if octopus should not hook into current environment" do
-      Rails.stub(:env).and_return('staging')
+    it 'should not be if octopus should not hook into current environment' do
+      allow(Rails).to receive(:env).and_return('staging')
 
-      Octopus.should_not be_enabled
+      expect(Octopus).not_to be_enabled
     end
   end
 
-  describe "#fully_replicated" do
+  describe '#fully_replicated' do
     before do
       OctopusHelper.using_environment :production_replicated do
         OctopusHelper.clean_all_shards([:slave1, :slave2, :slave3, :slave4])
-        4.times { |i| User.using(:"slave#{i+1}").create!(:name => "Slave User") }
+        4.times { |i| User.using(:"slave#{i + 1}").create!(:name => 'Slave User') }
       end
     end
 
-    it "sends queries to slaves" do
+    it 'sends queries to slaves' do
       OctopusHelper.using_environment :production_replicated do
-        User.count.should eq(0)
-        4.times do |i|
+        expect(User.count).to eq(0)
+        4.times do |_i|
           Octopus.fully_replicated do
-            User.count.should eq(1)
+            expect(User.count).to eq(1)
           end
         end
       end
     end
 
-    it "allows nesting" do
+    it 'allows nesting' do
       OctopusHelper.using_environment :production_replicated do
         Octopus.fully_replicated do
-          User.count.should eq(1)
+          expect(User.count).to eq(1)
 
           Octopus.fully_replicated do
-            User.count.should eq(1)
+            expect(User.count).to eq(1)
           end
 
-          User.count.should eq(1)
+          expect(User.count).to eq(1)
         end
       end
     end

data/spec/octopus/proxy_spec.rb

@@ -1,299 +1,299 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Octopus::Proxy do
   let(:proxy) { subject }
 
-  describe "creating a new instance", :shards => [] do
-    it "should initialize all shards and groups" do
+  describe 'creating a new instance', :shards => [] do
+    it 'should initialize all shards and groups' do
       # FIXME: Don't test implementation details
-      proxy.instance_variable_get(:@shards).should include("canada", "brazil", "master", "sqlite_shard", "russia", "alone_shard",
-                                                           "aug2009", "postgresql_shard", "aug2010", "aug2011")
+      expect(proxy.instance_variable_get(:@shards)).to include('canada', 'brazil', 'master', 'sqlite_shard', 'russia', 'alone_shard',
+                                                               'aug2009', 'postgresql_shard', 'aug2010', 'aug2011')
 
-      proxy.instance_variable_get(:@shards).should include("protocol_shard")
+      expect(proxy.instance_variable_get(:@shards)).to include('protocol_shard')
 
-      proxy.has_group?("country_shards").should be_true
-      proxy.shards_for_group("country_shards").should include(:canada, :brazil, :russia)
+      expect(proxy.has_group?('country_shards')).to be true
+      expect(proxy.shards_for_group('country_shards')).to include(:canada, :brazil, :russia)
 
-      proxy.has_group?("history_shards").should be_true
-      proxy.shards_for_group("history_shards").should include(:aug2009, :aug2010, :aug2011)
+      expect(proxy.has_group?('history_shards')).to be true
+      expect(proxy.shards_for_group('history_shards')).to include(:aug2009, :aug2010, :aug2011)
     end
 
-    it "should initialize the block attribute as false" do
-      proxy.block.should be_false
+    it 'should initialize the block attribute as false' do
+      expect(proxy.block).to be_falsey
     end
 
-    it "should initialize replicated attribute as false" do
-      proxy.instance_variable_get(:@replicated).should be_false
+    it 'should initialize replicated attribute as false' do
+      expect(proxy.instance_variable_get(:@replicated)).to be_falsey
     end
 
-    it "should work with thiking sphinx" do
+    it 'should work with thiking sphinx' do
       config = proxy.instance_variable_get(:@config)
-      config[:adapter].should == "mysql2"
-      config[:database].should == "octopus_shard_1"
-      config[:username].should == "root"
+      expect(config[:adapter]).to eq('mysql2')
+      expect(config[:database]).to eq('octopus_shard_1')
+      expect(config[:username]).to eq('root')
     end
 
     it 'should create a set with all adapters, to ensure that is needed to clean the table name.' do
       adapters = proxy.instance_variable_get(:@adapters)
-      adapters.should be_kind_of(Set)
-      adapters.to_a.should =~ ["sqlite3", "mysql2", "postgresql"]
+      expect(adapters).to be_kind_of(Set)
+      expect(adapters.to_a).to match_array(%w(sqlite3 mysql2 postgresql))
     end
 
     it 'should respond correctly to respond_to?(:pk_and_sequence_for)' do
-      proxy.respond_to?(:pk_and_sequence_for).should be_true
+      expect(proxy.respond_to?(:pk_and_sequence_for)).to be true
     end
 
     it 'should respond correctly to respond_to?(:primary_key)' do
-      proxy.respond_to?(:primary_key).should be_true
+      expect(proxy.respond_to?(:primary_key)).to be true
     end
 
     context 'when an adapter that modifies the config' do
-      before(:all) { OctopusHelper.set_octopus_env("modify_config") }
-      after(:all)  { OctopusHelper.set_octopus_env("octopus")       }
+      before { OctopusHelper.octopus_env = 'modify_config' }
+      after  { OctopusHelper.octopus_env = 'octopus'       }
 
       it 'should not fail with missing adapter second time round' do
-        pending "This test was actually failing because of a typo in the error message."
-        Thread.current["octopus.current_shard"] = :modify_config_read
+        skip 'This test was actually failing because of a typo in the error message.'
+        Thread.current['octopus.current_shard'] = :modify_config_read
 
-        lambda { Octopus::Proxy.new(Octopus.config()) }.should_not raise_error
+        expect { Octopus::Proxy.new(Octopus.config) }.not_to raise_error
 
-        Thread.current["octopus.current_shard"] = nil
+        Thread.current['octopus.current_shard'] = nil
       end
     end
 
-    describe "#should_clean_table_name?" do
+    describe '#should_clean_table_name?' do
       it 'should return true when you have a environment with multiple database types' do
-        proxy.should_clean_table_name?.should be_true
+        expect(proxy.should_clean_table_name?).to be true
       end
 
-      context "when using a environment with a single table name" do
+      context 'when using a environment with a single table name' do
         before(:each) do
-          OctopusHelper.set_octopus_env("production_replicated")
+          OctopusHelper.octopus_env = 'production_replicated'
         end
 
         it 'should return false' do
-          proxy.should_clean_table_name?.should be_false
+          expect(proxy.should_clean_table_name?).to be false
         end
       end
     end
 
-    describe "should raise error if you have duplicated shard names" do
+    describe 'should raise error if you have duplicated shard names' do
       before(:each) do
-        OctopusHelper.set_octopus_env("production_raise_error")
+        OctopusHelper.octopus_env = 'production_raise_error'
       end
 
-      it "should raise the error" do
-        lambda { proxy }.should raise_error("You have duplicated shard names!")
+      it 'should raise the error' do
+        expect { proxy }.to raise_error('You have duplicated shard names!')
       end
     end
 
     describe "should initialize just the master when you don't have a shards.yml file" do
       before(:each) do
-        OctopusHelper.set_octopus_env("crazy_environment")
+        OctopusHelper.octopus_env = 'crazy_environment'
       end
 
-      it "should initialize just the master shard" do
-        proxy.instance_variable_get(:@shards).keys.should == ["master"]
+      it 'should initialize just the master shard' do
+        expect(proxy.instance_variable_get(:@shards).keys).to eq(['master'])
       end
 
-      it "should not initialize replication" do
-        proxy.instance_variable_get(:@replicated).should be_nil
+      it 'should not initialize replication' do
+        expect(proxy.instance_variable_get(:@replicated)).to be_nil
       end
     end
   end
 
-  describe "when you have a replicated environment" do
+  describe 'when you have a replicated environment' do
     before(:each) do
-      OctopusHelper.set_octopus_env("production_replicated")
+      OctopusHelper.octopus_env = 'production_replicated'
     end
 
-    it "should have the replicated attribute as true" do
-      proxy.instance_variable_get(:@replicated).should be_true
+    it 'should have the replicated attribute as true' do
+      expect(proxy.instance_variable_get(:@replicated)).to be true
     end
 
-    it "should initialize the list of shards" do
-      proxy.instance_variable_get(:@slaves_list).should == ["slave1", "slave2", "slave3", "slave4"]
+    it 'should initialize the list of shards' do
+      expect(proxy.instance_variable_get(:@slaves_list)).to eq(%w(slave1 slave2 slave3 slave4))
     end
   end
 
-  describe "when you have a rails application" do
+  describe 'when you have a rails application' do
     before(:each) do
-      Rails = double()
-      OctopusHelper.set_octopus_env("octopus_rails")
+      Rails = double
+      OctopusHelper.octopus_env = 'octopus_rails'
     end
 
     after(:each) do
       Object.send(:remove_const, :Rails)
       Octopus.instance_variable_set(:@config, nil)
       Octopus.instance_variable_set(:@rails_env, nil)
-      OctopusHelper.clean_connection_proxy()
+      OctopusHelper.clean_connection_proxy
     end
 
-    it "should initialize correctly octopus common variables for the environments" do
-      Rails.stub(:env).and_return('staging')
+    it 'should initialize correctly octopus common variables for the environments' do
+      allow(Rails).to receive(:env).and_return('staging')
       Octopus.instance_variable_set(:@rails_env, nil)
       Octopus.instance_variable_set(:@environments, nil)
-      Octopus.config()
+      Octopus.config
 
-      proxy.instance_variable_get(:@replicated).should be_true
-      Octopus.environments.should == ["staging", "production"]
+      expect(proxy.instance_variable_get(:@replicated)).to be true
+      expect(Octopus.environments).to eq(%w(staging production))
     end
 
-    it "should initialize correctly the shards for the staging environment" do
-      Rails.stub(:env).and_return('staging')
+    it 'should initialize correctly the shards for the staging environment' do
+      allow(Rails).to receive(:env).and_return('staging')
       Octopus.instance_variable_set(:@rails_env, nil)
       Octopus.instance_variable_set(:@environments, nil)
-      Octopus.config()
+      Octopus.config
 
-      proxy.instance_variable_get(:@shards).keys.to_set.should == Set.new(["slave1", "slave2", "master"])
+      expect(proxy.instance_variable_get(:@shards).keys.to_set).to eq(Set.new(%w(slave1 slave2 master)))
     end
 
-    it "should initialize correctly the shard octopus_shard value for logging" do
-      Rails.stub(:env).and_return('staging')
+    it 'should initialize correctly the shard octopus_shard value for logging' do
+      allow(Rails).to receive(:env).and_return('staging')
       Octopus.instance_variable_set(:@rails_env, nil)
       Octopus.instance_variable_set(:@environments, nil)
-      Octopus.config()
+      Octopus.config
 
-      proxy.instance_variable_get(:@shards)['slave1'].spec.config.should have_key :octopus_shard
+      expect(proxy.instance_variable_get(:@shards)['slave1'].spec.config).to have_key :octopus_shard
     end
 
-    it "should initialize correctly the shards for the production environment" do
-      Rails.stub(:env).and_return('production')
+    it 'should initialize correctly the shards for the production environment' do
+      allow(Rails).to receive(:env).and_return('production')
       Octopus.instance_variable_set(:@rails_env, nil)
       Octopus.instance_variable_set(:@environments, nil)
-      Octopus.config()
+      Octopus.config
 
-      proxy.instance_variable_get(:@shards).keys.to_set.should == Set.new(["slave3", "slave4", "master"])
+      expect(proxy.instance_variable_get(:@shards).keys.to_set).to eq(Set.new(%w(slave3 slave4 master)))
     end
 
-    describe "using the master connection", :shards => [:russia, :master]  do
+    describe 'using the master connection', :shards => [:russia, :master]  do
       before(:each) do
-        Rails.stub(:env).and_return('development')
+        allow(Rails).to receive(:env).and_return('development')
       end
 
-      it "should use the master connection" do
-        user = User.create!(:name =>"Thiago")
-        user.name = "New Thiago"
-        user.save()
-        User.find_by_name("New Thiago").should_not be_nil
+      it 'should use the master connection' do
+        user = User.create!(:name => 'Thiago')
+        user.name = 'New Thiago'
+        user.save
+        expect(User.find_by_name('New Thiago')).not_to be_nil
       end
 
-      it "should work when using using syntax" do
-        user = User.using(:russia).create!(:name =>"Thiago")
+      it 'should work when using using syntax' do
+        user = User.using(:russia).create!(:name => 'Thiago')
 
-        user.name = "New Thiago"
-        user.save()
+        user.name = 'New Thiago'
+        user.save
 
-        User.using(:russia).find_by_name("New Thiago").should == user
-        User.find_by_name("New Thiago").should == user
+        expect(User.using(:russia).find_by_name('New Thiago')).to eq(user)
+        expect(User.find_by_name('New Thiago')).to eq(user)
       end
 
-      it "should work when using blocks" do
+      it 'should work when using blocks' do
         Octopus.using(:russia) do
-          @user = User.create!(:name =>"Thiago")
+          @user = User.create!(:name => 'Thiago')
         end
 
-        User.find_by_name("Thiago").should == @user
+        expect(User.find_by_name('Thiago')).to eq(@user)
       end
 
-      it "should work with associations" do
-        u = Client.create!(:name => "Thiago")
-        i = Item.create(:name => "Item")
+      it 'should work with associations' do
+        u = Client.create!(:name => 'Thiago')
+        i = Item.create(:name => 'Item')
         u.items << i
-        u.save()
+        u.save
       end
     end
   end
 
-  describe "returning the correct connection" do
-    describe "should return the shard name" do
-      it "when current_shard is empty" do
-        proxy.shard_name.should == :master
+  describe 'returning the correct connection' do
+    describe 'should return the shard name' do
+      it 'when current_shard is empty' do
+        expect(proxy.shard_name).to eq(:master)
       end
 
-      it "when current_shard is a single shard" do
+      it 'when current_shard is a single shard' do
         proxy.current_shard = :canada
-        proxy.shard_name.should == :canada
+        expect(proxy.shard_name).to eq(:canada)
       end
 
-      it "when current_shard is more than one shard" do
+      it 'when current_shard is more than one shard' do
         proxy.current_shard = [:russia, :brazil]
-        proxy.shard_name.should == :russia
+        expect(proxy.shard_name).to eq(:russia)
       end
     end
 
-    describe "should return the connection based on shard_name" do
-      it "when current_shard is empty" do
-        proxy.select_connection().should == proxy.instance_variable_get(:@shards)[:master].connection()
+    describe 'should return the connection based on shard_name' do
+      it 'when current_shard is empty' do
+        expect(proxy.select_connection).to eq(proxy.instance_variable_get(:@shards)[:master].connection)
       end
 
-      it "when current_shard is a single shard" do
+      it 'when current_shard is a single shard' do
         proxy.current_shard = :canada
-        proxy.select_connection().should == proxy.instance_variable_get(:@shards)[:canada].connection()
+        expect(proxy.select_connection).to eq(proxy.instance_variable_get(:@shards)[:canada].connection)
       end
     end
   end
 
-  describe "saving multiple sharded objects at once" do
+  describe 'saving multiple sharded objects at once' do
     before :each do
       @p = MmorpgPlayer.using(:alone_shard).create!(:player_name => 'Thiago')
     end
 
     subject { @p.save! }
 
-    context "when the objects are created with #new and saved one at a time" do
+    context 'when the objects are created with #new and saved one at a time' do
       before :each do
         @p.weapons.create!(:name => 'battleaxe', :hand => 'right')
         @p.skills.create!(:name => 'smiting', :weapon => @p.weapons[0])
       end
 
-      it "should save all associated objects on the correct shard" do
+      it 'should save all associated objects on the correct shard' do
         expect { subject }.to_not raise_error
       end
     end
 
-    context "when the objects are created with #new and saved at the same time" do
+    context 'when the objects are created with #new and saved at the same time' do
       before :each do
         @p.weapons.new(:name => 'battleaxe', :hand => 'right')
         @p.skills.new(:name => 'smiting', :weapon => @p.weapons[0])
       end
 
-      it "should save all associated objects on the correct shard" do
+      it 'should save all associated objects on the correct shard' do
         expect { subject }.to_not raise_error
       end
     end
   end
 
-  describe "connection reuse" do
+  describe 'connection reuse' do
     before :each do
-      @item_brazil_conn = Item.using(:brazil).new(:name => 'Brazil Item').connection.select_connection
-      @item_canada_conn = Item.using(:canada).new(:name => 'Canada Item').connection.select_connection
+      @item_brazil_conn = Item.using(:brazil).new(:name => 'Brazil Item').class.connection.select_connection
+      @item_canada_conn = Item.using(:canada).new(:name => 'Canada Item').class.connection.select_connection
     end
 
-    it "reuses connections" do
-      Item.using(:brazil).new(:name => 'Another Brazil Item').connection.select_connection.should eq(@item_brazil_conn)
-      Item.using(:canada).new(:name => 'Another Canada Item').connection.select_connection.should eq(@item_canada_conn)
+    it 'reuses connections' do
+      expect(Item.using(:brazil).new(:name => 'Another Brazil Item').class.connection.select_connection).to eq(@item_brazil_conn)
+      expect(Item.using(:canada).new(:name => 'Another Canada Item').class.connection.select_connection).to eq(@item_canada_conn)
     end
 
-    it "reuses connections after clear_active_connections! is called" do
-      Item.using(:brazil).new(:name => 'Another Brazil Item').connection.select_connection.should eq(@item_brazil_conn)
-      Item.using(:canada).new(:name => 'Another Canada Item').connection.select_connection.should eq(@item_canada_conn)
+    it 'reuses connections after clear_active_connections! is called' do
+      expect(Item.using(:brazil).new(:name => 'Another Brazil Item').class.connection.select_connection).to eq(@item_brazil_conn)
+      expect(Item.using(:canada).new(:name => 'Another Canada Item').class.connection.select_connection).to eq(@item_canada_conn)
     end
 
-    it "creates new connections after clear_all_connections! is called" do
+    it 'creates new connections after clear_all_connections! is called' do
       Item.clear_all_connections!
-      Item.using(:brazil).new(:name => 'Another Brazil Item').connection.select_connection.should_not eq(@item_brazil_conn)
-      Item.using(:canada).new(:name => 'Another Canada Item').connection.select_connection.should_not eq(@item_canada_conn)
+      expect(Item.using(:brazil).new(:name => 'Another Brazil Item').class.connection.select_connection).not_to eq(@item_brazil_conn)
+      expect(Item.using(:canada).new(:name => 'Another Canada Item').class.connection.select_connection).not_to eq(@item_canada_conn)
     end
 
-    it "is consistent with connected?" do
-      Item.connected?.should be_true
-      ActiveRecord::Base.connected?.should be_true
+    it 'is consistent with connected?' do
+      expect(Item.connected?).to be true
+      expect(ActiveRecord::Base.connected?).to be true
 
       Item.clear_all_connections!
 
-      Item.connected?.should be_false
-      ActiveRecord::Base.connected?.should be_false
+      expect(Item.connected?).to be false
+      expect(ActiveRecord::Base.connected?).to be false
     end
   end
 end