slimmer 10.0.0 → 10.1.0

data/test/skin_test.rb

@@ -1,99 +0,0 @@
-require_relative "test_helper"
-
-describe Slimmer::Skin do
-
-  describe "loading templates" do
-    it "should be able to load the template" do
-      skin = Slimmer::Skin.new asset_host: "http://example.local/", cache: Slimmer::Cache.instance
-
-      expected_url = "http://example.local/templates/example.html.erb"
-      stub_request(:get, expected_url).to_return :body => "<foo />"
-
-      template = skin.template 'example'
-
-      assert_requested :get, expected_url
-      assert_equal "<foo />", template
-    end
-
-    describe "should pass the GOVUK-Request-Id header when requesting the template" do
-      before do
-        @skin = Slimmer::Skin.new asset_host: "http://example.local/", cache: Slimmer::Cache.instance
-
-        @expected_url = "http://example.local/templates/example.html.erb"
-        stub_request(:get, @expected_url).to_return :body => "<foo />"
-      end
-
-      it "should pass the value from the original request if set" do
-        Slimmer::GovukRequestId.value = '12345'
-        template = @skin.template('example')
-
-        assert_requested :get, @expected_url do |request|
-          request.headers['Govuk-Request-Id'] == '12345'
-        end
-        assert_equal "<foo />", template
-      end
-
-      it "shouldnot set the header if the value is not set" do
-        Slimmer::GovukRequestId.value = ''
-        template = @skin.template('example')
-
-        assert_requested :get, @expected_url do |request|
-          ! request.headers.has_key?('Govuk-Request-Id')
-        end
-        assert_equal "<foo />", template
-      end
-    end
-
-    it "should try and load templates from the cache" do
-      skin = Slimmer::Skin.new asset_host: "http://example.local/", cache: Slimmer::Cache.instance
-
-      Slimmer::Cache.instance.expects(:fetch).with('example-template').returns('cache data')
-      template = skin.template 'example-template'
-      assert_equal 'cache data', template
-    end
-
-    it "should raise appropriate exception when template not found" do
-      skin = Slimmer::Skin.new asset_host: "http://example.local/", cache: Slimmer::Cache.instance
-
-      expected_url = "http://example.local/templates/example.html.erb"
-      stub_request(:get, expected_url).to_return(:status => '404')
-
-      assert_raises(Slimmer::TemplateNotFoundException) do
-        skin.template 'example'
-      end
-    end
-
-    it "should raise appropriate exception when cant reach template host" do
-      skin = Slimmer::Skin.new asset_host: "http://example.local/", cache: Slimmer::Cache.instance
-
-      expected_url = "http://example.local/templates/example.html.erb"
-      stub_request(:get, expected_url).to_raise(Errno::ECONNREFUSED)
-
-      assert_raises(Slimmer::CouldNotRetrieveTemplate) do
-        skin.template 'example'
-      end
-    end
-
-    it "should raise appropriate exception when hostname cannot be resolved" do
-      skin = Slimmer::Skin.new asset_host: "http://non-existent.domain/", cache: Slimmer::Cache.instance
-
-      expected_url = "http://non-existent.domain/templates/example.html.erb"
-      stub_request(:get, expected_url).to_raise(SocketError)
-
-      assert_raises(Slimmer::CouldNotRetrieveTemplate) do
-        skin.template 'example'
-      end
-    end
-
-    it "should raise appropriate exception when encountering an SSL error" do
-      skin = Slimmer::Skin.new asset_host: "https://bad-ssl.domain/", cache: Slimmer::Cache.instance
-
-      expected_url = "https://bad-ssl.domain/templates/example.html.erb"
-      stub_request(:get, expected_url).to_raise(OpenSSL::SSL::SSLError)
-
-      assert_raises(Slimmer::CouldNotRetrieveTemplate) do
-        skin.template 'example'
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,136 +0,0 @@
-require_relative '../lib/slimmer'
-require 'minitest/autorun'
-require 'rack/test'
-require 'json'
-require 'logger'
-require 'mocha/setup'
-require 'timecop'
-
-MiniTest::Test.class_eval do
-  def as_nokogiri(html_string)
-    Nokogiri::HTML.parse(html_string.strip)
-  end
-
-  def assert_in(template, selector, content=nil, message=nil)
-    message ||= "Expected to find #{content ? "#{content.inspect} at " : ""}#{selector.inspect} in the output template"
-
-    assert template.at_css(selector), message + ", but selector not found."
-
-    if content
-      assert_equal content, template.at_css(selector).inner_html.to_s, message
-    end
-  end
-
-  def assert_not_in(template, selector, message="didn't expect to find #{selector}")
-    refute template.at_css(selector), message
-  end
-
-  def allowing_real_web_connections(&block)
-    WebMock.allow_net_connect!
-    result = yield
-    WebMock.disable_net_connect!
-    result
-  end
-
-  def teardown
-    Timecop.return
-  end
-end
-
-require 'webmock/minitest'
-WebMock.disable_net_connect!
-
-# Including action_view is dificualt because it depends on rails and internal
-# ~*magic*~. To avoid depending on the whole of rails mock out the method we
-# need so we can tests the internal implementations which don't depend on rails
-module ActionView
-  class Resolver
-  end
-  class Template
-    attr_reader :args
-    def initialize(*args)
-      @args = args
-    end
-    def self.registered_template_handler(*args)
-      args
-    end
-  end
-end
-
-class SlimmerIntegrationTest < MiniTest::Test
-  include Rack::Test::Methods
-
-  # given_response can either be called from a setup method, or in the class scope.
-  # The setup method variant is necessary if you want to pass variables into the call that
-  # are created in higher setup methods.
-  def self.given_response(code, body, headers={}, app_options={})
-    define_method(:setup) do
-      super()
-      given_response(code, body, headers, app_options)
-    end
-  end
-
-  def given_response(code, body, headers={}, app_options={})
-    self.class.class_eval do
-      define_method(:app) do
-        inner_app = proc { |env|
-          [code, {"Content-Type" => "text/html"}.merge(headers), body]
-        }
-        Slimmer::App.new inner_app, {asset_host: "http://template.local"}.merge(app_options)
-      end
-    end
-
-    template_name = case code
-                    when 200 then 'core_layout'
-                    when 404 then '404'
-                    when 410 then '410'
-                    else          '500'
-                    end
-
-    use_template(template_name)
-    use_template('report_a_problem.raw')
-
-    fetch_page
-  end
-
-  def fetch_page
-    get "/"
-  end
-
-  def use_template(template_name)
-    template = File.read File.dirname(__FILE__) + "/fixtures/#{template_name}.html.erb"
-    stub_request(:get, "http://template.local/templates/#{template_name}.html.erb").
-      to_return(:body => template)
-  end
-
-  private
-
-  def assert_not_rendered_in_template(content)
-    refute_match /#{Regexp.escape(content)}/, last_response.body
-  end
-
-  # content can be a string or a Regexp
-  def assert_rendered_in_template(selector, content=nil, message=nil)
-    unless message
-      if content
-        message = "Expected to find #{content.inspect} at #{selector.inspect} in the output template"
-      else
-        message = "Expected to find #{selector.inspect} in the output template"
-      end
-    end
-
-    matched_elements = Nokogiri::HTML.parse(last_response.body).css(selector)
-    assert matched_elements.length > 0, message + ", but selector not found."
-
-    if content
-      inner_htmls = matched_elements.map(&:inner_html)
-      found_match = inner_htmls.grep(content).any? # grep matches strings or Regexps
-      assert found_match, message + ". The selector was found but with different content: \"#{inner_htmls.join('", ')}\""
-    end
-  end
-
-  def assert_no_selector(selector, message=nil)
-    message ||= "Expected not to find #{selector.inspect}, but did"
-    assert_nil Nokogiri::HTML.parse(last_response.body).at_css(selector), message
-  end
-end

