lucid_works 0.6.14 → 0.6.15

data/lib/lucid_works/collection/activity.rb

@@ -1,15 +1,19 @@
 require 'active_support/core_ext/numeric/time.rb'
 module LucidWorks
-  class Collection < Base
+  class Collection
     class Activity < Base
       TYPES = %w{ optimize spelling click autocomplete}
 
+      # Unlike Datasource schedules, the API allows multiples of these
+      # So, to be honest with gem users, we can't really say this:
+        # self.singleton = true
       belongs_to :collection
       has_many   :histories, :class_name => :history
       has_one    :status
 
       schema do
-        attributes :start_time, :period
+        attribute :period
+        attribute :start_time, :iso8601
         attribute :active, :boolean
         attribute :type, :string, :values => TYPES, :omit_during_update => true
       end
@@ -17,6 +21,151 @@ module LucidWorks
       validates_presence_of :type, :start_time
       validates_numericality_of :period, :allow_blank => true
 
+      def frequency
+        case period
+        when 1.weeks.seconds then 'weekly'
+        when 1.days.seconds then 'daily'
+        when 1.hours.seconds then 'hourly'
+        when 0 then nil
+        else 'custom'
+        end
+      end
+      
+      #
+      # accepts hourly, daily, weekly, and sets period to respective # of seconds
+      #
+      def frequency=(frequency)
+        self.period = case frequency
+        when 'hourly' then 1.hours.seconds
+        when 'daily' then 1.days.seconds
+        when 'weekly' then 1.weeks.seconds
+        else raise "unknown frequency"
+        end
+      end
+      
+      #
+      # predict when action will occur next if active at that time
+      #
+      def next_start
+        return start_time if (now = Time.now) <= start_time 
+        # require 'ruby-debug'; debugger
+        time_since_start = now - start_time
+        last_interval_num = (time_since_start / period).to_i
+        next_interval_num =  if (time_since_start % period) == 0
+          # this is sort of a stupid condition b/c time precision is millisecond or less
+          # for human purposes we wouldn't care if the result were as though the call 
+          # happened a millisecond later. But whatever.
+          last_interval_num # the next interval *is* the last interval if it is exactly now
+        else
+          last_interval_num + 1
+        end
+        start_time + period * next_interval_num
+      end
+      
+      #
+      # phantom attribute for compiling real start time and frequency from appropriate form data
+      # Allows the user to specify a schedule simply with repeat interval (hourly, daily, weekly)
+      # and time within the interval to run (e.g 5 past, or Tuesdays at 2:15)
+      # 
+      # We have to figure out when the actual start time will be because we are not asking 
+      # the user for this. It needs to be:
+      #   * at the requested time relative to the interval chosen
+      #   * as soon as possible
+      #   * in the future
+      #
+      # This is obvious to humans, but when computing it, you run into the following problem. It
+      # happens with all interval sizes, but for the sake of example, we'll use weekly:
+      #
+      # Problem 1) If today is Thursday, and the user asks for "weekly on Wednesdays," Wednesday has
+      # already happened this week. We have to make sure we pick the nearest wednesday that is in 
+      # the future
+      #
+      # Problem 2) If today is Tuesday, and the user asks for "weekly on Wednesdays,", the simple solution
+      # to problem 1 (start next week instead of this week) causes you to skip this Tuesday, even though
+      # it is valid and is what the user would expect
+      #
+      # The algorith to solve both problems at once is this: 
+      #    * From Time.now, back up to the beginning of the interval even if it is in the past. 
+      #    * Fast forward to the requested siimple start time
+      #    * If you are still in the past, advance by one interval
+      #
+      def schedule=(all_attributes)
+        # convert to format accepted by Time.advance
+        if all_attributes['start']
+          all_attributes['start'].to_options!
+          all_attributes['start'].each{|k,v| all_attributes['start'][k]=v.to_i}
+        end
+        
+        self.active = all_attributes['active']  if all_attributes.keys.include?('active')
+        
+        now = Time.now
+        self.frequency = all_attributes['frequency']
+        self.start_time = 
+          case all_attributes['frequency']
+          when 'weekly'
+            # require 'ruby-debug'; debugger
+            start = now.beginning_of_week.advance(all_attributes['start'])
+            start < now ? start.advance(:weeks => 1) : start 
+          when 'daily'                                                       
+            start = now.beginning_of_day.advance(all_attributes['start'])
+            start < now ? start.advance(:days => 1) : start 
+          when 'hourly'                                                      
+            start = now.change(:min => 0).advance(all_attributes['start'])
+            start < now ? start.advance(:hours => 1) : start 
+          else
+            puts "*** frequency: <#{all_attributes[:frequency]}>"
+            raise "unexpected frequency encountered"
+          end
+      end
+
+      #
+      # convenince method for setting the current value in a view selector
+      #
+      def hour
+        self.start_time.localtime.hour rescue nil
+      end
+      
+      #
+      # convenince method for setting the current value in a view selector
+      #
+      def min
+        self.start_time.localtime.min rescue nil
+      end
+      
+      #
+      # convenince method for setting the current value in a view selector
+      #
+      def day_of_week
+        # subract 1 because '%u' returns 1-7, and this is working with zero-indexed ruby arrays
+        self.start_time.localtime.strftime('%u').to_i - 1 rescue nil
+      end
+      
+      def start_is_more_than_one_period_in_the_future?
+        # This works fine with start times that are multiple periods in the past
+        # because that gives a negative difference, and period is always >= 0
+          (self.start_time - Time.now) > self.period 
+      end
+      
+      #
+      # convenience method for detecting whether schedule can be represented in simple format
+      # or should be described as custom (meaning it is beyond the capabilities of the convenience methods)
+      #
+      def custom?
+        return false unless self.start_time
+        return true if self.frequency == 'custom'
+        return true if self.start_is_more_than_one_period_in_the_future?
+        return false
+      end
+
+      #
+      # convenience method for setting defaults in a UI that make sense for a user
+      #
+      def ui_appropriate_defaults!
+        if self.start_time.blank? || self.period == 0
+          self.active = true
+        end
+      end
+
       def t_type
         I18n.t(type, :scope => 'activemodel.models.lucid_works.collection.activity.type')
       end

