spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/test/unit/test_permissions.rb

@@ -50,21 +50,22 @@ class PermissionsTest < MiniTest::Spec
     end
 
     should "provide a sorted list of all levels" do
-      Permissions::UserLevel.all.should == [:none, :editor, :admin, :designer, :root]
+      Permissions::UserLevel.all.map(&:to_sym).should == [:none, :editor, :admin, :designer, :root]
     end
+
     should "provide a list of all levels <= provided level" do
-      Permissions::UserLevel.all(:editor).should == [:none, :editor]
-      Permissions::UserLevel.all(:designer).should == [:none, :editor, :admin, :designer]
+      Permissions::UserLevel.all(:editor).map(&:to_sym).should == [:none, :editor]
+      Permissions::UserLevel.all(:designer).map(&:to_sym).should == [:none, :editor, :admin, :designer]
     end
 
     should "have a root level" do
       Permissions::UserLevel.root.should == Permissions::UserLevel::Root
     end
 
-    should "have a root level that is always greater than other levels" do
+    should "have a root level that is always greater than other levels except root" do
       Permissions::UserLevel.root.should > Permissions::UserLevel['designer']
       Permissions::UserLevel.root.should >= Permissions::UserLevel['designer']
-      Permissions::UserLevel.root.should > Permissions::UserLevel::Root
+      Permissions::UserLevel.root.should_not > Permissions::UserLevel::Root
       Permissions::UserLevel.root.should >= Permissions::UserLevel::Root
       Permissions::UserLevel[:root].should == Permissions::UserLevel::Root
     end
@@ -97,8 +98,8 @@ class PermissionsTest < MiniTest::Spec
     end
     should "Have a developer flag" do
       Permissions::UserLevel[:none].developer?.should be_false
-      Permissions::UserLevel[:editor].developer?.should be_nil
-      Permissions::UserLevel[:admin].developer?.should be_nil
+      Permissions::UserLevel[:editor].developer?.should be_false
+      Permissions::UserLevel[:admin].developer?.should be_false
       Permissions::UserLevel[:designer].developer?.should be_true
       Permissions::UserLevel[:root].developer?.should be_true
     end
@@ -112,14 +113,58 @@ class PermissionsTest < MiniTest::Spec
         :name => "A Person",
         :email => "person@example.org",
         :login => "person",
-        :password => "xxxxxx",
-        :password_confirmation => "xxxxxx"
+        :password => "xxxxxxxx"
+      }
+      @valid2 = {
+        :name => "Another Person",
+        :email => "person2@example.org",
+        :login => "person2",
+        :password => "xxxxxxxxxx"
       }
     end
 
     teardown do
     end
 
