akamai_rspec 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb49bd44abd110079985c0b84fa3dcd5c5c792c0
-  data.tar.gz: 27e1ebf081198f4a3cd07401ea6c8850a901ef90
+  metadata.gz: b6ca676a572b65fda62bd771e10b8472cdcb1704
+  data.tar.gz: e782f1e731582d5feb4270fbace5d6fef0eb4b46
 SHA512:
-  metadata.gz: 66a85bda03be573909a293684fbd98cf41b221a2b3201ddbda984bc02801cda7915fa12b9f95aa89db5dd605f9c77f37427abb057e8016d0de25a470ea1f5571
-  data.tar.gz: 34c2714e8b34e4ef63e3795133fd5e9df6e9c44559a521d19410e7cb5f9f088f1fd38bc371f1aa28f36d5ab5ea877f03ecec3d80483aff82cc7025d6f63e812a
+  metadata.gz: 6f58ba2ed53d2f7edcb81f449b9e658940f69c6a7aa1cd9e938d34ad6ab3a48597325791f2b95fe157c57b62b5913668fc4e5091bc619a65b7bf4fa24b8d140f
+  data.tar.gz: 371fbd6072b3a66a3e2db22d1b6186558a898f2448e799bfad310a9983939c79e7956e9d28ab37b14ef830276c3bbc8de2443da9d52efc5d1e692343c6049f82

data/lib/akamai_rspec.rb

@@ -1,4 +1,6 @@
-require 'akamai_rspec/akamai_headers'
-require 'akamai_rspec/matchers/matchers'
+require 'akamai_rspec/matchers'
 require 'akamai_rspec/request'
 require 'akamai_rspec/response'
+
+module AkamaiRSpec
+end

data/lib/akamai_rspec/helpers/cache_headers.rb

@@ -0,0 +1,17 @@
+
+module AkamaiRSpec
+  module Helpers
+    module CacheHeaders
+      X_CACHE_HEADERS = [:x_true_cache_key, :x_cache_key]
+
+      def x_cache_headers
+        X_CACHE_HEADERS
+      end
+
+      def cache_headers
+        x_cache_headers.map {|key| @response.headers[key] }
+      end
+
+    end
+  end
+end

data/lib/akamai_rspec/helpers/chainable_redirect.rb

@@ -0,0 +1,42 @@
+
+module AkamaiRSpec
+  module Helpers
+    module ChainableRedirect
+      def self.included(other)
+        other.chain :then do |matcher|
+          (@and_then_matchers ||= []).push(matcher)
+        end
+      end
+
+      def with_and_without_tls(url)
+        url = "http://#{url}" unless URI(url).scheme
+        url = url.gsub(/^https:/i, 'http:')
+        secure = url.gsub(/^http:/i, 'https:')
+        return secure, url
+      end
+
+      def redirect(url, expected_location, expected_response_code)
+        response = AkamaiRSpec::Request.get(url)
+        fail "Response was #{response.inspect}, expected code #{expected_response_code}" unless response.code == expected_response_code
+        unless expected_location === response.headers[:location]
+          fail "redirect location was #{response.headers[:location]} (expected #{expected_location})"
+        end
+
+        if @and_then_matchers
+          begin
+            @and_then_matchers.each {|matcher| expect(response.headers[:location]).to matcher}
+          rescue Exception => e
+            @and_then_error = e
+            return false
+          end
+        end
+
+        true
+      end
+
+      def failure_message
+        @and_then_error || super
+      end
+    end
+  end
+end

data/lib/akamai_rspec/matchers.rb

@@ -0,0 +1,15 @@
+require 'securerandom'
+require 'rspec'
+
+module AkamaiRSpec
+  module Matchers
+    extend RSpec::Matchers::DSL
+  end
+end
+
+require_relative 'matchers/redirects'
+require_relative 'matchers/caching'
+require_relative 'matchers/non_akamai'
+require_relative 'matchers/honour_origin_headers'
+require_relative 'matchers/x_cache_headers'
+require_relative 'matchers/forward_to_index'

data/lib/akamai_rspec/matchers/caching.rb

@@ -1,44 +1,68 @@
 require 'rspec'
 require 'securerandom'
