cucumber-api-steps 0.2.0 → 0.3

data/.gitignore

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

data/.rvmrc

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

data/Gemfile

@@ -1,13 +1,4 @@
-source 'https://rubygems.org'
+source "http://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/Rakefile

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

data/cucumber-api-steps.gemspec

@@ -7,18 +7,14 @@ Gem::Specification.new do |s|
   s.version     = Cucumber::ApiSteps::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Jay Zeschin"]
-  s.email       = ["jay@zeschin.org"]
+  s.email       = ["jay.zeschin@factorylabs.com"]
   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.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.add_dependency 'jsonpath', '>= 0.1.2'
+  s.add_dependency 'cucumber', '>= 0.8.3'
+  s.add_development_dependency 'bueller'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/cucumber/api_steps.rb

@@ -1,165 +1,74 @@
-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)
+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 set headers:$/ do |headers|
-  headers.rows_hash.each {|k,v| header k, v }
+Given /^I send and accept JSON$/ do
+  page.driver.header 'Accept', 'application/json'
+  page.driver.header 'Content-Type', 'application/json'
 end
 
-Given /^I send and accept (XML|JSON)$/ do |type|
-  header 'Accept', "application/#{type.downcase}"
-  header 'Content-Type', "application/#{type.downcase}"
+When /^I authenticate as the user "([^\"]*)" with the password "([^\"]*)"$/ do |user, pass|
+  page.driver.authorize(user, pass)
 end
 
-Given /^I send and accept HTML$/ do
-  header 'Accept', "text/html"
-  header 'Content-Type', "application/x-www-form-urlencoded"
+When /^I send a GET request (?:for|to) "([^\"]*)"$/ do |path|
+  page.driver.get path
 end
 
-When /^I authenticate as the user "([^"]*)" with the password "([^"]*)"$/ do |user, pass|
-  authorize user, pass
+When /^I send a POST request to "([^\"]*)"$/ do |path|
+  page.driver.post path
 end
 
-When /^I digest\-authenticate as the user "(.*?)" with the password "(.*?)"$/ do |user, pass|
-  digest_authorize user, pass
+When /^I send a POST request to "([^\"]*)" with the following:$/ do |path, body|
+  page.driver.post path, body
 end
 
-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
+When /^I send a PUT request to "([^\"]*)" with the following:$/ do |path, body|
+  page.driver.put path, body
 end
 
-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
+When /^I send a DELETE request to "([^\"]*)"$/ do |path|
+  page.driver.delete path
 end
 
-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
+Then /^show me the response$/ do
+  p page.driver.last_response
 end
 
-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
+Then /^the response status should be "([^\"]*)"$/ do |status|
+  if page.respond_to? :should
+    page.driver.last_response.status.should == status.to_i
   else
-    if negative.present?
-      assert results.empty?
-    else
-      assert !results.empty?
-    end
+    assert page.driver.last_response.status == status.to_i
   end
 end
 
-
-Then /^the JSON response should (not)?\s?have "([^"]*)" with the text "([^"]*)"$/ do |negative, json_path, text|
-  json    = JSON.parse(last_response.body)
+Then /^the JSON response should have "([^\"]*)" with the text "([^\"]*)"$/ do |json_path, text|
+  json    = JSON.parse(page.driver.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
+  if page.respond_to? :should
+    results.should include(text)
   else
-    if negative.present?
-      assert !results.include?(text)
-    else
-      assert results.include?(text)
-    end
+    assert results.include?(text)
   end
 end
 
-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
+Then /^the JSON response should not have "([^\"]*)" with the text "([^\"]*)"$/ do |json_path, text|
+  json    = JSON.parse(page.driver.last_response.body)
+  results = JsonPath.new(json_path).on(json).to_a.map(&:to_s) 
+  if page.respond_to? :should
+    results.should_not include(text)
   else
-    if negative.present?
-      assert elements.empty?
-    else
-      assert !elements.empty?
-    end
+    assert !results.include?(text)
   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)
-  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
+  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

data/lib/cucumber/api_steps/version.rb

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

metadata

@@ -1,135 +1,118 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: cucumber-api-steps
-version: !ruby/object:Gem::Version
-  version: 0.2.0
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  version: "0.3"
 platform: ruby
-authors:
+authors: 
 - Jay Zeschin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-25 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-04-12 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: jsonpath
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.2
-  type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
     - - ">="
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 1
+        - 2
         version: 0.1.2
-- !ruby/object:Gem::Dependency
-  name: cucumber
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.2
   type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    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
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 8
+        - 3
+        version: 0.8.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bueller
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
     - - ">="
-      - !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
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  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
+  version_requirements: *id003
 description: Cucumber steps to easily test REST-based XML and JSON APIs
-email:
-- jay@zeschin.org
+email: 
+- jay.zeschin@factorylabs.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
-- ".gitignore"
-- ".travis.yml"
+
+files: 
+- .gitignore
+- .rvmrc
 - 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
-  requirements:
+required_ruby_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"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 1.4.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Cucumber steps to easily test REST-based XML and JSON APIs
-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
+test_files: []
+

checksums.yaml

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

data/.travis.yml

@@ -1,7 +0,0 @@
-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/README.md

@@ -1,91 +0,0 @@
-# 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/features/authentication.feature

@@ -1,21 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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