spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/test/unit/test_layouts.rb

@@ -2,150 +2,161 @@
 
 require File.expand_path('../../test_helper', __FILE__)
 
-class LayoutsTest < MiniTest::Spec
+describe "Layouts" do
 
-  def setup
+  before do
     @template_root = ::File.expand_path('../../fixtures/layouts', __FILE__)
     @site = setup_site
     @site.paths.add(:templates, @template_root)
+    class ::LayoutPage < ::Page; end
+    class ::ABoxClass < ::Box; end
+    class ::SubPage < LayoutPage; end
+    ABoxClass.style :monkey
+    ABoxClass.style :crazy
+
+    class ::SomeContent < ::Piece; end
   end
 
-  def teardown
+  after do
+    [:LayoutPage, :SubPage, :ABoxClass, :SomeContent].each do |c|
+      Object.send(:remove_const, c) rescue nil
+    end
     teardown_site
   end
 
-  context "layouts" do
-
-    setup do
-      class ::LayoutPage < ::Page; end
-      class ::ABoxClass < ::Box; end
-      class ::SubPage < LayoutPage; end
-      ABoxClass.style :monkey
-      ABoxClass.style :crazy
-
-      class ::SomeContent < ::Piece; end
-    end
+  it "default to layouts/standard.html... if nothing defined" do
+    page = LayoutPage.new
+    assert_correct_template(page, @template_root / 'layouts/standard')
+    page.render.must_equal "layouts/standard.html.cut\n"
+  end
 
-    teardown do
-      [:LayoutPage, :SubPage, :ABoxClass, :SomeContent].each do |c|
-        Object.send(:remove_const, c) rescue nil
+  it "use the named template if it exists" do
+    layout = @template_root / "layouts/layout_page.html.cut"
+    begin
+      File.open(layout, "w") do |file|
+        file.write("layouts/layout_page.html.cut\n")
       end
+      page = LayoutPage.new
+      assert_correct_template(page, @template_root / 'layouts/layout_page')
+      page.render.must_equal "layouts/layout_page.html.cut\n"
+    ensure
+      FileUtils.rm(layout)
     end
+  end
 
-    context "Page layouts" do
-      setup do
-      end
-      should "default to layouts/standard.html... if nothing defined" do
-        page = LayoutPage.new
-        assert_correct_template(page, @template_root / 'layouts/standard')
-        page.render.should == "layouts/standard.html.cut\n"
-      end
+  it "return the first layout if some are declared but none declared default" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2
+    page = LayoutPage.new
+    assert_correct_template(page, @template_root / 'layouts/custom1')
+    page.render.must_equal "layouts/custom1.html.cut\n"
+  end
 
-      should "use the named template if it exists" do
-        layout = @template_root / "layouts/layout_page.html.cut"
-        begin
-          File.open(layout, "w") do |file|
-            file.write("layouts/layout_page.html.cut\n")
-          end
-          page = LayoutPage.new
-          assert_correct_template(page, @template_root / 'layouts/layout_page')
-          page.render.should == "layouts/layout_page.html.cut\n"
-        ensure
-          FileUtils.rm(layout)
-        end
-      end
+  it "return the layout declared default" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2, :default => true
+    page = LayoutPage.new
+    assert_correct_template(page, @template_root / 'layouts/custom2')
+    page.render.must_equal "layouts/custom2.html.cut\n"
+  end
 
-      should "return the first layout if some are declared but none declared default" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2
-        page = LayoutPage.new
-        assert_correct_template(page, @template_root / 'layouts/custom1')
-        page.render.should == "layouts/custom1.html.cut\n"
-      end
+  it "inherit templates from superclass" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2, :default => true
+    page = SubPage.new
+    assert_correct_template(page, @template_root / 'layouts/custom2')
+  end
 
-      should "return the layout declared default" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2, :default => true
-        page = LayoutPage.new
-        assert_correct_template(page, @template_root / 'layouts/custom2')
-        page.render.should == "layouts/custom2.html.cut\n"
-      end
+  it "be able to overwrite inherited templates from superclass" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2, :default => true
+    SubPage.layout :custom3
+    page = SubPage.new
+    # page.layout.template.must_equal 'layouts/custom2'
+    assert_correct_template(page, @template_root / 'layouts/custom2')
+  end
 
