runt19 0.7.6

data/test/scheduletest.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+require 'date'
+
+# Unit tests for Schedule classes
+# Author:: Matthew Lipper
+class ScheduleTest < Test::Unit::TestCase
+
+  include Runt
+
+  def setup
+    # Jane is very busy these days.
+    @sched=Schedule.new
+    # Elmo's World is on TV: Mon-Fri 8am-8:30am
+    @elmo=Event.new("Elmo's World")
+    @elmo_broadcast=(REWeek.new(Mon,Fri) & REDay.new(8,00,8,30))
+    @sched.add(@elmo,@elmo_broadcast)
+    #Oobi's on TV: Thu-Sat 8:30am-9am
+    @oobi=Event.new("Oobi")
+    @oobi_broadcast=(REWeek.new(Thu,Sat) & REDay.new(8,30,9,00))
+    @sched.add(@oobi,@oobi_broadcast)
+    @during_elmo=PDate.new(2004,5,4,8,06)
+    @not_during_elmo=PDate.new(2004,5,1,8,06)
+    @during_oobi=PDate.new(2004,4,30,8,56)
+    @not_during_oobi=PDate.new(2004,5,1,8,12)  
+  end
+
+  def test_include
+    # Check Elmo
+    assert(@sched.include?(@elmo, @during_elmo))
+    assert(!@sched.include?(@elmo,@not_during_elmo))
+    assert(!@sched.include?(@elmo,@during_oobi))
+    # Check Oobi
+    assert(@sched.include?(@oobi, @during_oobi))
+    assert(!@sched.include?(@oobi,@not_during_oobi))
+    assert(!@sched.include?(@oobi,@not_during_elmo))
+  end
+
+  def test_select_all
+    # select all
+    all=@sched.select {|ev,xpr| true; }
+    assert all.size==2
+    assert all.include?(@elmo)
+    assert all.include?(@oobi)
+  end
+
+  def test_select_none
+      # select none
+    assert((@sched.select {|ev,xpr| false; }).size==0)
+  end
+
+  def test_select_some
+    # select oobi only 
+    some=@sched.select {|ev,xpr| @oobi.eql?(ev); }
+    assert some.size==1
+    assert !some.include?(@elmo)
+    assert some.include?(@oobi)
+    some.clear
+    # select elmo only 
+    some=@sched.select {|ev,xpr| @elmo.eql?(ev); }
+    assert some.size==1
+    assert some.include?(@elmo)
+    assert !some.include?(@oobi)
+  end
+
+  def test_events
+    events=@sched.events(PDate.new(2006,12,4,11,15))
+    assert_equal 0,events.size
+    # The Barney power hour which overlaps with Elmo
+    barney=Event.new("Barney")
+    @sched.add(barney,REDay.new(7,30,8,30))
+    events=@sched.events(PDate.new(2006,12,4,8,15))
+    assert_equal 2,events.size
+    assert events.include?(barney)
+    assert events.include?(@elmo)
+  end
+
+  def test_update
+    @sched.update(Event.new("aaa")){|ev|assert_nil(ev)}
+    @sched.update(@elmo){|ev|assert_equal(@elmo_broadcast,ev)}
+    @sched.update(@oobi){|ev|assert_equal(@oobi_broadcast,ev)}
+  end
+
+  def test_select_old
+    @sched=Schedule.new
+    e1=Event.new("e1")
+    assert(!@sched.include?(e1,nil))
+    range=RSpec.new(DateRange.new(PDate.new(2006,12,3),PDate.new(2007,1,24)))
+    in_range=PDate.new(2007,1,4)
+    assert(range.include?(in_range))
+    out_of_range=PDate.new(2006,1,4)
+    assert(!range.include?(out_of_range))
+    @sched.add(e1,range)
+    assert(@sched.include?(e1,in_range))
+    assert(!@sched.include?(e1,out_of_range))
+  end
+
+  def test_dates
+    # range: May 1st, 2004 to May 31st, 2004
+    d_range = DateRange.new(PDate.day(2004,5,1), PDate.day(2004,5,31))
+    @sched = Schedule.new
+    event = Event.new("Visit Ernie")
+    # First and last Friday of the month
+    expr1 = DIMonth.new(1,Fri) |  DIMonth.new(-1,Fri)
+    @sched.add(event,expr1)
+    dates = @sched.dates(event,d_range)
+    expected = [PDate.day(2004,5,7), PDate.day(2004,5,28)]
+    assert_equal(expected,dates)
+  end
+
+  def test_using_a_schedule
+        
+    # September 18th - 19th, 2005, 8am - 10am 
+    expr1=RSpec.new(DateRange.new(PDate.day(2005,9,18),PDate.day(2005,9,19))) & REDay.new(8,0,10,0)
+    assert(expr1.include?(PDate.min(2005,9,18,8,15)))
+    # September 19th - 20th, 2005, 9am - 11am 
+    expr2=RSpec.new(DateRange.new(PDate.day(2005,9,19),PDate.day(2005,9,20))) & REDay.new(9,0,11,0) 
+    # Quick sanuty check
+    assert(expr1.overlap?(expr2))
+    # Setup a @schedule w/first expression
+    @sched = Schedule.new
+    @sched.add(Event.new("Snafubar Opening"),expr1)
+    resource = Resource.new(@sched)
+    # Add a another overlapping event 
+    resource.add_event(Event.new("Yodeling Lesson"),expr2)
+    # Create a new resource using the same schedule
+    resource2 = Resource.new(@sched)
+    # Add a another overlapping event and pass a block which should complain
+    #resource.add_event(Event.new("Yodeling Lesson"),expr2) \
+    #{|e,s| raise "Resource not available at requested time(s)." \
+    #  if (@schedule.overlap?(s))} 
+  end
+end
+
+class Resource
+  def initialize(schedule)
+    @schedule=schedule
+  end
+  def add_event(event,expr)
+    if(block_given?) 
+      yield(event,expr) 
+    else
+      @schedule.add(event,expr) 
+    end
+  end
+end

