cucumber-blinkbox 0.3.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2MyODE2NDZjYTE4Y2VhNjNhN2VmNmM4MDhkY2EzMmU0MTIyYzNiNQ==
+  data.tar.gz: !binary |-
+    NmNkZGExNjNkNTcyYWJlZmUxZTVlMjM2YTdiZTVmNzZlYTIwNjQzMQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZDI5MTIwZGJlOTQ2NzkyZDU5YzczYzFhNDczYWJiNjU1M2I0MjM4NzNkYjc4
+    ZjkyNGU1MTIwZjM1OTVmNTM0YjA3NjMzOTIzZjIzNzNiNTY5Y2NiOGMyMDEy
+    Mzg2MmE1MTgwOWVmNjZjZmMzMTYyNGQxZmY4NWE2MDQyNGJlOWU=
+  data.tar.gz: !binary |-
+    YjU4ZGI4YzhkYjZmMDlhNmMxM2YwNTdhYmQzNDRjZjJhZTk2MTMxNDVhYjI4
+    OTY5MWI3ZjM5YjQ1MTFhYzViYzNlYmQ4M2E3NWVhYWNmMTIzZTE2Y2Y3MGYy
+    ZGY5ZThjMzBlYWJjOGI2MjI2M2NkY2IyMDQ3ODgzYTdmMDRkMzU=

data/VERSION

@@ -0,0 +1 @@
+0.3.3

data/lib/cucumber/blinkbox.rb

@@ -0,0 +1,6 @@
+require "cucumber/blinkbox/environment"
+require "cucumber/blinkbox/data_dependencies"
+require "cucumber/blinkbox/subjects"
+require "cucumber/blinkbox/requests"
+require "cucumber/blinkbox/responses"
+require "cucumber/blinkbox/response_validation"

data/lib/cucumber/blinkbox/data_dependencies.rb

@@ -0,0 +1,31 @@
+module KnowsAboutDataDependencies
+  ::TEST_CONFIG ||= {}
+
+  def self.extended(base)
+    base.instance_eval do
+      path = TEST_CONFIG["data.yml"] || "config/data.yml"
+      raise "The data dependencies file does not exist at #{path}" unless File.exist?(path)
+      @data_dependencies = YAML.load_file(path)
+    end
+  end
+
+  def data_for_a(object, which: nil, but_isnt: nil, instances: nil)
+    raise ArgumentError, "Please specify a condition using `which:`" if which.nil?
+    data = @data_dependencies[object.to_s][which] rescue nil
+
+    if data.respond_to? :sample
+      data.delete_if { |item| item == but_isnt } if but_isnt
+      if instances
+        pending "Test error: There are not enough examples defined for a #{object} which #{which}" unless data.size >= instances
+        data = data.sample(instances)
+      else
+        data = data.sample
+      end
+    end
+
+    pending "Test error: There is no data dependency defined for a #{object} which #{which}" unless data
+    data
+  end
+end
+
+World(KnowsAboutDataDependencies)

data/lib/cucumber/blinkbox/environment.rb

@@ -0,0 +1,35 @@
+module KnowsAboutTheEnvironment
+  ::TEST_CONFIG ||= {}
+
+  class EnvStruct
+    def initialize(env)
+      @env = env
+    end
+    def [](key)
+      value = @env[key.to_s]
+      value.is_a?(Hash) ? EnvStruct.new(value) : value
+    end
+    def method_missing(name, *args)
+      key = name.to_s.tr("_", " ").downcase
+      self[key]
+    end
+    def inspect
+      @env.inspect
+    end
+  end
+
+  def self.extended(base)
+    base.instance_eval do
+      path = TEST_CONFIG["environments.yml"] || "config/environments.yml"
+      raise "The environments file does not exist at #{path}" unless File.exist?(path)
+      env = YAML.load_file(path)[TEST_CONFIG["server"].downcase]
+      raise "Environment '#{TEST_CONFIG["server"]}' is not defined in environments.yml" if env.nil?
+      @test_env = EnvStruct.new(env)
+    end
+  end
+
+  def test_env
+    @test_env
+  end
+end
+World(KnowsAboutTheEnvironment)

data/lib/cucumber/blinkbox/formatter/html.rb