data/lib/lucid_works/collection.rb

@@ -65,7 +65,8 @@ module LucidWorks
           act
         else
           num_created += 1
-          self.create_activity(:type => type, :active => true, 'start_time' => 3600*num_created)
+          start_time = Time.now.change(:min => 0) + num_created.hours
+          self.create_activity(:type => type, :active => true, :start_time => start_time, :period => 1.days.seconds)
         end
       end
       self.activities! if num_created > 0

data/lib/lucid_works/version.rb

@@ -1,5 +1,5 @@
 module LucidWorks
-  VERSION = "0.6.14"
+  VERSION = "0.6.15"
 
   class Version < Base
   end

data/spec/lib/lucid_works/collection/activity_spec.rb

@@ -1,125 +1,515 @@
 require 'spec_helper'
 
-describe LucidWorks::Collection::Activity do
-  before :all do
-    @server = connect_to_live_server
-    @server.reset_collections!
-    @collection = @server.collections!.first
+# convenience methods for readability of these tests themselves
+  class String
+    def weekday
+      Time.iso8601(self).strftime('%A')
+    end
   end
 
-  def activity_count
-    @collection.activities!.size
+  class Time
+    def weekday
+      self.strftime('%A')
+    end
   end
 
-  class LucidWorks::Collection::Activity
-    def history_size
-      self.histories!.size
+
+describe LucidWorks::Collection::Activity do
+  context "Functionality shared with Datasource scheduling" do
+    before :all do
+      ENV['TZ'] = 'UTC'
     end
-  end
 
