spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/test/unit/test_revisions.rb

@@ -5,6 +5,8 @@ require File.expand_path('../../test_helper', __FILE__)
 
 class RevisionsTest < MiniTest::Spec
 
+  Revision = Spontaneous::Publishing::Revision
+
   def setup
     @now = Time.now
     @site = setup_site
@@ -20,11 +22,11 @@ class RevisionsTest < MiniTest::Spec
 
       Content.delete
 
-      class Page < Spontaneous::Page
+      class Page < ::Page
         field :title, :string, :default => "New Page"
         box :things
       end
-      class Piece < Spontaneous::Piece
+      class Piece < ::Piece
         box :things
       end
 
@@ -53,14 +55,13 @@ class RevisionsTest < MiniTest::Spec
       RevisionsTest.send(:remove_const, :Page) rescue nil
       RevisionsTest.send(:remove_const, :Piece) rescue nil
       Content.delete
-      DB.logger = nil
     end
 
     context "data sources" do
 
       should "have the right names" do
-        Content.revision_table(23).should == '__r00023_content'
-        Content.revision_table(nil).should == 'content'
+        Content.revision_table(23).should == :'__r00023_content'
+        Content.revision_table(nil).should == :'content'
       end
 
       should "be recognisable" do
@@ -71,13 +72,11 @@ class RevisionsTest < MiniTest::Spec
       end
 
       should "be switchable within blocks" do
-        Content.dataset.should be_content_revision
         Content.with_revision(23) do
           Content.revision.should ==23
-          Content.dataset.should be_content_revision(23)
+          Content.mapper.current_revision.should == 23
         end
-        Content.dataset.should  be_content_revision
-        Content.revision.should be_nil
+        Content.mapper.current_revision.should be_nil
       end
 
       should "know which revision is active" do
@@ -86,57 +85,46 @@ class RevisionsTest < MiniTest::Spec
         end
       end
 
-      should "understand the with_editable" do
+      should "understand with_editable" do
         Content.with_revision(23) do
-          Content.dataset.should be_content_revision(23)
+          Content.mapper.current_revision.should == 23
           Content.with_editable do
-            Content.dataset.should be_content_revision
+            Content.mapper.current_revision.should be_nil
           end
-          Content.dataset.should be_content_revision(23)
         end
-        Content.dataset.should be_content_revision
       end
 
       should "understand with_published" do
-        Site.stubs(:published_revision).returns(99)
+        S::Site.stubs(:published_revision).returns(99)
         Content.with_published do
-          Content.dataset.should be_content_revision(99)
-          Content.with_editable do
-            Content.dataset.should be_content_revision
-          end
-          Content.dataset.should be_content_revision(99)
+          Content.mapper.current_revision.should == 99
         end
-        Content.dataset.should be_content_revision
       end
 
       should "be stackable" do
-        Content.dataset.should be_content_revision
         Content.with_revision(23) do
-          Content.dataset.should be_content_revision(23)
+          Content.mapper.current_revision.should == 23
           Content.with_revision(24) do
-            Content.dataset.should be_content_revision(24)
+            Content.mapper.current_revision.should == 24
           end
-          Content.dataset.should be_content_revision(23)
         end
-        Content.dataset.should be_content_revision
       end
 
       should "reset datasource after an exception" do
-        Content.dataset.should be_content_revision
         begin
           Content.with_revision(23) do
-            Content.dataset.should be_content_revision(23)
+            Content.mapper.current_revision.should == 23
             raise Exception.new
           end
         rescue Exception
         end
-        Content.dataset.should be_content_revision
+        Content.mapper.current_revision.should be_nil
       end
 
       should "read revision from the environment if present" do
         ENV["SPOT_REVISION"] = '1001'
         Content.with_published do
-          Content.dataset.should be_content_revision(1001)
+          Content.mapper.current_revision.should == 1001
         end
         ENV.delete("SPOT_REVISION")
       end
@@ -152,14 +140,11 @@ class RevisionsTest < MiniTest::Spec
 
         should "set all subclasses to use the same dataset" do
           Content.with_revision(23) do
