ar-octopus 0.0.1

data/spec/migrations/2_create_users_on_canada.rb

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

data/spec/migrations/3_create_users_on_both_shards.rb

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

data/spec/migrations/4_create_users_on_shards_of_a_group.rb

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

data/spec/migrations/5_create_users_on_multiples_groups.rb

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

data/spec/migrations/6_raise_exception_with_invalid_shard_name.rb

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

data/spec/migrations/7_raise_exception_with_invalid_multiple_shard_names.rb

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

data/spec/migrations/8_raise_exception_with_invalid_group_name.rb

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

data/spec/migrations/9_raise_exception_with_multiple_invalid_group_names.rb

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

data/spec/octopus/controller_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Octopus::Controller do
+  it "should have the using method to select the shard" do
+    pending()
+  end
+end

data/spec/octopus/migration_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Octopus::Migration do    
+  it "should run just in the master shard" do
+    ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 1)
+
+    User.using(:master).find_by_name("Master").should_not be_nil    
+    User.using(:canada).find_by_name("Master").should be_nil
+
+    ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT, 1)
+  end
+
+  it "should run on specific shard" do
+    ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 2)
+
+    User.using(:master).find_by_name("Sharding").should be_nil    
+    User.using(:canada).find_by_name("Sharding").should_not be_nil
+
+    ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT, 2)
+  end
+
+  it "should run on specifieds shards" do
+    ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 3)
+
+    User.using(:brazil).find_by_name("Both").should_not be_nil    
+    User.using(:canada).find_by_name("Both").should_not be_nil
+
+    ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT, 3)
+  end
+
+  it "should run on specified group" do
+    ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 4)
+
+    User.using(:canada).find_by_name("Group").should_not be_nil
+    User.using(:brazil).find_by_name("Group").should_not be_nil    
+    User.using(:russia).find_by_name("Group").should_not be_nil
+
+    ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT, 4)
+  end
+
+  it "should run on multiples groups" do
+    ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 5)
+
+    User.using(:canada).where(:name => "MultipleGroup").all.size.should == 2
+    User.using(:brazil).where(:name => "MultipleGroup").all.size.should == 2
+    User.using(:russia).where(:name => "MultipleGroup").all.size.should == 2
+
+    ActiveRecord::Migrator.run(:down, MIGRATIONS_ROOT, 5)
+  end
+
+  describe "should raise a exception when" do
+    it "you specify a invalid shard name" do
+      lambda { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 6) }.should raise_error("Nonexistent Shard Name: amazing_shard")
+    end
+
+    it "you specify a invalid shard name, even if you have multiple shards, and one of them are right" do
+      lambda { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 7) }.should raise_error("Nonexistent Shard Name: invalid_shard")
+    end
+
+    it "you specify a invalid group name" do
+      lambda { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 8) }.should raise_error("Nonexistent Group Name: invalid_group")
+    end
+
+    it "you specify a invalid group name, even if you have multiple groups, and one of them are right" do
+      lambda { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT, 9) }.should raise_error("Nonexistent Group Name: invalid_group")
+    end
+  end 
+
+  describe "when using replication" do
+    it "should run writes on master when you use replication" do
+      pending()
+    end
+
+    it "should run in all shards, master or another shards" do
+      pending()
+    end
+  end
+end
+

data/spec/octopus/model_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Octopus::Model do
+  describe "#using method" do
+    it "should return self after calling the #using method" do
+      User.using(:canada).should == User
+    end
+
+    it "should allow selecting the shards on scope" do
+      User.using(:canada).create!(:name => 'oi')
+      User.using(:canada).count.should == 1
+      User.count.should == 0
+    end
+
+    it "should allow scoping dynamically" do
+      User.using(:canada).using(:master).using(:canada).create!(:name => 'oi')
+      User.using(:canada).using(:master).count.should == 0
+      User.using(:master).using(:canada).count.should == 1
+    end
+
+    it "should clean the current_shard after executing the current query" do
+      User.using(:canada).create!(:name => "oi")
+      User.count.should == 0
+    end
+
+    it "should support both groups and alone shards" do
+      User.using(:alone_shard).create!(:name => "Alone")
+      User.using(:alone_shard).count.should == 1
+      User.using(:canada).count.should == 0
+      User.using(:brazil).count.should == 0
+      User.count.should == 0
+    end
+    
+    describe "passing a block" do
+      it "should allow queries be executed inside the block, ponting to a specific shard" do
+         User.using(:canada) do
+           User.create(:name => "oi")
+         end
+
+         User.using(:canada).count.should == 1
+         User.using(:master).count.should == 0
+         User.count.should == 0      
+       end
+
+       it "should allow execute queries inside a model" do
+         u = User.new
+         u.awesome_queries()
+         User.using(:canada).count.should == 1
+         User.count.should == 0
+       end
+    end
+    
+    describe "when you have a relationship" do
+      it "should find all models in the specified shard" do
+        pending()
+        # 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)
+        # c = Client.using(:brazil).find_by_name("Brazil Client")
+        # Client.using(:master).create!(:name => "teste")
+        # c.items.should == [item_brazil]
+      end
+    end
+    
+    describe "raising errors" do
+      it "should raise a error when you specify a shard that doesn't exist" do
+        lambda { User.using(:crazy_shard) }.should raise_error("Nonexistent Shard Name: crazy_shard")
+      end
+    end
+  end
+
+  describe "using a postgresql shard" do
+    after(:each) do
+      User.using(:postgresql_shard).delete_all
+    end
+    
+    it "should update the Arel Engine" do
+      User.using(:postgresql_shard).arel_engine.connection.adapter_name.should == "PostgreSQL"
+      User.using(:alone_shard).arel_engine.connection.adapter_name.should == "MySQL"
+    end
+    
+    it "should works with writes and reads" do
+      pending()
+      #u = User.using(:postgresql_shard).create!(:name => "PostgreSQL User")
+      #       #User.using(:postgresql_shard).arel_table.columns.should == ""
+      #       User.using(:postgresql_shard).scoped.should ==  ""
+      #       User.using(:alone_shard).find(:all).should == []
+    end
+  end
+  
+  describe "#replicated_model method" do
+    before(:each) do
+      Octopus.stub!(:env).and_return("production_replicated")
+      @proxy = Octopus::Proxy.new(Octopus.config())
+      #TODO - This is ugly, but is better than mocking
+      ActiveRecord::Base.class_eval("@@connection_proxy = nil")
+      #TODO - This is ugly, but is better than mocking
+    end
+    
+    after(:each) do
+      #TODO - One little Kitten dies each time this code is executed.
+      ActiveRecord::Base.class_eval("@@connection_proxy = nil")
+    end
+    
+    it "should be replicated" do
+      ActiveRecord::Base.connection_proxy.replicated.should be_true
+    end
+    
+    it "should mark the Cat model as replicated" do
+      Cat.all.should == []
+      ActiveRecord::Base.connection_proxy.replicated_models.first.should == "Cat"
+    end
+  end
+  
+  describe "#sharded_by method" do
+    it "should send all queries to the specify shard" do
+      pending()
+    end
+  end
+end

