radiant-forum-extension 2.1.6 → 3.0.0.rc3

data/spec/datasets/forums_dataset.rb

@@ -1,48 +1,57 @@
 class ForumsDataset < Dataset::Base
-  uses :forum_readers, :home_page, :users
+  uses :readers
   
   def load  
     create_layout "Forum"
 
     create_forum "Public" do
+      create_topic "sticky", :reader => readers(:normal), :replied_at => 3.days.ago, :sticky => true
       create_topic "older", :reader => readers(:normal), :replied_at => 2.days.ago do
-        add_post "First", :created_at => 2.days.ago, :body => 'original topic message'
-        add_post "Second", :created_at => 1.day.ago, :body => 'first reply to public topic'
+        create_post "First", :created_at => 2.days.ago, :body => 'original topic message'
+        create_post "Second", :created_at => 1.day.ago, :body => 'first reply to public topic'
       end
       create_topic "newer", :reader => readers(:normal), :replied_at => 1.day.ago
     end
       
-    create_forum "Private" do
-      create_topic "sticky", :reader => readers(:normal), :replied_at => 3.days.ago, :sticky => true
+    create_forum "Other" do
       create_topic "locked", :reader => readers(:normal), :locked => true, :replied_at => 1.year.ago
-      create_topic "private", :reader => readers(:normal), :replied_at => 1.day.ago do
-        add_post "Third", :created_at => 4.hours.ago, :body => 'Reply to private topic'
+      create_topic "another", :reader => readers(:normal), :replied_at => 1.day.ago do
+        create_post "Third", :created_at => 4.hours.ago, :body => 'Reply to another topic'
       end
     end
     
     create_forum "Misc" do
-      create_topic "empty", :reader => readers(:notable)
+      create_topic "empty", :reader => readers(:another)
+      create_topic "busy", :reader => readers(:another) do
+        60.times do |i|
+          create_post "test_#{i}", :body => "test #{i}", :reader => readers(:normal), :created_at => (100-i).minutes.ago
+        end
+        create_post "nearly", :body => "test by visible", :reader => readers(:visible)
+        create_post "finally", :body => "test by another", :reader => readers(:another)
+      end
+    end
+    
+    create_forum "Grouped" do
+      create_topic "grouped", :reader => readers(:another)
     end
     
     create_page "Commentable", :commentable => true, :comments_closed => false, :created_by => users(:admin) do
-      add_post "Comment", :created_at => 2.days.ago, :body => 'first comment on page'
-      add_post "Recomment", :created_at => 1.day.ago, :body => 'second comment on page'
+      create_post "Comment", :created_at => 2.days.ago, :body => 'first comment on page'
+      create_post "Recomment", :created_at => 1.day.ago, :body => 'second comment on page'
     end
 
     create_page "Uncommented", :commentable => true, :comments_closed => false, :created_by => users(:admin)
     create_page "Uncommentable", :commentable => false, :comments_closed => false, :created_by => users(:admin)
     create_page "Comments closed", :commentable => true, :comments_closed => true, :created_by => users(:admin)
+
+    
+    restrict_to_group :special, [forums(:grouped)]
   end
   
   helpers do
-    def create_layout(name, attributes={})
-      create_model :layout, name.symbolize, attributes.update(:name => name)
-    end
-
     def create_forum(name, attributes={})
-      attributes = forum_attributes(attributes.update(:name => name))
       symbol = name.symbolize
-      create_model :forum, symbol, attributes
+      create_model :forum, symbol, default_forum_attributes(name).merge(attributes)
       if block_given?
         @forum_id = forum_id(symbol)
         yield
@@ -51,20 +60,18 @@ class ForumsDataset < Dataset::Base
     end
     
     def create_topic(name, attributes={})
-      attributes = topic_attributes(attributes.update(:name => name))
       symbol = name.symbolize
       reader = attributes.delete(:reader)
-      create_model :topic, symbol, attributes
+      create_model :topic, symbol, default_topic_attributes(name).merge(attributes)
       @topic_id = topic_id(symbol)
-      add_post("#{name}_first_post", :reader => reader)
+      create_post("#{name}_first_post", :reader => reader)
       yield if block_given?
       @topic_id = nil
     end
   
-    def add_post(name, attributes={})
-      attributes = post_attributes(attributes)
+    def create_post(name, attributes={})
       symbol = name.symbolize
-      create_model :post, symbol, attributes
+      create_model :post, name.symbolize, default_post_attributes.merge(attributes)
       if block_given?
         @post_id = post_id(symbol)
         yield
@@ -72,37 +79,28 @@ class ForumsDataset < Dataset::Base
       end
     end
  
