serial-scheduler 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Andi Bade
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= serial-scheduler
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Andi Bade. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "serial-scheduler"
+    gem.summary = %Q{Schedule Task – execute all tasks at the same time one after another}
+    gem.description = %Q{Schedule Task – execute all tasks at the same time one after another}
+    gem.email = "andi@galaxycats.com"
+    gem.homepage = "http://github.com/thyphoon/serial-scheduler"
+    gem.authors = ["Andi Bade"]
+    gem.add_dependency "activesupport", "~> 3.0.0"
+    # gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "serial-scheduler #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/serial-scheduler.rb

@@ -0,0 +1 @@
+require "serial_scheduler"

data/lib/serial_scheduler.rb

@@ -0,0 +1,30 @@
+module SerialScheduler
+  
+  class <<self
+  
+    def define(environment_target, &block)
+      SerialScheduler::Dsl.new.instance_eval(&block) if !defined?(Rails) || environment_target == Rails.env.to_sym
+    end
+
+    def run(time = Time.now)
+      SerialScheduler::Runner.run(time)
+    end
+    
+    def dry_run(time = Time.now)
+      SerialScheduler::Runner.dry_run(time)
+    end
+    
+    if defined?(NewRelic)
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      add_transaction_tracer :run, :category => :task
+    end
+    
+  end
+  
+end
+
+require "serial_scheduler/date_day_names_core_extension"
+require "serial_scheduler/converter"
+require "serial_scheduler/dsl"
+require "serial_scheduler/runner"
+require "serial_scheduler/time_table"

data/lib/serial_scheduler/converter.rb

@@ -0,0 +1,70 @@
+class SerialScheduler::Converter
+  
+  class <<self
+    def to_datetime(string_or_time_or_datetime)
+      string_or_time_or_datetime.kind_of?(String) ?
+        DateTime.parse(string_or_time_or_datetime) :
+        string_or_time_or_datetime.to_datetime
+    end
+    
+    def hour_and_minute(time_or_datetime)
+      datetime = to_datetime(time_or_datetime)
+      formated_hour_and_minute_string(datetime.hour, datetime.min)
+    end
+    
+    def to_hour_and_minute(time_or_datetime)
+      hour_and_minute(time_or_datetime)
+    end
+  
+    def hour_and_minute_in_5_minute_steps(time_or_datetime)
+      datetime = to_datetime(time_or_datetime)
+      minutes = floor_to_five(datetime.min)
+      formated_hour_and_minute_string(datetime.hour, minutes)
+    end
+  
+    def weekday_hour_and_minute_in_5_minute_steps(time_or_datetime)
+      datetime = to_datetime(time_or_datetime)
+      "#{datetime.wday}:#{hour_and_minute_in_5_minute_steps(datetime)}"
+    end
+  
+    def floor_to_five(fixnum)
+      unit_digit = fixnum % 10
+      if unit_digit < 5
+        fixnum - unit_digit
+      else
+        fixnum - (unit_digit - 5)
+      end
+    end
+    
+    def formated_hour_and_minute_string(hours, minutes)
+      minutes = minutes < 10 ? "0#{minutes}" : "#{minutes}"
+      hours = hours < 10 ? "0#{hours}" : "#{hours}"
+      "#{hours}:#{minutes}"
+    end
+
+    def hours_between(from, to)
+      hours = []
+      for_each_hour(from,to) do |hour|
+        hours << hour
+      end
+      hours
+    end
+
+    def for_each_hour(from, to)
+      for_each_time_with_step(from, to, 1.hour) do |time|
+        yield(time)
+      end
+    end
+
+    def for_each_time_with_step(from, to, step)
+      current_time = DateTime.parse(from)
+      max_time = DateTime.parse(to)
+      max_time = max_time + 1.day if max_time <= current_time
+      while current_time <= max_time
+        yield(SerialScheduler::Converter.to_hour_and_minute(current_time))
+        current_time += step
+      end
+    end
+
+  end
+end

data/lib/serial_scheduler/date_day_names_core_extension.rb

@@ -0,0 +1,7 @@
+Date::DAYNAMES.each_with_index do |dayname, idx|
+  Date.const_set(dayname.upcase, idx)
+end
+
+def Date.human_wday(number)
+  Date::DAYNAMES[number].to_s.capitalize
+end

data/lib/serial_scheduler/dsl.rb