-  describe "CRUD" do
-    describe ".create"do
-      context "with invalid parameters" do
+    before do
+      @server = connect_to_live_server
+      @schedule = LucidWorks::Datasource::Schedule.new(:parent => @server)
+    end
+
+    describe '#frequency' do
+      it "should return 'weekly' when period == num of seconds in a week" do
+        @schedule.period = 604800
+        @schedule.frequency.should == 'weekly'
+      end
+
+      it "should return 'daily' when period == num of seconds in a day" do
+        @schedule.period = 86400
+        @schedule.frequency.should == 'daily'
+      end
+
+      it "should return 'hourly' when period == num of seconds in an hour" do
+        @schedule.period = 3600
+        @schedule.frequency.should == 'hourly'
+      end
+
+      it "should return 'custom' when period does not correspond to a common number of seconds" do
+        @schedule.period = 1
+        @schedule.frequency.should == 'custom'
+      end
+
+      it "should return nil when the period is zero" do
+        @schedule.period = 0
+        @schedule.frequency.should == nil
+      end
+    end
+
+    describe '#next_start' do
+      context 'start_time is in the future' do
+        it 'should return start_time' do
+          Timecop.freeze(now = Time.now.utc) do
+            @schedule.start_time = now + 30.minutes
+            @schedule.next_start.should == @schedule.start_time
+          end
+        end
+      end
+
+      #
+      # some of these are a little sketchy b/c comparing time equality is tricky
+      # Time objects are precise to the millisecond
+      # we cheat by converting to string, which is only accurate to the second
+      # but if these test are run on a second boundary, they might wrongly fail
+      # 
+      context 'start_time is in the past' do
         before do
-          @activity_params = {:type => 'bogus', :start_time => 8600}
+          @now = Time.iso8601(Time.now.utc.iso8601)
         end
 
-        it "should not create, and should add errors to model" do
-          a = nil
-          lambda {
-            a = LucidWorks::Collection::Activity.create(@activity_params.merge(:parent => @collection))
-          }.should_not change(self, :activity_count)
-          a.should_not be_persisted
-          a.errors[:type].should_not be_blank
+        describe 'and it is an exact multiple of self.periods until now' do
+          it 'should return now' do
+            # get current time after rounding error
+            Timecop.freeze(@now) do
+              @schedule.start_time = @now - 30.minutes
+              @schedule.period = 10.minutes
+              @schedule.next_start.should == @now
+            end
+          end
+        end
+
+        context 'Time since self.start_time is not even multiple of self.period' do
+          describe 'one interval has passed' do
+            before do 
+              @i = the_interval = 10.minutes
+              @a = a_little_more_than_an_interval_ago = @now - the_interval - 1.minutes
+              
+              @schedule.period = the_interval
+              @schedule.start_time = a_little_more_than_an_interval_ago
+            end
+
+            it 'should return a time less than one interval in the future' do
+              one_interval_in_the_future = @now + @schedule.period
+              @schedule.next_start.should < one_interval_in_the_future
+            end
+
+            it 'should return a time one interval from the start_time' do
+              # TODO: this should be in terms of start time & period, not @now
+              @schedule.next_start.to_s.should == (@now + 9.minutes).to_s
+            end
+          end
+
+          describe 'several (e.g. 4) intervals have passed' do
+            before do
+              @schedule.start_time = @now - 45.minutes
+              @schedule.period = 10.minutes
+            end
+
+            it 'should return a time between 4 and 6 intervals from start_time' do
+              @schedule.next_start.should > @schedule.start_time + (4 * @schedule.period)
+            end
+
+            it 'should return a start time within 1 period from now' do
+              @schedule.next_start.should < @now + @schedule.period
+            end
+          end
         end
       end
+    end
 
-      context "with valid parameters" do
-        before do
-          @activity_params = {:type => 'optimize', :start_time => 8600}
+    describe '#active, #active=' do 
+      it 'should maintain specified value' do
+        @schedule.active = true
+        @schedule.active.should == true
+        @schedule.active = false
+        @schedule.active.should == false
+        # make sure the first true wasn't luck
+        @schedule.active = true
+        @schedule.active.should == true
+      end
+    end
+
+    describe '#schedule=' do
+      context 'active attribute supplied' do
+        describe 'updates the "active" attribute in the model' do
+          it 'should update the "active" attribute in the model' do
+            @schedule.active = true
+            attributes = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}, "active" => 'false'}
+            @schedule.schedule = attributes
+            @schedule.active.should == false
+
+            attributes = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}, "active" => 'true'}
+            @schedule.schedule = attributes
+            @schedule.active.should == true
+          end
         end
