trackoid 0.2.0 → 0.3.0

data/spec/ext/range_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Range do
+  describe "using the diff method" do
+    it "should work for normal ranges" do
+      (0..2).diff.should == 3
+      (0...2).diff.should == 2
+    end
+
+    it "should work for Time ranges (DAYS)" do
+      now = Time.now
+      inc_range = now..(now + 1*Range::DAYS)
+      exc_range = now...(now + 1*Range::DAYS)
+
+      inc_range.diff.should == 2
+      exc_range.diff.should == 1
+    end
+    
+    it "should work for Time ranges (HOURS)" do
+      now = Time.now
+      inc_range = now..(now + 10*Range::HOURS)
+      exc_range = now...(now + 10*Range::HOURS)
+
+      inc_range.diff(Range::HOURS).should == 11
+      exc_range.diff(Range::HOURS).should == 10
+    end
+
+    it "should also work when using helper methods" do
+      now = Time.now
+      inc_range = now..(now + 10*Range::HOURS)
+      exc_range = now...(now + 10*Range::HOURS)
+
+      inc_range.hour_diff.should == 11
+      exc_range.hour_diff.should == 10
+    end
+
+    it "should behave like normal ranges for 1 element" do
+      now = Time.now
+      inc_range = now..now
+      exc_range = now...now
+
+      inc_range.diff.should == 1
+      exc_range.diff.should == 0
+    end
+
+    it "should keep Time UTC and DST properties" do
+      date1 = Time.local(2011, 4, 1, 0, 0)
+      date2 = Time.utc(2011, 4, 1, 0, 0)
+
+      range1 = date1..date1
+      range2 = date2..date2
+
+      range1.first.should_not be_utc
+      range1.first.should be_dst
+      range2.first.should be_utc
+      range2.first.should_not be_dst
+    end
+  end
+
+  describe "using the map method" do
+    it "should work for normal ranges (using enumerator)" do
+      inc_result = (0..2).map.to_a
+      inc_result.should == [0, 1, 2]
+      
+      exc_result = (0...2).map.to_a
+      exc_result.should == [0, 1]
+    end
+
+    it "should work for normal ranges (using block)" do
+      inc_result = (0..2).map {|e| e}
+      inc_result.should == [0, 1, 2]
+      
+      exc_result = (0...2).map {|e| e}
+      exc_result.should == [0, 1]
+    end
+
+    it "should work for Time ranges" do
+      date = Time.utc(2011, 4, 1, 0, 0)
+      inc_range = date..(date + 5*Range::DAYS)
+      inc_result = inc_range.map {|d| d.to_i_timestamp}
+      inc_result.should == [15065, 15066, 15067, 15068, 15069, 15070]
+
+      exc_range = date...(date + 5*Range::DAYS)
+      exc_result = exc_range.map {|d| d.to_i_timestamp}
+      exc_result.should == [15065, 15066, 15067, 15068, 15069]
+    end
+
+    it "should work for empty excluding Time ranges" do
+      date = Time.utc(2011, 4, 1, 0, 0)
+      exc_range = date...date
+      exc_result = exc_range.map {|d| d.to_i_timestamp}
+      exc_result.should == []
+    end
+    
+    it "should return an array if no block given" do
+      date = Time.utc(2011, 4, 1, 0, 0)
+      result = (date..(date + 5*Range::DAYS)).map
+      result.count.should == 6
+      
+      # Result is now an array
+      result.map(&:to_i_timestamp).should == [15065, 15066, 15067, 15068, 15069, 15070]
+    end
+
+    it "should also work using helper methods" do
+      date = Time.utc(2011, 4, 1, 0, 0)
+      result = (date..(date + 5*Range::HOURS)).hour_map
+      result.count.should == 6
+    end
+  end
+end