data/test/test_helpers/govuk_components_test.rb

@@ -1,19 +0,0 @@
-require_relative "../test_helper"
-require_relative "../../lib/slimmer/test_helpers/govuk_components"
-
-describe Slimmer::TestHelpers::GovukComponents do
-  let(:subject) {
-    class Dummy
-      include Slimmer::TestHelpers::GovukComponents
-    end
-  }
-
-  describe '#shared_component_selector' do
-    it 'generates a selector for components' do
-      outcome = subject.new.shared_component_selector('flux_capacitor')
-
-      expected = "test-govuk-component[data-template='govuk_component-flux_capacitor']"
-      assert_equal expected, outcome
-    end
-  end
-end

data/test/test_template_dependency_on_static_test.rb

@@ -1,25 +0,0 @@
-require "test_helper"
-
-class TestTemplateDependencyOnStaticTest < MiniTest::Test
-  def test_scripts_on_static_referenced_in_test_templates_exist
-    template_path = File.dirname(__FILE__).gsub('/test', '/lib/slimmer/test_templates')
-    Dir.foreach(template_path) do | template_file_name |
-      next if ['.','..'].include? template_file_name
-      doc = Nokogiri::HTML.fragment(File.read(File.join(template_path, template_file_name)))
-      scripts = doc.search("script").map { |node| node.attributes["src"].value }
-      failing_scripts = allowing_real_web_connections do
-        scripts.select do |script_src|
-          uri = URI.parse(script_src)
-          http = Net::HTTP.new(uri.host, uri.port)
-          if uri.scheme == "https"
-            http.use_ssl = true
-            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          end
-          response = http.get(uri.request_uri)
-          response.code != "200"
-        end
-      end
-      assert failing_scripts.empty?, "Some scripts could not be loaded: #{failing_scripts.inspect}"
-    end
-  end
-end

