couch_scheduler 0.1.0 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/features/couch_publish_integration.feature

@@ -3,33 +3,142 @@ Feature: CouchPublish Integration
   I want to integrate CouchScheduler with CouchPublish
   So that I can query my database for published documents within a schedule
 
+  @focus
   Scenario: Query for published documents within a schedule
-    Given an Article model that includes CouchPublish and CouchVisible
-    When I create several published articles scheduled now and in the future
-    And I create several unpublished articles scheduled now and in the future
-    When I call "Article.by_schedule :published => true"
-    Then I should receive the published documents scheduled now
-    When I call "Article.by_schedule :unpublished => true"
-    Then I should receive the unpublished documents scheduled now
-    When I wait till the future
-    And I call "Article.by_schedule :published => true"
-    Then I should receive the published documents scheduled in the future
-    When I call "Article.by_schedule :unpublished => true"
-    Then I should receive the unpublished documents scheduled in the future
- 
+    Given an Article model that includes CouchPublish and CouchVisible:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchPublish
+          include CouchScheduler
+        end
+      """
+    
+    When I create several published articles scheduled now and in the future:
+      """
+        @current_published_articles = []
+        @future_published_articles = []
+
+        3.times { @current_published_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish! }}
+        3.times { @future_published_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish! }}
+      """
+
+    And I create several unpublished articles scheduled now and in the future:
+      """
+        @current_unpublished_articles = []
+        @future_unpublished_articles = []
+        
+        3.times { @current_unpublished_articles << Article.create(:start => Time.now, :end => 1.day.from_now)}
+        3.times { @future_unpublished_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+      """
+
+    When I call "Article.map_within_schedule.published.get!":
+      """
+        @result = Article.map_within_schedule.published.get!
+      """
+
+    Then I should receive the published documents scheduled now:
+      """
+        @result.all? {|a| @current_published_articles.collect(&:id).include? a.id }.should be(true)
+        @result.length.should == @current_published_articles.length
+      """
+
+    When I call "Article.map_within_schedule.unpublished.get!":
+      """
+        @result = Article.map_within_schedule.unpublished.get!
+      """
+
+    Then I should receive the unpublished documents scheduled now:
+      """
+        @result.collect(&:id).sort.should == @current_unpublished_articles.collect(&:id).sort
+        @result.length.should == @current_unpublished_articles.length
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "Article.map_within_schedule.published.get!" should return the published documents I had scheduled in the future:
+      """
+        Article.map_within_schedule.published.get!.collect(&:id).sort.should == @future_published_articles.collect(&:id).sort
+      """
+
+    And "Article.map_within_schedule.unpublished.get!" should return the unpublished documents I had scheduled in the future:
+      """
+        Article.map_within_schedule.unpublished.get!.collect(&:id).sort.should == @future_unpublished_articles.collect(&:id).sort
+      """
+
+
   @focus
   Scenario: Count of published and unpublished documents within a schedule
-    Given an Article model that includes CouchPublish and CouchVisible
-    When I create 2 published articles scheduled now
-    And I create 3 published articles schedule in the future
-    And I create 4 unpublished articles scheduled now
-    And I create 7 unpublished articles schedule in the future
-    When I call "Article.count_schedule :published => true"
-    Then I should receive 2
-    When I call "Article.count_schedule :unpublished => true"
-    Then I should receive 4
-    When I wait till the future
-    And I call "Article.count_schedule :published => true"
-    Then I should receive 3
-    When I call "Article.count_schedule :unpublished => true"
-    Then I should receive 7   
+
+    Given an Article model that includes CouchPublish and CouchVisible:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchPublish
+          include CouchScheduler
+        end
+      """
+    
+    When I create 2 published articles scheduled now:
+      """
+        @current_published_articles = []
+
+        2.times { @current_published_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish! }}
+      """
+
+    When I create 3 published articles scheduled in the future:
+      """
+        @future_published_articles = []
+
+        3.times { @future_published_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish! }}
+      """
+
+    And I create 4 unpublished articles scheduled now:
+      """
+        @current_unpublished_articles = []
+        
+        4.times { @current_unpublished_articles << Article.create(:start => Time.now, :end => 1.day.from_now)}
+      """
+
+    And I create 10 unpublished articles scheduled in the future:
+      """
+        @future_unpublished_articles = []
+        
+        10.times { @future_unpublished_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+      """
+
+    When I call "Article.count_within_schedule.published.get!":
+      """
+        @result = Article.count_within_schedule.published.get!
+      """
+
+    Then I should receive the count of the published documents scheduled now:
+      """
+        @result.should == 2
+      """
+
+    When I call "Article.count_within_schedule.unpublished.get!":
+      """
+        @result = Article.count_within_schedule.unpublished.get!
+      """
+
+    Then I should receive the count of the unpublished documents scheduled now:
+      """
+        @result.should == 4
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "Article.count_within_schedule.published.get!" should return the count of the published documents I had scheduled in the future:
+      """
+        Article.count_within_schedule.published.get!.should == 3
+      """
+
+    And "Article.map_within_schedule.unpublished.get!" should return the count of the unpublished documents I had scheduled in the future:
+      """
+        Article.count_within_schedule.unpublished.get!.should == 10
+      """

data/features/couch_visible_and_couch_publish_integration.feature

@@ -4,42 +4,146 @@ Feature: CouchVisible and CouchPublish Integration
   So that I can query my database for shown, published documents within a schedule
 
   Scenario: Query for shown, published documents within a schedule
-    Given a Slide model that includes CouchVisible, CouchPublish and CouchScheduler
-    When I create several shown, published slides scheduled now and in the future
-    And I create several shown, unpublished slides scheduled now and in the future
-    And I create several hidden, published slides scheduled now and in the future
-    And I create several hidden, unpublished slides scheduled now and in the future
-    When I call "Slide.by_schedule :published => true, :shown => true"
-    Then I should receive the shown, published documents scheduled now
-    When I call "Slide.by_schedule :published => true, :hidden => true"
-    Then I should receive the hidden, published documents scheduled now
-    When I wait till the future
-    And I call "Slide.by_schedule :published => true, :shown => true"
-    Then I should receive the shown, published documents scheduled in the future
-    When I call "Slide.by_schedule :published =>true, :hidden => true"
-    Then I should receive the hidden, published documents scheduled in the future
- 
-  @focus
+    Given an Article model that includes CouchVisible, CouchPublish and CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchPublish
+          include CouchVisible
+          include CouchScheduler
+        end
+      """
+
+    When I create several shown, published articles scheduled now and in the future:
+      """
+        @current_published_shown_articles = []
+        @future_published_shown_articles = []
+
+        3.times { @current_published_shown_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish!; a.show!; a.save }}
+        3.times { @future_published_shown_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish!; a.show!; a.save}}
+      """
+
+    And I create several shown, unpublished articles scheduled now and in the future:
+      """
+        @current_unpublished_shown_articles = []
+        @future_unpublished_shown_articles = []
+
+        3.times { @current_unpublished_shown_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.show!; a.save }}
+        3.times { @future_unpublished_shown_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.save}}
+      """
+
+    And I create several hidden, published articles scheduled now and in the future:
+      """
+        @current_published_hidden_articles = []
+        @future_published_hidden_articles = []
+
+        3.times { @current_published_hidden_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish!}}
+        3.times { @future_published_hidden_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish!}}
+      """
+
+
+    And I create several hidden, unpublished articles scheduled now and in the future:
+      """
+        @current_unpublished_hidden_articles = []
+        @future_unpublished_hidden_articles = []
+
+        3.times { @current_unpublished_hidden_articles << Article.create(:start => Time.now, :end => 1.day.from_now)}
+        3.times { @future_unpublished_hidden_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+      """
+
+    Then "Article.map_within_schedule.published.shown.get!" should return the shown, published documents scheduled now:
+      """
+        Article.map_within_schedule.published.shown.get!.collect(&:id).sort.should == @current_published_shown_articles.collect(&:id).sort
+      """
+
+    And "Article.map_within_schedule.published.hidden.get!" should return the published, hidden documents scheduled now:
+      """
+        Article.map_within_schedule.published.hidden.get!.collect(&:id).sort.should == @current_published_hidden_articles.collect(&:id).sort
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "Article.by_schedule.published.shown.get!" should return the published, visible documents scheduled in the future:
+      """
+        Article.map_within_schedule.published.shown.get!.collect(&:id).sort.should == @future_published_shown_articles.collect(&:id).sort
+      """
+    
+    And "Article.map_within_schedule.published.hidden.get!" should return the published, hidden documents scheduled now:
+      """
+        Article.map_within_schedule.published.hidden.get!.collect(&:id).sort.should == @future_published_hidden_articles.collect(&:id).sort
+      """
+
+
   Scenario: Count of shown and hidden documents within a schedule
-    Given a Slide model that includes CouchVisible, CouchPublish and CouchScheduler
-    When I create 2 shown, published slides scheduled now
-    When I create 6 shown, unpublished slides scheduled now
-    And I create 3 shown, published slides schedule in the future
-    And I create 9 shown, unpublished slides schedule in the future
-    And I create 4 hidden, published slides scheduled now
-    And I create 12 hidden, unpublished slides scheduled now
-    And I create 7 hidden, published slides schedule in the future
-    And I create 21 hidden, unpublished slides schedule in the future
-    When I call "Slide.count_schedule :published => true, :shown => true"
-    Then I should receive 2
-    When I call "Slide.count_schedule :published => true"
-    Then I should receive 6
-    When I call "Slide.count_schedule"
-    Then I should receive 24
-    When I call "Slide.count_schedule :published =>true, :hidden => true"
-    Then I should receive 4
-    When I wait till the future
-    And I call "Slide.count_schedule :published => true, :shown => true"
-    Then I should receive 3
-    When I call "Slide.count_schedule :published =>true, :hidden => true"
-    Then I should receive 7
+    Given an Article model that includes CouchVisible, CouchPublish and CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchPublish
+          include CouchVisible
+          include CouchScheduler
+        end
+      """
+
+    When I create 2 shown, published articles scheduled now and 10 in the future:
+      """
+        @current_published_shown_articles = []
+        @future_published_shown_articles = []
+
+        2.times { @current_published_shown_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish!; a.show!; a.save }}
+        10.times { @future_published_shown_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish!; a.show!; a.save}}
+      """
+
+    And I create 3 shown, unpublished articles scheduled now and 8 in the future:
+      """
+        @current_unpublished_shown_articles = []
+        @future_unpublished_shown_articles = []
+
+        3.times { @current_unpublished_shown_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.show!; a.save }}
+        8.times { @future_unpublished_shown_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.save}}
+      """
+
+    And I create 5 hidden, published articles scheduled now and 14 in the future:
+      """
+        @current_published_hidden_articles = []
+        @future_published_hidden_articles = []
+
+        5.times { @current_published_hidden_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.publish!}}
+        14.times { @future_published_hidden_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.publish!}}
+      """
+
+
+    And I create 11 hidden, unpublished articles scheduled now and in the future:
+      """
+        @current_unpublished_hidden_articles = []
+        @future_unpublished_hidden_articles = []
+
+        11.times { @current_unpublished_hidden_articles << Article.create(:start => Time.now, :end => 1.day.from_now)}
+        11.times { @future_unpublished_hidden_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+      """
+
+    Then "Article.count_within_schedule.published.shown.get!" should return 2:
+      """
+        Article.count_within_schedule.published.shown.get!.should == 2
+      """
+
+    And "Article.count_within_schedule.published.hidden.get!" should return 5:
+      """
+        Article.count_within_schedule.published.hidden.get!.should == 5
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "Article.count_within_schedule.published.shown.get!" should return 10:
+      """
+        Article.count_within_schedule.published.shown.get!.should == 10
+      """
+
+    And "Article.count_within_schedule.published.hidden.get!" should return 14:
+      """
+        Article.count_within_schedule.published.hidden.get!.should == 14
+      """

data/features/couch_visible_integration.feature

@@ -4,32 +4,140 @@ Feature: CouchVisible Integration
   So that I can query my database for shown documents within a schedule
 
   Scenario: Query for shown documents within a schedule
-    Given an Post model that includes CouchVisible and CouchScheduler
-    When I create several shown posts scheduled now and in the future
-    And I create several hidden posts scheduled now and in the future
-    When I call "Post.by_schedule :shown => true"
-    Then I should receive the shown documents scheduled now
-    When I call "Post.by_schedule :hidden => true"
-    Then I should receive the hidden documents scheduled now
-    When I wait till the future
-    And I call "Post.by_schedule :shown => true"
-    Then I should receive the shown documents scheduled in the future
-    When I call "Post.by_schedule :hidden => true"
-    Then I should receive the hidden documents scheduled in the future
-  
+   Given an Article model that includes CouchVisible and CouchScheduler:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchVisible
+          include CouchScheduler
+        end
+      """
+    
+    When I create several shown articles scheduled now and in the future:
+      """
+        @current_shown_articles = []
+        @future_shown_articles = []
+
+        3.times { @current_shown_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.show!; a.save }}
+        3.times { @future_shown_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.save }}
+      """
+
+    And I create several hidden articles scheduled now and in the future:
+      """
+        @current_hidden_articles = []
+        @future_hidden_articles = []
+        
+        3.times { @current_hidden_articles << Article.create(:start => Time.now, :end => 1.day.from_now)}
+        3.times { @future_hidden_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+      """
+
+    When I call "Article.map_within_schedule.shown.get!":
+      """
+        @result = Article.map_within_schedule.shown.get!
+      """
+
+    Then I should receive the shown documents scheduled now:
+      """
+        @result.all? {|a| @current_shown_articles.collect(&:id).include? a.id }.should be(true)
+        @result.length.should == @current_shown_articles.length
+      """
+
+    When I call "Article.map_within_schedule.hidden.get!":
+      """
+        @result = Article.map_within_schedule.hidden.get!
+      """
+
+    Then I should receive the hidden documents scheduled now:
+      """
+        @result.collect(&:id).sort.should == @current_hidden_articles.collect(&:id).sort
+        @result.length.should == @current_hidden_articles.length
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "Article.map_within_schedule.shown.get!" should return the shown documents I had scheduled in the future:
+      """
+        Article.map_within_schedule.shown.get!.collect(&:id).sort.should == @future_shown_articles.collect(&:id).sort
+      """
+
+    And "Article.map_within_schedule.hidden.get!" should return the hidden documents I had scheduled in the future:
+      """
+        Article.map_within_schedule.hidden.get!.collect(&:id).sort.should == @future_hidden_articles.collect(&:id).sort
+      """
+
+
   @focus 
   Scenario: Count of shown and hidden documents within a schedule
-    Given an Post model that includes CouchVisible and CouchScheduler
-    When I create 2 shown posts scheduled now
-    And I create 3 shown posts schedule in the future
-    And I create 4 hidden posts scheduled now
-    And I create 7 hidden posts schedule in the future
-    When I call "Post.count_schedule :shown => true"
-    Then I should receive 2
-    When I call "Post.count_schedule :hidden => true"
-    Then I should receive 4
-    When I wait till the future
-    And I call "Post.count_schedule :shown => true"
-    Then I should receive 3
-    When I call "Post.count_schedule :hidden => true"
-    Then I should receive 7   
+ 
+    Given an Article model that includes CouchScheduler and CouchVisible:
+      """
+        class Article < CouchRest::Model::Base
+          include CouchVisible
+          include CouchScheduler
+        end
+      """
+    
+    When I create 2 shown articles scheduled now:
+      """
+        @current_shown_articles = []
+
+        2.times { @current_shown_articles << Article.create(:start => Time.now, :end => 1.day.from_now).tap {|a| a.show!; a.save }}
+      """
+
+    When I create 3 shown articles scheduled in the future:
+      """
+        @future_shown_articles = []
+
+        3.times { @future_shown_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now).tap {|a| a.show!; a.save }}
+      """
+
+    And I create 4 hidden articles scheduled now:
+      """
+        @current_hidden_articles = []
+        
+        4.times { @current_hidden_articles << Article.create(:start => Time.now, :end => 1.day.from_now)}
+      """
+
+    And I create 10 hidden articles scheduled in the future:
+      """
+        @future_hidden_articles = []
+        
+        10.times { @future_hidden_articles << Article.create(:start => 1.day.from_now, :end => 2.days.from_now)}
+      """
+
+    When I call "Article.count_within_schedule.shown.get!":
+      """
+        @result = Article.count_within_schedule.shown.get!
+      """
+
+    Then I should receive the count of the shown documents scheduled now:
+      """
+        @result.should == 2
+      """
+
+    When I call "Article.count_within_schedule.hidden.get!":
+      """
+        @result = Article.count_within_schedule.hidden.get!
+      """
+
+    Then I should receive the count of the hidden documents scheduled now:
+      """
+        @result.should == 4
+      """
+
+    When I wait a day:
+      """
+        Timecop.freeze 1.day.from_now
+      """
+
+    Then "Article.count_within_schedule.shown.get!" should return the count of the shown documents I had scheduled in the future:
+      """
+        Article.count_within_schedule.shown.get!.should == 3
+      """
+
+    And "Article.map_within_schedule.hidden.get!" should return the count of the hidden documents I had scheduled in the future:
+      """
+        Article.count_within_schedule.hidden.get!.should == 10
+      """