cucumber-rest 0.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGZhNzhkMDJlMzgyZTFjMTNlNjUzM2VkODM2NjhiYjUxODc4ZWIxZA==
+  data.tar.gz: !binary |-
+    MmM1ZGIwMTQ2ZDlkNGQ3OWIwYTJjNzQxNWJiYzc3OWZiZTA2ODUwNg==
+SHA512:
+  metadata.gz: !binary |-
+    MTVlYjc2ZTFkN2ZmNGUwYmFjMDVlZmYyMzUzM2FkODU2NTNiMjFhY2ZlYTE0
+    ZDdhYzhkMzlmOGI1YTNmNzc2YTZiMzkxOTlhOGM1NjUyY2E0NmIyNzBjMzRi
+    MzljZmRkNTFlNmM5ZjdhNTY1NTFlNTg3YjRmMmVhNGE1ZjRmZWU=
+  data.tar.gz: !binary |-
+    NWNlNDBlMjgyOTcxODRjNzVkZDg4NGMxMTYwZjU2M2IzMTRhYzdkZmM0NzBi
+    ZjM5OTc4M2EzM2U2NzljYjA2MTE4NGQ2ZTBiZDExMjQwY2I4MzY4MDdmOGU1
+    ZTI3NmU5MTYwOGE2ZWRlZmMxYzkyOTgyNTBjZGM3YWU3MTZkOTM=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log

data/.rspec

@@ -0,0 +1,5 @@
+--no-color
+--require spec_helper
+--format progress -o log/spec.log
+--format html     -o log/spec.html
+-cfd

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.2
+deploy:
+  provider: rubygems
+  api_key:
+    secure: DfssT15CddiWJaakPGmBqroMixeyvSDtJsDa6dXW1qfO7gnoYQ1VGc0pevMs/1NsJBS/LDPGMN30Y+aTQ/JceiItp6O4LZaWN894C9+tXb3/9QKmTUFQkLqsb44lQeuRESPTtmtVKqMwbaLfiya6BActAfQvNdGY1JmBNAQsx8g=
+  gem: cucumber-rest
+  on:
+    repo: blinkboxbooks/cucumber-rest.rb
+    branch: master

data/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Change log
+
+## 0.1.10 ([#27](https://git.mobcastdev.com/TEST/cucumber-rest/pull/27) 2014-12-16 13:37:19)
+
+Step def for asserting HTTP 501 responses
+
+Patch
+
+ * Step def for asserting HTTP 501 responses
+
+## 0.1.9 ([#26](https://git.mobcastdev.com/TEST/cucumber-rest/pull/26) 2014-12-16 11:09:35)
+
+Add a step for checking we specifically return a HTTP 202
+
+Patch
+
+ * Adds a step def for checking HTTP 202 responses
+
+## 0.1.8 ([#25](https://git.mobcastdev.com/TEST/cucumber-rest/pull/25) 2014-12-10 16:31:08)
+
+Http 204 status codes
+
+Patch
+
+Add support for handling HTTP 204 responses, checking that the body is empty.
+
+Also whitespace changes because hard tabs are bad, mmkay?
+
+## 0.1.7 ([#24](https://git.mobcastdev.com/TEST/cucumber-rest/pull/24) 2014-12-08 16:47:02)
+
+Using `ensure_status` instead of `ensure_status_class`
+
+A patch to fix checking the status with the correct method.
+
+## 0.1.6 ([#23](https://git.mobcastdev.com/TEST/cucumber-rest/pull/23) 2014-12-08 16:18:09)
+
+Made the item specified that is being create non capturing
+
+A patch to make the user specified resource being created in the step's regex non-capturing.
+
+## 0.1.5 ([#22](https://git.mobcastdev.com/TEST/cucumber-rest/pull/22) 2014-12-01 14:58:07)
+
+adding step for checking 201 Created response
+
+patch: adding step for checking 201 Created response
+
+## 0.1.4 ([#21](https://git.mobcastdev.com/TEST/cucumber-rest/pull/21) 2014-10-14 16:38:44)
+
+RSpec 3
+
+### Improvements
+
+- Move to RSpec 3
+
+## 0.1.3 ([#20](https://git.mobcastdev.com/TEST/cucumber-rest/pull/20) 2014-10-13 10:21:36)
+
+Fix where the version file is read from
+
+Patch
+
+VERSION file location was misdefined as one level too deep. If the VERSION file can't be found in the right folder, default to a more sane "0.0.0".
+
+## 0.1.2 ([#19](https://git.mobcastdev.com/TEST/cucumber-rest/pull/19) 2014-10-09 17:28:41)
+
+410 Gone step
+
+Patch
+
+## 0.1.1 ([#18](https://git.mobcastdev.com/TEST/cucumber-rest/pull/18) 2014-07-15 10:52:31)
+
+CP-1598 - Make Cucumber-Rest stricter about what it considers a valid Date in HTTP headers
+
+Patch to make Cucumber-Rest fall back to using DateTime.httpdate as opposed to generic Date parsing; such that it's more in keeping with the HTTP RFCs
+
+## 0.1.0 ([#17](https://git.mobcastdev.com/TEST/cucumber-rest/pull/17) 2014-06-30 17:42:16)
+
+Moved to artifactory
+
+### New Features
+
+- Moved to Artifactory
+- Moved to using VERSION file.
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org/"
+
+gemspec

