spontaneous 0.1.0.alpha1

data/test/slow/test_visibility.rb

@@ -0,0 +1,250 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+
+class VisibilityTest < MiniTest::Spec
+
+  context "Content" do
+    setup do
+      Spontaneous.database = DB
+      Spontaneous::Schema.reset!
+      Content.delete
+      class ::R < Page; end
+      R.box :pages
+      class ::P < Page; end
+      P.box :things
+      class ::E < Piece; end
+      E.box :pages
+
+      @root = R.new(:uid => 'root')
+      2.times do |i|
+        c = P.new(:uid => i, :slug => "#{i}")
+        @root.pages << c
+        4.times do |j|
+          d = E.new(:uid => "#{i}.#{j}")
+          c.things << d
+          2.times do |k|
+            e = P.new(:uid => "#{i}.#{j}.#{k}", :slug => "#{i}-#{j}-#{k}")
+            d.pages << e
+            2.times do |l|
+              e.things << E.new(:uid => "#{i}.#{j}.#{k}.#{l}")
+            end
+            d.save
+          end
+        end
+        c.save
+      end
+      @root.save
+      @root.reload
+      @child = Page.uid("0")
+    end
+
+    teardown do
+      [:R, :P, :E].each do |k|
+        Object.send(:remove_const, k)
+      end
+      Spontaneous.database.logger = nil
+      Content.delete
+    end
+
+    should "be visible by default" do
+      @child.visible?.should be_true
+    end
+
+    should "be hidable using #hide!" do
+      @child.hide!
+      @child.visible?.should be_false
+      @child.hidden?.should be_true
+    end
+
+    should "be hidable using #visible=" do
+      @child.visible = false
+      @child.visible?.should be_false
+      @child.hidden?.should be_true
+    end
+
+    should "hide child pages" do
+      @child.page?.should be_true
+      @child.hide!
+      @child.children.each do |child1|
+        child1.visible?.should be_false
+        child1.hidden_origin.should == @child.id
+        child1.children.each do |child2|
+          child2.visible?.should be_false
+          child2.hidden_origin.should == @child.id
+        end
+      end
+    end
+
+    should "hide page content" do
+      @child.hide!
+      @child.reload
+      Piece.all.select { |f| f.visible? }.length.should == 20
+      Piece.all.select do |f|
+        f.page.ancestors.include?(@child) || f.page == @child
+      end.each do |f|
+        f.visible?.should be_false
+        f.hidden_origin.should == @child.id
+      end
+      Piece.all.select do | f |
+        !f.page.ancestors.include?(@child) && f.page != @child
+      end.each do |f|
+        f.visible?.should be_true
+        f.hidden_origin.should be_nil
+      end
+    end
+
+    should "re-show all page content" do
+      @child.hide!
+      @child.show!
+      @child.reload
+      Content.all.each do |c|
+        c.visible?.should be_true
+        c.hidden_origin.should be_nil
+      end
+    end
+
+    should "hide all descendents of page content" do
+      piece = Content.first(:uid => "0.0")
+      f = Piece.new(:uid => "0.0.X")
+      piece << f
+      piece.save
+      piece.reload
+      piece.hide!
+
+      Content.all.each do |c|
+        if c.uid =~ /^0\.0/
+          c.hidden?.should be_true
+          if c.uid == "0.0"
+            c.visible?.should be_false
+            c.hidden_origin.should be_nil
+          else
+            c.visible?.should be_false
+            c.hidden_origin.should == piece.id
+          end
+        else
+          c.hidden?.should be_false
+          c.hidden_origin.should be_nil
+        end
+      end
+
+    end
+
+    should "re-show all descendents of page content" do
+      piece = Content.first(:uid => "0.0")
+      piece.hide!
+      piece.show!
+      Content.all.each do |c|
+        c.visible?.should be_true
+        c.hidden_origin.should be_nil
+      end
+    end
+
+    should "know if something is hidden because its ancestor is hidden" do
+      piece = Content.first(:uid => "0.0")
+      piece.hide!
+      piece.showable?.should be_true
+      child = Content.first(:uid => "0.0.0.0")
+      child.visible?.should be_false
+      child.showable?.should be_false
+    end
+
+    # showing something that is hidden because its ancestor is hidden shouldn't be possible
+    should "stop hidden child content from being hidden" do
+      piece = Content.first(:uid => "0.0")
+      piece.hide!
+      child = Content.first(:uid => "0.0.0.0")
+      child.visible?.should be_false
+      lambda { child.show! }.must_raise(Spontaneous::NotShowable)
+    end
+
+    should "not reveal child content that was hidden before its parent" do
+      piece1 = Content.first(:uid => "0.0.0.0")
+      piece2 = Content.first(:uid => "0.0.0.1")
+      parent = Content.first(:uid => "0.0.0")
+      piece1.container.should == parent
+      piece2.container.should == parent
+      piece1.hide!
+      parent.hide!
+      parent.reload.visible?.should be_false
+      piece1.reload.visible?.should be_false
+      piece2.reload.visible?.should be_false
+      piece1.hidden_origin.should be_blank
+      piece2.hidden_origin.should == parent.id
+      parent.show!
+      parent.reload.visible?.should be_true
+      piece2.reload.visible?.should be_true
+      piece1.reload.visible?.should be_false
+    end
+
+    context "root" do
+      should "should not be hidable" do
+        @root.is_root?.should be_true
+        lambda { @root.visible = false }.must_raise(RuntimeError)
+        lambda { @root.hide! }.must_raise(RuntimeError)
+        @root.visible?.should be_true
+      end
+    end
+
+    context "visibility scoping" do
+      setup do
+        # S.database.logger = ::Logger.new($stdout)
+      end
+
+      teardown do
+        # S.database.logger = nil
+      end
+
+      should "prevent inclusion of hidden content" do
+        @uid = '0'
+        @page = Page.uid(@uid)
+        @page.hide!
+        @page.reload
+        # Spontaneous.database.logger = ::Logger.new($stdout)
+        Page.path("/0").should == @page
+        Content.with_visible do
+          Content.visible_only?.should be_true
+          Page.uid(@uid).should be_blank
+          Page.path("/0").should be_blank
+          Page.uid('0.0.0').should be_blank
+        end
+      end
+
+      should "only show visibile pieces" do
+        page = Content.first(:uid => "1")
+        page.pieces.length.should == 4
+        page.pieces.first.hide!
+        page.reload
+        Content.with_visible do
+          page.pieces.length.should == 3
+          page.pieces.first.id.should_not == page.id
+          page.pieces.first.first?.should be_true
+        end
+      end
+
+      should "stop modification of pieces" do
+        page = Content.first(:uid => "1")
+        Content.with_visible do
+          # would like to make sure we're raising a predictable error
+          # but 1.9 changes the typeerror to a runtime error
+          lambda { page.pieces << Piece.new }.must_raise(TypeError, RuntimeError)
+          lambda { page << Piece.new }.must_raise(TypeError, RuntimeError)
+        end
+      end
+
+      should "ensure that no hidden content can be returned" do
+        @root.reload
+        @root.children.first.children.length.should == 8
+        @root.children.first.pieces.first.hide!
+        # p @root.children.first.children.map { |c| c.visible? }
+        @root.reload
+        Content.with_visible do
+          @root.children.first.children.length.should == 6
+        end
+        # p @root.children.map { |c| c.uid }
+        # p @root.children.first.children.length
+      end
+    end
+  end
+end

