neuron-client 0.2.6 → 0.3.0

data/spec/lib/model/common/ad_calculations_spec.rb

@@ -1,1151 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-
-        class FakeAd
-          include AdCalculations
-          attr_accessor :start_datetime, :end_datetime, :time_zone, :day_partitions,
-            :daily_cap, :overall_cap, :ideal_impressions_per_hour, :total_impressed,
-            :today_impressed
-          def initialize(opts={})
-            opts.each { |sym, value| self.send("#{sym}=", value) }
-            self.time_zone ||= "Beijing"
-            self.total_impressed ||= 0
-            self.today_impressed ||= 0
-          end
-        end
-
-        describe AdCalculations do
-          context "given an Ad with date range Sat, 01 Jan 2011, 00:00 -> Tue, 01 Feb 2011, 12:00; Beijing time; Day parted for 9:00 - 17:00, M-F; Daily cap of 10; Overall cap of 100; total_impressed of 50; today_impressed of 5" do
-            before(:each) do
-              @time_zone = "Beijing"
-              Time.zone = @time_zone
-              Chronic.time_class = Time.zone
-              @ad = FakeAd.new(
-                :start_datetime => Chronic.parse("2011-01-01 00:00"),
-                :end_datetime => Chronic.parse("2011-02-01 12:00"),
-                :time_zone => "Beijing",
-                :day_partitions => "F"*24 + ("F"*9 + "T"*8 + "F"*7)*5 + "F"*24,
-                :daily_cap => 10,
-                :overall_cap => 100,
-                :ideal_impressions_per_hour => nil,
-                :total_impressed => 50,
-                :today_impressed => 5
-              )
-            end
-            it "should be inactive on December 10th, 2010" do
-              Timecop.freeze(Chronic.parse("2010-12-10")) do
-                @ad.active?.should be_false
-              end
-            end
-            it "should be inactive on January 1st, 2011" do
-              Timecop.freeze(Chronic.parse("2011-01-01 10:00")) do
-                @ad.active?.should be_false
-              end
-            end
-            it "should be inactive on January 3rd, 2011 at 5:00 AM" do
-              Timecop.freeze(Chronic.parse("2011-01-03 05:00")) do
-                @ad.active?.should be_false
-              end
-            end
-            context "on January 3rd, 2011 at 10:00 AM" do
-              before(:each) { Timecop.freeze(Chronic.parse("2011-01-03 10:00")) }
-              after(:each) { Timecop.return }
-              it "should be active" do
-                @ad.active?.should be_true
-              end
-              it "should have a pressure of 10/7" do
-                @ad.pressure.should == 10 / 7.0
-              end
-            end
-            context "on January 3rd, 2011 at 16:00" do
-              before(:each) { Timecop.freeze(Chronic.parse("2011-1-3 16:00")) }
-              after(:each) { Timecop.return }
-              it "should be active" do
-                @ad.active?.should be_true
-              end
-              it "should have a pressure of 10/1" do
-                @ad.pressure.should == 10
-              end
-            end
-            context "on January 27th, 2011 at 16:00" do
-              before(:each) { Timecop.freeze(Chronic.parse("2011-1-27 16:00")) }
-              after(:each) { Timecop.return }
-              it "should be active" do
-                @ad.active?.should be_true
-              end
-              it "should have a pressure of 50/20" do
-                @ad.pressure.should == 50 / 20.0
-              end
-            end
-            it "should be inactive on February 1st, 2011 at 13:00" do
-              Timecop.freeze(Chronic.parse("2011-2-1 13:00")) do
-                @ad.active?.should be_false
-              end
-            end
-          end
-
-          describe ".active?" do
-            it "should call calculate_active?" do
-              @ad = FakeAd.new
-              @ad.should_receive(:calculate_active?).and_return(:result)
-
-              @ad.active?.should == :result
-            end
-          end
-
-          describe ".pressure" do
-            it "should call calculate_pressure" do
-              @ad = FakeAd.new
-              @ad.should_receive(:calculate_pressure).and_return(:result)
-
-              @ad.pressure.should == :result
-            end
-          end
-
-          describe ".calculate_active?(time, total_impressed, today_impressed)" do
-            it "should have specs"
-          end
-
-          describe ".calculate_pressure(time, total_impressed, today_impressed, active=nil)" do
-            it "should have some specs related to when 'active' is passed in"
-            context "when daily_cap is present" do
-              context "and daily_cap precludes overall_cap from being met" do
-                it "should calculate the overall pressure" do
-                  ad = FakeAd.new(:daily_cap => 10)
-                  ad.stub(:daily_cap_precludes_overall_cap?).and_return(true)
-                  ad.should_receive(:calculate_overall_pressure)
-                  ad.should_not_receive(:calculate_today_pressure)
-
-                  ad.calculate_pressure(Time.now, 50, 5)
-                end
-              end
-              context "and daily_cap does not preclude the overall_cap from being met" do
-                it "should calculate the pressure for just today" do
-                  ad = FakeAd.new(:daily_cap => 10)
-                  ad.stub(:daily_cap_precludes_overall_cap?).and_return(false)
-                  ad.should_not_receive(:calculate_overall_pressure)
-                  ad.should_receive(:calculate_today_pressure)
-
-                  ad.calculate_pressure(Time.now, 50, 5)
-                end
-              end
-            end
-            context "when daily_cap is not present" do
-              context "when overall_cap is blank or end_datetime is blank" do
-                it "should use the ideal_impressions_per_hour" do
-                  ad = FakeAd.new(:overall_cap => 100, :ideal_impressions_per_hour => 99.9)
-                  ad.should_not_receive(:calculate_overall_pressure)
-                  ad.should_not_receive(:calculate_today_pressure)
-
-                  ad.calculate_pressure(Time.now, 50, 5).should == 99.9
-                end
-              end
-              context "when overall_cap is not blank and end_datetime is not blank" do
-                it "should calculate the overall pressure" do
-                  ad = FakeAd.new(:overall_cap => 100, :end_datetime => Time.now + 1.month)
-                  ad.should_receive(:calculate_overall_pressure)
-                  ad.should_not_receive(:calculate_today_pressure)
-
-                  ad.calculate_pressure(Time.now, 50, 5)
-                end
-              end
-            end
-          end
-
-
-          describe ".start_in_time_zone" do
-            it "should return start_datetime, time zone adjusted" do
-              result = FakeAd.new(
-                :start_datetime => Time.utc(2011, 2, 1, 1, 59),
-                :time_zone => 'Eastern Time (US & Canada)'
-              ).send(:start_in_time_zone)
-              formatted_result = "#{result.time.strftime('%a, %d %b %Y %H:%M:%S')} #{result.zone} #{result.formatted_offset}"
-
-              formatted_result.should == "Mon, 31 Jan 2011 20:59:00 EST -05:00"
-            end
-          end
-
-          describe ".end_in_time_zone" do
-            context "when end_datetime is present" do
-              it "should return end_datetime, time zone adjusted" do
-                result = FakeAd.new(
-                  :end_datetime => Time.utc(2011, 2, 1, 1, 59),
-                  :time_zone => 'Eastern Time (US & Canada)'
-                ).send(:end_in_time_zone)
-                formatted_result = "#{result.time.strftime('%a, %d %b %Y %H:%M:%S')} #{result.zone} #{result.formatted_offset}"
-
-                formatted_result.should == "Mon, 31 Jan 2011 20:59:00 EST -05:00"
-              end
-            end
-            context "when end_datetime is not present" do
-              it "should return nil" do
-                FakeAd.new(:end_datetime => nil).send(:end_in_time_zone).should be_nil
-              end
-            end
-          end
-
-          describe ".daily_capped?" do
-            it "should be false when daily_cap is nil" do
-              FakeAd.new(:daily_cap => nil).send(:daily_capped?).should be_false
-            end
-            it "should be true when daily_cap is a positive integer > zero" do
-              FakeAd.new(:daily_cap => 42).send(:daily_capped?).should be_true
-            end
-          end
-
-          describe ".overall_capped?" do
-            it "should be false when overall_cap is nil" do
-              FakeAd.new(:overall_cap => nil).send(:overall_capped?).should be_false
-            end
-            it "should be true when overall_cap is a positive integer > zero" do
-              FakeAd.new(:overall_cap => 42).send(:overall_capped?).should be_true
-            end
-          end
-
-          describe ".partitioned?" do
-            it "should be false when day_partitions is nil" do
-              FakeAd.new(:day_partitions => nil).send(:partitioned?).should be_false
-            end
-            it "should be true when day_partitions is 168 character string of Ts and Fs." do
-              p = ("T"*100 + "F"*68).split('').shuffle.join
-              FakeAd.new(:day_partitions => p).send(:partitioned?).should be_true
-            end
-          end
-
-          def within_date_range
-            FakeAd.new(:start_datetime => @start, :end_datetime => @end).send(:within_date_range?, @now)
-          end
-
-          describe ".within_date_range?(date)" do
-            before(:all) do
-              @now = Time.now
-            end
-            context "when ad has no start date" do
-              context "when ad has no end date" do
-                it "should return true" do
-                  @start = nil
-                  @end = nil
-                  within_date_range.should be_true
-                end
-              end
-              context "when before ad's end date" do
-                it "should return true" do
-                  @start = nil
-                  @end = @now + 1.day
-                  within_date_range.should be_true
-                end
-              end
-              context "when on or beyond ad's end date" do
-                it "should return false" do
-                  @start = nil
-                  @end = @now
-                  within_date_range.should be_false
-                  @end = @now - 1.day
-                  within_date_range.should be_false
-                end
-              end
-            end
-            context "when before ad's start date" do
-              context "when ad has no end date" do
-                it "should return false" do
-                  @start = @now + 1.day
-                  @end = nil
-                  within_date_range.should be_false
-                end
-              end
-              context "when before ad's end date" do
-                it "should return false" do
-                  @start = @now + 1.day
-                  @end = @start + 1.day
-                  within_date_range.should be_false
-                end
-              end
-            end
-            context "when on or beyond ad's start date" do
-              context "when ad has no end date" do
-                it "should return true" do
-                  @start = @now
-                  @end = nil
-                  within_date_range.should be_true
-                  @start = @now - 1.day
-                  within_date_range.should be_true
-                end
-              end
-              context "when before ad's end date" do
-                it "should return true" do
-                  @start = @now
-                  @end = @now + 1.day
-                  within_date_range.should be_true
-                  @start = @now - 1.day
-                  within_date_range.should be_true
-                end
-              end
-              context "when on or beyond ad's end date" do
-                it "should return false" do
-                  @start = @now
-                  @end = @now
-                  within_date_range.should be_false
-                  @start = @now - 2.days
-                  @end = @now
-                  within_date_range.should be_false
-                  @end = @now - 1.day
-                  within_date_range.should be_false
-                end
-              end
-            end
-          end
-
-          describe ".partitioned_hour?(time)" do
-            context "when day partitions exist" do
-              before(:all) do
-                @ad = FakeAd.new(:day_partitions => [
-                  "TTTTTTTTTTFTTTTTTTTTTTTT", # Sunday
-                  "TTTTTTTTTTTTTTTFTTTTTTTT", # Monday
-                  "FTTTTTTTTTTTTTTTTTTTTTTT", # Tuesday
-                  "TTTTTFTTTTTTTTTTTTTTTTTT", # Wednesday
-                  "TTTTTTTTTTTTTTTTTTTTFTTT", # Thursday
-                  "TTTTTTTTTTTTTTTTTTTTTTTF", # Friday
-                  "TTTTTTTTTTTTFTTTTTTTTTTT"  # Saturday
-                ].join)
-              end
-              context "when on Sunday" do
-                context "when on day partition" do
-                  it "should return true" do
-                    time = Chronic.parse('Sunday @ 9 am')
-                    @ad.send(:partitioned_hour?, time).should be_true
-                  end
-                end
-                context "when not on day partition" do
-                  it "should return false" do
-                    time = Chronic.parse('Sunday @ 10 am')
-                    @ad.send(:partitioned_hour?, time).should be_false
-                  end
-                end
-              end
-              context "when on Monday" do
-                context "when on day partition" do
-                  it "should return true" do
-                    time = Chronic.parse('Monday @ 2 pm')
-                    @ad.send(:partitioned_hour?, time).should be_true
-                  end
-                end
-                context "when not on day partition" do
-                  it "should return false" do
-                    time = Chronic.parse('Monday @ 3 pm')
-                    @ad.send(:partitioned_hour?, time).should be_false
-                  end
-                end
-              end
-              context "when on Friday" do
-                context "when on day partition" do
-                  it "should return true" do
-                    time = Chronic.parse('Friday @ 10 pm')
-                    @ad.send(:partitioned_hour?, time).should be_true
-                  end
-                end
-                context "when not on day partition" do
-                  it "should return false" do
-                    time = Chronic.parse('Friday @ 11 pm')
-                    @ad.send(:partitioned_hour?, time).should be_false
-                  end
-                end
-              end
-              context "when on Saturday" do
-                context "when on day partition" do
-                  it "should return true" do
-                    time = Chronic.parse('Saturday @ 1 pm')
-                    @ad.send(:partitioned_hour?, time).should be_true
-                  end
-                end
-                context "when not on day partition" do
-                  it "should return false" do
-                    time = Chronic.parse('Saturday @ 12 pm')
-                    @ad.send(:partitioned_hour?, time).should be_false
-                  end
-                end
-              end
-            end
-          end
-
-          def partitioned_day?(time)
-            nine_to_five = "F"*9 + "T"*8 + "F"*7
-            no_hours = "F" * 24
-            ad = FakeAd.new(:day_partitions => [nine_to_five, nine_to_five, no_hours, nine_to_five, nine_to_five, nine_to_five, no_hours].join)
-            ad.send(:partitioned_day?, time)
-          end
-          describe ".partitioned_day?(time)" do
-            context "when ad is partitioned from 9-5, every day of the week except Tuesday and Saturday" do
-              it "should return true on Sunday @ 5 am" do
-                partitioned_day?( Chronic.parse('Sunday @ 5 am') ).should be_true
-              end
-              it "should return true on Sunday @ 10 am" do
-                partitioned_day?( Chronic.parse('Sunday @ 10 am') ).should be_true
-              end
-              it "should return true on Sunday @ 10 pm" do
-                partitioned_day?( Chronic.parse('Sunday @ 10 pm') ).should be_true
-              end
-              it "should return true on Monday @ 5 am" do
-                partitioned_day?( Chronic.parse('Monday @ 5 am') ).should be_true
-              end
-              it "should return false on Tuesday @ 5 am" do
-                partitioned_day?( Chronic.parse('Tuesday @ 5 am') ).should be_false
-              end
-              it "should return false on Tuesday @ 10 am" do
-                partitioned_day?( Chronic.parse('Tuesday @ 10 am') ).should be_false
-              end
-              it "should return true on Wednesday @ 5 am" do
-                partitioned_day?( Chronic.parse('Wednesday @ 5 am') ).should be_true
-              end
-              it "should return true on Thursday @ 5 am" do
-                partitioned_day?( Chronic.parse('Thursday @ 5 am') ).should be_true
-              end
-              it "should return true on Friday @ 5 am" do
-                partitioned_day?( Chronic.parse('Friday @ 5 am') ).should be_true
-              end
-              it "should return false on Saturday @ 5 am" do
-                partitioned_day?( Chronic.parse('Saturday @ 5 am') ).should be_false
-              end
-            end
-          end
-
-          describe ".cap_met?(total_impressed, today_impressed)" do
-            context "when not daily capped" do
-              context "and not overall capped" do
-                it "should return false" do
-                  FakeAd.new(:daily_cap => nil, :overall_cap => nil).send(:cap_met?, 10, 10).should be_false
-                end
-              end
-              context "and overall cap is 10" do
-                before(:each) do
-                  @ad = FakeAd.new(:daily_cap => nil, :overall_cap => 10)
-                end
-                context "and total_impressed = 9" do
-                  it "should return false" do
-                    @ad.send(:cap_met?, 9, 0).should be_false
-                  end
-                end
-                context "and total_impressed = 10" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 10, 0).should be_true
-                  end
-                end
-                context "and total_impressed = 11" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 11, 0).should be_true
-                  end
-                end
-              end
-            end
-            context "when daily cap is 10" do
-              context "and not overall capped" do
-                before(:each) do
-                  @ad = FakeAd.new(:daily_cap => 10, :overall_cap => nil)
-                end
-                context "and today_impressed = 9" do
-                  it "should return false" do
-                    @ad.send(:cap_met?, 0, 9).should be_false
-                  end
-                end
-                context "and today_impressed = 10" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 0, 10).should be_true
-                  end
-                end
-                context "and today_impressed = 11" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 0, 11).should be_true
-                  end
-                end
-              end
-              context "and overall cap is 100" do
-                before(:each) do
-                  @ad = FakeAd.new(:daily_cap => 10, :overall_cap => 100)
-                end
-                context "and total < 100, today < 10" do
-                  it "should return false" do
-                    @ad.send(:cap_met?, 99, 9).should be_false
-                  end
-                end
-                context "and total < 100, today = 10" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 99, 10).should be_true
-                  end
-                end
-                context "and total = 100, today < 10" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 100, 9).should be_true
-                  end
-                end
-                context "and total = 100, today = 10" do
-                  it "should return true" do
-                    @ad.send(:cap_met?, 100, 10).should be_true
-                  end
-                end
-              end
-            end
-          end
-
-          def precluded
-            @time = Time.now
-            @total = 500
-            @today = 100
-            ad = FakeAd.new(:daily_cap => @daily_cap, :overall_cap => @overall_cap, :end_datetime => @end_datetime)
-            ad.stub(:remaining_impressions_via_daily_cap).with(@time, @today).and_return(@remaining_via_daily_cap)
-            ad.stub(:remaining_impressions_via_overall_cap).with(@total).and_return(@remaining_via_overall_cap)
-            ad.send(:daily_cap_precludes_overall_cap?, @time, @total, @today)
-          end
-          describe ".daily_cap_precludes_overall_cap?(time, total_impressed, today_impressed)" do
-            context "when ad has no daily cap" do
-              it "should return false" do
-                @daily_cap = nil
-                @overall_cap = 1
-                precluded.should be_false
-              end
-            end
-            context "when ad has no overall cap" do
-              it "should return false" do
-                @daily_cap = 1
-                @overall_cap = nil
-                precluded.should be_false
-              end
-            end
-            context "when ad has no end date/time" do
-              it "should return false" do
-                @daily_cap = 1
-                @overall_cap = 1
-                @end_datetime = nil
-                precluded.should be_false
-              end
-            end
-            context "when ad's daily cap is 10, overall cap is 100, and end datetime is present" do
-              before(:each) { @daily_cap = 10; @overall_cap = 100; @end_datetime = Time.now + 10.days }
-              context "when remaining_impressions_via_daily_cap < remaining_impressions_via_overall_cap" do
-                it "returns true" do
-                  @remaining_via_daily_cap = 1
-                  @remaining_via_overall_cap = 2
-                  precluded.should be_true
-                end
-              end
-              context "when remaining_impressions_via_daily_cap = remaining_impressions_via_overall_cap" do
-                it "returns false" do
-                  @remaining_via_daily_cap = 1
-                  @remaining_via_overall_cap = 1
-                  precluded.should be_false
-                end
-              end
-              context "when remaining_impressions_via_daily_cap > remaining_impressions_via_overall_cap" do
-                it "returns false" do
-                  @remaining_via_daily_cap = 2
-                  @remaining_via_overall_cap = 1
-                  precluded.should be_false
-                end
-              end
-            end
-          end
-
-          describe ".remaining_impressions_via_overall_cap(total_impressed)" do
-            context "when overall_cap = 100" do
-              before(:each) { @ad = FakeAd.new(:overall_cap => 100) }
-              context "when total_impressed = 0" do
-                it "returns 100" do
-                  @ad.send(:remaining_impressions_via_overall_cap, 0).should == 100
-                end
-              end
-              context "when total_impressed = 99" do
-                it "returns 1" do
-                  @ad.send(:remaining_impressions_via_overall_cap, 99).should == 1
-                end
-              end
-              context "when total_impressed = 100" do
-                it "returns 0" do
-                  @ad.send(:remaining_impressions_via_overall_cap, 100).should == 0
-                end
-              end
-              context "when total_impressed = 101" do
-                it "returns 0" do
-                  @ad.send(:remaining_impressions_via_overall_cap, 101).should == 0
-                end
-              end
-            end
-          end
-
-          describe ".remaining_impressions_today(today_impressed)" do
-            context "when daily_cap = 100" do
-              before(:each) { @ad = FakeAd.new(:daily_cap => 100) }
-              context "when today_impressed = 0" do
-                it "returns 100" do
-                  @ad.send(:remaining_impressions_today, 0).should == 100
-                end
-              end
-              context "when today_impressed = 99" do
-                it "returns 1" do
-                  @ad.send(:remaining_impressions_today, 99).should == 1
-                end
-              end
-              context "when today_impressed = 100" do
-                it "returns 0" do
-                  @ad.send(:remaining_impressions_today, 100).should == 0
-                end
-              end
-              context "when today_impressed = 101" do
-                it "returns 0" do
-                  @ad.send(:remaining_impressions_today, 101).should == 0
-                end
-              end
-            end
-          end
-
-          describe ".remaining_impressions_via_daily_cap(time, today_impressed)" do
-            context "when daily_cap is 100, ad has 5 days remaining (including today), and 30 remaining impressions today" do
-              it "returns 430" do
-                ad = FakeAd.new(:daily_cap => 100)
-                ad.stub(:remaining_days).with(:time).and_return(5)
-                ad.stub(:remaining_impressions_today).with(:today_impressed).and_return(30)
-
-                ad.send(:remaining_impressions_via_daily_cap, :time, :today_impressed).should == 430
-              end
-            end
-          end
-
-          describe ".calculate_today_pressure(time, today_impressed)" do
-            context "when there are 3 hours and 12 impressions remaining today" do
-              it "should return a pressure of 8 (impressions/hr)" do
-                ad = FakeAd.new
-                ad.stub(:remaining_hours_today).with(:time).and_return(3)
-                ad.stub(:remaining_impressions_today).with(:today_impressed).and_return(12)
-
-                ad.send(:calculate_today_pressure, :time, :today_impressed).should == 8
-              end
-            end
-            context "when there are 0 hours and 12 impressions remaining today" do
-              it "should return a pressure of 0 (impressions/hr)" do
-                ad = FakeAd.new
-                ad.stub(:remaining_hours_today).with(:time).and_return(0)
-                ad.stub(:remaining_impressions_today).with(:today_impressed).and_return(12)
-
-                ad.send(:calculate_today_pressure, :time, :today_impressed).should == 0
-              end
-            end
-          end
-
-          describe ".calculate_overall_pressure(time, total_impressed)" do
-            context "when there are 3 hours and 12 impressions remaining overall" do
-              it "should return a pressure of 4 (impressions/hr)" do
-                ad = FakeAd.new
-                ad.stub(:remaining_hours).with(:time).and_return(3)
-                ad.stub(:remaining_impressions_via_overall_cap).with(:total_impressed).and_return(12)
-
-                ad.send(:calculate_overall_pressure, :time, :total_impressed).should == 4
-              end
-            end
-            context "when there are 0 hours and 12 impressions remaining overall" do
-              it "should return a pressure of 0 (impressions/hr)" do
-                ad = FakeAd.new
-                ad.stub(:remaining_hours).with(:time).and_return(0)
-                ad.stub(:remaining_impressions_via_overall_cap).with(:total_impressed).and_return(12)
-
-                ad.send(:calculate_overall_pressure, :time, :total_impressed).should == 0
-              end
-            end
-          end
-
-          def remaining_days(time)
-            FakeAd.new(
-              :start_datetime => @start,
-              :end_datetime => @end,
-              :day_partitions => @day_partitions).send(:remaining_days, time.in_time_zone("Beijing"))
-          end
-          describe ".remaining_days(time)" do
-            context "when time is on or after ad's end_datetime" do
-              it "should return zero" do
-                @start = nil
-                @end = Time.at(1234567890)
-                remaining_days(@end).should == 0
-                remaining_days(@end + 1.day).should == 0
-              end
-            end
-            context "when time is before ad's end_datetime" do
-              context "and ad is not day-partitioned" do
-                before(:each) { @day_partitions = nil }
-                context "and time is before ad's start_datetime" do
-                  it "returns the number of days between the ad's start and end, including partial days on either end" do
-                    @start = Time.parse("2011-11-11 11:11 +08:00")
-                    @end = @start + 2.days
-                    remaining_days(@start - 1.week).should == 3
-                  end
-                end
-                context "and time is after the ad's start_datetime" do
-                  it "should return the number of days between the given time and the ad's end" do
-                    @start = Time.parse("2011-11-11 11:11 +08:00")
-                    @time = @start + 1.day
-                    @end = @time + 1.day
-                    remaining_days(@time).should == 2
-                  end
-                  context "and the ad's end occurs at midnight" do
-                    it "should return the number of days between the given time and the ad's end, not counting the morning of the final date" do
-                      @start = Time.parse("2011-11-11 11:11 +08:00")
-                      @time = @start + 1.day
-                      @end = @time.end_of_day + 1.day
-                      remaining_days(@time).should == 2
-                    end
-                  end
-                  context "and the time is on the same day as the ad's end" do
-                    it "should return one" do
-                      @start = Time.parse("2011-11-11 11:11 +08:00")
-                      @time = @start + 1.day
-                      @end = @time + 1.hour
-                      remaining_days(@time).should == 1
-                    end
-                  end
-                  context "and the ad's end is at midnight the night after the given time" do
-                    it "should return one" do
-                      @start = Time.parse("2011-11-11 11:11 +08:00")
-                      @time = @start + 1.day
-                      @end = @time.end_of_day
-                      remaining_days(@time).should == 1
-                    end
-                  end
-                end
-              end
-              context "when ad is partitioned with the first 12 hours of each weekday active, and the last 12 and the whole weekend inactive" do
-                before(:all) do
-                  @time_zone = "Beijing"
-                  Time.zone = @time_zone
-                  Chronic.time_class = Time.zone
-                  @day_partitions = "F"*24 + ("T"*12 + "F"*12) * 5 + "F"*24
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 9:30am to Friday @ 6pm" do
-                  it "should return 5 days" do
-                    @start = Chronic.parse("Monday @ 9:30am")
-                    @end = Chronic.parse("Monday @ 6pm") + 4.days #Friday
-                    remaining_days(Chronic.parse("1 month ago")).should == 5
-                  end
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 6pm to Friday @ 9:30am" do
-                  it "should return 4 days" do
-                    @start = Chronic.parse("Monday @ 6pm")
-                    @end = Chronic.parse("Monday @ 9:30am") + 4.days #Friday
-                    remaining_days(Chronic.parse("1 month ago")).should == 4
-                  end
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 6pm to Friday morning @ 12am" do
-                  it "should return 4 days" do
-                    @start = Chronic.parse("Monday @ 6pm")
-                    @end = Chronic.parse("Monday @ 12am") + 4.days #Friday
-                    remaining_days(Chronic.parse("1 month ago")).should == 3
-                  end
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 6pm to Three Mondays later @ 6am" do
-                  it "should return 15 hours" do
-                    @start = Chronic.parse("Monday @ 6pm")
-                    @end = Chronic.parse("Monday @ 6am") + 3.weeks
-                    remaining_days(Chronic.parse("1 month ago")).should == 15
-                  end
-                end
-                context "when the date range is really long" do
-                  it "should not take a long time to compute" do
-                    @start = Chronic.parse "2010-01-01 1am"
-                    @end = Chronic.parse "2020-01-07 5am"
-                    started = Time.now.to_f
-                    remaining_days(Chronic.parse("2009-12-31 11pm")).should == 2613
-                    finished = Time.now.to_f
-                    (finished - started).should > 0.0
-                    (finished - started).should < 0.1
-                  end
-                end
-              end
-            end
-          end
-
-          describe ".remaining_hours(time)" do
-            context "when time is on or after ad's end_datetime" do
-              it "should return zero" do
-                @end = Time.at(1234567890)
-                a = FakeAd.new(:end_datetime => @end)
-                a.send(:remaining_hours, @end).should == 0
-                a.send(:remaining_hours, @end + 1.day).should == 0
-              end
-            end
-            context "when time is before ad's end_datetime" do
-              context "when ad is not day-partitioned" do
-                context "when time is before ad's start_datetime" do
-                  it "returns the number of hours between the ad's start and end" do
-                    @end = Time.at(1234567890)
-                    a = FakeAd.new(:start_datetime => @end - 3.days, :end_datetime => @end, :day_partitions => nil)
-                    a.send(:remaining_hours, @end - 5.days).should == 24*3
-                  end
-                end
-                context "when time is after the ad's start_datetime" do
-                  it "should return the number of hours between the given time and the ad's end" do
-                    @end = Time.at(1234567890)
-                    a = FakeAd.new(:start_datetime => @end - 5.days, :end_datetime => @end, :day_partitions => nil)
-                    a.send(:remaining_hours, @end - 3.days).should == 24*3
-                  end
-                end
-              end
-              context "when ad is partitioned with the first 12 hours of each day active, and the last 12 inactive" do
-                before(:all) do
-                  @time_zone = "Beijing"
-                  Time.zone = @time_zone
-                  Chronic.time_class = Time.zone
-                  @day_partitions = ("T"*12 + "F"*12) * 7
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 9:30am to Friday @ 6pm" do
-                  it "should return 50.5 hours" do
-                    a = FakeAd.new(:start_datetime => Chronic.parse("Monday @ 9:30am"),
-                                    :end_datetime => Chronic.parse("Monday @ 6pm") + 4.days,
-                                    :day_partitions => @day_partitions)
-                    a.send(:remaining_hours, Chronic.parse("1 month ago")).should == 50.5
-                  end
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 6pm to Friday @ 9:30am" do
-                  it "should return 45.5 hours" do
-                    a = FakeAd.new(:start_datetime => Chronic.parse("Monday @ 6pm"),
-                                    :end_datetime => Chronic.parse("Monday @ 9:30am") + 4.days,
-                                    :day_partitions => @day_partitions)
-                    a.send(:remaining_hours, Chronic.parse("1 month ago")).should == 45.5
-                  end
-                end
-                context "when time is before ad's start_datetime, and date range is from Monday @ 6pm to Three Mondays later @ 6am" do
-                  it "should return 246 (12 * 7 * 3 - 6) hours" do
-                    a = FakeAd.new(:start_datetime => Chronic.parse("Monday @ 6pm"),
-                                    :end_datetime => Chronic.parse("Monday @ 6am") + 3.weeks,
-                                    :day_partitions => @day_partitions)
-                    a.send(:remaining_hours, Chronic.parse("1 month ago")).should == 12 * 7 * 3 - 6
-                  end
-                end
-                context "when the date range is really long" do
-                  it "should not take a long time to compute" do
-                    a = FakeAd.new(:start_datetime => Chronic.parse("2010-01-01 1am"),
-                                    :end_datetime => Chronic.parse("2020-01-07 5am"),
-                                    :day_partitions => @day_partitions)
-                    started = Time.now.to_f
-                    a.send(:remaining_hours, Chronic.parse("2009-12-31 11pm")).should == 43900
-                    finished = Time.now.to_f
-                    (finished - started).should > 0.0
-                    (finished - started).should < 0.1
-                  end
-                end
-              end
-            end
-          end
-
-          def remaining_hours_today(time)
-            @ad = FakeAd.new(
-              :start_datetime => @start,
-              :end_datetime => @end,
-              :day_partitions => @day_partitions)
-            @ad.send(:remaining_hours_today, time.in_time_zone(@time_zone))
-          end
-          describe ".remaining_hours_today(time)" do
-            before(:all) do
-              @time_zone = "Beijing"
-              Time.zone = @time_zone
-              Chronic.time_class = Time.zone
-            end
-            context "when ad is not day-partitioned" do
-              before(:all) { @day_partitions = nil}
-              context "when ad's start and end date/time are the same day" do
-                before(:all) do
-                  @start = Chronic.parse('tomorrow @ 9am')
-                  @end = Chronic.parse('tomorrow @ 5pm')
-                end
-                context "when the given time is on a different day" do
-                  it "should return zero" do
-                    remaining_hours_today(@start - 2.days).should == 0
-                    remaining_hours_today(@end - 2.days).should == 0
-                  end
-                end
-                context "when the given time is on the same day, but before the start" do
-                  it "should return the full number of hours of the ad's range" do
-                    remaining_hours_today(@start - 5.hours).should == 8
-                  end
-                end
-                context 'when the given time is on the same day, within the date range' do
-                  it "should return the hours between the given time and the end" do
-                    remaining_hours_today(Chronic.parse('tomorrow @ noon')).should == 5
-                  end
-                end
-                context "when the given time is on the same day, but after the end" do
-                  it "should return zero" do
-                    remaining_hours_today(@end + 1.hour).should == 0
-                  end
-                end
-              end
-              context "when the given time is at least 24 hours before the start time" do
-                it "should return zero" do
-                  @start = Time.at(1234567890)
-                  @end = @start + 1.month
-                  remaining_hours_today(@start - 1.day).should == 0
-                end
-              end
-              context "when the given time is at least 24 hours after the end time" do
-                it "should return zero" do
-                  @start = Time.at(1234567890)
-                  @end = @start + 1.month
-                  remaining_hours_today(@end + 1.day).should == 0
-                end
-              end
-              context "when the given time is after the the start_time" do
-                context "and at least 24 hours before the end time" do
-                  it "should return the hours from the given time to midnight of that night" do
-                    @start = Chronic.parse("yesterday @ 3am")
-                    @time = Chronic.parse("today @ 8pm")
-                    @end = @time + 1.day
-                    remaining_hours_today(@time).should == 4
-                  end
-                end
-                context "and the ad's end comes before midnight of the given time" do
-                  context "and the given time is before the end time" do
-                    it "should return the hours between the given time and the end time" do
-                      @start = Chronic.parse("yesterday @ 3am")
-                      @time = Chronic.parse("today @ 8pm")
-                      @end = @time + 2.hours
-                      remaining_hours_today(@time).should == 2
-                    end
-                  end
-                  context "and the given time is after the end time" do
-                    it "should return zero" do
-                      @start = Chronic.parse("yesterday @ 3am")
-                      @time = Chronic.parse("today @ 8pm")
-                      @end = @time - 2.hours
-                      remaining_hours_today(@time).should == 0
-                    end
-                  end
-                  context "and the given time matches the end time" do
-                    it "should return zero" do
-                      @start = Chronic.parse("yesterday @ 3am")
-                      @time = Chronic.parse("today @ 8pm")
-                      @end = @time
-                      remaining_hours_today(@time).should == 0
-                    end
-                  end
-                end
-              end
-            end
-            context "when ad is partitioned with the first 12 hours of each day active, and the last 12 inactive" do
-              before(:all) { @day_partitions = ("T"*12 + "F"*12) * 7}
-              context "when ad's start and end date/time are the same day" do
-                before(:all) do
-                  @start = Chronic.parse('tomorrow @ 9am')
-                  @end = Chronic.parse('tomorrow @ 5pm')
-                end
-                context "when the given time is on a different day" do
-                  it "should return zero" do
-                    remaining_hours_today(@start - 2.days).should == 0
-                    remaining_hours_today(@end - 2.days).should == 0
-                  end
-                end
-                context "when the given time is on the same day, but before the start" do
-                  it "should return the full number of hours of the ad's range" do
-                    remaining_hours_today(@start - 5.hours).should == 3
-                  end
-                end
-                context 'when the given time is on the same day, within the date range' do
-                  it "should return the hours between the given time and the end" do
-                    remaining_hours_today(Chronic.parse('tomorrow @ 11am')).should == 1
-                  end
-                end
-                context "when the given time is on the same day, but after the end" do
-                  it "should return zero" do
-                    remaining_hours_today(@end + 1.hour).should == 0
-                  end
-                end
-              end
-              context "when the given time is at least 24 hours before the start time" do
-                it "should return zero" do
-                  @start = Time.at(1234567890)
-                  @end = @start + 1.month
-                  remaining_hours_today(@start - 1.day).should == 0
-                end
-              end
-              context "when the given time is at least 24 hours after the end time" do
-                it "should return zero" do
-                  @start = Time.at(1234567890)
-                  @end = @start + 1.month
-                  remaining_hours_today(@end + 1.day).should == 0
-                end
-              end
-              context "when the given time is after the the start_time" do
-                context "and at least 24 hours before the end time" do
-                  it "should return the hours from the given time to midnight of that night" do
-                    @start = Chronic.parse("yesterday @ 3am")
-                    @time = Chronic.parse("today @ 7am")
-                    @end = @time + 1.day
-                    remaining_hours_today(@time).should == 5 #day part ends at noon
-                  end
-                end
-                context "and the ad's end comes before midnight of the given time" do
-                  context "and the given time is before the end time" do
-                    it "should return the hours between the given time and the end time" do
-                      @start = Chronic.parse("yesterday @ 3am")
-                      @time = Chronic.parse("today @ 10:30am")
-                      @end = @time + 2.hours
-                      remaining_hours_today(@time).should == 1.5 #day part ends at noon
-                    end
-                  end
-                  context "and the given time is after the end time" do
-                    it "should return zero" do
-                      @start = Chronic.parse("yesterday @ 3am")
-                      @time = Chronic.parse("today @ 7am")
-                      @end = @time - 2.hours
-                      remaining_hours_today(@time).should == 0
-                    end
-                  end
-                  context "and the given time matches the end time" do
-                    it "should return zero" do
-                      @start = Chronic.parse("yesterday @ 3am")
-                      @time = Chronic.parse("today @ 7am")
-                      @end = @time
-                      remaining_hours_today(@time).should == 0
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          def beginning_of_week(time)
-            FakeAd.new.send(:beginning_of_week, time)
-          end
-          describe ".beginning_of_week(time)" do
-            context "time is on sunday morning at midnight" do
-              it "should return an equivalent time" do
-                time = Chronic.parse("Sunday @ 00:00")
-                beginning_of_week(time).should == time
-              end
-            end
-            context "time is on sunday at noon" do
-              it "should return a time 12 hours before" do
-                time = Chronic.parse("Sunday @ noon")
-                beginning_of_week(time).should == time - 12.hours
-              end
-            end
-            context "time is on monday at noon" do
-              it "should return a time 12 hours and one day before" do
-                time = Chronic.parse("Monday @ noon")
-                beginning_of_week(time).should == time - (12.hours + 1.day)
-              end
-            end
-            context "time is on tuesday at noon" do
-              it "should return a time 12 hours and two days before" do
-                time = Chronic.parse("Tuesday @ noon")
-                beginning_of_week(time).should == time - (12.hours + 2.day)
-              end
-            end
-            context "time is on wednesday at noon" do
-              it "should return a time 12 hours and three days before" do
-                time = Chronic.parse("Wednesday @ noon")
-                beginning_of_week(time).should == time - (12.hours + 3.day)
-              end
-            end
-            context "time is on thursday at noon" do
-              it "should return a time 12 hours and four days before" do
-                time = Chronic.parse("Thursday @ noon")
-                beginning_of_week(time).should == time - (12.hours + 4.day)
-              end
-            end
-            context "time is on friday at noon" do
-              it "should return a time 12 hours and five days before" do
-                time = Chronic.parse("Friday @ noon")
-                beginning_of_week(time).should == time - (12.hours + 5.day)
-              end
-            end
-            context "time is on saturday at noon" do
-              it "should return a time 12 hours and six days before" do
-                time = Chronic.parse("Saturday @ noon")
-                beginning_of_week(time).should == time - (12.hours + 6.day)
-              end
-            end
-          end
-
-          def beginning_of_hour(time)
-            FakeAd.new.send(:beginning_of_hour, time)
-          end
-          describe ".beginning_of_hour(time)" do
-            before(:all) { @one_pm = Chronic.parse('1:00pm')}
-            context "at 1:00 pm" do
-              it "should return 1:00 pm" do
-                beginning_of_hour(@one_pm).should == @one_pm
-              end
-            end
-            context "at 1:01 pm" do
-              it "should return 1:00 pm" do
-                beginning_of_hour(@one_pm + 1.minute).should == @one_pm
-              end
-            end
-            context "at 1:59:59.9 pm" do
-              it "should return 1:00 pm" do
-                beginning_of_hour(@one_pm + 59.minutes + 59.9.seconds).should == @one_pm
-              end
-            end
-          end
-
-          def partitioned_hours(beginning, ending)
-            FakeAd.new(:day_partitions => @day_partitions).send(:partitioned_hours, beginning, ending)
-          end
-          describe ".partitioned_hours(beginning, ending)" do
-            before(:all) do
-              @time_zone = "Beijing"
-              Time.zone = @time_zone
-              Chronic.time_class = Time.zone
-            end
-            context "when ad is partitioned, active first 12 hours of every week day, inactive the last 12 hours and weekends" do
-              before(:all) { @day_partitions = "F"*24 + ("T"*12 + "F"*12)*5 + "F"*24 }
-              context "and beginning after ending" do
-                it "should return zero" do
-                  partitioned_hours(Time.now, Time.now - 1.day).should == 0
-                end
-              end
-              context "and beginning and ending are in the same hour" do
-                context "and that hour is an active partition" do
-                  it "should return the time (in hours) from beginning to ending" do
-                    @start = Chronic.parse("Monday @ 9:10am")
-                    @end = Chronic.parse("Monday @ 9:50am")
-                    partitioned_hours(@start, @end).should == 40/60.0
-                  end
-                end
-                context "and that hour is an inactive partition" do
-                  it "should return zero" do
-                    @start = Chronic.parse("Monday @ 9:10pm")
-                    @end = Chronic.parse("Monday @ 9:50pm")
-                    partitioned_hours(@start, @end).should == 0
-                  end
-                end
-              end
-              it "should have more specs"
-            end
-          end
-
-          describe ".partitioned_days(beginning, ending)" do
-            it "should have specs"
-          end
-
-          describe ".each_day(beginning, ending)" do
-            it "should have specs"
-          end
-
-          describe ".each_hour(beginning, ending)" do
-            it "should have specs"
-          end
-
-          describe ".actual_hours(beginning, ending)" do
-            it "should have specs"
-          end
-
-          describe ".days_per_week" do
-            it "should have specs"
-          end
-
-          describe ".hours_per_week" do
-            it "should have specs"
-          end
-
-        end
-      end
-    end
-  end
-end
-