partitioned 0.8.0

data/spec/partitioned/by_created_at_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
+require "#{File.dirname(__FILE__)}/../support/shared_example_spec_helper_for_time_key"
+
+module Partitioned
+
+  describe ByCreatedAt do
+
+    include TablesSpecHelper
+
+    module CreatedAt
+      class Employee < Partitioned::ByCreatedAt
+        belongs_to :company, :class_name => 'Company'
+        attr_accessible :company_id, :name, :created_at
+
+        partitioned do |partition|
+          partition.index :id, :unique => true
+          partition.foreign_key :company_id
+        end
+      end # Employee
+    end # CreatedAt
+
+    before(:all) do
+      @employee = CreatedAt::Employee
+      create_tables
+      dates = @employee.partition_generate_range(DATE_NOW,
+                                                 DATE_NOW + 7.days)
+      @employee.create_new_partition_tables(dates)
+      ActiveRecord::Base.connection.execute <<-SQL
+        insert into employees_partitions.
+          p#{DATE_NOW.at_beginning_of_week.strftime('%Y%m%d')}
+          (company_id,name) values (1,'Keith');
+      SQL
+    end
+
+    after(:all) do
+      drop_tables
+    end
+
+    let(:class_by_created_at) { ::Partitioned::ByCreatedAt }
+
+    describe "model is abstract class" do
+
+      it "returns true" do
+        class_by_created_at.abstract_class.should be_true
+      end
+
+    end # model is abstract class
+
+    describe "#partition_time_field" do
+
+      it "returns :created_at" do
+        class_by_created_at.partition_time_field.should == :created_at
+      end
+
+    end # #partition_time_field
+
+    it_should_behave_like "check that basic operations with postgres works correctly for time key", CreatedAt::Employee
+
+  end # ByCreatedAt
+
+end # Partitioned

data/spec/partitioned/by_foreign_key_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
+require "#{File.dirname(__FILE__)}/../support/shared_example_spec_helper_for_integer_key"
+
+module Partitioned
+
+  describe ByForeignKey do
+
+    include TablesSpecHelper
+
+    module ForeignKey
+      class Employee < ByForeignKey
+        belongs_to :company, :class_name => 'Company'
+        attr_accessible :name, :integer_field, :company_id
+
+        def self.partition_foreign_key
+          return :company_id
+        end
+
+        partitioned do |partition|
+          partition.foreign_key :company_id
+        end
+      end # Employee
+    end # ForeignKey
+
+    before(:all) do
+      @employee =  ForeignKey::Employee
+      create_tables
+      @employee.create_new_partition_tables(Range.new(1, 3).step(@employee.partition_table_size))
+      ActiveRecord::Base.connection.execute <<-SQL
+        insert into employees_partitions.p1 (company_id,name) values (1,'Keith');
+      SQL
+    end
+
+    after(:all) do
+      drop_tables
+    end
+
+    let(:class_by_foreign_key) { ::Partitioned::ByForeignKey }
+
+    describe "model is abstract class" do
+
+      it "returns true" do
+        class_by_foreign_key.abstract_class.should be_true
+      end
+
+    end # model is abstract class
+
+    describe "#partition_foreign_key" do
+
+      it "raises MethodNotImplemented" do
+        lambda {
+          class_by_foreign_key.partition_foreign_key
+        }.should raise_error(MethodNotImplemented)
+      end
+
+    end # #partition_foreign_key
+
+    describe "partitioned block" do
+
+      context "checks data in the foreign_keys is Proc" do
+
+        it "returns Proc" do
+          class_by_foreign_key.configurator_dsl.data.foreign_keys.first.should be_is_a Proc
+        end
+
+      end # checks data in the foreign_keys is Proc
+
+      context "checks if there is data in the foreign_keys" do
+
+        let(:proc) do
+          class_by_foreign_key.configurator_dsl.data.foreign_keys.first.call(@employee, :id)
+        end
+
+        it "returns referencing_field" do
+          proc.referencing_field.should == :company_id
+        end
+
+        it "returns referenced_field" do
+          proc.referenced_field.should == :id
+        end
+
+        it "returns referencing_field" do
+          proc.referenced_table.should == "companies"
+        end
+
+      end # checks if there is data in the foreign_keys
+
+    end # partitioned block
+
+    it_should_behave_like "check that basic operations with postgres works correctly for integer key", ForeignKey::Employee
+
+  end # ByForeignKey
+
+end # Partitioned

