pdfkit 0.8.2 → 0.8.4.3.1

data/lib/pdfkit/source.rb

@@ -1,3 +1,4 @@
+require 'tempfile'
 require 'uri'
 
 class PDFKit
@@ -13,7 +14,7 @@ class PDFKit
     end
 
     def file?
-      @is_file ||= @source.kind_of?(File)
+      @is_file ||= @source.kind_of?(File) || @source.kind_of?(Tempfile)
     end
 
     def html?

data/lib/pdfkit/version.rb

@@ -1,3 +1,3 @@
 class PDFKit
-  VERSION = "0.8.2"
+  VERSION = '0.8.4.3.1'
 end

data/lib/pdfkit/wkhtmltopdf.rb

@@ -0,0 +1,80 @@
+class PDFKit
+  class WkHTMLtoPDF
+    attr_reader :options
+    # Pulled from:
+    # https://github.com/wkhtmltopdf/wkhtmltopdf/blob/ebf9b6cfc4c58a31349fb94c568b254fac37b3d3/README_WKHTMLTOIMAGE#L27
+    REPEATABLE_OPTIONS = %w[--allow --cookie --custom-header --post --post-file --run-script]
+    SPECIAL_OPTIONS = %w[cover toc]
+
+    def initialize(options)
+      @options = options
+    end
+  
+    def normalize_options
+      # TODO(cdwort,sigmavirus24): Make this method idempotent in a future release so it can be called repeatedly
+      normalized_options = {}
+  
+      @options.each do |key, value|
+        next if !value
+  
+        # The actual option for wkhtmltopdf
+        normalized_key = normalize_arg key
+        normalized_key = "--#{normalized_key}" unless SPECIAL_OPTIONS.include?(normalized_key)
+  
+        # If the option is repeatable, attempt to normalize all values
+        if REPEATABLE_OPTIONS.include? normalized_key
+          normalize_repeatable_value(normalized_key, value) do |normalized_unique_key, normalized_value|
+            normalized_options[normalized_unique_key] = normalized_value
+          end
+        else # Otherwise, just normalize it like usual
+          normalized_options[normalized_key] = normalize_value(value)
+        end
+      end
+  
+      @options = normalized_options
+    end
+
+    def error_handling?
+      @options.key?('--ignore-load-errors') ||
+        # wkhtmltopdf v0.10.0 beta4 replaces ignore-load-errors with load-error-handling
+        # https://code.google.com/p/wkhtmltopdf/issues/detail?id=55
+        %w(skip ignore).include?(@options['--load-error-handling'])
+    end
+
+    def options_for_command
+      @options.to_a.flatten.compact
+    end
+  
+    private
+  
+    def normalize_arg(arg)
+      arg.to_s.downcase.gsub(/[^a-z0-9]/,'-')
+    end
+  
+    def normalize_value(value)
+      case value
+      when nil
+        nil
+      when TrueClass, 'true' #ie, ==true, see http://www.ruby-doc.org/core-1.9.3/TrueClass.html
+        nil
+      when Hash
+        value.to_a.flatten.collect{|x| normalize_value(x)}.compact
+      when Array
+        value.flatten.collect{|x| x.to_s}
+      else
+        (OS::host_is_windows? && value.to_s.index(' ')) ? "'#{ value.to_s }'" : value.to_s
+      end
+    end
+  
+    def normalize_repeatable_value(option_name, value)
+      case value
+      when Hash, Array
+        value.each do |(key, val)|
+          yield [[option_name, normalize_value(key)], normalize_value(val)]
+        end
+      else
+        yield [[option_name, normalize_value(value)], nil]
+      end
+    end
+  end
+end

data/pdfkit.gemspec

@@ -11,20 +11,20 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/pdfkit/pdfkit"
   s.summary     = "HTML+CSS -> PDF"
   s.description = "Uses wkhtmltopdf to create PDFs using HTML"
