spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/test/unit/test_formats.rb

@@ -191,7 +191,7 @@ describe "Formats" do
         module CustomHelper1
           def here_is_my_custom_helper1; end
         end
-        Site.register_helper CustomHelper1, :newhtml
+        @site.register_helper CustomHelper1, :newhtml
 
         class NewHTMLFormat < S::Output::HTML
           provides_format :newhtml
@@ -242,6 +242,16 @@ describe "Formats" do
         refute @page.provides_output?(:xyz)
       end
 
+      it "recognises its own output" do
+        assert @page.provides_output?(@page.output(:html))
+      end
+
+      it "doesn't recognise another page's output" do
+        other = FPage.new(slug: "other")
+        refute @page == other
+        refute @page.provides_output?(other.output(:html))
+      end
+
       it "provide a symbol version of the output name" do
         @page.output(:html).to_sym.must_equal :html
       end

data/test/unit/test_generators.rb

@@ -122,7 +122,7 @@ describe "Generators" do
       it "configure the correct gem" do
         generate(:site, "example.com", "--root=#{@tmp}", "--database=postgresql")
         gemfile = File.read(File.join(@site_root, "Gemfile"))
-        gemfile.must_match /^gem 'pg'/
+        gemfile.must_match /^gem 'sequel_pg'.+require: 'sequel'/
       end
 
       it "setup the right db parameters" do
@@ -188,7 +188,7 @@ describe "Generators" do
       site_root = File.join(@tmp, 'example_com')
       generate(:site, "example.com", "--root=#{@tmp}", "--database=postgres", "--user=spontaneous", "--password=s3cret")
       gemfile = File.read(File.join(site_root, "Gemfile"))
-      gemfile.must_match /^gem 'pg'/
+      gemfile.must_match /^gem 'sequel_pg'.+require: 'sequel'/
       config = database_config("example_com")
       [:development, :test].each do |environment|
         config[environment][:user].must_equal "spontaneous"

data/test/unit/test_helpers.rb

@@ -8,7 +8,6 @@ describe "ContextHelpers" do
     @site = setup_site
     @site.paths.add :templates, File.expand_path("../../fixtures/helpers/templates", __FILE__)
     @renderer = S::Output::Template::Renderer.new(false)
-    S::Output.renderer = @renderer
   end
 
   after do
@@ -16,7 +15,7 @@ describe "ContextHelpers" do
   end
 
   it "be assignable to a particular format" do
-    CustomHelper1 = Site.helper :html do
+    CustomHelper1 = @site.helper :html do
       def here_is_my_custom_helper1; end
     end
 
@@ -27,24 +26,24 @@ describe "ContextHelpers" do
       Spontaneous::Output::Helpers::ScriptHelper,
       Spontaneous::Output::Helpers::StylesheetHelper
     ]
-    helper_module = Site.context :html
+    helper_module = @site.context :html
     join = included_helpers & helper_module.ancestors
     Set.new(join).must_equal Set.new(included_helpers)
     assert helper_module.respond_to?(:here_is_my_custom_helper1)
   end
 
   it "be assigned to all formats if none given" do
-    CustomHelper2 = Site.helper do
+    CustomHelper2 = @site.helper do
       extend self
       def here_is_my_custom_helper2; end
     end
 
     assert CustomHelper2.respond_to?(:here_is_my_custom_helper2)
 
-    helper_module = Site.context :html
+    helper_module = @site.context :html
     assert helper_module.ancestors.include?(CustomHelper2)
 
-    helper_module = Site.context :pdf
+    helper_module = @site.context :pdf
     assert helper_module.ancestors.include?(CustomHelper2)
   end
 
@@ -53,14 +52,14 @@ describe "ContextHelpers" do
       add_output :mobile
     end
 
-    Site.helper :html do
+    @site.helper :html do
       def here_is_my_custom_helper3
         "here_is_my_custom_helper3"
       end
       extend self
     end
 
-    Site.helper :mobile do
+    @site.helper :mobile do
       def here_is_my_custom_helper4
         "here_is_my_custom_helper4"
       end

data/test/unit/test_images.rb

@@ -49,7 +49,7 @@ describe "Images" do
       @upload_dir.mkpath
 
       @revision = 10