+    should "be retrievable as a list" do
+      user1 = Permissions::User.create(@valid.merge(:level => S::Permissions[:editor]))
+      user2 = Permissions::User.create(@valid2.merge(:level => S::Permissions[:admin]))
+      user1.logged_in!("196.168.1.11")
+      exported = Permissions::User.export(nil)
+      exported[:users].should == [
+        { :id => user1.id, :name => "A Person", :email => "person@example.org", :login => "person", :level => "editor",
+          :keys => [:last_access_at => @now.httpdate, :last_access_ip => "196.168.1.11"], :disabled => false },
+        { :id => user2.id, :name => "Another Person", :email => "person2@example.org", :login => "person2", :level => "admin", :disabled => false,
+          :keys => [] }
+      ]
+      exported[:levels].should == [
+        { :level => "none", :can_publish => false, :is_admin => false  },
+        { :level => "editor", :can_publish => false, :is_admin => false  },
+        { :level => "admin", :can_publish => false, :is_admin => true  },
+        { :level => "designer", :can_publish => true, :is_admin => false  },
+        { :level => "root", :can_publish => true, :is_admin => true  }
+      ]
+    end
+
+    should "filter exported user list to remove users with a higher level" do
+      user1 = Permissions::User.create(@valid.merge(:level => S::Permissions[:editor]))
+      user2 = Permissions::User.create(@valid2.merge(:level => S::Permissions[:admin]))
+      user3 = Permissions::User.create(@valid.merge(:login => "person3", :email => "person3@example.com", :level => S::Permissions[:root]))
+      user1.logged_in!("196.168.1.11")
+      exported = Permissions::User.export(user2)
+      exported[:users].should == [
+        { :id => user1.id, :name => "A Person", :email => "person@example.org", :login => "person", :level => "editor", :disabled => false,
+          :keys => [:last_access_at => @now.httpdate, :last_access_ip => "196.168.1.11"] },
+        { :id => user2.id, :name => "Another Person", :email => "person2@example.org", :login => "person2", :level => "admin", :disabled => false,
+          :keys => [] }
+      ]
+      exported[:levels].should == [
+        { :level => "none", :can_publish => false, :is_admin => false  },
+        { :level => "editor", :can_publish => false, :is_admin => false  },
+        { :level => "admin", :can_publish => false, :is_admin => true  },
+      ]
+    end
+
     should "be creatable with valid params" do
       user = Permissions::User.new(@valid)
       user.save.must_be_instance_of(Permissions::User)
@@ -161,7 +206,7 @@ class PermissionsTest < MiniTest::Spec
       user.errors[:login].should_not be_blank
     end
 
-    should "reject duplicate logins" do
+    should "reject duplicate logins on creation" do
       user1 = Permissions::User.create(@valid)
       user2 = Permissions::User.new(@valid)
       user2.save
@@ -169,22 +214,23 @@ class PermissionsTest < MiniTest::Spec
       user2.errors[:login].should_not be_blank
     end
 
-    should "require a non-blank password & password_confirmation" do
-      user = Permissions::User.new(@valid.merge(:password => "", :password_confirmation => ""))
-      user.save
-      user.valid?.should be_false
-      user.errors[:password].should_not be_blank
+    should "reject duplicate logins" do
+      user1 = Permissions::User.create(@valid)
+      user2 = Permissions::User.create(@valid.merge(:login => "other"))
+      user2.update_fields({:login => @valid[:login]}, [:login])
+      user2.valid?.should be_false
+      user2.errors[:login].should_not be_blank
     end
 
-    should "require a matching password & password_confirmation" do
-      user = Permissions::User.new(@valid.merge(:password => "sdfsddfsdf", :password_confirmation => "sdf"))
+    should "require a non-blank password" do
+      user = Permissions::User.new(@valid.merge(:password => ""))
       user.save
       user.valid?.should be_false
-      user.errors[:password_confirmation].should_not be_blank
+      user.errors[:password].should_not be_blank
     end
 
-    should "require passwords to be at least 6 characters" do
-      user = Permissions::User.new(@valid.merge(:password => "12345", :password_confirmation => "12345"))
+    should "require passwords to be at least 8 characters" do
+      user = Permissions::User.new(@valid.merge(:password => "1234567"))
       user.save
       user.valid?.should be_false
       user.errors[:password].should_not be_blank
@@ -289,16 +335,38 @@ class PermissionsTest < MiniTest::Spec
 
       should "have a test for developer status" do
         @user.update(:level => Permissions::UserLevel.editor)
-        @user.developer?.should be_nil
+        @user.developer?.should be_false
         @user.update(:level => Permissions::UserLevel.designer)
         @user.developer?.should be_true
       end
 