data/LICENCE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 blinkbox Books Ltd.
+
+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,3 @@
+# Cucumber::Rest
+
+A set of cucumber step definitions and helpers for testing RESTful APIs

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :build => :test
+task :test => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.10

data/cucumber-rest.gemspec

@@ -0,0 +1,33 @@
+($LOAD_PATH << File.expand_path("../lib", __FILE__)).uniq!
+require "cucumber/rest/version"
+
+Gem::Specification.new do |s|
+  s.name = "cucumber-rest"
+  s.version = Cucumber::Rest::VERSION
+  s.summary = "Cucumber steps and support for testing RESTful services."
+  s.description = "A set of Cucumber step definitions and support functions which encapsulate common RESTful functionality."
+  s.author = "blinkbox books"
+  s.email = "greg@blinkbox.com"
+  s.homepage = "http://www.blinkboxbooks.com"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split($/)
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.md"]
+
+  s.post_install_message = ":: Coded for blinkbox books :: Love books, love code? Get in touch ::"
+
+  s.add_runtime_dependency "activesupport", ">= 3.2"
+  s.add_runtime_dependency "cucumber", "~> 1.3"
+  s.add_runtime_dependency "multi_json", "~> 1.7"
+  s.add_runtime_dependency "rspec", "~> 3.0"
+  s.add_runtime_dependency "rack", "~> 1.5"
+  s.add_runtime_dependency "http_capture", "~> 0.0", ">= 0.0.4"
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake", "~> 10.1"
+
+  s.add_development_dependency "cucumber_spinner"
+end

data/lib/cucumber/rest/body.rb

@@ -0,0 +1,12 @@
+require 'http_capture'
+
+module Cucumber
+  module Rest
+    # Helper functions for the handling of response bodies
+    module Body
+      def self.ensure_empty(response: HttpCapture::RESPONSES.last)
+        raise "Request body was not empty:\n #{response.body}" if response.body.to_s.size != 0
+      end
+    end
+  end
+end

data/lib/cucumber/rest/caching.rb

