couch_scheduler 0.1.0 → 0.2.0

data/features/scheduling.feature

@@ -3,53 +3,353 @@ Feature: Scheduling
   I want the ability to schedule my documents
   So that I can control when they are accessible
 
+
   Scenario: Setting valid start and end dates
-    Given an instance of a model that includes CouchScheduler
-    When I set "start" to now
-    And I set "end" to a day from now
-    Then I should be able to save my document
+    
+    Given an instance of a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+
+        @article = Article.new
+      """
+
+    When I set "start" to now:
+      """
+        @article.start = Time.now
+      """
+
+    And I set "end" to a day from now:
+      """
+        @article.end = 1.day.from_now
+      """
+
+    Then I should be able to save my document:
+      """
+        @article.save
+        @article.errors.should be_empty
+        Article.all.count.should == 1
+      """
+  
   
   Scenario: Setting invalid start and end dates
-    Given an instance of a model that includes CouchScheduler
-    When I set "start" to now
-    And I set "end" to yesterday
-    Then I should not be able to save my document
-    And I should get an error message that the end "must be greater than start"
 
+    Given an instance of a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+
+        @article = Article.new
+      """
+
+    When I set "start" to now:
+      """
+        @article.start = Time.now
+      """
+
+    And I set "end" to yesterday:
+      """
+        @article.end = 1.day.ago
+      """
+
+    Then I should not be able to save my document:
+      """
+        @article.save
+        @article.errors.should_not be_empty
+        Article.all.count.should == 0
+      """  
+  
+  
   Scenario: Determining if a document is within it's schedule 
-    Given an instance of a model that includes CouchScheduler
-    When I set "start" to now
-    And I set "end" to a day from now
-    Then "within_schedule?" should return true on my instance
-    When I wait two days
-    Then "within_schedule?" should return false on my instance
+
+    Given an instance of a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+
+        @article = Article.new
+      """
+
+    When I set "start" to now:
+      """
+        @article.start = Time.now
+      """
+
+    And I set "end" to tomorrow:
+      """
+        @article.end = 1.day.from_now
+      """
+
+    Then "within_schedule?" should return true on my instance:
+      """
+        @article.within_schedule?.should be(true)
+      """
+
+    When I wait two days:
+      """
+        Timecop.freeze 2.days.from_now
+      """
+
+    Then "within_schedule?" should return false on my instance:
+      """
+        @article.within_schedule?
+      """
+
   
   Scenario: Determining if a document is within it's schedule for a document that has only a start date
-    Given an instance of a model that includes CouchScheduler
-    When I set "start" to a day from now
-    Then "within_schedule?" should return false on my instance
-    When I wait two days
-    Then "within_schedule?" should return true on my instance
+    Given an instance of a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+
+        @article = Article.new
+      """
+
+    When I set "start" to now:
+      """
+        @article.start = Time.now
+      """
+    
+    Then "within_schedule?" should return true on my instance:
+      """
+        @article.within_schedule?.should be(true)
+      """
+
+    When I wait two days:
+      """
+        Timecop.freeze 2.days.from_now
+      """
 
+    Then "within_schedule?" should return true on my instance:
+      """
+        @article.within_schedule?.should be(true)
+      """
+
+
+  @focus
   Scenario: Determining if a document is within it's schedule for a document that has only an end date