@@ -0,0 +1,109 @@
+class SerialScheduler::Dsl
+
+  class CallWrapper
+    attr_reader :callee, :meth
+    def initialize(callee, meth)
+      @callee = callee
+      @meth = meth
+    end
+    
+    def call
+      instance_to_call = callee.kind_of?(String) ? callee.constantize : callee
+      instance_to_call.send(meth)
+    end
+    
+    def to_s
+      "#{callee}.#{meth}"
+    end
+  end
+  
+  attr_accessor :callee
+  
+  
+  # How to use the scheduler
+  #
+  # With the scheduler DSL you can define jobs in a simple language
+  # 
+  # Example:
+  #   
+  #   schedule AnyReceiver do
+  #     some_method { every :hour }
+  #     some_other_method { every 2.hours, :from => "9:00", :to => "18:00" }
+  #     and_another_method { every :friday, :at => "3:00" }
+  #   end
+  
+  def schedule(callee, &block)
+    self.callee = callee
+    self.instance_eval(&block)
+  end
+  
+  def every(*args)
+    case args.first
+    when Symbol
+      time_keys_by_symbol(*args)
+    when ActiveSupport::Duration
+      time_keys_by_duration(*args)
+    else
+      raise "SerialScheduler::Dsl - every - You have to specify either a symbol or a duration (was #{args.first.inspect})"
+    end
+  end
+  
+  def time_keys_by_symbol(*args)
+    time_keys = []
+    options = args.extract_options!
+    case args.first
+    when :hour
+      from, to = extract_from_to_or_default(options)
+      time_keys = SerialScheduler::Converter.hours_between(from, to)
+    when :day
+      time_keys = extract_at_or_default(options)
+    else
+      at = extract_at_or_default(options)
+      day = args.first
+      if [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday].include?(day)
+        time_keys << "#{Date.const_get(day.to_s.upcase)}:#{at}"
+      end
+    end
+    return time_keys
+  end
+  
+  def time_keys_by_duration(*args)
+    options = args.extract_options!
+    from, to = extract_from_to_or_default(options)
+    step = args.first
+    time_keys = []
+    SerialScheduler::Converter.for_each_time_with_step(from, to, step) do |time_key|
+      time_keys << time_key
+    end
+    time_keys
+  end
+  
+  def extract_from_to_or_default(options)
+    options ||= {}
+    from = options[:from] ? SerialScheduler::Converter.to_hour_and_minute(options[:from]) : "00:00"
+    to = options[:to] ? SerialScheduler::Converter.to_hour_and_minute(options[:to]) : "23:59"
+    return from, to
+  end
+  
+  def extract_at_or_default(options)
+    options ||= {}
+    options[:at] ? SerialScheduler::Converter.to_hour_and_minute(options[:at]) : "00:00"
+  end
+  
+  def create_time_table_with_time_keys(time_keys, callee, meth)
+    time_keys.inject({}) do |time_table, time_key|
+      time_table[time_key] = CallWrapper.new(callee, meth)
+      time_table
+    end
+  end
+  
+  def method_missing(meth, *args, &blk)
+    if block_given?
+      time_keys = instance_eval(&blk)
+      SerialScheduler::TimeTable.add(create_time_table_with_time_keys(time_keys, self.callee, meth))
+    else
+      super
+    end
+  end
+  
+end

data/lib/serial_scheduler/runner.rb

@@ -0,0 +1,32 @@
+class SerialScheduler::Runner
+  
+  class <<self
+  
+    def run(time, options = {})
+      daily_time_key = SerialScheduler::Converter.hour_and_minute_in_5_minute_steps(time)
+      weekly_time_key = SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps(time)
+      jobs = SerialScheduler::TimeTable.jobs_for([weekly_time_key, daily_time_key].compact)
+      jobs.each do |job|
+        begin
+          if options[:dry_run]
+            puts ">> #{job}"
+          else
+            job.call
+          end
+        rescue => e
+          if defined?(Rails)
+            raise e if Rails.env.development?
+            Notifier.deliver_scheduler_error(e, job, time)
+          end
+        end
+      end
+    end
+
+    def dry_run(time)
+      run(time, :dry_run => true)
+      puts ">> end"
+    end
+    
+  end
+  
+end

data/lib/serial_scheduler/time_table.rb