@@ -0,0 +1,152 @@
+require "date"
+require "http_capture"
+
+module Cucumber
+  module Rest
+    # Helper functions for checking the cacheability of responses.
+    module Caching
+
+      class EmptyHTTPDateError < RuntimeError; end
+
+      # Ensures that a response is privately cacheable.
+      #
+      # This function uses a strict interpretation of RFC 2616 to ensure the widest interoperability with
+      # implementations, including HTTP 1.0.
+      #
+      # @param response [HttpCapture::Response] The response to check. If not supplied defaults to the last response.
+      # @param min_duration [Integer] The minimum permitted cache duration, in seconds.
+      # @param max_duration [Integer] The maximum permitted cache duration, in seconds.
+      # @param duration [Integer] The required cache duration, in seconds. Convenient if min and max are the same.
+      # @return [nil]
+      def self.ensure_response_is_publicly_cacheable(args = {})
+        response, min_duration, max_duration = extract_args(args)
+        ensure_cache_headers(response, false)
+
+        cache_control = parse_cache_control(response["Cache-Control"])
+        ensure_cache_directives(cache_control, "public", "max-age")
+        prohibit_cache_directives(cache_control, "private", "no-cache", "no-store")
+
+        age = response["Age"].to_i
+        date = parse_httpdate(response["Date"])
+        expires = parse_expires_httpdate(response["Expires"])
+        max_age = cache_control["max-age"]
+        expected_max_age = age + ((expires - date) * 24 * 3600).to_i
+        unless (max_age - expected_max_age).abs <= 1 # 1 second leeway
+          raise "Age, Date, Expires and Cache-Control:max-age are inconsistent"
+        end
+
+        ensure_cache_duration(max_age, min_duration, max_duration)
+      end
+
+      # Ensures that a response is privately cacheable.
+      #
+      # This function uses a strict interpretation of RFC 2616, including precedence rules for Date, Expires and
+      # Cache-Control:max-age to ensure the widest interoperability with implementations, including HTTP 1.0.
+      #
+      # @param response [HttpCapture::Response] The response to check. If not supplied defaults to the last response.
+      # @param min_duration [Integer] The minimum permitted cache duration, in seconds.
+      # @param max_duration [Integer] The maximum permitted cache duration, in seconds.
+      # @param duration [Integer] The required cache duration, in seconds. Convenient if min and max are the same.
+      # @return [nil]
+      def self.ensure_response_is_privately_cacheable(args = {})
+        response, min_duration, max_duration = extract_args(args)
+        ensure_cache_headers(response, false)
+
+        cache_control = parse_cache_control(response["Cache-Control"])
+        ensure_cache_directives(cache_control, "private", "max-age")
+        prohibit_cache_directives(cache_control, "public", "no-cache", "no-store")
+
+        date = parse_httpdate(response["Date"])
+        expires = parse_expires_httpdate(response["Expires"])
+        raise "Expires should not be later than Date" if expires && expires > date
+
+        ensure_cache_duration(cache_control["max-age"], min_duration, max_duration)
+      end
+
+      # Ensures that a response is not cacheable.
+      #
+      # This function uses a strict interpretation of RFC 2616, to ensure the widest interoperability with
+      # implementations, including HTTP 1.0.
+      #
+      # @param response [HttpCapture::Response] The response to check. If not supplied defaults to the last response.
+      # @return [nil]
+      def self.ensure_response_is_not_cacheable(args = {})
+        response, * = extract_args(args)
+        ensure_cache_headers(response, true)
+
+        cache_control = parse_cache_control(response["Cache-Control"])
+        ensure_cache_directives(cache_control, "no-store")
+        prohibit_cache_directives(cache_control, "public", "private", "max-age") # TODO: prohibit no-cache?
+
+        date = parse_httpdate(response["Date"])
+        expires = parse_expires_httpdate(response["Expires"]) rescue nil # invalid values are treated as < now, which is fine
+        raise "Expires should not be later than Date" if expires && expires > date
+      end
+
+      private
+
+      def self.extract_args(args)
+        response = args[:response] || HttpCapture::RESPONSES.last
+        if response.nil?
+          raise "There is no response to check. Have you required the right capture file from HttpCapture?"
+        end
+
+        min_duration = args[:min_duration] || args[:duration]
+        max_duration = args[:max_duration] || args[:duration]
+
+        return response, min_duration, max_duration
+      end
+
+      def self.ensure_cache_headers(response, pragma_nocache)
+        ["Cache-Control", "Date", "Expires"].each { |h| raise "Required header '#{h}' is missing" if response[h].nil? }
+
+        unless (/\bno-cache\b/ === response["Pragma"]) == pragma_nocache
+          raise "Pragma should #{pragma_nocache ? "" : "not "}include the 'no-cache' directive"
+        end
+      end
+
+      def self.parse_cache_control(cache_control)
+        cache_control.split(",").each_with_object({}) do |entry, hash|
+          key, value = entry.split("=", 2).map(&:strip)
+          hash[key] = value =~ /^\d+$/ ? value.to_i : value
+        end
+      end
+
+      def self.ensure_cache_directives(cache_control, *directives)
+        directives.each do |directive|
+          raise "Cache-Control should include the '#{directive}' directive" unless cache_control.has_key?(directive)
+        end
+      end
+
+      def self.prohibit_cache_directives(cache_control, *directives)
+        directives.each do |directive|
+          raise "Cache-Control should not include the '#{directive}' directive" if cache_control.has_key?(directive)
+        end
+      end
+
+      def self.ensure_cache_duration(actual, min_expected, max_expected)
+        if min_expected && actual < min_expected
+          raise "Cache duration is #{actual}s but expected at least #{min_expected}s"
+        end
+        if max_expected && actual > max_expected
+          raise "Cache duration is #{actual}s but expected no more than #{max_expected}s"
+        end
+      end
+
+      def self.parse_httpdate(date)
+        raise EmptyHTTPDateError, "Empty date value" if (date.empty? || date.nil?)
+        DateTime.httpdate(date)
+      end
+
+      def self.parse_expires_httpdate(date)
+        begin
+          parse_httpdate(date)
+        rescue EmptyHTTPDateError, ArgumentError => e
+          warn "Invalid Expires header value, handling as a past value"
+          DateTime.httpdate()
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/rest/status.rb

