timely 0.0.1 → 0.0.2

data/lib/timely/week_days.rb

@@ -0,0 +1,128 @@
+module Timely
+  class WeekDays
+    WEEKDAY_KEYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
+
+    # Create a new Weekdays object
+    # weekdays can be in three formats
+    # integer representing binary string
+    #   e.g. 1 = Sun, 2 = Mon, 3 = Sun + Mon, etc.
+    # hash with symbol keys for :sun, :mon, ... with true/false values
+    #   e.g. {:sun => true, :tue => true} is Sunday and Tuesday
+    #   Not passing in values is the same as setting them explicitly to true
+    # array with true/false values from sun to sat
+    #   e.g. [1, 0, 1, 0, 0, 0, 0] is Sunday and Tuesday
+    def initialize(weekdays)
+      @weekdays = {
+        :sun => false,
+        :mon => false,
+        :tue => false,
+        :wed => false,
+        :thu => false,
+        :fri => false,
+        :sat => false
+      }
+
+      case weekdays
+      when Fixnum
+        # 4 -> 0000100 (binary) -> "0010000" (reversed string) -> {:tue => true}
+        weekdays.to_s(2).reverse.each_char.with_index do |char, index|
+          set_day(index, char == '1')
+        end
+      when Hash
+        weekdays.each_pair do |day, value|
+          set_day(day, value)
+        end
+      when Array
+        weekdays.each.with_index do |value, index|
+          set_day(index, value)
+        end
+      when NilClass
+        @weekdays = {
+          :sun => true,
+          :mon => true,
+          :tue => true,
+          :wed => true,
+          :thu => true,
+          :fri => true,
+          :sat => true
+        }
+      else
+        raise ArgumentError, "You must initialize with an Fixnum, Hash or Array"
+      end
+    end
+
+    # Set the weekday on or off
+    # weekdays[:mon] = true
+    # weekdays[:tue] = false
+    # set ideally will be true, but 'true', 1 and '1' are accepted
+    # All other values will be treated as false
+    def []=(day, set)
+      set_day(day, set)
+    end
+
+    def set_day(day, set)
+      key = if day.is_a?(Fixnum)
+        WEEKDAY_KEYS[day]
+      elsif day.is_a?(String)
+        day.to_sym
+      else
+        day
+      end
+      raise ArgumentError, "Invalid week day index #{key}" unless WEEKDAY_KEYS.include?(key)
+      @weekdays[key] = [true, 'true', 1, '1'].include?(set)
+    end
+
+    def applies_for_date?(date)
+      has_day?(date.wday)
+    end
+
+    # Determine if weekdays has day selected
+    # Accepts either symbol or integer
+    # e.g. :sun or 0 = Sunday, :sat or 6 = Saturday
+    def has_day?(weekday)
+      weekday = WEEKDAY_KEYS[weekday] if weekday.is_a?(Fixnum)
+      @weekdays[weekday]
+    end
+
+    def number_of_occurances_in(range)
+      range.inject(0) do |count, date|
+        applies_for_date?(date) ? count+1 : count
+      end
+    end
+
+    # Returns true if all days are selected
+    def all_days?
+      @weekdays.all?{|day, selected| selected}
+    end
+
+    # Returns array of weekday selected
+    # e.g. [:sun, :sat]
+    def weekdays
+      selected = @weekdays.select{|day, selected| selected}
+      # Ruby 1.8 returns an array for Hash#select and loses order
+      selected.is_a?(Hash) ? selected.keys : selected.map(&:first).sort_by{|v| WEEKDAY_KEYS.index(v)}
+    end
+
+    # Returns comma separated and capitalized in Sun-Sat order
+    # e.g. 'Mon, Tue, Wed' or 'Sat' or 'Sun, Sat'
+    def to_s
+      days = weekdays.map{|day| day.to_s.capitalize}
+      last_day = days.pop
+
+      days.empty? ? last_day : days.join(", ") + ", and " + last_day
+    end
+
+    # 7 bits encoded in decimal number
+    # 0th bit = Sunday, 6th bit = Saturday
+    # Value of 127 => all days are on
+    def weekdays_int
+      int = 0
+      WEEKDAY_KEYS.each.with_index do |day, index|
+        int += 2 ** index if @weekdays[day]
+      end
+      int
+    end
+
+    ALL_WEEKDAYS = WeekDays.new(%w(1 1 1 1 1 1 1))
+  end
+end

data/lib/timely.rb

@@ -1,8 +1,17 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
 module Timely
-end
+  VERSION = '0.0.2'
 
-require 'timely/date'
-require 'timely/time'
+  require 'time'
+  require 'date'
+
+  require 'timely/string'
+  require 'timely/date'
+  require 'timely/time'
+  require 'timely/date_time'
+  require 'timely/range'
+  require 'timely/date_range'
+  require 'timely/date_chooser'
+  require 'timely/week_days'
+  require 'timely/temporal_patterns'
+  require 'timely/trackable_date_set'
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'timely/rails'

data/spec/date_chooser_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Timely::DateChooser do
+  before(:all) do
+    @from = "01-01-2011".to_date
+    @to = "01-03-2011".to_date
+  end
+
+  #Validation
+  it "rejects blank FROM dates" do
+    lambda { Timely::DateChooser.new({:from=>""}) }.should raise_error(Timely::DateChooserException)
+  end
+
+  it "rejects TO dates later than FROM dates" do
+    lambda {Timely::DateChooser.new(
+      :multiple_dates => true, :from => @from + 10, :to => @from
+    )}.should raise_error(Timely::DateChooserException)
+  end
+
+  #Operation
+  it "returns today if client only wants single date" do
+    Timely::DateChooser.new(
+      :multiple_dates => false, :from => @from
+    ).choose_dates.should == [@from]
+  end
+
+  #Test specific date of month
+  it "returns from and to as same (one) day in the case that only from date is given" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :from => @from, :to => ''
+    ).choose_dates.should == [@from]
+  end
+
+  it "returns all days between from and to days in the basic case" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :from => @from, :to => @to
+    ).choose_dates.should == (@from..@to).to_a
+  end
+
+  it "returns the specific dates if this option is picked" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'days', :dates => '1,11,3', :from => @from, :to => @to
+    ).choose_dates.should == [
+      "1-01-2011", "3-01-2011", "11-01-2011", "1-02-2011",
+      "3-02-2011", "11-02-2011", "1-03-2011"
+    ].map(&:to_date)
+  end
+
+  #Test days of week, every X weeks
+  it "returns every sunday correctly" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'weekdays', :from => @from, :to => @to,
+      :interval => {:level => "1", :unit => "w"}, :weekdays => {:sun => true}
+    ).choose_dates.should == [
+      "2-01-2011", "9-01-2011", "16-01-2011", "23-01-2011", "30-01-2011",
+      "06-02-2011", "13-02-2011", "20-02-2011", "27-02-2011"
+    ].map(&:to_date)
+  end
+
+  it "returns every thursday and sunday correctly" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'weekdays',
+      :interval => {:level => "1", :unit => "w"},
+      :weekdays => {:sun => true, :thu => true}, :from => @from, :to => @to
+    ).choose_dates.should == [
+      "2-01-2011", "6-01-2011", "9-01-2011", "13-01-2011", "16-01-2011",
+      "20-01-2011", "23-01-2011", "27-01-2011", "30-01-2011", "3-02-2011",
+      "06-02-2011", "10-02-2011", "13-02-2011", "17-02-2011", "20-02-2011",
+      "24-02-2011", "27-02-2011"
+    ].map(&:to_date)
+  end
+
+  it "returns every 2nd thursday and sunday correctly" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'weekdays',
+      :interval => {:level => "2", :unit => "w"},
+      :weekdays => {:sun => "1", :thu => "1"}, :from => @from, :to => @to
+    ).choose_dates.should == [
+      "2-01-2011", "6-01-2011", "16-01-2011", "20-01-2011", "30-01-2011",
+      "3-02-2011", "13-02-2011", "17-02-2011", "27-02-2011"
+    ].map(&:to_date)
+  end
+
+  #Test correct results for every Nth week of month
+  it "returns every 1st Tuesday" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'weekdays', :from => @from, :to => @to,
+      :interval => {:level => "1", :unit => "wom"}, :weekdays => {:tue => true}
+    ).choose_dates.should == ["4-01-2011", "1-02-2011", "1-03-2011"].map(&:to_date)
+  end
+
+  it "returns every 3st Monday and Friday" do
+    Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'weekdays',
+      :interval => {:level => "3", :unit => "wom"},
+      :weekdays => {:mon => true, :fri => true}, :from => @from, :to => @to
+    ).choose_dates.should == [
+      "17-01-2011", "21-01-2011", "18-02-2011", "21-02-2011"
+    ].map(&:to_date)
+  end
+end

data/spec/date_group_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+describe Timely::DateGroup do
+  before do
+    @date_group = Timely::DateGroup.create!(
+      :start_date => '2000-01-01', :end_date => '2000-01-03', :weekdays => %w(1 1 1 1 1 1 1)
+    )
+  end
+
+  it 'should detect overlaps' do
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-01'.to_date)).should be_true
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-06'.to_date)).should be_true
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2001-01-01'.to_date, '2001-01-01'.to_date)).should be_false
+    @date_group.applicable_for_duration?(Timely::DateRange.new('1999-12-29'.to_date, '2000-01-05'.to_date)).should be_true 
+  end
+
+  it "should detect overlaps when certain weekdays aren't selected" do
+    @date_group = Timely::DateGroup.create!(
+      :start_date => '2012-01-01', :end_date => '2012-01-07', :weekdays => %w(1 0 1 0 1 0 1)
+    )
+    # Note: 2012-01-1 is a Sunday
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-01'.to_date)).should be_true
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-02'.to_date, '2012-01-02'.to_date)).should be_false
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-03'.to_date, '2012-01-03'.to_date)).should be_true
+    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-03'.to_date)).should be_true
+  end
+end

data/spec/date_range_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Timely::DateRange do
+  
+  it "should allow initialization with two dates" do
+    lambda { @date_range = Timely::DateRange.new(Date.today, Date.today + 3) }.should_not raise_error
+    @date_range.start_date.should eql Date.today
+    @date_range.end_date.should eql Date.today + 3
+  end
+  
+  it "should allow initialization with one date" do
+    lambda { @date_range = Timely::DateRange.new(Date.today) }.should_not raise_error
+    @date_range.start_date.should eql Date.today
+    @date_range.end_date.should eql Date.today
+  end
+  
+  it "should allow initialization with a range" do
+    lambda { @date_range = Timely::DateRange.new(Date.today..Date.today + 3) }.should_not raise_error
+    @date_range.start_date.should eql Date.today
+    @date_range.end_date.should eql Date.today + 3
+  end
+
+  it "should correctly find the interesection between two date ranges" do
+    @date_range = Timely::DateRange.new("2000-01-03".to_date, "2000-01-06".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date)).should == ("2000-01-04".to_date.."2000-01-06".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-02".to_date)).should == []
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date)).should == ("2000-01-06".to_date.."2000-01-06".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date)).should == ("2000-01-06".to_date.."2000-01-06".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-05".to_date)).should == ("2000-01-04".to_date.."2000-01-05".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-05".to_date, "2000-01-05".to_date)).should == ("2000-01-05".to_date.."2000-01-05".to_date)
+
+    @date_range = Timely::DateRange.new("2000-01-03".to_date, "2000-01-03".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date)).should == []
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-03".to_date, "2000-01-05".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
+    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-02".to_date, "2000-01-04".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
+  end
+  
+end

data/spec/date_spec.rb

@@ -1,68 +1,68 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'spec_helper'
 
 describe Date do
   before :each do
     @date = Date.today - 5
-    
+
     @hour   = 1
     @minute = 2
     @second = 3
   end
-  
+
   it 'should give a time on that date' do
     @date.should respond_to(:at_time)
   end