-      S::Site.stubs(:working_revision).returns(@revision)
+      @site.stubs(:working_revision).returns(@revision)
 
       @src_image =  Pathname.new(File.join(File.dirname(__FILE__), "../fixtures/images/rose.jpg")).realpath
       @origin_image = @upload_dir + "rose.jpg"
@@ -265,7 +265,7 @@ describe "Images" do
           :public_host => "http://media.example.com"
         }
         ::Fog.mock!
-        @storage = Spontaneous::Storage::Cloud.new(@aws_credentials, 'media.example.com')
+        @storage = Spontaneous::Media::Store::Cloud.new(@aws_credentials, 'media.example.com')
         @storage.backend.directories.create(:key => @bucket_name)
         @site.stubs(:storage).with(anything).returns(@storage)
         @image.value = @origin_image.to_s
@@ -281,4 +281,41 @@ describe "Images" do
       end
     end
   end
+
+  describe "clearing" do
+    def assert_image_field_empty
+      @field.value.must_equal ''
+      @field.src.must_equal ''
+      @field.filesize.must_equal 0
+      @field.smaller.value.must_equal ''
+    end
+
+    before do
+      class ::ContentWithImage < ::Content::Piece
+        field :photo, :image do
+          size :smaller do
+            fit width: 100, height: 100
+          end
+        end
+      end
+
+      @instance = ContentWithImage.new
+
+      @content_id = 234
+      @instance.stubs(:id).returns(@content_id)
+      @field = @instance.photo
+      path = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
+      @field.value = path
+    end
+
+    after do
+      Object.send(:remove_const, :ContentWithImage) rescue nil
+    end
+
+    it "clears the value if set to the empty string" do
+      @field.value = ''
+      assert_image_field_empty
+    end
+  end
+
 end

data/test/unit/test_layouts.rb

@@ -24,9 +24,11 @@ describe "Layouts" do
     teardown_site
   end
 
+  let(:renderer) { Spontaneous::Output.default_renderer(@site) }
+
   it "default to layouts/standard.html... if nothing defined" do
     page = LayoutPage.new
-    assert_correct_template(page, @template_root / 'layouts/standard')
+    assert_correct_template(page, @template_root / 'layouts/standard', renderer)
     page.render.must_equal "layouts/standard.html.cut\n"
   end
 
@@ -37,7 +39,7 @@ describe "Layouts" do
         file.write("layouts/layout_page.html.cut\n")
       end
       page = LayoutPage.new
-      assert_correct_template(page, @template_root / 'layouts/layout_page')
+      assert_correct_template(page, @template_root / 'layouts/layout_page', renderer)
       page.render.must_equal "layouts/layout_page.html.cut\n"
     ensure
       FileUtils.rm(layout)
@@ -48,7 +50,7 @@ describe "Layouts" do
     LayoutPage.layout :custom1
     LayoutPage.layout :custom2
     page = LayoutPage.new
-    assert_correct_template(page, @template_root / 'layouts/custom1')
+    assert_correct_template(page, @template_root / 'layouts/custom1', renderer)
     page.render.must_equal "layouts/custom1.html.cut\n"
   end
 
@@ -56,7 +58,7 @@ describe "Layouts" do
     LayoutPage.layout :custom1
     LayoutPage.layout :custom2, :default => true
     page = LayoutPage.new
-    assert_correct_template(page, @template_root / 'layouts/custom2')
+    assert_correct_template(page, @template_root / 'layouts/custom2', renderer)
     page.render.must_equal "layouts/custom2.html.cut\n"
   end
 
@@ -64,7 +66,7 @@ describe "Layouts" do
     LayoutPage.layout :custom1
     LayoutPage.layout :custom2, :default => true
     page = SubPage.new
-    assert_correct_template(page, @template_root / 'layouts/custom2')
+    assert_correct_template(page, @template_root / 'layouts/custom2', renderer)
   end
 
   it "be able to overwrite inherited templates from superclass" do
@@ -73,17 +75,17 @@ describe "Layouts" do
     SubPage.layout :custom3
     page = SubPage.new
     # page.layout.template.must_equal 'layouts/custom2'
-    assert_correct_template(page, @template_root / 'layouts/custom2')
+    assert_correct_template(page, @template_root / 'layouts/custom2', renderer)
   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')
+    assert_correct_template(page, @template_root / 'layouts/custom1', renderer)
     # page.layout.template.must_equal 'layouts/custom1'
     page.layout = :custom2
