added pool unit test

app/models/pool.rb

@@ -1,27 +1,81 @@
 class Pool < ActiveRecord::Base
+  attr_accessor :updater_id, :updater_ip_addr
   validates_uniqueness_of :name
-  validates_presence_of :name
+  validates_presence_of :name, :updater_id, :updater_ip_addr
   validates_format_of :name, :with => /\A[^\s;,]+\Z/, :on => :create, :message => "cannot have whitespace, commas, or semicolons"
   belongs_to :creator, :class_name => "User"
+  belongs_to :updater, :class_name => "User"
   has_many :versions, :class_name => "PoolVersion"
+  after_save :create_version
   
-  def self.create_anonymous(creator)
-    pool = Pool.create(:name => "TEMP - #{Time.now.to_f}.#{rand(1_000_000)}", :creator => creator)
-    pool.update_attribute(:name => "anonymous:#{pool.id}")
+  def self.create_anonymous(creator, creator_ip_addr)
+    pool = Pool.create(:name => "TEMP:#{Time.now.to_f}.#{rand(1_000_000)}", :creator => creator, :updater_id => creator.id, :updater_ip_addr => creator_ip_addr)
+    pool.update_attribute(:name, "anonymous:#{pool.id}")
     pool
   end
   
+  def revert_to!(version)
+    self.post_ids = version.post_ids
+    save
+  end
+  
+  def add_post!(post)
+    self.post_ids += " #{post.id}"
+    self.post_ids.strip!
+    save
+  end
+  
+  def remove_post!(post)
+    post_ids.gsub!(/(?:\A| )#{post.id}(?:\Z| )/, " ")
+    post_ids.strip!
+    save
+  end
+  
+  def posts(options = {})
+    offset = options[:offset] || 0
+    limit = options[:limit] || 20
+    ids = post_id_array[offset, limit]
+    Post.where(["id IN (?)", ids])
+  end
+  
+  def post_id_array
+    @post_id_array ||= post_ids.scan(/\d+/).map(&:to_i)
+  end
+  
+  def clear_post_id_array
+    @post_id_array = nil
+  end
+  
   def neighbor_posts(post)
     post_ids =~ /\A#{post.id} (\d+)|(\d+) #{post.id} (\d+)|(\d+) #{post.id}\Z/
     
     if $2 && $3
       {:previous => $2.to_i, :next => $3.to_i}
     elsif $1
-      {:previous => $1.to_i}
+      {:next => $1.to_i}
     elsif $4
-      {:next => $4.to_i}
+      {:previous => $4.to_i}
     else
       nil
     end
   end
+  
+  def create_version
+    last_version = versions.last
+    
+    if last_version && updater_ip_addr == last_version.updater_ip_addr && updater_id == last_version.updater_id
+      last_version.update_attribute(:post_ids, post_ids)
+    else
+      versions.create(
+        :post_ids => post_ids,
+        :updater_id => updater_id,
+        :updater_ip_addr => updater_ip_addr
+      )
+    end
+  end
+  
+  def reload(options = {})
+    super
+    clear_post_id_array
+  end
 end

app/models/post.rb

@@ -134,6 +134,13 @@ class Post < ActiveRecord::Base
       
       raise PostVersion::Error.new(version.errors.full_messages.join("; ")) if version.errors.any?
     end
+    
+    def revert_to!(version)
+      self.source = version.source
+      self.rating = version.rating
+      self.tag_string = version.tag_string
+      save
+    end
   end
   
   module TagMethods
@@ -451,11 +458,13 @@ class Post < ActiveRecord::Base
     def add_pool(pool)
       self.pool_string += " pool:#{pool.name}"
       self.pool_string.strip!
+      pool.add_post!(self)
     end
     
     def remove_pool(pool)
       self.pool_string.gsub!(/(?:\A| )pool:#{pool.name}(?:\Z| )/, " ")
       self.pool_string.strip!
+      pool.remove_post!(self)
     end
   end
   

test/factories/pool.rb

@@ -2,4 +2,6 @@ Factory.define(:pool) do |f|
   f.name {Faker::Name.first_name}
   f.creator {|x| x.association(:user)}
   f.description {Faker::Lorem.sentences}
+  f.updater_id {|x| x.creator_id}
+  f.updater_ip_addr "127.0.0.1"
 end

test/factories/post.rb

@@ -11,4 +11,5 @@ Factory.define(:post) do |f|
   f.image_width 100
   f.image_height 200
   f.file_size 2000
+  f.rating "q"
 end

test/unit/pool_test.rb

@@ -1,8 +1,65 @@
-require 'test_helper'
+require File.dirname(__FILE__) + '/../test_helper'
 
 class PoolTest < ActiveSupport::TestCase
-  # Replace this with your real tests.
-  test "the truth" do
-    assert true
+  context "A pool" do
+    should "create versions for each distinct user" do
+      pool = Factory.create(:pool)
+      user = Factory.create(:user)
+      assert_equal(1, pool.versions(true).size)
+      pool.update_attributes(:post_ids => "1", :updater_id => user.id, :updater_ip_addr => "128.0.0.1")
+      assert_equal(2, pool.versions(true).size)
+      pool.update_attributes(:post_ids => "1 2", :updater_id => user.id, :updater_ip_addr => "128.0.0.1")
+      assert_equal(2, pool.versions(true).size)
+      pool.revert_to!(PoolVersion.first)
+      assert_equal("", pool.post_ids)
+    end
+    
+    should "have posts" do
+      pool = Factory.create(:pool)
+      p1 = Factory.create(:post)
+      p2 = Factory.create(:post)
+      p3 = Factory.create(:post)
+      p4 = Factory.create(:post)
+      p1.add_pool(pool)
+      p2.add_pool(pool)
+      p3.add_pool(pool)
+      
+      assert_equal("#{p1.id} #{p2.id} #{p3.id}", pool.post_ids)
+      assert_equal([p1.id, p2.id, p3.id], pool.post_id_array)
+      posts = pool.posts.all
+      assert_equal(3, posts.size)
+      assert_equal([p1.id, p2.id, p3.id], posts.map(&:id))
+      posts = pool.posts(:limit => 1, :offset => 1).all
+      assert_equal(1, posts.size)
+      assert_equal([p2.id], posts.map(&:id))
+    end
+    
+    should "return the neighboring posts for any member element" do
+      pool = Factory.create(:pool)
+      p1 = Factory.create(:post)
+      p2 = Factory.create(:post)
+      p3 = Factory.create(:post)
+      p1.add_pool(pool)
+      p2.add_pool(pool)
+      p3.add_pool(pool)
+      neighbors = pool.neighbor_posts(p1)
+      assert_nil(neighbors[:previous])
+      assert_equal(p2.id, neighbors[:next])
+      neighbors = pool.neighbor_posts(p2)
+      assert_equal(p1.id, neighbors[:previous])
+      assert_equal(p3.id, neighbors[:next])
+      neighbors = pool.neighbor_posts(p3)
+      assert_equal(p2.id, neighbors[:previous])
+      assert_nil(neighbors[:next])
+    end
+  end
+  
+  context "An anonymous pool" do
+    should "have a name starting with anonymous" do
+      user = Factory.create(:user)
+      pool = Pool.create_anonymous(user, "127.0.0.1")
+      assert_match(/^anonymous:\d+$/, pool.name)
+      
+    end
   end
 end

test/unit/post_test.rb

@@ -45,6 +45,10 @@ class PostTest < ActiveSupport::TestCase
       assert_equal(2, @post.versions.size)
       assert_equal(@user.id, @post.versions.last.updater_id)
       assert_equal("125.0.0.0", @post.versions.last.updater_ip_addr)
+      
+      @post.revert_to!(PostVersion.first)
+      assert_equal("tag1 tag2", @post.tag_string)
+      assert_equal("q", @post.rating)
     end
   end