octoball 0.1.0

data/spec/octoball/relation_proxy_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Octoball::RelationProxy do
+  describe 'shard tracking' do
+    before :each do
+      @client = Client.using(:canada).create!
+      @client.items << Item.using(:canada).create!
+      @relation = @client.items
+    end
+
+    it 'remembers the shard on which a relation was created' do
+      expect(@relation.current_shard).to eq(:canada)
+    end
+
+    it 'can define collection association with the same name as ancestor private method' do
+      @client.comments << Comment.using(:canada).create!(open: true)
+      expect(@client.comments.open.ar_relation).to be_a_kind_of(ActiveRecord::Relation)
+    end
+
+    it 'can be dumped and loaded' do
+      expect(Marshal.load(Marshal.dump(@relation))).to eq @relation
+    end
+
+    it 'is flattenable' do
+      expect([@relation].flatten).to eq @relation.to_a
+    end
+
+    it 'maintains the current shard when using where.not(...)' do
+      where_chain = @relation.where
+      expect(where_chain.current_shard).to eq(@relation.current_shard)
+      not_relation = where_chain.not("1=0")
+      expect(not_relation.current_shard).to eq(@relation.current_shard)
+    end
+
+    context 'when a new relation is constructed from the original relation' do
+      context 'and a where(...) is used' do
+        it 'does not tamper with the original relation' do
+          relation = Item.using(:canada).where(id: 1)
+          original_sql = relation.to_sql
+          new_relation = relation.where(id: 2)
+          expect(relation.to_sql).to eq(original_sql)
+        end
+      end
+
+      context 'and a where.not(...) is used' do
+        it 'does not tamper with the original relation' do
+          relation = Item.using(:canada).where(id: 1)
+          original_sql = relation.to_sql
+          new_relation = relation.where.not(id: 2)
+          expect(relation.to_sql).to eq(original_sql)
+        end
+      end
+    end
+
+    context 'when comparing to other Relation objects' do
+      before :each do
+        @relation.reset
+      end
+
+      it 'is equal to its clone' do
+        expect(@relation).to eq(@relation.clone)
+      end
+    end
+
+    it "can deliver methods in ActiveRecord::Batches correctly when given a block" do
+      expect { @relation.find_each(&:inspect) }.not_to raise_error
+    end
+
+    it "can deliver methods in ActiveRecord::Batches correctly as an enumerator" do
+      expect { @relation.find_each.each(&:inspect) }.not_to raise_error
+    end
+
+    it "can deliver methods in ActiveRecord::Batches correctly as a lazy enumerator" do
+      expect { @relation.find_each.lazy.each(&:inspect) }.not_to raise_error
+    end
+
+    it 'should be able to return its ActiveRecord::Relation' do
+      expect(@relation.ar_relation.is_a? ActiveRecord::Relation).to eq true
+    end
+
+    it 'is equal to an identically-defined, but different, RelationProxy' do
+      i = @client.items
+      expect(@relation).to eq(i)
+      expect(@relation.__id__).not_to eq(i.__id__)
+    end
+
+    it 'is equal to its own underlying ActiveRecord::Relation' do
+      expect(@relation).to eq(@relation.ar_relation)
+      expect(@relation.ar_relation).to eq(@relation)
+    end
+
+    context 'when no explicit shard context is provided' do
+      it 'uses the correct shard' do
+        expect(@relation.count).to eq(1)
+      end
+
+      it 'lazily evaluates on the correct shard' do
+        # Do something to force Client.connection_proxy.current_shard to change
+        _some_count = Client.using(:brazil).count
+        expect(@relation.select(:client_id).count).to eq(1)
+      end
+    end
+
+    context 'when an explicit, but different, shard context is provided' do
+      it 'uses the correct shard' do
+        expect(Item.using(:brazil).count).to eq(0)
+        _clients_on_brazil = Client.using(:brazil).all
+        Octoball.using(:brazil) do
+          expect(@relation.count).to eq(1)
+        end
+      end
+
+      it 'uses the correct shard in block when method_missing is triggered on CollectionProxy objects' do
+        Octoball.using(:brazil) do
+          @client.items.each do |item|
+            expect(item.current_shard).to eq(:canada)
+            expect(ActiveRecord::Base.connection.current_shard).to eq(:brazil)
+          end
+        end
+      end
+
+      it 'lazily evaluates on the correct shard' do
+        expect(Item.using(:brazil).count).to eq(0)
+        Octoball.using(:brazil) do
+          expect(@relation.select(:client_id).count).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/octoball/scope_proxy_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Octoball 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).first }.to raise_exception(ActiveRecord::ConnectionNotEstablished)
+  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/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'octoball'
+
+Octoball.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"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  mysql_spec = {
+    adapter:  'mysql2',
+    host:     (ENV['MYSQL_HOST'] || 'localhost'),
+    username: (ENV['MYSQL_USER'] || 'root'),
+    encoding: 'utf8mb4',
+  }
+  ActiveRecord::Base.configurations = {
+    "test" => {
+      shard1: mysql_spec.merge(database: 'octoball_shard_1'),
+      shard2: mysql_spec.merge(database: 'octoball_shard_2'),
+      shard3: mysql_spec.merge(database: 'octoball_shard_3'),
+      shard4: mysql_spec.merge(database: 'octoball_shard_4'),
+      shard5: mysql_spec.merge(database: 'octoball_shard_5'),
+    }
+  }
+
+  config.before(:each) do |example|
+    TestHelper.clean_all_shards(example.metadata[:shards])
+  end
+end