-    assert_correct_template(page, @template_root / 'layouts/custom2')
+    assert_correct_template(page, @template_root / 'layouts/custom2', renderer)
     # page.layout.template.must_equal 'layouts/custom2'
   end
 
@@ -93,9 +95,9 @@ describe "Layouts" do
     SubPage.layout :custom3
     SubPage.layout :custom4
     page = SubPage.new
-    assert_correct_template(page, @template_root / 'layouts/custom3')
+    assert_correct_template(page, @template_root / 'layouts/custom3', renderer)
     page.layout = :custom2
-    assert_correct_template(page, @template_root / 'layouts/custom2')
+    assert_correct_template(page, @template_root / 'layouts/custom2', renderer)
   end
 
   it "allow defining of default layout in sub-classes" do
@@ -104,9 +106,9 @@ describe "Layouts" do
     SubPage.layout :custom3
     SubPage.layout :custom4, :default => true
     page = SubPage.new
-    assert_correct_template(page, @template_root / 'layouts/custom4')
+    assert_correct_template(page, @template_root / 'layouts/custom4', renderer)
     page.layout = :custom3
-    assert_correct_template(page, @template_root / 'layouts/custom3')
+    assert_correct_template(page, @template_root / 'layouts/custom3', renderer)
   end
 
   it "support blocks to set simple templates" do

data/test/unit/test_media.rb

@@ -13,6 +13,14 @@ describe "Media" do
     teardown_site
   end
 
+  def file(*args)
+    @site.file(*args)
+  end
+
+  def tempfile(*args)
+    @site.tempfile(*args)
+  end
+
   describe "Utility methods" do
     it "be able to sanitise filenames" do
       filename = "Something with-dodgy 'characters'.many.jpg"
@@ -22,11 +30,11 @@ describe "Media" do
 
   describe "All media files" do
     it "know their mimetype" do
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       file.mimetype.must_equal "text/plain"
-      file = Spontaneous::Media::File.new(@content, "file name.jpg")
+      file = file(@content, "file name.jpg")
       file.mimetype.must_equal "image/jpeg"
-      file = Spontaneous::Media::File.new(@content, "file name.jpg", "text/html")
+      file = file(@content, "file name.jpg", "text/html")
       file.mimetype.must_equal "text/html"
     end
 
@@ -42,20 +50,21 @@ describe "Media" do
         :aws_access_key_id=>"ACCESS_KEY_ID",
         :public_host => "http://media.example.com"
       }
-      @storage = Spontaneous::Storage::Cloud.new(@aws_credentials, 'media.example.com')
+      @storage = Spontaneous::Media::Store::Cloud.new(@aws_credentials, 'media.example.com')
       @storage.backend.directories.create(:key => @bucket_name)
       @site.stubs(:storage).with(anything).returns(@storage)
       @content = ::Piece.create
       @content.stubs(:id).returns(99)
       Spontaneous::State.stubs(:revision).returns(853)
     end
+
     it "return an absolute path for the url" do
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       file.url.must_equal "http://media.example.com/00099/0853/file-name.txt"
     end
 
     it "create a new instance with a different name" do
-      file1 = Spontaneous::Media::File.new(@content, "file name.txt")
+      file1 = file(@content, "file name.txt")
       file2 = file1.rename("another.jpg")
       file2.owner.must_equal file1.owner
       file2.mimetype.must_equal "image/jpeg"
@@ -70,7 +79,7 @@ describe "Media" do
       }
       existing_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
       assert ::File.exist?(existing_file)
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       file.copy(existing_file)
     end
 
@@ -82,7 +91,7 @@ describe "Media" do
       }
       existing_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
       assert ::File.exist?(existing_file)
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       File.open(existing_file, 'rb') do |f|
         file.copy(f)
       end
@@ -95,7 +104,7 @@ describe "Media" do
           args[:public] == true
       }
 
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       content_string = "Hello"
       file.open do |f|
         f.write(content_string)
@@ -106,7 +115,7 @@ describe "Media" do
   describe "Local media files" do
     before do
       @media_dir = Dir.mktmpdir
-      @storage = Spontaneous::Storage::Local.new(@media_dir, '/media')
+      @storage = Spontaneous::Media::Store::Local.new(@media_dir, '/media')
       @site.stubs(:storage).with(anything).returns(@storage)
       @content = ::Piece.create
       @content.stubs(:id).returns(99)