-        it "should create a new activity" do
-          a = nil
-          lambda {
-            a = LucidWorks::Collection::Activity.create(@activity_params.merge(:parent => @collection))
-          }.should change(self, :activity_count).by(1)
-          a.should be_persisted
-          a.errors[:type].should be_blank
+
+        describe 'with active attribute not supplied' do
+          it 'should not change the attribute in the model' do
+            attributes = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}}
+            @schedule.active= true
+            @schedule.schedule = attributes
+            @schedule.active.should == true
+
+            @schedule.active= false
+            @schedule.schedule = attributes
+            @schedule.active.should == false
+          end
+
         end
       end
 
-      describe ".find" do
-        before do
-          @activity = LucidWorks::Collection::Activity.create(
-              :type => 'optimize',
-              :start_time => 8600,
-              :collection => @collection
-          )
-          @activity.should be_persisted
-        end
-
-        it "should return a valid activity" do
-          a = LucidWorks::Collection::Activity.find(@activity.id, :parent => @collection)
-          a.should be_a(LucidWorks::Collection::Activity)
-        end
-        
-        %w{ type period start_time }.each do |attr|
-          it "should have a value for #{attr}" do
-            @activity.send(attr.to_sym).should_not be_nil
+      context 'supplied start time has elapsed w/rt current interval' do
+        describe 'with hourly frequency' do
+          it "should advance the start time" do
+            half_past_midnight = Time.iso8601("2011-05-09T00:30:00Z").in_time_zone('Eastern Time (US & Canada)')
+            hourly_at_quarter_past = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}}
+            quarter_past_1_am = Time.iso8601('2011-05-09T01:15:00Z').in_time_zone('Eastern Time (US & Canada)')
+
+            Timecop.freeze                        half_past_midnight do
+              @schedule.start_time.should_not ==  quarter_past_1_am
+
+              @schedule.schedule =                hourly_at_quarter_past
+              @schedule.start_time.should ==      quarter_past_1_am
+            end
+          end
+        end
+
+        describe 'with daily frequency' do
+          it "should advance the start time" do
+            today_at_noon = Time.iso8601("2011-05-09T12:00:00Z").in_time_zone('Eastern Time (US & Canada)')
+            tomorrow_at_eleven_am = Time.iso8601('2011-05-10T11:00:00Z').in_time_zone('Eastern Time (US & Canada)')
+            daily_at_11_am = {"frequency"=>"daily", "start"=>{"hours" => "11", "minutes"=>"00"}}
+            Timecop.freeze                      today_at_noon do
+              @schedule.start_time.should_not ==  tomorrow_at_eleven_am
+
+              @schedule.schedule =                daily_at_11_am
+              @schedule.start_time.should ==      tomorrow_at_eleven_am
+            end
+          end
+        end
+
+        describe 'with weekly frequency' do
+          it "should advance the start time" do
+            # note: Rails week starts on Monday
+              friday_of_this_week = Time.iso8601("2011-05-13T00:00:00Z")
+              wednesday_of_next_week = Time.iso8601('2011-05-18T00:00:00Z')
+              weekly_on_wednesday = {"frequency"=>"weekly", "start"=>{"days" => "2", "hours" => "0", "minutes"=>"00"}}
+
+            # just make sure I'm not on crack
+              friday_of_this_week.weekday.should ==     'Friday'
+              wednesday_of_next_week.weekday.should ==  'Wednesday'
+
+            Timecop.freeze                        friday_of_this_week do
+              @schedule.start_time.should_not ==  wednesday_of_next_week
+
+              @schedule.schedule =                weekly_on_wednesday
+              @schedule.start_time.should ==      wednesday_of_next_week
+            end
           end
         end
       end
 