data/spec/octopus/octopus_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Octopus do
+  describe "#config method" do
+    it "should load shards.yml file to start working" do
+      Octopus.config().should be_kind_of(Hash)
+    end
+  end
+
+  describe "#directory method" do
+    it "should return the directory that contains the shards.yml file" do
+      Octopus.directory().should == File.expand_path(File.dirname(__FILE__) + "/../")
+    end
+  end
+end

data/spec/octopus/proxy_spec.rb

@@ -0,0 +1,112 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Octopus::Proxy do
+  before(:each) do
+    @proxy = Octopus::Proxy.new(Octopus.config())
+  end
+
+  describe "creating a new instance" do    
+    it "should initialize all shards and groups" do
+      @proxy.shards.keys.to_set.should == [:postgresql_shard, :alone_shard, :aug2011, :canada, :brazil, :aug2009, :russia, :aug2010, :master].to_set
+      @proxy.groups.should == {:country_shards=>[:canada, :brazil, :russia], :history_shards=>[:aug2009, :aug2010, :aug2011]}
+    end
+
+    it "should initialize the block attribute as false" do
+      @proxy.block.should be_false
+    end    
+    it "should initialize replicated attribute as false" do
+      @proxy.replicated.should be_false      
+    end
+
+    describe "should raise error if you have duplicated shard names" do
+      before(:each) do
+        Octopus.stub!(:env).and_return("production_raise_error")        
+      end
+
+      it "should raise the error" do
+        lambda { Octopus::Proxy.new(Octopus.config()) }.should raise_error("You have duplicated shard names!")        
+      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        
+      end
+
+      it "when current_shard is a single shard" do
+        @proxy.current_shard = :canada
+        @proxy.shard_name.should == :canada        
+      end
+
+      it "when current_shard is more than one shard" do
+        @proxy.current_shard = [:russia, :brazil]
+        @proxy.shard_name.should == :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.shards[:master].connection()        
+      end
+
+      it "when current_shard is a single shard" do
+        @proxy.current_shard = :canada
+        @proxy.select_connection().should == @proxy.shards[:canada].connection()       
+      end
+    end
+  end
+
+  describe "when the database is replicated" do
+    before(:each) do
+      Octopus.stub!(:env).and_return("production_replicated")
+      @proxy = Octopus::Proxy.new(Octopus.config())
+      #TODO - THIS IS SO UGLY
+      ActiveRecord::Base.class_eval("@@connection_proxy = nil")
+    end
+    
+    it "should have the replicated attribute as true" do
+      @proxy.replicated.should be_true
+    end
+
+    it "should initialize the list of shards" do
+      @proxy.slaves_list.should == ["slave1", "slave2", "slave3", "slave4"]
+    end
+
+    it "should send all writes queries to master" do
+      u = User.create!(:name => "Replicated")
+
+      [:slave4, :slave1, :slave2, :slave3].each do |sym|
+        User.using(sym).count.should == 0
+      end
+
+      User.using(:master).count.should == 1
+    end
+
+    it "should send read queries to slaves, using a round robin algorithm" do
+      u = Cat.create!(:name => "master")
+      c = Client.create!(:name => "client_master")
+      
+      [:slave4, :slave1, :slave2, :slave3].each do |sym|
+        Cat.using(sym).create!(:name => "Replicated_#{sym}")
+      end
+      
+      Client.find(:first).should_not be_nil
+      Cat.find(:first).name.should == "Replicated_slave1"
+      Client.find(:first).should_not be_nil
+      Cat.find(:first).name.should == "Replicated_slave2"
+      Client.find(:first).should_not be_nil
+      Cat.find(:first).name.should == "Replicated_slave3"
+      Client.find(:first).should_not be_nil
+      Cat.find(:first).name.should == "Replicated_slave4"
+      Client.find(:first).should_not be_nil
+      Cat.find(:first).name.should == "Replicated_slave1"
+      Client.find(:first).should_not be_nil
+      
+      [:slave4, :slave1, :slave2, :slave3].each do |sym|
+        Cat.using(sym).find_by_name("master").should be_false
+      end
+    end
+  end
+end