sitemap_generator_ftbpro 5.0.4

data/spec/files/sitemap.groups.rb

@@ -0,0 +1,49 @@
+SitemapGenerator::Sitemap.default_host = "http://www.example.com"
+
+SitemapGenerator::Sitemap.create(
+    :include_root => true, :include_index => true,
+    :filename => :new_sitemaps, :sitemaps_path => 'fr/') do
+
+  add('/one', :priority => 0.7, :changefreq => 'daily')
+
+  # Test a new location and filename and sitemaps host
+  group(:sitemaps_path => 'en/', :filename => :xxx,
+      :sitemaps_host => "http://newhost.com") do
+
+    add '/two'
+    add '/three'
+  end
+
+  # Test a simple namer.
+  group(:namer => SitemapGenerator::SimpleNamer.new(:abc, :start => 4, :zero => 3)) do
+    add '/four'
+    add '/five'
+    add '/six'
+  end
+
+  # Test a simple namer
+  group(:namer => SitemapGenerator::SimpleNamer.new(:def)) do
+    add '/four'
+    add '/five'
+    add '/six'
+  end
+
+  add '/seven'
+
+  # This should be in a file of its own.
+  # Not technically valid to have a link with a different host, but people like
+  # to do strange things sometimes.
+  group(:sitemaps_host => "http://exceptional.com") do
+    add '/eight'
+    add '/nine'
+  end
+
+  add '/ten'
+
+  # This should have no effect.  Already added default links.
+  group(:include_root => true, :include_index => true) {}
+
+  # Not technically valid to have a link with a different host, but people like
+  # to do strange things sometimes
+  add "/merchant_path", :host => "https://www.merchanthost.com"
+end

data/spec/sitemap_generator/adapters/s3_adapter_spec.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+# Don't run this test as part of the unit testing suite as we don't want
+# Fog to be a dependency of SitemapGenerator core.  This is an integration
+# test.  Unfortunately it doesn't really test much, so its usefullness is
+# questionable.
+describe 'SitemapGenerator::S3Adapter', :integration => true do
+
+  let(:location) { SitemapGenerator::SitemapLocation.new(:namer => SitemapGenerator::SitemapNamer.new(:sitemap), :public_path => 'tmp/', :sitemaps_path => 'test/', :host => 'http://example.com/') }
+  let(:directory) { stub(:files => stub(:create)) }
+  let(:directories) { stub(:directories => stub(:new => directory)) }
+
+  before do
+    SitemapGenerator::S3Adapter # eager load
+    Fog::Storage.stubs(:new => directories)
+  end
+
+  it 'should create the file in S3 with a single operation' do
+    subject.write(location, 'payload')
+  end
+end