-require 'akamai_rspec/akamai_headers'
-
-RSpec::Matchers.define :be_cacheable do |opts={request_count: 10}|
-  match do |url|
-    responses = [1..opts[:request_count]].map { AkamaiRSpec::Request.get_with_debug_headers url }
-
-    responses.any? do |response|
-      fail("Error fetching #{url}: #{response}") if response.code != 200
-      (
-        (response.headers[:x_cache] =~ /TCP(\w+)?_HIT/) and not
-        (response.headers[:x_cache] =~ /TCP_REFRESH/)
-      )
+require 'akamai_rspec/request'
+
+module AkamaiRSpec
+  module Matchers
+    define :be_cacheable do |request_count: 4, headers: {}, allow_refresh: false|
+      match do |url|
+        @responses = (1..request_count).map {
+          AkamaiRSpec::Request.get url, headers
+        }
+
+        @responses.any? do |response|
+          fail("Error fetching #{url}: #{response}") if response.code != 200
+          return allow_refresh if refresh_hit? response
+          hit?(response)
+        end
+      end
+
+      def refresh_hit?(response)
+        response.headers[:x_cache] =~ /TCP_REFRESH/
+      end
+
+      def hit?(response)
+        response.headers[:x_cache] =~ /TCP(\w+)?_HIT/
+      end
+
+      def suggest_allow_refresh?(allow_refresh)
+        !allow_refresh &&
+        !@responses.any?(&method(:hit?)) &&
+        @responses.any?(&method(:refresh_hit?))
+      end
+
+      description do
+        msg = "to be cacheable (got #{cache_headers} from #{@responses.length} requests)"
+        msg += ". Try setting 'allow_refresh: true'." if suggest_allow_refresh?(allow_refresh)
+        msg
+      end
+
+      def cache_headers
+        @responses.map {|response| response.headers[:x_cache] }
+      end
     end
-  end
-end
 
-module RSpec::Matchers
-  alias_method :be_cachable, :be_cacheable
-  alias_method :be_cached, :be_cacheable
-  define_negated_matcher :not_be_cached, :be_cached
-end
+    alias_method :be_cachable, :be_cacheable
+    alias_method :be_cached, :be_cacheable
 
-RSpec::Matchers.define :have_no_cache_set do
-  match do |url|
-    response = AkamaiRSpec::Request.get url
-    cache_control = response.headers[:cache_control]
-    return cache_control == 'no-cache'
-  end
-end
+    define :have_no_cache_set do
+      match do |url|
+        response = AkamaiRSpec::Request.get url
+        cache_control = response.headers[:cache_control]
+        return cache_control == 'no-cache'
+      end
+    end
 
+    define :be_tier_distributed do
+      match do |url|
+        response = AkamaiRSpec::Request.get_cache_miss(url)
+        @tiered = !response.headers[:x_cache_remote].empty?
+        response.code == 200 && @tiered
+      end
 
-RSpec::Matchers.define :be_tier_distributed do
-  match do |url|
-    response = AkamaiRSpec::Request.get_cache_miss(url)
-    @tiered = !response.headers[:x_cache_remote].nil?
-    response.code == 200 && @tiered
-  end
-  description do
-    "be tier distributed (as indicated by the presence of an X-Cache-Remote header in response)"
+      description do
+        "be tier distributed (as indicated by the presence of an X-Cache-Remote header in response)"
+      end
+    end
   end
 end
-

data/lib/akamai_rspec/matchers/forward_to_index.rb

@@ -0,0 +1,20 @@
+
+module AkamaiRSpec
+  module Matchers
+    define :be_forwarded_to_index do |channel|
+      match do |url|
+        response = Request.get(url)
+        session_info = response.headers[:x_akamai_session_info]
+        if session_info.nil?
+          fail("x-akamai-session-info not found in the headers '#{response.headers}'")
+        end
+        outcome_attribute = session_info.find { |header| header.include? 'AKA_PM_FWD_URL' }
+        if outcome_attribute.nil?
+          fail("AKA_PM_FWD_URL not found in the x-akamai-session-info header '#{session_info}'")
+        end
+        outcome_url = outcome_attribute.split('value=')[1]
+        response.code == 200 && outcome_url == "#{channel}"
+      end
+    end
+  end
+end

data/lib/akamai_rspec/matchers/honour_origin_headers.rb

@@ -3,122 +3,130 @@ require 'set'
 require 'time'
 require 'uri'
 