-      describe "#start" do
-        before do
-          @activity = LucidWorks::Collection::Activity.first(:parent => @collection)
+      context 'supplied time has not elapsed w/rt current interval' do
+        describe 'with hourly frequency' do
+          it "should not advance the start time" do
+            half_past_midnight =                Time.iso8601("2011-05-09T00:30:00Z")
+            three_quarters_past_midnight =      Time.iso8601('2011-05-09T00:45:00Z')
+            hourly_at_three_quarters_past =     {"frequency"=>"hourly", "start"=>{"minutes"=>"45"}}
+
+            Timecop.freeze                        half_past_midnight do
+              @schedule.start_time.should_not ==  three_quarters_past_midnight
+              @schedule.frequency.should_not == 'hourly'
+
+              @schedule.schedule =                hourly_at_three_quarters_past
+              @schedule.start_time.should ==      three_quarters_past_midnight
+              @schedule.frequency.should == 'hourly'
+            end
+          end
         end
 
-        # can't check #running? b/c w/out a big index, operation is done faster than we can check
+        describe 'with daily frequency' do
+          it "should not advance the start time" do
+            today_at_noon =                     Time.iso8601("2011-05-09T12:00:00Z")
+            today_at_1pm =                      Time.iso8601('2011-05-09T13:00:00Z')
+            daily_at_1pm =                      {"frequency"=>"daily", "start"=>{"hours" => "13", "minutes"=>"00"}}
+
+            Timecop.freeze                        today_at_noon do
+              @schedule.start_time.should_not ==  today_at_1pm
+              @schedule.frequency.should_not == 'daily'
 
-        it "should create a new history" do
-          lambda {
-            @collection.activities!.first.start
-          }.should change(@activity, :history_size).by(1)
+              @schedule.schedule =                daily_at_1pm
+              @schedule.start_time.should ==      today_at_1pm
+              @schedule.frequency.should == 'daily'
+            end
+          end
+        end
+
+        describe 'with weekly frequency' do
+          it "should not advance the start time" do
+            # note: Rails week starts on Monday
+              wednesday_of_this_week =          Time.iso8601("2011-05-11T00:00:00Z")
+              thursday_of_this_week =           Time.iso8601('2011-05-12T00:00:00Z')
+              weekly_on_thursday =              {"frequency"=>"weekly", "start"=>{"days" => "3", "hours" => "0", "minutes"=>"00"}}
+
+            # just make sure I'm not on crack
+              wednesday_of_this_week.weekday.should ==  'Wednesday'
+              thursday_of_this_week.weekday.should ==   'Thursday'
+
+            Timecop.freeze                        wednesday_of_this_week do
+              @schedule.start_time.should_not ==  thursday_of_this_week
+              @schedule.frequency.should_not == 'weekly'
+
+              @schedule.schedule =                weekly_on_thursday
+              @schedule.start_time.should ==      thursday_of_this_week
+              @schedule.frequency.should == 'weekly'
+            end
+          end
         end
       end
+    end
 
-      describe "#human_readable_period" do
-        it "should return hours if divisible by 1.hours but not by 1.days or 1.weeks" do
-          activity = LucidWorks::Collection::Activity.new(:period => 3600*2, :parent => @collection)
-          activity.human_readable_period.should == [2, 'hours']
+    context 'sub-time convenience accessors' do
+      describe '#hour' do
+        it 'should return the hour component of the time' do
+          @schedule.start_time = Time.new(2011, 4, 15, 13, 11, 56)
+          @schedule.hour.should == 13
         end
-        it "should return nearest hours if not divisible by 1.hours"do
-          activity = LucidWorks::Collection::Activity.new(:period => 3600*2.4, :parent => @collection)
-          activity.human_readable_period.should == [2, 'hours']
-          activity = LucidWorks::Collection::Activity.new(:period => 3600*4.6, :parent => @collection)
-          activity.human_readable_period.should == [5, 'hours']
-          activity = LucidWorks::Collection::Activity.new(:period => 3600*10.01, :parent => @collection)
-          activity.human_readable_period.should == [10, 'hours']
+
+        it 'should return nil if start_time == nil' do
+          @schedule.start_time = nil
+          @schedule.hour.should == nil
         end