@@ -0,0 +1,37 @@
+require "http_capture"
+require "rack"
+
+module Cucumber
+  module Rest
+    # Helper functions for checking the cacheability of responses.
+    module Status
+
+      def self.ensure_status(expected, response: HttpCapture::RESPONSES.last)
+        actual = response.status
+        unless expected == actual
+          actual_name = Rack::Utils::HTTP_STATUS_CODES[actual]
+          expected_name = Rack::Utils::HTTP_STATUS_CODES[expected]
+          message = "Request status was #{actual} #{actual_name}; expected #{expected} #{expected_name}"
+          raise message
+        end
+      end
+
+      def self.ensure_status_class(expected, response: HttpCapture::RESPONSES.last)
+        min = case expected
+              when :informational then 100
+              when :success then 200
+              when :redirection then 300
+              when :client_error then 400
+              when :server_error then 500
+              end
+        max = min + 99
+        expected_range = min..max
+        actual = response.status
+        unless expected_range === actual
+          message = "Request status was #{actual} #{Rack::Utils::HTTP_STATUS_CODES[actual]}; expected #{expected_range}"
+          raise message
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rest/steps/caching.rb

@@ -0,0 +1,20 @@
+require "active_support/core_ext/numeric/time"
+require "cucumber/rest/caching"
+
+Then(/^(?:the response|it)? is publicly cacheable$/) do
+  Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable
+end
+
+Then(/^(?:the response|it)? is publicly cacheable for (a|\d+(?:\.\d+)?) (week|day|hour|minute|second)s?$/) do |num, unit|
+  num = num == "a" ? 1 : num.to_f
+  duration = num.send(unit.to_sym).to_i
+  Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(duration: duration)
+end
+
+Then(/^(?:the response|it)? is privately cacheable$/) do
+  Cucumber::Rest::Caching.ensure_response_is_privately_cacheable
+end
+
+Then(/^(?:the response|it)? is not cacheable$/) do
+  Cucumber::Rest::Caching.ensure_response_is_not_cacheable
+end

data/lib/cucumber/rest/steps/status.rb

@@ -0,0 +1,47 @@
+require "cucumber/rest/status"
+require "cucumber/rest/body"
+
+Then(/^the request (?:is|was) successful$/) do
+  Cucumber::Rest::Status.ensure_status_class(:success)
+end
+
+Then(/^the request (?:is|was) successful and (?:a resource|.+) was created$/) do
+  Cucumber::Rest::Status.ensure_status(201)
+end
+
+Then(/^the request (?:is|was) successfully accepted$/) do
+  Cucumber::Rest::Status.ensure_status(202)
+end
+
+Then(/^the request (?:is|was) successful and (?:no|an empty) response body is returned$/) do
+  Cucumber::Rest::Status.ensure_status(204)
+  Cucumber::Rest::Body.ensure_empty
+end
+
+Then(/^(?:it|the request) fails because it (?:is|was) invalid$/) do
+  Cucumber::Rest::Status.ensure_status(400)
+end
+
+Then(/^(?:it|the request) fails because (?:.+) (?:is|was|am|are) unauthori[sz]ed$/) do
+  Cucumber::Rest::Status.ensure_status(401)
+end
+
+Then(/^(?:it|the request) fails because (?:.+) (?:is|was) forbidden$/) do
+  Cucumber::Rest::Status.ensure_status(403)
+end
+
+Then(/^(?:it|the request) fails because the (?:.+) (?:is|was) not found$/) do
+  Cucumber::Rest::Status.ensure_status(404)
+end
+
+Then(/^(?:it|the request) fails because there (?:is|was) a conflict(?: with .+)?$/) do
+  Cucumber::Rest::Status.ensure_status(409)
+end
+
+Then(/^(?:it|the request) fails because the (?:.+) (?:is|was|has) gone$/) do
+  Cucumber::Rest::Status.ensure_status(410)
+end
+
+Then(/^(?:it|the request) fails because the (?:.+) (?:is|was) not implemented$/) do
+  Cucumber::Rest::Status.ensure_status(501)
+end

