sql_partitioner 0.6.0

data/spec/lib/sql_partitioner/partition_spec.rb

@@ -0,0 +1,268 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+shared_examples_for "PartitionCollection" do
+  before(:each) do
+    @partition_manager = SqlPartitioner::BasePartitionsManager.new(
+      :adapter      => adapter,
+      :current_time => Time.utc(2014,04,18),
+      :table_name   => 'test_events',
+      :logger       => SPEC_LOGGER
+    )
+  end
+
+  context "with some partitions" do
+    before(:each) do
+      @partitions = {'until_2014_03_17' => 1395014400, 'until_2014_04_17' => 1397692800}
+      @sorted = SqlPartitioner::SQL.sort_partition_data(@partitions)
+      @newest_partition_ts = @sorted.last[1]
+      @oldest_partition_ts = @sorted.first[1]
+      @partition_manager.initialize_partitioning(@partitions)
+      @all_partitions = SqlPartitioner::Partition.all(adapter, 'test_events')
+    end
+
+    describe "#current_partition" do
+      it "should return nil when timestamp > newest partition.timestamp" do
+        @all_partitions.current_partition(@newest_partition_ts + 1).should == nil
+      end
+      it "should return nil when timestamp == newest partition.timestamp" do
+        @all_partitions.current_partition(@newest_partition_ts).should == nil
+      end
+      it "should return the newest partition when timestamp < newest partition.timestamp" do
+        @all_partitions.current_partition(@newest_partition_ts - 1).name.should == @sorted.last[0]
+      end
+      it "should return the oldest partition when timestamp < oldest partition.timestamp" do
+        @all_partitions.current_partition(@oldest_partition_ts - 1).name.should == @sorted.first[0]
+      end
+    end
+
+    describe "#older_than_timestamp" do
+      it "should return nil when timestamp < oldest partition.timestamp" do
+        @all_partitions.older_than_timestamp(@oldest_partition_ts - 1).should == []
+      end
+      it "should return nil when timestamp == partition.timestamp" do
+        @all_partitions.older_than_timestamp(@oldest_partition_ts).should == []
+      end
+      it "should return the partition when timestamp > newest partition timestamp" do
+        @all_partitions.older_than_timestamp(@newest_partition_ts + 1).map{|p| [p.name, p.timestamp]}.should == [
+          ['until_2014_03_17', 1395014400],
+          ['until_2014_04_17', 1397692800],
+        ]
+      end
+    end
+
+    describe "#newer_than_timestamp" do
+      it "should return nil when timestamp > newest partition.timestamp" do
+        @all_partitions.newer_than_timestamp(@newest_partition_ts + 1).should == []
+      end
+      it "should return the newest partition when timestamp == partition.timestamp" do
+        @all_partitions.newer_than_timestamp(@newest_partition_ts).map{|p| [p.name, p.timestamp]}.should == [
+            ['until_2014_04_17', 1397692800]
+        ]
+      end
+      it "should return all the partition when timestamp < oldest partition timestamp" do
+        @all_partitions.newer_than_timestamp(@oldest_partition_ts - 1).map{|p| [p.name, p.timestamp]}.should == [
+            ['until_2014_03_17', 1395014400],
+            ['until_2014_04_17', 1397692800],
+        ]
+      end
+    end
+
+  end
+
+
+  describe "#non_future_partitions" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::BasePartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+
+      @partitions = {'until_2014_03_17' => 1395014400}
+      @partition_manager.initialize_partitioning(@partitions)
+    end
+
+    it "should not return the future partition" do
+      SqlPartitioner::Partition.all(adapter, 'test_events').non_future_partitions.map{|p| [p.name, p.timestamp]}.should == [
+        ['until_2014_03_17', 1395014400]
+      ]
+    end
+  end
+
+  describe "#latest_partition" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::BasePartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+    end
+
+    context "with some partitions" do 
+      before(:each) do
+        @partitions = {'until_2014_03_17' => 1395014400, 'until_2014_04_17' => 1397692800}
+        @partition_manager.initialize_partitioning(@partitions)
+      end
+
+      it "should return the latest partition" do
+        partition = SqlPartitioner::Partition.all(adapter, 'test_events').latest_partition
+
+        partition.name.should      == 'until_2014_04_17'
+        partition.timestamp.should == 1397692800
+      end
+    end
+
+    context "with no partitions" do
+      before(:each) do
+        @partition_manager.initialize_partitioning({})
+      end
+
+      it "should not return the future partition" do
+        SqlPartitioner::Partition.all(adapter, 'test_events').latest_partition.should == nil
+      end
+    end
+  end
+
+  describe "#oldest_partition" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::BasePartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+    end
+
+    context "with some partitions" do 
+      before(:each) do
+        @partitions = {'until_2014_03_17' => 1395014400, 'until_2014_04_17' => 1397692800}
+        @partition_manager.initialize_partitioning(@partitions)
+      end
+
+      it "should the oldest partition" do
+        partition = SqlPartitioner::Partition.all(adapter, 'test_events').oldest_partition
+
+        partition.name.should      == 'until_2014_03_17'
+        partition.timestamp.should == 1395014400
+      end
+    end
+  end
+end
+
+
+shared_examples_for "Partition" do
+  before(:each) do
+    @partition_manager = SqlPartitioner::BasePartitionsManager.new(
+      :adapter      => adapter,
+      :current_time => Time.utc(2014,04,18),
+      :table_name   => 'test_events',
+      :logger       => SPEC_LOGGER
+    )
+  end
+  describe ".all" do
+    context "with no partitions" do
+      it "should an empty PartitionCollection" do
+        SqlPartitioner::Partition.all(adapter, 'test_events').should == []
+      end
+    end
+    context "with some partitions" do
+      before(:each) do
+        @partitions = {'until_2014_03_17' => 1395014400}
+        @partition_manager.initialize_partitioning(@partitions)
+      end
+
+      it "should return a PartitionCollection containing all the partitions" do
+        SqlPartitioner::Partition.all(adapter, 'test_events').map{|p| [p.name, p.timestamp]}.should == [
+          ['until_2014_03_17', 1395014400],
+          ["future", "MAXVALUE"]
+        ]
+      end
+    end
+  end
+
+  describe "#future_partition?" do
+    before(:each) do
+      @partitions = {'until_2014_03_17' => 1395014400}
+      @partition_manager.initialize_partitioning(@partitions)
+    end
+
+    it "should return true for the future partition" do
+      SqlPartitioner::Partition.all(adapter, 'test_events').last.future_partition?.should == true
+    end
+    it "should return false for non-future partition" do
+      SqlPartitioner::Partition.all(adapter, 'test_events').first.future_partition?.should == false
+    end
+  end
+
+  describe "#timestamp" do
+    before(:each) do
+      @partitions = {'until_2014_03_17' => 1395014400}
+      @partition_manager.initialize_partitioning(@partitions)
+    end
+
+    it "should return 'MAXVALUE' for the future partition" do
+      SqlPartitioner::Partition.all(adapter, 'test_events').last.timestamp.should == SqlPartitioner::Partition::FUTURE_PARTITION_VALUE
+    end
+    it "should return the timestamp for non-future partition" do
+      SqlPartitioner::Partition.all(adapter, 'test_events').first.timestamp.should == @partitions.values.last
+    end
+  end
+
+  describe "#to_log" do
+    before(:each) do
+      @partitions = {'until_2014_03_17' => 1395014400}
+      @partition_manager.initialize_partitioning(@partitions)
+    end
+
+    it "should return 'none' for no partitions" do
+      SqlPartitioner::Partition.to_log([]).should == 'none'
+    end
+
+    it "should return a pretty log message with partitions" do
+      log_msg =  "---------------------------------------------------------------------------------------------\n" +
+                 "ordinal_position   name               timestamp    table_rows   data_length   index_length   \n" +
+                 "---------------------------------------------------------------------------------------------\n" +
+                 "1                  until_2014_03_17   1395014400   0            16384         0              \n" +
+                 "2                  future             MAXVALUE     0            16384         0              \n" +
+                 "---------------------------------------------------------------------------------------------"
+
+      SqlPartitioner::Partition.to_log(SqlPartitioner::Partition.all(adapter, 'test_events')).should == log_msg
+    end
+  end
+
+end
+
+
+describe "PartitionCollection with ARAdapter" do
+  it_should_behave_like "PartitionCollection" do
+    let(:adapter) do
+      SqlPartitioner::ARAdapter.new(ActiveRecord::Base.connection)
+    end
+  end
+end
+
+describe "Partition with ARAdapter" do
+  it_should_behave_like "Partition" do
+    let(:adapter) do
+      SqlPartitioner::ARAdapter.new(ActiveRecord::Base.connection)
+    end
+  end
+end
+
+describe "PartitionCollection with DMAdapter" do
+  it_should_behave_like "PartitionCollection" do
+    let(:adapter) do
+      SqlPartitioner::DMAdapter.new(DataMapper.repository.adapter)
+    end
+  end
+end
+
+describe "Partition with DMAdapter" do
+  it_should_behave_like "Partition" do
+    let(:adapter) do
+      SqlPartitioner::DMAdapter.new(DataMapper.repository.adapter)
+    end
+  end
+end

