misha-ar-octopus 0.8.5

data/spec/octopus/replicated_slave_grouped_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+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
+
+    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')
+
+      # See "replicated_slave_grouped" defined in shards.yml
+      # We have:
+      #   The database `octopus_shard_1` as :slave21 which is a member of the slave group :slaves2, and as :master
+      #   The databse `octopus_shard_2` as :slave11 which is a member of the slave group :slaves1
+      # When a select-count query is sent to `octopus_shard_1`, it should return 2 because we have create two cats in :master .
+      # When a select-count query is sent to `octopus_shard_2`, it should return 0.
+
+      # The query goes to `octopus_shard_1`
+      expect(Cat.using(:master).count).to eq(2)
+      # The query goes to `octopus_shard_1`
+      expect(Cat.count).to eq(2)
+      # The query goes to `octopus_shard_2`
+      expect(Cat.using(:slave_group => :slaves1).count).to eq(0)
+      # The query goes to `octopus_shard_1`
+      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
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      # The query goes to :master(`octopus_shard_1`)
+      Cat.create!(:name => 'Thiago1')
+      # The query goes to :master(`octopus_shard_1`)
+      Cat.create!(:name => 'Thiago2')
+
+      # The query goes to :slave32(`octopus_shard_2`)
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(0)
+      # The query goes to :slave31(`octopus_shard_1`)
+      expect(Cat.using(:slave_group => :slaves3).count).to eq(2)
+      # The query goes to :slave32(`octopus_shard_2`)
+      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
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      # All the queries go to :master(`octopus_shard_1`)
+
+      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`)
+      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
+
+  it 'should keep sending to slaves in a using block' do
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
+
+      expect(Cat.count).to eq(2)
+      Octopus.using(:slave_group => :slaves1) do
+        expect(Cat.count).to eq(0)
+        expect(Cat.count).to eq(0)
+      end
+    end
+  end
+  
+  it 'should restore previous slave group after a using block' do
+    OctopusHelper.using_environment :replicated_slave_grouped do
+      Cat.create!(:name => 'Thiago1')
+      Cat.create!(:name => 'Thiago2')
+
+      Octopus.using(:slave_group => :slaves1) do
+        Octopus.using(:slave_group => :slaves2) do
+          expect(Cat.count).to eq(2)
+        end
+        expect(Cat.count).to eq(0)
+      end
+    end
+  end
+end

data/spec/octopus/replication_spec.rb

@@ -0,0 +1,137 @@
+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
+    OctopusHelper.using_environment :production_replicated do
+      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
+    OctopusHelper.using_environment :production_replicated do
+      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
+    OctopusHelper.using_environment :production_replicated do
+      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' 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')
+          _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(14)
+        end
+      end
+    end
+  end
+
+  describe 'When enabling the query cache with slave unavailable' do
+    it "should not raise can't connect error" do
+      OctopusHelper.using_environment :replicated_with_one_slave_unavailable do
+        expect {
+          ActiveRecord::Base.connection.enable_query_cache!
+        }.to_not raise_error
+      end
+    end
+  end
+
+  it 'should allow #using syntax to send queries to master' do
+    Cat.create!(:name => 'Master Cat')
+
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+    OctopusHelper.using_environment :production_replicated do
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.count).to eq(0)
+    end
+  end
+
+  def active_support_subscribed(callback, *args, &_block)
+    subscriber = ActiveSupport::Notifications.subscribe(*args, &callback)
+    yield
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+end
+
+describe 'when the database is replicated and the entire application is replicated' do
+  before(:each) do
+    allow(Octopus).to receive(:env).and_return('production_fully_replicated')
+    OctopusHelper.clean_connection_proxy
+  end
+
+  it 'should send all writes queries to master' do
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+    OctopusHelper.using_environment :production_fully_replicated do
+      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')
+
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+    OctopusHelper.using_environment :production_fully_replicated do
+      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
+
+  it 'should reset current shard if slave throws an exception with custom master' do
+    OctopusHelper.using_environment :production_fully_replicated do
+      Octopus.config[:master_shard] = :slave2
+      Cat.create!(:name => 'Slave Cat')
+      expect(Cat.connection.current_shard).to eql(:slave2)
+      Cat.where(:rubbish => true)
+      expect(Cat.connection.current_shard).to eql(:slave2)
+      Octopus.config[:master_shard] = nil
+    end
+  end
+end

data/spec/octopus/scope_proxy_spec.rb

@@ -0,0 +1,63 @@
+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)
+
+    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
+      expect(@evans.select { |u| u.number == 2 }.first.number).to 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
+      expect(@evan.select('name').first.name).to eq('Evan')
+    end
+
+    it 'allows selection by array' do
+      expect(@evan.select(['name']).first.name).to eq('Evan')
+    end
+
+    it 'allows multiple selection by string' do
+      expect(@evan.select('id, name').first.id).to be_a(Fixnum)
+    end
+
+    it 'allows multiple selection by array' do
+      expect(@evan.select(%w(id name)).first.id).to be_a(Fixnum)
+    end
+
+    if Octopus.rails4?
+      it 'allows multiple selection by symbol' do
+        expect(@evan.select(:id, :name).first.id).to be_a(Fixnum)
+      end
+
+      it 'allows multiple selection by string and symbol' do
+        expect(@evan.select(:id, 'name').first.id).to 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
+    expect { User.using(:dont_exists).all }.to raise_exception('Nonexistent Shard Name: dont_exists')
+  end
+end

data/spec/octopus/sharded_replicated_slave_grouped_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'when the database is both sharded and replicated' do
+
+  it 'should pick the shard based on current_shard when you have a sharded model' do
+
+    OctopusHelper.using_environment :sharded_replicated_slave_grouped do
+      Octopus.using(:russia) do
+        Cat.create!(:name => 'Thiago1')
+        Cat.create!(:name => 'Thiago2')
+      end
+
+      # We must stub here to make it effective (not in the `before(:each)` block)
+      allow(Octopus).to receive(:env).and_return('sharded_replicated_slave_grouped')
+
+      expect(Cat.using(:russia).count).to eq(2)
+      # It distributes queries between two slaves in the slave group
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves1).count).to eq(0)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves1).count).to eq(2)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves1).count).to eq(0)
+      # It distributes queries between two slaves in the slave group
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves2).count).to eq(2)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves2).count).to eq(0)
+      expect(Cat.using(:shard => :russia, :slave_group => :slaves2).count).to eq(2)
+
+      expect(Cat.using(:europe).count).to eq(0)
+      expect(Cat.using(:shard => :europe, :slave_group => :slaves1)
+        .count).to eq(0)
+      expect(Cat.using(:shard => :europe, :slave_group => :slaves2)
+        .count).to eq(2)
+    end
+  end
+
+  it 'should make queries to master when slave groups are configured for the shard but not selected' do
+    OctopusHelper.using_environment :sharded_replicated_slave_grouped do
+      Octopus.using(:europe) do
+        # All the queries go to :master(`octopus_shard_1`)
+
+        Cat.create!(:name => 'Thiago1')
+        Cat.create!(:name => 'Thiago2')
+
+        # In `database.yml` and `shards.yml`, we have configured 1 master and 6 slaves for `sharded_replicated_slave_grouped`
+        # So we can ensure Octopus is not distributing queries between them
+        # by asserting 1 + 6 = 7 queries go to :master(`octopus_shard_1`)
+        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)
+        expect(Cat.count).to eq(2)
+        expect(Cat.count).to eq(2)
+      end
+    end
+  end
+end

data/spec/octopus/sharded_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'when the database is not entire sharded' do
+  before(:each) do
+    allow(Octopus).to receive(:env).and_return('not_entire_sharded')
+    OctopusHelper.clean_connection_proxy
+  end
+
+  it 'should not send all queries to the specified slave' do
+    skip
+    # User.create!(:name => "Thiago")
+    #
+    # using_environment :not_entire_sharded do
+    #   Octopus.using(:russia) do
+    #     User.create!(:name => "Thiago")
+    #   end
+    # end
+    #
+    # User.count.should == 2
+  end
+
+  it 'should pick the shard based on current_shard when you have a sharded model' do
+    Cat.create!(:name => 'Thiago')
+
+    OctopusHelper.using_environment :not_entire_sharded do
+      Octopus.using(:russia) do
+        Cat.create!(:name => 'Thiago')
+      end
+    end
+
+    expect(Cat.count).to eq(1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'pry'
+require 'bundler/setup'
+require 'octopus'
+
+Octopus.instance_variable_set(:@directory, File.dirname(__FILE__))
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.before(:each) do |example|
+    OctopusHelper.clean_all_shards(example.metadata[:shards])
+  end
+end

data/spec/support/active_record/connection_adapters/modify_config_adapter.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class Base
+    def self.modify_config_connection(config)
+      ConnectionAdapters::ModifyConfigAdapter.new(config)
+    end
+  end
+
+  module ConnectionAdapters
+    class ModifyConfigAdapter < AbstractAdapter
+      def initialize(config)
+        config.replace(config.symbolize_keys)
+      end
+    end
+  end
+end

data/spec/support/database_connection.rb

@@ -0,0 +1,4 @@
+require 'logger'
+
+ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'octopus_shard_1', :username => 'root', :password => '')
+ActiveRecord::Base.logger = Logger.new(File.open('database.log', 'a'))

data/spec/support/database_models.rb

@@ -0,0 +1,118 @@
+# Rails 3.1 needs to do some introspection around the base class, which requires
+# the model be a descendent of ActiveRecord::Base.
+class BlankModel < ActiveRecord::Base; end
+
+# The user class is just sharded, not replicated
+class User < ActiveRecord::Base
+  scope :thiago, -> { where(:name => 'Thiago') }
+
+  def awesome_queries
+    Octopus.using(:canada) do
+      User.create(:name => 'teste')
+    end
+  end
+end
+
+# The client class isn't replicated
+class Client < ActiveRecord::Base
+  has_many :items
+  has_many :comments, :as => :commentable
+end
+
+# This class is replicated
+class Cat < ActiveRecord::Base
+  replicated_model
+  # sharded_model()
+end
+
+# This class sets its own connection
+class CustomConnection < ActiveRecord::Base
+  self.table_name = 'custom'
+  octopus_establish_connection(:adapter => 'mysql2', :database => 'octopus_shard_2', :username => 'root', :password => '')
+end
+
+# This items belongs to a client
+class Item < ActiveRecord::Base
+  belongs_to :client
+  has_many :parts
+end
+
+class Part < ActiveRecord::Base
+  belongs_to :item
+end
+
+class Keyboard < ActiveRecord::Base
+  replicated_model
+  validates_uniqueness_of :name
+  belongs_to :computer
+end
+
+class Computer < ActiveRecord::Base
+  has_one :keyboard
+end
+
+class Role < ActiveRecord::Base
+  has_and_belongs_to_many :permissions
+end
+
+class Permission < ActiveRecord::Base
+  has_and_belongs_to_many :roles
+end
+
+class Assignment < ActiveRecord::Base
+  belongs_to :programmer
+  belongs_to :project
+end
+
+class Programmer < ActiveRecord::Base
+  has_many :assignments
+  has_many :projects, :through => :assignments
+end
+
+class Project < ActiveRecord::Base
+  has_many :assignments
+  has_many :programmers, :through => :assignments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :commentable, :polymorphic => true
+  scope :open, -> { where(open: true) }
+end
+
+class Bacon < ActiveRecord::Base
+  self.table_name = 'yummy'
+end
+
+class Cheese < ActiveRecord::Base
+  self.table_name = 'yummy'
+end
+
+class Ham < ActiveRecord::Base
+  self.table_name = 'yummy'
+end
+
+# This class sets its own connection
+class Advert < ActiveRecord::Base
+  establish_connection(:adapter => 'postgresql', :database => 'octopus_shard_1', :username => ENV['POSTGRES_USER'] || 'postgres', :password => '')
+end
+
+class MmorpgPlayer < ActiveRecord::Base
+  has_many :weapons
+  has_many :skills
+end
+
+class Weapon < ActiveRecord::Base
+  belongs_to :mmorpg_player, :inverse_of => :weapons
+  validates :hand, :uniqueness => { :scope => :mmorpg_player_id }
+  validates_presence_of :mmorpg_player
+  has_many :skills
+end
+
+class Skill < ActiveRecord::Base
+  belongs_to :weapon, :inverse_of => :skills
+  belongs_to :mmorpg_player, :inverse_of => :skills
+
+  validates_presence_of :weapon
+  validates_presence_of :mmorpg_player
+  validates :name, :uniqueness => { :scope => :mmorpg_player_id }
+end