-      should "inherit templates from superclass" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2, :default => true
-        page = SubPage.new
-        assert_correct_template(page, @template_root / 'layouts/custom2')
-      end
+  it "allow setting of style used" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2
+    page = LayoutPage.new
+    assert_correct_template(page, @template_root / 'layouts/custom1')
+    # page.layout.template.must_equal 'layouts/custom1'
+    page.layout = :custom2
+    assert_correct_template(page, @template_root / 'layouts/custom2')
+    # page.layout.template.must_equal 'layouts/custom2'
+  end
 
-      should "be able to overwrite inherited templates from superclass" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2, :default => true
-        SubPage.layout :custom3
-        page = SubPage.new
-        # page.layout.template.should == 'layouts/custom2'
-        assert_correct_template(page, @template_root / 'layouts/custom2')
-      end
+  it "use the last definied layout in sub-classes" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2
+    SubPage.layout :custom3
+    SubPage.layout :custom4
+    page = SubPage.new
+    assert_correct_template(page, @template_root / 'layouts/custom3')
+    page.layout = :custom2
+    assert_correct_template(page, @template_root / 'layouts/custom2')
+  end
 
-      should "allow setting of style used" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2
-        page = LayoutPage.new
-        assert_correct_template(page, @template_root / 'layouts/custom1')
-        # page.layout.template.should == 'layouts/custom1'
-        page.layout = :custom2
-        assert_correct_template(page, @template_root / 'layouts/custom2')
-        # page.layout.template.should == 'layouts/custom2'
-      end
+  it "allow defining of default layout in sub-classes" do
+    LayoutPage.layout :custom1
+    LayoutPage.layout :custom2, :default => true
+    SubPage.layout :custom3
+    SubPage.layout :custom4, :default => true
+    page = SubPage.new
+    assert_correct_template(page, @template_root / 'layouts/custom4')
+    page.layout = :custom3
+    assert_correct_template(page, @template_root / 'layouts/custom3')
+  end
 
-      should "use the last definied layout in sub-classes" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2
-        SubPage.layout :custom3
-        SubPage.layout :custom4
-        page = SubPage.new
-        assert_correct_template(page, @template_root / 'layouts/custom3')
-        page.layout = :custom2
-        assert_correct_template(page, @template_root / 'layouts/custom2')
-      end
+  it "support blocks to set simple templates" do
+    LayoutPage.field :title
+    LayoutPage.layout do
+      "${ title }!"
+    end
+    page = LayoutPage.new(:title => "john")
+    page.render.must_equal "john!"
+  end
 
-      should "allow defining of default layout in sub-classes" do
-        LayoutPage.layout :custom1
-        LayoutPage.layout :custom2, :default => true
-        SubPage.layout :custom3
-        SubPage.layout :custom4, :default => true
-        page = SubPage.new
-        assert_correct_template(page, @template_root / 'layouts/custom4')
-        page.layout = :custom3
-        assert_correct_template(page, @template_root / 'layouts/custom3')
-      end
+  it "allows assigning a layout block to a particular output" do
+    LayoutPage.add_output :rss
+    LayoutPage.layout :html do
+      "HTML"
+    end
+    LayoutPage.layout :rss do
+      "RSS"
+    end
+    page = LayoutPage.new
+    page.render(:html).must_equal "HTML"
+    page.render(:rss).must_equal  "RSS"
+  end
 
-      should "support blocks to set simple templates" do
-        LayoutPage.field :title
-        LayoutPage.layout do
-          "${ title }!"
-        end
-        page = LayoutPage.new(:title => "john")
-        page.render.should == "john!"
-      end
-      # should "raise error when setting unknown layout" do
-      #   LayoutPage.layout :custom1
-      #   LayoutPage.layout :custom2
-      #   SubPage.layout :custom3
-      #   page = SubPage.new
-      #   lambda { page.layout = :wrong }.must_raise(Spontaneous::Errors::UnknownLayoutError)
-      # end
-      # should "have a list of formats" do
-      #   LayoutPage.layout :custom1
-      #   skip("Need to implement formats correctly")
-      # end
-
-      # should "be able to test that an instance supports a format" do
-      #   skip("Need to implement formats correctly")
-      #   LayoutPage.layout :custom1
-      #   page = LayoutPage.new
-      #   # page.provides_format?(:html).should be_true
-      # end
+  it "allows a fallback layout block to render all formats" do
+    LayoutPage.add_output :rss
+    LayoutPage.layout do
+      "${ __format }"
     end