data/lib/cucumber/rest/steps.rb

@@ -0,0 +1,2 @@
+require "cucumber/rest/steps/caching"
+require "cucumber/rest/steps/status"

data/lib/cucumber/rest/version.rb

@@ -0,0 +1,5 @@
+module Cucumber
+  module Rest
+    VERSION = File.read(File.join(__dir__,"../../../VERSION")) rescue "0.0.0"
+  end
+end

data/lib/cucumber/rest.rb

@@ -0,0 +1,6 @@
+module Cucumber
+  module Rest
+  end
+end
+
+require "cucumber/rest/steps"

data/spec/cucumber/rest/body_spec.rb

@@ -0,0 +1,21 @@
+require "cucumber/rest/body"
+
+describe Cucumber::Rest::Body, :body do
+  context "#ensure_empty" do
+    def generate_response(body: nil)
+      response = MockResponse.new
+      response.body = body
+      response
+    end
+
+    it "does not raise an error when the response body is empty" do
+      response = generate_response(body: nil)
+      expect { Cucumber::Rest::Body.ensure_empty(response: response) }.to_not raise_error
+    end
+
+    it "raises an error when the response body is non-empty" do
+      response = generate_response(body: "something")
+      expect { Cucumber::Rest::Body.ensure_empty(response: response) }.to raise_error
+    end
+  end
+end

data/spec/cucumber/rest/caching_spec.rb

