cucumber-api-steps 0.10 → 0.12

data/.gitignore

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

data/.rvmrc

@@ -1 +1 @@
-rvm use ree@cucumber-api-steps
+rvm use 1.9.3@cucumber-api-steps

data/.travis.yml

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

data/Gemfile

@@ -1,2 +1,13 @@
-source :rubygems 
+source 'https://rubygems.org'
+
 gemspec
+
+gem 'sinatra'
+gem 'rack-test'
+gem 'pry'
+gem 'activesupport'
+gem 'nokogiri'
+
+group :test do
+  gem 'rake'
+end

data/README.md

@@ -1,4 +1,7 @@
-# Cucumber API Steps
+# 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/aslakhellesoy/cucumber) step definitions utilizing
 [Rack-Test](https://github.com/brynary/rack-test) that ease basic
@@ -19,16 +22,65 @@ Add the following line to your Gemfile, preferably in the test or cucumber group
 Then add the following line to your env.rb to make the step definitions available in your features:
 
     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.  
+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
+
+    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"
 
-One major caveat is that the way the steps are currently built, the PUT and POST steps accept a heredoc-style string (demarcated with lines of three double quotes) as a body, instead of a hash as many people seem to expect.  I found this way to be more natural/flexible for how I write API tests, but it seems like others do not, so I'll be changing the steps to accept either a hash or a string soon.
+      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
 

data/Rakefile

@@ -5,3 +5,5 @@ 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

@@ -11,10 +11,12 @@ Gem::Specification.new do |s|
   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',  '>= 0.8.3'
-  s.add_development_dependency  'capybara'
+  s.add_dependency              'cucumber',  '>= 1.2.1'
+  s.add_dependency              'rspec',  '>= 2.12.0'
 
   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,33 @@
+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
+
+    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,25 @@
+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: 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,44 @@
+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|
+  last_response.body.should 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 '/'
+  last_request.env.slice(*headers_hash.keys).values.should eq(headers_hash.values)
+end
+
+Then /^I should be authenticated$/ do
+  last_request.env["HTTP_AUTHORIZATION"].should eq("Basic #{Base64.encode64("joe:god")}")
+end
+
+Then /^I should be digest authenticated$/ do
+  last_request.env["HTTP_AUTHORIZATION"].starts_with?("Digest ").should be_true
+end

data/features/support/env.rb

@@ -1,11 +1,23 @@
 require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
-require 'capybara/cucumber'
+require 'pry'
 
-# Capybara defaults to XPath selectors rather than Webrat's default of CSS3. In
-# order to ease the transition to Capybara we set the default here. If you'd
-# prefer to use XPath just remove this line and adjust any selectors in your
-# steps to use the XPath syntax.
-Capybara.default_selector = :css
-Capybara.default_driver = :rack_test
+require 'rack'
+require 'rack/test'
+require File.dirname(__FILE__) + "/../fixtures/fake_app"
 
-require 'cucumber/api_steps'
+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,54 +1,104 @@
 require 'jsonpath'
+require 'nokogiri'
 
-World(Rack::Test::Methods) if defined?(Rack)
+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)
+
+end
+
+Given /^I set headers:$/ do |headers|
+  headers.rows_hash.each {|k,v| header k, v }
+end
 
 Given /^I send and accept (XML|JSON)$/ do |type|
-  page.driver.header 'Accept', "application/#{type.downcase}"
-  page.driver.header 'Content-Type', "application/#{type.downcase}"
+  header 'Accept', "application/#{type.downcase}"
+  header 'Content-Type', "application/#{type.downcase}"
+end
+
+Given /^I send and accept HTML$/ do
+  header 'Accept', "text/html"
+  header 'Content-Type', "application/x-www-form-urlencoded"
 end
 
 When /^I authenticate as the user "([^"]*)" with the password "([^"]*)"$/ do |user, pass|
-  if page.driver.respond_to?(:basic_auth)
-    page.driver.basic_auth(user, pass)
-  elsif page.driver.respond_to?(:basic_authorize)
-    page.driver.basic_authorize(user, pass)
-  elsif page.driver.respond_to?(:browser) && page.driver.browser.respond_to?(:basic_authorize)
-    page.driver.browser.basic_authorize(user, pass)
-  elsif page.driver.respond_to?(:authorize)
-    page.driver.authorize(user, pass)
-  else
-    raise "Can't figure out how to log in with the current driver!"
-  end
+  authorize user, pass
+end
+
+When /^I digest\-authenticate as the user "(.*?)" with the password "(.*?)"$/ do |user, pass|
+  digest_authorize user, pass
 end
 
 When /^I send a (GET|POST|PUT|DELETE) request (?:for|to) "([^"]*)"(?: with the following:)?$/ do |*args|
   request_type = args.shift
   path = args.shift