data/spec/ext/time_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Time do
+  describe "when working with UTC dates" do
+    it "should return the correct timestamp" do
+      time1 = Time.utc(2011, 1, 1, 0, 0, 0)
+      time1.to_i_timestamp.should == 14975
+
+      time2 = Time.utc(2011, 1, 1, 23, 59, 59)
+      time2.to_i_timestamp.should == 14975
+    end
+
+    it "should return the correct hours" do
+      time1 = Time.utc(2011, 1, 1, 0, 0, 0)
+      time1.to_i_hour.should == 0
+
+      time2 = Time.utc(2011, 1, 1, 23, 59, 59)
+      time2.to_i_hour.should == 23
+    end
+
+    it "should convert back with timestamps and hours" do
+      t = Time.from_key(14975, 23).utc
+      t.to_s.should == "2011-01-01 23:00:00 UTC"
+    end
+  
+    it "should work also on ranges (dates)" do
+      time1 = Time.utc(2011, 1, 1, 0, 0, 0)
+      range = time1...(time1 + 10*Range::DAYS)
+      range.map(&:to_i_timestamp).should == [14975, 14976, 14977, 14978, 14979, 14980, 14981, 14982, 14983, 14984]
+    end
+
+    it "should work also on ranges (hours)" do
+      range = Time.utc(2011, 1, 1)...Time.utc(2011, 1, 2)
+      
+      # With Range::HOURS
+      range.map(Range::HOURS){|d| d.to_i_hour}.should == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
+
+      # With ActiveSupport Numeric extensions
+      range.map(1.hour){|d| d.to_i_hour}.should == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
+    end
+
+    it "should iterate for a day and return the correct UTC keys" do
+      today = Time.utc(2011, 1, 1).whole_day
+      today.diff(Range::HOURS).should == 24
+      today.map(Range::HOURS) {|d| d.to_key}.should == [
+        "14975.0", "14975.1", "14975.2", "14975.3", "14975.4", "14975.5",
+        "14975.6", "14975.7", "14975.8", "14975.9", "14975.10", "14975.11",
+        "14975.12", "14975.13", "14975.14", "14975.15", "14975.16", "14975.17",
+        "14975.18", "14975.19", "14975.20", "14975.21", "14975.22", "14975.23"
+      ]
+    end
+
+    it "should iterate for a day and return the correct UTC keys (Helper methods)" do
+      today = Time.utc(2011, 1, 1).whole_day
+      today.hour_diff.should == 24
+      today.hour_map {|d| d.to_key}.should == [
+        "14975.0", "14975.1", "14975.2", "14975.3", "14975.4", "14975.5",
+        "14975.6", "14975.7", "14975.8", "14975.9", "14975.10", "14975.11",
+        "14975.12", "14975.13", "14975.14", "14975.15", "14975.16", "14975.17",
+        "14975.18", "14975.19", "14975.20", "14975.21", "14975.22", "14975.23"
+      ]
+    end
+  end
+
+  describe "when working with TZ dates (Europe)" do
+    before do
+      ENV["TZ"] = "Europe/Madrid"
+    end
+
+    it "should return the correct timestamp" do
+      # NOTE: January 1, 2011 00:00 GMT+1 Timezone corresponds to: December, 31 2010 23:00 UTC
+      time1 = Time.local(2011, 1, 1, 0, 0, 0)
+      time1.to_i_timestamp.should == 14974
+
+      time2 = Time.local(2011, 1, 1, 23, 59, 59)
+      time2.to_i_timestamp.should == 14975
+    end
+
+    it "should return the correct hours" do
+      time1 = Time.local(2011, 1, 1, 0, 0, 0)
+      time1.to_i_hour.should == 23 # This is for the previous day
+    
+      time2 = Time.local(2011, 1, 1, 23, 59, 59)
+      time2.to_i_hour.should == 22
+    end
+
+    it "should convert back with timestamps and hours" do
+      t = Time.from_key(14975, 23)
+      t.to_s.should == "2011-01-02 00:00:00 +0100"
+    end
+  end
+
+  describe "when working with TZ dates (America)" do
+    before do
+      ENV["TZ"] = "America/Los_Angeles"
+    end
+
+    it "should return the correct timestamp" do
+      time1 = Time.local(2011, 1, 1, 0, 0, 0)
+      time1.to_i_timestamp.should == 14975
+
+      # Note: January 1, 2011 23:00 PST Timezone corresponds to: January, 2 2010 07:00 UTC
+      time2 = Time.local(2011, 1, 1, 23, 59, 59)
+      time2.to_i_timestamp.should == 14976
+    end
+
+    it "should return the correct hours" do
+      time1 = Time.local(2011, 1, 1, 0, 0, 0)
+      time1.to_i_hour.should == 8
+    
+      time2 = Time.local(2011, 1, 1, 23, 59, 59)
+      time2.to_i_hour.should == 7 # This is for the next day
+    end
+
+    it "should convert back with timestamps and hours" do
+      t = Time.from_key(14976, 7)
+      t.to_s.should == "2011-01-01 23:00:00 -0800"
+    end
+
+    it "should iterate for a day and return the correct UTC keys" do
+      today = Time.local(2011, 1, 1).whole_day
+      today.map(Range::HOURS) {|d| d.to_key}.should == [
+        "14975.8", "14975.9", "14975.10", "14975.11", "14975.12", "14975.13",
+        "14975.14", "14975.15", "14975.16", "14975.17", "14975.18",
+        "14975.19", "14975.20", "14975.21", "14975.22", "14975.23",
+        "14976.0", "14976.1", "14976.2", "14976.3", "14976.4", "14976.5",
+        "14976.6", "14976.7"
+      ]
+    end
+
+    it "should iterate for a day and return the correct UTC keys (Helper methods)" do
+      today = Time.local(2011, 1, 1).whole_day
+      today.hour_map {|d| d.to_key}.should == [
+        "14975.8", "14975.9", "14975.10", "14975.11", "14975.12", "14975.13",
+        "14975.14", "14975.15", "14975.16", "14975.17", "14975.18",
+        "14975.19", "14975.20", "14975.21", "14975.22", "14975.23",
+        "14976.0", "14976.1", "14976.2", "14976.3", "14976.4", "14976.5",
+        "14976.6", "14976.7"
+      ]
+    end
+  end
+end

