ftbpro_sitemap_generator 5.0.8

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

data/spec/sitemap_generator/core_ext/bigdecimal_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'bigdecimal'
+
+describe SitemapGenerator::BigDecimal do
+  describe "to_yaml" do
+    it "should serialize correctly" do
+      SitemapGenerator::BigDecimal.new('100000.30020320320000000000000000000000000000001').to_yaml.should =~ /^--- 100000\.30020320320000000000000000000000000000001\n/
+      SitemapGenerator::BigDecimal.new('Infinity').to_yaml.should =~ /^--- \.Inf\n/
+      SitemapGenerator::BigDecimal.new('NaN').to_yaml.should =~ /^--- \.NaN\n/
+      SitemapGenerator::BigDecimal.new('-Infinity').to_yaml.should =~ /^--- -\.Inf\n/
+    end
+  end
+
+  describe "to_d" do
+    it "should convert correctly" do
+      bd = SitemapGenerator::BigDecimal.new '10'
+      bd.to_d.should == bd
+    end
+  end
+end

data/spec/sitemap_generator/core_ext/numeric_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe SitemapGenerator::Numeric do
+  def numeric(size)
+    SitemapGenerator::Numeric.new(size)
+  end
+
+  describe "bytes" do
+    it "should define equality of different units" do
+      relationships = {
+        numeric(  1024).bytes     => numeric(  1).kilobyte,
+        numeric(  1024).kilobytes => numeric(  1).megabyte,
+        numeric(3584.0).kilobytes => numeric(3.5).megabytes,
+        numeric(3584.0).megabytes => numeric(3.5).gigabytes,
+        numeric(1).kilobyte ** 4  => numeric(  1).terabyte,
+        numeric(1024).kilobytes + numeric(2).megabytes =>   numeric(3).megabytes,
+        numeric(             2).gigabytes / 4 => numeric(512).megabytes,
+        numeric(256).megabytes * 20 +numeric( 5).gigabytes => numeric(10).gigabytes,
+        numeric(1).kilobyte ** 5 => numeric(1).petabyte,
+        numeric(1).kilobyte ** 6 => numeric(1).exabyte
+      }
+
+      relationships.each do |left, right|
+        left.should == right
+      end
+    end
+
+    it "should represent units as bytes" do
+      numeric(3).megabytes.should == 3145728
+      numeric(3).megabyte .should == 3145728
+      numeric(3).kilobytes.should == 3072
+      numeric(3).kilobyte .should == 3072
+      numeric(3).gigabytes.should == 3221225472
+      numeric(3).gigabyte .should == 3221225472
+      numeric(3).terabytes.should == 3298534883328
+      numeric(3).terabyte .should == 3298534883328
+      numeric(3).petabytes.should == 3377699720527872
+      numeric(3).petabyte .should == 3377699720527872
+      numeric(3).exabytes .should == 3458764513820540928
+      numeric(3).exabyte  .should == 3458764513820540928
+    end
+  end
+end

data/spec/sitemap_generator/file_adaptor_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "SitemapGenerator::FileAdapter" do
+  let(:location) { SitemapGenerator::SitemapLocation.new }
+  let(:adapter)  { SitemapGenerator::FileAdapter.new }
+
+  describe "write" do
+    it "should gzip contents if filename ends in .gz" do
+      adapter.expects(:gzip).once
+      location.stubs(:filename).returns('sitemap.xml.gz')
+      adapter.write(location, 'data')
+    end
+
+    it "should not gzip contents if filename does not end in .gz" do
+      adapter.expects(:plain).once
+      location.stubs(:filename).returns('sitemap.xml')
+      adapter.write(location, 'data')
+    end
+  end
+end

