spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/test/unit/test_assets.rb

@@ -0,0 +1,213 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+require 'ostruct'
+require 'shine'
+
+class AssetTest < MiniTest::Spec
+
+  module LiveSimulation
+    # simulate a production + publishing environment
+    def live?
+      true
+    end
+    # usually set as part of the render process
+    def revision
+      99
+    end
+  end
+
+  def new_context(content = @page, format = :html, params = {})
+    renderer = Spontaneous::Output::Template::PublishRenderer.new
+    output = content.output(format)
+    context = renderer.context(output, params)
+    context.extend LiveSimulation
+    context
+  end
+
+  def setup
+    @site = setup_site
+    @fixture_root = File.expand_path("../../fixtures/assets", __FILE__)
+    @site.paths.add :public, @fixture_root / "public1", @fixture_root / "public2"
+    @page = S::Page.create
+  end
+
+  def teardown
+    S::Content.delete
+    teardown_site
+  end
+
+  context "Publishing context" do
+    should "be flagged as live" do
+      Spontaneous.stubs(:production?).returns(true)
+      new_context.live?.should be_true
+    end
+
+    should "be flagged as publishing" do
+      new_context.publishing?.should be_true
+    end
+  end
+
+  context "Javascript assets" do
+    should "be compressed in live environment" do
+      files = [@fixture_root / "public1/js/a.js", @fixture_root / "public2/js/b.js"]
+      src = files.map { |p| File.read(p) }.join
+      Shine.expects(:compress_string).with(src, :js, {}).once.returns("var A;\nvar B;\n")
+      context = new_context
+      result = context.scripts("/js/a", "/js/b")
+      result.should =~ /src="\/rev\/5dde6b3e04ce364ef23f51048006e5dd7e6f62ad\.js"/
+      on_disk = Spontaneous::Output.revision_root(context.revision) / "rev/5dde6b3e04ce364ef23f51048006e5dd7e6f62ad.js"
+      assert File.exist?(on_disk)
+      File.read(on_disk).should == "var A;\nvar B;\n"
+    end
+
+    should "use a cache to make sure identical file lists are only compressed once" do
+      files1 = [@fixture_root / "public1/js/a.js", @fixture_root / "public2/js/b.js"]
+      files2 = [@fixture_root / "public2/js/b.js", @fixture_root / "public2/js/c.js"]
+      src1 = files1.map { |p| File.read(p) }.join
+      src2 = files2.map { |p| File.read(p) }.join
+      Shine.expects(:compress_string).with(src1, :js, {}).once.returns("var A;\nvar B;\n")
+      Shine.expects(:compress_string).with(src2, :js, {}).once.returns("var B;\nvar C;\n")
+      context = new_context
+      result = context.scripts("/js/a", "/js/b")
+      result = context.scripts("/js/a", "/js/b")
+      result = context.scripts("/js/b", "/js/c")
+      result = context.scripts("/js/b", "/js/c")
+      result.should =~ /src="\/rev\/1458221916fde33ec803fbbae20af8ded0ee2ca1\.js"/
+    end
+
+    should "be compressed when publishing & passed a force_compression option" do
+      files = [@fixture_root / "public1/js/a.js", @fixture_root / "public2/js/b.js"]
+      src = files.map { |p| File.read(p) }.join
+      Shine.expects(:compress_string).with(src, :js, {}).once.returns("var A;\nvar B;\n")
+      context = new_context
+      context.stubs(:live?).returns(false)
+      context.stubs(:publishing?).returns(true)
+      result = context.scripts("/js/a", "/js/b", :force_compression => true)
+
+      Shine.expects(:compress_string).with(src, :js, {}).never
+      context.stubs(:publishing?).returns(false)
+      result = context.scripts("/js/a", "/js/b", :force_compression => true)
+    end
+
+    should "support UTF8 scripts" do
+      files = [@fixture_root / "public1/js/a.js", @fixture_root / "public2/js/b.js"]
+      src = files.map { |p| File.read(p) }.join
+      Shine.expects(:compress_string).with(src, :js, {}).once.returns("var A = \"\xC2\";\nvar B;\n".force_encoding("ASCII-8BIT"))
+      context = new_context
+      result = context.scripts("/js/a", "/js/b")
+    end
+
+    should "support scripts with full urls" do
+      context = new_context
+      result = context.scripts("http://jquery.com/jquery.js")
+      result.should =~ /src="http:\/\/jquery.com\/jquery.js"/
+    end
+  end
+
+  context "CoffeeScript assets" do
+    should "be compiled & compressed in live environment" do
+      files = [@fixture_root / "public1/js/m.js", @fixture_root / "public2/js/n.js"]
+      Shine.expects(:compress_string).with((<<-COMPILED), :js, {}).once.returns("var A;\nvar B;\n")
+(function() {
+  var square;
+
+  square = function(x) {
+    return x * x;
+  };
+
+  if (typeof elvis !== "undefined" && elvis !== null) alert("I knew it!");
+
+}).call(this);
+      COMPILED
+      context = new_context
+      result = context.scripts("/js/m", "/js/n")
+      result.should =~ /src="\/rev\/5dde6b3e04ce364ef23f51048006e5dd7e6f62ad\.js"/
+      on_disk = Spontaneous::Output.revision_root(context.revision) / "rev/5dde6b3e04ce364ef23f51048006e5dd7e6f62ad.js"
+      assert File.exist?(on_disk)
+      File.read(on_disk).should == "var A;\nvar B;\n"
+    end
+
+    should "be correctly compiled when mixed with plain js" do
+      Shine.expects(:compress_string).with((<<-COMPILED), :js, {}).once.returns("var A;\nvar B;\n")
+var A;
+(function() {
+  var square;
+
+  square = function(x) {
+    return x * x;
+  };
+
+  if (typeof elvis !== "undefined" && elvis !== null) alert("I knew it!");
+
+}).call(this);
+var B;
+      COMPILED
+      context = new_context
+      result = context.scripts("/js/a", "/js/m", "/js/n", "/js/b")
+    end
+  end
+
+  context "Stylesheet assets" do
+    should "be compressed in live environment" do
+      files = [@fixture_root / "public1/css/a.scss", @fixture_root / "public2/css/b.scss"]
+      context = new_context
+      Shine.expects(:compress_string).with(<<-CSS, :css, {}).once.returns("/* compressed */\n")
+.a{width:8px}
+.c { color: #fff; }
+.b{height:42px}
+      CSS
+      result = context.stylesheets("/css/a", "/css/c", "/css/b")
+      result.should =~ /href="\/rev\/df3e2b3fa3409d8ca37faac7da80349098f0b28a\.css"/
+      on_disk = Spontaneous::Output.revision_root(context.revision) / "rev/df3e2b3fa3409d8ca37faac7da80349098f0b28a.css"
+
+      assert File.exist?(on_disk)
+      File.read(on_disk).should == "/* compressed */\n"
+    end
+
+    should "be compressed if publishing and passed a force option" do
+      files = [@fixture_root / "public1/css/a.scss", @fixture_root / "public2/css/b.scss"]
+      context = new_context
+      m = Module.new do
+        def live?; false; end
+        def publishing?; true; end
+      end
+      context.extend m
+      context.live?.should be_false
+      Shine.expects(:compress_string).with(anything, :css, {}).once.returns("/* compressed */\n")
+      result = context.stylesheets("/css/a", "/css/c", "/css/b", {:force_compression => true})
+
+      def context.publishing?; false; end
+      context.publishing?.should be_false
+      Shine.expects(:compress_string).with(anything, :css, {}).never
+      result = context.stylesheets("/css/a", "/css/c", "/css/b", {:force_compression => true})
+    end
+
+    should "use a cache to make sure identical file lists are only compressed once" do
+      context = new_context
+      Shine.expects(:compress_string).with(<<-CSS, :css, {}).once.returns("/* compressed1 */\n")
+.a{width:8px}
+.b{height:42px}
+      CSS
+      Shine.expects(:compress_string).with(<<-CSS, :css, {}).once.returns("/* compressed2 */\n")
+.a{width:8px}
+.c { color: #fff; }
+      CSS
+      result = context.stylesheets("/css/a", "/css/b")
+      result = context.stylesheets("/css/a", "/css/b")
+      result.should =~ /href="\/rev\/20aac22ae20e78ef1574a3a6635fa353148e9d9a\.css"/
+      result = context.stylesheets("/css/a", "/css/c")
+      result = context.stylesheets("/css/a", "/css/c")
+      result.should =~ /href="\/rev\/77ec1b6ee2907c65cf316b99b59c8cf8006dcddf\.css"/
+    end
+
+    should "support UTF8 styles" do
+      context = new_context
+      Shine.expects(:compress_string).with(<<-CSS, :css, {}).once.returns("/* \xC2 */\n".force_encoding("ASCII-8BIT"))
+.a{width:8px}
+.b{height:42px}
+      CSS
+      result = context.stylesheets("/css/a", "/css/b")
+    end
+  end
+end

data/test/unit/test_async.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+require 'eventmachine'
+
+class AsyncTest < MiniTest::Spec
+
+  def setup
+    @site = setup_site
+    @filename = Time.now.to_i
+    @filepath = @site.root / @filename
+    File.exist?(@filepath).should be_false
+  end
+
+  def teardown
+    teardown_site
+  end
+
+  context "async system calls" do
+    should "be able to test for running EM reactor" do
+      Spontaneous.async?.should be_false
+      EM.run do
+        Spontaneous.async?.should be_true
+        EM.stop
+      end
+      Spontaneous.async?.should be_false
+    end
+
+    should "use fibers to simulate sync code if running in a fiber" do
+      EM.run do
+        Fiber.new {
+          result = Spontaneous.system("touch #{@filepath}")
+          File.exist?(@filepath).should be_true
+        }.resume
+        EM.stop
+      end
+    end
+
+    # TODO: can't get this to work at moment'
+    # should "resort to sync code if execution is not running in a fiber" do
+    #   EM.run do
+    #     result = Spontaneous.system("touch #{@filepath}")
+    #     File.exist?(@filepath).should be_true
+    #     EM.stop
+    #   end
+    # end
+
+
+    should "run synchronously outside of EM reactor" do
+      result = Spontaneous.system("touch #{@filepath}")
+      File.exist?(@filepath).should be_true
+      result.should be_true
+    end
+  end
+end

data/test/unit/test_authentication.rb

@@ -14,8 +14,7 @@ class AuthenticationTest < MiniTest::Spec
       :name => "#{name.capitalize}",
       :email => "#{name}@example.org",
       :login => name,
-      :password => "#{name}_password",
-      :password_confirmation => "#{name}_password"
+      :password => "#{name}_password"
     })
     user.update(:level => level)
     user