data/spec/lib/sql_partitioner/partitions_manager_spec.rb

@@ -0,0 +1,275 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+shared_examples_for "PartitionsManager with an Adapter" do
+  describe "#initialize_partitioning_in_intervals" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::PartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+    end
+    it "should initialize the database table as requested" do
+      days_into_future = 50
+
+      @partition_manager.initialize_partitioning_in_intervals(days_into_future)
+
+      SqlPartitioner::Partition.all(adapter, 'test_events').map{|p| [p.name, p.timestamp]}.should == [
+        ["until_2014_05_18", Time.utc(2014,05,18).to_i],
+        ["until_2014_06_18", Time.utc(2014,06,18).to_i],
+        ["future", "MAXVALUE"]
+      ]
+    end
+  end
+  describe "#append_partition_intervals" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::PartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+    end
+    context "with an unpartitioned database table" do
+      it "should raise a RuntimeError" do
+        lambda{
+          @partition_manager.append_partition_intervals(:months, 1, days_into_future = 30, dry_run = false)
+        }.should raise_error(RuntimeError, /initialized/)
+      end
+    end
+    context "with a partitioned database table" do
+      context "and only the future partition exists" do
+        before(:each) do
+          @partition_manager.initialize_partitioning({})
+        end
+        it "should raise a RuntimeError" do
+          lambda{
+            @partition_manager.append_partition_intervals(:months, 1, days_into_future = 30, dry_run = false)
+          }.should raise_error(RuntimeError, /initialized/)
+        end
+      end
+      context "and the future partition as well as other partitions exist" do
+        context "and all requested partitions already exist" do
+          before(:each) do
+            @partition_manager.initialize_partitioning({'until_2014_05_18' => Time.utc(2014,05,18).to_i})
+          end
+          it "should log and do nothing" do
+            expect(@partition_manager.append_partition_intervals(:months, 1, days_into_future = 30, dry_run = false)).to eq({})
+          end
+        end
+        context "and not all of the requested partitions exist yet" do
+          before(:each) do
+            @partition_manager.initialize_partitioning({'until_2014_05_18' => Time.utc(2014,05,18).to_i})
+          end
+          it "should log and do nothing" do
+            expect(@partition_manager.append_partition_intervals(:months, 1, days_into_future = 60, dry_run = false)).to eq({
+              'until_2014_06_18' => Time.utc(2014,06,18).to_i
+            })
+          end
+        end
+      end
+    end
+  end
+  describe "#drop_partitions_older_than_in_days" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::PartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+    end
+    it "should drop the requested partition" do
+      @partition_manager.initialize_partitioning({
+        'until_2014_02_18' => Time.utc(2014,02,18).to_i,
+        'until_2014_03_18' => Time.utc(2014,03,18).to_i,
+        'until_2014_04_18' => Time.utc(2014,04,18).to_i
+      })
+      @partition_manager.drop_partitions_older_than_in_days(days_from_now = 40)
+
+      SqlPartitioner::Partition.all(adapter, 'test_events').map{|p| [p.name, p.timestamp]}.should == [
+        ["until_2014_03_18", Time.utc(2014,03,18).to_i],
+        ["until_2014_04_18", Time.utc(2014,04,18).to_i],
+        ["future", "MAXVALUE"]
+      ]
+    end
+  end
+
+  describe "#drop_partitions_older_than" do
+    before(:each) do
+      @partition_manager = SqlPartitioner::PartitionsManager.new(
+        :adapter      => adapter,
+        :current_time => Time.utc(2014,04,18),
+        :table_name   => 'test_events',
+        :logger       => SPEC_LOGGER
+      )
+    end
+    context "with no partition requested to be dropped" do
+      before(:each) do
+        @partition_manager.initialize_partitioning({
+          'until_2014_03_18' => Time.utc(2014,03,18).to_i,
+          'until_2014_04_18' => Time.utc(2014,04,18).to_i
+        })
+      end
+      it "should not drop anything" do
+        expect(@partition_manager.drop_partitions_older_than(Time.utc(2014,03,18).to_i)).to eq []
+      end
+    end
+    context "with one partition requested to be dropped" do
+      before(:each) do
+        @partition_manager.initialize_partitioning({
+          'until_2014_03_18' => Time.utc(2014,03,18).to_i,
+          'until_2014_04_18' => Time.utc(2014,04,18).to_i
+        })
+      end
+      it "should drop the requeuest partition to be dropped" do
+        expect(@partition_manager.drop_partitions_older_than(Time.utc(2014,04,18).to_i)).to eq [
+          'until_2014_03_18'
+        ]
+      end
+    end
+  end
+end
+
+describe "PartitionsManager with ARAdapter" do
+  it_should_behave_like "PartitionsManager with an Adapter" do
+    let(:adapter) do
+      SqlPartitioner::ARAdapter.new(ActiveRecord::Base.connection)
+    end
+  end
+end
+
+describe "PartitionsManager with DMAdapter" do
+  it_should_behave_like "PartitionsManager with an Adapter" do
+    let(:adapter) do
+      SqlPartitioner::DMAdapter.new(DataMapper.repository.adapter)
+    end
+  end
+end
+
+describe "PartitionsManager" do
+  before(:each) do
+    @adapter = Struct.new(:schema_name).new("sql_partitioner_test")
+
+    @partition_manager = SqlPartitioner::PartitionsManager.new(
+      :adapter      => @adapter,
+      :current_time => Time.utc(2014,01,01),
+      :table_name   => 'test_events',
+      :logger       => SPEC_LOGGER
+    )
+  end
+
+  describe "#partitions_to_append" do
+    it "should return the partitions to create" do
+      partition_start_timestamp = Time.utc(2013,12,01).to_i
+      partition_size   = 2
+      days_into_future = 32
+
+      expect(@partition_manager.partitions_to_append(partition_start_timestamp, :months, partition_size, days_into_future)).to eq({
+        "until_2014_02_01"=>Time.utc(2014,02,01).to_i,
+        "until_2014_04_01"=>Time.utc(2014,04,01).to_i
+      })
+    end
+  end
+
+  describe "#partitions_to_append_by_ts_range" do
+    context "with end_timestamp == partition_start_timestamp" do
+      before(:each) do
+        @start_ts = Time.utc(2014,01,01).to_i
+        @end_ts   = Time.utc(2014,01,01).to_i
+      end
+      it "should create no partitions" do
+        expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :months, 1)).to eq({})
+      end
+    end
+    context "with end_timestamp - partition_start_timestamp < partition_size_unit * partition_size" do
+      before(:each) do
+        @start_ts = Time.utc(2014,01,01).to_i
+        @end_ts   = Time.utc(2014,01,02).to_i
+      end
+      it "should create 1 partition" do
+        expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :months, 1)).to eq({
+            "until_2014_02_01"=>Time.utc(2014,02,01).to_i
+          }
+        )
+      end
+    end
+    context "with end_timestamp - partition_start_timestamp == partition_size_unit * partition_size" do
+      before(:each) do
+        @start_ts = Time.utc(2014,01,01).to_i
+        @end_ts   = Time.utc(2014,02,01).to_i
+      end
+      it "should create 1 partition to cover it" do
+        expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :months, 1)).to eq({
+            "until_2014_02_01"=>Time.utc(2014,02,01).to_i
+          }
+        )
+      end
+    end
+    context "with end_timestamp - partition_start_timestamp > partition_size_unit * partition_size" do
+      before(:each) do
+        @start_ts = Time.utc(2014,01,01).to_i
+        @end_ts   = Time.utc(2014,03,01).to_i
+      end
+      context "with one months partition size" do
+        it "should create two partitions to cover two months in the future from start_ts" do
+          expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :months, 1)).to eq({
+              "until_2014_02_01"=>Time.utc(2014,02,01).to_i,
+              "until_2014_03_01"=>Time.utc(2014,03,01).to_i
+            }
+          )
+        end
+      end
+      context "with two months partition size" do
+        it "should create one partition to cover two months in the future from start_ts" do
+          expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :months, 2)).to eq({
+              "until_2014_03_01"=>Time.utc(2014,03,01).to_i
+            }
+          )
+        end
+      end
+      context "with 20 day partition size" do
+        it "should create three partitions to cover two months in the future from start_ts" do
+          expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :days, 20)).to eq({
+              "until_2014_01_21" => Time.utc(2014,01,21).to_i,
+              "until_2014_02_10" => Time.utc(2014,02,10).to_i,
+              "until_2014_03_02" => Time.utc(2014,03,02).to_i
+            }
+          )
+        end
+      end
+    end
+    context "with end_timestamp < partition_start_timestamp" do
+      before(:each) do
+        @start_ts = Time.utc(2014,02,01).to_i
+        @end_ts   = Time.utc(2014,01,01).to_i
+      end
+      it "should create no partitions" do
+        expect(@partition_manager.partitions_to_append_by_ts_range(@start_ts, @end_ts, :months, 1)).to eq({})
+      end
+    end
+    context "with invalid parameters" do
+      it "should raise an Argument error with a start_ts < 0" do
+        lambda do
+          expect(@partition_manager.partitions_to_append_by_ts_range(start_ts = -1, end_ts = 1, :months, 1)).to eq({})
+        end.should raise_error(ArgumentError, /should be > 0/)
+      end
+      it "should raise an Argument error with a end_ts < 0" do
+        lambda do
+          expect(@partition_manager.partitions_to_append_by_ts_range(start_ts = 1, end_ts = -1, :months, 1)).to eq({})
+        end.should raise_error(ArgumentError, /should be > 0/)
+      end
+      it "should raise an Argument error with an invalid partition_size_unit" do
+        lambda do
+          expect(@partition_manager.partitions_to_append_by_ts_range(start_ts = 1, end_ts = 1, :potatoes, 1)).to eq({})
+        end.should raise_error(ArgumentError, /partition_size_unit must be one of/)
+      end
+      it "should raise an Argument error with an invalid partition_size" do
+        lambda do
+          expect(@partition_manager.partitions_to_append_by_ts_range(start_ts = 1, end_ts = 1, :months, -1)).to eq({})
+        end.should raise_error(ArgumentError, /should be > 0/)
+      end
+    end
+  end
+end