@@ -0,0 +1,124 @@
+require 'cucumber/formatter/html'
+
+module Cucumber
+  module Blinkbox
+    module Formatter
+      class Html < Cucumber::Formatter::Html
+
+        def timestamp
+          Time.now.strftime("%b %e %H:%M:%S")
+        end
+
+        def append_timestamp_to(name)
+          "#{name} [#{timestamp}]"
+        end
+
+        def prefix_with_timestamp(name)
+          "#{timestamp} #{name}"
+        end
+
+        #override inline JS in the default html formatter to always show cucumber tags regardless expand/collapse state of the scenarios
+        #also make all scenarios collapsed on page load
+        def inline_js_content
+          <<-EOF
+
+          SCENARIOS = "h3[id^='scenario_'],h3[id^=background_]";
+
+          $(document).ready(function() {
+            $(SCENARIOS).css('cursor', 'pointer');
+            $(SCENARIOS).click(function() {
+              $(this).siblings().toggle(250, function(){
+                $(this).siblings(".tag").show();  
+                $(this).siblings(".examples").show();
+                $(this).siblings(".examples").children().show();
+              });
+            });
+
+            $("#collapser").css('cursor', 'pointer');
+            $("#collapser").click(function() {
+              $(SCENARIOS).siblings().hide();
+              $(SCENARIOS).siblings(".tag").show();
+            });
+
+            $("#expander").css('cursor', 'pointer');
+            $("#expander").click(function() {
+              $(SCENARIOS).siblings().show();
+            });
+
+            $(SCENARIOS).siblings().hide();
+            $(SCENARIOS).siblings(".tag").show();
+          })
+
+          function moveProgressBar(percentDone) {
+            $("cucumber-header").css('width', percentDone +"%");
+          }
+          function makeRed(element_id) {
+            $('#'+element_id).css('background', '#C40D0D');
+            $('#'+element_id).css('color', '#FFFFFF');
+          }
+          function makeYellow(element_id) {
+            $('#'+element_id).css('background', '#FAF834');
+            $('#'+element_id).css('color', '#000000');
+          }
+
+          EOF
+        end
+
+        #log scenario name so that console log is more readable
+        #also track the position in the all logs array from which out for current scenario starts
+        def scenario_name(keyword, name, file_colon_line, source_indent)
+          name = append_timestamp_to(name)
+          super(keyword, name, file_colon_line, source_indent)
+        end
+
+        def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+          name = super
+          append_timestamp_to(name)
+        end
+
+        def build_step(keyword, step_match, status)
+          super
+          @builder.div(:class => 'step_file') do |div|
+            @builder.span do
+              @builder << append_timestamp_to("")
+            end
+          end
+        end
+
+        #override to set color of pending exceptions backtraces to Yellow instead of Red (and thus not make the whole scenario Red)
+        def after_table_row(table_row)
+          return if @hide_this_step
+          print_table_row_messages
+          @builder << '</tr>'
+          if table_row.exception
+            if table_row.exception.instance_of?(Cucumber::Pending)
+              @builder.tr do
+                @builder.td(:colspan => @col_index.to_s, :class => 'pending') do
+                  @builder.pre do |pre|
+                    pre << h(format_exception(table_row.exception))
+                  end
+                end
+              end
+              set_scenario_color_pending
+            else
+              @builder.tr do
+                @builder.td(:colspan => @col_index.to_s, :class => 'failed') do
+                  @builder.pre do |pre|
+                    pre << h(format_exception(table_row.exception))
+                  end
+                end
+              end
+              set_scenario_color_failed
+            end
+          end
+          if @outline_row
+            @outline_row += 1
+          end
+          @step_number += 1
+          move_progress
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/blinkbox/requests.rb