data/spec/partitioned/by_id_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
+require "#{File.dirname(__FILE__)}/../support/shared_example_spec_helper_for_integer_key"
+
+module Partitioned
+
+  describe ById do
+
+    include TablesSpecHelper
+
+    module Id
+      class Employee < ById
+        belongs_to :company, :class_name => 'Company'
+        attr_accessible :company_id, :name, :integer_field
+
+        def self.partition_table_size
+          return 1
+        end
+
+        partitioned do |partition|
+          partition.foreign_key :company_id
+        end
+      end # Employee
+    end # Id
+
+    before(:all) do
+      @employee = Id::Employee
+      create_tables
+      @employee.create_new_partition_tables(Range.new(1, 5).step(@employee.partition_table_size))
+      ActiveRecord::Base.connection.execute <<-SQL
+        insert into employees_partitions.p1 (company_id,name) values (1,'Keith');
+      SQL
+    end
+
+    after(:all) do
+      drop_tables
+    end
+
+    let(:class_by_id) { ::Partitioned::ById }
+
+    describe "model is abstract class" do
+
+      it "returns true" do
+        class_by_id.abstract_class.should be_true
+      end
+
+    end # model is abstract class
+
+    describe "#prefetch_primary_key?" do
+
+      context "is :id set as a primary_key" do
+
+        it "returns true" do
+          class_by_id.prefetch_primary_key?.should be_true
+        end
+
+      end # is :id set as a primary_key
+
+    end # #prefetch_primary_key?
+
+    describe "#partition_table_size" do
+
+      it "returns 10000000" do
+        class_by_id.partition_table_size.should == 10000000
+      end
+
+    end # #partition_table_size
+
+    describe "#partition_integer_field" do
+
+      it "returns :id" do
+        class_by_id.partition_integer_field.should == :id
+      end
+
+    end # #partition_integer_field
+
+    describe "partitioned block" do
+
+      context "checks if there is data in the indexes field" do
+
+        it "returns :id" do
+          class_by_id.configurator_dsl.data.indexes.first.field.should == :id
+        end
+
+        it "returns { :unique => true }" do
+          class_by_id.configurator_dsl.data.indexes.first.options.should == { :unique => true }
+        end
+
+      end # checks if there is data in the indexes field
+
+    end # partitioned block
+
+    it_should_behave_like "check that basic operations with postgres works correctly for integer key", Id::Employee
+
+  end # ById
+
+end # Partitioned

data/spec/partitioned/by_integer_field_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
+require "#{File.dirname(__FILE__)}/../support/shared_example_spec_helper_for_integer_key"
+
+module Partitioned
+
+  describe ByIntegerField do
+
+    include TablesSpecHelper
+
+    module IntegerField
+      class Employee < Partitioned::ByIntegerField
+        belongs_to :company, :class_name => 'Company'
+        attr_accessible :name, :integer_field, :company_id
+
+        def self.partition_integer_field
+          return :integer_field
+        end
+
+        partitioned do |partition|
+          partition.index :id, :unique => true
+        end
+      end # Employee
+    end # IntegerField
+
+    before(:all) do
+      create_tables
+      @employee = IntegerField::Employee
+      @employee.create_new_partition_tables(Range.new(1, 4).step(@employee.partition_table_size))
+      ActiveRecord::Base.connection.execute <<-SQL
+        insert into employees_partitions.p1 (integer_field,company_id,name) values (1,1,'Keith');
+      SQL
+    end
+
+    after(:all) do
+      drop_tables
+    end
+
+    let(:class_by_integer_field) { ::Partitioned::ByIntegerField }
+
+    describe "model is abstract class" do
+
+      it "returns true" do
+        class_by_integer_field.abstract_class.should be_true
+      end
+
+    end # model is abstract class
+
+    describe "#partition_table_size" do
+
+      it "returns 1" do
+        class_by_integer_field.partition_table_size.should == 1
+      end
+
+    end # #partition_table_size
+
+    describe "#partition_integer_field" do
+
+      it "raises MethodNotImplemented" do
+        lambda {
+          class_by_integer_field.partition_integer_field
+        }.should raise_error(MethodNotImplemented)
+      end
+
+    end # #partition_integer_field
+
+    describe "#partition_normalize_key_value" do
+
+      context "when call method with param equal five" do
+
+        it "returns 5" do
+          class_by_integer_field.partition_normalize_key_value(5).should == 5
+        end
+
+      end
+
+    end # #partition_normalize_key_value
+
+    describe "partitioned block" do
+
+      let(:data) do
+        class_by_integer_field.configurator_dsl.data
+      end
+
+      context "checks data in the on_field is Proc" do
+
+        it "returns Proc" do
+          data.on_field.should be_is_a Proc
+        end
+
+      end # checks data in the on_field is Proc
+
+      context "checks data in the check_constraint is Proc" do
+
+        it "returns Proc" do
+          data.check_constraint.should be_is_a Proc
+        end
+
+      end # checks data in the check_constraint is Proc
+
+      context "checks data in the on_field" do
+
+        it "returns on_field" do
+          data.on_field.call(@employee).should == :integer_field
+        end
+
+      end # checks data in the on_field
+
+      context "checks data in the last_partitions_order_by_clause" do
+
+        it "returns last_partitions_order_by_clause" do
+          data.last_partitions_order_by_clause.should == "substring(tablename, 2)::integer desc"
+        end
+
+      end # checks data in the last_partitions_order_by_clause
+
+      context "checks data in the check_constraint" do
+
+        it "returns check_constraint" do
+          data.check_constraint.call(@employee, 1).should == "( integer_field = 1 )"
+        end
+
+      end # checks data in the check_constraint
+
+      context "checks data in the check_constraint, when partition_table_size != 1" do
+
+        before do
+          @employee.stub!(:partition_table_size).and_return(2)
+        end
+
+        it "returns check_constraint" do
+          data.check_constraint.call(@employee, 1).should == "( integer_field >= 0 and integer_field < 2 )"
+        end
+
+      end # checks data in the check_constraint, when partition_table_size != 1
+
+    end # partitioned block
+
+    it_should_behave_like "check that basic operations with postgres works correctly for integer key", IntegerField::Employee
+
+  end # ByIntegerField
+
+end # Partitioned