data/spec/lib/sql_partitioner/sql_helper_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe "SqlHelper" do
+  before(:each) do
+    @table_name = 'my_table'
+  end
+  describe ".drop_partitions" do
+    it "should return nil when no partition_names are passed" do
+      SqlPartitioner::SQL.drop_partitions(@table_name, []).should == nil
+    end
+  end
+
+  describe ".reorg_partitions" do
+    it "should return nil when no partition_names are passed" do
+      SqlPartitioner::SQL.reorg_partitions(@table_name, [], "future").should == nil
+    end
+  end
+
+  describe ".create_partition" do
+    it "should return something" do
+      SqlPartitioner::SQL.create_partition(@table_name, "until_2014_03_17", "future").should_not be_empty
+    end
+  end
+
+  describe ".sort_partition_data" do
+    before(:each) do
+      @partition_data = {
+        'until_2014_04_17' => 1397692800,
+        SqlPartitioner::BasePartitionsManager::FUTURE_PARTITION_NAME =>
+            SqlPartitioner::BasePartitionsManager::FUTURE_PARTITION_VALUE,
+        'until_2014_03_17' => 1395014400,
+      }
+    end
+    it "should sort into an array by timestamp (key) with the 'future' partition at the end" do
+      SqlPartitioner::SQL.sort_partition_data(@partition_data).should == [
+        ['until_2014_03_17', 1395014400],
+        ['until_2014_04_17', 1397692800],
+        [SqlPartitioner::BasePartitionsManager::FUTURE_PARTITION_NAME,
+            SqlPartitioner::BasePartitionsManager::FUTURE_PARTITION_VALUE],
+      ]
+    end
+  end
+end

