Merge branch 'qrush/shoulda' into can_has_good_tests

Conflicts:
	test/test_generated_site.rb
	test/test_post.rb
	test/test_site.rb
	test/test_tags.rb

test/helper.rb

@@ -2,6 +2,7 @@ require File.join(File.dirname(__FILE__), *%w[.. lib jekyll])
 
 require 'test/unit'
 require 'redgreen'
+require 'shoulda'
 
 include Jekyll
 

test/test_filters.rb

@@ -1,41 +1,41 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TestFilters < Test::Unit::TestCase
-  
   class JekyllFilter
     include Jekyll::Filters
   end
 
-  def setup
+  context "filters" do
+    setup do
       @filter = JekyllFilter.new
     end
 
-  def test_textilize_with_simple_string
+    should "textilize with simple string" do
       assert_equal "<p>something <strong>really</strong> simple</p>", @filter.textilize("something *really* simple")
     end
 
-  def test_array_to_sentence_string_with_no_args
+    should "convert array to sentence string with no args" do
       assert_equal "", @filter.array_to_sentence_string([])
     end
 
-  def test_array_to_sentence_string_with_one_arg
+    should "convert array to sentence string with one arg" do
       assert_equal "1", @filter.array_to_sentence_string([1])
       assert_equal "chunky", @filter.array_to_sentence_string(["chunky"])
     end
 
-  def test_array_to_sentence_string_with_two_args
+    should "convert array to sentence string with two args" do
       assert_equal "1 and 2", @filter.array_to_sentence_string([1, 2])
       assert_equal "chunky and bacon", @filter.array_to_sentence_string(["chunky", "bacon"])
     end
 
-  def test_array_to_sentence_string_with_multiple_args
+    should "convert array to sentence string with multiple args" do
       assert_equal "1, 2, 3, and 4", @filter.array_to_sentence_string([1, 2, 3, 4])
       assert_equal "chunky, bacon, bits, and pieces", @filter.array_to_sentence_string(["chunky", "bacon", "bits", "pieces"])
     end
 
-  def test_xml_escape_with_ampersands
+    should "escape xml with ampersands" do
       assert_equal "AT&amp;T", @filter.xml_escape("AT&T")
       assert_equal "&lt;code&gt;command &amp;lt;filename&amp;gt;&lt;/code&gt;", @filter.xml_escape("<code>command &lt;filename&gt;</code>")
     end
-  
+  end
 end

test/test_generated_site.rb

@@ -1,38 +1,36 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TestGeneratedSite < Test::Unit::TestCase
-  def setup
+  context "generated sites" do
+    setup do
       clear_dest
-    @config = Jekyll::DEFAULTS.clone
+      @source = File.join(File.dirname(__FILE__), *%w[source])
-    @config['source'] = File.join(File.dirname(__FILE__), *%w[source])
+      @s = Site.new(@source, dest_dir)
-    @config['destination'] = dest_dir
-    Jekyll.configure(@config)
-    @s = Site.new(@config)
       @s.process
       @index = File.read(File.join(dest_dir, 'index.html'))
     end
 
-  def test_site_posts_in_index
+    should "insert site.posts into the index" do
-    # confirm that {{ site.posts }} is working
       assert @index.include?("#{@s.posts.size} Posts")
     end
 
-  def test_post_content_in_index
+    should "render post.content" do
-    # confirm that the {{ post.content }} is rendered OK
+      latest_post = Dir[File.join(@source, '_posts/*')].last
-    latest_post = Dir[File.join(@config['source'], '_posts/*')].last
+      post = Post.new(@source, '', File.basename(latest_post))
-    post = Post.new(@config['source'], '', File.basename(latest_post))
+      Jekyll.content_type = post.determine_content_type
       post.transform
       assert @index.include?(post.content)
     end
 
-  def test_unpublished_posts_are_hidden
+    should "hide unpublished posts" do
       published = Dir[File.join(dest_dir, 'publish_test/2008/02/02/*.html')].map {|f| File.basename(f)}
 
       assert_equal 1, published.size
       assert_equal "published.html", published.first
     end
 
-  def test_posts_directory_not_copied
+    should "not copy _posts directory" do
       assert !File.exist?(File.join(dest_dir, '_posts'))
     end
   end
+end

test/test_post.rb