-RSpec::Matchers.define :honour_origin_cache_headers do |origin, headers|
-  header_options = [:cache_control, :expires, :both]
-  headers ||= :both
-  fail("Headers must be one of: #{header_options}") unless header_options.include? headers
-
-  match do |url|
-    akamai_response = AkamaiRSpec::Request.get url
-    origin_response = origin_response(origin)
-    check_cache_control(origin_response, akamai_response, headers)
-    check_expires(origin_response, akamai_response, headers)
-    true
+module AkamaiRSpec
+  module Matchers
+
+    define :honour_origin_cache_headers do |origin, headers=:both|
+      header_options = [:cache_control, :expires, :both]
+      fail("Headers must be one of: #{header_options}") unless header_options.include? headers
+
+      match do |url|
+        akamai_response = AkamaiRSpec::Request.get url
+        url = "http://" + url unless url =~ /^http/
+        origin_url = URI(url)
+        origin_url.host = URI(origin).hostname || origin
+        origin_response = origin_response(origin_url.to_s)
+        check_cache_control(origin_response, akamai_response, headers)
+        check_expires(origin_response, akamai_response, headers)
+        true
+      end
+
+      def fix_date_header(origin_response)
+        origin_response.headers[:date] ||= Time.now.httpdate
+        origin_response
+      end
+
+      def origin_response(origin)
+        fix_date_header(RestClient::Request.execute(method: :get, url: origin, verify_ssl: false))
+      end
+
+      def clean_cc_directives(origin_response, akamai_response)
+        origin_cc_directives = origin_response.headers[:cache_control].split(/[, ]+/).to_set
+        akamai_cc_directives = akamai_response.headers[:cache_control].split(/[, ]+/).to_set
+
+        origin_cc_directives.delete 'must-revalidate' # as Akamai does no pass it on
+        return origin_cc_directives, akamai_cc_directives
+      end
+
+      def cc_directives(origin_response, akamai_response)
+        origin_cc, akamai_cc = clean_cc_directives(origin_response, akamai_response)
+        check_cc(origin_cc, akamai_cc) unless (origin_cc & ['no-store', 'no-cache']).empty?
+        return origin_cc, akamai_cc
+      end
+
+      def check_and_clean_header(origin_cc, akamai_cc, expected)
+        unless akamai_cc.include? expected
+          fail "Akamai was expected to, but did not, add 'Cache-Control: #{expected}' as Origin sent 'no-store' or 'no-cache'"
+        end
+        akamai_cc.delete expected unless origin_cc.include? expected
+        akamai_cc
+      end
+
+      def check_cc(origin_cc, akamai_cc)
+        ['no-store', 'max-age=0'].each do |expected|
+          akamai_cc = check_and_clean_header(origin_cc, akamai_cc, expected)
+        end
+        return origin_cc, akamai_cc
+      end
+
+      def max_age(cc_directives)
+        cc_directives.detect { |d| d.start_with? 'max-age=' }
+      end
+
+      def max_age_to_num(max_age)
+        max_age.split('=').last.to_i
+      end
+
+      def clean_max_age(cc_directives)
+        max_age = max_age(cc_directives)
+        cc_directives.delete max_age if max_age
+        return max_age_to_num(max_age), cc_directives
+      end
+
+      def check_max_age(origin_cc_directives, akamai_cc_directives)
+        origin_max_age, origin_cc_directives = clean_max_age(origin_cc_directives)
+        akamai_max_age, akamai_cc_directives = clean_max_age(akamai_cc_directives)
+        if akamai_max_age > origin_max_age
+          fail "Akamai sent a max-age greater than Origin's: #{akamai_max_age} > #{origin_max_age}"
+        end
+        return origin_cc_directives, akamai_cc_directives
+      end
+
+      def validate_akamai_dropped(origin_cc, akamai_cc)
+        dropped = origin_cc - akamai_cc
+        unless dropped.empty?
+          fail "Origin sent 'Cache-Control: #{dropped.to_a.join ','}', but Akamai did not."
+        end
+      end
+
+      def validate_akamai_added(origin_cc, akamai_cc)
+        added = akamai_cc - origin_cc
+        unless added.empty?
+          fail "Akamai unexpectedly added 'Cache-Control: #{added.to_a.join ','}'"
+        end
+      end
+
+      def check_cache_control(origin_response, akamai_response, headers)
+        if [:both, :cache_control].include? headers
+          origin_cc, akamai_cc = cc_directives(origin_response, akamai_response)
+          origin_cc, akamai_cc = check_max_age(origin_cc, akamai_cc)
+          validate_akamai_dropped(origin_cc, akamai_cc)
+          validate_akamai_added(origin_cc, akamai_cc)
+        end
+      end
+
+      def check_expires(origin_response, akamai_response, headers)
+        if [:both, :expires].include? headers
+          origin_expires, akamai_expires = expires(origin_response, akamai_response)
+          validate_expires(origin_expires, akamai_expires)
+        end
+      end
+
+      def validate_expires(origin, akamai)
+        unless akamai.to_i == origin.to_i
+          fail "Origin sent 'Expires: #{origin}' but Akamai sent 'Expires: #{akamai}'"
+        end
+      end
+
+      def expires(origin_response, akamai_response)
+        return origin_expires(origin_response), Time.httpdate(akamai_response.headers[:expires])
+      end
+
+      def origin_expires(origin_response)
+        expires = origin_response.headers[:expires]
+        expires == '0' ? Time.httpdate(origin_response.headers[:date]) : Time.httpdate(expires)
+      end
+
+    end
   end
 end