data/test/typical_usage_test.rb

@@ -1,358 +0,0 @@
-require_relative "test_helper"
-
-module TypicalUsage
-
-  class SkippingSlimmerTest < SlimmerIntegrationTest
-    given_response 200, %{Don't template me}, {"X-Slimmer-Skip" => "true"}
-
-    def test_should_return_the_response_as_is
-      assert_equal "Don't template me", last_response.body
-    end
-  end
-
-  class SkipUsingQueryParamTest < SlimmerIntegrationTest
-    given_response 200, %{<html><body><div id='unskinned'>Unskinned</div><div id="wrapper">Don't template me</div></body></html>}, {}
-
-    def fetch_page; end
-
-    def with_rails_env(new_env, &block)
-      old_env, ENV['RAILS_ENV'] = ENV['RAILS_ENV'], new_env
-      begin
-        yield
-      ensure
-        ENV['RAILS_ENV'] = old_env
-      end
-    end
-
-    def test_should_return_the_response_as_is_in_development
-      with_rails_env('development') do
-        get "/some-slug?skip_slimmer=1"
-      end
-      assert_rendered_in_template '#unskinned', "Unskinned"
-    end
-
-    def test_not_skip_slimmer_in_test
-      with_rails_env('test') do
-        get "/some-slug?skip_slimmer=1"
-      end
-      assert_rendered_in_template '#wrapper', /^Don't template me/
-    end
-  end
-
-  class SkipNonHtmlResponse < SlimmerIntegrationTest
-    given_response 200, '{ "json" : "document" }', {'Content-Type' => 'application/json'}
-
-    def test_should_pass_through_non_html_response
-      assert_equal '{ "json" : "document" }', last_response.body
-    end
-  end
-
-  class SkipDoesntInteractWithNonHtmlBodies < SlimmerIntegrationTest
-    def test_non_html_response_bodies_are_passed_through_untouched
-      # Rack::SendFile doesn't work if to_s, to_str or each are called on the
-      # response body (as happens when building a Rack::Response)
-      body = stub('body')
-      inner_app = proc { |env|
-        [200, {"Content-Type" => "application/json"}, body]
-      }
-      app = Slimmer::App.new inner_app, {asset_host: "http://template.local"}
-
-      body.expects(:to_s).never
-      body.expects(:to_str).never
-      body.expects(:each).never
-      Rack::Response.expects(:new).never
-
-      app.call({})
-    end
-  end
-
-  class ContentLengthTest < SlimmerIntegrationTest
-    given_response 200, %{
-      <html>
-      <head><title>The title of the page</title>
-      <meta name="something" content="yes">
-      <script src="blah.js"></script>
-      <link href="app.css" rel="stylesheet" type="text/css">
-      </head>
-      <body class="body_class">
-      <div id="wrapper">The body of the page</div>
-      </body>
-      </html>
-    }
-
-    def test_should_set_correct_content_length_header
-      expected = last_response.body.bytesize
-      assert_equal expected.to_s, last_response.headers['Content-Length']
-    end
-  end
-
-  class NormalResponseTest < SlimmerIntegrationTest
-    def setup
-      super
-      given_response 200, %{
-        <html>
-        <head><title>The title of the page</title>
-        <meta name="something" content="yes">
-        <script src="blah.js"></script>
-        <link href="app.css" rel="stylesheet" type="text/css">
-        </head>
-        <body class="body_class">
-        <div id="wrapper">The body of the page</div>
-        </body>
-        </html>
-      }, {}
-    end
-
-    def test_should_replace_the_wrapper_using_the_app_response
-      assert_rendered_in_template "#wrapper", /^The body of the page/
-    end
-
-    def test_should_replace_the_title_using_the_app_response
-      assert_rendered_in_template "head title", "The title of the page"
-    end
-
-    def test_should_move_script_tags_into_the_body
-      assert_rendered_in_template "body script[src='blah.js']"
-    end
-
-    def test_should_move_meta_tags_into_the_head
-      assert_rendered_in_template "head meta[name='something']"
-    end
-
-    def test_should_move_stylesheet_tags_into_the_head
-      assert_rendered_in_template "head link[href='app.css']"
-    end
-
-    def test_should_copy_the_class_of_the_body_element
-      assert_rendered_in_template "body.body_class"
-    end
-  end
-
-  class ConditionalCommentTest < SlimmerIntegrationTest
-    given_response 200, %{
-      <html>
-      <head><title>The title of the page</title>
-      <!--[if lt IE 9]><link href="app-ie.css" rel="stylesheet" type="text/css"><![endif]-->
-      </head>
-      <body class="body_class"><div id="wrapper"></div></body>
-      </html>
-    }
-    def test_should_find_conditional_comments_copied_into_the_head
-      element = Nokogiri::HTML.parse(last_response.body).at_xpath('//comment()')
-      assert_match /app-ie\.css/, element.to_s, 'Not found conditional comment in output'
-    end
-  end
-
-  class WrapTagTest < SlimmerIntegrationTest
-    given_response 200, %{
-      <html>
-      <head>
-      <!--[if gt IE 8]><!--><link href="app.css" rel="stylesheet" type="text/css"><!--<![endif]-->
-      </head>
-      <body class="body_class"><div id="wrapper"></div></body>
-      </html>
-    }
-    def test_should_find_stylesheet_wrapped_with_conditional_comments
-      assert_rendered_in_template "head link[href='app.css']"
-      element = Nokogiri::HTML.parse(last_response.body).at_xpath('/html/head')
-      assert_match /<!--\[if gt IE 8\]><!-->.*app\.css.*<!--<!\[endif\]-->/m, element.to_s, 'Not found conditional comment in output'
-    end
-  end
-
-  class HeaderContextResponseTest < SlimmerIntegrationTest
-    given_response 200, %{
-      <html>
-      <head><title>The title of the page</title>
-      <meta name="something" content="yes">
-      <script src="blah.js"></script>
-      <link href="app.css" rel="stylesheet" type="text/css">
-      </head>
-      <body class="body_class">
-      <div class="header-context custom-class">app-specific header context</div>
-      <div id="wrapper">The body of the page</div>
-      </body>
-      </html>
-    }
-
-    def test_should_replace_the_header_context_using_the_app_response
-      assert_rendered_in_template ".header-context.custom-class", "app-specific header context"
-    end
-  end
-
-  class ReportAProblemTest < SlimmerIntegrationTest
-    given_response 200, %{
-      <html>
-      <body>
-      <div id="wrapper">The body of the page</div>
-      </body>
-      </html>
-    }
-
-    def test_should_insert_the_report_a_problem_form
-      assert_rendered_in_template "#wrapper .report-a-problem-container"
-    end
-
-    def test_should_add_the_current_url_to_the_form
-      assert_rendered_in_template ".report-a-problem-container input[name=url][value='http://example.org/']"
-    end
-  end
-
-  class Error500ResponseTest < SlimmerIntegrationTest
-    given_response 500, %{
-      <html>
-      <head><title>500 Error</title>
-      <meta name="something" content="yes">
-      <script src="blah.js"></script>
-      <link href="app.css" rel="stylesheet" type="text/css">
-      </head>
-      <body class="body_class">
-      <div id="wrapper"><p class='message'>Something bad happened</p></div>
-      </body>
-      </html>
-    }
-
-    def test_should_not_replace_the_wrapper_using_the_app_response
-      assert_not_rendered_in_template "Something bad happened"
-    end
-
-    def test_should_include_default_500_error_message
-      assert_rendered_in_template "body .content header h1", "We seem to be having a problem."
-    end
-
-    def test_should_replace_the_title_using_the_app_response
-      assert_rendered_in_template "head title", "500 Error"
-    end
-  end
-
-  class Error404ResponseTest < SlimmerIntegrationTest
-    given_response 404, %{
-      <html>
-      <head><title>404 Missing</title>
-      <meta name="something" content="yes">
-      <script src="blah.js"></script>
-      <link href="app.css" rel="stylesheet" type="text/css">
-      </head>
-      <body class="body_class">
-      <div id="wrapper"><p class='message'>Something bad happened</p></div>
-      </body>
-      </html>
-    }
-
-    def test_should_not_replace_the_wrapper_using_the_app_response
-      assert_not_rendered_in_template "Something bad happened"
-    end
-
-    def test_should_include_default_404_error_message
-      assert_rendered_in_template "body .content header h1", "Oops! We can't find what you're looking for."
-    end
-
-    def test_should_replace_the_title_using_the_app_response
-      assert_rendered_in_template "head title", "404 Missing"
-    end
-  end
-
-  class Error406ResponseTest < SlimmerIntegrationTest
-    given_response 406, %{
-      <html>
-      <head><title>406 Not Acceptable</title>
-      <meta name="something" content="yes">
-      <script src="blah.js"></script>
-      <link href="app.css" rel="stylesheet" type="text/css">
-      </head>
-      <body class="body_class">
-      <div id="wrapper"><p class='message'>Something bad happened</p></div>
-      </body>
-      </html>
-    }
-
-    def test_should_not_replace_the_wrapper_using_the_app_response
-      assert_not_rendered_in_template "Something bad happened"
-    end
-
-    def test_should_include_default_non_404_error_message
-      assert_rendered_in_template "body .content header h1", "We seem to be having a problem."
-    end
-
-    def test_should_replace_the_title_using_the_app_response
-      assert_rendered_in_template "head title", "406 Not Acceptable"
-    end
-  end
-
-  class Error410ResponseTest < SlimmerIntegrationTest
-    given_response 410, %{
-      <html>
-      <head><title>410 Gone</title>
-      <meta name="something" content="yes">
-      <script src="blah.js"></script>
-      <link href="app.css" rel="stylesheet" type="text/css">
-      </head>
-      <body class="body_class">
-      <div id="wrapper"><p class='message'>Something bad happened</p></div>
-      </body>
-      </html>
-    }
-
-    def test_should_not_replace_the_wrapper_using_the_app_response
-      assert_not_rendered_in_template "Something bad happened"
-    end
-
-    def test_should_include_default_410_error_message
-      assert_rendered_in_template "body .content header h1", "That's gone now, sorry."
-    end
-
-    def test_should_replace_the_title_using_the_app_response
-      assert_rendered_in_template "head title", "410 Gone"
-    end
-  end
-
-  class ArbitraryWrapperIdTest < SlimmerIntegrationTest
-
-    given_response 200, %{
-      <html>
-      <body>
-      <div id="custom_wrapper">The body of the page</div>
-      </body>
-      </html>
-    }, {}, {wrapper_id: "custom_wrapper"}
-
-    def test_should_replace_wrapper_with_custom_wrapper
-      assert_rendered_in_template "body #custom_wrapper", /^The body of the page/
-      assert_no_selector "#wrapper"
-    end
-  end
-
-  class StrippingHeadersTest < SlimmerIntegrationTest
-    def test_should_strip_all_slimmer_headers_from_final_response
-      given_response 200, %{
-        <html>
-        <body>
-        <div id="wrapper">The body of the page</div>
-        </body>
-        </html>
-      }, {
-        "#{Slimmer::Headers::HEADER_PREFIX}-Foo" => "Something",
-        "X-Custom-Header" => "Something else"
-      }
-
-      refute last_response.headers.has_key?("#{Slimmer::Headers::HEADER_PREFIX}-Foo")
-      assert_equal "Something else", last_response.headers["X-Custom-Header"]
-    end
-
-    def test_should_strip_slimmer_headers_even_when_skipping_slimmer
-      given_response 200, %{
-        <html>
-        <body>
-        <div id="wrapper">The body of the page</div>
-        </body>
-        </html>
-      }, {
-        "#{Slimmer::Headers::HEADER_PREFIX}-Foo" => "Something",
-        "X-Custom-Header" => "Something else",
-        Slimmer::Headers::SKIP_HEADER => "1"
-      }
-
-      refute last_response.headers.has_key?("#{Slimmer::Headers::HEADER_PREFIX}-Foo")
-      assert_equal "Something else", last_response.headers["X-Custom-Header"]
-    end
-  end
-end