+    page = LayoutPage.new
+    page.render(:html).must_equal "html"
+    page.render(:rss).must_equal  "rss"
   end
+
+  # it "raise error when setting unknown layout" do
+  #   LayoutPage.layout :custom1
+  #   LayoutPage.layout :custom2
+  #   SubPage.layout :custom3
+  #   page = SubPage.new
+  #   lambda { page.layout = :wrong }.must_raise(Spontaneous::Errors::UnknownLayoutError)
+  # end
+  # it "have a list of formats" do
+  #   LayoutPage.layout :custom1
+  #   skip("Need to implement formats correctly")
+  # end
+
+  # it "be able to test that an instance supports a format" do
+  #   skip("Need to implement formats correctly")
+  #   LayoutPage.layout :custom1
+  #   page = LayoutPage.new
+  #   # page.provides_format?(:html).should be_true
+  # end
 end

data/test/unit/test_logger.rb

@@ -1,13 +1,12 @@
 # encoding: UTF-8
 
-
 require File.expand_path('../../test_helper', __FILE__)
 
 # borrowed from Padrino
-class LoggerTest < MiniTest::Spec
+describe "Logger" do
   include Spontaneous
 
-  def setup
+  before do
     Spontaneous.env = :test
     Spontaneous::Logger::Config[:test][:stream] = :null # The default
     Spontaneous::Logger.setup!
@@ -18,44 +17,44 @@ class LoggerTest < MiniTest::Spec
     @logger = Spontaneous::Logger.new(options.merge(:stream => @log))
   end
 
-  context 'for logger functionality' do
+  describe 'for logger functionality' do
 
-    context 'check stream config' do
+    describe 'check stream config' do
 
-      should 'use stdout if stream is nil' do
+      it 'use stdout if stream is nil' do
         Spontaneous::Logger::Config[:test][:stream] = nil
         Spontaneous::Logger.setup!
         assert_equal $stdout, Spontaneous.logger.log
       end
 
-      should 'use StringIO as default for test' do
+      it 'use StringIO as default for test' do
         assert_instance_of StringIO, Spontaneous.logger.log
       end
 
-      should 'use a custom stream' do
+      it 'use a custom stream' do
         my_stream = StringIO.new
         Spontaneous::Logger::Config[:test][:stream] = my_stream
         Spontaneous::Logger.setup!
         assert_equal my_stream, Spontaneous.logger.log
       end
 
-      context "with custom log file path" do
-        setup do
+      describe "with custom log file path" do
+        before do
           @relative_path = "tmp/log/mylogfile.log"
         end
 
-        teardown do
+        after do
           FileUtils.rm_r(@relative_path) if File.exists?(@relative_path)
         end
 
-        should "log to given file" do
+        it "log to given file" do
           logger = Spontaneous::Logger.setup(:logfile => @relative_path)
-          logger.log.path.should == @relative_path
+          logger.log.path.must_equal @relative_path
         end
       end
     end
 
-    should 'log something' do
+    it 'log something' do
       setup_logger(:log_level => :error)
       @logger.error "You log this error?"
       assert_match(/You log this error?/, @log.string)
@@ -65,7 +64,7 @@ class LoggerTest < MiniTest::Spec
       assert_match(/Yep this can be logged/, @log.string)
     end
 
-    should "be silenceable" do
+    it "be silenceable" do
       setup_logger(:log_level => :debug)
       @logger.silent!
       @logger.error "You log this error?"
@@ -75,6 +74,4 @@ class LoggerTest < MiniTest::Spec
       assert_match(/You log this error?/, @log.string)
     end
   end
-
-
 end