-
-def fix_date_header(origin_response)
-  origin_response.headers[:date] ||= Time.now.httpdate
-  origin_response
-end
-
-def origin_response(origin)
-  fix_date_header(RestClient::Request.execute(method: :get, url: origin, verify_ssl: false))
-end
-
-def clean_cc_directives(origin_response, akamai_response)
-  origin_cc_directives = origin_response.headers[:cache_control].split(/[, ]+/).to_set
-  akamai_cc_directives = akamai_response.headers[:cache_control].split(/[, ]+/).to_set
-
-  origin_cc_directives.delete 'must-revalidate' # as Akamai does no pass it on
-  return origin_cc_directives, akamai_cc_directives
-end
-
-def cc_directives(origin_response, akamai_response)
-  origin_cc, akamai_cc = clean_cc_directives(origin_response, akamai_response)
-  check_cc(origin_cc, akamai_cc) unless (origin_cc & ['no-store', 'no-cache']).empty?
-  return origin_cc, akamai_cc
-end
-
-def check_and_clean_header(origin_cc, akamai_cc, expected)
-  unless akamai_cc.include? expected
-    fail "Akamai was expected to, but did not, add 'Cache-Control: #{expected}' as Origin sent 'no-store' or 'no-cache'"
-  end
-  akamai_cc.delete expected unless origin_cc.include? expected
-  akamai_cc
-end
-
-def check_cc(origin_cc, akamai_cc)
-  ['no-store', 'max-age=0'].each do |expected|
-    akamai_cc = check_and_clean_header(origin_cc, akamai_cc, expected)
-  end
-  return origin_cc, akamai_cc
-end
-
-def max_age(cc_directives)
-  cc_directives.detect { |d| d.start_with? 'max-age=' }
-end
-
-def max_age_to_num(max_age)
-  max_age.split('=').last.to_i
-end
-
-def clean_max_age(cc_directives)
-  max_age = max_age(cc_directives)
-  cc_directives.delete max_age if max_age
-  return max_age_to_num(max_age), cc_directives
-end
-
-def check_max_age(origin_cc_directives, akamai_cc_directives)
-  origin_max_age, origin_cc_directives = clean_max_age(origin_cc_directives)
-  akamai_max_age, akamai_cc_directives = clean_max_age(akamai_cc_directives)
-  if akamai_max_age > origin_max_age
-    fail "Akamai sent a max-age greater than Origin's: #{akamai_max_age} > #{origin_max_age}"
-  end
-  return origin_cc_directives, akamai_cc_directives
-end
-
-def validate_akamai_dropped(origin_cc, akamai_cc)
-  dropped = origin_cc - akamai_cc
-  unless dropped.empty?
-    fail "Origin sent 'Cache-Control: #{dropped.to_a.join ','}', but Akamai did not."
-  end
-end
-
-def validate_akamai_added(origin_cc, akamai_cc)
-  added = akamai_cc - origin_cc
-  unless added.empty?
-    fail "Akamai unexpectedly added 'Cache-Control: #{added.to_a.join ','}'"
-  end
-end
-
-def check_cache_control(origin_response, akamai_response, headers)
-  if [:both, :cache_control].include? headers
-    origin_cc, akamai_cc = cc_directives(origin_response, akamai_response)
-    origin_cc, akamai_cc = check_max_age(origin_cc, akamai_cc)
-    validate_akamai_dropped(origin_cc, akamai_cc)
-    validate_akamai_added(origin_cc, akamai_cc)
-  end
-end
-
-def check_expires(origin_response, akamai_response, headers)
-  if [:both, :expires].include? headers
-    origin_expires, akamai_expires = expires(origin_response, akamai_response)
-    validate_expires(origin_expires, akamai_expires)
-  end
-end
-
-def validate_expires(origin, akamai)
-  unless akamai.to_i == origin.to_i
-    fail "Origin sent 'Expires: #{origin}' but Akamai sent 'Expires: #{akamai}'"
-  end
-end
-
-def expires(origin_response, akamai_response)
-  return origin_expires(origin_response), Time.httpdate(akamai_response.headers[:expires])
-end
-
-def origin_expires(origin_response)
-  expires = origin_response.headers[:expires]
-  expires == '0' ? Time.httpdate(origin_response.headers[:date]) : Time.httpdate(expires)
-end