data/spec/sitemap_generator/alternate_sitemap_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe "SitemapGenerator" do
+  it "should not include media element unless provided" do
+    xml_fragment = SitemapGenerator::Builder::SitemapUrl.new('link_with_alternates.html',
+      :host => 'http://www.example.com',
+      :alternates => [
+        {
+          :lang => 'de',
+          :href => 'http://www.example.de/link_with_alternate.html'
+        }
+      ]
+    ).to_xml
+
+    doc = Nokogiri::XML.parse("<root xmlns='http://www.sitemaps.org/schemas/sitemap/0.9' xmlns:xhtml='http://www.w3.org/1999/xhtml'>#{xml_fragment}</root>")
+    url = doc.css('url')
+    url.should_not be_nil
+    url.css('loc').text.should == 'http://www.example.com/link_with_alternates.html'
+
+    alternate = url.at_xpath('xhtml:link')
+    alternate.should_not be_nil
+    alternate.attribute('rel').value.should == 'alternate'
+    alternate.attribute('hreflang').value.should == 'de'
+    alternate.attribute('media').should be_nil
+  end
+
+  it "should add alternate links to sitemap" do
+    xml_fragment = SitemapGenerator::Builder::SitemapUrl.new('link_with_alternates.html',
+      :host => 'http://www.example.com',
+      :alternates => [
+        {
+          :lang => 'de',
+          :href => 'http://www.example.de/link_with_alternate.html',
+          :media => 'only screen and (max-width: 640px)'
+        }
+      ]
+    ).to_xml
+
+    doc = Nokogiri::XML.parse("<root xmlns='http://www.sitemaps.org/schemas/sitemap/0.9' xmlns:xhtml='http://www.w3.org/1999/xhtml'>#{xml_fragment}</root>")
+    url = doc.css('url')
+    url.should_not be_nil
+    url.css('loc').text.should == 'http://www.example.com/link_with_alternates.html'
+
+    alternate = url.at_xpath('xhtml:link')
+    alternate.should_not be_nil
+    alternate.attribute('rel').value.should == 'alternate'
+    alternate.attribute('hreflang').value.should == 'de'
+    alternate.attribute('href').value.should == 'http://www.example.de/link_with_alternate.html'
+    alternate.attribute('media').value.should == 'only screen and (max-width: 640px)'
+  end
+
+  it "should add alternate links to sitemap with rel nofollow" do
+    xml_fragment = SitemapGenerator::Builder::SitemapUrl.new('link_with_alternates.html',
+      :host => 'http://www.example.com',
+      :alternates => [
+        {
+          :lang => 'de',
+          :href => 'http://www.example.de/link_with_alternate.html',
+          :nofollow => true,
+          :media => 'only screen and (max-width: 640px)'
+        }
+      ]
+    ).to_xml
+
+    doc = Nokogiri::XML.parse("<root xmlns='http://www.sitemaps.org/schemas/sitemap/0.9' xmlns:xhtml='http://www.w3.org/1999/xhtml'>#{xml_fragment}</root>")
+    url = doc.css('url')
+    url.should_not be_nil
+    url.css('loc').text.should == 'http://www.example.com/link_with_alternates.html'
+
+    alternate = url.at_xpath('xhtml:link')
+    alternate.should_not be_nil
+    alternate.attribute('rel').value.should == 'alternate nofollow'
+    alternate.attribute('hreflang').value.should == 'de'
+    alternate.attribute('href').value.should == 'http://www.example.de/link_with_alternate.html'
+    alternate.attribute('media').value.should == 'only screen and (max-width: 640px)'
+  end
+
+end
+

data/spec/sitemap_generator/application_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe SitemapGenerator::Application do
+  before :all do
+    SitemapGenerator::Utilities.with_warnings(nil) do
+      Object.const_set(:Rails, Object.new)
+    end
+  end
+
+  after :all do
+    SitemapGenerator::Utilities.with_warnings(nil) do
+      Object.const_set(:Rails, nil)
+    end
+  end
+
+  before :each do
+    @app = SitemapGenerator::Application.new
+  end
+
+  describe "rails3?" do
+    tests = {
+      :nil => false,
+      '2.3.11' => false,
+      '3.0.1' => true,
+      '3.0.11' => true
+    }
+
+    it "should identify the rails version correctly" do
+      tests.each do |version, result|
+        Rails.expects(:version).returns(version)
+        @app.rails3?.should == result
+      end
+    end
+  end
+
+  describe "with Rails" do
+    before :each do
+      @root = '/test'
+      Rails.expects(:root).returns(@root).at_least_once
+    end
+
+    it "should use the Rails.root" do
+      @app.root.should be_a(Pathname)
+      @app.root.to_s.should == @root
+      (@app.root + 'public/').to_s.should == File.join(@root, 'public/')
+    end
+  end
+
+  describe "with no Rails" do
+    before :each do
+      @rails = Rails
+      Object.send(:remove_const, :Rails)
+    end
+
+    after :each do
+      Object::Rails = @rails
+    end
+
+    it "should not be Rails" do
+      @app.rails?.should be_false
+    end
+
+    it "should use the current working directory" do
+      @app.root.should be_a(Pathname)
+      @app.root.to_s.should == Dir.getwd
+      (@app.root + 'public/').to_s.should == File.join(Dir.getwd, 'public/')
+    end
+  end
+end