data/spec/sitemap_generator/geo_sitemap_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "SitemapGenerator" do
+
+  it "should add the geo sitemap element" do
+    loc = 'http://www.example.com/geo_page.kml'
+    format = 'kml'
+
+    geo_xml_fragment = SitemapGenerator::Builder::SitemapUrl.new('geo_page.kml',
+      :host => 'http://www.example.com',
+      :geo => {
+        :format => format
+      }
+    ).to_xml
+
+    # Check that the options were parsed correctly
+    doc = Nokogiri::XML.parse("<root xmlns:geo='#{SitemapGenerator::SCHEMAS['geo']}'>#{geo_xml_fragment}</root>")
+    url = doc.at_xpath("//url")
+    url.should_not be_nil
+    url.at_xpath("loc").text.should == loc
+
+    geo = url.at_xpath("geo:geo")
+    geo.should_not be_nil
+    geo.at_xpath("geo:format").text.should == format
+
+    # Google's documentation and published schema don't match some valid elements may
+    # not validate.
+    xml_fragment_should_validate_against_schema(geo, 'sitemap-geo', 'xmlns:geo' => SitemapGenerator::SCHEMAS['geo'])
+  end
+end

data/spec/sitemap_generator/helpers/number_helper_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require 'sitemap_generator/helpers/number_helper'
+
+def kilobytes(number)
+  number * 1024
+end
+
+def megabytes(number)
+  kilobytes(number) * 1024
+end
+
+def gigabytes(number)
+  megabytes(number) * 1024
+end
+
+def terabytes(number)
+  gigabytes(number) * 1024
+end
+
+describe SitemapGenerator::Helpers::NumberHelper do
+  include SitemapGenerator::Helpers::NumberHelper
+
+  it "should number_with_delimiter" do
+    number_with_delimiter(12345678).should == "12,345,678"
+    number_with_delimiter(0).should == "0"
+    number_with_delimiter(123).should == "123"
+    number_with_delimiter(123456).should == "123,456"
+    number_with_delimiter(123456.78).should == "123,456.78"
+    number_with_delimiter(123456.789).should == "123,456.789"
+    number_with_delimiter(123456.78901).should == "123,456.78901"
+    number_with_delimiter(123456789.78901).should == "123,456,789.78901"
+    number_with_delimiter(0.78901).should == "0.78901"
+    number_with_delimiter("123456.78").should == "123,456.78"
+  end
+
+  it "should number_with_delimiter_with_options_hash" do
+    number_with_delimiter(12345678, :delimiter => ' ').should == '12 345 678'
+    number_with_delimiter(12345678.05, :separator => '-').should == '12,345,678-05'
+    number_with_delimiter(12345678.05, :separator => ',', :delimiter => '.').should == '12.345.678,05'
+    number_with_delimiter(12345678.05, :delimiter => '.', :separator => ',').should == '12.345.678,05'
+  end
+
+  it "should number_with_precision" do
+    number_with_precision(-111.2346).should == "-111.235"
+    number_with_precision(111.2346).should == "111.235"
+    number_with_precision(31.825, :precision => 2).should == "31.83"
+    number_with_precision(111.2346, :precision => 2).should == "111.23"
+    number_with_precision(111, :precision => 2).should == "111.00"
+    number_with_precision("111.2346").should == "111.235"
+    number_with_precision("31.825", :precision => 2).should == "31.83"
+    number_with_precision((32.6751 * 100.00), :precision => 0).should == "3268"
+    number_with_precision(111.50, :precision => 0).should == "112"
+    number_with_precision(1234567891.50, :precision => 0).should == "1234567892"
+    number_with_precision(0, :precision => 0).should == "0"
+    number_with_precision(0.001, :precision => 5).should == "0.00100"
+    number_with_precision(0.00111, :precision => 3).should == "0.001"
+    # Odd difference between Ruby versions
+    if RUBY_VERSION < '1.9.3'
+      number_with_precision(9.995, :precision => 2).should == "9.99"
+    else
+      number_with_precision(9.995, :precision => 2).should == "10.00"
+    end
+    number_with_precision(10.995, :precision => 2).should == "11.00"
+  end
+
+  it "should number_with_precision_with_custom_delimiter_and_separator" do
+    number_with_precision(31.825, :precision => 2, :separator => ',').should == '31,83'
+    number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.').should == '1.231,83'
+  end
+
+  it "should number_with_precision_with_significant_digits" do
+    number_with_precision(123987, :precision => 3, :significant => true).should == "124000"
+    number_with_precision(123987876, :precision => 2, :significant => true ).should == "120000000"
+    number_with_precision("43523", :precision => 1, :significant => true ).should == "40000"
+    number_with_precision(9775, :precision => 4, :significant => true ).should == "9775"
+    number_with_precision(5.3923, :precision => 2, :significant => true ).should == "5.4"
+    number_with_precision(5.3923, :precision => 1, :significant => true ).should == "5"
+    number_with_precision(1.232, :precision => 1, :significant => true ).should == "1"
+    number_with_precision(7, :precision => 1, :significant => true ).should == "7"
+    number_with_precision(1, :precision => 1, :significant => true ).should == "1"
+    number_with_precision(52.7923, :precision => 2, :significant => true ).should == "53"
+    number_with_precision(9775, :precision => 6, :significant => true ).should == "9775.00"
+    number_with_precision(5.3929, :precision => 7, :significant => true ).should == "5.392900"
+    number_with_precision(0, :precision => 2, :significant => true ).should == "0.0"
+    number_with_precision(0, :precision => 1, :significant => true ).should == "0"
+    number_with_precision(0.0001, :precision => 1, :significant => true ).should == "0.0001"
+    number_with_precision(0.0001, :precision => 3, :significant => true ).should == "0.000100"
+    number_with_precision(0.0001111, :precision => 1, :significant => true ).should == "0.0001"
+    number_with_precision(9.995, :precision => 3, :significant => true).should == "10.0"
+    number_with_precision(9.994, :precision => 3, :significant => true).should == "9.99"
+    number_with_precision(10.995, :precision => 3, :significant => true).should == "11.0"
+  end
+
+  it "should number_with_precision_with_strip_insignificant_zeros" do
+    number_with_precision(9775.43, :precision => 4, :strip_insignificant_zeros => true ).should == "9775.43"
+    number_with_precision(9775.2, :precision => 6, :significant => true, :strip_insignificant_zeros => true ).should == "9775.2"
+    number_with_precision(0, :precision => 6, :significant => true, :strip_insignificant_zeros => true ).should == "0"
+  end
+
+  it "should number_with_precision_with_significant_true_and_zero_precision" do
+    # Zero precision with significant is a mistake (would always return zero),
+    # so we treat it as if significant was false (increases backwards compatibily for number_to_human_size)
+    number_with_precision(123.987, :precision => 0, :significant => true).should == "124"
+    number_with_precision(12, :precision => 0, :significant => true ).should == "12"
+    number_with_precision("12.3", :precision => 0, :significant => true ).should == "12"
+  end
+
+  it "should number_to_human_size" do
+    number_to_human_size(0).should == '0 Bytes'
+    number_to_human_size(1).should == '1 Byte'
+    number_to_human_size(3.14159265).should == '3 Bytes'
+    number_to_human_size(123.0).should == '123 Bytes'
+    number_to_human_size(123).should == '123 Bytes'
+    number_to_human_size(1234).should == '1.21 KB'
+    number_to_human_size(12345).should == '12.1 KB'
+    number_to_human_size(1234567).should == '1.18 MB'
+    number_to_human_size(1234567890).should == '1.15 GB'
+    number_to_human_size(1234567890123).should == '1.12 TB'
+    number_to_human_size(terabytes(1026)).should == '1030 TB'
+    number_to_human_size(kilobytes(444)).should == '444 KB'
+    number_to_human_size(megabytes(1023)).should == '1020 MB'
+    number_to_human_size(terabytes(3)).should == '3 TB'
+    number_to_human_size(1234567, :precision => 2).should == '1.2 MB'
+    number_to_human_size(3.14159265, :precision => 4).should == '3 Bytes'
+    number_to_human_size('123').should == '123 Bytes'
+    number_to_human_size(kilobytes(1.0123), :precision => 2).should == '1 KB'
+    number_to_human_size(kilobytes(1.0100), :precision => 4).should == '1.01 KB'
+    number_to_human_size(kilobytes(10.000), :precision => 4).should == '10 KB'
+    number_to_human_size(1.1).should == '1 Byte'
+    number_to_human_size(10).should == '10 Bytes'
+  end
+
+  it "should number_to_human_size_with_options_hash" do
+    number_to_human_size(1234567, :precision => 2).should == '1.2 MB'
+    number_to_human_size(3.14159265, :precision => 4).should == '3 Bytes'
+    number_to_human_size(kilobytes(1.0123), :precision => 2).should == '1 KB'
+    number_to_human_size(kilobytes(1.0100), :precision => 4).should == '1.01 KB'
+    number_to_human_size(kilobytes(10.000), :precision => 4).should == '10 KB'
+    number_to_human_size(1234567890123, :precision => 1).should == '1 TB'
+    number_to_human_size(524288000, :precision=>3).should == '500 MB'
+    number_to_human_size(9961472, :precision=>0).should == '10 MB'
+    number_to_human_size(41010, :precision => 1).should == '40 KB'
+    number_to_human_size(41100, :precision => 2).should == '40 KB'
+    number_to_human_size(kilobytes(1.0123), :precision => 2, :strip_insignificant_zeros => false).should == '1.0 KB'
+    number_to_human_size(kilobytes(1.0123), :precision => 3, :significant => false).should == '1.012 KB'
+    number_to_human_size(kilobytes(1.0123), :precision => 0, :significant => true) #ignores significant it precision is 0.should == '1 KB'
+  end
+
+  it "should number_to_human_size_with_custom_delimiter_and_separator" do
+   number_to_human_size(kilobytes(1.0123), :precision => 3, :separator => ',')                    .should == '1,01 KB'
+   number_to_human_size(kilobytes(1.0100), :precision => 4, :separator => ',')                    .should == '1,01 KB'
+   number_to_human_size(terabytes(1000.1), :precision => 5, :delimiter => '.', :separator => ',') .should == '1.000,1 TB'
+  end
+
+  it "should number_helpers_should_return_nil_when_given_nil" do
+    number_with_delimiter(nil).should be_nil
+    number_with_precision(nil).should be_nil
+    number_to_human_size(nil).should be_nil
+  end
+
+  it "should number_helpers_should_return_non_numeric_param_unchanged" do
+    number_with_delimiter("x").should == "x"
+    number_with_precision("x.").should == "x."
+    number_with_precision("x").should == "x"
+    number_to_human_size('x').should == "x"
+  end
+
+  it "should number_helpers_should_raise_error_if_invalid_when_specified" do
+    lambda do
+      number_to_human_size("x", :raise => true)
+    end.should raise_error(SitemapGenerator::Helpers::NumberHelper::InvalidNumberError)
+    begin
+      number_to_human_size("x", :raise => true)
+    rescue SitemapGenerator::Helpers::NumberHelper::InvalidNumberError => e
+      e.number.should == "x"
+    end
+
+    lambda do
+      number_with_precision("x", :raise => true)
+    end.should raise_error(SitemapGenerator::Helpers::NumberHelper::InvalidNumberError)
+    begin
+      number_with_precision("x", :raise => true)
+    rescue SitemapGenerator::Helpers::NumberHelper::InvalidNumberError => e
+      e.number.should == "x"
+    end
+
+    lambda do
+      number_with_delimiter("x", :raise => true)
+    end.should raise_error(SitemapGenerator::Helpers::NumberHelper::InvalidNumberError)
+    begin
+      number_with_delimiter("x", :raise => true)
+    rescue SitemapGenerator::Helpers::NumberHelper::InvalidNumberError => e
+      e.number.should == "x"
+    end
+  end
+end