@@ -1,11 +1,7 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TestPost < Test::Unit::TestCase
-  def setup
+  should "ensure valid posts are valid" do
-    Jekyll.configure(Jekyll::DEFAULTS)
-  end
-  
-  def test_valid
     assert Post.valid?("2008-10-19-foo-bar.textile")
     assert Post.valid?("foo/bar/2008-10-19-foo-bar.textile")
 
@@ -13,132 +9,127 @@ class TestPost < Test::Unit::TestCase
     assert !Post.valid?("blah")
   end
 
-  def test_process
+  context "processing posts" do
-    p = Post.allocate
+    setup do
-    p.process("2008-10-19-foo-bar.textile")
+      @post = Post.allocate
-    
+      @real_file = "2008-10-18-foo-bar.textile"
-    assert_equal Time.parse("2008-10-19"), p.date
+      @fake_file = "2008-10-19-foo-bar.textile"
-    assert_equal "foo-bar", p.slug
+      @source = File.join(File.dirname(__FILE__), *%w[source _posts])
-    assert_equal ".textile", p.ext
     end
 
-  def test_url
+    should "keep date, title, and markup type" do
-    p = Post.allocate
+      @post.process(@fake_file)
-    p.categories = []
-    p.process("2008-10-19-foo-bar.textile")
 
-    assert_equal "/2008/10/19/foo-bar.html", p.url
+      assert_equal Time.parse("2008-10-19"), @post.date
+      assert_equal "foo-bar", @post.slug
+      assert_equal ".textile", @post.ext
     end
 
-  def test_permalink
+    should "create url based on date and title" do
-    p = Post.allocate
+      @post.categories = []
-    p.process("2008-12-03-permalinked-post.textile")
+      @post.process(@fake_file)
-    p.read_yaml(File.join(File.dirname(__FILE__), *%w[source _posts]), "2008-12-03-permalinked-post.textile")
+      assert_equal "/2008/10/19/foo-bar.html", @post.url
-
-    assert_equal "my_category/permalinked-post", p.permalink
     end
 
-  def test_dir_respects_permalink
+    should "respect permalink" do
-    p = Post.allocate
+      file = "2008-12-03-permalinked-post.textile"
-    p.process("2008-12-03-permalinked-post.textile")
+      @post.process(file)
-    p.read_yaml(File.join(File.dirname(__FILE__), *%w[source _posts]), "2008-12-03-permalinked-post.textile")
+      @post.read_yaml(@source, file)
 
-    assert_equal "my_category/", p.dir
+      assert_equal "my_category/permalinked-post", @post.permalink
+      assert_equal "my_category/", @post.dir
+      assert_equal "my_category/permalinked-post", @post.url
     end
 
-  def test_url_respects_permalink
+    should "read yaml front-matter" do
-    p = Post.allocate
+      @post.read_yaml(@source, @real_file)
-    p.process("2008-12-03-permalinked-post.textile")
-    p.read_yaml(File.join(File.dirname(__FILE__), *%w[source _posts]), "2008-12-03-permalinked-post.textile")
 
-    assert_equal "my_category/permalinked-post", p.url
+      assert_equal({"title" => "Foo Bar", "layout" => "default"}, @post.data)
+      assert_equal "\nh1. {{ page.title }}\n\nBest *post* ever", @post.content
     end
 
-  def test_read_yaml
+    should "transform textile" do
-    p = Post.allocate
+      @post.process(@real_file)
-    p.read_yaml(File.join(File.dirname(__FILE__), *%w[source _posts]), "2008-10-18-foo-bar.textile")
+      @post.read_yaml(@source, @real_file)
+      @post.transform
 