data/spec/sitemap_generator/builder/sitemap_file_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe 'SitemapGenerator::Builder::SitemapFile' do
+  let(:location) { SitemapGenerator::SitemapLocation.new(:namer => SitemapGenerator::SimpleNamer.new(:sitemap, :start => 2, :zero => 1), :public_path => 'tmp/', :sitemaps_path => 'test/', :host => 'http://example.com/') }
+  let(:sitemap)  { SitemapGenerator::Builder::SitemapFile.new(location) }
+
+  it "should have a default namer" do
+    sitemap = SitemapGenerator::Builder::SitemapFile.new
+    sitemap.location.filename.should == 'sitemap1.xml.gz'
+  end
+
+  it "should return the name of the sitemap file" do
+    sitemap.location.filename.should == 'sitemap1.xml.gz'
+  end
+
+  it "should return the URL" do
+    sitemap.location.url.should == 'http://example.com/test/sitemap1.xml.gz'
+  end
+
+  it "should return the path" do
+    sitemap.location.path.should == File.expand_path('tmp/test/sitemap1.xml.gz')
+  end
+
+  it "should be empty" do
+    sitemap.empty?.should be_true
+    sitemap.link_count.should == 0
+  end
+
+  it "should not be finalized" do
+    sitemap.finalized?.should be_false
+  end
+
+  it "should raise if no default host is set" do
+    lambda { SitemapGenerator::Builder::SitemapFile.new.location.url }.should raise_error(SitemapGenerator::SitemapError)
+  end
+
+  describe "lastmod" do
+    it "should be the file last modified time" do
+      lastmod = (Time.now - 1209600)
+      sitemap.location.reserve_name
+      File.expects(:mtime).with(sitemap.location.path).returns(lastmod)
+      sitemap.lastmod.should == lastmod
+    end
+
+    it "should be nil if the location has not reserved a name" do
+      File.expects(:mtime).never
+      sitemap.lastmod.should be_nil
+    end
+
+    it "should be nil if location has reserved a name and the file DNE" do
+      sitemap.location.reserve_name
+      File.expects(:mtime).raises(Errno::ENOENT)
+      sitemap.lastmod.should be_nil
+    end
+  end
+
+  describe "new" do
+    let(:original_sitemap) { sitemap }
+    let(:new_sitemap)      { sitemap.new }
+
+    before :each do
+      original_sitemap
+      new_sitemap
+    end
+
+    it "should inherit the same options" do
+      # The name is the same because the original sitemap was not finalized
+      new_sitemap.location.url.should == 'http://example.com/test/sitemap1.xml.gz'
+      new_sitemap.location.path.should == File.expand_path('tmp/test/sitemap1.xml.gz')
+    end
+
+    it "should not share the same location instance" do
+      new_sitemap.location.should_not be(original_sitemap.location)
+    end
+
+    it "should inherit the same namer instance" do
+      new_sitemap.location.namer.should == original_sitemap.location.namer
+    end
+  end
+
+  describe "reserve_name" do
+    it "should reserve the name from the location" do
+      sitemap.reserved_name?.should be_false
+      sitemap.location.expects(:reserve_name).returns('name')
+      sitemap.reserve_name
+      sitemap.reserved_name?.should be_true
+      sitemap.instance_variable_get(:@reserved_name).should == 'name'
+    end
+
+    it "should be safe to call multiple times" do
+      sitemap.location.expects(:reserve_name).returns('name').once
+      sitemap.reserve_name
+      sitemap.reserve_name
+    end
+  end
+
+  describe "add" do
+    it "should use the host provided" do
+      url = SitemapGenerator::Builder::SitemapUrl.new('/one', :host => 'http://newhost.com/')
+      SitemapGenerator::Builder::SitemapUrl.expects(:new).with('/one', :host => 'http://newhost.com').returns(url)
+      sitemap.add '/one', :host => 'http://newhost.com'
+    end
+
+    it "should use the host from the location" do
+      url = SitemapGenerator::Builder::SitemapUrl.new('/one', :host => 'http://example.com/')
+      SitemapGenerator::Builder::SitemapUrl.expects(:new).with('/one', :host => 'http://example.com/').returns(url)
+      sitemap.add '/one'
+    end
+  end
+end