-
-  s.rubyforge_project = "pdfkit"
+  s.license     = "MIT"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # Developmnet Dependencies
-  s.add_development_dependency(%q<activesupport>, [">= 3.0.8"])
+  s.requirements << "wkhtmltopdf"
+
+  # Development Dependencies
+  s.add_development_dependency(%q<activesupport>, [">= 4.1.11"])
   s.add_development_dependency(%q<mocha>, [">= 0.9.10"])
   s.add_development_dependency(%q<rack-test>, [">= 0.5.6"])
-  s.add_development_dependency(%q<i18n>, ["~>0.6.11"]) # Ruby 1.9.2 compatibility
-  s.add_development_dependency(%q<rake>, ["~>0.9.2"])
+  s.add_development_dependency(%q<rake>, ["~>12.3.3"])
   s.add_development_dependency(%q<rdoc>, ["~> 4.0.1"])
   s.add_development_dependency(%q<rspec>, ["~> 3.0"])
 end

data/spec/configuration_spec.rb

@@ -3,26 +3,74 @@ require 'spec_helper'
 describe PDFKit::Configuration do
   subject { PDFKit::Configuration.new }
   describe "#wkhtmltopdf" do
-    it "can be configured" do
-      subject.wkhtmltopdf = '/my/bin/wkhtmltopdf'
-      expect(subject.wkhtmltopdf).to eql '/my/bin/wkhtmltopdf'
-    end
+    context "when explicitly configured" do
+      it "uses configured value and don't detect" do
+        expect(subject).not_to receive(:default_wkhtmltopdf)
+        subject.wkhtmltopdf = "./Gemfile" # Need a file which exists
+        expect(subject.wkhtmltopdf).to eq("./Gemfile")
+      end
 
-    # This test documents existing functionality. Feel free to fix.
-    it "can be poorly configured" do
-      subject.wkhtmltopdf = 1234
-      expect(subject.wkhtmltopdf).to eql 1234
+      it "falls back to detected binary if configured path doesn't exists" do
+        expect(subject).to receive(:default_wkhtmltopdf).twice.and_return("/bin/fallback")
+        expect(subject).to receive(:warn).with(/No executable found/)
+        subject.wkhtmltopdf = "./missing-file" # Need a file which doesn't exist
+        expect(subject.wkhtmltopdf).to eq("/bin/fallback")
+      end
     end
 
     context "when not explicitly configured" do
-      it "detects the existance of bundler" do
-        # Test assumes bundler is installed in your test environment
-        expect(subject).to receive(:`).with('bundle exec which wkhtmltopdf').and_return('c:\windows\path.exe')
-        subject.wkhtmltopdf
+      context "when running inside bundler" do
+        # Simulate the presence of bundler even if it's not here
+        before { stub_const("Bundler::GemfileError", Class) }
+
+        it "detects the existance of bundler" do
+          expect(subject).to receive(:`).with('bundle exec which wkhtmltopdf').and_return("c:\\windows\\path.exe\n")
+          expect(subject.wkhtmltopdf).to eq('c:\windows\path.exe')
+        end
+
+        it "falls back if bundler path fails" do
+          # This happens when there is a wrong (buggy) version of bundler for example
+          expect(subject).to receive(:`).with('bundle exec which wkhtmltopdf').and_return("")
+          expect(subject).to receive(:`).with('which wkhtmltopdf').and_return("c:\\windows\\path.exe\n")
+          expect(subject.wkhtmltopdf).to eq('c:\windows\path.exe')
+        end
+
+        it "returns last line of 'bundle exec which' output" do
+          # Happens when the user does not have a HOME directory on their system and runs bundler < 2
+          expect(subject).to receive(:`).with('bundle exec which wkhtmltopdf').and_return(<<~EOT
+            `/home/myuser` is not a directory.
+            Bundler will use `/tmp/bundler/home/myuser' as your home directory temporarily.
+            /usr/bin/wkhtmltopdf
+          EOT
+          )
+          expect(subject.wkhtmltopdf).to eq('/usr/bin/wkhtmltopdf')
+        end
+      end
+
+      context "when running without bundler" do
+        # Simulate the absence of bundler even if it's there
+        before { hide_const("Bundler::GemfileError") }
+
+        it "detects the existance of bundler" do
+          expect(subject).not_to receive(:`).with('bundle exec which wkhtmltopdf')
+          expect(subject).to receive(:`).with('which wkhtmltopdf').and_return('c:\windows\path.exe')
+          expect(subject.wkhtmltopdf).to eq('c:\windows\path.exe')
+        end
       end
     end
   end
 