data/lib/akamai_rspec/matchers/non_akamai.rb

@@ -3,76 +3,77 @@ require 'socket'
 require 'openssl'
 require 'uri'
 
-def check_ssl_serial(addr, port, url, serial)
-  cert_serial = ssl_cert(addr, port, url).serial.to_s(16).upcase
-  fail("Incorrect S/N of: #{cert_serial}") unless cert_serial == serial.upcase
-end
-
-def ssl_cert(addr, port, url)
-  ssl_client = ssl_client_for_verify_cert(TCPSocket.new(addr, port), addr, url)
-  # We get this after the request as we have layer 7 routing in Akamai
-  cert = OpenSSL::X509::Certificate.new(ssl_client.peer_cert)
-  ssl_client.sysclose
-  cert
-end
+module AkamaiRSpec
+  module Matchers
+    define :be_successful do |response_codes=(200..299)|
+      match do |url|
+        @response = AkamaiRSpec::Request.get url
+        response_codes === @response.code
+      end
 
-def dummy_request(url, addr)
-  "GET #{url} HTTP/1.1\r\n" \
-    'User-Agent: Akamai-Regression-Framework\r\n' \
-    "Host: #{addr}\r\n" \
-  'Accept: */*\r\n'
-end
+      failure_message do |url|
+        "Response #{@response} was not successful for #{url}"
+      end
+    end
 
-def ssl_client_for_verify_cert(tcp_client, addr, url)
-  ssl_client = OpenSSL::SSL::SSLSocket.new(tcp_client)
-  ssl_client.sync_close = true
-  ssl_client.connect
-  ssl_client.puts(dummy_request(url, addr))
-  ssl_client
-end
+    define :respond_with_headers do |headers|
+      match do |url|
+        @response = AkamaiRSpec::Request.get url
+        headers.each do |k, v|
+          fail "Expected header #{k} to be #{v}, got #{@response.headers[k]}" unless @response.headers[k] == v
+        end
+        true
+      end
+    end
 
-RSpec::Matchers.define :be_successful do
-  match do |url|
-    response = AkamaiRSpec::Request.get url
-    fail('Response was not successful') unless response.code == 200
-    true
-  end
-end
+    define :be_verifiably_secure do
+      match do |url|
+        return false if URI(url).scheme == "http"
+        url = "https://#{url}" unless URI(url).scheme
+        begin
+          # Avoid AkamaiRspec::Request as it turns off SSL checking
+          @response = RestClient::Request.execute(method: :get, url: url, verify_ssl: OpenSSL::SSL::VERIFY_PEER)
+          return true
+        rescue => e
+          @error = e
+          return false
+        end
+      end
 
-RSpec::Matchers.define :be_verifiably_secure do (verify = OpenSSL::SSL::VERIFY_PEER)
-  match do |url|
-    return false if URI(url).scheme == "http"
-    url = "https://#{url}" unless URI(url).scheme
-    begin
-      RestClient::Request.execute(method: :get, url: url, verify_ssl: verify)
-      return true
-    rescue => e
-      return false
+      failure_message do |url|
+        "got error #{@error} fetching #{@response}"
+      end
     end
-  end
-end
 
