akamai_rspec 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06d8b35c313b71c7d4d8723af6c0f6fac7884ec6
+  data.tar.gz: acddb3b50759171eb123010e287a1cf842cc1bb8
+SHA512:
+  metadata.gz: e9c998292a3c9b68c4e125b43e318b062019903408159916cdc994fc63bf7b58e432190b7ab7dda0f3c3f1d66ef073c8d4c298a87c3749536b2b78a9cfc559d0
+  data.tar.gz: 57043ea5fa5f880a19bd2d964adcbb4970adc28b7bbe9812157186c32e76e6f0fe840703c0b4670743c5c4fbed1548e62150a2a7183ccc029c307b1a0f118357

data/lib/akamai_rspec/akamai_headers.rb

@@ -0,0 +1,7 @@
+module AkamaiHeaders
+  def 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/caching.rb

@@ -0,0 +1,54 @@
+require 'rspec'
+require 'securerandom'
+
+RSpec::Matchers.define :be_cacheable do
+  match do |url|
+    response = RestClient::Request.responsify url
+    x_check_cacheable(response, 'YES')
+    response.code == 200
+  end
+end
+
+module RSpec::Matchers
+  alias_method :be_cachable, :be_cacheable
+end
+
+RSpec::Matchers.define :have_no_cache_set do
+  match do |url|
+    response = RestClient::Request.responsify url
+    cache_control = response.headers[:cache_control]
+    fail('Cache-Control has been set') unless cache_control == 'no-cache'
+    true
+  end
+end
+
+RSpec::Matchers.define :not_be_cached do
+  match do |url|
+    response = RestClient::Request.responsify url
+    x_check_cacheable(response, 'NO')
+    response = RestClient::Request.responsify response.args[:url]  # again to prevent spurious cache miss
+
+    not_cached = response.headers[:x_cache] =~ /TCP(\w+)?_MISS/
+    unless not_cached
+      fail("x_cache header does not indicate an origin hit: '#{response.headers[:x_cache]}'")
+    end
+    response.code == 200 && not_cached
+  end
+end
+
+RSpec::Matchers.define :be_tier_distributed do
+  match do |url|
+    response = RestClient::Request.request_cache_miss(url)
+    tiered = !response.headers[:x_cache_remote].nil?
+    fail('No X-Cache-Remote header in response') unless tiered
+    response.code == 200 && tiered
+  end
+end
+
+def x_check_cacheable(response, should_be_cacheable)
+  x_check_cacheable = response.headers[:x_check_cacheable]
+  fail('No X-Check-Cacheable header?') if x_check_cacheable.nil?
+  unless (x_check_cacheable == should_be_cacheable)
+    fail("X-Check-Cacheable header is: #{x_check_cacheable} expected #{should_be_cacheable}")
+  end
+end

data/lib/akamai_rspec/matchers/honour_origin_headers.rb

@@ -0,0 +1,124 @@
+require 'rspec'
+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 = RestClient::Request.responsify url
+    origin_response = origin_response(origin)
+    check_cache_control(origin_response, akamai_response, headers)
+    check_expires(origin_response, akamai_response, headers)
+    true
+  end
+end
+
+def fix_date_header(origin_response)
+  origin_response.headers[:date] = Time.now.httpdate unless origin_response.headers[:date]
+  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/matchers.rb

@@ -0,0 +1,40 @@
+require 'securerandom'
+require 'rspec'
+require_relative 'redirects'
+require_relative 'caching'
+require_relative 'non_akamai'
+require_relative 'honour_origin_headers'
+include AkamaiHeaders
+
+RSpec::Matchers.define :x_cache_key_contains do |contents|
+  match do |url|
+    response = RestClient::Request.responsify url
+    fail 'No X-Cache-Key header' if response.headers[:x_cache_key].nil?
+    unless response.headers[:x_cache_key].include?(contents)
+      fail("x_cache_key has value '#{response.headers[:x_cache_key]}' which doesn't include '#{contents}'")
+    end
+    response.code == 200 && response.headers[:x_cache_key].include?(contents)
+  end
+end
+
+module RSpec::Matchers
+  alias_method :be_served_from_origin, :x_cache_key_contains
+  alias_method :have_cp_code, :x_cache_key_contains
+end
+
+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

data/lib/akamai_rspec/matchers/non_akamai.rb