-  
+
   describe 'giving a time on that date' do
     it 'should accept hour, minute, and second' do
       lambda { @date.at_time(@hour, @minute, @second) }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should accept hour and minute' do
       lambda { @date.at_time(@hour, @minute) }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should accept hour' do
       lambda { @date.at_time(@hour) }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should accept no arguments' do
       lambda { @date.at_time }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should return a time for the given hour, minute, and second if all three are specified' do
       expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
       @date.at_time(@hour, @minute, @second).should == expected
     end
-    
+
     it 'should default second to 0 if unspecified' do
       expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, 0)
       @date.at_time(@hour, @minute).should == expected
     end
-    
+
     it 'should default minute to 0 if unspecified' do
       expected = Time.local(@date.year, @date.month, @date.day, @hour, 0, 0)
       @date.at_time(@hour).should == expected
     end
-    
+
     it 'should default hour to 0 if unspecified' do
       expected = Time.local(@date.year, @date.month, @date.day, 0, 0, 0)
       @date.at_time.should == expected
     end
-    
+
     it 'should accept a time' do
       lambda { @date.at_time(Time.now) }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should return the passed-in time on the date' do
       @time = Time.now - 12345
       expected = Time.local(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
       @date.at_time(@time).should == expected
     end
   end
-  
+
   it "should provide 'at' as an alias" do
-    expected = expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
+    expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
     @date.at(@hour, @minute, @second).should == expected
   end
 end

data/spec/schema.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :seasons do |t|
+    t.string :name
+  end
+
+  create_table :date_groups do |t|
+    t.integer :season_id, :weekdays_bit_array
+    t.date :start_date, :end_date
+  end
+end
+

data/spec/season_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Timely::Season, "in general" do
+  before do
+    # 1st and 3rd Quarter
+    @simple_low_season = Timely::Season.new
+    @simple_low_season.date_groups.build(:start_date => '2009-01-01'.to_date, :end_date => '2009-03-31'.to_date)
+    @simple_low_season.date_groups.build(:start_date => '2009-07-01'.to_date, :end_date => '2009-09-30'.to_date)
+    @simple_low_season.save!
+
+    # 2nd and 4th Quarter
+    @simple_high_season = Timely::Season.new
+    @simple_high_season.date_groups.build(:start_date => '2009-04-01'.to_date, :end_date => '2009-06-30'.to_date)
+    @simple_high_season.date_groups.build(:start_date => '2009-10-01'.to_date, :end_date => '2009-12-31'.to_date)
+    @simple_high_season.save!
+  end
+
+  it "be able to tell if a date is in or out of its season" do
+    low_season_date = '2009-02-22'.to_date
+    high_season_date = '2009-04-22'.to_date
+
+    @simple_low_season.includes_date?(low_season_date).should be_true
+    @simple_high_season.includes_date?(low_season_date).should_not be_true
+
+    @simple_low_season.includes_date?(high_season_date).should_not be_true
+    @simple_high_season.includes_date?(high_season_date).should be_true
+  end
+
+  it "should be able to tell the boundary range (the range including the absolute first and last date) of itself" do
+    @simple_low_season.boundary_range.should eql('2009-01-01'.to_date..'2009-09-30'.to_date)
+    @simple_high_season.boundary_range.should eql('2009-04-01'.to_date..'2009-12-31'.to_date)
+  end
+end
+
+
+describe Timely::Season, 'when asked to build season for given dates' do
+  before do
+    @dates = [Date.current + 1, Date.current + 4, Date.current + 5]
+  end
+
+  it "should generate proper season" do
+    season = Timely::Season.build_season_for(@dates)
+    season.class.should == Timely::Season
+    season.date_groups.size.should == 3
+    season.date_groups.first.start_date.should == (Date.current + 1)
+    season.date_groups.last.start_date.should == (Date.current + 5)
+    season.date_groups.last.end_date.should == (Date.current + 5)
+    @dates = []
+    season = Timely::Season.build_season_for(@dates)
+    season.class.should == Timely::Season
+    season.date_groups.size.should == 0
+  end
+
+
+
+end
+
+
+# == Schema Information
+#
+# Table name: seasons
+#
+#  id         :integer(4)      not null, primary key
+#  name       :string(255)
+#  created_at :datetime
+#  updated_at :datetime
+#
+

data/spec/spec_helper.rb

@@ -1,23 +1,46 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  gem 'rspec'
-  require 'spec'
-end
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
-# this is my favorite way to require ever
-begin
-  require 'mocha'
-rescue LoadError
-  require 'rubygems'
-  gem 'mocha'
-  require 'mocha'
-end
+require 'rubygems'
+require 'bundler/setup'
+require 'active_record'
+require 'timely/rails'
 
-Spec::Runner.configure do |config|
-  config.mock_with :mocha
+if ENV['COVERAGE']
+  require 'simplecov'
+  require 'simplecov-rcov'
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  SimpleCov.start do
+    add_filter '/vendor/'
+    add_filter '/spec/'
+    add_group 'lib', 'lib'
+  end
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    percent = SimpleCov.result.covered_percent
+    unless percent >= 50
+      puts "Coverage must be above 50%. It is #{"%.2f" % percent}%"
+      Kernel.exit(1)
+    end
+  end
 end
 
-$:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'timely'
+
+DB_FILE = 'tmp/test_db'
+FileUtils.mkdir_p File.dirname(DB_FILE)
+FileUtils.rm_f DB_FILE
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => DB_FILE
+
+load('spec/schema.rb')
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/string_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe String do
+  it "should convert to date" do
+    "10-2010-01".to_date('%d-%Y-%m').should eql Date.parse("2010-01-10")
+  end
+
+  # Spec currently doesn't work
+  #it 'should handle rails date formats' do
+  #  Date::DATE_FORMATS[:db] = '%m-%Y-%d'
+  #  "01-2010-10".to_date(:db).should eql Date.parse("2010-01-10")
+  #end
+end

data/spec/time_spec.rb

@@ -1,43 +1,62 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'spec_helper'
+
+describe Time do
+  it 'should be able to set date on a time' do
+    xmas = Date.new(2012, 12, 25)
+    lunch_time = Time.parse("12:00")
+    xmas_lunch = lunch_time.on_date(xmas)
+    xmas_lunch.year.should == 2012
+    xmas_lunch.month.should == 12
+    xmas_lunch.day.should == 25
+    xmas_lunch.hour.should == 12
+    xmas_lunch.min.should == 0
+    xmas_lunch.sec.should == 0
+  end
+
+  it "should allow setting the date part given a date" do
+    time = Time.parse("2010-01-01 09:30:00")
+    time.on_date(Date.parse("2012-12-31")).should eql Time.parse("2012-12-31 09:30:00")
+  end
+end
 
 describe Time do
   before :each do
     @time = Time.now - 12345
-    
+
     @year  = 2005
     @month = 3
     @day   = 15
   end
-  
+
   it 'should give that time on a date' do
     @time.should respond_to(:on_date)
   end
-  
+
   describe 'giving that time on a date' do
     it 'should accept year, month and day' do
       lambda { @time.on_date(@year, @month, @day) }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should require year, month, and day' do
       lambda { @time.on_date(@year, @month) }.should raise_error(ArgumentError)
     end
-    
+
     it 'should return the same time on the specified year, month, and day' do
       expected = Time.local(@year, @month, @day, @time.hour, @time.min, @time.sec)
       @time.on_date(@year, @month, @day).should == expected
     end
-    
+
     it 'should accept a date' do
       lambda { @time.on_date(Date.today) }.should_not raise_error(ArgumentError)
     end
-    
+
     it 'should return the same time on the specified date' do
       @date = Date.today - 2345
       expected = Time.local(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
       @time.on_date(@date).should == expected
     end
   end
-  
+
   it "should provide 'on' as an alias" do
     expected = Time.local(@year, @month, @day, @time.hour, @time.min, @time.sec)
     @time.on(@year, @month, @day).should == expected