@@ -0,0 +1,92 @@
+module KnowsAboutApiRequests
+  CONTENT_TYPE = "application/vnd.blinkboxbooks.data.v1+json"
+  
+  def http_client
+    @http ||= HTTPClient.new(TEST_CONFIG["proxy"])
+    # Ensure we're using the system SSL certs, as per other libraries (like HTTParty)
+    @http.ssl_config.set_trust_ca(OpenSSL::X509::DEFAULT_CERT_FILE)
+    @http.debug_dev = STDOUT if TEST_CONFIG["debug"]
+    #@http.reset_all
+    @http
+  end
+
+  def query
+    @query ||= {}
+  end
+
+  def request_headers(header = {})
+    @request_headers ||= {
+        "Accept" => CONTENT_TYPE
+    }
+    if @access_token
+      @request_headers["Authorization"] = "Bearer #{@access_token}" 
+    else
+      @request_headers.delete("Authorization")
+    end
+    @request_headers.merge!(header)
+    @request_headers
+  end
+
+  def set_query_param(name, value)
+    if value.respond_to?(:each)
+      value.each { |v| set_query_param(name, v) }
+    else
+      name = name.camel_case
+      value = is_enum_param(name) ? value.snake_case(:upper) : value
+      current_value = query[name]
+
+      if current_value.nil?
+        query[name] = value
+      elsif current_value.is_a?(Array)
+        query[name] << value
+      else
+        query[name] = [current_value, value]
+      end
+    end
+  end
+
+  def qualified_uri(server, path)
+    uri = test_env.servers[server.to_sym]
+    raise "Test Error: #{server} doesn't appear to be defined in the environments.yml" if uri.nil?
+    File.join(uri.to_s, path)
+  end
+
+  # request methods
+
+  def http_get(server, path, header = {})
+    uri = qualified_uri(server, path)
+    params = query if query.count > 0
+    @response = http_client.get(uri, query: params, header: request_headers(header), follow_redirect: true)
+  end
+
+  def http_post(server, path, body = {}, header = {})
+    uri = qualified_uri(server, path)
+    @response = http_client.post(uri, body: format_body(body), header: request_headers({"Content-Type" => CONTENT_TYPE}.merge(header)))
+  end
+
+  def http_put(server, path, body = {}, header = {})
+    uri = qualified_uri(server, path)
+    @response = http_client.put(uri, body: format_body(body), header: request_headers({"Content-Type" => CONTENT_TYPE}.merge(header)))
+  end
+
+  def http_delete(server, path, header = {})
+    uri = qualified_uri(server, path)
+    params = query if query.count > 0
+    @response = http_client.delete(uri, query: params, header: request_headers(header))
+  end
+
+  private
+
+  def format_body(body)
+    body.is_a?(Hash) ? JSON.dump(body) : body
+  end
+
+  # So that we don't have to put enum parameters in the Gherkin in SCREAMING_SNAKE_CASE this heuristic identifies
+  # enum parameters so that we can transform them, meaning an enum value like PURCHASE_DATE can be written in the
+  # Gherkin as "purchase date" but still be sent correctly. This heuristic will need updating over time.
+  def is_enum_param(name)
+    ["bookmarkType", "order", "role"].include?(name)
+  end
+end
+
+World(KnowsAboutApiRequests)