@@ -0,0 +1,67 @@
+require 'rspec'
+require 'socket'
+require 'openssl'
+
+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
+
+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
+
+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
+
+RSpec::Matchers.define :be_successful do
+  match do |url|
+    response = RestClient::Request.responsify url
+    fail('Response was not successful') unless response.code == 200
+    true
+  end
+end
+
+RSpec::Matchers.define :be_verifiably_secure do (verify = OpenSSL::SSL::VERIFY_PEER)
+  match do |url|
+    begin
+      RestClient::Request.execute(method: :get, url: url, verify_ssl: verify)
+      true
+    rescue => e
+      raise("#{url} could not be verified as secure, :sad_panda: #{e.message}")
+    end
+  end
+end
+
+RSpec::Matchers.define :be_gzipped do
+  match do |response_or_url|
+    response = RestClient::Request.responsify response_or_url
+    response.headers[:content_encoding] == 'gzip'
+  end
+end
+
+RSpec::Matchers.define :have_cookie do |cookie|
+  match do |response_or_url|
+    response = RestClient::Request.responsify response_or_url
+    unless response.cookies[cookie]
+      fail("Cookie #{cookie} not in #{response.cookies}")
+    end
+    response.cookies[cookie]
+  end
+end

data/lib/akamai_rspec/matchers/redirects.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+
+RSpec::Matchers.define :be_permanently_redirected_to do |expected_location|
+  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
+
+RSpec::Matchers.define :be_temporarily_redirected_with_trailing_slash do
+  match do |url|
+    redirect(url, url + '/', 302)
+  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})"
+  end
+  true
+end

data/lib/akamai_rspec/request.rb

@@ -0,0 +1,89 @@
+require 'rest-client'
+require 'akamai_rspec'
+
+module RestClient
+  class Request
+    @@akamai_network = 'prod'
+    @@akamai_stg_domain = 'overwrite me'
+    @@akamai_prod_domain = 'overwrite me'
+
+    def self.domain
+      env = @@akamai_network
+      case env.downcase
+      when 'staging'
+        @@akamai_stg_domain
+      else
+        @@akamai_prod_domain
+      end
+    end
+
+    def self.akamai_network(env)
+      @@akamai_network = env
+    end
+
+    def self.stg_domain(domain)
+      @@akamai_stg_domain = domain
+    end
+
+    def self.prod_domain(domain)
+      @@akamai_prod_domain = domain
+    end
+
+    def self.http_url(url)
+      url = "/#{url}" unless url.start_with?('/')
+      "http://#{domain}#{url}"
+    end
+
+    def self.https_url(url)
+      url = "/#{url}" unless url.start_with?('/')
+      "https://#{domain}#{url}"
+    end
+
+    # Define the Host header and join the Akamai headers
+    def self.options
+      akamai_debug_headers
+    end
+
+    # Make requests to the right network
+    def self.http_get(url, options, cookies = {})
+      do_get(url, options, cookies, false)
+    end
+
+    def self.https_get(url, options, cookies = {})
+      do_get(url, options, cookies, true)
+    end
+
+    def self.do_get(url, options, cookies = {}, is_secure)
+      if is_secure
+        base_url = https_url(url)
+      else
+        base_url = http_url(url)
+      end
+      headers = options.merge(akamai_debug_headers).merge(cookies)
+      do_get_no_ssl(base_url, headers) { |response, _, _| response }
+    end
+
+    def self.do_get_no_ssl(url, additional_headers = {}, &block)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      RestClient::Request.execute(options.merge(
+        method: :get,
+        url: url,
+        verify_ssl: false,
+        headers: headers), &(block || @block))
+    end
+
+    def self.responsify(maybe_a_url)
+      if maybe_a_url.is_a? RestClient::Response
+        maybe_a_url
+      else
+        RestClient.get(maybe_a_url, akamai_debug_headers)
+      end
+    end
+
+    def self.request_cache_miss(url)
+      url += url.include?('?') ? '&' : '?'
+      url += SecureRandom.hex
+      RestClient.get(url, akamai_debug_headers)
+    end
+  end
+end

data/lib/akamai_rspec.rb

@@ -0,0 +1,3 @@
+require 'akamai_rspec/akamai_headers'
+require 'akamai_rspec/matchers/matchers'
+require 'akamai_rspec/request'

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: akamai_rspec
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Bianca Gibson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: 
+email: bianca.gibson@rea-group.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/akamai_rspec.rb
+- lib/akamai_rspec/akamai_headers.rb
+- lib/akamai_rspec/matchers/caching.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/request.rb
+homepage: 
+licenses: []
+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.1.11
+signing_key: 
+specification_version: 4
+summary: Test your akamai configuration with rspec
+test_files: []