-    assert_equal({"title" => "Foo Bar", "layout" => "default"}, p.data)
+      assert_equal "<h1>{{ page.title }}</h1>\n<p>Best <strong>post</strong> ever</p>", @post.content
-    assert_equal "\nh1. {{ page.title }}\n\nBest *post* ever", p.content
-  end
-  
-  def test_transform
-    p = Post.allocate
-    p.process("2008-10-18-foo-bar.textile")
-    p.read_yaml(File.join(File.dirname(__FILE__), *%w[source _posts]), "2008-10-18-foo-bar.textile")
-    p.transform
-    
-    assert_equal "<h1>{{ page.title }}</h1>\n<p>Best <strong>post</strong> ever</p>", p.content
-  end
-
-  def test_published
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '',  "2008-02-02-published.textile")
-		assert_equal true, p.published
-  end
-
-  def test_not_published
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '',  "2008-02-02-not-published.textile")
-		assert_equal false, p.published
-  end
-
-  def test_yaml_category
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '',  "2009-01-27-category.textile")
-    assert p.categories.include?('foo')
-  end
-
-  def test_yaml_categories
-    p1 = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '',
-                  "2009-01-27-categories.textile")
-    p2 = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '',
-                  "2009-01-27-array-categories.textile")
-    
-    [p1, p2].each do |p|
-      assert p.categories.include?('foo')
-      assert p.categories.include?('bar')
-      assert p.categories.include?('baz')
     end
   end
 
-  def test_render
+  context "initializing posts" do
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '',  "2008-10-18-foo-bar.textile")
+    setup do
-    layouts = {"default" => Layout.new(File.join(File.dirname(__FILE__), *%w[source _layouts]), "simple.html")}
+      @setup_post = lambda do |file|
-    p.render(layouts, {"site" => {"posts" => []}})
+        Post.new(File.join(File.dirname(__FILE__), *%w[source]), '', file)
-    
+      end
-    assert_equal "<<< <h1>Foo Bar</h1>\n<p>Best <strong>post</strong> ever</p> >>>", p.output
     end
 
-  def test_write
+    should "publish when published yaml is no specified" do
+      post = @setup_post.call("2008-02-02-published.textile")
+      assert_equal true, post.published
+    end
+
+    should "not published when published yaml is false" do
+      post = @setup_post.call("2008-02-02-not-published.textile")
+      assert_equal false, post.published
+    end
+
+    should "recognize category in yaml" do
+      post = @setup_post.call("2009-01-27-category.textile")
+      assert post.categories.include?('foo')
+    end
+
+    should "recognize several categories in yaml" do
+      post = @setup_post.call("2009-01-27-categories.textile")
+      assert post.categories.include?('foo')
+      assert post.categories.include?('bar')
+      assert post.categories.include?('baz')
+    end
+
+    context "rendering" do
+      setup do
         clear_dest
-    
+        @render = lambda do |post|
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '', "2008-10-18-foo-bar.textile")
           layouts = {"default" => Layout.new(File.join(File.dirname(__FILE__), *%w[source _layouts]), "simple.html")}
-    p.render(layouts, {"site" => {"posts" => []}})
+          post.render(layouts, {"site" => {"posts" => []}})
-    p.write(dest_dir)
+        end
-  end
+      end
-  
+
-  def test_data
+      should "render properly" do
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '', "2008-11-21-complex.textile")
+        post = @setup_post.call("2008-10-18-foo-bar.textile")
-    layouts = {"default" => Layout.new(File.join(File.dirname(__FILE__), *%w[source _layouts]), "simple.html")}
+        @render.call(post)
-    p.render(layouts, {"site" => {"posts" => []}})
+        assert_equal "<<< <h1>Foo Bar</h1>\n<p>Best <strong>post</strong> ever</p> >>>", post.output
-    
+      end
-    assert_equal "<<< <p>url: /2008/11/21/complex.html<br />\ndate: #{Time.parse("2008-11-21")}<br />\nid: /2008/11/21/complex</p> >>>", p.output
+
-  end
+      should "write properly" do
-  
+        post = @setup_post.call("2008-10-18-foo-bar.textile")
-  def test_categories_and_topics
+        @render.call(post)
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), 'foo', 'bar/2008-12-12-topical-post.textile')
+        post.write(dest_dir)
-    assert_equal ['foo'], p.categories
+
-    assert_equal ['bar'], p.topics
+        assert File.directory?(dest_dir)
-  end    
+        assert File.exists?(File.join(dest_dir, '2008', '10', '18', 'foo-bar.html'))
-  
+      end
-  def test_include
+
-    config = Jekyll::DEFAULTS.clone
+      should "insert data" do
-    config['source'] = File.join(File.dirname(__FILE__), *%w[source])
+        post = @setup_post.call("2008-11-21-complex.textile")
-    Jekyll.configure(config)
+        @render.call(post)
-
+
-    p = Post.new(File.join(File.dirname(__FILE__), *%w[source]), '', "2008-12-13-include.markdown")
+        assert_equal "<<< <p>url: /2008/11/21/complex.html<br />\ndate: #{Time.parse("2008-11-21")}<br />\nid: /2008/11/21/complex</p> >>>", post.output
-    layouts = {"default" => Layout.new(File.join(File.dirname(__FILE__), *%w[source _layouts]), "simple.html")}
+      end
-    p.render(layouts, {"site" => {"posts" => []}})
+
-    
+      should "include templates" do
-    assert_equal "<<< <hr />\n<p>Tom Preston-Werner github.com/mojombo</p>\n\n<p>This <em>is</em> cool</p> >>>", p.output
+        Jekyll.source = File.join(File.dirname(__FILE__), 'source')
+        post = @setup_post.call("2008-12-13-include.markdown")
+        @render.call(post)
+
+        assert_equal "<<< <hr />\n<p>Tom Preston-Werner github.com/mojombo</p>\n\n<p>This <em>is</em> cool</p> >>>", post.output
+      end
+    end
+  end
+
+  should "generate categories and topics" do
+    post = Post.new(File.join(File.dirname(__FILE__), *%w[source]), 'foo', 'bar/2008-12-12-topical-post.textile')
+    assert_equal ['foo'], post.categories
+    assert_equal ['bar'], post.topics
   end
 end