-    def forum_attributes(attributes={})
-      name = attributes[:name] || "Forum"
-      symbol = name.symbolize
-      attributes = { 
+    def default_forum_attributes(name="Forum")
+      { 
         :name => name,
         :created_at => Time.now
-      }.merge(attributes)
-      attributes[:site_id] = site_id(:test) if Forum.reflect_on_association(:site)
-      attributes
+      }
     end
 
-    def topic_attributes(attributes={})
-      name = attributes[:name] || "A topic"
-      att = {
+    def default_topic_attributes(name="A topic")
+      {
         :name => name,
         :forum_id => @forum_id
-      }.merge(attributes)
-      attributes[:site_id] ||= site_id(:test) if Topic.reflect_on_association(:site)
-      att
+      }
     end
   
-    def post_attributes(attributes={})
-      att = {
+    def default_post_attributes
+      {
         :body => "Message body",
         :reader => readers(:normal),
         :created_at => 1.day.ago,
         :topic_id => @topic_id,
         :page_id => @current_page_id
-      }.merge(attributes)
-      att[:site_id] ||= site_id(:test) if Post.reflect_on_association(:site)
-      att
+      }
     end
   end
   

data/spec/lib/commentable_model_spec.rb

@@ -1,88 +1,76 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
+# NB post-holder may be Page or Topic (or whatever else has been made commentable)
+
 describe 'Post-holder' do
   dataset :forums
   
   before do
     Radiant::Config['forum.paginate_posts?'] = true
-    @topic = topics(:empty)
   end
+  
+  let(:topic) { topics(:empty) }
+  let(:busy_topic) { topics(:busy) }
 
   describe "without replies" do
     it "should announce posts but not replies" do
-      @topic.posts.count.should == 1
-      @topic.has_posts?.should be_true
-      @topic.has_replies?.should be_false
+      topic.posts.count.should == 1
+      topic.has_posts?.should be_true
+      topic.has_replies?.should be_false
     end
   end
   
   describe "with replies" do
-    before do
-      60.times do |i|
-        @topic.posts.create!(:body => "test #{i}", :reader => readers(:normal), :created_at => (100-i).minutes.ago)
-      end
-      @topic.posts.create!(:body => "test by another", :reader => readers(:idle))
-      @topic.reload
-    end
-    
     it "should have many posts" do
-      @topic.posts.count.should == 62
+      busy_topic.posts.count.should == 63
     end
 
     it "should report the number of replies to the original post" do
-      @topic.reply_count.should == 61
-      @topic.replies.length.should == @topic.reply_count
+      busy_topic.reply_count.should == 62
+      busy_topic.replies.length.should == busy_topic.reply_count
     end
 
     it "should report the number of readers taking part" do
-      calculated = @topic.posts.map(&:reader).uniq
-      Rails.logger.warn ">>"
-      @topic.voice_count.should == calculated.length
-      Rails.logger.warn "<<"
+      calculated = busy_topic.posts.map(&:reader).uniq
+      busy_topic.voice_count.should == calculated.length
     end
 
     it "should report the number of readers replying" do
-      calculated = @topic.posts.map(&:reader).uniq - [@topic.posts.first.reader]
-      @topic.other_voice_count.should == calculated.length
+      calculated = busy_topic.posts.map(&:reader).uniq - [topic.posts.first.reader]
+      busy_topic.other_voice_count.should == calculated.length
     end
 
     it "should report the list of readers taking part" do
-      @topic.voices.length.should == 3
-      @topic.voices.include?(readers(:notable)).should be_true
-      @topic.voices.include?(readers(:normal)).should be_true
-      @topic.voices.include?(readers(:idle)).should be_true
+      busy_topic.voices.should =~ [readers(:normal), readers(:another), readers(:visible)]
     end
 
     it "should report the list of readers replying" do
-      @topic.other_voices.length.should == 2
-      @topic.other_voices.include?(readers(:notable)).should be_false
-      @topic.other_voices.include?(readers(:normal)).should be_true
-      @topic.other_voices.include?(readers(:idle)).should be_true
+      busy_topic.other_voices.should =~ [readers(:visible), readers(:normal)]
     end
 
     it "should paginate its posts" do
-      @topic.paged?.should be_true
+      busy_topic.paged?.should be_true
     end
 
     it "should know on which page to find a given post" do
-      @topic.page_for(Post.find_by_body("test 16")).should == 1
-      @topic.page_for(Post.find_by_body("test 36")).should == 2
-      @topic.page_for(Post.find_by_body("test 56")).should == 3
+      busy_topic.page_for(Post.find_by_body("test 16")).should == 1
+      busy_topic.page_for(Post.find_by_body("test 36")).should == 2
+      busy_topic.page_for(Post.find_by_body("test 56")).should == 3
     end
 
     it "should read config to find the number of posts per page" do
       Radiant::Config['forum.posts_per_page'] = 15