@@ -92,20 +91,13 @@ class AuthenticationTest < MiniTest::Spec
   def teardown
     teardown_site
   end
-  def assert_login_page(path = nil, method = "GET")
-    assert last_response.status == 401, "#{method} #{path} should have status 401 but has #{last_response.status}"
-    last_response.body.should =~ %r{<form.+action="/@spontaneous/login"}
-    last_response.body.should =~ %r{<form.+method="post"}
-    last_response.body.should =~ %r{<input.+name="user\[login\]"}
-    last_response.body.should =~ %r{<input.+name="user\[password\]"}
-  end
 
   def post_paths
     %(/save/#{root.id} /savebox/#{root.id}/#{root.boxes[:editor_level].schema_id} /content/#{root.id}/position/0 /file/upload/#{root.id} /file/replace/#{root.id} /file/wrap/#{root.id}/#{root.boxes[:pages].schema_id} /add/#{root.id}/#{root.boxes[:pages].schema_id}/#{SitePage.schema_id} /destroy/#{root.id} /slug/#{root.id} /slug/#{root.id}/unavailable /toggle/#{root.id} /schema/delete /schema/rename)
   end
 
   def get_paths
-    %(/root /page/#{root.id} /types /map /map/#{root.id} /location/about /user)
+    %(/root /page/#{root.id} /metadata /map /map/#{root.id} /location/about)
   end
 
   context "Authentication:" do
@@ -183,6 +175,7 @@ class AuthenticationTest < MiniTest::Spec
       Permissions::User.delete
       Permissions::AccessKey.delete
       Spontaneous.environment = :test
+      Permissions::UserLevel.reset!
       Permissions::UserLevel.stubs(:level_file).returns(File.expand_path('../../fixtures/permissions', __FILE__) / 'config/user_levels.yml')
 
       @root = SitePage.create
@@ -254,7 +247,7 @@ class AuthenticationTest < MiniTest::Spec
       end
 
       should "get access to CSS files" do
-        get "/@spontaneous/css/v2.css"
+        get "/@spontaneous/css/spontaneous.css"
         assert last_response.status == 200
       end
 
@@ -291,6 +284,27 @@ class AuthenticationTest < MiniTest::Spec
           last_response.headers["Location"].should =~ %r{/@spontaneous/103/preview$}
         end
 
+        should "set the secure flag for cookies delivered behind https" do
+          clear_cookies
+          rack_mock_session.cookie_jar[S::Rack::AUTH_COOKIE].should be_nil
+          user = @admin_user
+          post "https://example.org/@spontaneous/login", {"user[login]" => user.login, "user[password]" => user.password}
+          cookies = rack_mock_session.cookie_jar.instance_variable_get("@cookies")
+          cookie = cookies.detect { |c| c.name == S::Rack::AUTH_COOKIE }
+          cookie.secure?.should be_true
+        end
+
+        should "set the secure flag for cookies delivered behind https when reauthenticating" do
+          clear_cookies
+          key = @admin_user.logged_in!
+          post "https://example.org/@spontaneous/reauthenticate", "api_key" => key.key_id, "origin" => "/99/edit"
+          cookies = rack_mock_session.cookie_jar.instance_variable_get("@cookies")
+          cookie = cookies.detect { |c| c.name == S::Rack::AUTH_COOKIE }
+          cookie.secure?.should be_true
+          cookie_options = cookie.instance_variable_get("@options")
+          cookie_options.key?("HttpOnly").should be_true
+        end
+
         should "succeed and return an api key value for correct login over XHR" do
           key = Spontaneous::Permissions::AccessKey.new
           Spontaneous::Permissions::AccessKey.expects(:new).returns(key)
@@ -347,18 +361,18 @@ class AuthenticationTest < MiniTest::Spec
           assert last_response.ok?, "Expected 200 but got #{last_response.status}"
         end
 
+        should "be able to logout" do
+          auth_post "/@spontaneous/logout"
+          assert last_response.status == 401
+          rack_mock_session.cookie_jar.merge(last_response.headers["set-cookie"])
+          rack_mock_session.cookie_jar[Spontaneous::Rack::AUTH_COOKIE].value.should == ""
+        end
+
         # context "providing an API key in the request" do
         #   should "be able to see previously forbidden fruit" do
         #     get "/@spontaneous/root"
         #     assert last_response.ok?
         #   end
-
-        #   should "be able to load info about themselves" do
-        #     get "/@spontaneous/user"
-        #     assert last_response.ok?
-        #     Spot::JSON.parse(last_response.body).should == @editor_user.export
-        #   end
-        # end
       end
 
     end
@@ -400,7 +414,7 @@ class AuthenticationTest < MiniTest::Spec
           value = "Updated #{version}"
           field = root.fields[:root_level]
           auth_post "/@spontaneous/save/#{root.id}", "field[#{field.schema_id}][unprocessed_value]" => value
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
           root.reload.fields[:root_level].value.should == @root_copy.root_level.value
         end
 
@@ -414,12 +428,12 @@ class AuthenticationTest < MiniTest::Spec
 
         should "not be able to add to root level box" do
           auth_post "/@spontaneous/add/#{root.id}/#{root.boxes[:root_level].schema_id}/#{AuthenticationTest::C.schema_id}"
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
 
         should "not be able to add root level types to admin level box" do
           auth_post "/@spontaneous/add/#{root.id}/#{root.boxes[:admin_level].schema_id}/#{AuthenticationTest::D.schema_id}"
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
 
         should "be able to add to admin level box" do
@@ -432,27 +446,27 @@ class AuthenticationTest < MiniTest::Spec
           value = "Updated #{version}"
           field = root.fields[:editor_level]
           auth_post "/@spontaneous/savebox/#{root.id}/#{root.boxes[:root_level].schema_id}", "field[#{field.schema_id}][unprocessed_value]" => value
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
 
         should "not be able to update root level fields from admin level box" do
           value = "Updated #{version}"
           field = root.boxes[:admin_level].fields[:root_level]
           auth_post "/@spontaneous/savebox/#{root.id}/#{root.boxes[:admin_level].schema_id}", "field[#{field.schema_id}][unprocessed_value]" => value
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
 
         should "not be able to delete from root level box" do
-          piece = root.boxes[:root_level].pieces.first
-          pieces = root.reload.boxes[:root_level].pieces.length
+          piece = root.boxes[:root_level].contents.first
+          pieces = root.reload.boxes[:root_level].contents.length
           auth_post "/@spontaneous/destroy/#{piece.id}"
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
-          root.reload.boxes[:root_level].pieces.length.should == pieces
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
+          root.reload.boxes[:root_level].contents.length.should == pieces
         end
         should "not be able to wrap files in root level box" do
           src_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
           auth_post "/@spontaneous/file/wrap/#{root.id}/#{root.boxes[:root_level].schema_id}", "file" => ::Rack::Test::UploadedFile.new(src_file, "image/jpeg")
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
         should "not be able to wrap files in box if allow permissions don't permit it" do
           src_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
@@ -460,27 +474,27 @@ class AuthenticationTest < MiniTest::Spec
           # editor_level box allows addition of type C but only by root
           # so the following should throw a perms error:
           auth_post "/@spontaneous/file/wrap/#{root.id}/#{root.boxes[:editor_level].schema_id}", "file" => ::Rack::Test::UploadedFile.new(src_file, "image/jpeg")
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
         should "not be able to re-order pieces in root level box" do
-          piece = root.boxes[:root_level].pieces.last
+          piece = root.boxes[:root_level].contents.last
           auth_post "/@spontaneous/content/#{piece.id}/position/0"
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
-          root.reload.boxes[:root_level].pieces.last.id.should == piece.id
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
+          root.reload.boxes[:root_level].contents.last.id.should == piece.id
         end
 
         should "not be able to replace root level fields" do
-          piece = root.boxes[:root_level].pieces.first
+          piece = root.boxes[:root_level].contents.first
           src_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
           field = piece.fields[:photo]
           auth_post "/@spontaneous/file/replace/#{piece.id}", "file" => ::Rack::Test::UploadedFile.new(src_file, "image/jpeg"), "field" => field.schema_id
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
 
         should "not be able to hide entries in root-level boxes" do
-          piece = root.boxes[:root_level].pieces.first
+          piece = root.boxes[:root_level].contents.first
           auth_post "/@spontaneous/toggle/#{piece.id}"
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
 
         should "not be allowed to update path of pages without permission"
@@ -496,9 +510,8 @@ class AuthenticationTest < MiniTest::Spec
         end
 
         should "not be able to retrieve the list of changes" do
-          Change.delete
-          get "/@spontaneous/publish/changes"
-          assert last_response.status == 401, "Should have a permissions error 401 not #{last_response.status}"
+          auth_get "/@spontaneous/publish/changes"
+          assert last_response.status == 403, "Should have a permissions error 403 not #{last_response.status}"
         end
       end
     end

data/test/unit/test_boxes.rb

@@ -338,16 +338,16 @@ class BoxesTest < MiniTest::Spec
       @parent = Content[@parent.id]
       child1.reload; child2.reload; child3.reload
       @parent.images.contents.should == [child1]
-      @parent.images.pieces.should == [child1]
+      @parent.images.contents.should == [child1]
+      @parent.words.contents.should == [child2]
       @parent.words.contents.should == [child2]
-      @parent.words.pieces.should == [child2]
-      @parent.pieces.should == [child1, child2]
-      child1.images.pieces.should == [child3]
-      child1.pieces.should == [child3]
+      @parent.contents.should == [child1, child2]
+      child1.images.contents.should == [child3]
+      child1.contents.should == [child3]
 
-      @parent.images.pieces.first.box.should == @parent.images
-      @parent.words.pieces.first.box.should == @parent.words
-      @parent.pieces.first.box.should == @parent.images
+      @parent.images.contents.first.box.should == @parent.images
+      @parent.words.contents.first.box.should == @parent.words
+      @parent.contents.first.box.should == @parent.images
     end
 
     should "choose correct style" do
@@ -358,9 +358,10 @@ class BoxesTest < MiniTest::Spec
       styled.one << child1
       styled.two << child2
       styled.save
-      styled = Content[styled.id]
-      styled.one.pieces.first.style.name.should == :blank2
-      styled.two.pieces.first.style.name.should == :blank3
+      styled = Content.first :id => styled.id
+
+      styled.one.contents.first.style.name.should == :blank2
+      styled.two.contents.first.style.name.should == :blank3
     end
 
     should "be insertable at any position" do
@@ -443,12 +444,12 @@ class BoxesTest < MiniTest::Spec
     # end
 
     should "allow all styles by default" do
-      Parent.allowed[2].styles.should == Allowed3.styles
+      Parent.allowed[2].styles(nil).should == Allowed3.styles
     end
 
     should "have a list of allowable styles" do
-      Parent.allowed[1].styles.length.should == 2
-      Parent.allowed[1].styles.map { |s| s.name }.should == [:ringo, :george]
+      Parent.allowed[1].styles(nil).length.should == 2
+      Parent.allowed[1].styles(nil).map { |s| s.name }.should == [:ringo, :george]
     end
 
     # TODO: decide on whether verifying style names is a good idea
@@ -460,7 +461,7 @@ class BoxesTest < MiniTest::Spec
       a = Allowable.new
       b = Allowed2.new
       a.parents << b
-      a.parents.pieces.first.style.prototype.should == Allowed2.styles[:ringo]
+      a.parents.contents.first.style.prototype.should == Allowed2.styles[:ringo]
     end
 
     should "know what the available styles are for an entry" do
@@ -563,6 +564,10 @@ class BoxesTest < MiniTest::Spec
       @c.boxes.inner.render.should == "[a][b][f]"
       @c.boxes.outer.render.should == "[c][d][e]"
     end
+
+    should "return an empty array when asking for an unknown box group" do
+      @a.boxes.group(:nothing).should == []
+    end
   end
 end