cucumber-api-steps 0.1 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 47646a126718a454f84de22a7919a0b1433b2b18
+  data.tar.gz: 34255c3e6bc067d566126fa70768abe30ceab12a
+SHA512:
+  metadata.gz: ef0f10de3c180d5fd54427138a9dced2d1d11a34a5942a650da16538cdddeabb5eec3cd1ddbf3a7c0452ab5426c1821701b3780c45636804e60c0a0e62fb61be
+  data.tar.gz: 3335fa36c67b4293f11c6389fc5ef95b419dbf8c8d7ef9de6d1ba37dcb8c05f525cf692e691df3081e9e63a9755b14784716bd888291a8ce8e886df59763f74e

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+.DS_Store
+.idea

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.2"
+  - jruby-19mode # JRuby in 1.9 mode
+  - jruby-20mode # JRuby in 1.9 mode

data/Gemfile

@@ -1,4 +1,13 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 
-# Specify your gem's dependencies in cuke-api-steps.gemspec
 gemspec
+
+gem 'sinatra'
+gem 'rack-test'
+gem 'pry'
+gem 'activesupport'
+gem 'nokogiri'
+
+group :test do
+  gem 'rake'
+end

data/README.md

@@ -0,0 +1,91 @@
+# cucumber-api-steps
+
+[![Build Status](https://travis-ci.org/jayzes/cucumber-api-steps.png)](https://travis-ci.org/jayzes/cucumber-api-steps)
+[![Gem Version](https://badge.fury.io/rb/cucumber-api-steps.png)](http://badge.fury.io/rb/cucumber-api-steps)
+
+A set of [Cucumber](https://github.com/cucumber/cucumber) step definitions utilizing
+[Rack-Test](https://github.com/brynary/rack-test) that ease basic
+testing of REST-style APIs using either XML or JSON formats.
+
+Adapted from [a blog post by Anthony Eden](http://anthonyeden.com/2013/07/10/testing-rest-apis-with-cucumber-and-rack.html) with a few additions based on my own needs.  I found myself copying these step definitions around to multiple projects, and decided that it would be worthwhile to gem them up to keep things nice and DRY.
+
+## Dependencies
+
+Requires [Cucumber](https://github.com/aslakhellesoy/cucumber) (obviously).  Also makes use of [JSONPath](https://github.com/joshbuddy/jsonpath) for setting criteria against JSON responses.  See the gemspec for more info.
+
+## Installation
+
+Add the following line to your Gemfile, preferably in the test or cucumber group:
+
+```ruby
+gem 'cucumber-api-steps', :require => false
+```
+
+Then add the following line to your env.rb to make the step definitions available in your features:
+
+```ruby
+require 'cucumber/api_steps'
+```
+
+# Usage
+
+Still a work in progress.  For now, read the api_steps.rb file or check out the [stashboard-rails](https://github.com/jayzes/stashboard-rails) project - its Cucumber features make extensive use of the steps in this gem.
+
+# Examples
+```cucumber
+Feature: API
+
+  Scenario: List tweets in JSON
+    When I send and accept JSON
+    And I send a GET request to "/api/tweets"
+    Then the response status should be "200"
+    And the JSON response should be:
+      """
+      [{"tweet":"Hello World!"},{"tweet":"New Rails has been released"}]
+      """
+    And the JSON response should have "$..tweet" with the text "Hello World!"
+    And the JSON response should have "$..tweet" with a length of 2
+
+  Scenario: List tweets in XML
+    When I send and accept XML
+    And I send a GET request to "/api/tweets"
+    Then the XML response should have "tweet" with text "Hello World!"
+
+  Scenario: Post tweet using POST-params
+    When I send a POST request to "/api/tweets" with the following:
+      | tweet | Hello World! |
+      | lat   | 42.848282    |
+      | lng   | 74.634933    |
+    Then the response status should be "201"
+
+  Scenario: Post tweet using json in POST body
+    When I send a POST request to "/api/tweets" with the following:
+      """
+      {"tweet":"Hello World!","lat":"42.848282", "lng":"74.634933"}
+      """
+    Then the response status should be "201"
+
+  Scenario: Basic authentication
+    When I authenticate as the user "joe" with the password "password123"
+    And I send a GET request to "/api/tweets"
+    Then the response status should be "200"
+
+  Scenario: Digest authentication
+    When I digest-authenticate as the user "joe" with the password "password123"
+    And I send a GET request to "/api/tweets"
+    Then the response status should be "200"
+```
+# Contributors
+* Jay Zeschin
+* Justin Smestad
+* Kevin Pfefferle
+* Kalys Osmonov
+* Mingding Han
+* Gabe Varela
+* Steven Heidel
+* Adam Elhardt
+* Gonzalo Bulnes Guilpain
+
+## Copyright
+
+Copyright (c) 2011 Jay Zeschin. Distributed under the MIT License.

data/Rakefile

@@ -1,5 +1,9 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+require 'bundler/gem_tasks'
 
-require 'bueller'
-Bueller::Tasks.new
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--format pretty}
+end
+
+task :default => :cucumber

data/cucumber-api-steps.gemspec

@@ -7,14 +7,18 @@ Gem::Specification.new do |s|
   s.version     = Cucumber::ApiSteps::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Jay Zeschin"]
-  s.email       = ["jay.zeschin@factorylabs.com"]
+  s.email       = ["jay@zeschin.org"]
   s.homepage    = "http://github.com/jayzes/cucumber-api-steps"
   s.summary     = %q{Cucumber steps to easily test REST-based XML and JSON APIs}
   s.description = %q{Cucumber steps to easily test REST-based XML and JSON APIs}
-  
-  s.add_dependency 'jsonpath', '>= 0.1.2'
-  s.add_dependency 'cucumber', '>= 0.8.3'
-  s.add_development_dependency 'bueller'
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_dependency              'jsonpath',       '>= 0.1.2'
+  s.add_dependency              'cucumber',       '>= 2.0.2'
+  s.add_development_dependency  'activesupport',  '>= 3.0.0'
+  s.add_development_dependency  'rspec',          '~> 3.3.0'
+  s.add_development_dependency  'sinatra',        '~> 1.4.3'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/features/authentication.feature

@@ -0,0 +1,21 @@
+Feature:
+  As cucumber tester
+  I want to test basic authentication
+
+  Scenario: Basic authentication
+    When I perform the following steps:
+      """
+      I authenticate as the user "joe" with the password "god"
+      I send a GET request for "/"
+      """
+    Then I should be authenticated
+
+
+  @digest-auth
+  Scenario: Successful digest authentication
+    When I perform the following steps:
+      """
+      I digest-authenticate as the user "joe" with the password "god"
+      I send a GET request for "/"
+      """
+    Then I should be digest authenticated

data/features/fixtures/fake_app.rb

@@ -0,0 +1,37 @@
+require "rubygems"
+require "sinatra/base"
+
+module CucumberApiSteps
+  class FakeApp < Sinatra::Base
+
+    get '/' do end
+
+    get '/api/books' do
+      books = {books: [
+        {title: 'Pride and prejudice'},
+        {title: 'Metaprograming ruby'}
+      ]}
+
+      if request.accept.empty? || request.accept?('application/json')
+        content_type :json
+        books.to_json
+      elsif request.accept?('application/xml')
+        content_type :xml
+        books.to_xml
+      end
+    end
+
+    post '/api/books' do
+      status 201 if params.values == ["Metaprograming ruby", "Pragprog"]
+    end
+
+    patch '/api/books' do
+      status 200 if params.values == ["Metaprograming ruby", "Pragprog"]
+    end
+
+    post '/api/publishers' do
+      input_data = JSON.parse request.env["rack.input"].read, symbolize_names: true
+      status 201 if input_data == {publisher: 'Pragprog'}
+    end
+  end
+end

data/features/header.feature

@@ -0,0 +1,32 @@
+Feature:
+  As cucumber tester
+  I should be able to set headers for request
+
+  Scenario: Set multiple headers
+    When I perform the following step with table:
+      """
+      I set headers:
+        | Accept     | application/vnd.myproject.v1 |
+        | User-Agent | Cucumber Api Steps Client   |
+      """
+    Then the request headers should be:
+      | HTTP_ACCEPT     | application/vnd.myproject.v1 |
+      | HTTP_USER_AGENT | Cucumber Api Steps Client    |
+
+  Scenario: Send and accept JSON
+    When I perform the following step:
+      """
+      I send and accept JSON
+      """
+    Then the request headers should be:
+      | HTTP_ACCEPT  | application/json |
+      | CONTENT_TYPE | application/json |
+
+  Scenario: Send and accept HTML
+    When I perform the following step:
+      """
+      I send and accept HTML
+      """
+    Then the request headers should be:
+      | HTTP_ACCEPT  | text/html                         |
+      | CONTENT_TYPE | application/x-www-form-urlencoded |

data/features/request.feature

@@ -0,0 +1,34 @@
+Feature:
+
+  Scenario: GET request
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the response status should be "200"
+
+  Scenario: POST request with params
+    When I perform the following step with table:
+      """
+      I send a POST request to "/api/books" with the following:
+      | title     | Metaprograming ruby |
+      | publisher | Pragprog            |
+      """
+    Then the response status should be "201"
+
+  Scenario: PATCH request with params
+    When I perform the following step with table:
+      """
+      I send a PATCH request to "/api/books" with the following:
+      | title     | Metaprograming ruby |
+      | publisher | Pragprog            |
+      """
+    Then the response status should be "200"
+
+  Scenario: POST request with string
+    When I perform the following step with string:
+      """
+      I send a POST request to "/api/publishers" with the following:
+      {"publisher": "Pragprog"}
+      """
+    Then the response status should be "201"

data/features/response.feature

@@ -0,0 +1,112 @@
+Feature:
+  As cucumber tester
+  I want to test response
+
+  Scenario: Test response status
+    When I perform the following step:
+      """
+      I send a GET request to "/"
+      """
+
+    Then the response status should be "200"
+
+  Scenario: Test that JSON response contains a node
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the JSON response should have "$..title"
+
+  Scenario: Test that JSON response does not contain a node
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the JSON response should not have "$..nonexistent_key"
+
+  Scenario: Test that XML response contains a node
+    When I send and accept XML
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then show me the unparsed response
+    Then the XML response should have "//title"
+
+  Scenario: Test that XML response does not contain a node
+    When I send and accept XML
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the XML response should not have "//nonexistent_element"
+
+  Scenario: Test if JSON response contains text
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the JSON response should have "$..title" with the text "Metaprograming ruby"
+
+  Scenario: Test if JSON response doesn't contain text
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the JSON response should not have "$..publisher" with the text "Metaprograming ruby"
+
+  Scenario: Test if XML response contains text
+    When I send and accept XML
+    And I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the XML response should have "//title" with the text "Metaprograming ruby"
+
+  Scenario: Test JSON response
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the JSON response should be:
+      """
+      {"books":[{"title":"Pride and prejudice"},{"title":"Metaprograming ruby"}]}
+      """
+
+  Scenario: Test JSON with length of some element
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then the JSON response should have "$..title" with a length of 2
+
+  Scenario: Test debugging the XML response should not blow up
+    When I send and accept XML
+    And I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then show me the response
+
+  Scenario: Test debugging the JSON response should not blow up
+    When I send and accept JSON
+    And I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then show me the response
+
+  Scenario: Test debugging unparsed JSON response should not blow up
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then show me the unparsed response
+
+  Scenario: Test debugging unparsed XML response should not blow up
+    When I send and accept XML
+    When I perform the following step:
+      """
+      I send a GET request to "/api/books"
+      """
+    Then show me the unparsed response

data/features/step_definitions/api_test_steps.rb

@@ -0,0 +1,45 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+When /^I perform the following steps?:$/ do |step_strings|
+  steps = step_strings.split("\n")
+  steps.each {|step_string| step step_string }
+end
+
+Then /^the response should equal:$/ do |response_body|
+  expect(last_response.body).to eq(response_body)
+end
+
+When /^I perform the following step with table:$/ do |step_definition|
+  lines = step_definition.split("\n")
+  step_string = lines.shift
+
+  raw = lines.map do |line|
+    line.squish.gsub(/^\|/, '').gsub(/\|$/, '').squish.split("|").map(&:squish)
+  end
+
+  step step_string, table(raw)
+end
+
+When /^I perform the following step with string:$/ do |step_definition|
+  lines = step_definition.split("\n")
+  step_string = lines.shift
+
+  param_string = lines.join("\n")
+
+  step step_string, param_string
+end
+
+Then /^the request headers should be:$/ do |headers|
+  headers_hash = headers.rows_hash
+  request '/'
+  expect(last_request.env.slice(*headers_hash.keys).values).to eq(headers_hash.values)
+end
+
+Then /^I should be authenticated$/ do
+  expect(last_request.env["HTTP_AUTHORIZATION"]).to eq("Basic #{Base64.encode64("joe:god")}")
+end
+
+Then /^I should be digest authenticated$/ do
+  expect(last_request.env["HTTP_AUTHORIZATION"].starts_with?("Digest ")).to be true
+end

data/features/support/env.rb

@@ -0,0 +1,23 @@
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'pry'
+
+require 'rack'
+require 'rack/test'
+require File.dirname(__FILE__) + "/../fixtures/fake_app"
+
+require 'cucumber/api_steps'
+
+def app
+  Rack::Lint.new(CucumberApiSteps::FakeApp.new)
+end
+
+Before("@digest-auth") do
+  def app
+    app = Rack::Auth::Digest::MD5.new(CucumberApiSteps::FakeApp.new) do |username|
+      { 'joe' => 'god' }[username]
+    end
+    app.realm = 'TestApi'
+    app.opaque = 'this-should-be-secret'
+    app
+  end
+end

data/lib/cucumber/api_steps.rb

@@ -1,60 +1,165 @@
-World(Rack::Test::Methods)
+require 'jsonpath'
+require 'nokogiri'
+
+if defined?(Rack)
+
+  # Monkey patch Rack::MockResponse to work properly with response debugging
+  class Rack::MockResponse
+    def to_str
+      body
+    end
+  end
+
+  World(Rack::Test::Methods)
 
-Given /^I send and accept XML$/ do
-  page.driver.header 'Accept', 'text/xml'
-  page.driver.header 'Content-Type', 'text/xml'
 end
 
-Given /^I send and accept JSON$/ do
-  page.driver.header 'Accept', 'application/json'
-  page.driver.header 'Content-Type', 'application/json'
+Given /^I set headers:$/ do |headers|
+  headers.rows_hash.each {|k,v| header k, v }
 end
 
-When /^I authenticate as the user "([^\"]*)" with the password "([^\"]*)"$/ do |user, pass|
-  page.driver.authorize(user, pass)
+Given /^I send and accept (XML|JSON)$/ do |type|
+  header 'Accept', "application/#{type.downcase}"
+  header 'Content-Type', "application/#{type.downcase}"
 end
 
-When /^I send a GET request (?:for|to) "([^\"]*)"$/ do |path|
-  page.driver.get path
+Given /^I send and accept HTML$/ do
+  header 'Accept', "text/html"
+  header 'Content-Type', "application/x-www-form-urlencoded"
 end
 
-When /^I send a POST request to "([^\"]*)"$/ do |path|
-  page.driver.post path
+When /^I authenticate as the user "([^"]*)" with the password "([^"]*)"$/ do |user, pass|
+  authorize user, pass
 end
 
-When /^I send a POST request to "([^\"]*)" with the following:$/ do |path, body|
-  page.driver.post path, body
+When /^I digest\-authenticate as the user "(.*?)" with the password "(.*?)"$/ do |user, pass|
+  digest_authorize user, pass
 end
 
-When /^I send a PUT request to "([^\"]*)" with the following:$/ do |path, body|
-  page.driver.put path, body
+When /^I send a (GET|PATCH|POST|PUT|DELETE) request (?:for|to) "([^"]*)"(?: with the following:)?$/ do |*args|
+  request_type = args.shift
+  path = args.shift
+  input = args.shift
+
+  request_opts = {method: request_type.downcase.to_sym}
+
+  unless input.nil?
+    if input.class == Cucumber::MultilineArgument::DataTable
+      request_opts[:params] = input.rows_hash
+    else
+      request_opts[:input] = StringIO.new input
+    end
+  end
+
+  request path, request_opts
 end
 
-When /^I send a DELETE request to "([^\"]*)"$/ do |path|
-  page.driver.delete path
+Then /^show me the (unparsed)?\s?response$/ do |unparsed|
+  if unparsed == 'unparsed'
+    puts last_response.body
+  elsif last_response.headers['Content-Type'] =~ /json/
+    json_response = JSON.parse(last_response.body)
+    puts JSON.pretty_generate(json_response)
+  elsif last_response.headers['Content-Type'] =~ /xml/
+    puts Nokogiri::XML(last_response.body)
+  else
+    puts last_response.headers
+    puts last_response.body
+  end
 end
 
-Then /^show me the response$/ do
-  p page.driver.last_response
+Then /^the response status should be "([^"]*)"$/ do |status|
+  if self.respond_to?(:expect)
+    expect(last_response.status).to eq(status.to_i)
+  else
+    assert_equal status.to_i, last_response.status
+  end
 end
 
-Then /^the response status should be "([^\"]*)"$/ do |status|
-  page.driver.last_response.status.should == status.to_i
+Then /^the JSON response should (not)?\s?have "([^"]*)"$/ do |negative, json_path|
+  json    = JSON.parse(last_response.body)
+  results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
+  if self.respond_to?(:expect)
+    if negative.present?
+      expect(results).to be_empty
+    else
+      expect(results).not_to be_empty
+    end
+  else
+    if negative.present?
+      assert results.empty?
+    else
+      assert !results.empty?
+    end
+  end
 end
 
-Then /^the JSON response should have "([^\"]*)" with the text "([^\"]*)"$/ do |json_path, text|
-  json = JSON.parse(page.driver.last_response.body)
-  JsonPath.new(json_path).on(json).to_a.map(&:to_s).should include(text)
+
+Then /^the JSON response should (not)?\s?have "([^"]*)" with the text "([^"]*)"$/ do |negative, json_path, text|
+  json    = JSON.parse(last_response.body)
+  results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
+  if self.respond_to?(:expect)
+    if negative.present?
+      expect(results).not_to include(text)
+    else
+      expect(results).to include(text)
+    end
+  else
+    if negative.present?
+      assert !results.include?(text)
+    else
+      assert results.include?(text)
+    end
+  end
 end
 
-Then /^the JSON response should not have "([^\"]*)" with the text "([^\"]*)"$/ do |json_path, text|
-  json = JSON.parse(page.driver.last_response.body)
-  JsonPath.new(json_path).on(json).to_a.map(&:to_s).should_not include(text)
+Then /^the XML response should (not)?\s?have "([^"]*)"$/ do |negative, xpath|
+  parsed_response = Nokogiri::XML(last_response.body)
+  elements = parsed_response.xpath(xpath)
+  if self.respond_to?(:expect)
+    if negative.present?
+      expect(elements).to be_empty
+    else
+      expect(elements).not_to be_empty
+    end
+  else
+    if negative.present?
+      assert elements.empty?
+    else
+      assert !elements.empty?
+    end
+  end
 end
 