@@ -114,17 +123,17 @@ describe "Media" do
     end
 
     it "return an absolute path for the url" do
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       file.url.must_equal "/media/00099/0853/file-name.txt"
     end
 
     it "place files into its configured root" do
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       file.path.must_equal File.join(@media_dir, "/00099/0853/file-name.txt")
     end
 
     it "create a new instance with a different name" do
-      file1 = Spontaneous::Media::File.new(@content, "file name.txt")
+      file1 = file(@content, "file name.txt")
       file2 = file1.rename("another.jpg")
       file2.owner.must_equal file1.owner
       file2.mimetype.must_equal "image/jpeg"
@@ -136,7 +145,7 @@ describe "Media" do
       existing_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
       refute ::File.exist?(file_path)
       assert ::File.exist?(existing_file)
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       file.copy(existing_file)
       assert ::File.exist?(file_path)
       file.source.must_equal existing_file
@@ -147,7 +156,7 @@ describe "Media" do
       existing_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
       refute ::File.exist?(file_path)
       assert ::File.exist?(existing_file)
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       File.open(existing_file, 'rb') do |f|
         file.copy(f)
       end
@@ -158,7 +167,7 @@ describe "Media" do
     it "provide an open method that writes files to the correct location" do
       file_path = File.join(@media_dir, "/00099/0853/file-name.txt")
       refute ::File.exist?(file_path)
-      file = Spontaneous::Media::File.new(@content, "file name.txt")
+      file = file(@content, "file name.txt")
       content_string = "Hello"
       file.open do |f|
         f.write(content_string)
@@ -179,11 +188,11 @@ describe "Media" do
         :aws_access_key_id=>"ACCESS_KEY_ID",
         :public_host => "http://media.example.com"
       }
-      cloud = Spontaneous::Storage::Cloud.new(@aws_credentials, 'media.example.com')
+      cloud = Spontaneous::Media::Store::Cloud.new(@aws_credentials, 'media.example.com')
       cloud.backend.directories.create(:key => @bucket_name)
       @site.stubs(:storage).with(anything).returns(cloud)
       @media_dir = Dir.mktmpdir
-      @storage = Spontaneous::Storage::Local.new(@media_dir, '/media')
+      @storage = Spontaneous::Media::Store::Local.new(@media_dir, '/media')
       @site.stubs(:local_storage).with(anything).returns(@storage)
       @site.stubs(:default_storage).with(anything).returns(@storage)
       @content = ::Piece.create
@@ -191,12 +200,12 @@ describe "Media" do
     end
 
     it "return an absolute path for the url" do
-      file = Spontaneous::Media::TempFile.new(@content, "file name.txt")
+      file = tempfile(@content, "file name.txt")
       file.url.must_equal "/media/tmp/00099/file-name.txt"
     end
 
     it "place files into its configured root" do
-      file = Spontaneous::Media::TempFile.new(@content, "file name.txt")
+      file = tempfile(@content, "file name.txt")
       file.path.must_equal File.join(@media_dir, "/tmp/00099/file-name.txt")
     end
 
@@ -205,7 +214,7 @@ describe "Media" do
       existing_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
       refute ::File.exist?(file_path)
       assert ::File.exist?(existing_file)
-      file = Spontaneous::Media::TempFile.new(@content, "file name.txt")
+      file = tempfile(@content, "file name.txt")
       file.copy(existing_file)
       assert ::File.exist?(file_path)
       file.source.must_equal existing_file
@@ -216,7 +225,7 @@ describe "Media" do
       existing_file = File.expand_path("../../fixtures/images/rose.jpg", __FILE__)
       refute ::File.exist?(file_path)
       assert ::File.exist?(existing_file)
-      file = Spontaneous::Media::TempFile.new(@content, "file name.txt")
+      file = tempfile(@content, "file name.txt")
       File.open(existing_file, 'rb') do |f|
         file.copy(f)
       end
@@ -227,7 +236,7 @@ describe "Media" do
     it "provide an open method that writes files to the correct location" do
       file_path = File.join(@media_dir, "/tmp/00099/file-name.txt")
       refute ::File.exist?(file_path)
-      file = Spontaneous::Media::TempFile.new(@content, "file name.txt")
+      file = tempfile(@content, "file name.txt")
       content_string = "Hello"
       file.open do |f|
         f.write(content_string)

data/test/unit/test_output_store.rb