-      @topic.page_for(Post.find_by_body("test 16")).should == 2
-      @topic.page_for(Post.find_by_body("test 36")).should == 3
-      @topic.page_for(Post.find_by_body("test 56")).should == 4
+      busy_topic.page_for(Post.find_by_body("test 16")).should == 2
+      busy_topic.page_for(Post.find_by_body("test 36")).should == 3
+      busy_topic.page_for(Post.find_by_body("test 56")).should == 4
     end
 
     it "should know when it was last replied to" do
-      @topic.replied_at.should == @topic.posts.last.created_at
+      busy_topic.replied_at.should == posts(:finally).created_at
     end
 
     it "should know by whom it was last replied to" do
-      @topic.replied_by.should == readers(:idle)
+      busy_topic.replied_by.should == posts(:finally).reader
     end
   end
 end

data/spec/lib/forum_reader_spec.rb

@@ -2,10 +2,6 @@ require File.dirname(__FILE__) + "/../spec_helper"
 
 describe 'Forum reader' do
 
-  it "should have a topics association" do
-    Reader.reflect_on_association(:topics).should_not be_nil
-  end
-
   it "should have a posts association" do
     Reader.reflect_on_association(:posts).should_not be_nil
   end

data/spec/models/forum_spec.rb

@@ -2,29 +2,26 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Forum do
   dataset :forums
-  
-  before do
-    @site = Page.current_site = sites(:test) if defined? Site
-    @forum = forums(:public)
-    @reader = Reader.current = readers(:normal)
-  end
+  let(:forum) {forums(:public)}
+  let(:group_forum) {forums(:grouped)}
+  let(:reader) {readers(:normal)}
+  let(:unrestricted) {[forums(:public), forums(:other), forums(:misc)]}
   
   it "should require a name" do
-    @forum.name = nil
-    @forum.should_not be_valid
-    @forum.errors.on(:name).should_not be_empty
+    forum.name = nil
+    forum.should_not be_valid
+    forum.errors.on(:name).should_not be_empty
   end
   
   describe "topics.bydate" do
     it "should list its topics in descending date order" do
-      forums(:public).topics.bydate.first.should == topics(:newer)
-      forums(:private).topics.bydate.first.should == topics(:private)
+      forum.topics.bydate.first.should == topics(:newer)
     end
   end
   
   describe "topics.stickyfirst" do
     it "should list its topics with the sticky first" do
-      forums(:private).topics.stickyfirst.first.should == topics(:sticky)
+      forum.topics.stickyfirst.first.should == topics(:sticky)
     end
   end
   
@@ -34,11 +31,11 @@ describe Forum do
     end
 
     it "should be visible to a reader" do
-      forums(:public).visible_to?(@reader).should be_true
+      forum.visible_to?(reader).should be_true
     end
     
     it "should be visible when there is no reader" do
-      forums(:public).visible_to?(nil).should be_true
+      forum.visible_to?(nil).should be_true
     end
   end
 
@@ -48,11 +45,44 @@ describe Forum do
     end
 
     it "should be visible to a reader" do
-      forums(:public).visible_to?(@reader).should be_true
+      forum.visible_to?(reader).should be_true
     end
     
     it "should not be visible when there is no reader" do
-      forums(:public).visible_to?(nil).should be_false
+      forum.visible_to?(nil).should be_false
+    end
+  end
+
+  it "should have a groups association" do
+    Forum.reflect_on_association(:groups).should_not be_nil
+  end
+  
+  describe "when a reader is not grouped" do
+    it "should list only the ungrouped forums" do
+      Forum.visible.should =~ unrestricted
+      Forum.visible_to(readers(:ungrouped)).should =~ unrestricted
+    end
+  end
+  
+  describe "to a grouped reader" do
+    it "should list also the forums of that group" do
+      Forum.visible_to(readers(:another)).should =~ unrestricted + [group_forum]
+    end
+  end
+
+  describe "with a group" do
+    it "should report itself visible to a reader who is a group member" do
+      group_forum.visible_to?(readers(:another)).should be_true
+    end
+    it "should report itself invisible to a reader who is not a group member" do
+      group_forum.visible_to?(readers(:normal)).should be_false
+    end
+  end
+
+  describe "without a group" do
+    it "should report itself visible to everyone" do
+      forum.visible_to?(readers(:normal)).should be_true
+      forum.visible_to?(readers(:another)).should be_true
     end
   end
 

data/spec/models/post_spec.rb

@@ -23,12 +23,16 @@ describe Post do
     describe "when added to a topic" do
       before do
         Rails.logger.warn ">>"
-        post = topics(:older).posts.create!(:body => 'newly added', :reader => readers(:idle))
+        @post = topics(:older).posts.create!(:body => 'and its my post about new marmalade', :reader => readers(:normal))
       end
       