@@ -0,0 +1,74 @@
+require 'singleton'
+
+class SerialScheduler::TimeTable
+  include Singleton
+  
+  attr_reader :timing
+  
+  def initialize
+    @timing = {}
+  end
+  
+  class <<self
+    def jobs_for(*time_keys)
+      [time_keys].flatten.collect do |time_key|
+        timing[time_key]
+      end.flatten.compact
+    end
+    
+    def method_missing(meth, *args, &blk)
+      if self.instance.respond_to?(meth)
+        self.instance.send(meth, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+
+  def add(hash_with_timing_info)
+    hash_with_timing_info.each do |timing_key, calls|
+      self.timing[timing_key] ||= []
+      self.timing[timing_key] += [calls].flatten
+    end
+  end
+  
+  def clear
+    self.timing = {}
+  end
+  
+  def weekly_timing
+    timing.reject { |time_key, call| time_key.size != 7 }
+  end
+  
+  def daily_timing
+    timing.reject { |time_key, call| time_key.size != 5 }
+  end
+  
+  def print
+    print_daily_timing
+    print_weekly_timing
+  end
+  
+  def print_daily_timing
+    puts
+    puts "daily timing"
+    puts "-"*15
+    daily_timing.keys.sort.each do |time_key|
+      scheduled_calls = timing[time_key]
+      puts "#{time_key} |\t#{scheduled_calls.join("\n\t")}"
+    end
+  end
+  
+  def print_weekly_timing
+    puts
+    puts "weekly timing"
+    puts "-"*15
+    weekly_timing.keys.sort.each do |time_key|
+      scheduled_calls = timing[time_key]
+      puts "#{Date.human_wday(time_key.first.to_i)}, #{time_key[2..-1]} |\t#{scheduled_calls.join("\n\t")}"
+    end
+  end
+  
+  private
+    attr_writer :timing
+end

data/serial-scheduler.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{serial-scheduler}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andi Bade"]
+  s.date = %q{2011-02-28}
+  s.description = %q{Schedule Task – execute all tasks at the same time one after another}
+  s.email = %q{andi@galaxycats.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/serial-scheduler.rb",
+     "lib/serial_scheduler.rb",
+     "lib/serial_scheduler/converter.rb",
+     "lib/serial_scheduler/date_day_names_core_extension.rb",
+     "lib/serial_scheduler/dsl.rb",
+     "lib/serial_scheduler/runner.rb",
+     "lib/serial_scheduler/time_table.rb",
+     "serial-scheduler.gemspec",
+     "test/converter_test.rb",
+     "test/dsl_test.rb",
+     "test/runner_test.rb",
+     "test/serial_scheduler_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/thyphoon/serial-scheduler}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Schedule Task – execute all tasks at the same time one after another}
+  s.test_files = [
+    "test/converter_test.rb",
+     "test/dsl_test.rb",
+     "test/runner_test.rb",
+     "test/serial_scheduler_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
+    else
+      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+  end
+end
+

data/test/converter_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class ConverterTest < ActiveSupport::TestCase
+  
+  test "should calculate hour and minute string floored in 5 minute steps" do
+    assert_equal "11:55", SerialScheduler::Converter.hour_and_minute_in_5_minute_steps("17.12.2010 11:59".to_datetime)
+    assert_equal "12:00", SerialScheduler::Converter.hour_and_minute_in_5_minute_steps("17.12.2010 12:00".to_datetime)
+    assert_equal "12:00", SerialScheduler::Converter.hour_and_minute_in_5_minute_steps("17.12.2010 12:04".to_datetime)
+    assert_equal "12:05", SerialScheduler::Converter.hour_and_minute_in_5_minute_steps("17.12.2010 12:05".to_datetime)
+    assert_equal "12:05", SerialScheduler::Converter.hour_and_minute_in_5_minute_steps("17.12.2010 12:06".to_datetime)
+  end
+
+  test "should calculate weekday, hour and minute string floored in 5 minute steps" do
+    assert_equal "#{Date::FRIDAY}:11:55", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("17.12.2010 11:59".to_datetime)
+    assert_equal "#{Date::SATURDAY}:12:00", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("18.12.2010 12:00".to_datetime)
+    assert_equal "#{Date::SUNDAY}:12:00", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("19.12.2010 12:04".to_datetime)
+    assert_equal "#{Date::MONDAY}:12:05", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("20.12.2010 12:05".to_datetime)
+    assert_equal "#{Date::TUESDAY}:12:05", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("21.12.2010 12:06".to_datetime)
+    assert_equal "#{Date::WEDNESDAY}:14:05", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("22.12.2010 14:06".to_datetime)
+    assert_equal "#{Date::THURSDAY}:18:05", SerialScheduler::Converter.weekday_hour_and_minute_in_5_minute_steps("23.12.2010 18:06".to_datetime)
+  end
+
+  test "should round (floor) numbers in steps of 5" do
+    assert_equal 0, SerialScheduler::Converter.floor_to_five(1)
+    assert_equal 0, SerialScheduler::Converter.floor_to_five(4)
+    assert_equal 5, SerialScheduler::Converter.floor_to_five(5)
+    assert_equal 5, SerialScheduler::Converter.floor_to_five(6)
+    assert_equal 5, SerialScheduler::Converter.floor_to_five(9)
+    assert_equal 10, SerialScheduler::Converter.floor_to_five(10)
+    assert_equal 10, SerialScheduler::Converter.floor_to_five(11)
+  end
+  
+  test "should format hour and minute as a string with two and two digits" do
+    assert_equal "01:09", SerialScheduler::Converter.formated_hour_and_minute_string(1, 9)
+    assert_equal "12:00", SerialScheduler::Converter.formated_hour_and_minute_string(12, 0)
+    assert_equal "14:03", SerialScheduler::Converter.formated_hour_and_minute_string(14, 3)
+    assert_equal "23:59", SerialScheduler::Converter.formated_hour_and_minute_string(23, 59)
+  end
+  
+  test "should return an array with all hours between two hours" do
+    assert_equal ["23:00", "00:00", "01:00", "02:00"], SerialScheduler::Converter.hours_between("23:00", "02:00")
+    assert_equal ["03:00", "04:00", "05:00", "06:00", "07:00", "08:00", "09:00", "10:00", "11:00", "12:00", "13:00", "14:00",
+      "15:00", "16:00", "17:00", "18:00", "19:00", "20:00", "21:00", "22:00", "23:00", "00:00", "01:00", "02:00", "03:00"], SerialScheduler::Converter.hours_between("03:00", "03:00")
+    assert_equal ["03:00", "04:00"], SerialScheduler::Converter.hours_between("03:00", "04:00")
+    assert_equal ["03:00"], SerialScheduler::Converter.hours_between("03:00", "03:01")
+    assert_equal ["08:00", "09:00", "10:00", "11:00", "12:00", "13:00"], SerialScheduler::Converter.hours_between("08:00", "13:00")
+  end
+  
+  
+end

data/test/dsl_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class DslTest < ActiveSupport::TestCase
+  
+  test "should create time keys by symbol :hour" do
+    assert_equal ["00:00", "01:00", "02:00", "03:00", "04:00", "05:00", "06:00", "07:00", "08:00", "09:00", "10:00", "11:00",
+     "12:00", "13:00", "14:00", "15:00", "16:00", "17:00", "18:00", "19:00", "20:00", "21:00", "22:00", "23:00"], SerialScheduler::Dsl.new.time_keys_by_symbol(:hour)
+    
+    assert_equal ["08:00", "09:00", "10:00", "11:00", "12:00", "13:00",
+      "14:00", "15:00", "16:00", "17:00", "18:00", "19:00", "20:00"], SerialScheduler::Dsl.new.time_keys_by_symbol(:hour, :from => "8:00", :to => "20:00")
+  end
+  
+  test "should create time keys by time step size (duration)" do
+    expected_time_keys = []
+    SerialScheduler::Converter.for_each_time_with_step("00:00", "23:55", 5.minutes) { |time_key| expected_time_keys << time_key }
+    assert_equal expected_time_keys, SerialScheduler::Dsl.new.time_keys_by_duration(5.minutes)
+    
+    assert_equal ["11:23", "11:28", "11:33"], SerialScheduler::Dsl.new.time_keys_by_duration(5.minutes, :from => "11:23", :to => "11:37")
+  end
+  
+  test "should create time key for a day symbol with 'at' condition" do
+    assert_equal ["5:00:00"], SerialScheduler::Dsl.new.time_keys_by_symbol(:friday)
+  end
+  
+  test "should extract from and to from options or return defaults" do
+    dsl = SerialScheduler::Dsl.new
+    assert_equal ["08:00", "09:00"], dsl.extract_from_to_or_default({:from => "8:00", :to => "9:00"})
+    assert_equal ["12:00", "13:00"], dsl.extract_from_to_or_default({:from => "12:00", :to => "13:00"})
+    assert_equal ["00:00", "23:59"], dsl.extract_from_to_or_default(nil)
+  end
+
+  test "should extract at from options or return default" do
+    dsl = SerialScheduler::Dsl.new
+    assert_equal "00:00", dsl.extract_at_or_default({:at => "0:00"})
+    assert_equal "12:00", dsl.extract_at_or_default({:at => "12:00"})
+    assert_equal "00:00", dsl.extract_at_or_default(nil)
+  end
+
+  test "should create time stamps for every :day" do
+    assert_equal "03:00", SerialScheduler::Dsl.new.time_keys_by_symbol(:day, :at => "3:00")
+  end
+  
+end

data/test/runner_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class RunnerTest < ActiveSupport::TestCase
+  
+  class MockReceiver; end
+  
+  def setup
+    SerialScheduler::TimeTable.clear
+    SerialScheduler.define :test do
+      schedule RunnerTest::MockReceiver do
+        lastminute   { every :hour,   :from => "8:00", :to => "20:00" }
+        availability { every 2.hours, :from => "0:00", :to => "4:00" }
+        houses       { every :monday, :at => "0:00" }
+      end
+    end
+  end
+  
+  test "should run all relevant jobs for given time" do
+    MockReceiver.expects(:houses)
+    MockReceiver.expects(:availability)
+    SerialScheduler::Runner.run("27.12.2010 00:00".to_datetime)
+  end
+  
+  test "should dry-run all relevant jobs for given time" do
+    MockReceiver.expects(:houses).never
+    MockReceiver.expects(:availability).never
+    SerialScheduler::Runner.dry_run("27.12.2010 00:00".to_datetime)
+  end
+  
+  test "should catch all exceptions during job execution and send an email to developers" do
+    if defined?(Rails)
+      MockReceiver.expects(:lastminute).raises(ArgumentError, "Hello from test")
+      Notifier.expects(:deliver_scheduler_error)
+      SerialScheduler::Runner.run("27.12.2010 8:00".to_datetime)
+    end
+  end
+  
+end

data/test/serial_scheduler_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class SerialSchedulerTest < ActiveSupport::TestCase
+  
+  def setup
+    SerialScheduler::TimeTable.clear
+  end
+
+  test "should evaluate a definition with every hour" do
+    SerialScheduler.define :test do
+      schedule "some importer" do
+        lastminute { every :hour }
+      end
+    end
+    assert_equal(
+      ["00:00", "01:00", "02:00", "03:00", "04:00", "05:00", "06:00", "07:00", "08:00", "09:00", "10:00", "11:00",
+       "12:00", "13:00", "14:00", "15:00", "16:00", "17:00", "18:00", "19:00", "20:00", "21:00", "22:00", "23:00"],
+      SerialScheduler::TimeTable.timing.keys.sort
+    )
+    SerialScheduler::TimeTable.timing.values.each do |vals|
+      assert_kind_of Array, vals
+      assert vals.all? { |val| val.kind_of?(SerialScheduler::Dsl::CallWrapper) }
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'active_support/core_ext'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'serial-scheduler'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: serial-scheduler
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andi Bade
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-28 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: "Schedule Task \xE2\x80\x93 execute all tasks at the same time one after another"
+email: andi@galaxycats.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/serial-scheduler.rb
+- lib/serial_scheduler.rb
+- lib/serial_scheduler/converter.rb
+- lib/serial_scheduler/date_day_names_core_extension.rb
+- lib/serial_scheduler/dsl.rb
+- lib/serial_scheduler/runner.rb
+- lib/serial_scheduler/time_table.rb
+- serial-scheduler.gemspec
+- test/converter_test.rb
+- test/dsl_test.rb
+- test/runner_test.rb
+- test/serial_scheduler_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/thyphoon/serial-scheduler
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: "Schedule Task \xE2\x80\x93 execute all tasks at the same time one after another"
+test_files: 
+- test/converter_test.rb
+- test/dsl_test.rb
+- test/runner_test.rb
+- test/serial_scheduler_test.rb
+- test/test_helper.rb