data/spec/sitemap_generator/builder/sitemap_index_file_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe 'SitemapGenerator::Builder::SitemapIndexFile' do
+  let(:location) { SitemapGenerator::SitemapLocation.new(:filename => 'sitemap.xml.gz', :public_path => '/public/', :host => 'http://example.com/') }
+  let(:index)    { SitemapGenerator::Builder::SitemapIndexFile.new(location) }
+
+  before :each do
+    index.location[:sitemaps_path] = 'test/'
+  end
+
+  it "should return the URL" do
+    index.location.url.should == 'http://example.com/test/sitemap.xml.gz'
+  end
+
+  it "should return the path" do
+    index.location.path.should == '/public/test/sitemap.xml.gz'
+  end
+
+  it "should be empty" do
+    index.empty?.should be_true
+    index.link_count.should == 0
+  end
+
+  it "should not have a last modification data" do
+    index.lastmod.should be_nil
+  end
+
+  it "should not be finalized" do
+    index.finalized?.should be_false
+  end
+
+  it "filename should be set" do
+    index.location.filename.should == 'sitemap.xml.gz'
+  end
+
+  it "should have a default namer" do
+    index = SitemapGenerator::Builder::SitemapIndexFile.new
+    index.location.filename.should == 'sitemap.xml.gz'
+  end
+
+  describe "link_count" do
+    it "should return the link count" do
+      index.instance_variable_set(:@link_count, 10)
+      index.link_count.should == 10
+    end
+  end
+
+  describe "create_index?" do
+    it "should return false" do
+      index.location[:create_index] = false
+      index.create_index?.should be_false
+
+      index.instance_variable_set(:@link_count, 10)
+      index.create_index?.should be_false
+    end
+
+    it "should return true" do
+      index.location[:create_index] = true
+      index.create_index?.should be_true
+
+      index.instance_variable_set(:@link_count, 1)
+      index.create_index?.should be_true
+    end
+
+    it "when :auto, should be true if more than one link" do
+      index.instance_variable_set(:@link_count, 1)
+      index.location[:create_index] = :auto
+      index.create_index?.should be_false
+
+      index.instance_variable_set(:@link_count, 2)
+      index.create_index?.should be_true
+    end
+  end
+
+  describe "add" do
+    it "should use the host provided" do
+      url = SitemapGenerator::Builder::SitemapIndexUrl.new('/one', :host => 'http://newhost.com/')
+      SitemapGenerator::Builder::SitemapIndexUrl.expects(:new).with('/one', :host => 'http://newhost.com').returns(url)
+      index.add '/one', :host => 'http://newhost.com'
+    end
+
+    it "should use the host from the location" do
+      url = SitemapGenerator::Builder::SitemapIndexUrl.new('/one', :host => 'http://example.com/')
+      SitemapGenerator::Builder::SitemapIndexUrl.expects(:new).with('/one', :host => 'http://example.com/').returns(url)
+      index.add '/one'
+    end
+
+    describe "when adding manually" do
+      it "should reserve a name" do
+        index.expects(:reserve_name)
+        index.add '/link'
+      end
+
+      it "should create index" do
+        index.create_index?.should be_false
+        index.add '/one'
+        index.create_index?.should be_true
+      end
+    end
+  end
+
+  describe "index_url" do
+    it "when not creating an index, should be the first sitemap url" do
+      index.instance_variable_set(:@create_index, false)
+      index.instance_variable_set(:@first_sitemap_url, 'http://test.com/index.xml')
+      index.create_index?.should be_false
+      index.index_url.should == 'http://test.com/index.xml'
+    end
+
+    it "if there's no first sitemap url, should default to the index location url" do
+      index.instance_variable_set(:@create_index, false)
+      index.instance_variable_set(:@first_sitemap_url, nil)
+      index.create_index?.should be_false
+      index.index_url.should == index.location.url
+      index.index_url.should == 'http://example.com/test/sitemap.xml.gz'
+    end
+
+    it "when creating an index, should be the index location url" do
+      index.instance_variable_set(:@create_index, true)
+      index.index_url.should == index.location.url
+      index.index_url.should == 'http://example.com/test/sitemap.xml.gz'
+    end
+  end
+end

data/spec/sitemap_generator/builder/sitemap_index_url_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe SitemapGenerator::Builder::SitemapIndexUrl do
+  let(:index) {
+    SitemapGenerator::Builder::SitemapIndexFile.new(
+      :sitemaps_path => 'sitemaps/',
+      :host => 'http://test.com',
+      :filename => 'sitemap_index.xml.gz'
+    )
+  }
+  let(:url)  { SitemapGenerator::Builder::SitemapUrl.new(index) }
+
+  it "should return the correct url" do
+    url[:loc].should == 'http://test.com/sitemaps/sitemap_index.xml.gz'
+  end
+
+  it "should use the host from the index" do
+    host = 'http://myexample.com'
+    index.location.expects(:host).returns(host)
+    url[:host].should == host
+  end
+
+  it "should use the public path for the link" do
+    path = '/path'
+    index.location.expects(:path_in_public).returns(path)
+    url[:loc].should == 'http://test.com/path'
+  end
+end