-RSpec::Matchers.define :be_gzipped do
-  match do |response_or_url|
-    response = AkamaiRSpec::Request.get_decode response_or_url
-    response.headers[:content_encoding] == 'gzip'
-  end
-end
+    define :be_gzipped do
+      match do |url|
+        @response = AkamaiRSpec::Request.get_decode url
+        @response.headers[:content_encoding] == 'gzip'
+      end
+      failure_message do |url|
+        "Expected #{url} to be gzipped (got #{@response})"
+      end
+    end
 
-RSpec::Matchers.define :have_cookie do |cookie|
-  match do |response_or_url|
-    response = AkamaiRSpec::Request.get response_or_url
-    unless response.cookies[cookie]
-      fail("Cookie #{cookie} not in #{response.cookies}")
+    define :have_cookie do |cookie, value=nil|
+      match do |response_or_url|
+        response = AkamaiRSpec::Request.get response_or_url
+        unless response.cookies[cookie]
+          fail("Cookie #{cookie} not in #{response.cookies}")
+        end
+        if value && response.cookies[cookie] != value
+          fail("Cookie #{cookie} was set to #{response.cookies[cookie]}, expected #{value}")
+        end
+        !!response.cookies[cookie]
+      end
     end
-    response.cookies[cookie]
-  end
-end
 
-RSpec::Matchers.define :be_forbidden do
-  match do |url|
-    response = AkamaiRSpec::Request.get url
-    fail('Response was not forbidden') unless response.code == 403
-    true
+    define :be_forbidden do
+      match do |url|
+        response = AkamaiRSpec::Request.get url
+        fail("Response #{response} was not forbidden") unless response.code == 403
+        true
+      end
+    end
   end
 end

data/lib/akamai_rspec/matchers/redirects.rb

@@ -1,28 +1,53 @@
 require 'rspec'
+require 'uri'
+require 'akamai_rspec/helpers/chainable_redirect'
 
-RSpec::Matchers.define :be_permanently_redirected_to do |expected_location|
-  match do |url|
-    redirect(url, expected_location, 301)
-  end
-end
+module AkamaiRSpec
+  module Matchers
+    define :be_permanently_redirected_to do |expected_location|
+      include AkamaiRSpec::Helpers::ChainableRedirect
+      match do |url|
+        redirect(url, expected_location, 301)
+      end
+    end
 
-RSpec::Matchers.define :be_temporarily_redirected_to do |expected_location|
-  match do |url|
-    redirect(url, expected_location, 302)
-  end
-end
+    define :be_temporarily_redirected_to do |expected_location|
+      include AkamaiRSpec::Helpers::ChainableRedirect
+      match do |url|
+        redirect(url, expected_location, 302)
+      end
+    end
 
-RSpec::Matchers.define :be_temporarily_redirected_with_trailing_slash do
-  match do |url|
-    redirect(url, url + '/', 302)
-  end
-end
+    define :redirect_http_to_https do |with: 301|
+      include AkamaiRSpec::Helpers::ChainableRedirect
+      match do |url|
+        secure, url = with_and_without_tls(url)
+        redirect(url, secure, with)
+      end
+    end
+
+    define :redirect_https_to_http do |with: 301|
+      include AkamaiRSpec::Helpers::ChainableRedirect
+      match do |url|
+        secure, url = with_and_without_tls(url)
+        redirect(secure, url, with)
+      end
+    end
+
+    define :redirect_to_add_trailing_slash do |with: 301|
+      include AkamaiRSpec::Helpers::ChainableRedirect
+      match do |url|
+        without_trailing_slash = url.gsub(/\/+$/, '')
+        with_trailing_slash = without_trailing_slash + "/"
+        redirect(without_trailing_slash, with_trailing_slash, with)
+      end
+    end
 
-def redirect(url, expected_location, expected_response_code)
-  response = RestClient.get(url) { |response, _, _| response }
-  fail "response was #{response.code}" unless response.code == expected_response_code
-  unless response.headers[:location] == expected_location
-    fail "redirect location was #{response.headers[:location]} (expected #{expected_location})"
+    define :be_temporarily_redirected_with_trailing_slash do
+      include AkamaiRSpec::Helpers::ChainableRedirect
+      match do |url|
+        redirect(url, url + '/', 302)
+      end
+    end
   end
-  true
 end

data/lib/akamai_rspec/matchers/x_cache_headers.rb

@@ -1,29 +1,35 @@
 require 'rspec'
+require 'akamai_rspec/helpers/cache_headers'
 
 module AkamaiRSpec