@@ -0,0 +1,342 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+# Store.new(backend_class, options) #=> Store
+# Store#revision(revision_number)   #=> Revision
+# Store#revisions #=> [Fixnum]
+# Revision#static_template(output) #=> (String or nil)
+# Revision#dynamic_template(output, request_method = "GET") #=> (String or nil)
+# Revision#transaction #=> Transaction
+# Revision#delete
+# Transaction#write(output, template)
+# Transaction#commit
+# Transaction#rollback
+# Backend#store_static(revision, key, template)
+# Backend#store_protected(revision, key, template)
+# Backend#store_dynamic(revision, key, template)
+# Backend#load_static(revision, key) #=> String
+# Backend#load_protected(revision, key) #=> String
+# Backend#load_dynamic(revision, key) #=> String
+# Backend#delete_revision(revision)
+# Backend#revisions #=> [Fixnum]
+
+describe "Output store" do
+  start do
+    site = setup_site
+    let(:site) { site  }
+
+    class CustomPage < Page
+      add_output :xml, dynamic: true, language: 'php'
+      add_output :json
+      box :stuff
+    end
+
+    home = CustomPage.create
+    page = CustomPage.new(slug: 'one')
+    home.stuff << page
+    page.save
+    home.save
+    let(:home) { home }
+    let(:page) { page }
+  end
+
+  finish do
+    Content.delete
+    Object.send(:remove_const, :CustomPage) rescue nil
+    teardown_site
+  end
+
+  describe "File" do
+    let(:root)  { Dir.mktmpdir }
+    let(:store) { Spontaneous::Output::Store::File.new(root) }
+    let(:revision) { 100 }
+    let(:revision_path) { ::File.join(root, "00100") }
+
+
+    it "puts static files under 'static'" do
+      store.store_static(revision, "/one.html", "*template*")
+      ::File.read(::File.join(revision_path, 'static', 'one.html')).must_equal "*template*"
+    end
+
+    it "puts protected files under 'protected'" do
+      store.store_protected(revision, "/one.html", "*template*")
+      ::File.read(::File.join(revision_path, 'protected', 'one.html')).must_equal "*template*"
+    end
+
+    it "puts dynamic files under 'dynamic'" do
+      store.store_dynamic(revision, "/one.html", "*template*")
+      ::File.read(::File.join(revision_path, 'dynamic', 'one.html')).must_equal "*template*"
+    end
+
+    it "enables the retrieval of available revisions" do
+      store.store_static(1, "/one.html", "*template*")
+      store.store_protected(2, "/one.html", "*template*")
+      store.store_dynamic(3, "/one.html", "*template*")
+      store.revisions.must_equal [1, 2, 3]
+    end
+
+    it "enables the retrieval of templates" do
+      store.store_static(revision, "/one.html", "*template*")
+      store.load_static(revision, "/one.html").read.must_equal "*template*"
+    end
+
+    it "returns a File object for static templates" do
+      store.store_static(revision, "/one.html", "*template*")
+      result = store.load_static(revision, "/one.html")
+      result.must_be_instance_of ::File
+      result.to_path.must_equal ::File.join(revision_path, 'static', 'one.html')
+      result.read.must_equal "*template*"
+    end
+
+    it "returns a File object for dynamic templates" do
+      store.store_dynamic(revision, "/one.html", "*template*")
+      result = store.load_dynamic(revision, "/one.html")
+      result.must_be_instance_of ::File
+      result.to_path.must_equal ::File.join(revision_path, 'dynamic', 'one.html')
+      result.read.must_equal "*template*"
+    end
+
+    it "sets the returned template's encoding as UTF-8" do
+      store.store_static(revision, "/one.html", "«küßî»")
+      result = store.load_static(revision, "/one.html")
+      result.external_encoding.must_equal Encoding::UTF_8
+      result.read.must_equal "«küßî»"
+    end
+
+    it "returns nil when attempting to retrieve a non-existant template" do
+      store.load_static(revision, "/faile.html").must_equal nil
+    end
+
+    it "puts all written keys into a transaction if given" do
+      transaction = []
+      store.store_static(revision, "/one.html", "*template*", transaction)
+      store.store_protected(revision, "/one.html", "*template*", transaction)
+      store.store_dynamic(revision, "/one.html", "*template*", transaction)
+      transaction.length.must_equal 3
+      transaction.must_equal ["00100/static/one.html", "00100/protected/one.html", "00100/dynamic/one.html"]
+    end
+
+    it "enables registration of a revision" do
+      store.add_revision(100, ["100/one.html", "100/two.html", "100/three.html"])
+      store.add_revision(101, ["101/one.html", "101/two.html", "101/three.html"])
+      store.revisions.must_equal [100, 101]
+    end
+
+    it "allows for the deletion of a revision" do
+      store.store_static(100, "/one.html", "*template*")
+      store.store_static(100, "/another/two.html", "*template*")
+      ::File.exist?(::File.join(revision_path, 'static', 'one.html')).must_equal true
+      ::File.exist?(::File.join(revision_path, 'static', 'another/two.html')).must_equal true
+      store.delete_revision(100)
+      ::File.exist?(revision_path).must_equal false
+    end
+  end
+
+  describe "Moneta" do
+    let(:store) { Spontaneous::Output::Store::Moneta.new(:Memory) }
+    let(:r) { 100 }
+    let(:revision) { Spontaneous::Output::Store::Revision.new(r, store) }
+    let(:transaction) { revision.transaction }
+
+
+    it "allows the storage & retrieval of static templates" do
+      store.store_static(r, "/one.html", "*template*")
+      result = store.load_static(r, "/one.html")
+      result.respond_to?(:read).must_equal true
+      result.read.must_equal "*template*"
+      result.respond_to?(:path).must_equal true
+      result.respond_to?(:to_path).must_equal false
+      result.path.must_equal "/#{r}/static/one.html"
+    end
+
+    it "allows the storage & retrieval of protected templates" do
+      store.store_protected(r, "/one.html", "*template*")
+      result = store.load_protected(r, "/one.html")
+      result.respond_to?(:read).must_equal true
+      result.read.must_equal "*template*"
+      result.respond_to?(:path).must_equal true
+      result.respond_to?(:to_path).must_equal false
+      result.path.must_equal "/#{r}/protected/one.html"
+    end
+
+    it "allows the storage & retrieval of dynamic templates" do
+      store.store_dynamic(r, "/one.html", "*template*")
+      result = store.load_dynamic(r, "/one.html")
+      result.respond_to?(:read).must_equal true
+      result.read.must_equal "*template*"
+      result.respond_to?(:path).must_equal true
+      result.respond_to?(:to_path).must_equal false
+      result.path.must_equal "/#{r}/dynamic/one.html"
+    end
+
+    it "puts all written keys into a transaction if given" do
+      transaction = []
+      store.store_static(r, "/one.html", "*template*", transaction)
+      store.store_protected(r, "/two.html", "*template*", transaction)
+      store.store_dynamic(r, "/three.html", "*template*", transaction)
+      transaction.length.must_equal 3
+      transaction.must_equal ["100:static:/one.html", "100:protected:/two.html", "100:dynamic:/three.html"]
+    end
+
+    it "enables registration of a revision" do
+      store.add_revision(100, ["100:static:/one.html", "100:static:/two.html", "100:static:/three.html"])
+      store.add_revision(101, ["101:static:/one.html", "101:static:/two.html", "101:static:/three.html"])
+      store.revisions.must_equal [100, 101]
+    end
+
+    it "enables removal of a revision" do
+      keys = []
+      store.store_static(r, "/one.html", "*template*", keys)
+      store.store_protected(r, "/two.html", "*template*", keys)
+      store.store_dynamic(r, "/three.html", "*template*", keys)
+      store.add_revision(100, keys)
+      keys.each do |key|
+        store.backend.key?(key).must_equal true
+      end
+      store.add_revision(101, ["101:static:/one.html", "101:protected:/two.html", "101:dynamic:/three.html"])
+      store.revisions.must_equal [100, 101]
+      store.delete_revision(100)
+      store.revisions.must_equal [101]
+      hash = store.backend.backend
+      keys.each do |key|
+        hash.key?(key).must_equal false
+      end
+      hash.key?(store.revision_key(100)).must_equal false
+    end
+
+
+  end
+
+  describe "Transaction" do
+    let(:store) { Spontaneous::Output::Store::Moneta.new(:Memory) }
+    let(:r) { 100 }
+    let(:transaction) { Spontaneous::Output::Store::Transaction.new(r, store) }
+    let(:output_html) { page.output(:html) }
+    let(:output_xml) { page.output(:xml) }
+    let(:output_json) { page.output(:json) }
+
+    it "tracks all keys written to it" do
+      transaction.store(output_html, true, "*template*")
+      transaction.store(output_xml, false, "*template*")
+      transaction.store(output_json, false, "*template*")
+      transaction.commit
+      store.revisions.must_equal [ 100 ]
+    end
+
+    it "clears up the store after a rollback" do
+      keys = ["100:static:/one.html"]
+      transaction.store(output_html, false, "*template*")
+      keys.each do |key|
+        store.backend.key?(key).must_equal true
+      end
+      transaction.rollback
+      store.revisions.must_equal []
+      keys.each do |key|
+        store.backend.key?(key).must_equal false
+      end
+    end
+
+    it "ignores a rollback after a commit" do
+      transaction.store(output_html, true, "*template*")
+      transaction.store(output_xml, false, "*template*")
+      transaction.store(output_json, false, "*template*")
+      transaction.commit
+      transaction.rollback
+      store.revisions.must_equal [ 100 ]
+    end
+
+    it "writes to index.xxx when given the site root" do
+      store.expects(:store_static).with(r, "/index.html", "*template*", transaction)
+      transaction.store(home.output(:html), false, "*template*")
+      store.expects(:store_dynamic).with(r, "/index.xml.php", "*template*", transaction)
+      transaction.store(home.output(:xml), false, "*template*")
+    end
+
+    describe "template partitioning" do
+      it "writes dynamic templates to dynamic partition" do
+        store.expects(:store_dynamic).with(r, "/one.html.cut", "*template*", transaction)
+        transaction.store(output_html, true, "*template*")
+      end
+
+      it "writes dynamic outputs to dynamic partition" do
+        store.expects(:store_dynamic).with(r, "/one.xml.php", "*template*", transaction)
+        transaction.store(output_xml, false, "*template*")
+      end
+
+      it "writes protected templates to protected partition" do
+        page.expects(:dynamic?).returns(true)
+        store.expects(:store_protected).with(r, "/one.html", "*template*", transaction)
+        transaction.store(output_html, false, "*template*")
+      end
+
+      it "writes static templates to the static partition" do
+        store.expects(:store_static).with(r, "/one.html", "*template*", transaction)
+        transaction.store(output_html, false, "*template*")
+      end
+    end
+  end
+
+  describe "Revision" do
+    let(:r) { 100 }
+    let(:store) { Spontaneous::Output::Store::Moneta.new(:Memory) }
+    let(:revision) { Spontaneous::Output::Store::Revision.new(r, store) }
+    let(:output_html) { page.output(:html) }
+    let(:output_xml) { page.output(:xml) }
+    let(:output_json) { page.output(:json) }
+
+    before do
+      transaction = revision.transaction
+      transaction.store(output_html, false, "HTML")
+      transaction.store(output_xml, false, "XML")
+      transaction.commit
+    end
+
+    it "provides a transaction for writing" do
+      revision.transaction.must_be_instance_of Spontaneous::Output::Store::Transaction
+      revision.transaction.revision.must_equal r
+    end
+
+    it "allows for reading a static template" do
+      template = revision.static_template(output_html)
+      template.read.must_equal "HTML"
+    end
+
+    it "allows for reading a dynamic template" do
+      template = revision.dynamic_template(output_xml)
+      template.read.must_equal "XML"
+    end
+
+    it "doesn't return a dynamic template as a static one" do
+      template = revision.static_template(output_xml)
+      template.must_equal nil
+    end
+
+    it "allows for deletion of the revision" do
+      store.expects(:delete_revision).with(r)
+      revision.delete
+    end
+  end
+
+  describe "Store" do
+    let(:store) { Spontaneous::Output::Store.new(:Memory) }
+    let(:output_html) { page.output(:html) }
+    let(:output_xml) { page.output(:xml) }
+
+    before do
+      transaction = store.revision(20).transaction
+      transaction.store(output_html, false, "HTML")
+      transaction.store(output_xml, false, "XML")
+      transaction.commit
+    end
+
+    it "will provide a revision instance" do
+      store.revision(20).must_be_instance_of Spontaneous::Output::Store::Revision
+      store.revision(20).revision.must_equal 20
+    end
+
+    it "can provide a list of revisions" do
+      store.revisions.must_equal [20]
+    end
+  end
+end