prerendercloud 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5682cc335eaeab97282c40c13b90856a311a2067
+  data.tar.gz: 8ad8486d91b632356e9cddc5b10a6777f4c0a65e
+SHA512:
+  metadata.gz: 70531d251e9001ea5d585fa74a54b64980c03cdd2e4b9cc63eb2c89efc8852b6e4d075483b720bab310b3808ebcf59c082a9f3da37248b3b802da20044b8fb86
+  data.tar.gz: 3c276ac603ba71eb5777251f59ea9214d91ff9b6c1bd574c0d860719a566923117a6157a9e35989d1176e6dcc8b0a59427938c40d938e64edd260cbbf4e1f36f

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in prerender_rails.gemspec
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    prerendercloud (0.1.0)
+      activesupport
+      rack
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.8)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.5.1)
+      public_suffix (~> 2.0, >= 2.0.2)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    hashdiff (0.3.4)
+    i18n (0.8.4)
+    minitest (5.10.2)
+    public_suffix (2.0.5)
+    rack (1.6.8)
+    rake (12.0.0)
+    safe_yaml (1.0.4)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    webmock (3.0.1)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  prerendercloud!
+  rake
+  webmock
+
+BUNDLED WITH
+   1.14.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 San Francesco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+![image](https://cloud.githubusercontent.com/assets/22159102/21554484/9d542f5a-cdc4-11e6-8c4c-7730a9e9e2d1.png)
+
+# prerendercloud-ruby
+
+Rack middleware for server-side rendering (prerendering) JavaScript web pages/apps (single page apps or SPA) with [https://www.prerender.cloud/](https://www.prerender.cloud/)
+
+
+## Rails Usage
+
+`Gemfile`
+
+```ruby
+gem 'prerendercloud'
+```
+
+`config/environment/production.rb`
+
+```ruby
+
+config.middleware.use Rack::Prerendercloud
+# either hard code your secret token:
+# config.middleware.use Rack::Prerendercloud, prerender_token: 'YOUR_TOKEN'
+# or set the PRERENDER_TOKEN environment variable
+
+
+```

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/prerendercloud'
+  t.test_files = FileList['test/lib/prerendercloud.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/prerendercloud.rb

@@ -0,0 +1,253 @@
+module Rack
+  class Prerendercloud
+    require 'net/http'
+    require 'active_support'
+
+    class << self
+
+      def header_whitelist
+         # preserve (and send to client) these headers from service.prerender.cloud
+         # which originally came from the origin server
+        return [
+          "vary",
+          "content-type",
+          "cache-control",
+          "strict-transport-security",
+          "content-security-policy",
+          "public-key-pins",
+          "x-frame-options",
+          "x-xss-protection",
+          "x-content-type-options"
+        ];
+      end
+
+      def normalize_headers(headers)
+        filtered = headers.select { |key, value| header_whitelist.any? { |h| key.to_s.match(/#{h}/i) } }
+
+        mapped = filtered.map do |k, v|
+          [k, if v.is_a? Array then v.join("\n") else v end]
+        end
+        Utils::HeaderHash.new Hash[mapped]
+      end
+    end
+
+    def initialize(app, options={})
+      # googlebot, yahoo, and bingbot are not in this list because
+      # we support _escaped_fragment_ and want to ensure people aren't
+      # penalized for cloaking.
+      @crawler_user_agents = [
+        'googlebot',
+        'yahoo',
+        'bingbot',
+        'baiduspider',
+        'facebookexternalhit',
+        'twitterbot',
+        'rogerbot',
+        'linkedinbot',
+        'embedly',
+        'bufferbot',
+        'quora link preview',
+        'showyoubot',
+        'outbrain',
+        'pinterest/0.',
+        'developers.google.com/+/web/snippet',
+        'www.google.com/webmasters/tools/richsnippets',
+        'slackbot',
+        'vkShare',
+        'W3C_Validator',
+        'redditbot',
+        'Applebot',
+        'WhatsApp',
+        'flipboard',
+        'tumblr',
+        'bitlybot',
+        'SkypeUriPreview',
+        'nuzzel',
+        'Discordbot',
+        'Google Page Speed',
+        'Qwantify'
+      ]
+
+      @options = options
+      @options[:whitelist] = [@options[:whitelist]] if @options[:whitelist].is_a? String
+      @options[:blacklist] = [@options[:blacklist]] if @options[:blacklist].is_a? String
+      @crawler_user_agents = @options[:crawler_user_agents] if @options[:crawler_user_agents]
+      @app = app
+    end
+
+
+    def call(env)
+      if should_show_prerendered_page(env)
+
+        cached_response = before_render(env)
+
+        if cached_response
+          return cached_response.finish
+        end
+
+        prerendered_response = get_prerendered_page_response(env)
+
+        if prerendered_response
+          response = build_rack_response_from_prerender(prerendered_response)
+          after_render(env, prerendered_response)
+          return response.finish
+        end
+      end
+
+      @app.call(env)
+    end
+
+
+    def should_show_prerendered_page(env)
+      user_agent = env['HTTP_USER_AGENT']
+      buffer_agent = env['HTTP_X_BUFFERBOT']
+      is_requesting_prerendered_page = false
+
+      return false if !user_agent
+      return false if env['REQUEST_METHOD'] != 'GET'
+      return false if user_agent.match(/prerendercloud/i);
+
+      request = Rack::Request.new(env)
+
+      return false if !prerenderable_extension(request.fullpath);
+
+      #if it is a bot...show prerendered page
+      if (@options[:bots_only])
+        is_requesting_prerendered_page = true if @crawler_user_agents.any? { |crawler_user_agent| user_agent.downcase.include?(crawler_user_agent.downcase) }
+
+        #if it is BufferBot...show prerendered page
+        is_requesting_prerendered_page = true if buffer_agent
+      else
+        is_requesting_prerendered_page = true
+      end
+
+      is_requesting_prerendered_page = true if Rack::Utils.parse_query(request.query_string).has_key?('_escaped_fragment_')
+
+      # if whitelist exists and path is not whitelisted...don't prerender
+      return false if @options[:whitelist].is_a?(Array) && @options[:whitelist].all? { |whitelisted| !Regexp.new(whitelisted).match(request.fullpath) }
+
+      # if blacklist exists and path is blacklisted(url or referer)...don't prerender
+      if @options[:blacklist].is_a?(Array) && @options[:blacklist].any? { |blacklisted|
+          blacklistedUrl = false
+          blacklistedReferer = false
+          regex = Regexp.new(blacklisted)
+
+          blacklistedUrl = !!regex.match(request.fullpath)
+          blacklistedReferer = !!regex.match(request.referer) if request.referer
+
+          blacklistedUrl || blacklistedReferer
+        }
+        return false
+      end
+
+      return is_requesting_prerendered_page
+    end
+
+    def prerenderable_extension(fullpath)
+
+      path = URI.parse(fullpath).path;
+
+      # doesn't detect index.whatever.html (multiple dots)
+      hasHtmlOrNoExtension = !!path.match(/^(([^.]|\.html?)+)$/);
+
+      return true if hasHtmlOrNoExtension
+
+      # hack to handle basenames with multiple dots: index.whatever.html
+      endsInHtml = !!path.match(/.html?$/);
+
+      return true if endsInHtml
+
+      return false;
+
+    end
+
+    def get_prerendered_page_response(env)
+      begin
+        url = URI.parse(build_api_url(env))
+        headers = {
+          'User-Agent' => env['HTTP_USER_AGENT'],
+          'Accept-Encoding' => 'gzip'
+        }
+        headers['X-Prerender-Token'] = ENV['PRERENDER_TOKEN'] if ENV['PRERENDER_TOKEN']
+        headers['X-Prerender-Token'] = @options[:prerender_token] if @options[:prerender_token]
+        req = Net::HTTP::Get.new(url.request_uri, headers)
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true if url.scheme == 'https'
+        response = http.request(req)
+        if response['Content-Encoding'] == 'gzip'
+          response.body = ActiveSupport::Gzip.decompress(response.body)
+          response['Content-Length'] = response.body.length
+          response.delete('Content-Encoding')
+        end
+        response
+      rescue => e
+        puts "Error: #{e.class.name}"
+        nil
+      end
+    end
+
+
+    def build_api_url(env)
+      new_env = env
+      if env["CF-VISITOR"]
+        match = /"scheme":"(http|https)"/.match(env['CF-VISITOR'])
+        new_env["HTTPS"] = true and new_env["rack.url_scheme"] = "https" and new_env["SERVER_PORT"] = 443 if (match && match[1] == "https")
+        new_env["HTTPS"] = false and new_env["rack.url_scheme"] = "http" and new_env["SERVER_PORT"] = 80 if (match && match[1] == "http")
+      end
+
+      if env["X-FORWARDED-PROTO"]
+        new_env["HTTPS"] = true and new_env["rack.url_scheme"] = "https" and new_env["SERVER_PORT"] = 443 if env["X-FORWARDED-PROTO"].split(',')[0] == "https"
+        new_env["HTTPS"] = false and new_env["rack.url_scheme"] = "http" and new_env["SERVER_PORT"] = 80 if env["X-FORWARDED-PROTO"].split(',')[0] == "http"
+      end
+
+      if @options[:protocol]
+        new_env["HTTPS"] = true and new_env["rack.url_scheme"] = "https" and new_env["SERVER_PORT"] = 443 if @options[:protocol] == "https"
+        new_env["HTTPS"] = false and new_env["rack.url_scheme"] = "http" and new_env["SERVER_PORT"] = 80 if @options[:protocol] == "http"
+      end
+
+      url = Rack::Request.new(new_env).url
+      puts "Requesting prerendered page for #{url}"
+      prerender_url = get_prerender_service_url()
+      forward_slash = prerender_url[-1, 1] == '/' ? '' : '/'
+      "#{prerender_url}#{forward_slash}#{url}"
+    end
+
+
+    def get_prerender_service_url
+      @options[:prerender_service_url] || ENV['PRERENDER_SERVICE_URL'] || 'http://service.prerender.cloud/'
+    end
+
+
+    def build_rack_response_from_prerender(prerendered_response)
+
+      headers = (prerendered_response.respond_to?(:headers) && prerendered_response.headers) || self.class.normalize_headers(prerendered_response.to_hash)
+
+      response = Rack::Response.new(prerendered_response.body, prerendered_response.code, headers)
+
+
+      @options[:build_rack_response_from_prerender].call(response, prerendered_response) if @options[:build_rack_response_from_prerender]
+
+      response
+    end
+
+    def before_render(env)
+      return nil unless @options[:before_render]
+
+      cached_render = @options[:before_render].call(env)
+
+      if cached_render && cached_render.is_a?(String)
+        Rack::Response.new(cached_render, 200, { 'Content-Type' => 'text/html; charset=utf-8' })
+      elsif cached_render && cached_render.is_a?(Rack::Response)
+        cached_render
+      else
+        nil
+      end
+    end
+
+
+    def after_render(env, response)
+      return true unless @options[:after_render]
+      @options[:after_render].call(env, response)
+    end
+  end
+end

data/prerendercloud.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "prerendercloud"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Jonathan Otto"]
+  spec.email         = ["support@prerender.cloud"]
+  spec.description   = %q{Rack middleware to server-side render your JavaScript apps by prerender.cloud}
+  spec.summary       = %q{Rack middleware to server-side render your JavaScript apps by prerender.cloud}
+  spec.homepage      = "https://github.com/sanfrancesco/prerendercloud-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rack', '>= 0'
+  spec.add_dependency 'activesupport', '>= 0'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "webmock"
+end

data/rack_sample_app.rb

@@ -0,0 +1,23 @@
+require 'rack'
+
+require_relative './lib/prerendercloud'
+
+class RackSampleApp
+  def call(env)
+    req = Rack::Request.new(env)
+    case req.path_info
+    when /main.js/
+      [200, {"Content-Type" => "application/javascript"}, ["document.getElementById('root').innerHTML = 'js-app';"]]
+    else
+      [200, {"Content-Type" => "text/html"}, ["<html><body><div id='root'></div><script src='/main.js'></script></body></html>"]]
+    end
+  end
+end
+
+
+app = Rack::Builder.new do
+  use Rack::Prerendercloud
+  run RackSampleApp.new
+end
+
+Rack::Handler::WEBrick.run app

data/test/lib/prerendercloud.rb

@@ -0,0 +1,239 @@
+require_relative '../test_helper'
+
+describe Rack::Prerendercloud do
+
+  bot = 'Baiduspider+(+http://www.baidu.com/search/spider.htm)'
+  user = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.76 Safari/537.36'
+
+  before :each do
+    @app = lambda do |params|
+      [200, {}, ""]
+    end
+
+    @prerender = Rack::Prerendercloud.new(@app)
+  end
+
+
+  it "should return a prerendered response for a crawler with the returned status code and headers" do
+    request = Rack::MockRequest.env_for "/", "HTTP_USER_AGENT" => bot
+    stub_request(:get, @prerender.build_api_url(request)).with(:headers => { 'User-Agent' => bot }).to_return(:body => "<html></html>", :status => 301, :headers => { 'Location' => 'http://google.com'})
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal response[2].body, ["<html></html>"]
+    assert_equal response[2].status, 301
+    assert_equal( { 'Content-Length' => '13'}, response[2].headers )
+  end
+
+
+  it "should return a prerendered reponse if user is a bot by checking for _escaped_fragment_" do
+    request = Rack::MockRequest.env_for "/path?_escaped_fragment_=", "HTTP_USER_AGENT" => user
+    stub_request(:get, @prerender.build_api_url(request)).with(:headers => { 'User-Agent' => user }).to_return(:body => "<html></html>")
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal ["<html></html>"], response[2].body
+  end
+
+  it "should return a prerendered reponse if the url is for .html file" do
+    request = Rack::MockRequest.env_for "/path.html", "HTTP_USER_AGENT" => bot
+    stub_request(:get, @prerender.build_api_url(request)).with(:headers => { 'User-Agent' => bot }).to_return(:body => "<html></html>")
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal ["<html></html>"], response[2].body
+  end
+
+  it "should continue to app routes if the url is for .js file" do
+    request = Rack::MockRequest.env_for "/path.js", "HTTP_USER_AGENT" => bot
+    stub_request(:get, @prerender.build_api_url(request)).with(:headers => { 'User-Agent' => bot }).to_return(:body => "<html></html>")
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal "", response[2]
+  end
+
+  it "with bots_only, should continue to app routes if the url is a bad url with _escaped_fragment_" do
+    request = Rack::MockRequest.env_for "/path?query=string?_escaped_fragment_=", "HTTP_USER_AGENT" => user
+    response = Rack::Prerendercloud.new(@app, bots_only: true).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "should continue to app routes if the request is not a GET" do
+    request = Rack::MockRequest.env_for "/path?_escaped_fragment_=", { "HTTP_USER_AGENT" => user, "REQUEST_METHOD" => "POST" }
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "with bots_only option, should continue to app routes if user is not a bot by checking agent string" do
+    request = Rack::MockRequest.env_for "/", "HTTP_USER_AGENT" => user
+    response = Rack::Prerendercloud.new(@app, bots_only: true).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "should continue to app routes if prerendercloud user-agent" do
+    request = Rack::MockRequest.env_for "/path?_escaped_fragment_=", "HTTP_USER_AGENT" => 'prerendercloud'
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "should continue to app routes if user is a bot, but the bot is requesting a resource file" do
+    request = Rack::MockRequest.env_for "/main.js?anyQueryParam=true", "HTTP_USER_AGENT" => bot
+    response = Rack::Prerendercloud.new(@app).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "should continue to app routes if the url is not part of the regex specific whitelist" do
+    request = Rack::MockRequest.env_for "/saved/search/blah?_escaped_fragment_=", "HTTP_USER_AGENT" => bot
+    response = Rack::Prerendercloud.new(@app, whitelist: ['^/search', '/help']).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "should set use_ssl to true for https prerender_service_url" do
+    @prerender = Rack::Prerendercloud.new(@app, prerender_service_url: 'https://service.prerender.cloud/')
+
+    request = Rack::MockRequest.env_for "/search/things/123/page?_escaped_fragment_=", "HTTP_USER_AGENT" => bot
+    stub_request(:get, @prerender.build_api_url(request)).to_return(:body => "<html></html>")
+    response = @prerender.call(request)
+
+    assert_equal ["<html></html>"], response[2].body
+  end
+
+
+  it "should return a prerendered response if the url is part of the regex specific whitelist" do
+    request = Rack::MockRequest.env_for "/search/things/123/page?_escaped_fragment_=", "HTTP_USER_AGENT" => bot
+    stub_request(:get, @prerender.build_api_url(request)).to_return(:body => "<html></html>")
+    response = Rack::Prerendercloud.new(@app, whitelist: ['^/search.*page', '/help']).call(request)
+
+    assert_equal ["<html></html>"], response[2].body
+  end
+
+
+  it "should continue to app routes if the url is part of the regex specific blacklist" do
+    request = Rack::MockRequest.env_for "/search/things/123/page", "HTTP_USER_AGENT" => bot
+    response = Rack::Prerendercloud.new(@app, blacklist: ['^/search', '/help']).call(request)
+
+    assert_equal "", response[2]
+  end
+
+  it "should continue to app routes if the hashbang url is part of the regex specific blacklist" do
+    request = Rack::MockRequest.env_for "?_escaped_fragment_=/search/things/123/page", "HTTP_USER_AGENT" => bot
+    response = Rack::Prerendercloud.new(@app, blacklist: ['/search', '/help']).call(request)
+
+    assert_equal "", response[2]
+  end
+
+  it "should return a prerendered response if the url is not part of the regex specific blacklist" do
+    request = Rack::MockRequest.env_for "/profile/search/blah", "HTTP_USER_AGENT" => bot
+    stub_request(:get, @prerender.build_api_url(request)).to_return(:body => "<html></html>")
+    response = Rack::Prerendercloud.new(@app, blacklist: ['^/search', '/help']).call(request)
+
+    assert_equal ["<html></html>"], response[2].body
+  end
+
+
+  it "should continue to app routes if the referer is part of the regex specific blacklist" do
+    request = Rack::MockRequest.env_for "/api/results", "HTTP_USER_AGENT" => bot, "HTTP_REFERER" => '/search'
+    response = Rack::Prerendercloud.new(@app, blacklist: ['^/search', '/help']).call(request)
+
+    assert_equal "", response[2]
+  end
+
+
+  it "should return a prerendered response if the referer is not part of the regex specific blacklist" do
+    request = Rack::MockRequest.env_for "/api/results", "HTTP_USER_AGENT" => bot, "HTTP_REFERER" => '/profile/search'
+    stub_request(:get, @prerender.build_api_url(request)).to_return(:body => "<html></html>")
+    response = Rack::Prerendercloud.new(@app, blacklist: ['^/search', '/help']).call(request)
+
+    assert_equal ["<html></html>"], response[2].body
+  end
+
+
+  it "should return a prerendered response if a string is returned from before_render" do
+    request = Rack::MockRequest.env_for "/", "HTTP_USER_AGENT" => bot
+    response = Rack::Prerendercloud.new(@app, before_render: Proc.new do |env| '<html>cached</html>' end).call(request)
+
+    assert_equal ["<html>cached</html>"], response[2].body
+  end
+
+
+  it "should return a prerendered response if a response is returned from before_render" do
+    request = Rack::MockRequest.env_for "/", "HTTP_USER_AGENT" => bot
+    response = Rack::Prerendercloud.new(@app, before_render: Proc.new do |env| Rack::Response.new('<html>cached2</html>', 200, { 'test' => 'test2Header'}) end).call(request)
+
+    assert_equal ["<html>cached2</html>"], response[2].body
+    assert_equal response[2].status, 200
+    assert_equal( { 'test' => 'test2Header', "Content-Length"=>"20"}, response[2].headers )
+  end
+
+
+  describe '#buildApiUrl' do
+    it "should build the correct api url with the default url" do
+      request = Rack::MockRequest.env_for "https://google.com/search?q=javascript"
+      ENV['PRERENDER_SERVICE_URL'] = nil
+      assert_equal 'http://service.prerender.cloud/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+
+
+    it "should build the correct api url with an environment variable url" do
+      ENV['PRERENDER_SERVICE_URL'] = 'http://prerenderurl.com'
+      request = Rack::MockRequest.env_for "https://google.com/search?q=javascript"
+      assert_equal 'http://prerenderurl.com/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+      ENV['PRERENDER_SERVICE_URL'] = nil
+    end
+
+
+    it "should build the correct api url with an initialization variable url" do
+      @prerender = Rack::Prerendercloud.new(@app, prerender_service_url: 'http://prerenderurl.com')
+      request = Rack::MockRequest.env_for "https://google.com/search?q=javascript"
+      assert_equal 'http://prerenderurl.com/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+
+
+    it "should build the correct https api url with an initialization variable url" do
+      @prerender = Rack::Prerendercloud.new(@app, prerender_service_url: 'https://prerenderurl.com')
+      request = Rack::MockRequest.env_for "https://google.com/search?q=javascript"
+      assert_equal 'https://prerenderurl.com/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+
+
+    # Check CF-Visitor header in order to Work behind CloudFlare with Flexible SSL (https://support.cloudflare.com/hc/en-us/articles/200170536)
+    it "should build the correct api url for the Cloudflare Flexible SSL support" do
+      request = Rack::MockRequest.env_for "http://google.com/search?q=javascript", { 'CF-VISITOR' => '"scheme":"https"'}
+      ENV['PRERENDER_SERVICE_URL'] = nil
+      assert_equal 'http://service.prerender.cloud/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+
+
+    # Check X-Forwarded-Proto because Heroku SSL Support terminates at the load balancer
+    it "should build the correct api url for the Heroku SSL Addon support with single value" do
+      request = Rack::MockRequest.env_for "http://google.com/search?q=javascript", { 'X-FORWARDED-PROTO' => 'https'}
+      ENV['PRERENDER_SERVICE_URL'] = nil
+      assert_equal 'http://service.prerender.cloud/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+
+
+    # Check X-Forwarded-Proto because Heroku SSL Support terminates at the load balancer
+    it "should build the correct api url for the Heroku SSL Addon support with double value" do
+      request = Rack::MockRequest.env_for "http://google.com/search?q=javascript", { 'X-FORWARDED-PROTO' => 'https,http'}
+      ENV['PRERENDER_SERVICE_URL'] = nil
+      assert_equal 'http://service.prerender.cloud/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+
+    it "should build the correct api url for the protocol option" do
+      @prerender = Rack::Prerendercloud.new(@app, protocol: 'https')
+      request = Rack::MockRequest.env_for "http://google.com/search?q=javascript"
+      ENV['PRERENDER_SERVICE_URL'] = nil
+      assert_equal 'http://service.prerender.cloud/https://google.com/search?q=javascript', @prerender.build_api_url(request)
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'rack'
+require File.expand_path('../../lib/prerendercloud.rb', __FILE__)

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: prerendercloud
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Otto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rack middleware to server-side render your JavaScript apps by prerender.cloud
+email:
+- support@prerender.cloud
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/prerendercloud.rb
+- prerendercloud.gemspec
+- rack_sample_app.rb
+- test/lib/prerendercloud.rb
+- test/test_helper.rb
+homepage: https://github.com/sanfrancesco/prerendercloud-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Rack middleware to server-side render your JavaScript apps by prerender.cloud
+test_files:
+- test/lib/prerendercloud.rb
+- test/test_helper.rb