-            Subclass.revision.should ==23
-            Subclass.dataset.should be_content_revision(23, Subclass.schema_id)
+            Subclass.revision.should == 23
+            Subclass.mapper.current_revision.should == 23
             # piece wasn't loaded until this point
-            Piece.dataset.should  be_content_revision(23)
-            Piece.revision.should == 23
+            Piece.mapper.current_revision.should == 23
           end
-          Subclass.dataset.should  be_content_revision(nil, Subclass.schema_id)
-          Piece.dataset.should  be_content_revision(nil)
         end
       end
     end
@@ -167,76 +152,79 @@ class RevisionsTest < MiniTest::Spec
     context "content revisions" do
       setup do
         @revision = 1
+        Revision.history_dataset(Content).delete
+        Revision.archive_dataset(Content).delete
       end
+
       teardown do
-        Content.delete_revision(@revision)
-        Content.delete_revision(@revision+1) rescue nil
+        Revision.delete_all(Content)
       end
+
       should "be testable for existance" do
         Content.revision_exists?(@revision).should be_false
-        Content.create_revision(@revision)
-        Content.revision_exists?(@revision).should be_true
+        Revision.create(Content, @revision)
+        Revision.exists?(Content, @revision).should be_true
       end
+
+      should "not be deletable if their revision is nil" do
+        Revision.delete(Content, nil)
+        Content.db.table_exists?(:content).should be_true
+      end
+
       should "be deletable en masse" do
-        tables = (1..10).map { |i| Content.revision_table(i).to_sym }
+        revisions = (1..10).to_a
+        tables = revisions.map { |i| Content.revision_table(i).to_sym }
+
+        revisions.each do |r|
+          Content.history_dataset.insert(:revision => r, :uid => "revision-#{r}")
+          Content.archive_dataset.insert(:revision => r, :uid => "archive-#{r}")
+        end
+
+        Content.history_dataset.count.should == 10
+        Content.archive_dataset.count.should == 10
+
         tables.each do |t|
-          DB.create_table(t){Integer :id}
+          DB.create_table(t){Integer :id} rescue nil
         end
+
         tables.each do |t|
           DB.tables.include?(t).should be_true
         end
-        Content.delete_all_revisions!
+
+        Revision.delete_all(Content)
+
         tables.each do |t|
           DB.tables.include?(t).should be_false
         end
+
+        Content.history_dataset.count.should == 0
+        Content.archive_dataset.count.should == 0
       end
 
       should "be creatable from current content" do
         DB.tables.include?(Content.revision_table(@revision).to_sym).should be_false
-        Content.create_revision(@revision)
+        Revision.create(Content, @revision)
         DB.tables.include?(Content.revision_table(@revision).to_sym).should be_true
         count = Content.count
         Content.with_revision(@revision) do
           Content.count.should == count
           Content.all.each do |published|
+            published.revision.should == @revision
             Content.with_editable do
               e = Content[published.id]
-              e.should == published
-            end
-          end
-        end
-      end
-
-      should "be creatable from any revision" do
-        revision = 2
-        source_revision = @revision
-        source_revision_count = nil
-
-        Content.create_revision(source_revision)
-
-        Content.with_revision(source_revision) do
-          Content.first(:uid => "0").destroy
-          source_revision_count = Content.count
-        end
-
-        Content.count.should == source_revision_count + 7
-
-        Content.create_revision(revision, source_revision)
-
-        Content.with_revision(revision) do
-          Content.count.should == source_revision_count
-          Content.all.each do |published|
-
-            Content.with_revision(source_revision) do
-              e = Content.first :id => published.id
-              e.should == published
+              assert_content_equal(e, published, :revision)
+              e.revision.should be_nil
             end
           end
         end
+        Content.history_dataset(@revision).count.should == count
+        Content.history_dataset.select(:revision).group(:revision).all.should == [{:revision => 1}]
+        Content.archive_dataset(@revision).count.should == count
+        Content.archive_dataset.select(:revision).group(:revision).all.should == [{:revision => 1}]
       end
 
       should "have the correct indexes" do