data/test/support/custom_matchers.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+module CustomMatchers
+  custom_matcher :be_nil do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be nil but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be nil but it was"
+    receiver.nil?
+  end
+
+  custom_matcher :be_blank do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be blank but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be blank but it was"
+    receiver.blank?
+  end
+
+  custom_matcher :be_true do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be true but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be true but it was"
+    receiver.eql?(true)
+  end
+
+  custom_matcher :be_false do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be false but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be false but it was"
+    receiver.eql?(false)
+  end
+
+  custom_matcher :be_valid do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected to be valid but it was invalid #{receiver.errors.inspect}"
+    matcher.negative_failure_message = "Expected to be invalid but it was valid #{receiver.errors.inspect}"
+    receiver.valid?
+  end
+
+  custom_matcher :have_error_on do |receiver, matcher, args|
+    receiver.valid?
+    attribute = args[0]
+    expected_message = args[1]
+
+    if expected_message.nil?
+      matcher.positive_failure_message = "#{receiver} had no errors on #{attribute}"
+      matcher.negative_failure_message = "#{receiver} had errors on #{attribute} #{receiver.errors.inspect}"
+      !receiver.errors.on(attribute).blank?
+    else
+      actual = receiver.errors.on(attribute)
+      matcher.positive_failure_message = %Q(Expected error on #{attribute} to be "#{expected_message}" but was "#{actual}")
+      matcher.negative_failure_message = %Q(Expected error on #{attribute} not to be "#{expected_message}" but was "#{actual}")
+      actual == expected_message
+    end
+  end
+
+  custom_matcher :have_index do |receiver, matcher, args|
+    index_name = args[0]
+    matcher.positive_failure_message = "#{receiver} does not have index named #{index_name}, but should"
+    matcher.negative_failure_message = "#{receiver} does have index named #{index_name}, but should not"
+    !receiver.collection.index_information.detect { |index| index[0] == index_name }.nil?
+  end
+
+  custom_matcher :be_content_revision do |receiver, matcher, args|
+    revision = args[0]
+    types = args[1]
+    table = "`#{Spontaneous::Content.revision_table(revision)}`"
+    sql = "SELECT \\* FROM #{table}"
+    if types
+      if types.is_a?(Array)
+        types = types.map { |t| "'#{t}'" }.join(', ')
+      else
+        types = "'#{types}'"
+      end
+      sql << " WHERE \\(#{table}.`type_sid` IN \\(#{types}"
+    end
+    regexp = %r{^#{sql}}
+    matcher.positive_failure_message = "Expected #{receiver.sql} to =~ #{regexp}"
+    matcher.negative_failure_message = "Expected #{receiver.sql} to !~ #{regexp}"
+    regexp === receiver.sql
+  end
+end
+

data/test/support/timing.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+class Test::Unit::TestCase
+  def run_with_test_timing(*args, &block)    
+    begin_time = Time.now
+    run_without_test_timing(*args, &block)
+    end_time = Time.now
+ 
+    duration = end_time - begin_time
+    threshold = 0.5
+    
+    if duration > threshold
+      puts "\nSLOW TEST: #{duration} - #{self.name}"
+    end
+  end
+  
+  # alias_method_chain :run, :test_timing unless method_defined?(:run_without_test_timing)
+  unless method_defined?(:run_without_test_timing)
+    alias_method :run_without_test_timing, :run
+    alias_method :run, :run_with_test_timing
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,164 @@
+# encoding: UTF-8
+
+# Set up the Spontaneous environment
+ENV["SPOT_ENV"] = "test"
+
+require "rubygems"
+require "bundler"
+gem 'minitest'
+Bundler.setup(:default, :development)
+
+Bundler.require
+
+require 'rack'
+require 'logger'
+
+
+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)
+# 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 'test/unit'
+require 'minitest/spec'
+require 'rack/test'
+require 'matchy'
+require 'shoulda'
+require 'timecop'
+require 'mocha'
+require 'pp'
+begin
+  require 'leftright'
+rescue LoadError
+  # fails for ruby 1.9
+end
+
+require 'support/custom_matchers'
+# require 'support/timing'
+
+
+# Spontaneous.database = DB
+
+
+class MiniTestWithHooks < MiniTest::Unit
+  def before_suites
+  end
+
+  def after_suites
+  end
+
+  def exclude?(suite)
+    [MiniTest::Spec, Test::Unit::TestCase].include?(suite)
+  end
+
+  def _run_suites(suites, type)
+    names = suites.reject { |s| exclude?(s) }.map { |s| s.to_s.gsub(/Test$/, '') }
+    @max_name_length = names.inject(-1) { |max, name| [name.length, max].max }
+    begin
+      before_suites
+      super(suites, type)
+    ensure
+      after_suites
+    end
+  end
+
+  def _run_suite(suite, type)
+    begin
+      Spontaneous::Schema.schema_loader_class = Spontaneous::Schema::TransientMap
+      Spontaneous::Schema.reset!
+      Spontaneous.logger.silent!
+      unless exclude?(suite)
+        print "\n#{suite.to_s.gsub(/Test$/, '').ljust(@max_name_length, " ")}  "
+      end
+      suite.startup if suite.respond_to?(:startup)
+      super(suite, type)
+    ensure
+      suite.shutdown if suite.respond_to?(:shutdown)
+    end
+  end
+end
+
+
+
+MiniTest::Unit.runner = MiniTestWithHooks.new
+
+def silence_logger(&block)
+  begin
+    $stdout = log_buffer = StringIO.new
+    $stderr.reopen("/dev/null", 'w')
+    block.call
+  ensure
+    $stdout = STDOUT
+    $stderr = STDERR
+    log_buffer.string
+  end
+end
+
+class MiniTest::Spec
+  include Spontaneous
+  include CustomMatchers
+
+  attr_accessor :template_root
+  alias :silence_stdout :silence_logger
+
+  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))
+  end
+
+  def assert_file_exists(*path)
+    path = File.join(*path)
+    assert File.exist?(path), "File at path '#{path}' does not exist!"
+  end
+  alias :assert_dir_exists :assert_file_exists
+
+  def assert_hashes_equal(expected_hash, result_hash, path = [], level = 0)
+    assert result_hash.is_a?(Hash), "'#{path[0..level].join(' > ')}' Expected a hash #{expected_hash.inspect} !== #{result_hash.inspect}"
+    assert_equal expected_hash.keys.length, result_hash.keys.length, "'#{path[0..level].join(' > ')}' Expected #{expected_hash.keys.length} keys #{expected_hash.keys.inspect} !== #{result_hash.keys.inspect} >> #{(expected_hash.keys - result_hash.keys).inspect}"
+    expected_hash.keys.each do |key|
+      path[level] = key
+      expected = expected_hash[key]
+      result = result_hash[key]
+      case expected
+      when Hash
+        assert_hashes_equal(expected, result, path, level+1)
+      when Array
+        assert_arrays_equal(expected, result, path, level+1)
+      else
+        assert_equal expected, result, "Key '#{path[0..level].join(' > ')}' should be identical"
+      end
+    end
+  end
+
+  def assert_arrays_equal(expected_array, result_array, path = [], level = 0)
+    assert_equal expected_array.length, result_array.length
+    expected_array.each_with_index do |expected, index|
+      path[level] = index
+      result = result_array[index]
+      case expected
+      when Hash
+        assert_hashes_equal(expected, result, path, level+1)
+      when Array
+        assert_arrays_equal(expected, result, path, level+1)
+      else
+        assert_equal expected, result, "Key '#{path[0..level].join(' -> ')}' should be identical"
+      end
+    end
+  end
+
+
+end
+
+
+
+require 'minitest/autorun'
+

data/test/test_javascript.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require 'harmony'
+
+module JavascriptTestBase
+
+  def spontaneous_index
+    Harmony::Page.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")
+    end
+    page.x("jQuery.noConflict();")
+    # page.load(javascript_dir / 'properties.js')
+    page
+  end
+
+  def javascript_dir
+    "application/js"
+  end
+
+end
+