-    Given an instance of a model that includes CouchScheduler
-    When I set "end" to a day from now
-    Then "within_schedule?" should return true on my instance
-    When I wait two days
-    Then "within_schedule?" should return false on my instance
+
+    Given an instance of a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+
+        @article = Article.new
+      """
+
+    When I set "end" to tomorrow:
+      """
+        @article.end = 1.day.from_now
+      """
+    
+    Then "within_schedule?" should return true on my instance:
+      """
+        @article.within_schedule?.should be(true)
+      """
+
+    When I wait two days:
+      """
+        Timecop.freeze 2.days.from_now
+      """
+
+    Then "within_schedule?" should return false on my instance:
+      """
+        @article.within_schedule?.should be(false)
+      """
   
+
+  @focus
   Scenario: Getting all documents that are within schedule on a given date 
-    Given there are several documents currently scheduled
-    And there are several documents scheduled in the future
-    Then "by_schedule" should return the documents currently within schedule
-    And "by_schedule" should not return the documents scheduled in the future
 
+    Given an instance of a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+
+        @article = Article.new
+      """
+
+    And there are several documents currently scheduled:
+      """
+        @current_articles = [].tap {|a| 10.times { a << Article.create(:start => Time.now, :end => 1.day.from_now) }}
+        @current_articles.length.should == 10
+      """
+
+    And there are several documents scheduled in the future:
+      """
+        @future_articles = [].tap {|a| 10.times { a << Article.create(:start => 2.days.from_now, :end => 3.days.from_now) }}
+        @future_articles.length.should == 10
+        Article.all.count.should == 20
+      """
+
+    Then "map_within_schedule!" should return the documents currently within schedule:
+      """
+        Article.map_within_schedule!.all? {|a| @current_articles.collect(&:id).include? a.id }
+      """
+
+    And "map_within_schedule!" should not return the documents scheduled in the future:
+      """
+        Article.map_within_schedule!.all? {|a| !@future_articles.collect(&:id).include? a.id }
+      """
+    
+    Then "map_within_schedule.key(2.days.from_now.to_date).get!" should return the documents scheduled in the future:
+      """
+        Article.map_within_schedule.key(2.days.from_now.to_date).get!.all? {|a| @future_articles.collect(&:id).include? a.id }
+      """
+
+    And "map_within_schedule.key(2.days.from_now.to_date).get!" should not return the documents currently scheduled:
+      """
+        Article.map_within_schedule.key(2.days.from_now.to_date).get!.all? {|a| !@current_articles.collect(&:id).include? a.id }
+      """
+
+
+  @focus
   Scenario: Counting documents
-    Given there are 3 documents scheduled between now and tomorrow
-    And ther are 10 documents scheduled between tomorrow and two days from now
-    Then "count_schedule" should return 3
-    And "count_schedule :key => 1.day.from_now" should return 10
-    When I wait a day
-    Then "count_schedule" should return 10
-    When I wait another day
-    Then "count_schedule" should return 0
+    
+    Given a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+      """
+    
+    And there are 3 documents scheduled between now and tomorrow:
+      """
+        3.times { Article.create :start => Time.now, :end => 1.day.from_now}
+      """
+
+    And there are 10 documents scheduled between tomorrow and two days from now:
+      """
+        10.times { Article.create :start => 1.day.from_now, :end => 2.days.from_now }
+      """
+
+    Then "count_within_schedule!" should return 3:
+      """
+        Article.count_within_schedule!.should == 3
+      """
+
+    And "count_within_schedule.key(1.day.from_now.to_date).get!" should return 10:
+      """
+        Article.count_within_schedule.key(1.day.from_now.to_date).get!.should == 10
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "count_within_schedule!" should return 10:
+      """
+        Article.count_within_schedule!.should == 10
+      """
+
+    When I wait another day:  
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "count_within_schedule!" should return 0:
+      """
+        Article.count_within_schedule!.should == 0
+      """
+
+  @focus
+  Scenario: Generating the correct date key index for scheduled documents
+    
+    Given a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+      """
+    
+    And the date is January 1st, 2011:
+      """
+        Timecop.freeze Time.parse("2011/01/01")
+      """
+
+    And there are 3 documents scheduled between now and one month and a day from now:
+      """
+        3.times { Article.create :start => Time.now, :end => (1.month.from_now + 1.day)}
+      """
+
+    And there are 10 documents scheduled between one month and a day from now and two months from now:
+      """
+        10.times { Article.create :start => (1.month.from_now + 1.day), :end =>  2.months.from_now }
+      """
+    
+    Then "count_within_schedule!" should return 3:
+      """
+        Article.count_within_schedule!.should == 3
+      """
+
+    And "count_within_schedule.key('2011-01-01').get!" should return 3:
+      """
+        Article.count_within_schedule.key('2011-01-01').get!.should == 3
+      """
+
+    And "count_within_schedule.key('2011-02-02).get!" should return 10:
+      """
+        Article.count_within_schedule.key('2011-02-02').get!.should == 10
+      """
+
+    When I wait a month and a day:
+      """
+        Timecop.freeze(1.month.from_now + 1.day)
+      """
+
+    Then "count_within_schedule!" should return 10:
+      """
+        Article.count_within_schedule!.should == 10
+      """
+
+  @focus
+  Scenario: Default start within the "schedule" index to the current date
+    
+    Given a model that includes CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchScheduler
+        end
+      """
+    
+    And there are 3 documents scheduled to end one month and a day from now:
+      """
+        3.times { Article.create :end => (1.month.from_now + 1.day)}
+      """
+
+    And there are 10 documents scheduled to start one month and a day from now:
+      """
+        10.times { Article.create :start => (1.month.from_now + 1.day)}
+      """
+    
+    Then "count_within_schedule!" should return 3:
+      """
+        Article.count_within_schedule!.should == 3
+      """
+
+    And "count_within_schedule.key(Time.now.to_date).get!" should return 3:
+      """
+        Article.count_within_schedule.key(Time.now.to_date).get!.should == 3
+      """
+
+    And "count_within_schedule.key((1.month.from_now + 1.day).to_date).get!" should return 10:
+      """
+        Article.count_within_schedule.key((1.month.from_now + 1.day).to_date).get!.should == 10
+      """
+
+    When I wait a month and a day:
+      """
+        Timecop.freeze(1.month.from_now + 1.day)
+      """
+
+    Then "count_within_schedule!" should return 10:
+      """
+        Article.count_within_schedule!.should == 10
+      """

