rack-livereload/spec/rack/livereload_spec.rb

require 'spec_helper'
require 'nokogiri'

describe Rack::LiveReload do
  let(:middleware) { described_class.new(app, options) }
  let(:app) { stub }

  subject { middleware }

  its(:app) { should == app }

  let(:env) { {} }
  let(:options) { {} }

  describe "livereload local uri" do
    context 'does not exist' do
      before do
        stub_request(:any, 'localhost:35729/livereload.js').to_timeout
      end

      it { should use_vendored }
    end

    context 'exists' do
      before do
        stub_request(:any, 'localhost:35729/livereload.js')
      end

      it { should_not use_vendored }
    end

    context 'with custom port' do
      let(:options) { {:live_reload_port => '12348'}}
      context 'exists' do
        before do
          stub_request(:any, 'localhost:12348/livereload.js')
        end
        it { should_not use_vendored }
      end
    end

    context 'specify vendored' do
      let(:options) { { :source => :vendored } }

      it { should use_vendored }
    end

    context 'specify LR' do
      let(:options) { { :source => :livereload } }

      it { should_not use_vendored }
    end
  end

  context 'not text/html' do
    let(:ret) { [ 200, { 'Content-Type' => 'application/pdf' }, [ '<head></head>' ] ] }

    before do
      app.stubs(:call).with(env).returns(ret)
    end

    it 'should pass through' do
      middleware.call(env).should == ret
    end
  end

  context 'image/png' do
    let(:body) { [ '<head></head>' ] }
    let(:ret) { [ 200, { 'Content-Type' => 'image/png' }, body ] }

    before do
      app.stubs(:call).with(env).returns(ret)
      body.expects(:close).never
      body.stubs(:respond_to?).with(:close).returns(true)
    end

    it 'should pass through' do
      middleware.call(env).should == ret
    end
  end

  context 'text/event-stram' do
    let(:body) { [ '<head></head>' ] }
    let(:ret) { [ 200, { 'Content-Type' => 'text/event-stream' }, body ] }

    before do
      app.stubs(:call).with(env).returns(ret)
      body.expects(:close).never
      body.stubs(:respond_to?).with(:close).returns(true)
    end

    it 'should pass through' do
      middleware.call(env).should == ret
    end
  end

  context 'chunked response' do
    let(:body) { [ '<head></head>' ] }
    let(:ret) { [ 200, { 'Transfer-Encoding' => 'chunked' }, body ] }

    before do
      app.stubs(:call).with(env).returns(ret)
      body.expects(:close).never
      body.stubs(:respond_to?).with(:close).returns(true)
    end

    it 'should pass through' do
      middleware.call(env).should == ret
    end
  end

  context 'inline disposition' do
    let(:body) { [ '<head></head>' ] }
    let(:ret) { [ 200, { 'Content-Disposition' => 'inline; filename=my_inlined_file' }, body ] }

    before do
      app.stubs(:call).with(env).returns(ret)
      body.expects(:close).never
      body.stubs(:respond_to?).with(:close).returns(true)
    end

    it 'should pass through' do
      middleware.call(env).should == ret
    end
  end

  context 'unknown Content-Type' do
    let(:ret) { [ 200, {}, [ 'hey ho' ] ] }

    before do
      app.stubs(:call).with(env).returns(ret)
    end

    it 'should not break' do
      middleware.call(env).should_not raise_error(NoMethodError, /You have a nil object/)
    end
  end

  context 'text/html' do
    before do
      app.stubs(:call).with(env).returns([ 200, { 'Content-Type' => 'text/html', 'Content-Length' => 0 }, [ page_html ] ])
      middleware.stubs(:use_vendored?).returns(true)
    end

    let(:host) { 'host' }
    let(:env) { { 'HTTP_HOST' => host } }

    let(:ret) { middleware._call(env) }
    let(:body) { ret.last.join }
    let(:length) { ret[1]['Content-Length'] }

    let(:page_html) { '<head></head>' }

    context 'vendored' do
      it 'should add the vendored livereload js script tag' do
        body.should include("script")
        body.should include(described_class::LIVERELOAD_JS_PATH)

        length.should == body.length.to_s

        described_class::LIVERELOAD_JS_PATH.should_not include(host)

        body.should include('swfobject')
        body.should include('web_socket')
      end
    end

    context 'at the top of the head tag' do
      let(:page_html) { '<head attribute="attribute"><script type="text/javascript" insert="first"></script><script type="text/javascript" insert="before"></script></head>' }

      let(:body_dom) { Nokogiri::XML(body) }

      it 'should add the livereload js script tag before all other script tags' do
        body_dom.at_css("head")[:attribute].should == 'attribute'
        body_dom.at_css("script:eq(5)")[:src].should include(described_class::LIVERELOAD_JS_PATH)
        body_dom.at_css("script:last-child")[:insert].should == "before"
      end

      context 'when a relative URL root is specified' do
        before do
          ENV['RAILS_RELATIVE_URL_ROOT'] = '/a_relative_path'
        end

        it 'should prepend the relative path to the script src' do
          body_dom.at_css("script:eq(5)")[:src].should match(%r{^/a_relative_path/})
        end
      end
    end

    describe "LIVERELOAD_PORT value" do
      let(:options) { {:live_reload_port => 12345 }}
      it "sets the variable at the top of the file" do
        body.should include 'RACK_LIVERELOAD_PORT = 12345'
      end
    end


    context 'in header tags' do
      let(:page_html) { "<header class='hero'><h1>Just a normal header tag</h1></header>" }

      let(:body_dom) { Nokogiri::XML(body) }

      it 'should not add the livereload js' do
        body_dom.at_css("header")[:class].should == 'hero'
        body_dom.css('script').should be_empty
      end
    end

    context 'not vendored' do
      before do
        middleware.stubs(:use_vendored?).returns(false)
      end

      it 'should add the LR livereload js script tag' do
        body.should include("script")
        body.should include(middleware.livereload_local_uri.gsub('localhost', 'host'))
      end
    end

    context 'set options' do
      let(:middleware) { described_class.new(app, :host => new_host, :port => port, :min_delay => min_delay, :max_delay => max_delay) }
      let(:min_delay) { 5 }
      let(:max_delay) { 10 }
      let(:port) { 23 }
      let(:new_host) { 'myhost' }

      it 'should add the livereload.js script tag' do
        body.should include("mindelay=#{min_delay}")
        body.should include("maxdelay=#{max_delay}")
        body.should include("port=#{port}")
        body.should include("host=#{new_host}")
      end
    end

    context 'force flash' do
      let(:middleware) { described_class.new(app, :force_swf => true) }

      it 'should not add the flash shim' do
        body.should include('WEB_SOCKET_FORCE_FLASH')
        body.should include('swfobject')
        body.should include('web_socket')
      end
    end

    context 'no flash' do
      let(:middleware) { described_class.new(app, :no_swf => true) }

      it 'should not add the flash shim' do
        body.should_not include('swfobject')
        body.should_not include('web_socket')
      end
    end

    context 'no host at all' do
      let(:env) { {} }

      it 'should use localhost' do
        body.should include('localhost')
      end
    end

    context 'ignored' do
      let(:options) { { :ignore => [ %r{file} ] } }

      context 'not root' do
        let(:env) { { 'PATH_INFO' => '/this/file' } }

        it 'should have no change' do
          body.should_not include('script')
        end
      end

      context 'root' do
        let(:env) { { 'PATH_INFO' => '/' } }

        it 'should have script' do
          body.should include('script')
        end
      end
    end
  end

  context '/__rack/livereload.js' do
    let(:env) { { 'PATH_INFO' => described_class::LIVERELOAD_JS_PATH } }

    before do
      middleware.expects(:deliver_file).returns(true)
    end

    it 'should return the js file' do
      middleware._call(env).should be_true
    end
  end

  describe '#ignored?' do
    let(:path_info) { 'path info' }

    context 'no ignore set' do
      it { should_not be_ignored(path_info) }
    end

    context 'ignore set' do
      let(:options) { { :ignore => [ %r{#{path_info}} ] } }

      it { should be_ignored(path_info) }
    end
  end

  describe '#bad_browser?' do
    let(:user_agent) { described_class::BAD_USER_AGENTS.first.source }

    it { should be_bad_browser(user_agent) }
  end

  describe 'head tag regex' do
    let(:regex) { described_class::HEAD_TAG_REGEX }
    subject { regex }

    it { should be_kind_of(Regexp) }

    it 'only picks a valid <head> tag' do
      regex.match("<head></head>").to_s.should eq('<head>')
      regex.match("<head><title></title></head>").to_s.should eq('<head>')
      regex.match("<head attribute='something'><title></title></head>").to_s.should eq("<head attribute='something'>")
    end

    it 'responds false when no head tag' do
      regex.match("<header></header>").should be_false
    end
  end
end
initial commit 2011-11-04 15:51:22 +00:00			`require 'spec_helper'`
potential fix for turbolinks load order problem 2012-12-03 19:00:45 +00:00			`require 'nokogiri'`
initial commit 2011-11-04 15:51:22 +00:00
			`describe Rack::LiveReload do`
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`let(:middleware) { described_class.new(app, options) }`
initial commit 2011-11-04 15:51:22 +00:00			`let(:app) { stub }`

			`subject { middleware }`

			`its(:app) { should == app }`

			`let(:env) { {} }`
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`let(:options) { {} }`

Adds the live_reload_port option. This allows the javascript to work with a non default value for the livereload port (specified with the port option in the guard command). For example, in config/environments/development.rb in rails: config.middleware.insert_after(ActionDispatch::Static, Rack::LiveReload, :live_reload_port => 22351) works with the following in the Guardfile: guard 'livereload', port: '22351' do ... end This allows multiple guard livereload processes to operate at the same time without conflicts. 2013-02-03 11:13:48 +00:00			`describe "livereload local uri" do`
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`context 'does not exist' do`
			`before do`
			`stub_request(:any, 'localhost:35729/livereload.js').to_timeout`
			`end`

			`it { should use_vendored }`
			`end`

			`context 'exists' do`
			`before do`
			`stub_request(:any, 'localhost:35729/livereload.js')`
			`end`

			`it { should_not use_vendored }`
			`end`

Adds the live_reload_port option. This allows the javascript to work with a non default value for the livereload port (specified with the port option in the guard command). For example, in config/environments/development.rb in rails: config.middleware.insert_after(ActionDispatch::Static, Rack::LiveReload, :live_reload_port => 22351) works with the following in the Guardfile: guard 'livereload', port: '22351' do ... end This allows multiple guard livereload processes to operate at the same time without conflicts. 2013-02-03 11:13:48 +00:00			`context 'with custom port' do`
			`let(:options) { {:live_reload_port => '12348'}}`
			`context 'exists' do`
			`before do`
			`stub_request(:any, 'localhost:12348/livereload.js')`
			`end`
			`it { should_not use_vendored }`
			`end`
			`end`

detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`context 'specify vendored' do`
			`let(:options) { { :source => :vendored } }`

			`it { should use_vendored }`
			`end`

			`context 'specify LR' do`
			`let(:options) { { :source => :livereload } }`

			`it { should_not use_vendored }`
			`end`
			`end`
initial commit 2011-11-04 15:51:22 +00:00
			`context 'not text/html' do`
pass images through 2013-04-21 13:48:32 +00:00			`let(:ret) { [ 200, { 'Content-Type' => 'application/pdf' }, [ '<head></head>' ] ] }`
initial commit 2011-11-04 15:51:22 +00:00
			`before do`
			`app.stubs(:call).with(env).returns(ret)`
			`end`

			`it 'should pass through' do`
			`middleware.call(env).should == ret`
			`end`
			`end`

pass images through 2013-04-21 13:48:32 +00:00			`context 'image/png' do`
			`let(:body) { [ '<head></head>' ] }`
			`let(:ret) { [ 200, { 'Content-Type' => 'image/png' }, body ] }`

			`before do`
			`app.stubs(:call).with(env).returns(ret)`
			`body.expects(:close).never`
			`body.stubs(:respond_to?).with(:close).returns(true)`
			`end`

			`it 'should pass through' do`
			`middleware.call(env).should == ret`
			`end`
			`end`

don't try to close text/event-stream bodies, should fix #24 2013-01-24 15:22:54 +00:00			`context 'text/event-stram' do`
			`let(:body) { [ '<head></head>' ] }`
			`let(:ret) { [ 200, { 'Content-Type' => 'text/event-stream' }, body ] }`

			`before do`
			`app.stubs(:call).with(env).returns(ret)`
			`body.expects(:close).never`
			`body.stubs(:respond_to?).with(:close).returns(true)`
			`end`

			`it 'should pass through' do`
			`middleware.call(env).should == ret`
			`end`
			`end`

Don't force iterating chunked (streamed) responses 2013-03-19 06:11:45 +00:00			`context 'chunked response' do`
			`let(:body) { [ '<head></head>' ] }`
			`let(:ret) { [ 200, { 'Transfer-Encoding' => 'chunked' }, body ] }`

			`before do`
			`app.stubs(:call).with(env).returns(ret)`
			`body.expects(:close).never`
			`body.stubs(:respond_to?).with(:close).returns(true)`
			`end`

			`it 'should pass through' do`
			`middleware.call(env).should == ret`
			`end`
			`end`

While we're at not messing with stuff, don't mess with inlined content 2013-03-19 06:32:46 +00:00			`context 'inline disposition' do`
			`let(:body) { [ '<head></head>' ] }`
			`let(:ret) { [ 200, { 'Content-Disposition' => 'inline; filename=my_inlined_file' }, body ] }`

			`before do`
			`app.stubs(:call).with(env).returns(ret)`
			`body.expects(:close).never`
			`body.stubs(:respond_to?).with(:close).returns(true)`
			`end`

			`it 'should pass through' do`
			`middleware.call(env).should == ret`
			`end`
			`end`

Added failing test 2012-01-23 19:51:08 +00:00			`context 'unknown Content-Type' do`
			`let(:ret) { [ 200, {}, [ 'hey ho' ] ] }`

			`before do`
			`app.stubs(:call).with(env).returns(ret)`
			`end`

			`it 'should not break' do`
			`middleware.call(env).should_not raise_error(NoMethodError, /You have a nil object/)`
			`end`
			`end`

initial commit 2011-11-04 15:51:22 +00:00			`context 'text/html' do`
			`before do`
potential fix for turbolinks load order problem 2012-12-03 19:00:45 +00:00			`app.stubs(:call).with(env).returns([ 200, { 'Content-Type' => 'text/html', 'Content-Length' => 0 }, [ page_html ] ])`
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`middleware.stubs(:use_vendored?).returns(true)`
initial commit 2011-11-04 15:51:22 +00:00			`end`

haha, fix a dumb bug: 2011-11-04 15:57:41 +00:00			`let(:host) { 'host' }`
			`let(:env) { { 'HTTP_HOST' => host } }`

fix tests 2012-03-04 18:27:31 +00:00			`let(:ret) { middleware._call(env) }`
initial commit 2011-11-04 15:51:22 +00:00			`let(:body) { ret.last.join }`
			`let(:length) { ret[1]['Content-Length'] }`

potential fix for turbolinks load order problem 2012-12-03 19:00:45 +00:00			`let(:page_html) { '<head></head>' }`

detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`context 'vendored' do`
			`it 'should add the vendored livereload js script tag' do`
			`body.should include("script")`
			`body.should include(described_class::LIVERELOAD_JS_PATH)`

			`length.should == body.length.to_s`
initial commit 2011-11-04 15:51:22 +00:00
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`described_class::LIVERELOAD_JS_PATH.should_not include(host)`
add support for web-sockets-js 2011-11-17 20:44:48 +00:00
			`body.should include('swfobject')`
			`body.should include('web_socket')`
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`end`
			`end`
haha, fix a dumb bug: 2011-11-04 15:57:41 +00:00
put the javascript at the start of the head block 2012-12-04 19:12:53 +00:00			`context 'at the top of the head tag' do`
			`let(:page_html) { '<head attribute="attribute"><script type="text/javascript" insert="first"></script><script type="text/javascript" insert="before"></script></head>' }`
potential fix for turbolinks load order problem 2012-12-03 19:00:45 +00:00
			`let(:body_dom) { Nokogiri::XML(body) }`

			`it 'should add the livereload js script tag before all other script tags' do`
put the javascript at the start of the head block 2012-12-04 19:12:53 +00:00			`body_dom.at_css("head")[:attribute].should == 'attribute'`
...and fix the test for that 2013-03-27 21:50:58 +00:00			`body_dom.at_css("script:eq(5)")[:src].should include(described_class::LIVERELOAD_JS_PATH)`
potential fix for turbolinks load order problem 2012-12-03 19:00:45 +00:00			`body_dom.at_css("script:last-child")[:insert].should == "before"`
			`end`
Adds the live_reload_port option. This allows the javascript to work with a non default value for the livereload port (specified with the port option in the guard command). For example, in config/environments/development.rb in rails: config.middleware.insert_after(ActionDispatch::Static, Rack::LiveReload, :live_reload_port => 22351) works with the following in the Guardfile: guard 'livereload', port: '22351' do ... end This allows multiple guard livereload processes to operate at the same time without conflicts. 2013-02-03 11:13:48 +00:00
Handle Rails apps running on relative root 2013-03-08 19:59:39 +00:00			`context 'when a relative URL root is specified' do`
			`before do`
			`ENV['RAILS_RELATIVE_URL_ROOT'] = '/a_relative_path'`
			`end`

			`it 'should prepend the relative path to the script src' do`
			`body_dom.at_css("script:eq(5)")[:src].should match(%r{^/a_relative_path/})`
			`end`
			`end`
potential fix for turbolinks load order problem 2012-12-03 19:00:45 +00:00			`end`

Adds the live_reload_port option. This allows the javascript to work with a non default value for the livereload port (specified with the port option in the guard command). For example, in config/environments/development.rb in rails: config.middleware.insert_after(ActionDispatch::Static, Rack::LiveReload, :live_reload_port => 22351) works with the following in the Guardfile: guard 'livereload', port: '22351' do ... end This allows multiple guard livereload processes to operate at the same time without conflicts. 2013-02-03 11:13:48 +00:00			`describe "LIVERELOAD_PORT value" do`
			`let(:options) { {:live_reload_port => 12345 }}`
			`it "sets the variable at the top of the file" do`
			`body.should include 'RACK_LIVERELOAD_PORT = 12345'`
			`end`
			`end`



don't insert into <header> tags. 2012-12-13 22:41:30 +00:00			`context 'in header tags' do`
			`let(:page_html) { "<header class='hero'><h1>Just a normal header tag</h1></header>" }`

			`let(:body_dom) { Nokogiri::XML(body) }`

			`it 'should not add the livereload js' do`
			`body_dom.at_css("header")[:class].should == 'hero'`
			`body_dom.css('script').should be_empty`
			`end`
			`end`

detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`context 'not vendored' do`
			`before do`
			`middleware.stubs(:use_vendored?).returns(false)`
			`end`

			`it 'should add the LR livereload js script tag' do`
			`body.should include("script")`
Adds the live_reload_port option. This allows the javascript to work with a non default value for the livereload port (specified with the port option in the guard command). For example, in config/environments/development.rb in rails: config.middleware.insert_after(ActionDispatch::Static, Rack::LiveReload, :live_reload_port => 22351) works with the following in the Guardfile: guard 'livereload', port: '22351' do ... end This allows multiple guard livereload processes to operate at the same time without conflicts. 2013-02-03 11:13:48 +00:00			`body.should include(middleware.livereload_local_uri.gsub('localhost', 'host'))`
detection and use of local livereload if available 2011-11-08 14:48:34 +00:00			`end`
initial commit 2011-11-04 15:51:22 +00:00			`end`
set options when adding the middleware to the stack 2011-11-07 14:06:40 +00:00
			`context 'set options' do`
override the host. now it is complete. no more changes ever need to be made to this. ever. 2011-11-07 14:11:27 +00:00			`let(:middleware) { described_class.new(app, :host => new_host, :port => port, :min_delay => min_delay, :max_delay => max_delay) }`
set options when adding the middleware to the stack 2011-11-07 14:06:40 +00:00			`let(:min_delay) { 5 }`
			`let(:max_delay) { 10 }`
			`let(:port) { 23 }`
override the host. now it is complete. no more changes ever need to be made to this. ever. 2011-11-07 14:11:27 +00:00			`let(:new_host) { 'myhost' }`
set options when adding the middleware to the stack 2011-11-07 14:06:40 +00:00
			`it 'should add the livereload.js script tag' do`
			`body.should include("mindelay=#{min_delay}")`
			`body.should include("maxdelay=#{max_delay}")`
			`body.should include("port=#{port}")`
override the host. now it is complete. no more changes ever need to be made to this. ever. 2011-11-07 14:11:27 +00:00			`body.should include("host=#{new_host}")`
set options when adding the middleware to the stack 2011-11-07 14:06:40 +00:00			`end`
			`end`
add support for web-sockets-js 2011-11-17 20:44:48 +00:00
			`context 'force flash' do`
			`let(:middleware) { described_class.new(app, :force_swf => true) }`

			`it 'should not add the flash shim' do`
			`body.should include('WEB_SOCKET_FORCE_FLASH')`
			`body.should include('swfobject')`
			`body.should include('web_socket')`
			`end`
			`end`

			`context 'no flash' do`
			`let(:middleware) { described_class.new(app, :no_swf => true) }`

			`it 'should not add the flash shim' do`
			`body.should_not include('swfobject')`
			`body.should_not include('web_socket')`
			`end`
			`end`
ensure some sort of host for rack::mockrequests that don't provide one 2011-11-28 15:42:39 +00:00
			`context 'no host at all' do`
			`let(:env) { {} }`

			`it 'should use localhost' do`
			`body.should include('localhost')`
			`end`
			`end`
add the ability to ignore certain urls that may match 2011-12-01 12:25:02 +00:00
			`context 'ignored' do`
			`let(:options) { { :ignore => [ %r{file} ] } }`

fix bug when path was nil 2011-12-02 11:58:06 +00:00			`context 'not root' do`
			`let(:env) { { 'PATH_INFO' => '/this/file' } }`

			`it 'should have no change' do`
			`body.should_not include('script')`
			`end`
			`end`

			`context 'root' do`
			`let(:env) { { 'PATH_INFO' => '/' } }`

			`it 'should have script' do`
			`body.should include('script')`
			`end`
add the ability to ignore certain urls that may match 2011-12-01 12:25:02 +00:00			`end`
			`end`
initial commit 2011-11-04 15:51:22 +00:00			`end`

			`context '/__rack/livereload.js' do`
			`let(:env) { { 'PATH_INFO' => described_class::LIVERELOAD_JS_PATH } }`

			`before do`
			`middleware.expects(:deliver_file).returns(true)`
			`end`

			`it 'should return the js file' do`
fix tests 2012-03-04 18:27:31 +00:00			`middleware._call(env).should be_true`
initial commit 2011-11-04 15:51:22 +00:00			`end`
			`end`
a little cleanup, add cucumber, add support for ignoring particular browsers 2012-01-03 13:58:51 +00:00
			`describe '#ignored?' do`
			`let(:path_info) { 'path info' }`

			`context 'no ignore set' do`
			`it { should_not be_ignored(path_info) }`
			`end`

			`context 'ignore set' do`
			`let(:options) { { :ignore => [ %r{#{path_info}} ] } }`

			`it { should be_ignored(path_info) }`
			`end`
			`end`

			`describe '#bad_browser?' do`
			`let(:user_agent) { described_class::BAD_USER_AGENTS.first.source }`

			`it { should be_bad_browser(user_agent) }`
			`end`
add specs for regex 2012-12-14 00:27:16 +00:00
			`describe 'head tag regex' do`
			`let(:regex) { described_class::HEAD_TAG_REGEX }`
			`subject { regex }`

			`it { should be_kind_of(Regexp) }`

			`it 'only picks a valid <head> tag' do`
			`regex.match("<head></head>").to_s.should eq('<head>')`
			`regex.match("<head><title></title></head>").to_s.should eq('<head>')`
			`regex.match("<head attribute='something'><title></title></head>").to_s.should eq("<head attribute='something'>")`
			`end`

			`it 'responds false when no head tag' do`
			`regex.match("<header></header>").should be_false`
			`end`
			`end`
initial commit 2011-11-04 15:51:22 +00:00			`end`
set options when adding the middleware to the stack 2011-11-07 14:06:40 +00:00