test/test_site.rb

@@ -1,43 +1,36 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TestSite < Test::Unit::TestCase
-  def setup
+  context "creating sites" do
-    @config = Jekyll::DEFAULTS.clone
+    setup do
-    @config['source'] = File.join(File.dirname(__FILE__), *%w[source])
+      @source = File.join(File.dirname(__FILE__), 'source')
-    @config['destination'] = dest_dir
+      @s = Site.new(@source, dest_dir)
-    Jekyll.configure(@config)
-    @s = Site.new(@config)
     end
 
-  def test_site_init
+    should "read layouts" do
-    
-  end
-  
-  def test_read_layouts
       @s.read_layouts
-    
       assert_equal ["default", "simple"].sort, @s.layouts.keys.sort
     end
 
-  def test_read_posts
+    should "read posts" do
       @s.read_posts('')
-    posts = Dir[File.join(@config['source'], '_posts/*')]
+      posts = Dir[File.join(@source, '_posts/*')]
       assert_equal posts.size - 1, @s.posts.size
     end
 
-  def test_site_payload
+    should "deploy payload" do
       clear_dest
       @s.process
 
-    posts = Dir[File.join(@config['source'], "**", "_posts/*")]
+      posts = Dir[File.join(@source, "**", "_posts/*")]
       categories = %w(bar baz category foo z_category publish_test).sort
 
       assert_equal posts.size - 1, @s.posts.size
       assert_equal categories, @s.categories.keys.sort
-    assert_equal 4, @s.categories['foo'].size
+      assert_equal 3, @s.categories['foo'].size
     end
 
-  def test_filter_entries
+      should "filter entries" do
         ent1 = %w[foo.markdown bar.markdown baz.markdown #baz.markdown#
                 .baz.markdow foo.markdown~]
         ent2 = %w[.htaccess _posts bla.bla]
@@ -46,3 +39,4 @@ class TestSite < Test::Unit::TestCase
         assert_equal ent2, @s.filter_entries(ent2)
     end
   end
+end

test/test_tags.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TestTags < Test::Unit::TestCase
-  
+  context "tagging" do
-  def setup
+    setup do
       @content = <<CONTENT
 ---
 layout: post
@@ -19,13 +19,13 @@ puts "bye"
 CONTENT
     end
 
-  def test_markdown_with_pygments_line_handling
+    should "render markdown with pygments line handling" do
       Jekyll.pygments = true
-    context = {"content_type" => 'markdown'}
+      Jekyll.content_type = :markdown
 
-    result = Liquid::Template.parse(@content).render(context, [Jekyll::Filters])
+      result = Liquid::Template.parse(@content).render({}, [Jekyll::Filters])
-    result = Jekyll.markdown(result)
+      result = Jekyll.markdown_proc.call(result)
       assert_no_match(/markdown\-html\-error/,result)
     end
-  
+  end
 end