@@ -0,0 +1,304 @@
+require "cucumber/rest/caching"
+
+shared_examples "a cache header inspector" do |method, *header_names|
+
+  ["Cache-Control", "Date", "Expires"].each do |header_name|
+    it "raises an error when the #{header_name} header is missing" do
+      response = generate_response
+      response[header_name] = nil
+      expect {
+        Cucumber::Rest::Caching.send(method, { response: response })
+      }.to raise_error "Required header '#{header_name}' is missing"
+    end
+  end
+
+end
+
+describe Cucumber::Rest::Caching, :caching do
+
+  context "#ensure_response_is_publicly_cacheable" do
+
+    def generate_response(duration = 3600, date = DateTime.now, age = nil)
+      response = MockResponse.new
+      response["Cache-Control"] = "public, max-age=#{duration}"
+      response["Expires"] = (date + (duration / (24.0 * 3600))).strftime(RFC822_DATE_FORMAT)
+      if age
+        date += age / 86400.0
+        response["Age"] = age.to_s if age
+      end
+      response["Date"] = date.strftime(RFC822_DATE_FORMAT)
+      response.body = "test"
+      response
+    end
+
+    context "with cacheable responses" do
+      it_behaves_like "a cache header inspector", :ensure_response_is_publicly_cacheable
+
+      it "does not raise an error when the public cache headers are set correctly" do
+        duration = 3600
+        response = generate_response(duration)
+        Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response, duration: duration)
+      end      
+
+      it "does not raise an error when the public cache headers are set correctly, including an Age header" do
+        duration = 3600
+        response = generate_response(duration, DateTime.now, 243)
+        Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response, duration: duration)
+      end
+
+      ["max-age"].each do |directive| # TODO: Should include "public" 
+        it "raises an error when the Cache-Control header does not include the #{directive} directive" do
+          response = generate_response
+          response["Cache-Control"] = response["Cache-Control"].split(/\s*,\s*/).reject { |d| d =~ /^#{directive}($|=)/ }.join(", ")
+          expect {
+            Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response)
+          }.to raise_error "Cache-Control should include the '#{directive}' directive"
+        end
+      end
+
+      ["private", "no-cache", "no-store"].each do |directive|     
+        it "raises an error when the Cache-Control header includes the #{directive} directive" do
+          response = generate_response
+          response["Cache-Control"] << ", #{directive}"
+          expect {
+            Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response)
+          }.to raise_error "Cache-Control should not include the '#{directive}' directive"
+        end
+      end
+
+      it "raises an error when Date, Expires and Cache-Control:max-age are inconsistent" do
+        response = generate_response
+        response["Expires"] = DateTime.now.strftime(RFC822_DATE_FORMAT)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response)
+        }.to raise_error "Age, Date, Expires and Cache-Control:max-age are inconsistent"
+      end
+
+      it "raises an error when Age, Date, Expires and Cache-Control:max-age are inconsistent" do
+        response = generate_response
+        response["Age"] = "5"
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response)
+        }.to raise_error "Age, Date, Expires and Cache-Control:max-age are inconsistent"
+      end
+
+      it "raises an error when the Pragma header includes the no-cache directive" do
+        response = generate_response
+        response["Pragma"] = "no-cache"
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response)
+        }.to raise_error "Pragma should not include the 'no-cache' directive"
+      end
+
+    end
+
+    context "with application-level requirements" do
+
+      it "raises an error when the cache duration is higher than the expected duration" do
+        response = generate_response(3600)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response, duration: 1800)
+        }.to raise_error "Cache duration is 3600s but expected no more than 1800s"
+      end
+
+      it "raises an error when the cache duration is lower than the expected duration" do
+        response = generate_response(900)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_publicly_cacheable(response: response, duration: 1800)
+        }.to raise_error "Cache duration is 900s but expected at least 1800s"
+      end
+
+    end
+
+  end
+
+  context "#ensure_response_is_privately_cacheable" do
+
+    def generate_response(duration = 3600, date = DateTime.now)
+      response = MockResponse.new
+      response["Cache-Control"] = "private, max-age=#{duration}"
+      response["Date"] = date.strftime(RFC822_DATE_FORMAT)
+      response["Expires"] = date.strftime(RFC822_DATE_FORMAT)
+      response.body = "test"
+      response
+    end
+
+    context "with non-cacheable responses" do
+      it_behaves_like "a cache header inspector", :ensure_response_is_privately_cacheable
+
+      it "does not raise an error when the private cache headers are set correctly" do
+        duration = 3600
+        response = generate_response(duration)
+        Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response, duration: duration)
+      end
+
+      it "does not raise an error when the private cache headers are set correctly, with Expires as -1" do
+        duration = 3600
+        response = generate_response(duration)
+        response["Expires"] = "-1" # invalid, but should be treated as in the past (i.e. already expired)
+        Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response, duration: duration)
+      end
+
+      ["private", "max-age"].each do |directive|     
+        it "raises an error when the Cache-Control header does not include the #{directive} directive" do
+          response = generate_response
+          response["Cache-Control"] = response["Cache-Control"].split(/\s*,\s*/).reject { |d| d =~ /^#{directive}($|=)/ }.join(", ")
+          expect {
+            Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response)
+          }.to raise_error "Cache-Control should include the '#{directive}' directive"
+        end
+      end
+
+      ["public", "no-cache", "no-store"].each do |directive|     
+        it "raises an error when the Cache-Control header includes the #{directive} directive" do
+          response = generate_response
+          response["Cache-Control"] << ", #{directive}"
+          expect {
+            Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response)
+          }.to raise_error "Cache-Control should not include the '#{directive}' directive"
+        end
+      end
+
+      it "raises an error when Expires is a valid date later than Date" do
+        response = generate_response
+        response["Expires"] = (DateTime.now + 10).strftime(RFC822_DATE_FORMAT)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response)
+        }.to raise_error "Expires should not be later than Date"
+      end
+
+      it "raises an error when the Pragma header includes the no-cache directive" do
+        response = generate_response
+        response["Pragma"] = "no-cache"
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response)
+        }.to raise_error "Pragma should not include the 'no-cache' directive"
+      end
+
+    end
+
+    context "with application-level requirements" do
+
+      it "raises an error when the cache duration is higher than the expected duration" do
+        response = generate_response(3600)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response, duration: 1800)
+        }.to raise_error "Cache duration is 3600s but expected no more than 1800s"
+      end
+
+      it "raises an error when the cache duration is lower than the expected duration" do
+        response = generate_response(900)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_privately_cacheable(response: response, duration: 1800)
+        }.to raise_error "Cache duration is 900s but expected at least 1800s"
+      end
+
+    end
+
+  end
+
+  context "#ensure_response_is_not_cacheable" do
+
+    def generate_response(date = DateTime.now)
+      response = MockResponse.new
+      response["Cache-Control"] = "no-store"
+      response["Date"] = date.strftime(RFC822_DATE_FORMAT)
+      response["Expires"] = date.strftime(RFC822_DATE_FORMAT)
+      response["Pragma"] = "no-cache"
+      response.body = "test"
+      response
+    end
+
+    context "with non-cacheable responses" do
+      it_behaves_like "a cache header inspector", :ensure_response_is_not_cacheable
+
+      it "does not raise an error when the prevent cache headers are set correctly" do
+        Cucumber::Rest::Caching.ensure_response_is_not_cacheable(response: generate_response)
+      end
+
+      it "does not raise an error when the public cache headers are set correctly, with Expires as -1" do
+        response = generate_response
+        response["Expires"] = "-1" # invalid, but should be treated as in the past (i.e. already expired)
+        Cucumber::Rest::Caching.ensure_response_is_not_cacheable(response: response)
+      end
+
+      ["no-store"].each do |directive|     
+        it "raises an error when the Cache-Control header does not include the #{directive} directive" do
+          response = generate_response
+          response["Cache-Control"] = response["Cache-Control"].split(/\s*,\s*/).reject { |d| d =~ /^#{directive}($|=)/ }.join(", ")
+          expect {
+            Cucumber::Rest::Caching.ensure_response_is_not_cacheable(response: response)
+          }.to raise_error "Cache-Control should include the '#{directive}' directive"
+        end
+      end
+
+      ["public", "private", "max-age"].each do |directive|     
+        it "raises an error when the Cache-Control header includes the #{directive} directive" do
+          response = generate_response
+          response["Cache-Control"] << ", #{directive}"
+          expect {
+            Cucumber::Rest::Caching.ensure_response_is_not_cacheable(response: response)
+          }.to raise_error "Cache-Control should not include the '#{directive}' directive"
+        end
+      end
+
+      it "raises an error when Expires is a valid date later than Date" do
+        response = generate_response
+        response["Expires"] = (DateTime.now + 10).strftime(RFC822_DATE_FORMAT)
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_not_cacheable(response: response)
+        }.to raise_error "Expires should not be later than Date"
+      end
+
+      it "raises an error when the Pragma header does not include the no-cache directive" do
+        response = generate_response
+        response["Pragma"] = nil
+        expect {
+          Cucumber::Rest::Caching.ensure_response_is_not_cacheable(response: response)
+        }.to raise_error "Pragma should include the 'no-cache' directive"
+      end
+
+    end
+
+  end
+
+	context "#parse_httpdate" do
+
+		it "doesn't raise an error when an RFC822 date is passed" do
+			date = DateTime.now.strftime(RFC822_DATE_FORMAT)
+			Cucumber::Rest::Caching.parse_httpdate(date)
+		end
+
+		it "doesn't raise an error when an ANCI C asctime format date is passed" do
+			date = DateTime.now.strftime(ANSI_C_DATE_FORMAT)
+			Cucumber::Rest::Caching.parse_httpdate(date)
+		end
+
+		it "doesn't raise an error when an RFC850 date is passed" do
+			date = DateTime.now.strftime(RFC850_DATE_FORMAT)
+			Cucumber::Rest::Caching.parse_httpdate(date)
+		end
+
+		it "raises an error when a non-English date is passed" do
+			date = "ma, 14 heinä 2014 16:08:33 GMT"
+			expect {
+				Cucumber::Rest::Caching.parse_httpdate(date)
+			}.to raise_error("invalid date")
+		end
+
+		it "raises an error when a non-GMT date is passed" do
+			date = "Mon, 14 Jul 2014 16:33:04 +0100"
+			expect {
+				Cucumber::Rest::Caching.parse_httpdate(date)
+			}.to raise_error("invalid date")
+		end
+
+		it "raises an error when empty date values are passed" do
+			expect {
+				Cucumber::Rest::Caching.parse_httpdate("")
+			}.to raise_error("Empty date value")
+		end
+
+	end
+
+end