-        Content.create_revision(@revision)
+        Revision.create(Content, @revision)
         content_indexes = DB.indexes(:content)
         published_indexes = DB.indexes(Content.revision_table(@revision))
         # made slightly complex by the fact that the index names depend on the table names
@@ -244,24 +232,34 @@ class RevisionsTest < MiniTest::Spec
         assert_same_elements published_indexes.values, content_indexes.values
       end
 
+      should "only be kept until a new revision is available" do
+        (0..2).each do |r|
+          Revision.create(Content, @revision+r)
+          Content.history_dataset(@revision+r).count.should == 15
+          Content.archive_dataset(@revision+r).count.should == 15
+        end
+        Content.revision_tables.should == [:__r00001_content, :__r00002_content, :__r00003_content]
+        Revision.cleanup(Content, @revision+2, 2)
+        Content.revision_tables.should == [:__r00003_content]
+        Content.history_dataset(@revision).count.should == 0
+        Content.archive_dataset(@revision).count.should == 15
+        Content.history_dataset(@revision+2).count.should == 15
+      end
+
 
       context "incremental publishing" do
         setup do
           @initial_revision = 1
           @final_revision = 2
-          Content.create_revision(@initial_revision)
-          Content.delete_revision(@final_revision) rescue nil
-          Content.delete_revision(@final_revision+1) rescue nil
+          Revision.create(Content, @initial_revision)
+          Revision.delete(Content, @final_revision) rescue nil
+          Revision.delete(Content, @final_revision+1) rescue nil
         end
 
         teardown do
-          begin
-            Content.delete_revision(@initial_revision)
-            Content.delete_revision(@final_revision)
-            Content.delete_revision(@final_revision+1)
-          rescue
-          end
-          DB.logger = nil
+          Revision.create(Content, @initial_revision) rescue nil
+          Revision.delete(Content, @final_revision) rescue nil
+          Revision.delete(Content, @final_revision+1) rescue nil
         end
 
         should "duplicate changes to only a single item" do
@@ -273,14 +271,13 @@ class RevisionsTest < MiniTest::Spec
           editable2.label = "unpublished"
           editable2.save
           editable2.reload
-          Content.publish(@final_revision, [editable1.id])
+          Revision.patch(Content, @final_revision, [editable1.id])
           editable1.reload
           Content.with_revision(@final_revision) do
             published = Content.first :id => editable1.id
             unpublished = Content.first :id => editable2.id
-            assert_content_equal(published, editable1)
-
-            unpublished.should_not == editable2
+            assert_content_equal(published, editable1, :revision)
+            assert_content_unequal(unpublished, editable2, :revision)
           end
         end
 
@@ -290,14 +287,14 @@ class RevisionsTest < MiniTest::Spec
 
           editable1.things << new_content
           editable1.save
-          Content.publish(@final_revision, [editable1.id])
+          Revision.patch(Content, @final_revision, [editable1.id])
           new_content.reload
           editable1.reload
           Content.with_revision(@final_revision) do
             published1 = Content[editable1.id]
             published2 = Content[new_content.id]
-            assert_content_equal(published2, new_content)
-            assert_content_equal(published1, editable1)
+            assert_content_equal(published2, new_content, :revision)
+            assert_content_equal(published1, editable1, :revision)
           end
         end
 
@@ -305,11 +302,11 @@ class RevisionsTest < MiniTest::Spec
           editable1 = Content.first(:uid => '0')
           deleted = editable1.contents.first
           editable1.contents.first.destroy
-          Content.publish(@final_revision, [editable1.id])
+          Revision.patch(Content, @final_revision, [editable1.id])
           editable1.reload
           Content.with_revision(@final_revision) do
             published1 = Content[editable1.id]
-            assert_content_equal(published1, editable1)
+            assert_content_equal(published1, editable1, :revision)
             Content[deleted.id].should be_nil
           end
         end
@@ -320,14 +317,14 @@ class RevisionsTest < MiniTest::Spec
           editable1.things << new_page
           editable1.save
           new_page.save