-        it "should return 1 hours if < 1.hours"do
-          activity = LucidWorks::Collection::Activity.new(:period => 3599, :parent => @collection)
-          activity.human_readable_period.should == [1, 'hours']
+      end
+
+      describe '#min' do
+        it 'should return the minute component of the time' do
+          @schedule.start_time = Time.new(2011, 4, 15, 13, 11, 56)
+          @schedule.min.should == 11
         end
-        it "should return days if divisible by 1.days but not 1.weeks" do
-          activity = LucidWorks::Collection::Activity.new(:period => 3600*48, :parent => @collection)
-          activity.human_readable_period.should == [2, 'days']
+
+        it 'should return nil if start_time == nil' do
+          @schedule.start_time = nil
+          @schedule.min.should == nil
         end
-        it "should return weeks if divisible by 1.weeks" do
-          activity = LucidWorks::Collection::Activity.new(:period => 3600*24*7, :parent => @collection)
-          activity.human_readable_period.should == [1, 'weeks']                    
+      end
+
+      describe '#day_of_week' do
+        it 'should return the week component of the time' do
+          @schedule.start_time = Time.new(2011, 4, 15, 13, 11, 56)
+          @schedule.day_of_week.should == 4
+        end
+
+        it 'should return nil if start_time == nil' do
+          @schedule.start_time = nil
+          @schedule.day_of_week.should == nil
         end
       end
+    end
 
-      describe "#human_readable_period=" do
-        it "should set correct period if given a number and hours/days/weeks" do
-          activity = LucidWorks::Collection::Activity.new(:parent => @collection)
-          activity.human_readable_period = [2, 'hours']
-          activity.period.should == 3600*2
-          activity.human_readable_period = [2, 'days']
-          activity.period.should == 3600*2*24
+    describe '#custom?' do
+      context 'schedule can not be represent as simple weekly/daily/hourly' do
+        it 'should be true if frequency is non-standard' do
+          @schedule.period = 1
+          @schedule.should be_custom
         end
+
+        it 'should be true if period is standard but start_time is > 1 period from now' do
+          some_random_time = Time.new(2011, 4, 15, 13, 11, 56)
+          more_than_a_day_later = some_random_time.advance(:days => 2) 
+
+          Timecop.freeze   some_random_time do
+            @schedule.frequency = 'daily'
+            @schedule.start_time = more_than_a_day_later
+
+            @schedule.should be_custom
+          end
+        end
+      end
+
+      context 'schedule can be represent as simple weekly/daily/hourly' do
+        it 'should be false if period is standard and start_time is within period from now' do
+          half_past_midnight = Time.iso8601("2011-05-09T00:30:00Z")
+          a_standard_schedule = {"frequency"=>"hourly", "start"=>{"minutes"=>"15"}}
+          some_random_specific_time = Time.iso8601('2011-05-09T01:15:00Z')
+
+          Timecop.freeze                        some_random_specific_time do
+            @schedule.schedule =                a_standard_schedule
+
+            @schedule.should_not be_custom
+          end
+        end
+
+        it 'should be false if period is standard and start time is > 1 period in the past' do
+          some_random_time = Time.new(2011, 4, 15, 13, 11, 56)
+          more_than_a_day_ago = some_random_time.advance(:days => -2) 
+          Timecop.freeze some_random_time do
+            @schedule.frequency = 'daily'
+            @schedule.start_time = more_than_a_day_ago
+
+            @schedule.should_not be_custom
+          end
+        end
+
+      end
+
+      it 'should be false if the start_time is nil and frequency is standard' do
+        @schedule.start_time = nil
+        @schedule.frequency = 'weekly'
+        @schedule.should_not be_custom
+      end
+    end
+
+    describe '#ui_appropriate_defaults!' do
+      it "should set active to true if start_time is defaulted" do
+        @schedule.start_time = nil
+        @schedule.period = 1.hours.seconds
+        @schedule.active = false
+
+        @schedule.ui_appropriate_defaults!
+
+        @schedule.active.should == true
+      end
+
+      it "should set active to true if period is defaulted" do
+        @schedule.start_time = Time.now
+        @schedule.period = 0
+        @schedule.active = false
+
+        @schedule.ui_appropriate_defaults!
+
+        @schedule.active.should == true
       end
     end
   end