data/spec/cucumber/rest/status_spec.rb

@@ -0,0 +1,40 @@
+require "cucumber/rest/status"
+
+shared_examples "a status class inspector" do |status_class, min, max|
+  def generate_response(status_code)
+    response = MockResponse.new
+    response.status = status_code
+    response
+  end
+
+  Rack::Utils::HTTP_STATUS_CODES.keys.keep_if { |code| code >= min && code <= max }.each do |status_code|
+    it "does not raise an error for status code #{status_code}" do
+      Cucumber::Rest::Status.ensure_status_class(status_class, response: generate_response(status_code))
+    end
+  end
+  Rack::Utils::HTTP_STATUS_CODES.keys.keep_if { |code| code < min || code > max }.each do |status_code|
+    it "raises an error for status code #{status_code}" do
+      expect {
+        Cucumber::Rest::Status.ensure_status_class(status_class, response: generate_response(status_code))
+        }.to raise_error
+    end
+  end
+end
+
+describe Cucumber::Rest::Status, :status do
+  context "#ensure_status_class(:informational)" do
+    it_behaves_like "a status class inspector", :informational, 100, 199
+  end
+  context "#ensure_status_class(:success)" do
+    it_behaves_like "a status class inspector", :success, 200, 299
+  end
+  context "#ensure_status_class(:redirection)" do
+    it_behaves_like "a status class inspector", :redirection, 300, 399
+  end
+  context "#ensure_status_class(:client_error)" do
+    it_behaves_like "a status class inspector", :client_error, 400, 499
+  end
+  context "#ensure_status_class(:server_error)" do
+    it_behaves_like "a status class inspector", :server_error, 500, 599
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require "cucumber"
+
+RFC822_DATE_FORMAT = "%a, %d %b %Y %H:%M:%S GMT"
+RFC850_DATE_FORMAT = "%A, %d-%b-%y %H:%M:%S GMT"
+ANSI_C_DATE_FORMAT = "%a %b %e %H:%M:%S %Y"
+
+# A mock response class that looks like HttpCapture::Response
+class MockResponse
+  include Enumerable
+
+  attr_accessor :status
+  attr_accessor :body
+
+  def initialize
+    @header = {}
+  end
+
+  # The default header accessor
+  def [](key)
+    @header[key]
+  end
+
+  # The default header accessor
+  def []=(key, value)
+    @header[key] = value
+  end
+
+  def each(&block)
+    @header.each(&block)
+  end
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-rest
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- blinkbox books
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: http_capture
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !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: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: cucumber_spinner
+  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: A set of Cucumber step definitions and support functions which encapsulate
+  common RESTful functionality.
+email: greg@blinkbox.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENCE
+- README.md
+- Rakefile
+- VERSION
+- cucumber-rest.gemspec
+- lib/cucumber/rest.rb
+- lib/cucumber/rest/body.rb
+- lib/cucumber/rest/caching.rb
+- lib/cucumber/rest/status.rb
+- lib/cucumber/rest/steps.rb
+- lib/cucumber/rest/steps/caching.rb
+- lib/cucumber/rest/steps/status.rb
+- lib/cucumber/rest/version.rb
+- spec/cucumber/rest/body_spec.rb
+- spec/cucumber/rest/caching_spec.rb
+- spec/cucumber/rest/status_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.blinkboxbooks.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: ':: Coded for blinkbox books :: Love books, love code? Get in
+  touch ::'
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Cucumber steps and support for testing RESTful services.
+test_files:
+- spec/cucumber/rest/body_spec.rb
+- spec/cucumber/rest/caching_spec.rb
+- spec/cucumber/rest/status_spec.rb
+- spec/spec_helper.rb