+  describe "#executable" do
+    it "returns wkhtmltopdf by default" do
+      expect(subject.executable).to eql subject.wkhtmltopdf
+    end
+
+    it "uses xvfb-run wrapper when option of using xvfb is configured" do
+      expect(subject).to receive(:using_xvfb?).and_return(true)
+      expect(subject.executable).to include 'xvfb-run'
+    end
+  end
+
   describe "#default_options" do
     it "sets defaults for the command options" do
       expect(subject.default_options[:disable_smart_shrinking]).to eql false
@@ -40,6 +88,13 @@ describe PDFKit::Configuration do
       expect(subject.default_options[:quiet]).to eql false
       expect(subject.default_options[:is_awesome]).to eql true
     end
+
+    it "merges additional options with existing defaults" do
+      subject.default_options = { quiet: false, is_awesome: true }
+      expect(subject.default_options[:quiet]).to eql false
+      expect(subject.default_options[:is_awesome]).to eql true
+      expect(subject.default_options[:disable_smart_shrinking]).to eql false
+    end
   end
 
   describe "#root_url" do
@@ -64,6 +119,22 @@ describe PDFKit::Configuration do
     end
   end
 
+  describe "#using_xvfb?" do
+    it "can be configured to true" do
+      subject.use_xvfb = true
+      expect(subject.using_xvfb?).to eql true
+    end
+
+    it "defaults to false" do
+      expect(subject.using_xvfb?).to eql false
+    end
+
+    it "can be configured to false" do
+      subject.use_xvfb = false
+      expect(subject.using_xvfb?).to eql false
+    end
+  end
+
   describe "#verbose?" do
     it "can be configured to true" do
       subject.verbose = true

