ar-octopus-ruby-3 0.11.2

data/spec/octopus/replication_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe 'when the database is replicated' do
+  let(:slave_pool) do
+    ActiveRecord::Base.connection_proxy.shards['slave1']
+  end
+
+  let(:slave_connection) do
+    slave_pool.connection
+  end
+
+  let(:master_pool) do
+    ActiveRecord::Base.connection_proxy.shards['master']
+  end
+
+  let(:master_connection) do
+    master_pool.connection
+  end
+
+  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
+
+  context 'when updating model' do
+    it 'should send writes to master' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        Cat.using(:slave1).create!(:name => 'Cat')
+        cat = Cat.find_by_name('Cat')
+        cat.name = 'New name'
+
+        expect(master_connection).to receive(:update).and_call_original
+
+        cat.save!
+      end
+    end
+  end
+
+  context 'when querying' do
+    it 'Reads from slave' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        expect(master_connection).not_to receive(:select)
+
+        Cat.where(:name => 'Catman2').first
+      end
+    end
+  end
+
+  context 'When record is read from slave' do
+    it 'Should write associations to master' do
+      OctopusHelper.using_environment :replicated_with_one_slave do
+        client = Client.using(:slave1).create!(:name => 'Client')
+
+        client = Client.find(client.id)
+
+        expect(master_connection).to receive(:insert).and_call_original
+
+        client.items.create!(:name => 'Item')
+      end
+    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)
+
+          # Rails 5.1 count the cached queries as regular queries.
+          # TODO: How we can verify if the queries are using cache on Rails 5.1? - @thiagopradi
+          expected_records = Octopus.rails51? || Octopus.rails52? ? 19 : 14
+
+          expect(counter.query_count).to eq(expected_records)
+        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,97 @@
+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
+
+    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
+
+  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
+
+  context "dup / clone" do
+    before(:each) do
+      User.using(:brazil).create!(:name => 'Thiago', :number => 1)
+    end
+
+    it "should change it's object id" do
+      user = User.using(:brazil).where(id: 1)
+      dupped_object = user.dup
+      cloned_object = user.clone
+
+      expect(dupped_object.object_id).not_to eq(user.object_id)
+      expect(cloned_object.object_id).not_to eq(user.object_id)
+    end
+  end
+
+  context 'When iterated with Enumerable methods' 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 each method' do
+      expect(@evans.each.count).to eq(3)
+    end
+
+    it 'allows each_with_index method' do
+      expect(@evans.each_with_index.to_a.flatten.count).to eq(6)
+    end
+
+    it 'allows map method' do
+      expect(@evans.map(&:number)).to eq([1, 2, 3])
+    end
+  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,18 @@
+require 'rubygems'
+require 'pry'
+require 'bundler/setup'
+require 'octopus'
+
+Octopus.instance_variable_set(:@directory, File.dirname(__FILE__))
+
+BaseOctopusMigrationClass = (Octopus.rails4? ? ActiveRecord::Migration : ActiveRecord::Migration[ActiveRecord::VERSION::STRING[0..2]])
+
+# 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 => "#{ENV['MYSQL_USER'] || '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 => "#{ENV['MYSQL_USER'] || ''}", :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'] || 'daniel', :password => '1234', :host => '')
+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

data/spec/support/octopus_helper.rb

@@ -0,0 +1,66 @@
+module OctopusHelper
+  def self.clean_all_shards(shards)
+    if shards.nil?
+      shards = BlankModel.using(:master).connection.shards.keys
+    end
+
+    shards.each do |shard_symbol|
+      %w(schema_migrations users clients cats items keyboards computers permissions_roles roles permissions assignments projects programmers yummy adverts).each do |tables|
+        BlankModel.using(shard_symbol).connection.execute("DELETE FROM #{tables}")
+      end
+      if shard_symbol == 'alone_shard'
+        %w(mmorpg_players weapons skills).each do |table|
+          BlankModel.using(shard_symbol).connection.execute("DELETE FROM #{table}")
+        end
+      end
+      BlankModel.using(:master).connection.shards[shard_symbol].disconnect if Octopus.atleast_rails50?
+    end
+  end
+
+  def self.clean_connection_proxy
+    Thread.current['octopus.current_model'] = nil
+    Thread.current['octopus.current_shard'] = nil
+    Thread.current['octopus.current_group'] = nil
+    Thread.current['octopus.current_slave_group'] = nil
+    Thread.current['octopus.block'] = nil
+
+    ActiveRecord::Base.class_variable_set(:@@connection_proxy, nil)
+  end
+
+  def self.migrating_to_version(version, &_block)
+    migrations_root = File.expand_path(File.join(File.dirname(__FILE__), '..', 'migrations'))
+
+    begin
+      migrate_to_version(:up, migrations_root, version)
+      yield
+    ensure
+      migrate_to_version(:down, migrations_root, version)
+    end
+  end
+
+  def self.migrate_to_version(direction, root, version)
+
+    if Octopus.atleast_rails52?
+      migrations = ActiveRecord::MigrationContext.new(root).migrations.select {|mig| version == mig.version }
+      ActiveRecord::Migrator.new(direction, migrations, version).run
+    else
+      schema     = ActiveRecord::SchemaMigration
+      migrations = ActiveRecord::MigrationContext.new(root, schema).migrations.select {|mig| version == mig.version }
+      ActiveRecord::Migrator.new(direction, migrations, schema, version).run
+    end
+  end
+
+  def self.using_environment(environment, &_block)
+    self.octopus_env = environment.to_s
+    clean_connection_proxy
+    yield
+  ensure
+    self.octopus_env = 'octopus'
+    clean_connection_proxy
+  end
+
+  def self.octopus_env=(env)
+    Octopus.instance_variable_set(:@config, nil)
+    Octopus.stub(:env).and_return(env)
+  end
+end

data/spec/support/query_count.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  class QueryCounter
+    attr_accessor :query_count
+
+    def initialize
+      @query_count = 0
+    end
+
+    def to_proc
+      lambda(&method(:callback))
+    end
+
+    def callback(_name, _start, _finish, _message_id, values)
+      @query_count += 1 unless %w(CACHE SCHEMA).include?(values[:name])
+    end
+  end
+end

data/spec/support/shared_contexts.rb

@@ -0,0 +1,18 @@
+shared_context 'with query cache enabled' do
+  let!(:counter) { ActiveRecord::QueryCounter.new }
+
+  before(:each) do
+    ActiveRecord::Base.connection.enable_query_cache!
+    counter.query_count = 0
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection.disable_query_cache!
+  end
+
+  around(:each) do |example|
+    active_support_subscribed(counter.to_proc, 'sql.active_record') do
+      example.run
+    end
+  end
+end

data/spec/tasks/octopus.rake_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'rake'
+
+describe 'octopus.rake' do
+  before do
+    load File.expand_path('../../../lib/tasks/octopus.rake', __FILE__)
+    Rake::Task.define_task(:environment)
+  end
+
+  describe 'octopus:copy_schema_versions' do
+    class SchemaMigration < ActiveRecord::Base; end
+
+    before do
+      Rake::Task['octopus:copy_schema_versions'].reenable
+
+      path = File.expand_path('../../migrations', __FILE__)
+      ActiveRecord::Migrator.migrations_paths = [path]
+    end
+
+    it 'assumes each shard migrated to the current master version' do
+      SchemaMigration.create(:version => 1)
+      SchemaMigration.create(:version => 2)
+      SchemaMigration.create(:version => 3)
+
+      Rake::Task['octopus:copy_schema_versions'].invoke
+
+      ActiveRecord::Base.connection.shard_names.each do |shard_name|
+        expect(Octopus.using(shard_name) { ActiveRecord::SchemaMigration.all.pluck(:version).map(&:to_i).sort }).to eq([1, 2, 3])
+      end
+    end
+  end
+end