data/spec/partitioned/by_monthly_time_field_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
+require "#{File.dirname(__FILE__)}/../support/shared_example_spec_helper_for_time_key"
+
+module Partitioned
+
+  describe ByMonthlyTimeField do
+
+    include TablesSpecHelper
+
+    module MonthlyTimeField
+      class Employee < Partitioned::ByMonthlyTimeField
+        belongs_to :company, :class_name => 'Company'
+        attr_accessible :company_id, :name, :created_at
+
+        def self.partition_time_field
+          return :created_at
+        end
+
+        partitioned do |partition|
+          partition.index :id, :unique => true
+          partition.foreign_key :company_id
+        end
+      end # Employee
+    end # MonthlyTimeField
+
+    before(:all) do
+      @employee = MonthlyTimeField::Employee
+      create_tables
+      dates = @employee.partition_generate_range(DATE_NOW,
+                                                 DATE_NOW + 1.month)
+      @employee.create_new_partition_tables(dates)
+      ActiveRecord::Base.connection.execute <<-SQL
+        insert into employees_partitions.
+          p#{DATE_NOW.at_beginning_of_month.strftime('%Y%m')}
+          (company_id,name) values (1,'Keith');
+      SQL
+    end
+
+    after(:all) do
+      drop_tables
+    end
+
+    let(:class_by_monthly_time_field) { ::Partitioned::ByMonthlyTimeField }
+
+    describe "model is abstract class" do
+
+      it "returns true" do
+        class_by_monthly_time_field.abstract_class.should be_true
+      end
+
+    end # model is abstract class
+
+    describe "#partition_normalize_key_value" do
+
+      it "returns date with day set to 1st of the month" do
+        class_by_monthly_time_field.
+            partition_normalize_key_value(Date.parse('2011-01-05')).
+            should == Date.parse('2011-01-01')
+      end
+
+    end # #partition_normalize_key_value
+
+    describe "#partition_table_size" do
+
+      it "returns 1.month" do
+        class_by_monthly_time_field.partition_table_size.should == 1.month
+      end
+
+    end # #partition_table_size
+
+    describe "partitioned block" do
+
+      let(:data) do
+        class_by_monthly_time_field.configurator_dsl.data
+      end
+
+      context "checks data in the base_name is Proc" do
+
+        it "returns Proc" do
+          data.base_name.should be_is_a Proc
+        end
+
+      end # checks data in the on_field is Proc
+
+      context "checks data in the base_name" do
+
+        it "returns base_name" do
+          data.base_name.call(@employee, Date.parse('2011-02-05')).should == "201102"
+        end
+
+      end # checks data in the base_name
+
+    end # partitioned block
+
+    it_should_behave_like "check that basic operations with postgres works correctly for time key", MonthlyTimeField::Employee
+
+  end # ByMonthlyTimeField
+
+end # Partitioned