data/test/spectest.rb

@@ -0,0 +1,36 @@
+
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for Spec class
+# Author:: Matthew Lipper
+
+class SpecTest < BaseExpressionTest
+
+  def setup
+    super
+    @spec = Spec.new(@stub1)
+  end
+
+  def test_initialize
+    assert_same @stub1, @spec.date_expr, "Expected #{@stub1}, instead got #{@spec.date_expr}"
+  end
+
+  def test_include_arg_has_include_method
+    assert !@spec.include?(@stub2), "Expression should not include configured stub"
+    @stub2.match = true
+    assert @spec.include?(@stub2), "Expression should include configured stub"
+  end
+
+  def test_include_arg_without_include_method
+    @spec = Spec.new(4)
+    assert !@spec.include?(3), "Expression #{@spec.to_s} should not include 3"
+    assert @spec.include?(4), "Expression #{@spec.to_s} should include 4"
+  end 
+
+  def test_to_s
+    assert_equal @stub1.to_s, @spec.to_s
+  end
+
+end

data/test/sugartest.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+require 'runt/sugar'
+
+class SugarTest < Test::Unit::TestCase
+  include Runt
+
+  def test_build__should_return_nil_when_an_unknown_name_is_given
+    assert self.build('duh').nil?
+  end
+
+  def test_method_missing_should_be_called_for_invalid_name
+    begin
+      self.some_tuesday
+    rescue NoMethodError
+      # YAY!
+    end
+  end
+
+  def test_const_should_return_runt_constant
+    assert_equal Runt::Monday, Runt.const('monday'), \
+      "Expected #{Runt::Monday} but was #{Runt.const('monday')}"
+  end
+  
+  def test_method_missing_should_define_dimonth
+      make_ordinals.each do |ordinal|
+        make_days.each do |day|
+	  name = ordinal + '_' + day
+	  result = self.send(name)
+	  expected = DIMonth.new(Runt.const(ordinal), Runt.const(day))
+	  assert_expression expected, result
+	end
+      end
+  end
+  
+  def test_method_missing_should_define_diweek
+    assert_expression(DIWeek.new(Monday), self.monday)
+    assert_expression(DIWeek.new(Tuesday), self.tuesday)
+    assert_expression(DIWeek.new(Wednesday), self.wednesday)
+    assert_expression(DIWeek.new(Thursday), self.thursday)
+    assert_expression(DIWeek.new(Friday), self.friday)
+    assert_expression(DIWeek.new(Saturday), self.saturday)
+    assert_expression(DIWeek.new(Sunday), self.sunday)
+  end
+
+  def test_parse_time
+    assert_equal [13,2], parse_time('1','02','pm')
+    assert_equal [1,2], parse_time('1','02','am')
+  end
+
+  def test_method_missing_should_define_re_day
+    assert_expression(REDay.new(8,45,14,00), daily_8_45am_to_2_00pm)
+  end
+
+  def test_method_missing_should_define_re_week
+    make_days.each do |st_day|
+      make_days.each do |end_day|
+	if Runt.const(st_day) <= Runt.const(end_day) then
+	  assert_expression REWeek.new(Runt.const(st_day), \
+	      Runt.const(end_day)), self.send('weekly_' + st_day + '_to_' + end_day)
+	end
+      end
+    end
+  end
+
+  def test_method_missing_should_define_re_month
+    assert_expression(REMonth.new(3,14), monthly_3rd_to_14th)
+  end
+  def test_method_missing_should_define_re_year
+    # Imperfect but "good enough" for now
+    make_months.each do |st_month|
+      make_months.each do |end_month|
+	st_mon_number = Runt.const(st_month)
+	end_mon_number = Runt.const(end_month)
+	next if st_mon_number > end_mon_number
+	st_day = rand(27) + 1
+	end_day = rand(27) + 1
+        if st_mon_number == end_mon_number && st_day > end_day then
+	  st_day, end_day = end_day, st_day
+	end	  
+	#puts "Checking #{st_month} #{st_day} - #{end_month} #{end_day}"
+	assert_expression REYear.new(st_mon_number, st_day, end_mon_number, end_day), \
+	  self.send('yearly_' + st_month + '_' + st_day.to_s + '_to_' + end_month + '_' + end_day.to_s)
+      end
+    end
+  end
+
+  private 
+  def assert_expression(expected, actual)
+    assert_equal expected.to_s, actual.to_s, \
+      "Expected #{expected.to_s} but was #{actual.to_s}"
+  end
+  def make_ordinals
+    Runt::WEEK_OF_MONTH_ORDINALS.delete('()').split('|')
+  end
+  def make_days
+    Runt::DAYS.delete('()').split('|')
+  end
+  def make_months
+    Runt::MONTHS.delete('()').split('|')
+  end
+end

