spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/test/javascript/test_markdown.rb

@@ -9,7 +9,7 @@ class MarkdownEditorTest < MiniTest::Spec
 
   def setup
     @page = page
-    @page.x(<<-JS)
+    @page.eval(<<-JS)
       var fake_input = function(start, end, value) {
         var array = [];
         array.value = value;
@@ -25,19 +25,25 @@ class MarkdownEditorTest < MiniTest::Spec
           if (new_value) { this.value = new_value; }
           return this.value;
         };
+        array.focus = function() {};
+        array.bind = function() { return array;  };
         return array;
       }
     JS
   end
 
   def style(command, sel_start, sel_end, value)
-    state = @page.x(<<-JS)
+    state = @page.eval(<<-JS)
       var input = fake_input(#{sel_start}, #{sel_end}, #{value.inspect})
       var command = new Spontaneous.FieldTypes.MarkdownField.#{command}(input)
       command.execute();
       Spontaneous.FieldTypes.MarkdownField.TextCommand.get_state(input)
     JS
-    result = Hash[state.to_ary]
+    result = {
+      "before" => state["before"],
+      "middle" => state["middle"],
+      "after" => state["after"]
+    }
     result["value"] = result["before"] + result["middle"] + result["after"]
     result
   end
@@ -92,6 +98,40 @@ class MarkdownEditorTest < MiniTest::Spec
           end
         end
       end
+      context "for links" do
+        setup do
+          @page.eval("Spontaneous.Location.retrieve = function() {}")
+          @page.eval("Spontaneous.Popover.open = function() {}")
+        end
+        should "expand selection to full link if cursor inside a link text" do
+          state = style('Link', 8, 8, "Before [link](http://example.com/page?param1=a&param2=b) after")
+          state["middle"].should == "[link](http://example.com/page?param1=a&param2=b)"
+        end
+        should "expand selection to full link if cursor inside a link URL" do
+          state = style('Link', 14, 14, "Before [link](http://example.com/page?param1=a&param2=b) after")
+          state["middle"].should == "[link](http://example.com/page?param1=a&param2=b)"
+        end
+        should "expand selection to full link if cursor inside a link URL with brackets afterwards" do
+          state = style('Link', 14, 14, "Before [link](http://example.com/page?param1=a&param2=b) (after)")
+          state["middle"].should == "[link](http://example.com/page?param1=a&param2=b)"
+        end
+        should "expand selection to full link if cursor between link text & URL" do
+          state = style('Link', 13, 13, "Before [link](http://example.com/page?param1=a&param2=b) after")
+          state["middle"].should == "[link](http://example.com/page?param1=a&param2=b)"
+        end
+        should "not greedily expand forward to other brackets within text" do
+          state = style('Link', 7, 11, "Before link (after)")
+          state["middle"].should == "link"
+        end
+        should "not greedily expand to other brackets within text" do
+          state = style('Link', 9, 13, "(Before) link after")
+          state["middle"].should == "link"
+        end
+        should "properly extract link from surrounding brackets" do
+          state = style('Link', 9, 9, "Before ([link](http://example.com/page?param1=a&param2=b)) after")
+          state["middle"].should == "[link](http://example.com/page?param1=a&param2=b)"
+        end
+      end
     end
   end
 end

data/test/support/custom_matchers.rb

@@ -56,9 +56,10 @@ module CustomMatchers
   end
 
   custom_matcher :be_content_revision do |receiver, matcher, args|
+    ident = lambda { |ident| Spontaneous.database.dataset.quote_identifier(ident) }
     revision = args[0]
     types = args[1]
-    table = "`#{Spontaneous::Content.revision_table(revision)}`"
+    table = "#{ident[Spontaneous::Content.revision_table(revision)]}"
     sql = "SELECT \\* FROM #{table}"
     if types
       if types.is_a?(Array)
@@ -66,7 +67,7 @@ module CustomMatchers
       else
         types = "'#{types}'"
       end
-      sql << " WHERE \\(#{table}.`type_sid` IN \\(#{types}"
+      sql << " WHERE \\(#{table}.#{ident["type_sid"]} IN \\(#{types}"
     end
     regexp = %r{^#{sql}}
     matcher.positive_failure_message = "Expected #{receiver.sql} to =~ #{regexp}"

data/test/test_helper.rb

@@ -18,17 +18,30 @@ $:.unshift(spot_path) if File.directory?(spot_path) && !$:.include?(spot_path)
 
 require 'rack'
 require 'logger'
+require 'pg'
 
 
 Sequel.extension :migration
 
-DB = Sequel.connect('mysql2://root@localhost/spontaneous2_test') unless defined?(DB)
-# DB = Sequel.connect('postgres://postgres@localhost/spontaneous2_test') unless defined?(DB)
+# for future integration with travis
+ENV["SPOT_ADAPTER"] ||= "postgres"
+
+connection_string = case ENV["SPOT_ADAPTER"]
+                    when "postgres"
+                      'postgres:///spontaneous2_test'
+                    when "mysql"
+                      'mysql2://root@localhost/spontaneous2_test'
+                    end
+
+p connection_string
+DB = Sequel.connect(connection_string) unless defined?(DB)
 # DB.logger = Logger.new($stdout)
+
 Sequel::Migrator.apply(DB, 'db/migrations')
 
 require File.expand_path(File.dirname(__FILE__) + '/../lib/spontaneous')
-require File.expand_path(File.dirname(__FILE__) + '/../lib/cutaneous')
+# require File.expand_path(File.dirname(__FILE__) + '/../lib/cutaneous')
+require 'cutaneous'
 
 # require 'test/unit'
 require 'minitest/spec'
@@ -125,6 +138,32 @@ class MiniTest::Spec
     FileUtils.rm_r(Spontaneous.instance.root) rescue nil
   end
 
+  def self.stub_time(time)
+    Sequel.datetime_class.stubs(:now).returns(time)
+    Time.stubs(:now).returns(time)
+  end
+  def stub_time(time)
+    self.class.stub_time(time)
+  end
+
+  def assert_content_equal(result, compare)
+    serialised_columns = [:field_store, :entry_store]
+    columns = Content.columns - serialised_columns
+    columns.each do |col|
+      assert_equal(result[col], compare[col], "Column '#{col}' should be equal")
+    end
+    serialised_columns.each do |col|
+      result.send(col).should == compare.send(col)
+    end
+  end
+
+  def log_sql(&block)
+    logger = S::Content.db.logger
+    S::Content.db.logger = ::Logger.new($stdout)
+    yield
+  ensure
+    S::Content.db.logger = logger
+  end
   def setup_site(root = nil)
     self.class.setup_site(root)
   end
@@ -133,13 +172,8 @@ class MiniTest::Spec
     self.class.teardown_site
   end
 
-  def template_root=(template_root)
-    @template_root = template_root
-    Spontaneous.stubs(:template_paths).returns([@template_root])
-  end
-
   def assert_correct_template(content, expected_path, format = :html)
-    assert_equal(template_root / expected_path, content.template(format))
+    assert_equal(expected_path, content.template(format))
   end
 
   def assert_file_exists(*path)
@@ -182,6 +216,13 @@ class MiniTest::Spec
     end
   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
 
 end
 

data/test/test_javascript.rb

@@ -1,33 +1,33 @@
 # encoding: UTF-8
 
-require 'harmony'
+require 'v8'
+require 'spontaneous/rack'
 
 module JavascriptTestBase
 
   def spontaneous_index
-    Harmony::Page.new
+    V8::Context.new
   end
 
   def page
     config = mock()
     config.stubs(:reload_classes).returns(false)
     Spontaneous.stubs(:config).returns(config)
-    page = Harmony::Page.new
-    page.x("window.console = {'log': function(){ print.apply(window, arguments)}, 'dir': function() {}};")
-    page.x("Spontaneous = {};")
-    Spontaneous::Rack::Back::JAVASCRIPT_FILES.each do |script|
-      # jquery 1.5.1 doesn't work with johnson
-      script = script.gsub(/jquery-1\.5\.1/, 'jquery-1.4.2')
-      # puts script
-      page.load(javascript_dir / "#{script}.js")
+    page = V8::Context.new
+    page.load(File.expand_path('../javascript/env.js', __FILE__))
+    page.eval("window.console = {'log': function(){ print.apply(window, arguments)}, 'dir': function() {}};")
+    page.eval("Spontaneous = {};")
+    %w(JQUERY COMPATIBILITY EDITING_JS).each do |const|
+      Spontaneous::Rack::Assets::JavaScript.const_get(const).each do |script|
+        page.load(javascript_dir / "#{script}.js") unless ["load", "init"].include?(script)
+      end
     end
-    page.x("jQuery.noConflict();")
-    # page.load(javascript_dir / 'properties.js')
+    page.eval("jQuery.noConflict();")
     page
   end
 
   def javascript_dir
-    "application/js"
+    File.expand_path("../../application/js", __FILE__)
   end
 
 end

data/test/ui_helper.rb

@@ -25,7 +25,7 @@ module SeleniumTest
 
     def startup
       Spontaneous::Permissions::User.delete
-      @user = Spontaneous::Permissions::User.create(:email => "root@example.com", :login => "root", :name => "root", :password => "rootpass", :password_confirmation => "rootpass")
+      @user = Spontaneous::Permissions::User.create(:email => "root@example.com", :login => "root", :name => "root", :password => "rootpass")
       @user.update(:level => Spontaneous::Permissions.root)
       @user.save
       launch_selenium

data/test/unit/test_alias.rb

@@ -18,9 +18,12 @@ class AliasTest < MiniTest::Spec
   context "Aliases:" do
     setup do
       @site = setup_site
-      Content.delete
+      @template_root = File.expand_path(File.join(File.dirname(__FILE__), "../fixtures/templates/aliases"))
+      @site.paths.add(:templates, @template_root)
+      @renderer = S::Output::Template::Renderer.new(false)
+      S::Output.renderer = @renderer
 
-      self.template_root = File.expand_path(File.join(File.dirname(__FILE__), "../fixtures/templates/aliases"))
+      Content.delete
 
       class ::Page < Spontaneous::Page
         field :title
@@ -172,8 +175,8 @@ class AliasTest < MiniTest::Spec
             class ::XX < ::Piece
               alias_of :AA, :container => Proc.new { S::Site['#thepage'].box1 }
             end
-            X.targets.should == @page.box1.select { |p| A === p }
-            XX.targets.should == @page.box1.select { |p| AA === p }
+            Set.new(X.targets).should == Set.new(@page.box1.select { |p| A === p })
+            Set.new(XX.targets).should == Set.new(@page.box1.select { |p| AA === p })
           end
 
           should "allow for selecting only content from a range of boxes" do
@@ -219,10 +222,10 @@ class AliasTest < MiniTest::Spec
 
           should "allow for selecting content only from the content of the owner of the box" do
             class ::X < ::Piece
-              alias_of proc { |owner| owner.box1.pieces }
+              alias_of proc { |owner| owner.box1.contents }
             end
             class ::XX < ::Piece
-              alias_of proc { |owner, box| box.pieces }
+              alias_of proc { |owner, box| box.contents }
             end
             class ::XXX < ::Piece
               alias_of :A, :container => proc { |owner, box| box }
@@ -243,6 +246,36 @@ class AliasTest < MiniTest::Spec
             end
             assert_same_content pieces, X.targets
           end
+
+          should "allow for filtering instances according to current page content" do
+            @page.box1 << AAA.create
+            @page.box2 << AAA.create
+            @page.save.reload
+            allowable = AAA.all - @page.box1.contents
+            ::X  = Class.new(::Piece) do
+              alias_of :AAA, :filter => proc { |choice, page, box| !box.include?(choice) }
+            end
+            assert_same_content allowable, X.targets(@page, @page.box1)
+          end
+
+          should "allow for ensuring the uniqueness of the entries" do
+            aaa = AAA.all
+            ::X  = Class.new(::Piece) do
+              alias_of :AAA, :unique => true
+            end
+            @page.box1 << aaa.first
+            @page.save.reload
+            assert_same_content [aaa.last], X.targets(@page, @page.box1)
+          end
+
+          should "allow for returning an arbitrary list of results generated by a proc" do
+            results = [mock, mock, mock]
+            ::X  = Class.new(::Piece) do
+              alias_of proc { results }
+            end
+            ::X.targets.should ==  results
+          end
+
         end
       end
 
@@ -257,6 +290,11 @@ class AliasTest < MiniTest::Spec
           @a_alias.field?(:a_alias_field1).should be_true
         end
 
+        should "provide access to their target" do
+          @a_alias.target.should == @a
+        end
+
+
         # TODO
         should "reference the aliases fields before the targets"
 
@@ -270,13 +308,13 @@ class AliasTest < MiniTest::Spec
         end
 
         should "have their own styles" do
-          assert_correct_template(@a_alias,  'a_alias/a_alias_style')
+          assert_correct_template(@a_alias,  @template_root / 'a_alias/a_alias_style')
         end
 
         should "present their target's styles as their own" do
           @a_alias.style = :a_style
 
-          assert_correct_template(@a_alias,  'a/a_style')
+          assert_correct_template(@a_alias,  @template_root / 'a/a_style')
         end
 
         # should "have an independent style setting"
@@ -297,11 +335,44 @@ class AliasTest < MiniTest::Spec
           @a_alias.export[:alias_title].should == @a.alias_title
           @a_alias.export[:alias_icon].should == @a.alias_icon_field.export
         end
+
       end
+    end
 
+    context "Aliases to custom models" do
+      setup do
+        @target_id = target_id = 9999
+        @target = target = mock()
+        @target.stubs(:id).returns(@target_id)
+        @target.stubs(:title).returns("custom object")
+
+        @custom_alias_class = Class.new(::Page) do
+          alias_of proc { [target] }, :lookup => lambda { |id|
+            return target if id == target_id
+            nil
+          }, :slug => lambda { |target| target.title.to_url }
+        end
+      end
+      should "be creatable using a custom initializer" do
+        a = @custom_alias_class.for_target(@target_id)
+
+        a.target_id.should == @target_id
+        a.target.should == @target
+      end
 
+      should "be able to provide a slug for pages" do
+        a = @custom_alias_class.for_target(@target_id)
+        a.target.should == @target
+        a.slug.should == "custom-object"
+      end
+
+      should "ignore styles if object doesn't provide them" do
+        a = @custom_alias_class.for_target(@target_id)
+        a.style.template.call.should == Page.new.style.template.call
+      end
     end
 
+
     context "Piece aliases" do
       should "be allowed to target pages" do
         a = BBAlias.create(:target => @bb)

data/test/unit/test_asset_bundler.rb

@@ -0,0 +1,220 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+class AssetBundler < MiniTest::Spec
+  include ::Rack::Test::Methods
+
+  def app
+    Spontaneous::Rack::Back.application
+  end
+
+  def fixture_dir
+    File.expand_path("../../fixtures/asset_pipeline", __FILE__)
+  end
+
+  def setup
+    @site = setup_site
+  end
+
+  def teardown
+    teardown_site
+  end
+
+  context "CMS asset bundler" do
+    should "compile Javascript into any destination directory ddd" do
+      compiler = Spontaneous::Asset::AppCompiler.new(fixture_dir, @site.root, :compress => false)
+      compiler.compile
+      compiled_js_path = Dir["#{@site.root}/public/@spontaneous/assets/spontaneous*.js"].first
+      js = File.read(compiled_js_path)
+      js.should =~ /var simple = "yes";/
+      js.should =~ /var basic/
+      js.should =~ /var complex/
+      js.should =~ /complex = "#{Date.today.day}"/
+      js.should =~ /var simple_subdir = "yes";/
+      js.should =~ /var complex_subdir;/
+      js.should =~ /complex_subdir = "subdir\/#{Date.today.day}";/
+    end
+
+    should "produce compressed Javascript on demand" do
+      compiler = Spontaneous::Asset::AppCompiler.new(fixture_dir, @site.root, :compress => true)
+      compiler.compile
+      compiled_js_path = Dir["#{@site.root}/public/@spontaneous/assets/spontaneous*.js"].first
+      js = File.read(compiled_js_path)
+      # hard to test because we don't know exactly what the uglifier is going to do
+      js.should =~ /var a;a="yes"/
+      js.should =~ /var a;a="#{Date.today.day}"/
+      js.should =~ /var a;a="subdir\/#{Date.today.day}"/
+    end
+
+    should "compile CSS into any destination directory" do
+      compiler = Spontaneous::Asset::AppCompiler.new(fixture_dir, @site.root, :compress => false)
+      compiler.compile
+      compiled_css_path = Dir["#{@site.root}/public/@spontaneous/assets/*.css"].first
+      css = File.read(compiled_css_path)
+      css.should =~ /\.simple \{\s+color: #aaa/
+      css.should =~ /\.basic \{\s+color: #aabbcc/
+      css.should =~ /\.complex \{\s+color: #ddeeff;\s*width: #{Date.today.day}px/
+      css.should =~ /\.subdir\.simple \{\s+color: #000;/
+      css.should =~ /\.subdir\.complex \{\s+color: #aaaaaa;\s+height: #{Date.today.day}px/
+    end
+
+    should "produce compressed CSS by default" do
+      compiler = Spontaneous::Asset::AppCompiler.new(fixture_dir, @site.root)
+      compiler.compile
+      compiled_css_path = Dir["#{@site.root}/public/@spontaneous/assets/spontaneous*.css"].first
+      css = File.read(compiled_css_path)
+      css.should =~ /\.simple\{color:#aaa\}/
+      css.should =~ /\.basic\{color:#aabbcc\}/
+      css.should =~ /\.complex\{color:#ddeeff;width:#{Date.today.day}px\}/
+      css.should =~ /\.subdir\.simple\{color:#000\}/
+      css.should =~ /\.subdir\.complex\{color:#aaaaaa;height:#{Date.today.day}px\}/
+    end
+  end
+
+  context "Development mode editing app" do
+    setup do
+      @page = ::S::Content.create
+    end
+
+    teardown do
+      Content.delete
+    end
+
+    context "unauthorised users" do
+      should "load a non-fingerprinted CSS file" do
+        get "/@spontaneous/#{@page.id}"
+        assert_login_page
+        last_response.body.should =~ %r{/@spontaneous/css/spontaneous\.css}
+      end
+    end
+
+    context "authorised users" do
+      setup do
+        @user = Spontaneous::Permissions::User.create(:email => "test@example.com", :login => "test", :name => "test name", :password => "testpass")
+        @site.config.auto_login @user.login
+
+        @key = "c5AMX3r5kMHX2z9a5ExLKjAmCcnT6PFf22YQxzb4Codj"
+        @key.stubs(:user).returns(@user)
+        @key.stubs(:key_id).returns(@key)
+        @user.stubs(:access_keys).returns([@key])
+
+        Spontaneous::Permissions::User.stubs(:[]).with(:login => 'test').returns(@user)
+        Spontaneous::Permissions::User.stubs(:[]).with(@user.id).returns(@user)
+        Spontaneous::Permissions::AccessKey.stubs(:authenticate).with(@key).returns(@key)
+        Spontaneous::Permissions::AccessKey.stubs(:valid?).with(@key, @user).returns(true)
+
+      end
+      teardown do
+        Content.delete
+        Spontaneous::Permissions::User.delete
+      end
+    end
+
+    should "be able to load spontaneous.css" do
+      get "/@spontaneous/css/spontaneous.css"
+      assert last_response.ok?, "Recieved a #{last_response.status} instead of 200"
+      last_response.body.should =~ /#content/
+    end
+  end
+
+  context "Production mode editing app xxxx" do
+    setup do
+      @compiler = Spontaneous::Asset::AppCompiler.new(fixture_dir, @site.root)
+      @compiler.compile
+      @page = ::S::Content.create
+    end
+
+    teardown do
+      Content.delete
+    end
+
+    should "be able to retrieve compiled assets" do
+      css_path = Dir["#{@site.root}/public/@spontaneous/assets/spontaneous*.css"].first
+      css_file = ::File.basename(css_path)
+      get "/@spontaneous/assets/#{css_file}"
+      assert last_response.ok?, "Recieved #{last_response.status} instead of 200 for /@spontaneous/assets/#{css_file}"
+    end
+
+    context "unauthorised users" do
+      should "load a fingerprinted CSS file" do
+        get "/@spontaneous/#{@page.id}"
+        assert_login_page
+        css_path = Dir["#{@site.root}/public/@spontaneous/assets/spontaneous*.css"].first
+        css_file = ::File.basename(css_path)
+        last_response.body.should =~ %r{/@spontaneous/assets/#{ css_file }}
+      end
+
+      should "load fingerpringed JS files" do
+        get "/@spontaneous/#{@page.id}"
+        assert_login_page
+
+        js_path = Dir["#{@site.root}/public/@spontaneous/assets/login*.js"].first
+        js_file = ::File.basename(js_path)
+        last_response.body.should =~ %r{/@spontaneous/assets/#{ js_file }}
+
+        js_path = Dir["#{@site.root}/public/@spontaneous/assets/vendor/jquery*.js"].first
+        js_file = ::File.basename(js_path)
+        last_response.body.should =~ %r{/@spontaneous/assets/vendor/#{ js_file }}
+      end
+    end
+
+    context "authorised users aaaa" do
+      setup do
+        Spontaneous.stubs(:reload!)
+        @user = Spontaneous::Permissions::User.create(:email => "test@example.com", :login => "test", :name => "test name", :password => "testpass")
+        @user.update(:level => Spontaneous::Permissions[:editor])
+        @user.save
+        config = mock()
+        config.stubs(:reload_classes).returns(false)
+        config.stubs(:auto_login).returns('test')
+        config.stubs(:default_charset).returns('utf-8')
+        config.stubs(:publishing_method).returns(:immediate)
+        config.stubs(:services).returns(nil)
+        config.stubs(:site_domain).returns('example.org')
+        config.stubs(:site_id).returns('example_org')
+        config.stubs(:site_id).returns('example_org')
+        @site.stubs(:config).returns(config)
+
+        @key = "c5AMX3r5kMHX2z9a5ExLKjAmCcnT6PFf22YQxzb4Codj"
+        @key.stubs(:user).returns(@user)
+        @key.stubs(:key_id).returns(@key)
+        @user.stubs(:access_keys).returns([@key])
+
+        Spontaneous::Permissions::User.stubs(:[]).with(:login => 'test').returns(@user)
+        Spontaneous::Permissions::User.stubs(:[]).with(@user.id).returns(@user)
+        Spontaneous::Permissions::AccessKey.stubs(:authenticate).with(@key).returns(@key)
+        Spontaneous::Permissions::AccessKey.stubs(:valid?).with(@key, @user).returns(true)
+      end
+
+      teardown do
+        Content.delete
+        Spontaneous::Permissions::User.delete
+      end
+
+      should "load fingerpringed JS files" do
+        get "/@spontaneous/"
+        assert last_response.ok?, "User should be authorised but recieving a #{last_response.status}"
+
+        js_path = Dir["#{@site.root}/public/@spontaneous/assets/spontaneous*.js"].first
+        js_file = ::File.basename(js_path)
+        js_size = ::File.size(js_path)
+        last_response.body.should =~ %r{\["/@spontaneous/assets/#{ js_file }", *#{js_size}\]}
+
+        js_path = Dir["#{@site.root}/public/@spontaneous/assets/require*.js"].first
+        js_file = ::File.basename(js_path)
+        last_response.body.should =~ %r{/@spontaneous/assets/#{ js_file }}
+
+        js_path = Dir["#{@site.root}/public/@spontaneous/assets/vendor/jquery*.js"].first
+        js_file = ::File.basename(js_path)
+        last_response.body.should =~ %r{/@spontaneous/assets/vendor/#{ js_file }}
+      end
+    end
+
+    should "be able to load spontaneous.css" do
+      get "/@spontaneous/css/spontaneous.css"
+      assert last_response.ok?, "Recieved a #{last_response.status} instead of 200"
+      last_response.body.should =~ /#content/
+    end
+  end
+end