data/lib/cucumber/blinkbox/response_validation.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+module KnowsAboutResponseValidation
+  INFINITY = 1.0 / 0.0
+
+  # Parses a string into a data if that's the specified date type. This is needed for interpreting JSON markup as
+  # it doesn't have dates as a first-class concept so they should appear as specifically formatted strings.
+  def parse_and_validate_date_if_necessary(value, type)
+    # note: cannot use 'case type' as that expands to === which checks for instances of rather than type equality
+    if type == Date
+      expect(value).to match(/^\d{4}-\d{2}-\d{2}$/)
+      Date.strptime(value, "%Y-%m-%d")
+    elsif type == DateTime
+      expect(value).to match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/)
+      DateTime.strptime(value, "%Y-%m-%dT%H:%M:%SZ")
+    else
+      value
+    end
+  end
+
+  def validate_attribute(data, name, options = {})
+    type = options[:type]
+    type = type.constantize if type.respond_to?(:constantize) # allows it to be passed in as a string or a constant
+    expected_value = options[:is] || options[:value]
+    expected_value = expected_value.to_type(type) if expected_value.is_a?(String) && !type.nil?
+    expected_content = options[:contains]
+
+    value = parse_and_validate_date_if_necessary(data.deep_key(name), type)
+
+    begin
+      expect(value).to_not be_nil
+      expect(value).to be_a_kind_of(type) unless type.nil?
+      expect(value).to eq(expected_value) unless expected_value.nil?
+      expect(value).to match(/#{Regexp.escape(expected_content)}/) unless expected_content.nil?
+      yield value if block_given?
+    rescue => e
+      message = "'#{name}' is invalid:\n#{e.message}"
+      send((options[:warn_only] ? "puts" : "raise").to_sym, message)
+    end
+  end
+
+  def validate_entity(data, type, options = {})
+    warn_only = options[:warn_only] || []
+    validate_attribute(data, "type", type: String, warn_only: warn_only.include?(:type)) { |value| expect(value).to eq("urn:blinkboxbooks:schema:#{type}") }
+    validate_attribute(data, "guid", type: String, warn_only: warn_only.include?(:guid)) { |value| expect(value).to start_with "urn:blinkboxbooks:id:#{type}:#{data["id"]}" }
+  end
+
+  def validate_link(data)
+    validate_attribute(data, "rel", type: String) { |value| expect(value).to start_with "urn:blinkboxbooks:schema:" }
+    validate_attribute(data, "href", type: String) { |value| expect(value).to_not be_empty } if data["href"]
+    validate_attribute(data, "title", type: String) { |value| expect(value).to_not be_empty } if data["title"]
+    validate_attribute(data, "text", type: String) { |value| expect(value).to_not be_empty } if data["text"]
+  end
+
+  def validate_links(data, *expected)
+    validate_attribute(data, "links", type: Array)
+    data["links"].each { |link_data| validate_link(link_data) }
+    expected.each do |link_info|
+      rel = link_info[:rel] || link_info[:relationship]
+      rel = "urn:blinkboxbooks:schema:" << rel.tr(" ", "").downcase unless rel.start_with?("urn:")
+      count = data["links"].select { |link| link["rel"] == rel }.count
+      min = link_info[:min].to_i
+      max = %w{∞ *}.include?(link_info[:max]) ? INFINITY : link_info[:min].to_i
+      raise "Wrong number of #{rel} links: Expected #{min..max}, Actual: #{count}" unless count >= min && count <= max
+    end
+  end
+
+  # Validates a list of items is in the standardised blinkbox books format.
+  #
+  # @param options [Hash] Options for the validation.
+  # @option options [String] :item_type The (singular, snake cased) name of the items in the list, and the validation method (`validate_item_type`) that will be used to test them.
+  # @option options [String] :list_type The (signular, snake cased) name of the list type to be validated. Corresponds to the schema urn of `urn:blinkboxbooks:schema:listtypelist` and will look for the method `validate_list_of_list_type`.
+  # @option options [Integer] :min_count The minimum number of items there must be.
+  # @option options [Integer] :max_count The maximum number of items there can be.
+  # @option options [Integer] :count The exact number of items there must be. (Is overridden by min_ and max_count)
+  # @option options [Integer] :offset The offset expected for the data (used for ensuring the `offset` value is correct)
+  # @option options [Array<Symbol>] :warn_only Ask the validator to be lenient while testing the specified attributes (NB. Use snake_case)
+  def validate_list(data, options = {})
+    list_type = options[:list_type]
+    item_type = options[:item_type]
+    min_count = options[:min_count] || options[:count] || 0
+    max_count = options[:max_count] || options[:count] || 1000000
+    offset = options[:offset] || 0
+    warn_only = options[:warn_only] || []
+
+    # TODO: Should this be :list:#{list_type} rather than the list type before list?
+    expected_type = "urn:blinkboxbooks:schema:#{(list_type || "").tr("_", "")}list"
+    validate_attribute(data, "type",            type: String,  warn_only: warn_only.include?(:type))              { |value| expect(value).to eq(expected_type) }
+    validate_attribute(data, "count",           type: Integer, warn_only: warn_only.include?(:count))             { |value| expect(min_count..max_count).to cover(value) }
+    validate_attribute(data, "offset",          type: Integer, warn_only: warn_only.include?(:offset))            { |value| expect(value).to eq(offset) }
+    validate_attribute(data, "numberOfResults", type: Integer, warn_only: warn_only.include?(:number_of_results)) { |value| expect(value).to be >= data["count"] }
+    validate_attribute(data, "items",           type: Array,   warn_only: warn_only.include?(:empty_items))
+
+    unless list_type.nil?
+      further_validation = "validate_list_of_#{list_type}".to_sym
+      send(further_validation, data) if respond_to?(further_validation)
+    end
+
+    if data["items"] || min_count > 0
+      validate_attribute(data, "items", type: Array) do |value|
+        if min_count == max_count
+          expect(value.count).to eq(min_count)
+        else
+          expect(value.count).to be_between(min_count, max_count)
+        end
+      end
+      unless item_type.nil?
+        item_validation_method = "validate_#{item_type}".to_sym
+        data["items"].each { |item| self.send(item_validation_method, item) }
+      end
+    end
+  end
+
+ def validate_list_order(data, attribute_name, descending: false)
+    attribute_values = data["items"].map.with_index do |item, index|
+      value = item[attribute_name]
+      expect(value).to_not be_nil, "'#{attribute_name}' is nil in item at index #{index}"
+      if attribute_name =~ /date$/i
+        DateTime.parse(value)
+      else
+        value
+      end
+    end
+    expected_values = attribute_values.sort do |a, b|
+      if a.respond_to?(:upcase)
+        a.upcase <=> b.upcase # ordering of values should be case-insensitive
+      else
+        a <=> b
+      end
+    end
+    expected_values.reverse! if descending
+    expect(attribute_values).to eq(expected_values)
+  end
+end
+
+World(KnowsAboutResponseValidation)

data/lib/cucumber/blinkbox/responses.rb

@@ -0,0 +1,17 @@
+require "http_capture"
+
+module KnowsAboutApiResponses
+  # Parses response data that is expected to be in JSON format.
+  #
+  # @return [Hash] The response data.
+  def parse_response_data
+    expect(HttpCapture::RESPONSES.last["Content-Type"]).to match(%r{^application/vnd.blinkboxbooks.data.v1\+json;?})
+    begin
+      @response_data = JSON.load(HttpCapture::RESPONSES.last.body)
+    rescue => e
+      raise "The response is not valid JSON: #{e.message}"
+    end
+  end
+end
+
+World(KnowsAboutApiResponses)

data/lib/cucumber/blinkbox/subjects.rb

@@ -0,0 +1,28 @@
+# This module allows steps to set the subject of a scenario simply.
+#
+#     subject(:book, {"isbn" => "9780111222333"})
+#     subject(:contributor, {"guid" => "abc123"})
+#
+#     p subject(:book)
+#     # => {"isbn" => "9780111222333"}
+#
+# It's really just a readable wrapper for a hash with some test specific exceptions and things
+module KnowsAboutGrammaticalSubjects
+  SUBJECTS = {}
+  USING_SETTER = :you_will_never_accidentally_pass_this
+
+  def subject(type, details = USING_SETTER)
+    if details == USING_SETTER
+      raise "Test error: A #{type} subject hasn't been defined in this scenario yet." unless SUBJECTS[type]
+      return SUBJECTS[type]
+    else
+      SUBJECTS[type] = details
+    end
+  end
+end
+
+World(KnowsAboutGrammaticalSubjects)
+
+Before do
+  KnowsAboutGrammaticalSubjects::SUBJECTS.clear
+end

data/spec/cucumber/blinkbox/requests_spec.rb

@@ -0,0 +1,56 @@
+require_relative "../../spec_helper"
+require 'rspec'
+require 'cucumber/blinkbox/requests'
+
+# needed for String#camel_case
+# (ought this be required by cucumber/blinkbox/requests ?)
+require 'cucumber/helpers'
+
+# needed for String#camelize
+# (ought this be required by cucumber/helpers ?)
+require 'active_support/core_ext/string'
+
+describe "requests" do
+
+  describe "setting query parameters" do
+
+    before :each do
+      @request = Object.new
+      @request.extend(KnowsAboutApiRequests)
+    end
+
+    it "accepts a single value" do
+      @request.set_query_param("foo", 1)
+      @request.query["foo"].should eq(1)
+    end
+
+    it "accepts an array of values" do
+      @request.set_query_param("foo", [1, 2])
+      @request.query["foo"].should eq([1, 2])
+    end
+
+    it "accepts multiple single values" do
+      @request.set_query_param("foo", 1)
+      @request.set_query_param("foo", 2)
+      @request.query["foo"].should eq([1, 2])
+    end
+
+    it "appends arrays to existing arrays" do
+      @request.set_query_param("foo", [1, 2])
+      @request.set_query_param("foo", [3, 4])
+      @request.query["foo"].should eq([1, 2, 3, 4])
+    end
+
+    it "appends single values to existing arrays" do
+      @request.set_query_param("foo", [1, 2])
+      @request.set_query_param("foo", 3)
+      @request.query["foo"].should eq([1, 2, 3])
+    end
+
+    it "appends arrays to existing values" do
+      @request.set_query_param("foo", 1)
+      @request.set_query_param("foo", [2, 3])
+      @request.query["foo"].should eq([1, 2, 3])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$:<<File.join(File.dirname(__FILE__), "..", "lib")
+
+# Modules under test register themselves with Cucumber by passing themselves to
+# World(m) Since Cucumber doesn't exist in test scope, however, we need to
+# create a noop World
+def World(m) end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-blinkbox
+version: !ruby/object:Gem::Version
+  version: 0.3.3
+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: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !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: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: http_capture
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.99'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber-helpers
+  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: blinkbox books specific cucumber test helpers
+email:
+- jphastings@blinkbox.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- lib/cucumber/blinkbox.rb
+- lib/cucumber/blinkbox/data_dependencies.rb
+- lib/cucumber/blinkbox/environment.rb
+- lib/cucumber/blinkbox/formatter/html.rb
+- lib/cucumber/blinkbox/requests.rb
+- lib/cucumber/blinkbox/response_validation.rb
+- lib/cucumber/blinkbox/responses.rb
+- lib/cucumber/blinkbox/subjects.rb
+- spec/cucumber/blinkbox/requests_spec.rb
+- spec/spec_helper.rb
+homepage: http://blinkboxbooks.github.io/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: blinkbox books specific cucumber test helpers
+test_files:
+- spec/cucumber/blinkbox/requests_spec.rb
+- spec/spec_helper.rb