-end
+  
+#   context "Custom Activity schedule functionality" do
+#     before :all do
+#       @server = connect_to_live_server
+#       @server.reset_collections!
+#       @collection = @server.collections!.first
+#     end
+# 
+#     def activity_count
+#       @collection.activities!.size
+#     end
+# 
+#     class LucidWorks::Collection::Activity
+#       def history_size
+#         self.histories!.size
+#       end
+#     end
+# 
+#     describe "CRUD" do
+#       describe ".create"do
+#         context "with invalid parameters" do
+#           before do
+#             @activity_params = {:type => 'bogus', :start_time => 8600}
+#           end
+# 
+#           it "should not create, and should add errors to model" do
+#             a = nil
+#             lambda {
+#               a = LucidWorks::Collection::Activity.create(@activity_params.merge(:parent => @collection))
+#             }.should_not change(self, :activity_count)
+#             a.should_not be_persisted
+#             a.errors[:type].should_not be_blank
+#           end
+#         end
+# 
+#         context "with valid parameters" do
+#           before do
+#             @activity_params = {:type => 'optimize', :start_time => 8600}
+#           end
+#           it "should create a new activity" do
+#             a = nil
+#             lambda {
+#               a = LucidWorks::Collection::Activity.create(@activity_params.merge(:parent => @collection))
+#             }.should change(self, :activity_count).by(1)
+#             a.should be_persisted
+#             a.errors[:type].should be_blank
+#           end
+#         end
+# 
+#         describe ".find" do
+#           before do
+#             @activity = LucidWorks::Collection::Activity.create(
+#                 :type => 'optimize',
+#                 :start_time => 8600,
+#                 :collection => @collection
+#             )
+#             @activity.should be_persisted
+#           end
+# 
+#           it "should return a valid activity" do
+#             a = LucidWorks::Collection::Activity.find(@activity.id, :parent => @collection)
+#             a.should be_a(LucidWorks::Collection::Activity)
+#           end
+#         
+#           %w{ type period start_time }.each do |attr|
+#             it "should have a value for #{attr}" do
+#               @activity.send(attr.to_sym).should_not be_nil
+#             end
+#           end
+#         end
+# 
+#         describe "#start" do
+#           before do
+#             @activity = LucidWorks::Collection::Activity.first(:parent => @collection)
+#           end
+# 
+#           # can't check #running? b/c w/out a big index, operation is done faster than we can check
+# 
+#           it "should create a new history" do
+#             lambda {
+#               @collection.activities!.first.start
+#             }.should change(@activity, :history_size).by(1)
+#           end
+#         end
+# 
+#         describe "#human_readable_period" do
+#           it "should return hours if divisible by 1.hours but not by 1.days or 1.weeks" do
+#             activity = LucidWorks::Collection::Activity.new(:period => 3600*2, :parent => @collection)
+#             activity.human_readable_period.should == [2, 'hours']
+#           end
+#           it "should return nearest hours if not divisible by 1.hours"do
+#             activity = LucidWorks::Collection::Activity.new(:period => 3600*2.4, :parent => @collection)
+#             activity.human_readable_period.should == [2, 'hours']
+#             activity = LucidWorks::Collection::Activity.new(:period => 3600*4.6, :parent => @collection)
+#             activity.human_readable_period.should == [5, 'hours']
+#             activity = LucidWorks::Collection::Activity.new(:period => 3600*10.01, :parent => @collection)
+#             activity.human_readable_period.should == [10, 'hours']
+#           end
+#           it "should return 1 hours if < 1.hours"do
+#             activity = LucidWorks::Collection::Activity.new(:period => 3599, :parent => @collection)
+#             activity.human_readable_period.should == [1, 'hours']
+#           end
+#           it "should return days if divisible by 1.days but not 1.weeks" do
+#             activity = LucidWorks::Collection::Activity.new(:period => 3600*48, :parent => @collection)
+#             activity.human_readable_period.should == [2, 'days']
+#           end
+#           it "should return weeks if divisible by 1.weeks" do
+#             activity = LucidWorks::Collection::Activity.new(:period => 3600*24*7, :parent => @collection)
+#             activity.human_readable_period.should == [1, 'weeks']                    
+#           end
+#         end
+# 
+#         describe "#human_readable_period=" do
+#           it "should set correct period if given a number and hours/days/weeks" do
+#             activity = LucidWorks::Collection::Activity.new(:parent => @collection)
+#             activity.human_readable_period = [2, 'hours']
+#             activity.period.should == 3600*2
+#             activity.human_readable_period = [2, 'days']
+#             activity.period.should == 3600*2*24
+#           end
+#         end
+#       end
+#     end
+#   end
+end