-Then /^the XML response should have "([^\"]*)" with the text "([^\"]*)"$/ do |xpath, text|
+Then /^the XML response should have "([^"]*)" with the text "([^"]*)"$/ do |xpath, text|
   parsed_response = Nokogiri::XML(last_response.body)
   elements = parsed_response.xpath(xpath)
-  elements.should_not be_empty, "could not find #{xpath} in:\n#{last_response.body}"
-  elements.find { |e| e.text == text }.should_not be_nil, "found elements but could not find #{text} in:\n#{elements.inspect}"
-end
+  if self.respond_to?(:expect)
+    expect(elements).not_to be_empty, "could not find #{xpath} in:\n#{last_response.body}"
+    expect(elements.find { |e| e.text == text }).not_to be_nil, "found elements but could not find #{text} in:\n#{elements.inspect}"
+  else
+    assert !elements.empty?, "could not find #{xpath} in:\n#{last_response.body}"
+    assert elements.find { |e| e.text == text }, "found elements but could not find #{text} in:\n#{elements.inspect}"
+  end
+end
+
+Then /^the JSON response should be:$/ do |json|
+  expected = JSON.parse(json)
+  actual = JSON.parse(last_response.body)
+
+  if self.respond_to?(:expect)
+    expect(actual).to eq(expected)
+  else
+    assert_equal actual, response
+  end
+end
+
+Then /^the JSON response should have "([^"]*)" with a length of (\d+)$/ do |json_path, length|
+  json = JSON.parse(last_response.body)
+  results = JsonPath.new(json_path).on(json)
+  if self.respond_to?(:expect)
+    expect(results.length).to eq(length.to_i)
+  else
+    assert_equal length.to_i, results.length
+  end
+end