data/spec/lib/sql_partitioner/time_unit_converter_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe "TimeUnitConverter" do
+  describe "#initialize" do
+    it "should initalize a new TimeUnitConverter with a supported time unit" do
+      SqlPartitioner::TimeUnitConverter.new(SqlPartitioner::TimeUnitConverter::SUPPORTED_TIME_UNITS.first)
+    end
+    it "should raise an ArgumentError with with a unsupported time unit" do
+      lambda{ SqlPartitioner::TimeUnitConverter.new(:potatoes) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#to_date_time" do
+    before(:each) do
+      @tuc = SqlPartitioner::TimeUnitConverter.new(:seconds)
+    end
+    it "should return a DateTime object" do
+      timestamp = Time.utc(2014,01,15).to_i
+      @tuc.to_date_time(timestamp).to_s.should == "2014-01-15T00:00:00+00:00"
+    end
+  end
+  describe "#from_seconds" do
+    it "should return a timestamp in the configured time unit" do
+      timestamp_in_secs = Time.utc(2014,01,15).to_i
+
+      tum = SqlPartitioner::TimeUnitConverter.new(:micro_seconds)
+      tum.from_seconds(timestamp_in_secs).should == timestamp_in_secs * 1_000_000
+
+      tum = SqlPartitioner::TimeUnitConverter.new(:seconds)
+      tum.from_seconds(timestamp_in_secs).should == timestamp_in_secs
+    end
+  end
+
+  describe "#to_seconds" do
+    it "should return a timestamp in the configured time unit" do
+      timestamp_in_secs = Time.utc(2014,01,15).to_i
+
+      tum = SqlPartitioner::TimeUnitConverter.new(:micro_seconds)
+      tum.to_seconds(timestamp_in_secs * 1_000_000).should == timestamp_in_secs
+
+      tum = SqlPartitioner::TimeUnitConverter.new(:seconds)
+      tum.to_seconds(timestamp_in_secs).should == timestamp_in_secs
+    end
+  end
+
+  describe "#advance_date_time" do
+    before(:each) do
+      @date_time = DateTime.new(2014,01,31)
+    end
+    context "using days" do
+      before(:each) do
+        @calendar_unit = :days
+      end
+      it "should return the correct DateTime when adding" do
+        SqlPartitioner::TimeUnitConverter.advance_date_time(@date_time, @calendar_unit, days = 2).to_s.should == "2014-02-02T00:00:00+00:00"
+      end
+      it "should return the correct DateTime when subtracting" do
+        SqlPartitioner::TimeUnitConverter.advance_date_time(@date_time, @calendar_unit, days = -2).to_s.should == "2014-01-29T00:00:00+00:00"
+      end
+    end
+    context "using months" do
+      before(:each) do
+        @calendar_unit = :months
+      end
+      it "should return the correct DateTime when adding" do
+        SqlPartitioner::TimeUnitConverter.advance_date_time(@date_time, @calendar_unit, months = 2).to_s.should == "2014-03-31T00:00:00+00:00"
+      end
+      it "should return the correct DateTime when subtracting" do
+        SqlPartitioner::TimeUnitConverter.advance_date_time(@date_time, @calendar_unit, months = -2).to_s.should == "2013-11-30T00:00:00+00:00"
+      end
+    end
+  end
+
+  describe ".time_units_per_second" do
+    it "should return the proper seconds multiplier to get the specified time unit" do
+      SqlPartitioner::TimeUnitConverter.time_units_per_second(:micro_seconds).should == 1_000_000
+      SqlPartitioner::TimeUnitConverter.time_units_per_second(:seconds).should == 1
+    end
+    it "all SUPPORTED_TIME_UNITS accounted for" do
+      SqlPartitioner::TimeUnitConverter::SUPPORTED_TIME_UNITS.each do |u|
+        SqlPartitioner::TimeUnitConverter.time_units_per_second(u).should be_a(Fixnum)
+      end
+    end
+    it "unknown time unit should raise an error" do
+      lambda {
+        SqlPartitioner::TimeUnitConverter.time_units_per_second(:bogus)
+      }.should raise_error(RuntimeError, /unknown time_unit :bogus/)
+    end
+  end
+  
+end