data/spec/html_preprocessor_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe PDFKit::HTMLPreprocessor do
+  describe "#process" do
+    let(:preprocessor) { PDFKit::HTMLPreprocessor }
+    let(:root_url) { 'http://example.com/' }  # This mirrors Middleware#root_url's response
+    let(:protocol) { 'http' }
+
+    it "correctly parses host-relative url with single quotes" do
+      original_body = %{<html><head><link href='/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src="/test.png" /></body></html>}
+      body = preprocessor.process original_body, root_url, protocol
+      expect(body).to eq("<html><head><link href='http://example.com/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src=\"http://example.com/test.png\" /></body></html>")
+    end
+
+    it "correctly parses host-relative url with double quotes" do
+      original_body = %{<link href="/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />}
+      body = preprocessor.process original_body, root_url, protocol
+      expect(body).to eq("<link href=\"http://example.com/stylesheets/application.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />")
+    end
+
+    it "correctly parses protocol-relative url with single quotes" do
+      original_body = %{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'>}
+      body = preprocessor.process original_body, root_url, protocol
+      expect(body).to eq("<link href='http://fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'>")
+    end
+
+    it "correctly parses protocol-relative url with double quotes" do
+      original_body = %{<link href="//fonts.googleapis.com/css?family=Open+Sans:400,600" rel='stylesheet' type='text/css'>}
+      body = preprocessor.process original_body, root_url, protocol
+      expect(body).to eq("<link href=\"http://fonts.googleapis.com/css?family=Open+Sans:400,600\" rel='stylesheet' type='text/css'>")
+    end
+
+    it "correctly parses multiple tags where first one is root url" do
+      original_body = %{<a href='/'><img src='/logo.jpg' ></a>}
+      body = preprocessor.process original_body, root_url, protocol
+      expect(body).to eq "<a href='http://example.com/'><img src='http://example.com/logo.jpg' ></a>"
+    end
+
+    it "returns the body even if there are no valid substitutions found" do
+      original_body = "NO MATCH"
+      body = preprocessor.process original_body, root_url, protocol
+      expect(body).to eq("NO MATCH")
+    end
+
+    context 'when root_url is nil' do
+      it "returns the body safely, without interpolating" do
+        original_body = %{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'><a href='/'><img src='/logo.jpg'></a>}
+        body = preprocessor.process original_body, nil, protocol
+        expect(body).to eq(%{<link href='http://fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'><a href='/'><img src='/logo.jpg'></a>})
+      end
+    end
+
+    context 'when protocol is nil' do
+      it "returns the body safely, without interpolating" do
+        original_body = %{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'><a href='/'><img src='/logo.jpg'></a>}
+        body = preprocessor.process original_body, root_url, nil
+        expect(body).to eq(%{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'><a href='http://example.com/'><img src='http://example.com/logo.jpg'></a>})
+      end
+    end
+
+    context 'when root_url and protocol are both nil' do
+      it "returns the body safely, without interpolating" do
+        original_body = %{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'><a href='/'><img src='/logo.jpg'></a>}
+        body = preprocessor.process original_body, nil, nil
+        expect(body).to eq original_body
+      end
+    end
+  end
+end

data/spec/middleware_spec.rb

@@ -21,6 +21,35 @@ describe PDFKit::Middleware do
   end
 
   describe "#call" do
+
+    describe 'threadsafety' do
+      before { mock_app }
+      it 'is threadsafe' do
+        n = 30
+        extensions = Array.new(n) { rand > 0.5 ? 'html' : 'pdf' }
+        actual_content_types = Hash.new
+
+        threads = (0...n).map { |i|
+          Thread.new do
+            resp = get("http://www.example.org/public/test.#{extensions[i]}")
+            actual_content_types[i] = resp.content_type
+          end
+        }
+
+        threads.each(&:join)
+
+        extensions.each_with_index do |extension, index|
+          result = actual_content_types[index]
+          case extension
+          when 'html', 'txt', 'csv'
+            expect(result).to eq("text/#{extension}")
+          when 'pdf'
+            expect(result).to eq('application/pdf')
+          end
+        end
+      end
+    end
+
     describe "caching" do
       let(:headers) do
         {
@@ -236,22 +265,22 @@ describe PDFKit::Middleware do
       end
 
       describe "saving generated pdf to disk" do
-	before do
+        before do
           #make sure tests don't find an old test_save.pdf
           File.delete('spec/test_save.pdf') if File.exists?('spec/test_save.pdf')
           expect(File.exists?('spec/test_save.pdf')).to eq(false)
-	end
+        end
 
         context "when header PDFKit-save-pdf is present" do
           it "saves the .pdf to disk" do
-	    headers = { 'PDFKit-save-pdf' => 'spec/test_save.pdf' }
+            headers = { 'PDFKit-save-pdf' => 'spec/test_save.pdf' }
             mock_app({}, {only: '/public'}, headers)
-	    get 'http://www.example.org/public/test_save.pdf'
+            get 'http://www.example.org/public/test_save.pdf'
             expect(File.exists?('spec/test_save.pdf')).to eq(true)
-	  end
+          end
 
           it "does not raise when target directory does not exist" do
-	    headers = { 'PDFKit-save-pdf' => '/this/dir/does/not/exist/spec/test_save.pdf' }
+            headers = { 'PDFKit-save-pdf' => '/this/dir/does/not/exist/spec/test_save.pdf' }
             mock_app({}, {only: '/public'}, headers)
             expect {
               get 'http://www.example.com/public/test_save.pdf'
@@ -262,15 +291,122 @@ describe PDFKit::Middleware do
         context "when header PDFKit-save-pdf is not present" do
           it "does not saved the .pdf to disk" do
             mock_app({}, {only: '/public'}, {} )
-	    get 'http://www.example.org/public/test_save.pdf'
+            get 'http://www.example.org/public/test_save.pdf'
             expect(File.exists?('spec/test_save.pdf')).to eq(false)
           end
         end
       end
+
+      describe 'javascript delay' do
+        context 'when header PDFKit-javascript-delay is present' do
+          it 'passes header value through to PDFKit initialiser' do
+            expect(PDFKit).to receive(:new).with('Hello world!', {
+              root_url: 'http://www.example.com/', protocol: 'http', javascript_delay: 4321
+            }).and_call_original
+
+            headers = { 'PDFKit-javascript-delay' => '4321' }
+            mock_app({}, { only: '/public' }, headers)
+            get 'http://www.example.com/public/test_save.pdf'
+          end
+
+          it 'handles invalid content in header' do
+            expect(PDFKit).to receive(:new).with('Hello world!', {
+              root_url: 'http://www.example.com/', protocol: 'http', javascript_delay: 0
+            }).and_call_original
+
+            headers = { 'PDFKit-javascript-delay' => 'invalid' }
+            mock_app({}, { only: '/public' }, headers)
+            get 'http://www.example.com/public/test_save.pdf'
+          end
+
+          it 'overrides default option' do
+            expect(PDFKit).to receive(:new).with('Hello world!', {
+              root_url: 'http://www.example.com/', protocol: 'http', javascript_delay: 4321
+            }).and_call_original
+
+            headers = { 'PDFKit-javascript-delay' => '4321' }
+            mock_app({ javascript_delay: 1234 }, { only: '/public' }, headers)
+            get 'http://www.example.com/public/test_save.pdf'
+          end
+        end
+
+        context 'when header PDFKit-javascript-delay is not present' do
+          it 'passes through default option' do
+            expect(PDFKit).to receive(:new).with('Hello world!', {
+              root_url: 'http://www.example.com/', protocol: 'http', javascript_delay: 1234
+            }).and_call_original
+
+            mock_app({ javascript_delay: 1234 }, { only: '/public' }, { })
+            get 'http://www.example.com/public/test_save.pdf'
+          end
+        end
+      end
+
+      describe ":disposition" do
+        describe "doesn't overwrite existing value" do
+          let(:headers) do
+            super().merge({
+              'Content-Disposition' => 'attachment; filename=report-20200101.pdf'
+            })
+          end
+
+          specify do
+            mock_app({}, { :disposition => 'inline' })
+            get 'http://www.example.org/public/test.pdf'
+            expect(last_response.headers["Content-Disposition"]).to eq('attachment; filename=report-20200101.pdf')
+          end
+        end
+
+        describe "inline or blank" do
+          context "default" do
+            specify do
+              mock_app
+              get 'http://www.example.org/public/test.pdf'
+              expect(last_response.headers["Content-Disposition"]).to eq("inline")
+            end
+          end
+
+          context "inline" do
+            specify do
+              mock_app({}, { :disposition => 'inline'  })
+              get 'http://www.example.org/public/test.pdf'
+              expect(last_response.headers["Content-Disposition"]).to eq("inline")
+            end
+          end
+        end
+
+        describe "attachment" do
+          context "attachment" do
+            specify do
+              mock_app({}, { :disposition => 'attachment'  })
+              get 'http://www.example.org/public/test.pdf'
+              expect(last_response.headers["Content-Disposition"]).to eq("attachment")
+            end
+          end
+
+          context "attachment with filename" do
+            specify do
+              mock_app({}, { :disposition => 'attachment; filename=report.pdf'  })
+              get 'http://www.example.org/public/test.pdf'
+              expect(last_response.headers["Content-Disposition"]).to eq("attachment; filename=report.pdf")
+            end
+          end
+        end
+      end
+
+      describe "error handling" do
+        specify do
+          mock_app
+          allow(PDFKit).to receive(:new).and_raise(StandardError.new("Something went wrong"))
+          get 'http://www.example.org/public/test.pdf'
+          expect(last_response.status).to eq(500)
+          expect(last_response.body).to eq("Something went wrong")
+        end
+      end
     end
 
-  describe "remove .pdf from PATH_INFO and REQUEST_URI" do
-    before { mock_app }
+    describe "remove .pdf from PATH_INFO and REQUEST_URI" do
+      before { mock_app }
 
       context "matching" do
 
@@ -319,80 +455,37 @@ describe PDFKit::Middleware do
     end
   end
 
-  describe "#translate_paths" do
+  describe "#root_url and #protocol" do
     before do
       @pdf = PDFKit::Middleware.new({})
       @env = { 'REQUEST_URI' => 'http://example.com/document.pdf', 'rack.url_scheme' => 'http', 'HTTP_HOST' => 'example.com' }
     end
 
-    it "correctly parses relative url with single quotes" do
-      @body = %{<html><head><link href='/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src="/test.png" /></body></html>}
-      body = @pdf.send :translate_paths, @body, @env
-      expect(body).to eq("<html><head><link href='http://example.com/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src=\"http://example.com/test.png\" /></body></html>")
-    end
-
-    it "correctly parses relative url with double quotes" do
-      @body = %{<link href="/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />}
-      body = @pdf.send :translate_paths, @body, @env
-      expect(body).to eq("<link href=\"http://example.com/stylesheets/application.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />")
-    end
-
-    it "correctly parses relative url with double quotes" do
-      @body = %{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'>}
-      body = @pdf.send :translate_paths, @body, @env
-      expect(body).to eq("<link href='http://fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'>")
-    end
-
-    it "correctly parses multiple tags where first one is root url" do
-      @body = %{<a href='/'><img src='/logo.jpg' ></a>}
-      body = @pdf.send :translate_paths, @body, @env
-      expect(body).to eq "<a href='http://example.com/'><img src='http://example.com/logo.jpg' ></a>"
-    end
+    context 'when root_url is not configured' do
+      it "infers the root_url and protocol from the environment" do
+        root_url = @pdf.send(:root_url, @env)
+        protocol = @pdf.send(:protocol, @env)
 
-    it "returns the body even if there are no valid substitutions found" do
-      @body = "NO MATCH"
-      body = @pdf.send :translate_paths, @body, @env
-      expect(body).to eq("NO MATCH")
+        expect(root_url).to eq('http://example.com/')
+        expect(protocol).to eq('http')
+      end
     end
-  end
 
-  describe "#translate_paths with root_url configuration" do
-    before do
-      @pdf = PDFKit::Middleware.new({})
-      @env = { 'REQUEST_URI' => 'http://example.com/document.pdf', 'rack.url_scheme' => 'http', 'HTTP_HOST' => 'example.com' }
-      PDFKit.configure do |config|
-        config.root_url = "http://example.net/"
+    context 'when root_url is configured' do
+      before do
+        PDFKit.configuration.root_url = 'http://example.net/'
+      end
+      after do
+        PDFKit.configuration.root_url = nil
       end
-    end
 
-    it "adds the root_url" do
-      @body = %{<html><head><link href='/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src="/test.png" /></body></html>}
-      body = @pdf.send :translate_paths, @body, @env
-      expect(body).to eq("<html><head><link href='http://example.net/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src=\"http://example.net/test.png\" /></body></html>")
-    end
+      it "takes the root_url from the configuration, and infers the protocol from the environment" do
+        root_url = @pdf.send(:root_url, @env)
+        protocol = @pdf.send(:protocol, @env)
 
-    after do
-      PDFKit.configure do |config|
-        config.root_url = nil
+        expect(root_url).to eq('http://example.net/')
+        expect(protocol).to eq('http')
       end
     end
   end
-
-  it "does not get stuck rendering each request as pdf" do
-    mock_app
-    # false by default. No requests.
-    expect(@app.send(:rendering_pdf?)).to eq(false)
-
-    # Remain false on a normal request
-    get 'http://www.example.org/public/file'
-    expect(@app.send(:rendering_pdf?)).to eq(false)
-
-    # Return true on a pdf request.
-    get 'http://www.example.org/public/file.pdf'
-    expect(@app.send(:rendering_pdf?)).to eq(true)
-
-    # Restore to false on any non-pdf request.
-    get 'http://www.example.org/public/file'
-    expect(@app.send(:rendering_pdf?)).to eq(false)
-  end
 end