data/spec/reader_extender_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Mongoid::Tracking::ReaderExtender do
+  it "should behave like a number" do
+    num = Mongoid::Tracking::ReaderExtender.new(5, [])
+    num.should == 5
+    num.should < 10
+    (num * 10).should == 50
+  end
+
+  it "should be able to add additional data to it" do
+    num = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    num.hourly.should == [1, 2, 3, 4]
+  end
+
+  it "should be able to sum two ReadersExtenders" do
+    a = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    b = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    c = a + b
+    c.should == 10
+    c.hourly.should == [2, 4, 6, 8]
+  end
+
+  it "should be able to sum more than two ReadersExtenders" do
+    a = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    b = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    c = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    d = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    e = Mongoid::Tracking::ReaderExtender.new(5, [1, 2, 3, 4])
+    f = a + b + c + d + e
+    f.should == 25
+    f.hourly.should == [5, 10, 15, 20]
+  end
+end

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ Mongoid.configure do |config|
   name = "trackoid_test"
   host = "localhost"
   port = "27017"
-#  config.master = Mongo::Connection.new(host, port, :logger => Logger.new(STDOUT)).db(name)
+  # config.master = Mongo::Connection.new(host, port, :logger => Logger.new(STDOUT)).db(name)
   config.master = Mongo::Connection.new.db(name)
 end
 

data/spec/timezone_spec.rb