data/spec/sitemap_generator/builder/sitemap_url_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe SitemapGenerator::Builder::SitemapUrl do
+  let(:loc) {
+    SitemapGenerator::SitemapLocation.new(
+      :sitemaps_path => 'sitemaps/',
+      :public_path => '/public',
+      :host => 'http://test.com',
+      :namer => SitemapGenerator::SimpleNamer.new(:sitemap)
+    )}
+  let(:sitemap_file) { SitemapGenerator::Builder::SitemapFile.new(loc) }
+
+  def new_url(*args)
+    if args.empty?
+      args = ['/home', { :host => 'http://example.com' }]
+    end
+    SitemapGenerator::Builder::SitemapUrl.new(*args)
+  end
+
+  it "should build urls for sitemap files" do
+    url = SitemapGenerator::Builder::SitemapUrl.new(sitemap_file)
+    url[:loc].should == 'http://test.com/sitemaps/sitemap.xml.gz'
+  end
+
+  it "lastmod should default to the last modified date for sitemap files" do
+    lastmod = (Time.now - 1209600)
+    sitemap_file.expects(:lastmod).returns(lastmod)
+    url = SitemapGenerator::Builder::SitemapUrl.new(sitemap_file)
+    url[:lastmod].should == lastmod
+  end
+
+  it "should support subdirectory routing" do
+    url = SitemapGenerator::Builder::SitemapUrl.new('/profile', :host => 'http://example.com/subdir/')
+    url[:loc].should == 'http://example.com/subdir/profile'
+    url = SitemapGenerator::Builder::SitemapUrl.new('profile', :host => 'http://example.com/subdir/')
+    url[:loc].should == 'http://example.com/subdir/profile'
+    url = SitemapGenerator::Builder::SitemapUrl.new('/deep/profile/', :host => 'http://example.com/subdir/')
+    url[:loc].should == 'http://example.com/subdir/deep/profile/'
+    url = SitemapGenerator::Builder::SitemapUrl.new('/deep/profile', :host => 'http://example.com/subdir')
+    url[:loc].should == 'http://example.com/subdir/deep/profile'
+    url = SitemapGenerator::Builder::SitemapUrl.new('deep/profile', :host => 'http://example.com/subdir')
+    url[:loc].should == 'http://example.com/subdir/deep/profile'
+    url = SitemapGenerator::Builder::SitemapUrl.new('deep/profile/', :host => 'http://example.com/subdir/')
+    url[:loc].should == 'http://example.com/subdir/deep/profile/'
+    url = SitemapGenerator::Builder::SitemapUrl.new('/', :host => 'http://example.com/subdir/')
+    url[:loc].should == 'http://example.com/subdir/'
+  end
+
+  it "should not fail on a nil path segment" do
+    lambda do
+      SitemapGenerator::Builder::SitemapUrl.new(nil, :host => 'http://example.com')[:loc].should == 'http://example.com'
+    end.should_not raise_error
+  end
+
+  it "should support a :videos option" do
+    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :videos => [1,2,3])
+    loc[:videos].should == [1,2,3]
+  end
+
+  it "should support a singular :video option" do
+    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :video => 1)
+    loc[:videos].should == [1]
+  end
+
+  it "should support an array :video option" do
+    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :video => [1,2], :videos => [3,4])
+    loc[:videos].should == [3,4,1,2]
+  end
+
+  it "should support a :alternates option" do
+    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :alternates => [1,2,3])
+    loc[:alternates].should == [1,2,3]
+  end
+
+  it "should support a singular :alternate option" do
+    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :alternate => 1)
+    loc[:alternates].should == [1]
+  end
+
+  it "should support an array :alternate option" do
+    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :alternate => [1,2], :alternates => [3,4])
+    loc[:alternates].should == [3,4,1,2]
+  end
+
+  it "should not fail if invalid characters are used in the URL" do
+    special = ':$&+,;:=?@'
+    url = SitemapGenerator::Builder::SitemapUrl.new("/#{special}", :host => "http://example.com/#{special}/")
+    url[:loc].should == "http://example.com/#{special}/#{special}"
+  end
+
+  describe "w3c_date" do
+    it "should convert dates and times to W3C format" do
+      url = new_url
+      url.send(:w3c_date, Date.new(0)).should == '0000-01-01'
+      url.send(:w3c_date, Time.at(0).utc).should == '1970-01-01T00:00:00+00:00'
+      url.send(:w3c_date, DateTime.new(0)).should == '0000-01-01T00:00:00+00:00'
+    end
+
+    it "should return strings unmodified" do
+      new_url.send(:w3c_date, '2010-01-01').should == '2010-01-01'
+    end
+
+    it "should try to convert to utc" do
+      time = Time.at(0)
+      time.expects(:respond_to?).times(2).returns(false, true) # iso8601, utc
+      new_url.send(:w3c_date, time).should == '1970-01-01T00:00:00+00:00'
+    end
+
+    it "should include timezone for objects which do not respond to iso8601 or utc" do
+      time = Time.at(0)
+      time.expects(:respond_to?).times(2).returns(false, false) # iso8601, utc
+      time.expects(:strftime).times(2).returns('+0800', '1970-01-01T00:00:00')
+      new_url.send(:w3c_date, time).should == '1970-01-01T00:00:00+08:00'
+    end
+
+    it "should support integers" do
+      new_url.send(:w3c_date, Time.at(0).to_i).should == '1970-01-01T00:00:00+00:00'
+    end
+  end
+
+  describe "yes_or_no" do
+    it "should recognize truthy values" do
+      new_url.send(:yes_or_no, 1).should == 'yes'
+      new_url.send(:yes_or_no, 0).should == 'yes'
+      new_url.send(:yes_or_no, 'yes').should == 'yes'
+      new_url.send(:yes_or_no, 'Yes').should == 'yes'
+      new_url.send(:yes_or_no, 'YES').should == 'yes'
+      new_url.send(:yes_or_no, true).should == 'yes'
+      new_url.send(:yes_or_no, Object.new).should == 'yes'
+    end
+
+    it "should recognize falsy values" do
+      new_url.send(:yes_or_no, nil).should   == 'no'
+      new_url.send(:yes_or_no, 'no').should  == 'no'
+      new_url.send(:yes_or_no, 'No').should  == 'no'
+      new_url.send(:yes_or_no, 'NO').should  == 'no'
+      new_url.send(:yes_or_no, false).should == 'no'
+    end
+
+    it "should raise on unrecognized strings" do
+      lambda { new_url.send(:yes_or_no, 'dunno')  }.should raise_error(ArgumentError)
+      lambda { new_url.send(:yes_or_no, 'yessir') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "yes_or_no_with_default" do
+    it "should use the default if the value is nil" do
+      url = new_url
+      url.expects(:yes_or_no).with(true).returns('surely')
+      url.send(:yes_or_no_with_default, nil, true).should == 'surely'
+    end
+
+    it "should use the value if it is not nil" do
+      url = new_url
+      url.expects(:yes_or_no).with('surely').returns('absolutely')
+      url.send(:yes_or_no_with_default, 'surely', true).should == 'absolutely'
+    end
+  end
+
+  describe "format_float" do
+    it "should not modify if a string" do
+      new_url.send(:format_float, '0.4').should == '0.4'
+    end
+
+    it "should round to one decimal place" do
+      url = new_url
+      url.send(:format_float, 0.499999).should == '0.5'
+      url.send(:format_float, 3.444444).should == '3.4'
+    end
+  end
+
+  describe "expires" do
+    let(:url)  { SitemapGenerator::Builder::SitemapUrl.new('/path', :host => 'http://example.com', :expires => time) }
+    let(:time) { Time.at(0).utc }
+
+    it "should include the option" do
+      url[:expires].should == time
+    end
+
+    it "should format it and include it in the XML" do
+      xml = url.to_xml
+      doc = Nokogiri::XML("<root xmlns='http://www.sitemaps.org/schemas/sitemap/0.9' xmlns:xhtml='http://www.w3.org/1999/xhtml'>#{xml}</root>")
+      doc.css('url expires').text.should == url.send(:w3c_date, time)
+    end
+  end
+end