remote_http_testing 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in remote_http_testing.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,60 @@
+Remote Http Testing
+===================
+
+This module helps write integration tests which make HTTP requests to remote servers. Unlike Rack::Test, it doesn't make requests to an in-process Rack server. It uses Net::HTTP for making requests.
+
+Usage
+=====
+To use it, mix it in to your test case, specify the server your integration test is talking to, and begin
+making requests.
+
+    require "remote_http_testing"
+
+    class MyServiceIntegrationTest < Scope::TestCase
+
+      # This is the server all HTTP requests will be made to.
+      def server
+        "http://localhost:3000"
+      end
+
+      setup_once do
+        ensure_reachable!(server)
+      end
+
+      should "return a '401 Unauthorized' response when unaunthenticated" do
+        get "/users/123/profile"
+        assert_status 401
+      end
+    end
+
+Reference
+=========
+These methods are available to your test.
+
+    delete(url, params)
+
+    get(url, params)
+
+    patch(url, params)
+
+    post(url, params)
+
+    put(url, params)
+
+    last_response() - a Net::HTTPResponse object. Use last_response.body to get the response body.
+
+    dom_response() - The response body parsed using Nokogiri::HTML().
+
+    json_respones() - A hash of the response body, parsed using JSON.parse().
+
+    assert_status(status_code, optional_helpful_message)
+
+    ensure_reachable!(server_url, optional_server_display_name) - Exits if the given server is not reachable.
+
+Development
+===========
+When working on this gem, after you've made changes, you can include your modified gem into any app which uses bundler by adding the `:path` option in your Gemfile:
+
+    gem "remote_http_testing", :path => "~/path/to/remote_http_testing_repo"
+
+Then run `bundle install` from within your app. The installed gem is now symlinked to your local working copy of the gem.

data/Rakefile

@@ -0,0 +1,2 @@
+# Bundler provides some helpful gem creation and publishing tasks. `rake -T` to see them.
+require "bundler/gem_tasks"

data/lib/remote_http_testing.rb