+      it "should update its indexable form" do
+        @post.search_text.should == "older post new marmalade"
+      end
+
       it "should update topic reply data" do
         topic = Topic.find(topic_id(:older))
-        topic.replied_by.should == readers(:idle)
+        topic.replied_by.should == readers(:normal)
         topic.replied_at.should be_close(Time.now, 10.seconds)
       end
     end
@@ -45,7 +49,7 @@ describe Post do
     end
 
     it "should not be editable by anyone else" do 
-      @post.editable_by?(readers(:idle)).should be_false
+      @post.editable_by?(readers(:another)).should be_false
     end
   end
   
@@ -60,14 +64,14 @@ describe Post do
     end
 
     it "should not be editable by anyone else" do 
-      @post.editable_by?(readers(:idle)).should be_false
+      @post.editable_by?(readers(:another)).should be_false
     end
   end
 
   describe "on removal" do
     before do
       @last = topics(:older).posts.last
-      @post = topics(:older).posts.create!(:body => 'uh oh', :reader => readers(:idle))
+      @post = topics(:older).posts.create!(:body => 'uh oh', :reader => readers(:normal))
     end
     it "should revert topic reply data" do
       @post.destroy
@@ -84,7 +88,7 @@ describe Post do
     55.times do |i| 
       topics(:older).posts.create!(:body => 'rhubarb', :reader => readers(:normal))
     end
-    lastpost = topics(:older).posts.create!(:body => 'bar', :reader => readers(:idle))
+    lastpost = topics(:older).posts.create!(:body => 'bar', :reader => readers(:normal))
     firstpost.page_when_paginated.should == 1
     lastpost.page_when_paginated.should == 3
   end

data/spec/models/topic_spec.rb

@@ -4,30 +4,29 @@ describe Topic do
   dataset :forums
 
   describe "on creation" do
-    before do
-      @post = Post.create!(
+    let(:topic) {
+      Post.create!(
         :body => "first post body", 
         :reader_id => reader_id(:normal),
         :topic_attributes => {
           :name => 'testing',
           :forum_id => forum_id(:public)
         }
-      )
-      @topic = @post.topic
-    end
-    
+      ).topic
+      
+    }    
     it "should set default values" do
-      @topic.sticky?.should be_false
-      @topic.locked?.should be_false
-      @topic.replied_by.should == readers(:normal)
-      @topic.replied_at.should be_close(Time.now, 1.minute)
+      topic.sticky?.should be_false
+      topic.locked?.should be_false
+      topic.replied_by.should == readers(:normal)
+      topic.replied_at.should be_close(Time.now, 1.minute)
     end
 
     [:name].each do |field|
       it "should require a #{field}" do
-        @topic.send("#{field}=".intern, nil)
-        @topic.should_not be_valid
-        @topic.errors.on(field).should_not be_empty
+        topic.send("#{field}=".intern, nil)
+        topic.should_not be_valid
+        topic.errors.on(field).should_not be_empty
       end
     end
     
@@ -37,11 +36,11 @@ describe Topic do
       end
 
       it "should be visible to a reader" do
-        @topic.visible_to?(@reader).should be_true
+        topic.visible_to?(@reader).should be_true
       end
 
       it "should be visible when there is no reader" do
-        @topic.visible_to?(nil).should be_true
+        topic.visible_to?(nil).should be_true
       end
     end
 
@@ -51,11 +50,21 @@ describe Topic do
       end
 
       it "should be visible to a reader" do
-        @topic.visible_to?(readers(:idle)).should be_true
+        topic.visible_to?(readers(:normal)).should be_true
       end
 
       it "should not be visible when there is no reader" do
-        @topic.visible_to?(nil).should be_false
+        topic.visible_to?(nil).should be_false
+      end
+    end
+    
+    describe "in a grouped forum" do
+      it "should be visible to a group member" do
+        topics(:grouped).visible_to?(readers(:another)).should be_true
+      end
+
+      it "should not be visible to a non group member" do
+        topics(:grouped).visible_to?(readers(:normal)).should be_false
       end
     end
   end

data/spec/spec_helper.rb

@@ -20,6 +20,7 @@ Radiant::Config['site.title'] = 'Test Site'
 Radiant::Config['site.url'] = 'www.example.com'
 Radiant::Config['readers.layout'] = 'Main'
 Dataset::Resolver.default << (File.dirname(__FILE__) + "/datasets")
+Dataset::Resolver.default << (ReaderExtension.root + "/spec/datasets")
 
 if File.directory?(File.dirname(__FILE__) + "/matchers")
   Dir[File.dirname(__FILE__) + "/matchers/*.rb"].each {|file| require file }