@@ -0,0 +1,249 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Mongoid::Tracking do
+  describe "Testing the system TZ for Europe/Madrid" do
+    before do
+      ENV['TZ'] = 'Europe/Madrid'
+    end
+
+    it "should convert dates to UTC" do
+      t = Time.now
+      t.should_not be_utc
+      t.utc
+      t.should be_utc
+    end
+
+    it "should create dates in UTC" do
+      t = Time.utc(2011, 1, 1, 20, 30)
+      t.to_s.should == "2011-01-01 20:30:00 UTC"
+    end
+
+    it "should create dates in local time" do
+      t = Time.local(2011, 1, 1, 20, 30)
+      t.to_s.should == "2011-01-01 20:30:00 +0100"
+      t.utc_offset.should == 3600
+    end
+
+    it "should detect daylight saving for local times" do
+      t = Time.local(2011, 6, 1, 20, 30)
+      t.should be_dst
+      t.to_s.should == "2011-06-01 20:30:00 +0200"
+      t.utc_offset.should == 7200
+    end
+
+    it "timestamps should be offset by the utc_offset" do
+      local = Time.local(2011, 1, 1, 0, 0)
+      utc = Time.utc(2011, 1, 1, 0, 0)
+      (utc - local).should == local.utc_offset
+    end
+
+    it "timestamps should be offset by the utc_offset even when daylight saving is on" do
+      local = Time.local(2011, 6, 1, 0, 0)
+      utc = Time.utc(2011, 6, 1, 0, 0)
+      local.should be_dst
+      utc.should_not be_dst
+      (local - utc).abs.should == local.utc_offset
+    end
+  end
+
+  describe "Testing the system TZ for America/San Francisco" do
+    before do
+      ENV['TZ'] = 'America/Los_Angeles'
+    end
+
+    it "should convert dates to UTC" do
+      t = Time.now
+      t.should_not be_utc
+      t.utc
+      t.should be_utc
+    end
+
+    it "should create dates in UTC" do
+      t = Time.utc(2011, 1, 1, 20, 30)
+      t.to_s.should == "2011-01-01 20:30:00 UTC"
+    end
+
+    it "should create dates in local time" do
+      t = Time.local(2011, 1, 1, 20, 30)
+      t.to_s.should == "2011-01-01 20:30:00 -0800"
+      t.utc_offset.should == -28800
+    end
+
+    it "should detect daylight saving for local times" do
+      t = Time.local(2011, 6, 1, 20, 30)
+      t.should be_dst
+      t.to_s.should == "2011-06-01 20:30:00 -0700"
+      t.utc_offset.should == -25200
+    end
+
+    it "timestamps should be offset by the utc_offset" do
+      local = Time.local(2011, 1, 1, 0, 0)
+      utc = Time.utc(2011, 1, 1, 0, 0)
+      (utc - local).should == local.utc_offset
+    end
+
+    it "timestamps should be offset by the utc_offset even when daylight saving is on" do
+      local = Time.local(2011, 6, 1, 0, 0)
+      utc = Time.utc(2011, 6, 1, 0, 0)
+      local.should be_dst
+      utc.should_not be_dst
+      (utc - local).should == local.utc_offset
+    end
+  end
+
+  describe "Testing the RAILS TZ capabilities" do
+    before do
+      ENV['TZ'] = nil
+    end
+
+    it "should support time zone changing" do
+      Time.zone = ActiveSupport::TimeZone["America/Los_Angeles"]
+
+      local = Time.local(2011, 6, 1, 0, 0).in_time_zone
+      local.should be_dst
+      local.utc_offset.should == -25200
+
+      Time.zone = ActiveSupport::TimeZone["Europe/Madrid"]
+      local = Time.local(2011, 6, 1, 0, 0)
+      local.should be_dst
+      local.utc_offset.should == 7200
+    end
+
+    it "should correctly handle UTC offseted dates" do
+      utc = Time.utc(2011, 6, 1, 0, 0)
+      utc_localized = Time.utc(2011, 6, 1, 0, 0) + 7200
+
+      (utc_localized - utc).should == 7200
+    end
+  end
+
+  describe "Testing TZ data with real models" do
+    before(:all) do
+      class Test
+        include Mongoid::Document
+        include Mongoid::Tracking
+
+        field :name   # Dummy field
+        track :visits
+      end
+    end
+    
+    before do
+      Test.delete_all
+      Test.create(:name => "test")
+      @object_id = Test.first.id
+      @mock = Test.find(@object_id)
+    end
+
+    it "should correctly handle hours for my TimeZone" do
+      # WARNING: Volatile test, time dependant... Do not run at 00:00:00 :-)
+      t1 = Time.now.change(:hour => 0)
+      t2 = Time.now.change(:hour => 23)
+
+      @mock.visits.inc(t1)
+      @mock.visits.inc(t2)
+      @mock.visits.today.should == 2
+      @mock.visits.today.hourly.should == [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+    end
+
+    it "should correctly handle hours for UTC" do
+      # WARNING: Volatile test, time dependant... Do not run at 00:00:00 :-)
+      t1 = Time.now.utc.change(:hour => 0)
+      t2 = Time.now.utc.change(:hour => 23)
+
+      @mock.visits.inc(t1)
+      @mock.visits.inc(t2)
+      @mock.visits.on(Time.now.utc).should == 2
+      @mock.visits.on(Time.now.utc).hourly.should == [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+    end
+
+    it "Hours in Europe/Madrid (Winter time) should be shifted by 1 hour from UTC" do
+      ENV["TZ"] = "Europe/Madrid"
+
+      time = Time.parse("2011-01-01")
+      t1 = time.change(:hour => 1)
+      t2 = time.change(:hour => 22)
+
+      @mock.visits.inc(t1)
+      @mock.visits.inc(t2)
+      
+      # This test is interesting. We added with local TZ time but want to
+      # query shifted data on UTC. We need to read the expected span dates
+      # separately
+      visits = @mock.visits.on(time.utc..(time.utc + 1.day))
+
+      # Data from 2010-12-31 00:00:00 UTC up to 2011-12-31 23:59:59 UTC
+      visits.first.hourly.should == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+      # Data from 2011-01-01 00:00:00 UTC up to 2011-01-01 23:59:59 UTC
+      visits.last.hourly.should == [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
+    end
+
+    it "Hours in Europe/Madrid (Summer time) should be shifted by 2 hour from UTC" do
+      ENV["TZ"] = "Europe/Madrid"
+
+      time = Time.parse("2011-06-01")
+      t1 = time.change(:hour => 1)
+      t2 = time.change(:hour => 22)
+
+      @mock.visits.inc(t1)
+      @mock.visits.inc(t2)
+      
+      # This test is interesting. We added with local TZ time but want to
+      # query shifted data on UTC. We need to read the expected span dates
+      # separately
+      visits = @mock.visits.on(time.utc..(time.utc + 1.day))
+
+      # Data from 2011-05-31 00:00:00 UTC up to 2011-05-31 23:59:59 UTC
+      visits.first.hourly.should == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+
+      # Data from 2011-06-01 00:00:00 UTC up to 2011-06-01 23:59:59 UTC
+      visits.last.hourly.should == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
+    end
+
+    it "Hours in America/Los_Angeles (Winter time) should be shifted by -8 hours from UTC" do
+      ENV["TZ"] = "America/Los_Angeles"
+
+      time = Time.parse("2011-01-01")
+      t1 = time.change(:hour => 1)
+      t2 = time.change(:hour => 22)
+
+      @mock.visits.inc(t1)
+      @mock.visits.inc(t2)
+      
+      # This test is interesting. We added with local TZ time but want to
+      # query shifted data on UTC. We need to read the expected span dates
+      # separately
+      visits = @mock.visits.on(time.utc..(time.utc + 1.day))
+
+      # Data from 2011-01-01 00:00:00 UTC up to 2011-01-01 23:59:59 UTC
+      visits.first.hourly.should == [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+      # Data from 2011-01-02 00:00:00 UTC up to 2011-01-02 23:59:59 UTC
+      visits.last.hourly.should == [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    end
+
+    it "Hours in America/Los_Angeles (Summer time) should be shifted by -7 hours from UTC" do
+      ENV["TZ"] = "America/Los_Angeles"
+
+      time = Time.parse("2011-06-01")
+      t1 = time.change(:hour => 1)
+      t2 = time.change(:hour => 22)
+
+      @mock.visits.inc(t1)
+      @mock.visits.inc(t2)
+      
+      # This test is interesting. We added with local TZ time but want to
+      # query shifted data on UTC. We need to read the expected span dates
+      # separately
+      visits = @mock.visits.on(time.utc..(time.utc + 1.day))
+
+      # Data from 2011-01-01 00:00:00 UTC up to 2011-01-01 23:59:59 UTC
+      visits.first.hourly.should == [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+      # Data from 2011-01-02 00:00:00 UTC up to 2011-01-02 23:59:59 UTC
+      visits.last.hourly.should == [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    end
+
+  end
+end

data/spec/trackoid_spec.rb

@@ -50,6 +50,10 @@ describe Mongoid::Tracking do
       @mock.respond_to?(:visits).should be_true
     end
 
+    it "should NOT create an index for the stats field" do
+      @mock.class.index_options.should_not include(:visits_data)
+    end
+
     it "should respond 'false' to field_changed? method" do
       # Ok, this test is not very relevant since it will return false even
       # if Trackid does not override it.
@@ -105,6 +109,7 @@ describe Mongoid::Tracking do
 
     before do
       @mock = Test.find(@object_id)
+      @today = Time.now
     end
 
     it "should increment visits stats for today" do
@@ -118,12 +123,12 @@ describe Mongoid::Tracking do
     end
 
     it "should also work for yesterday" do
-      @mock.visits.inc(DateTime.now - 1)
+      @mock.visits.inc(@today - 1.day)
       @mock.visits.yesterday.should == 1
     end
 
     it "should also work for yesterday if adding another visit (for a total of 2)" do
-      @mock.visits.inc(DateTime.now - 1)
+      @mock.visits.inc(@today - 1.day)
       @mock.visits.yesterday.should == 2
     end
     
@@ -145,11 +150,16 @@ describe Mongoid::Tracking do
     end
 
     it "should give the first date with first_date" do
-      @mock.visits.first_date.should == Date.parse("2010-07-11")
+      t = Time.parse("2010-07-11")
+      f = @mock.visits.first_date
+      [f.year, f.month, f.day, f.hour].should == [t.year, t.month, t.day, t.hour]
     end
 
     it "should give the last date with last_date" do
-      @mock.visits.last_date.should == Date.today
+      future = @today + 1.month
+      @mock.visits.set(22, future)
+      f = @mock.visits.last_date
+      [f.year, f.month, f.day, f.hour].should == [future.year, future.month, future.day, future.hour]
     end
 
     it "should give the first value" do
@@ -157,7 +167,7 @@ describe Mongoid::Tracking do
     end
 
     it "should give the last value" do
-      @mock.visits.last_value.should == 2
+      @mock.visits.last_value.should == 22
     end
   end
 
@@ -179,9 +189,9 @@ describe Mongoid::Tracking do
     end
 
     it "'set' operator must work on arbitrary days" do
-      @mock.visits.set(5, Date.parse("2010-05-01"))
-      @mock.visits.on(Date.parse("2010-05-01")).should == 5
-      Test.find(@object_id).visits.on(Date.parse("2010-05-01")).should == 5
+      @mock.visits.set(5, Time.parse("2010-05-01"))
+      @mock.visits.on(Time.parse("2010-05-01")).should == 5
+      Test.find(@object_id).visits.on(Time.parse("2010-05-01")).should == 5
     end
 
     it "'add' operator must work" do
@@ -191,9 +201,9 @@ describe Mongoid::Tracking do
     end
 
     it "'add' operator must work on arbitrary days" do
-      @mock.visits.add(5, Date.parse("2010-05-01"))
-      @mock.visits.on(Date.parse("2010-05-01")).should == 10
-      Test.find(@object_id).visits.on(Date.parse("2010-05-01")).should == 10
+      @mock.visits.add(5, Time.parse("2010-05-01"))
+      @mock.visits.on(Time.parse("2010-05-01")).should == 10
+      Test.find(@object_id).visits.on(Time.parse("2010-05-01")).should == 10
     end
 
     it "on() accessor must work on dates as String" do
@@ -201,14 +211,14 @@ describe Mongoid::Tracking do
       @mock.visits.on("2010-05-01").should == 10
     end
 
-    it "on() accessor must work on dates as Date ancestors" do
+    it "on() accessor must work on Date descendants" do
       # We have data for today as previous tests populated the visits field
       @mock.visits.on(Date.parse("2010-05-01")).should == 10
     end
 
     it "on() accessor must work on dates as Ranges" do
       # We have data for today as previous tests populated the visits field
-      @mock.visits.on(Date.parse("2010-04-30")..Date.parse("2010-05-02")).should == [0, 10, 0]
+      @mock.visits.on(Time.parse("2010-04-30")..Time.parse("2010-05-02")).should == [0, 10, 0]
     end
   end