+      should "be testable for ability to publish depending on their user level" do
+        @user.update(:level => Permissions::UserLevel.editor)
+        @user.can_publish?.should be_false
+        @user.update(:level => Permissions::UserLevel.designer)
+        @user.can_publish?.should be_true
+      end
+
+      should "be testable for admin privileges" do
+        @user.update(:level => Permissions::UserLevel.none)
+        @user.admin?.should be_false
+        @user.update(:level => Permissions::UserLevel.editor)
+        @user.admin?.should be_false
+        @user.update(:level => Permissions::UserLevel.designer)
+        @user.admin?.should be_false
+        @user.update(:level => Permissions::UserLevel.admin)
+        @user.admin?.should be_true
+        @user.update(:level => Permissions::UserLevel.root)
+        @user.admin?.should be_true
+      end
+
       should "serialise to JSON" do
         @user.export.should == {
           :name => "A Person",
           :email => "person@example.org",
           :login => "person",
+          :can_publish => false,
+          :admin => false,
           :developer => false
         }
       end
@@ -313,8 +381,7 @@ class PermissionsTest < MiniTest::Spec
         :name => "A Person",
         :email => "person@example.org",
         :login => "person",
-        :password => "xxxxxx",
-        :password_confirmation => "xxxxxx"
+        :password => "xxxxxxxx"
       }
     end
 
@@ -426,10 +493,10 @@ class PermissionsTest < MiniTest::Spec
   context "Guards" do
     setup do
       Permissions::User.delete
-      @visitor = Permissions::User.create(:email => "visitor@example.com", :login => "visitor", :name => "visitor", :password => "visitorpass", :password_confirmation => "visitorpass")
-      @editor = Permissions::User.create(:email => "editor@example.com", :login => "editor", :name => "editor", :password => "editorpass", :password_confirmation => "editorpass")
-      @admin = Permissions::User.create(:email => "admin@example.com", :login => "admin", :name => "admin", :password => "adminpass", :password_confirmation => "adminpass")
-      @root = Permissions::User.create(:email => "root@example.com", :login => "root", :name => "root", :password => "rootpass", :password_confirmation => "rootpass")
+      @visitor = Permissions::User.create(:email => "visitor@example.com", :login => "visitor", :name => "visitor", :password => "visitorpass")
+      @editor = Permissions::User.create(:email => "editor@example.com", :login => "editor", :name => "editor", :password => "editorpass")
+      @admin = Permissions::User.create(:email => "admin@example.com", :login => "admin", :name => "admin", :password => "adminpass")
+      @root = Permissions::User.create(:email => "root@example.com", :login => "root", :name => "root", :password => "rootpass")
       @editor.update(:level => Permissions::UserLevel.editor)
       @admin.update(:level => Permissions::UserLevel.admin)
       @root.update(:level => Permissions::UserLevel.root)
@@ -813,5 +880,12 @@ class PermissionsTest < MiniTest::Spec
       # end
 
     end
+
+    should "determine what fields are visible in the exoported schema" do
+      schema = Site.schema.export(@editor)
+      c_schema = schema["C"]
+      c_schema[:fields].map { |f| f[:name] }.should == %w(editor_level mixed_level default_level)
+      c_schema[:boxes].map { |b| b[:name] }.should == %w(editor_level mixed_level default_level)
+    end
   end
 end

data/test/unit/test_piece.rb

@@ -84,13 +84,13 @@ class PieceTest < MiniTest::Spec
 
       should "be available from their containing page" do
         @page.content.length.should == 3
-        @page.content.should == [@f1, @f2, @f3]
-        @page.content.last.class.should == Fridge
+        Set.new(@page.content).should == Set.new([@f1, @f2, @f3])
+        Set.new(@page.content.map(&:class)).should == Set.new([::Piece, ::Piece, Fridge])
       end
 
       should "have a link to their pieces" do
-        @f1.entry.should == @page.pieces.first
-        @f2.entry.should == @page.pieces.first.pieces.first
+        @f1.entry.should == @page.contents.first
+        @f2.entry.should == @page.contents.first.contents.first
       end
     end
   end

data/test/unit/test_plugins.rb

@@ -14,6 +14,7 @@ class PluginsTest < MiniTest::Spec
 
 
     klass =  Class.new(Spontaneous::Page)