data/lib/cucumber/api_steps/version.rb

@@ -1,5 +1,5 @@
 module Cucumber
   module ApiSteps
-    VERSION = "0.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,118 +1,135 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: cucumber-api-steps
-version: !ruby/object:Gem::Version 
-  hash: 9
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  version: "0.1"
+version: !ruby/object:Gem::Version
+  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Jay Zeschin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-12 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2017-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: jsonpath
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 0
-        - 1
-        - 2
+      - !ruby/object:Gem::Version
         version: 0.1.2
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: cucumber
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 57
-        segments: 
-        - 0
-        - 8
-        - 3
-        version: 0.8.3
+      - !ruby/object:Gem::Version
+        version: 2.0.2
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bueller
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.3
 description: Cucumber steps to easily test REST-based XML and JSON APIs
-email: 
-- jay.zeschin@factorylabs.com
+email:
+- jay@zeschin.org
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
-- .rvmrc
+files:
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
+- README.md
 - Rakefile
 - cucumber-api-steps.gemspec
+- features/authentication.feature
+- features/fixtures/fake_app.rb
+- features/header.feature
+- features/request.feature
+- features/response.feature
+- features/step_definitions/api_test_steps.rb
+- features/support/env.rb
 - lib/cucumber/api_steps.rb
 - lib/cucumber/api_steps/version.rb
-has_rdoc: true
 homepage: http://github.com/jayzes/cucumber-api-steps
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 2.5.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Cucumber steps to easily test REST-based XML and JSON APIs
-test_files: []
-
+test_files:
+- features/authentication.feature
+- features/fixtures/fake_app.rb
+- features/header.feature
+- features/request.feature
+- features/response.feature
+- features/step_definitions/api_test_steps.rb
+- features/support/env.rb

data/.rvmrc

@@ -1 +0,0 @@
-rvm use ree@cucumber-api-steps