@@ -0,0 +1,122 @@
+require "remote_http_testing/version"
+require "cgi"
+require "nokogiri"
+require "json"
+
+#
+# This module helps write integration tests which make HTTP requests to remote servers. Unlike Rack::Test,
+# it doesn't make requests to an in-process Rack server. Include it into your test case class.
+#
+# This module's API should match the API of Rack::Test. In the future, we should consider whether it's just as
+# easy to amend Rack::Test so that it can make requests to remote servers, since Rack::Test has supoprt for
+# other desirable features.
+#
+module RemoteHttpTesting
+  attr_accessor :last_response
+  attr_accessor :last_request
+  # You can set this to be a Hash, and these HTTP headers will be added to all requests.
+  attr_accessor :headers_for_request
+
+  # Define this method to return the URL of the HTTP server to talk to, e.g. "http://localhost:3000"
+  def server() raise "You need to define a server() method." end
+
+  def dom_response
+    @dom_response ||= Nokogiri::HTML(last_response.body)
+  end
+
+  def json_response
+    @json_response ||= JSON.parse(last_response.body)
+  end
+
+  # Prints out an error message and exits the program (to avoid running subsequent tests which are just
+  # going to fail) if the server is not reachable.
+  def ensure_reachable!(server_url, server_display_name = nil)
+    unless server_reachable?(server_url)
+      failure_message = server_display_name ? "#{server_display_name} at #{server_url}" : server_url
+      puts "FAIL: Unable to connect to #{failure_message}"
+      exit 1
+    end
+  end
+
+  # True if the server is reachable. Fails if the server can't be contacted within 2 seconds.
+  def server_reachable?(server_url)
+    uri = URI.parse(server_url)
+    request = Net::HTTP.new(uri.host, uri.port)
+    request.read_timeout = 2
+    response = nil
+    begin
+      response = request.request(create_request(server_url, :get))
+    rescue StandardError, Timeout::Error
+    end
+    !response.nil? && response.code.to_i == 200
+  end
+
+  def delete(url, params = {}, request_body = nil) perform_request(url, :delete, params, request_body) end
+  def get(url, params = {}, request_body = nil) perform_request(url, :get, params, request_body) end
+  def post(url, params = {}, request_body = nil) perform_request(url, :post, params, request_body) end
+  def put(url, params = {}, request_body = nil) perform_request(url, :put, params, request_body) end
+  def patch(url, params = {}, request_body = nil) perform_request(url, :patch, params, request_body) end
+
+  # Used by perform_request. This can be overridden by integration tests to append things to the request,
+  # like adding a login cookie.
+  def create_request(url, http_method, params = {}, request_body = nil)
+    uri = URI.parse(url)
+    RemoteHttpTesting::populate_uri_with_querystring(uri, params)
+    request_class = case http_method
+      when :delete then Net::HTTP::Delete
+      when :get then Net::HTTP::Get
+      when :post then Net::HTTP::Post
+      when :put then Net::HTTP::Put
+      when :patch then Net::HTTP::Patch
+    end
+    request = request_class.new(uri.request_uri)
+    request.body = request_body if request_body
+    headers_for_request.each { |key, value| request.add_field(key, value) } if headers_for_request
+    request
+  end
+
+  def perform_request(url, http_method, params = {}, request_body = nil)
+    self.last_response = @dom_response = @json_response = nil
+    url = self.server + url
+    uri = URI.parse(url)
+    self.last_request = create_request(url, http_method, params, request_body)
+    response = Net::HTTP.new(uri.host, uri.port).request(self.last_request) rescue nil
+    raise "Unable to connect to #{self.server}" if response.nil?
+    self.last_response = response
+  end
+
+  def self.populate_uri_with_querystring(uri, query_string_hash)
+    return if query_string_hash.nil? || query_string_hash == ""
+    key_values = query_string_hash.map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+    uri.query = uri.query.to_s.empty? ? key_values : "&" + key_values # uri.query can be nil
+  end
+
+  def assert_status(status_code, helpful_message = last_response.body)
+    assert_equal(status_code.to_i, last_response.code.to_i, helpful_message)
+  end
+
+  def assert_content_include?(string)
+    assert_block("Failed: content did not include the string: #{string}") { content_include?(string) }
+  end
+
+  def assert_content_not_include?(string)
+    assert_block("Failed: content should not have included this string but it did: #{string}") do
+      !content_include?(string)
+    end
+  end
+
+  def content_include?(string)
+    raise "No request was made yet, or no response was returned" unless last_response
+    last_response.body.include?(string)
+  end
+
+  # This is intended to provide similar functionality to the Rails assert_select helper.
+  # With no additional options, "assert_select('my_selector')" just ensures there's an element matching the
+  # given selector, assuming the response is structured like XML.
+  def assert_select(css_selector, options = {})
+    raise "You're trying to assert_select when there hasn't been a response yet." unless dom_response
+    assert_block("There were no elements matching #{css_selector}") do
+      !dom_response.css(css_selector).empty?
+    end
+  end
+end

data/lib/remote_http_testing/version.rb

@@ -0,0 +1,3 @@
+module RemoteHttpTesting
+  VERSION = "0.1.0"
+end

data/remote_http_testing.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+#
+# We created this project by running "bundle gem remote_http_testing".
+#
+$:.push File.expand_path("../lib", __FILE__)
+require "remote_http_testing/version"
+
+Gem::Specification.new do |s|
+  s.name        = "remote_http_testing"
+  s.version     = RemoteHttpTesting::VERSION
+  s.authors     = ["Phil Crosby"]
+  s.email       = ["phil.crosby@gmail.com"]
+  s.homepage    = "http://github.com/ooyala"
+  s.summary     = %q{A small library for making remote HTTP requests and response assertions in tests.}
+
+  s.rubyforge_project = "remote_http_testing"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "nokogiri"
+  s.add_runtime_dependency "json"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: remote_http_testing
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Phil Crosby
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-07 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: 
+- phil.crosby@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- lib/remote_http_testing.rb
+- lib/remote_http_testing/version.rb
+- remote_http_testing.gemspec
+has_rdoc: true
+homepage: http://github.com/ooyala
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: remote_http_testing
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A small library for making remote HTTP requests and response assertions in tests.
+test_files: []
+