-          Content.publish(@final_revision, [editable1.id])
+          Revision.patch(Content, @final_revision, [editable1.id])
           new_page.reload
           editable1.reload
           Content.with_revision(@final_revision) do
             published1 = Content[editable1.id]
             published2 = Content[new_page.id]
             published2.should be_nil
-            assert_content_equal(published1, editable1)
+            assert_content_equal(published1, editable1, :revision)
           end
         end
 
@@ -339,7 +336,7 @@ class RevisionsTest < MiniTest::Spec
           new_content = Piece.new(:uid => "new")
           editable2.things << new_content
           editable2.save
-          Content.publish(@final_revision, [editable1.id])
+          Revision.patch(Content, @final_revision, [editable1.id])
           editable1.reload
           editable2.reload
           new_content.reload
@@ -347,43 +344,43 @@ class RevisionsTest < MiniTest::Spec
             published1 = Content.first :id => editable1.id
             Content.first(:uid => "added").should_not be_nil
             published3 = Content.first :id => editable2.id
-            assert_content_equal(published1, editable1)
-            published3.should_not == editable2
+            assert_content_equal(published1, editable1, :revision)
+            assert_content_unequal(published3, editable2, :revision)
             published3.uid.should_not == "new"
           end
-          Content.publish(@final_revision+1, [editable2.id])
+          Revision.patch(Content, @final_revision+1, [editable2.id])
           editable1.reload
           editable2.reload
           new_content.reload
           Content.with_revision(@final_revision+1) do
             published1 = Content.first :id => editable1.id
-            assert_content_equal(published1, editable1)
+            assert_content_equal(published1, editable1, :revision)
             published2 = Content.first :id => editable2.id
-            assert_content_equal(published2, editable2)
+            assert_content_equal(published2, editable2, :revision)
             published3 = Content.first :id => editable2.contents.first.id
             # published3.should == editable2.contents.first
-            assert_content_equal(published3, editable2.contents.first)
+            assert_content_equal(published3, editable2.contents.first, :revision)
           end
         end
 
-        should "insert an entry value into the parent of a newly added page when that page is published" do
+        should "insert an entry value into the parent of a newly added page when that page is published aaa" do
           editable1 = Content.first(:uid => '0')
           new_page = Page.new(:uid => "new")
           editable1.things << new_page
           editable1.save
           new_page.save
-          Content.publish(@final_revision, [new_page.id])
+          Revision.patch(Content, @final_revision, [new_page.id])
           new_page.reload
           editable1.reload
           Content.with_revision(@final_revision) do
             published1 = Content[editable1.id]
             published2 = Content[new_page.id]
-            assert_content_equal(published2, new_page)
+            assert_content_equal(published2, new_page, :revision)
             editable1.entry_store.should == published1.entry_store
           end
         end
 
-        should "choose a sensible position for entry into the parent of a newly added page xxx" do
+        should "choose a sensible position for entry into the parent of a newly added page" do
           editable1 = Content.first(:uid => '0')
           new_page1 = Page.new(:uid => "new1")
           new_page2 = Page.new(:uid => "new2")
@@ -392,7 +389,7 @@ class RevisionsTest < MiniTest::Spec
           editable1.save
           new_page1.save
           new_page2.save
-          Content.publish(@final_revision, [new_page2.id])
+          Revision.patch(Content, @final_revision, [new_page2.id])
           new_page1.reload
           new_page2.reload
           editable1.reload
@@ -401,7 +398,7 @@ class RevisionsTest < MiniTest::Spec
             published2 = Content[new_page1.id]
             published3 = Content[new_page2.id]
             published2.should be_nil
-            assert_content_equal(published3, new_page2)
+            assert_content_equal(published3, new_page2, :revision)
             editable1.entry_store.reject { |e| e[0] == new_page1.id }.should == published1.entry_store
           end
         end
@@ -415,7 +412,7 @@ class RevisionsTest < MiniTest::Spec
           editable1.save
           new_page1.save
           new_page2.save
-          Content.publish(@final_revision, [editable1.id, new_page2.id])
+          Revision.patch(Content, @final_revision, [editable1.id, new_page2.id])
           new_page1.reload
           new_page2.reload
           editable1.reload