data/spec/lib/lucid_works/collection_spec.rb

@@ -117,6 +117,64 @@ describe LucidWorks::Collection do
       end
     end
   end
+ 
+  describe "#prime_activities" do
+    before do
+      @collection = @server.collection('collection1')
+      # require 'ruby-debug'; debugger
+      # activity = LucidWorks::Collection::Activity.create(
+      #     :type => 'optimize',
+      #     :start_time => 8600,
+      #     :collection => @collection
+      # )
+      # activity.should be_persisted
+    end
+    
+    it "should not create activities that already exist" do
+      activity_params = {:type => 'optimize', :start_time => 8600}
+      c = LucidWorks::Collection.create(:name => "a_collection_for_prime_activities_non_redundancy",
+                                        :instance_dir => @instance_dir,
+                                        :template => @template,
+                                        :parent => @server)
+
+      LucidWorks::Collection::Activity.create(activity_params.merge(:parent => c))
+      c.activities.size.should == 1
+      c.prime_activities
+      c.activities.size.should == 4
+    end
+    
+    context "with a new collection with no activities" do
+      before :all do
+        @collection2 = LucidWorks::Collection.create(:name => "a_collection_for_prime_activities",
+                                          :instance_dir => @instance_dir,
+                                          :template => @template,
+                                          :parent => @server)
+
+        @collection2.activities.size.should == 0
+        @collection2.prime_activities
+        @collection2.activities.size.should == 4
+      end
+
+      it "should ensure at least one of each activity" do
+        %w(optimize spelling click autocomplete).each do |type|
+          @collection2.activities.find_all{|a| a.type == type}.size.should == 1
+        end
+      end
+
+      it "should give start_times divisible by 5 minutes for created activities" do
+        @collection2.activities!.each do |activity|
+          (activity.start_time.min % 5).should == 0
+        end
+      end
+    
+      it "should schedule reasonable repeat intervals for each activity" do
+        @collection2.activities!.each do |activity|
+          (activity.period % 1.hours).should == 0
+          (activity.period / 1.hours).should > 0
+        end
+      end
+    end
+  end
   
   describe "#synonyms" do
     before do

data/spec/lib/lucid_works/datasource/schedule_spec.rb

@@ -44,7 +44,7 @@ describe LucidWorks::Datasource::Schedule do
       @schedule.frequency.should == 'custom'
     end
 
-    it "should return nil" do
+    it "should return nil when the period is zero" do
       @schedule.period = 0
       @schedule.frequency.should == nil
     end

metadata

@@ -2,7 +2,7 @@
 name: lucid_works
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.6.14
+  version: 0.6.15
 platform: ruby
 authors: 
 - Sam Pierson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-03 00:00:00 +01:00
+date: 2011-06-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency