spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/test/unit/test_changesets.rb

@@ -0,0 +1,261 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+
+class ChangeTest < MiniTest::Spec
+
+  def setup
+    @now = Time.now
+    @site = setup_site
+  end
+
+  def teardown
+    teardown_site
+  end
+
+  context "Changes" do
+    setup do
+      @revision = 1
+      stub_time(@now)
+
+      # DB.logger = Logger.new($stdout)
+      Content.delete
+
+      class Page < Spontaneous::Page
+        field :title, :string, :default => "New Page"
+        box :things
+      end
+      class Piece < Spontaneous::Piece
+        box :things
+      end
+    end
+
+    teardown do
+      ChangeTest.send(:remove_const, :Page) rescue nil
+      ChangeTest.send(:remove_const, :Piece) rescue nil
+      Content.delete_revision(@revision) rescue nil
+      Content.delete_revision(@revision+1) rescue nil
+      Content.delete
+      DB.logger = nil
+    end
+
+
+
+    should "list all newly created pages" do
+      root = Page.create(:title => "root")
+      root[:first_published_at] = root[:last_published_at] = root.modified_at + 1000
+      root.save
+
+      5.times { |i| root.things << Page.create(:title => "Page #{i+1}") }
+
+      result = Change.outstanding
+      result.must_be_instance_of(Array)
+      result.length.should == 5
+
+      result.map(&:class).should == [Change]*5
+
+      Set.new(result.map(&:page_id)).should == Set.new(root.things.map { |p| p.id })
+    end
+
+    should "not list new pieces as available for publish" do
+      root = Page.create(:title => "root")
+      Content.publish(@revision)
+      # force root to appear in the modified lists -- need this because otherwise the changes happen
+      # more quickly than the resolution of the timestamps can register
+      root[:first_published_at] = root[:last_published_at] = root.modified_at - 1000
+      root.things << Piece.new
+      root.save.reload
+      result = Change.outstanding
+      result.length.should == 1
+      result.first.page.should == root
+    end
+
+    should "not list pages that have been published" do
+      root = Page.create(:title => "root")
+
+      Content.publish(@revision)
+
+      5.times { |i| root.things << Page.create(:title => "Page #{i+1}") }
+      root.save
+
+      Content.publish(@revision+1, [root.id, root.things.first.id])
+
+      result = Change.outstanding
+      result.length.should == 4
+      Set.new(result.map(&:page_id).flatten).should == Set.new(root.things[1..-1].map(&:id))
+    end
+
+    should "group unpublished parents with their children" do
+      root = Page.create(:title => "root")
+
+      Content.publish(@revision)
+
+      root.reload
+      page1 = Page.new(:title => "Page 1")
+      root.things << page1
+      new_child1  = Page.new(:title => "New Child 1")
+      page1.things << new_child1
+      new_parent = Page.new(:title => "New Parent")
+      new_child2  = Page.new(:title => "New Child 2")
+      new_child3  = Page.new(:title => "New Child 3")
+      root.things << new_parent
+      new_parent.things << new_child2
+      new_child2.things << new_child3
+
+      pages = [root, page1, new_child1, new_parent, new_child2, new_child3]
+      pages.each(&:save)
+
+
+      Content.publish(@revision+1, [root.id])
+      result = Change.outstanding
+
+      result.length.should == 5
+
+      id_groups = result.map { |change|
+        [change.page.id, change.dependent.map(&:id)]
+      }
+      Set.new(id_groups).should == Set.new([
+        [page1.id, []],
+        [new_child1.id, [page1.id]],
+        [new_parent.id, []],
+        [new_child2.id, [new_parent.id ]],
+        [new_child3.id, [new_parent.id, new_child2.id]]
+      ])
+    end
+
+    should "successfully publish list of dependent pages" do
+      root = Page.create(:title => "root")
+
+      Content.publish(@revision)
+
+      root.reload
+      page1 = Page.new(:title => "Page 1")
+      root.things << page1
+      new_child1  = Page.new(:title => "New Child 1")
+      page1.things << new_child1
+      new_parent = Page.new(:title => "New Parent")
+      new_child2  = Page.new(:title => "New Child 2")
+      new_child3  = Page.new(:title => "New Child 3")
+      root.things << new_parent
+      new_parent.things << new_child2
+      new_child2.things << new_child3
+
+      pages = [root, page1, new_child1, new_parent, new_child2, new_child3]
+      pages.each(&:save)
+
+
+      Content.publish(@revision+1, [root.id])
+      result = Change.outstanding
+
+      e = nil
+      begin
+        pages = Spontaneous::Change.include_dependencies([new_child3])
+        Content.publish(@revision+2, pages)
+        Content.delete_revision(@revision + 2) rescue nil
+      rescue => e
+        Content.delete_revision(@revision + 2) rescue nil
+        raise
+      end
+    end
+
+    should "provide page & dependency information in serializable format" do
+      root = Page.create(:title => "root")
+
+      Content.publish(@revision)
+
+      root.reload
+      page1 = Page.new(:title => "Page 1")
+      root.things << page1
+      new_child1  = Page.new(:title => "New Child 1")
+      page1.things << new_child1
+      root.save
+
+      Content.publish(@revision+1, [root.id])
+      result = Change.outstanding
+      change = result.detect { |change| change.page.id == new_child1.id }
+      change.export.should == {
+        :id => new_child1.id,
+        :title => new_child1.title.value,
+        :url => new_child1.path,
+        :published_at => nil,
+        :modified_at => new_child1.modified_at.httpdate,
+        # :editor_login => "someone",
+        :depth => new_child1.depth,
+        :side_effects => {},
+        :dependent => [{
+          :id => page1.id,
+          :depth => page1.depth,
+          :title => page1.title.value,
+          :url => page1.path,
+          :side_effects => {},
+          :published_at => nil,
+          :modified_at => page1.modified_at.httpdate,
+        }]
+      }
+    end
+
+    should "order modified changes in reverse modification date order" do
+      root = Page.create(:title => "root")
+
+      Content.publish(@revision)
+
+      root.reload
+      page1 = Page.new(:title => "Page 1")
+      root.things << page1
+      new_child1  = Page.new(:title => "New Child 1")
+      page1.things << new_child1
+      root.save
+      last = Time.now + 100
+      S::Content.filter(:id => new_child1.id).update(:modified_at => last)
+      result = Change.outstanding
+      assert result.first.modified_at > result.last.modified_at, "Change list in incorrect order"
+    end
+
+    should "provide information on side effects of publishing page with path changes" do
+      root = Page.create(:title => "root")
+
+
+      root.reload
+      page1 = Page.new(:title => "Page 1")
+      root.things << page1
+      new_child1  = Page.new(:title => "New Child 1")
+      page1.things << new_child1
+      root.save
+
+      Content.publish(@revision)
+
+      old_slug = page1.slug
+      page1.slug = "changed"
+      page1.save
+
+      result = Change.outstanding
+      change = result.detect { |change| change.page.id == page1.id }
+      change.export[:side_effects].should == {
+        :slug => [{ :count => 1, :created_at => @now.httpdate, :old_value => old_slug, :new_value => "changed"}]
+      }
+    end
+
+    should "provide information on side effects of publishing page with visibility changes" do
+      root = Page.create(:title => "root")
+
+
+      root.reload
+      page1 = Page.new(:title => "Page 1")
+      root.things << page1
+      new_child1  = Page.new(:title => "New Child 1")
+      page1.things << new_child1
+      root.save
+
+      Content.publish(@revision)
+
+      page1.hide!
+
+      result = Change.outstanding
+      change = result.detect { |change| change.page.id == page1.id }
+      change.export[:side_effects].should == {
+        :visibility => [{ :count => 1, :created_at => @now.httpdate, :old_value => false, :new_value => true}]
+      }
+    end
+  end
+end

data/test/unit/test_content.rb

@@ -8,15 +8,22 @@ class ContentTest < MiniTest::Spec
     setup do
       @site = setup_site
       class Piece < Spontaneous::Piece; end
+      class Page < Spontaneous::Page; end
       class C < Piece; end
+      class P < Page; end
       C.box :things
+      P.box :box1
+      P.box :box2
     end
 
     teardown do
       teardown_site
       ContentTest.send(:remove_const, :Piece) rescue nil
+      ContentTest.send(:remove_const, :Page) rescue nil
       ContentTest.send(:remove_const, :C) rescue nil
+      ContentTest.send(:remove_const, :P) rescue nil
     end
+
     context "Content instances" do
       should "evaluate instance code" do
         @instance = C.create({
@@ -37,20 +44,24 @@ class ContentTest < MiniTest::Spec
         Content.delete
       end
       should "be initialised empty" do
-        @instance.pieces.should == []
+        @instance.contents.should == []
+      end
+
+      should "provide a #target method poiting to itself" do
+        @instance.target.should == @instance
       end
 
       should "accept addition of child content" do
         e = C.new
         @instance.things << e
-        @instance.pieces.length.should == 1
-        @instance.things.pieces.length.should == 1
-        @instance.pieces.first.should == e
-        @instance.pieces.first.container.should == @instance.things
-        @instance.pieces.first.owner.should == @instance
-        @instance.pieces.first.parent.should == @instance
+        @instance.contents.length.should == 1
+        @instance.things.contents.length.should == 1
+        @instance.contents.first.should == e
+        @instance.contents.first.container.should == @instance.things
+        @instance.contents.first.owner.should == @instance
+        @instance.contents.first.parent.should == @instance
         e.visibility_path.should == "#{@instance.id}"
-        @instance.pieces.first.visibility_path.should == "#{@instance.id}"
+        @instance.contents.first.visibility_path.should == "#{@instance.id}"
       end
 
       should "accept addition of multiple children" do
@@ -58,20 +69,20 @@ class ContentTest < MiniTest::Spec
         f = C.new
         @instance.things << e
         @instance.things << f
-        @instance.pieces.length.should == 2
-        @instance.things.pieces.length.should == 2
-        @instance.pieces.first.should == e
-        @instance.things.pieces.first.should == e
-        @instance.pieces.last.should == f
-        @instance.things.pieces.last.should == f
-        @instance.pieces.first.container.should == @instance.things
-        @instance.pieces.last.container.should == @instance.things
-        @instance.pieces.first.parent.should == @instance
-        @instance.pieces.last.parent.should == @instance
-        @instance.pieces.first.owner.should == @instance
-        @instance.pieces.last.owner.should == @instance
-        @instance.pieces.first.visibility_path.should == "#{@instance.id}"
-        @instance.pieces.last.visibility_path.should == "#{@instance.id}"
+        @instance.contents.length.should == 2
+        @instance.things.contents.length.should == 2
+        @instance.contents.first.should == e
+        @instance.things.contents.first.should == e
+        @instance.contents.last.should == f
+        @instance.things.contents.last.should == f
+        @instance.contents.first.container.should == @instance.things
+        @instance.contents.last.container.should == @instance.things
+        @instance.contents.first.parent.should == @instance
+        @instance.contents.last.parent.should == @instance
+        @instance.contents.first.owner.should == @instance
+        @instance.contents.last.owner.should == @instance
+        @instance.contents.first.visibility_path.should == "#{@instance.id}"
+        @instance.contents.last.visibility_path.should == "#{@instance.id}"
       end
 
       should "allow for a deep hierarchy" do
@@ -79,8 +90,8 @@ class ContentTest < MiniTest::Spec
         f = C.new
         @instance.things << e
         e.things << f
-        @instance.pieces.length.should == 1
-        @instance.pieces.first.should == e
+        @instance.contents.length.should == 1
+        @instance.contents.first.should == e
         e.owner.id.should == @instance.id
         e.parent.id.should == @instance.id
         e.container.should == @instance.things
@@ -105,8 +116,8 @@ class ContentTest < MiniTest::Spec
         e = C[e.id]
         f = C[f.id]
 
-        i.pieces.length.should == 1
-        i.pieces.first.should == e
+        i.contents.length.should == 1
+        i.contents.first.should == e
 
         e.container.should == i.things
         e.owner.should == i
@@ -114,9 +125,9 @@ class ContentTest < MiniTest::Spec
         f.container.should == e.things
         f.parent.should == e
         f.owner.should == e
-        e.entry.should == i.pieces.first
-        f.entry.should == e.pieces.first
-        e.pieces.first.should == f
+        e.entry.should == i.contents.first
+        f.entry.should == e.contents.first
+        e.contents.first.should == f
       end
 
       should "have a list of child nodes" do
@@ -131,10 +142,35 @@ class ContentTest < MiniTest::Spec
         i = C[@instance.id]
         e = C[e.id]
         f = C[f.id]
-        i.pieces.should == [e]
-        e.pieces.should == [f]
+        i.contents.should == [e]
+        e.contents.should == [f]
+      end
+
+      should "provide a list of non-page contents" do
+        p = P.new
+
+        c1 = C.new
+        c2 = C.new
+        c3 = C.new
+        p1 = P.new
+        p2 = P.new
+        p3 = P.new
+
+        p.box1 << c1
+        p.box1 << c2
+        p.box1 << p1
+
+        p.box2 << p3
+        p.box2 << c3
+
+        [p, c1, c2, c3, p1, p2, p3].each { |c| c.save; c.reload }
+
+        p = P[p.id]
+
+        p.pieces.should == [c1, c2, c3]
       end
 
+
       should "allow for testing of position" do
         e = C.new
         f = C.new
@@ -223,8 +259,8 @@ class ContentTest < MiniTest::Spec
         @b.destroy
         C.count.should == 2
         @a.reload
-        @a.pieces.length.should == 1
-        @a.pieces.first.should == @d.reload
+        @a.contents.length.should == 1
+        @a.contents.first.should == @d.reload
         C.all.map { |c| c.id }.sort.should == [@a, @d].map { |c| c.id }.sort
       end
 
@@ -292,6 +328,10 @@ class ContentTest < MiniTest::Spec
         @b.reload
         @b.visibility_path.should == @r.id.to_s
       end
+
+      should "ensure that child pages have their visibility paths updated" do
+        flunk "Implement this"
+      end
     end
 
 

data/test/unit/test_content_inheritance.rb

@@ -49,26 +49,26 @@ class ContentInheritanceTest < MiniTest::Spec
     end
 
     should "aaa correctly type subclasses found via Content" do
-      Content.all.map { |c| c.class }.should == \
-        [PageClass1, PageClass11, PageClass111, PageClass2, PageClass22,
-          PieceClass1, PieceClass11, PieceClass111, PieceClass2, PieceClass22]
-      Content.all.should == \
-        [@page1, @page11, @page111, @page2, @page22,
-          @piece1, @piece11, @piece111, @piece2, @piece22]
+      Set.new(Content.all.map { |c| c.class }).should == \
+        Set.new([PageClass1, PageClass11, PageClass111, PageClass2, PageClass22,
+          PieceClass1, PieceClass11, PieceClass111, PieceClass2, PieceClass22])
+      Set.new(Content.all).should == \
+        Set.new([@page1, @page11, @page111, @page2, @page22,
+          @piece1, @piece11, @piece111, @piece2, @piece22])
     end
 
     context "Pages" do
 
       should "type subclasses found via Page" do
-        ::Page.all.map { |c| c.class }.should == \
-          [PageClass1, PageClass11, PageClass111, PageClass2, PageClass22]
-        ::Page.all.should == [@page1, @page11, @page111, @page2, @page22]
+        Set.new(::Page.all.map { |c| c.class }).should == \
+          Set.new([PageClass1, PageClass11, PageClass111, PageClass2, PageClass22])
+        Set.new(::Page.all).should == Set.new([@page1, @page11, @page111, @page2, @page22])
       end
 
       should "type subclasses found via Spontaneous::Page" do
-        Spontaneous::Page.all.map { |c| c.class }.should == \
-          [PageClass1, PageClass11, PageClass111, PageClass2, PageClass22]
-        Spontaneous::Page.all.should == [@page1, @page11, @page111, @page2, @page22]
+        Set.new(Spontaneous::Page.all.map { |c| c.class }).should == \
+          Set.new([PageClass1, PageClass11, PageClass111, PageClass2, PageClass22])
+        Set.new(Spontaneous::Page.all).should == Set.new([@page1, @page11, @page111, @page2, @page22])
       end
 
       should "only find instances of a single class when searching via that subclass" do
@@ -82,14 +82,14 @@ class ContentInheritanceTest < MiniTest::Spec
 
     context "Pieces" do
       should "type subclasses found via Spontaneous::Piece" do
-        Spontaneous::Piece.all.map { |c| c.class }.should == \
-          [PieceClass1, PieceClass11, PieceClass111, PieceClass2, PieceClass22]
-        Spontaneous::Piece.all.should == [@piece1, @piece11, @piece111, @piece2, @piece22]
+        Set.new(Spontaneous::Piece.all.map { |c| c.class }).should == \
+          Set.new([PieceClass1, PieceClass11, PieceClass111, PieceClass2, PieceClass22])
+        Set.new(Spontaneous::Piece.all).should == Set.new([@piece1, @piece11, @piece111, @piece2, @piece22])
       end
       should "type subclasses found via Piece" do
-        ::Piece.all.map { |c| c.class }.should == \
-          [PieceClass1, PieceClass11, PieceClass111, PieceClass2, PieceClass22]
-        ::Piece.all.should == [@piece1, @piece11, @piece111, @piece2, @piece22]
+        Set.new(::Piece.all.map { |c| c.class }).should == \
+          Set.new([PieceClass1, PieceClass11, PieceClass111, PieceClass2, PieceClass22])
+        Set.new(::Piece.all).should == Set.new([@piece1, @piece11, @piece111, @piece2, @piece22])
       end
 
       should "only find instances of a single class when searching via that subclass" do

data/test/unit/test_extensions.rb

@@ -9,12 +9,38 @@ class ExtensionsTest < MiniTest::Spec
       ("this" / "that").should == "this/that"
       ("/this" / "/that").should == "/this/that"
     end
+
+    should "override the | method to return the argument if empty" do
+      ("" | "that").should == "that"
+      ("this" | "that").should == "this"
+    end
+
+    should "override the or method to return the argument if empty" do
+      ("".or("that")).should == "that"
+      ("this".or("that")).should == "this"
+    end
+
+    should "return self for #value" do
+      "this".value.should == "this"
+      "this".value(:html).should == "this"
+      "this".value(:smsx).should == "this"
+    end
   end
 
   context "Nil" do
     should "always return the argument for the slash switch" do
       (nil / "something").should == "something"
     end
+    should "always return the argument for the #or switch" do
+      (nil.or("something")).should == "something"
+    end
+  end
+
+  context "Enumerable" do
+    should "correctly slice_between elements" do
+      result = ["js", "coffee", "coffee", "js", "coffee"].slice_between { |prev, current| prev != current }.to_a
+      result.should == [["js"], ["coffee", "coffee"], ["js"], ["coffee"]]
+    end
   end
 end