data/spec/support/database_connection.rb

@@ -0,0 +1,22 @@
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.open('database.log', 'a'))
+
+mysql_spec = {
+  adapter:  'mysql2',
+  host:     (ENV['MYSQL_HOST'] || 'localhost'),
+  username: (ENV['MYSQL_USER'] || 'root'),
+  encoding: 'utf8mb4',
+}
+
+ActiveRecord::Base.configurations = {
+  "test" => {
+    shard1: mysql_spec.merge(database: 'octoball_shard_1'),
+    shard2: mysql_spec.merge(database: 'octoball_shard_2'),
+    shard3: mysql_spec.merge(database: 'octoball_shard_3'),
+    shard4: mysql_spec.merge(database: 'octoball_shard_4'),
+    shard5: mysql_spec.merge(database: 'octoball_shard_5'),
+  }
+}
+ActiveRecord::Base.establish_connection(
+  ActiveRecord::Base.configurations.configs_for(env_name: "test").first)

data/spec/support/database_models.rb

@@ -0,0 +1,115 @@
+require './spec/models/application_record.rb'
+
+# The user class is just sharded, not replicated
+class User < ApplicationRecord
+  scope :thiago, -> { where(:name => 'Thiago') }
+
+  def awesome_queries
+    Octoball.using(:canada) do
+      User.create(:name => 'teste')
+    end
+  end
+end
+
+# The client class isn't replicated
+class Client < ApplicationRecord
+  has_many :items
+  has_many :comments, :as => :commentable
+end
+
+# This class sets its own connection
+class CustomConnectionBase < ActiveRecord::Base
+  self.abstract_class = true
+  establish_connection(:adapter => 'mysql2', :host => (ENV['MYSQL_HOST'] || 'localhost'), :database => 'octoball_shard_2', :username => "#{ENV['MYSQL_USER'] || 'root'}", :password => '')
+  connects_to shards: {
+    custom_shard: { writing: :shard3 }
+  }
+end
+
+class CustomConnection < CustomConnectionBase
+  self.table_name = 'custom'
+end
+
+# This items belongs to a client
+class Item < ApplicationRecord
+  belongs_to :client
+  has_many :parts
+end
+
+class Part < ApplicationRecord
+  belongs_to :item
+end
+
+class Keyboard < ApplicationRecord
+  validates_uniqueness_of(:name, case_sensitive: true)
+  belongs_to :computer
+end
+
+class Computer < ApplicationRecord
+  has_one :keyboard
+end
+
+class Role < ApplicationRecord
+  has_and_belongs_to_many :permissions
+end
+
+class Permission < ApplicationRecord
+  has_and_belongs_to_many :roles
+end
+
+class Assignment < ApplicationRecord
+  belongs_to :programmer
+  belongs_to :project
+end
+
+class Programmer < ApplicationRecord
+  has_many :assignments
+  has_many :projects, :through => :assignments
+end
+
+class Project < ApplicationRecord
+  has_many :assignments
+  has_many :programmers, :through => :assignments
+end
+
+class Comment < ApplicationRecord
+  belongs_to :commentable, :polymorphic => true
+  scope :open, -> { where(open: true) }
+end
+
+class Bacon < ApplicationRecord
+  self.table_name = 'yummy'
+end
+
+class Cheese < ApplicationRecord
+  self.table_name = 'yummy'
+end
+
+class Ham < ApplicationRecord
+  self.table_name = 'yummy'
+end
+
+# This class sets its own connection
+class Advert < ApplicationRecord
+end
+
+class MmorpgPlayer < ApplicationRecord
+  has_many :weapons
+  has_many :skills
+end
+
+class Weapon < ApplicationRecord
+  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 < ApplicationRecord
+  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/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/support/test_helper.rb

@@ -0,0 +1,14 @@
+module TestHelper
+  def self.clean_all_shards(shards)
+    (shards || [:master, :brazil, :canada, :russia, :alone_shard]).each do |shard_symbol|
+      %w(users clients cats items keyboards computers permissions_roles roles permissions assignments projects programmers yummy adverts).each do |tables|
+        ApplicationRecord.using(shard_symbol).connection.execute("DELETE FROM #{tables}")
+      end
+      if shard_symbol == :alone_shard
+        %w(mmorpg_players weapons skills).each do |table|
+          ApplicationRecord.using(shard_symbol).connection.execute("DELETE FROM #{table}")
+        end
+      end
+    end
+  end
+end