+    klass.box :box1
     Object.send(:const_set, :Page, klass)
     klass =  Class.new(Spontaneous::Piece)
     Object.send(:const_set, :Piece, klass)
@@ -51,7 +52,6 @@ class PluginsTest < MiniTest::Spec
       Site.publishing_method = :immediate
       State.delete
       Content.delete
-      Change.delete
       @site = Spontaneous.instance
       page = ::Page.new
       page.save
@@ -61,7 +61,6 @@ class PluginsTest < MiniTest::Spec
     teardown do
       State.delete
       Content.delete
-      Change.delete
     end
 
     should "load their init.rb file" do
@@ -145,7 +144,9 @@ class PluginsTest < MiniTest::Spec
       should "make content classes available to rest of app" do
         defined?(::SchemaPlugin).should == "constant"
         ::SchemaPlugin::External.fields.length.should == 1
+        page  = ::Page.new
         piece = ::SchemaPlugin::External.new(:a => "A Field")
+        page.box1 << piece
         piece.render.should == "plugins/templates/external.html.cut\n"
       end
     end

data/test/unit/test_publishing.rb

@@ -0,0 +1,332 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+
+class PublishingTest < MiniTest::Spec
+
+  def self.site_root
+    @site_root
+  end
+
+  def self.startup
+    @site_root = Dir.mktmpdir
+    template_source = File.expand_path(File.dirname(__FILE__) / "../fixtures/templates/publishing/templates")
+    FileUtils.cp_r(template_source, @site_root)
+  end
+
+  def self.shutdown
+    S::Content.delete_all_revisions! rescue nil
+  end
+
+  @@now = Time.now
+
+  def setup
+    @site = setup_site(self.class.site_root)
+    @now = @@now
+    Site.publishing_method = :immediate
+  end
+
+  context "publishing" do
+
+    setup do
+      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
+
+      count = 0
+      2.times do |i|
+        c = Page.new(:uid => i)
+        count += 1
+        2.times do |j|
+          d = Piece.new(:uid => "#{i}.#{j}")
+          c.things << d
+          count += 1
+          2.times do |k|
+            d.things << Page.new(:uid => "#{i}.#{j}.#{k}")
+            d.save
+            count += 1
+          end
+        end
+        c.save
+      end
+    end
+
+    teardown do
+      PublishingTest.send(:remove_const, :Page) rescue nil
+      PublishingTest.send(:remove_const, :Piece) rescue nil
+      Content.delete
+      DB.logger = nil
+    end
+
+
+
+
+    context "site publishing" do
+      setup do
+        Content.delete
+        @revision = 3
+        State.delete
+        State.create(:revision => @revision, :published_revision => 2)
+        State.revision.should == @revision
+      end
+
+      teardown do
+        Content.delete_revision(@revision)
+        Revision.delete
+      end
+
+      should "delete any conflicting revision tables" do
+        S::Content.create_revision(3)
+        Site.publish_all
+      end
+
+
+      should "issue a publish_all if passed page id list including all pages (in any order)" do
+        skip "Implement after scheduled publishes"
+      end
+
+      should "publish all" do
+        Content.expects(:publish).with(@revision, nil)
+        Site.publish_all
+      end
+
+      should "record date and time of publish" do
+        Content.expects(:publish).with(@revision, nil)
+        Revision.expects(:create).with(:revision => @revision, :published_at => @now)
+        Site.publish_all
+      end
+
+      should "bump revision after a publish" do
+        Site.publish_all
+        Site.revision.should == @revision + 1
+        Site.published_revision.should == @revision
+      end
+
+      should "not delete scheduled changes after an exception during publish" do
+        skip "Implement after scheduled publishes"
+      end
+
+      should "set Site.pending_revision before publishing" do
+        Content.expects(:publish).with(@revision, nil) { Site.pending_revision == @revision }
+        Site.publish_all
+      end
+
+      should "reset Site.pending_revision after publishing" do
+        Site.publish_all
+        Site.pending_revision.should be_nil
+      end
+
+      should "not update first_published or last_published if rendering fails" do
+        c = Content.create
+        c.first_published_at.should be_nil
+        Spontaneous::Page.expects(:order).returns([c])
+        # c.expects(:render).raises(Exception)
+        begin
+          silence_logger { Site.publish_all }
+          # Site.publish_all
+        rescue Exception; end
+        c.reload
+        Content.with_editable do
+          c.first_published_at.should be_nil
+        end
+      end
+
+      should "clean up state on publishing failure" do
+        Site.pending_revision.should be_nil
+        Content.revision_exists?(@revision).should be_false
+        # don't like peeking into implementation here but don't know how else
+        # to simulate the right error
+        root = Page.create()
+        Spontaneous::Page.expects(:order).returns([root])
+        output = root.output(:html)
+        output.expects(:render_using).raises(Exception)
+        root.expects(:outputs).at_least_once.returns([output])
+        begin
+          silence_logger { Site.publish_all }
+        rescue Exception; end
+        Site.pending_revision.should be_nil
+        Content.revision_exists?(@revision).should be_false
+        begin
+          silence_logger { Site.publish_pages([change1]) }
+        rescue Exception; end
+        Site.pending_revision.should be_nil
+        Content.revision_exists?(@revision).should be_false
+      end
+    end
+
+
+    context "rendering" do
+      setup do
+        @revision = 2
+        Content.delete_revision(@revision)
+        Content.delete
+        State.delete
+        State.create(:revision => @revision, :published_revision => 2)
+        Site.revision.should == @revision
+
+
+        class ::PublishablePage < Page; end
+        class ::DynamicPublishablePage < Page; end
+        PublishablePage.box :box1
+        DynamicPublishablePage.box :box1
+        PublishablePage.layout :"static"
+        PublishablePage.layout :"dynamic"
+
+        DynamicPublishablePage.layout :"static"
+        DynamicPublishablePage.layout :"dynamic"
+
+        DynamicPublishablePage.request { show "/about" }
+
+        @home = PublishablePage.create(:title => 'Home')
+        @home.layout = :"dynamic"
+        @about = PublishablePage.create(:title => "About", :slug => "about")
+        @blog = PublishablePage.create(:title => "Blog", :slug => "blog")
+        @post1 = PublishablePage.create(:title => "Post 1", :slug => "post-1")
+        @post2 = PublishablePage.create(:title => "Post 2", :slug => "post-2")
+        @post3 = PublishablePage.create(:title => "Post 3", :slug => "post-3")
+        @news = DynamicPublishablePage.create(:title => "News", :slug => "news")
+        @contact = DynamicPublishablePage.create(:title => "Contact", :slug => "contact")
+        @contact.layout = :dynamic
+        @home.box1 << @about
+        @home.box1 << @blog
+        @home.box1 << @news
+        @home.box1 << @contact
+        @blog.box1 << @post1
+        @blog.box1 << @post2
+        @blog.box1 << @post3
+        @pages = [@home, @about, @blog, @news, @post1, @post2, @post3]
+        @pages.each { |p| p.save }
+        Site.publish_all
+      end
+
+      teardown do
+        Content.delete_revision(@revision)
+        Content.delete_revision(@revision+1)
+        Content.delete
+        State.delete
+        Object.send(:remove_const, :PublishablePage) rescue nil
+        Object.send(:remove_const, :DynamicPublishablePage) rescue nil
+      end
+
+      should "put its files into a numbered revision directory" do
+        Spontaneous.revision_dir(2).should == Pathname.new(@site.root / 'cache/revisions' / "00002").realpath.to_s
+      end
+
+      should "symlink the latest revision to 'current'" do
+        revision_dir = @site.revision_root / "00002"
+        current_dir = @site.revision_root / "current"
+        File.exists?(current_dir).should be_true
+        File.symlink?(current_dir).should be_true
+        File.readlink(current_dir).should == revision_dir
+      end
+
+      should "have access to the current revision within the templates" do
+        revision_dir = @site.revision_root / "00002"
+        File.read(revision_dir / "static/about.html").should == "Page: 'About' 2\n"
+      end
+
+      should "produce rendered versions of each page" do
+        revision_dir = @site.revision_root / "00002"
+        file = result = nil
+        @pages.each do |page|
+          case page.slug
+          when "" # root is a dynamic page with no request handler
+            file = revision_dir / "dynamic/index.html.cut"
+            result = "Page: '#{page.title}' {{Time.now.to_i}}\n"
+          when "news" # news produces a static template but has a request handler
+            file = revision_dir / "protected/news.html"
+            result = "Page: 'News' 2\n"
+          when "contact" # contact is both dynamic and has a request handler
+            file = revision_dir / "dynamic/contact.html.cut"
+            result = "Page: 'Contact' {{Time.now.to_i}}\n"
+          else # the other pages are static
+            file = revision_dir / "static#{page.path}.html"
+            result = "Page: '#{page.title}' 2\n"
+          end
+          assert File.exists?(file), "File '#{file}' should exist"
+          File.read(file).should == result
+        end
+        revision_dir = @site.revision_root / "00002"
+        Dir[S.root / "public/**/*"].each do |public_file|
+          site_file = public_file.gsub(%r(^#{S.root}/), '')
+          publish_file = revision_dir / site_file
+          File.exists?(publish_file).should be_true
+        end
+      end
+
+      should "generate a config.ru file pointing to the current root" do
+        config_file = @site.revision_root / "00002/config.ru"
+        File.exists?(config_file).should be_true
+        File.read(config_file).should =~ %r(#{Spontaneous.root})
+      end
+
+      should "transparently support previously unknown formats by assuming a simple HTML like rendering model" do
+        PublishablePage.add_output :rtf
+        Content.delete_revision(@revision+1)
+        Site.publish_all
+        File.read("#{@site.revision_root}/00003/static/index.rtf").should == "RICH!\n"
+      end
+
+      should "respect a format's #dynamic? setting when deciding a rendered templates location xxx" do
+        PublishablePage.add_output :rtf, :dynamic => true
+        Content.delete_revision(@revision+1)
+        Site.publish_all
+        File.read("#{@site.revision_root}/00003/dynamic/index.rtf.cut").should == "RICH!\n"
+      end
+
+      context "hooks & triggers" do
+        setup do
+        end
+
+        should "after_publish hook should be fired after publish is complete" do
+          publish1 = mock
+          publish1.expects(:finished).with(@revision+1)
+          publish2 = mock
+          publish2.expects(:finished)
+          Site.after_publish do |revision|
+            publish1.finished(revision)
+          end
+          Site.after_publish do
+            publish2.finished
+          end
+          Content.delete_revision(@revision+1)
+          Site.publish_all
+          Site.published_revision.should == @revision+1
+        end
+
+        should "abort publish if hook raises error" do
+          published_revision = @revision+1
+          Site.pending_revision.should be_nil
+          Content.revision_exists?(published_revision).should be_false
+
+          Site.after_publish do |revision|
+            raise "Boom"
+          end
+
+          begin
+            silence_logger { Site.publish_all }
+          rescue Exception; end
+
+          Site.pending_revision.should be_nil
+          Site.published_revision.should == @revision
+          Content.revision_exists?(published_revision).should be_false
+          S::Revision.first(:revision => published_revision).should be_nil
+          previous_root = Spontaneous.revision_dir(@revision)
+          published_root = Spontaneous.revision_dir(published_revision)
+          symlink = Pathname.new Spontaneous.revision_dir
+          symlink.realpath.to_s.should == Pathname.new(previous_root).realpath.to_s
+        end
+      end
+    end
+  end
+end