data/features/step_definitions/couch_publish_integration.rb

@@ -1,74 +1,7 @@
-Given /^an Article model that includes CouchPublish and CouchVisible$/ do
-  unless defined?(Article)
-    class Article < CouchRest::Model::Base
-      include CouchPublish
-      include CouchScheduler
-    end
-  end
+When /^I create.*:$/ do |code|
+  eval code
 end
 
-When /^I create several published articles scheduled now and in the future$/ do
-  @published_now = []
-  @published_future = []
-
-  5.times { @published_now << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish! } }
-  5.times { @published_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish! } }
-end
-
-When /^I create several unpublished articles scheduled now and in the future$/ do
-  @unpublished_now = []
-  @unpublished_future = []
-
-  5.times { @unpublished_now << Article.create(:start => Time.now, :end => 1.day.from_now) }
-  5.times { @unpublished_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now) }
-end
-
-When /^I call "([^"]*)"$/ do |code|
-  @result = eval code
-end
-
-Then /^I should receive the published documents scheduled now$/ do
-  @result.collect(&:id).sort.should == @published_now.collect(&:id).sort
-end
-
-Then /^I should receive the unpublished documents scheduled now$/ do
-  @result.collect(&:id).sort.should == @unpublished_now.collect(&:id).sort
-end
-
-When /^I wait till the future$/ do
-  Timecop.freeze 1.day.from_now
-end
-
-Then /^I should receive the published documents scheduled in the future$/ do
-  @result.collect(&:id).sort.should == @published_future.collect(&:id).sort
+When /^I call ".*":$/ do |code|
+  eval code
 end
-
-Then /^I should receive the unpublished documents scheduled in the future$/ do
-  @result.collect(&:id).sort.should == @unpublished_future.collect(&:id).sort
-end
-
-When /^I create (\d+) published articles scheduled now$/ do |num|
-  @published_now = []
-  num.to_i.times { @published_now << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish!}}
-end
-
-When /^I create (\d+) published articles schedule in the future$/ do |num|
-  @published_future = []
-  num.to_i.times { @published_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish!}}
-end
-
-When /^I create (\d+) unpublished articles scheduled now$/ do |num|
-  @unpublished_now = []
-  num.to_i.times { @unpublished_now << Article.create(:start => Time.now, :end => 1.day.from_now)}
-end
-
-When /^I create (\d+) unpublished articles schedule in the future$/ do |num|
-  @unpublished_future = []
-  num.to_i.times { @unpublished_future << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
-end
-
-Then /^I should receive (\d+)$/ do |count|
-  @result.should == count.to_i
-end
-
-