data/test/temporalexpressiontest.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for TExpr classes
+# Author:: Matthew Lipper
+
+class TExprTest < BaseExpressionTest
+
+  include TExpr
+
+  def test_include
+    assert !self.include?(true), "Default include? method should always return false"
+  end
+
+  def test_to_s
+    assert_equal self.to_s, 'TExpr', "Default to_s method should always return 'TExpr'"
+  end
+
+  def test_or_from_union
+    union = Union.new
+    same_union = union.or(@stub1)
+    assert_same union, same_union, "Expected same Union instance that received the or method"
+    assert_same @stub1, union.expressions.first, "Union instance should have added the stub expression"
+  end
+
+  def test_or_from_nonunion
+    result = @stub1.or(@stub2) {|e| e}
+    assert_equal Runt::Union, result.class, "Expected an Union instance. Instead got #{result.class}"
+    assert_same @stub1, result.expressions.first, "Result should be new Union instance containing both stub expressions"
+    assert_same @stub2, result.expressions.last, "Result should be new Union instance containing both stub expressions"
+  end
+
+  def test_and_from_intersect
+    intersect = Intersect.new
+    result = intersect.and(@stub1)
+    assert_same intersect, result, "Expected same Intersect instance that received the and method"
+    assert_same @stub1, intersect.expressions.first, "Intersect instance should have added the stub expression"
+  end
+
+  def test_or_from_nonintersect
+    result = @stub1.and(@stub2) {|e| e}
+    assert_equal Runt::Intersect, result.class, "Expected an Intersect instance. Instead got #{result.class}"
+    assert_same @stub1, result.expressions.first, "Result should be new Intersect instance containing both stub expressions"
+    assert_same @stub2, result.expressions.last, "Result should be new Intersect instance containing both stub expressions"
+  end
+
+  def test_minus
+    result = @stub1.minus(@stub2) {|e| e}
+    assert_equal Runt::Diff, result.class, "Expected an Diff instance. Instead got #{result.class}"
+    assert_same @stub1, result.expr1, "Expected first stub instance used to create Diff expression"
+    assert_same @stub2, result.expr2, "Expected second stub instance used to create Diff expression"
+  end
+
+  def test_dates_no_limit
+    # Normally, your range is made up of Date-like Objects
+    range = 1..3
+    assert @stub1.dates(range).empty?, "Expected empty Array of Objects returned from stub expression"
+    @stub1.match = true
+    result = @stub1.dates(range)
+    assert_equal 1, result[0], "Expected Array of Objects given by range to be returned from stub expression"
+    assert_equal 2, result[1], "Expected Array of Objects given by range to be returned from stub expression"
+    assert_equal 3, result[2], "Expected Array of Objects given by range to be returned from stub expression"
+  end
+
+  def test_dates_with_limit
+    range = 1..3
+    assert @stub1.dates(range).empty?, "Expected empty Array of Objects returned from stub expression"
+    @stub1.match = true
+    result = @stub1.dates(range,2)
+    assert_equal 2, result.size, "Expected Array of only 2 Objects. Got #{result.size}"
+    assert_equal 1, result[0], "Expected Array of Objects given by range to be returned from stub expression"
+    assert_equal 2, result[1], "Expected Array of Objects given by range to be returned from stub expression"
+  end
+
+end