-  body = args.shift
-  if body.present?
-    page.driver.send(request_type.downcase.to_sym, path, body)
-  else
-    page.driver.send(request_type.downcase.to_sym, path)
+  input = args.shift
+
+  request_opts = {method: request_type.downcase.to_sym}
+
+  unless input.nil?
+    if input.class == Cucumber::Ast::Table
+      request_opts[:params] = input.rows_hash
+    else
+      request_opts[:input] = input
+    end
   end
+
+  request path, request_opts
 end
 
-Then /^show me the response$/ do
-  json_response = JSON.parse(page.driver.response)
-  puts JSON.pretty_generate(json_response)
+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 /^the response status should be "([^"]*)"$/ do |status|
-  if page.respond_to? :should
-    page.driver.response.status.should == status.to_i
+  if self.respond_to? :should
+    last_response.status.should == status.to_i
   else
-    assert_equal status.to_i, page.driver.response.status
+    assert_equal status.to_i, last_response.status
   end
 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?(:should)
+    if negative.present?
+      results.should be_empty
+    else
+      results.should_not be_empty
+    end
+  else
+    if negative.present?
+      assert results.empty?
+    else
+      assert !results.empty?
+    end
+  end
+end
+
+
 Then /^the JSON response should (not)?\s?have "([^"]*)" with the text "([^"]*)"$/ do |negative, json_path, text|
-  json    = JSON.parse(page.driver.response.body)
+  json    = JSON.parse(last_response.body)
   results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
-  if page.respond_to?(:should)
+  if self.respond_to?(:should)
     if negative.present?
       results.should_not include(text)
     else
@@ -63,11 +113,29 @@ Then /^the JSON response should (not)?\s?have "([^"]*)" with the 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?(:should)
+    if negative.present?
+      elements.should be_empty
+    else
+      elements.should_not 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|
-  parsed_response = Nokogiri::XML(page.body)
+  parsed_response = Nokogiri::XML(last_response.body)
   elements = parsed_response.xpath(xpath)
-  if page.respond_to?(:should)
-    elements.should_not be_empty, "could not find #{xpath} in:\n#{page.body}"
+  if self.respond_to?(:should)
+    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}"
   else
     assert !elements.empty?, "could not find #{xpath} in:\n#{last_response.body}"
@@ -75,3 +143,23 @@ Then /^the XML response should have "([^"]*)" with the text "([^"]*)"$/ do |xpat
   end
 end
 
+Then /^the JSON response should be:$/ do |json|
+  expected = JSON.parse(json)
+  actual = JSON.parse(last_response.body)
+
+  if self.respond_to?(:should)
+    actual.should == 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?(:should)
+    results.length.should == 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.10"
+    VERSION = "0.12"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-api-steps
 version: !ruby/object:Gem::Version
-  version: '0.10'
+  version: '0.12'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-19 00:00:00.000000000 Z
+date: 2013-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonpath
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 1.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,23 +42,23 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 1.2.1
 - !ruby/object:Gem::Dependency
-  name: capybara
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 2.12.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.12.0
 description: Cucumber steps to easily test REST-based XML and JSON APIs
 email:
 - jay.zeschin@modeset.com
@@ -68,10 +68,17 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rvmrc
+- .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
@@ -84,9 +91,9 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ~>
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -100,4 +107,10 @@ signing_key:
 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