@@ -424,8 +421,8 @@ class RevisionsTest < MiniTest::Spec
             published2 = Content[new_page1.id]
             published3 = Content[new_page2.id]
             published2.should be_nil
-            assert_content_equal(published3, new_page2)
-            assert_content_equal(published1, editable1)
+            assert_content_equal(published3, new_page2, :revision)
+            assert_content_equal(published1, editable1, :revision)
           end
         end
 
@@ -434,7 +431,7 @@ class RevisionsTest < MiniTest::Spec
           piece = page.things.first
           child = piece.things.first
           page.things.first.destroy
-          Content.publish(@final_revision, [page.id])
+          Revision.patch(Content, @final_revision, [page.id])
 
           Content.with_revision(@final_revision) do
             published_parent = Content[page.id]
@@ -452,18 +449,18 @@ class RevisionsTest < MiniTest::Spec
     context "publication timestamps" do
       setup do
         @revision = 1
-        Content.delete_revision(@revision+1)
+        Revision.delete(Content, @revision+1)
       end
       teardown do
-        Content.delete_revision(@revision)
-        Content.delete_revision(@revision+1)
+        Revision.delete(Content, @revision)
+        Revision.delete(Content, @revision+1)
       end
 
       should "set correct timestamps on first publish" do
         first = Content.first
         first.reload.first_published_at.should be_nil
         first.reload.last_published_at.should be_nil
-        Content.publish(@revision)
+        Revision.create(Content, @revision)
         first.reload.first_published_at.to_i.should == @now.to_i
         first.reload.last_published_at.to_i.should == @now.to_i
         first.reload.first_published_revision.should == @revision
@@ -482,12 +479,12 @@ class RevisionsTest < MiniTest::Spec
       should "set correct timestamps on later publishes" do
         first = Content.first
         first.first_published_at.should be_nil
-        Content.publish(@revision)
+        Revision.create(Content, @revision)
         first.reload.first_published_at.to_i.should == @now.to_i
         c = Content.create
         c.first_published_at.should be_nil
         stub_time(@now + 100)
-        Content.publish(@revision+1)
+        Revision.create(Content, @revision+1)
         first.reload.first_published_at.to_i.should == @now.to_i
         first.reload.last_published_at.to_i.should == @now.to_i + 100
         Content.with_editable do
@@ -501,22 +498,22 @@ class RevisionsTest < MiniTest::Spec
       end
 
       should "not set publishing date for items not published" do
-        Content.publish(@revision)
+        Revision.create(Content, @revision)
         page = Content.first
         page.uid = "fish"
         page.save
         added = Content.create
         added.first_published_at.should be_nil
-        Content.publish(@revision+1, [page])
+        Revision.patch(Content, @revision+1, [page])
         page.first_published_at.to_i.should == @now.to_i
         added.first_published_at.should be_nil
         added.last_published_at.should be_nil
       end
 
-      should "not set publishing dates if exception raised in passed block" do
+      should "not set publishing dates if exception raised in passed block xxx" do
         Content.first.first_published_at.should be_nil
         begin
-          Content.publish(@revision) do
+          Revision.create(Content, @revision) do
             raise Exception
           end
         rescue Exception; end
@@ -524,21 +521,21 @@ class RevisionsTest < MiniTest::Spec
       end
 
       should "delete revision tables if exception raised in passed block" do
-        Content.revision_exists?(@revision).should be_false
+        Revision.exists?(Content, @revision).should be_false
         begin
-          Content.publish(@revision) do
-            Content.revision_exists?(@revision).should be_true
+          Revision.create(Content, @revision) do
+            Revision.exists?(Content, @revision).should be_true
             Content.revision.should == @revision
             raise Exception
           end
         rescue Exception; end
-        Content.revision_exists?(@revision).should be_false
+        Revision.exists?(Content, @revision).should be_false
       end
 
       should "always publish all if no previous revisions exist" do
         page = Content.first
         Content.filter(:first_published_at => nil).count.should == Content.count
-        Content.publish(@revision, [page])
+        Revision.patch(Content, @revision, [page])
         Content.filter(:first_published_at => nil).count.should == 0
       end
     end