data/test/uniontest.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for Union class
+# Author:: Matthew Lipper
+
+class UnionTest < BaseExpressionTest
+
+  def setup
+    super
+    @union = Union.new
+    @date = @pdate_20071028
+  end
+
+  def test_include
+    assert !@union.include?(@date), "Empty Union instance should not include any dates"
+    @union.add(@stub1).add(@stub2) # both expressions will return false
+    assert !@union.include?(@date), "Union instance should not include any dates"
+    @stub2.match = true
+    assert @union.include?(@date), "Union instance should include any dates"
+    @stub2.match = false
+    @stub1.match = true
+    assert @union.include?(@date), "Union instance should include any dates"
+
+  end
+  
+  def test_to_s
+    assert_equal 'empty', @union.to_s
+    @union.add(@stub1)
+    assert_equal 'every ' + @stub1.to_s, @union.to_s
+    @union.add(@stub2)
+    assert_equal 'every ' + @stub1.to_s + ' or ' + @stub2.to_s, @union.to_s
+  end
+  
+end

data/test/wimonthtest.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for WIMonth class
+# Author:: Matthew Lipper
+
+class WIMonthTest < BaseExpressionTest
+
+  def setup
+    super
+    @date_range = @date_20050101..@date_20050228
+  end
+
+
+  def test_second_week_in_month
+    expr = WIMonth.new(Second)
+    assert expr.include?(@pdate_20071008), "#{expr.to_s} should include #{@pdate_20071008.to_s}"
+    assert !expr.include?(@pdate_20071030), "#{expr.to_s} should not include #{@pdate_20071030.to_s}"
+  end
+
+  def test_last_week_in_month 
+    expr = WIMonth.new(Last_of)
+    # Make sure of day precision or things will be unusably slow!
+    assert expr.include?(@pdate_20071030), "#{expr.to_s} should include #{@pdate_20071030.to_s}"
+    assert !expr.include?(@pdate_20071008), "#{expr.to_s} should not include #{@pdate_20071008.to_s}"
+  end
+  
+  def test_second_to_last_week_in_month
+    expr = WIMonth.new(Second_to_last)
+    # Make sure of day precision or things will be unusably slow!
+    assert expr.include?(@pdate_20071024), "#{expr.to_s} should include #{@pdate_20071024}"
+    assert !expr.include?(@pdate_20071008), "#{expr.to_s} should not include #{@pdate_20071008}"
+  end
+
+  def test_dates_mixin_second_week_in_month
+    dates = WIMonth.new(Second).dates(@date_range)
+    assert dates.size == 14, "Expected 14 dates, was #{dates.size}"
+    assert dates.first.mday == 8, "Expected first date.mday to be 8, was #{dates.first.mday}" 
+    assert dates.last.mday == 14, "Expected last date.mday to be 14, was #{dates.last.mday}"
+  end
+
+  def test_dates_mixin_last_week_in_month
+    dates = WIMonth.new(Last).dates(@date_range)
+    assert dates.size == 14, "Expected 14 dates, was #{dates.size}"
+    assert dates.first.mday == 25, "Expected first date.mday to be 25, was #{dates.first.mday}"
+    assert dates.last.mday == 28, "Expected last date.mday to be 28, was #{dates.last.mday}" 
+  end
+
+  def test_week_in_month_to_s
+    assert_equal 'last week of any month', WIMonth.new(Last).to_s
+  end
+
+end