-  module Helpers
-    X_CACHE_HEADERS = [:x_true_cache_key, :x_cache_key]
+  module Matchers
+    define :be_served_from_origin do |contents|
+      include AkamaiRSpec::Helpers::CacheHeaders
 
-    def x_cache_headers
-      X_CACHE_HEADERS
+      match do |url|
+        @response = AkamaiRSpec::Request.get url
+        cache_headers.any? {|h| h.split("/").include? contents}
+      end
+
+      failure_message do |actual|
+        "expected \"#{actual}\" to be served from origin \"#{contents}\"; got #{@response} and the cache headers indicated '#{cache_headers.inspect}'"
+      end
     end
-  end
-end
 
-RSpec::Matchers.define :be_served_from_origin do |contents|
-  include AkamaiRSpec::Helpers
-  match do |url|
-    response = AkamaiRSpec::Request.get url
-    response.headers.any? { |key, value| x_cache_headers.include?(key) && value =~ /\/#{contents}\// } && \
-      response.code == 200
-  end
-end
+    define :have_cp_code do |contents|
+      include AkamaiRSpec::Helpers::CacheHeaders
+      match do |url|
+        @response = AkamaiRSpec::Request.get url
+        @response.code == 200 && cache_headers.any? do |value|
+          value.to_s.split("/").include? contents
+        end
+      end
 
-RSpec::Matchers.define :have_cp_code do |contents|
-  include AkamaiRSpec::Helpers
-  match do |url|
-    response = AkamaiRSpec::Request.get url
-    response.headers.any? { |key, value| x_cache_headers.include?(key) && value == contents } && \
-      response.code == 200
+      failure_message do |url|
+        headers = {}
+        x_cache_headers.each {|h| headers[h] = @response.headers[h] }
+        "Expected #{url} to have cp_code #{contents} but responded with #{headers.to_json}"
+      end
+    end
   end
 end

data/lib/akamai_rspec/request.rb

@@ -20,26 +20,42 @@ module AkamaiRSpec
       @@env = env
     end
 
-    def self.get(url)
-      new.get(url)
+    def self.get(url, headers={})
+      new.get(url, headers.merge(debug_headers))
     end
 
-    def self.get_with_debug_headers(url)
-      new.get(url, AkamaiHeaders.akamai_debug_headers)
+    def self.get_without_debug_headers(url, headers={})
+      new.get(url, headers)
     end
 
     def self.get_cache_miss(url)
       url += url.include?('?') ? '&' : '?'
       url += SecureRandom.hex
-      new.get(url, AkamaiHeaders.akamai_debug_headers)
+      get(url)
     end
 
     def self.get_decode(url)
-      response = new.get(url, AkamaiHeaders.akamai_debug_headers)
+      response = new.get(url, debug_headers.merge({'Accept-Encoding' => 'gzip'}))
       RestClient::Request.decode(response.headers[:content_encoding], response.body)
       response
     end
 
+    def self.debug_headers
+      {
+        pragma: [
+          'akamai-x-cache-on',
+          'akamai-x-cache-remote-on',
+          'akamai-x-check-cacheable',
+          'akamai-x-get-cache-key',
+          'akamai-x-get-extracted-values',
+          'akamai-x-get-nonces',
+          'akamai-x-get-ssl-client-session-id',
+          'akamai-x-get-true-cache-key',
+          'akamai-x-serial-no'
+        ].join(", ")
+      }
+    end
+
     def initialize
       @@env ||= 'prod'
 
@@ -47,7 +63,7 @@ module AkamaiRSpec
                 when 'staging'
                   if @@akamai_stg_domain.nil?
                     raise ArgumentError.new(
-                      "You must set the prod domain: AkamaiRSpec::Request.stg_domain = 'www.example.com.edgesuite.net'"
+                      "You must set the staging domain: AkamaiRSpec::Request.stg_domain = 'www.example.com.edgesuite.net'"
                     )
                   end
 
@@ -70,12 +86,18 @@ module AkamaiRSpec
     delegate [:parse_url_with_auth, :stringify_headers] => :@rest_client
 
     def get(url, headers = {})
-      if url.is_a? RestClient::Response
+      # DO NOT USE url.is_a? here - some versions of
+      # the JSON gem monkey patch String which causes it to match.
+
+      if url.class.ancestors.include? RestClient::Response
         return AkamaiRSpec::Response.new(url)
       end
 
-      uri = parse_url_with_auth(url)
+      if url.class.ancestors.include? AkamaiRSpec::Response
+        return url
+      end
 
+      uri = parse_url_with_auth(url)
       req = build_request(uri, stringify_headers(headers))
 
       req['Host'] = uri.hostname

data/lib/akamai_rspec/response.rb

@@ -6,6 +6,7 @@ module AkamaiRSpec
 
     def headers
       headers = Hash[@response.to_hash.map{ |k, v| [k.gsub(/-/,'_').downcase.to_sym, v] }]
+      headers.default = ""
       headers.each do |k, v|
         if v.is_a?(Array) && v.size == 1
           headers[k] = v.first
@@ -20,26 +21,36 @@ module AkamaiRSpec
     end
 
     def cookies
-      cookie_header = headers.to_hash[:set_cookie]
-      if cookie_header
-        if cookie_header.is_a?(Array)
-          cookies_string = cookie_header.collect do |header_value|
-            header_value.split('; ')
-          end
-          cookies_string.flatten!
-          cookies_array = cookies_string.collect { |c| c.split('=') }
-        else
-          cookies_array = [cookie_header.split('=')]
-        end
+      cookies = {}
 
-        Hash[cookies_array]
-      else
-        {}
+      [headers[:set_cookie]].flatten.each do |cookie|
+        name, value = cookie.split(/=/, 2)
+        cookies[name] = value
       end
+      cookies
     end
 
     def method_missing(method, *args)
       @response.send(method, *args)
     end
+
+    def to_s
+      case code
+      when 0..99
+        "Invalid status code #{code}"
+      when 100..199
+        "Informational: #{code}"
+      when 200..299
+        "Success: #{code}"
+      when 300..399
+        "Redirect #{code} to #{headers[:location]}"
+      when 400..499
+        "Client error #{code}"
+      when 500..599
+        "Server error #{code}"
+      else
+        "Unknown status code #{code}"
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: akamai_rspec
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Bianca Gibson
+- Daniel Heath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-21 00:00:00.000000000 Z
+date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -59,10 +60,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/akamai_rspec.rb
-- lib/akamai_rspec/akamai_headers.rb
+- lib/akamai_rspec/helpers/cache_headers.rb
+- lib/akamai_rspec/helpers/chainable_redirect.rb
+- lib/akamai_rspec/matchers.rb
 - lib/akamai_rspec/matchers/caching.rb
+- lib/akamai_rspec/matchers/forward_to_index.rb
 - lib/akamai_rspec/matchers/honour_origin_headers.rb
-- lib/akamai_rspec/matchers/matchers.rb
 - lib/akamai_rspec/matchers/non_akamai.rb
 - lib/akamai_rspec/matchers/redirects.rb
 - lib/akamai_rspec/matchers/x_cache_headers.rb

data/lib/akamai_rspec/akamai_headers.rb

@@ -1,7 +0,0 @@
-module AkamaiHeaders
-  def self.akamai_debug_headers
-    {
-      pragma: 'akamai-x-cache-on, akamai-x-cache-remote-on, akamai-x-check-cacheable, akamai-x-get-cache-key, akamai-x-get-extracted-values, akamai-x-get-nonces, akamai-x-get-ssl-client-session-id, akamai-x-get-true-cache-key, akamai-x-serial-no'
-    }
-  end
-end

data/lib/akamai_rspec/matchers/matchers.rb

@@ -1,25 +0,0 @@
-require 'securerandom'
-require 'rspec'
-require_relative 'redirects'
-require_relative 'caching'
-require_relative 'non_akamai'
-require_relative 'honour_origin_headers'
-require_relative 'x_cache_headers'
-include AkamaiHeaders
-
-RSpec::Matchers.define :be_forwarded_to_index do |channel|
-  match do |url|
-    response = RestClient.get(url, akamai_debug_headers)
-
-    session_info = response.raw_headers['x-akamai-session-info']
-    if session_info.nil?
-      fail("x-akamai-session-info not found in the headers '#{response.raw_headers}'")
-    end
-    outcome_attribute = session_info.find { |header| header.include? 'AKA_PM_FWD_URL' }
-    if outcome_attribute.nil?
-      fail("AKA_PM_FWD_URL not found in the x-akamai-session-info header '#{session_info}'")
-    end
-    outcome_url = outcome_attribute.split('value=')[1]
-    response.code == 200 && outcome_url == "#{channel}"
-  end
-end