fakettp 0.2.4.1 → 0.3.0

data/.gitignore

@@ -0,0 +1,6 @@
+tmp/**
+pkg
+install
+testinstall
+coverage
+tmtags

data/README.rdoc

@@ -0,0 +1,201 @@
+= FakeTTP
+
+== Purpose
+
+When you are writing acceptance/integration tests for an application which
+makes HTTP requests to a remote application, sometimes you need to be able
+to test the interactions in different scenarios without talking to a real
+instance of the remote application.
+
+FakeTTP is a standalone web application that allows you to mock requests (ie
+set and verify expectations on the requests your application makes, and
+return suitable responses to those requests).
+
+== Installation
+
+=== Install the gem
+
+Add GemCutter as a gem source (you only need to do this once):
+
+  gem sources -a http://gemcutter.org
+
+Then install FakeTTP:
+
+  sudo gem install fakettp
+
+Alternatively, you can specify the source when you install the gem:
+
+  sudo gem install fakettp --source http://gemcutter.org
+
+=== Create a FakeTTP directory
+
+You can install FakeTTP anywhere that your web server user can see it:
+
+  fakettp install <directory> <hostname>
+
+Set _hostname_ to the host you want to use for FakeTTP control requests (the
+examples below use <tt>fakettp.local</tt>). You can install multiple copies
+and run them independently by using different directories and hostnames (for
+example on a CI server to prevent clashes when building multiple projects
+in parallel).
+
+=== Point your web server at the directory
+
+FakeTTP should work with any Rack-compatible server: just point the server to
+the correct directory. For example, using Passenger[http://www.modrails.com/]
+(mod_rails) with Apache, create a virtual host along these lines:
+
+  <VirtualHost *:80>
+    ServerName fakettp.local
+    DocumentRoot "/path/to/fakettp/public"
+    <directory "/path/to/fakettp/public">
+      Order deny,allow
+      Deny from all
+      Allow from 127.0.0.1
+    </directory>
+  </VirtualHost>
+
+Then make sure <tt>fakettp.local</tt> resolves to 127.0.0.1 (assuming you're
+running the simulator on the same machine as the application under test), eg
+by adding the following line to <tt>/etc/hosts</tt>:
+
+  127.0.0.1	fakettp.local
+
+=== IMPORTANT: security note
+
+Because expectations are set by posting Ruby code to be executed on the
+server, you probably don't want any old Tom, Dick or Harry to be able to
+connect. The security settings in the virtual host config example above
+restrict access to clients running on the local machine.
+
+== Usage
+
+The examples below assume you've installed using the hostname
+<tt>fakettp.local</tt>. If you've used a different host, adjust appropriately.
+
+=== Resetting
+
+To reset FakeTTP (ie remove all expectations and errors), make an HTTP POST
+request to <tt>http://fakettp.local/reset</tt>.
+
+==== Calling from curl
+
+  curl fakettp.local/reset -X POST
+
+=== Setting expectations
+
+To create a new expectation, make an HTTP POST request to
+<tt>http://fakettp.local/expect</tt>, with a <em>Content-Type</em> header of
+'text/plain' and the request data containing a Ruby block to execute.
+
+The supplied code should be in the following format, and will generally
+consist of a number of assertions on the request, followed by creation of
+the response to return to the application under test.
+
+  expect "GET of /foo" do
+    request.host.should == 'fakettp.local'
+    request.path_info.should == '/foo'
+  
+    content_type 'text/plain'
+    "All is well\n"
+  end
+
+The label on the first line is used in error reporting.
+
+The expectation code has access to the underlying Sinatra request and
+response objects etc, as well as RSpec[http://rspec.info] matchers.
+
+==== Calling from curl
+
+Assuming the expectation is in <tt>expectation_file</tt>:
+
+curl -X POST fakettp.local/expect -X POST -H 'Content-Type:text/plain' --binary-data <expectation_file>
+
+=== Verifying
+
+To verify that all expectations have been met, make an HTTP GET request
+to <tt>http://fakettp.local/verify</tt>.
+
+If all is well, the response will be a <em>200 OK</em> with a body of 'OK'. Otherwise
+the status will be <em>400 Bad Request</em>, with a list of failures in the body. The
+failure messages include the complete details of the unexpected request that
+was received, to assist debugging.
+
+==== Calling from curl
+
+  curl fakettp.local/verify
+
+=== Web console
+
+Point your browser at http://fakettp.local/
+
+Currently this is very basic, just showing the expectations from the last run.
+
+=== Multiple faked hosts
+
+To have FakeTTP respond to multiple hostnames, create the appropriate hosts
+entries. If you're using name-based virtual hosts in Apache, add a
+_ServerAlias_ entry to the virtual host config, under the _ServerName_ line, eg:
+
+  ServerAlias foo.com bar.com
+
+== Change log
+
+0.3.0 (18 May 2009)
+
+* Now uses SQLite and ActiveRecord to store expectations, instead of the filesystem.
+* Supports specification of hostname on installation
+* HTML page showing expectations from the last run
+
+0.2.4.1 (5 May 2009)
+
+* Temporarily depend on edge version of Sinatra, to gain Rack 1.0 compatibility.
+
+0.2.4 (25 Mar 2009)
+
+* Fixed a bug which caused expectations to be run in the wrong order if there
+were more than nine of them.
+
+0.2.3 (19 Mar 2009)
+
+* Fixed a bug where expectations were being overwritten on Linux due to
+  Dir.entries not returning results in the expected order
+
+0.2.2 (18 Mar 2009)
+
+* Only accept control requests (reset, expect, verify) on fakettp.local
+
+0.2.1 (17 Mar 2009)
+
+* Fixed issue where rspec matchers weren't available to expectations
+
+0.2 (14 Mar 2009)
+
+* Complete rewrite, with tests and classes and stuff this time.
+
+If you get an 'unexpected return' error, remove the return statement from your
+expectation, and just put the return value on the last line of the _expect_ block.
+
+0.1.2 (13 Feb 2009)
+
+* Make sure README.html appears in generated gem
+
+0.1.1 (13 Feb 2009)
+
+* Fix permissions on installed tmp directory.
+
+0.1.0 (13 Feb 2009)
+
+* First release as a gem.
+
+== To Do
+
+* Add examples
+* Make control requests RESTful?
+* Show label in verification error for expected requests that weren't received
+* Add facility to stub as well as mock requests
+* Allow more flexibility in request ordering
+* Allow user-specific helper files in installation dir
+* Provide Ruby API to set expectations etc
+* Return the expected content type even if expectation fails
+* Highlight failed lines in console

data/Rakefile

@@ -0,0 +1,113 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+desc 'run specs, create gem, install and test'
+task :default => [:rcov, :verify_rcov, :gemspec, :build, :local_install, :test_install, :'cucumber:all', :ok]
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fakettp"
+    gem.summary = %Q{HTTP server mocking tool}
+    gem.description = gem.summary
+    gem.email = "kerryjbuckley@gmail.com"
+    gem.homepage = "http://github.com/kerryb/fakettp"
+    gem.authors = ["Kerry Buckley"]
+    gem.add_dependency 'sinatra-sinatra'
+    gem.add_dependency 'sqlite3-ruby'
+    gem.add_development_dependency 'jeweler'
+    gem.add_development_dependency 'rcov'
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "cucumber"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+  spec.rcov_opts = ['--exclude', 'spec']
+end
+
+task :spec => :check_dependencies
+
+desc 'Check spec coverage'
+RCov::VerifyTask.new(:verify_rcov) do |t|
+  t.threshold = 100.0
+  t.index_html = 'coverage/index.html'
+end
+
+begin
+  require 'cucumber/rake/task'
+  namespace :cucumber do
+    Cucumber::Rake::Task.new({:ok => :check_dependencies}, 'Run features that should pass') do |t|
+      t.cucumber_opts = "--color --tags ~@wip --strict --format 'pretty'"
+    end
+
+    Cucumber::Rake::Task.new({:wip => :check_dependencies}, 'Run features that are being worked on') do |t|
+      t.cucumber_opts = "--color --tags @wip:2 --wip --format 'pretty'"
+    end
+
+    desc 'Run all features'
+    task :all => [:ok, :wip]
+  end
+  desc 'Alias for cucumber:ok'
+  task :cucumber => 'cucumber:ok'
+rescue LoadError
+  task :cucumber do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "fakettp2 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'remove all build products'
+task :clean do
+  FileUtils.rm_rf %w(tmp install coverage pkg)
+end
+
+task :local_install do
+  system 'sudo gem in -l pkg/*'
+end
+
+desc 'Install FakeTTP into local install directory'
+task :test_install do
+  rm_rf 'install'
+  system 'fakettp install install fakettp.local'
+  touch 'install/tmp/restart.txt'
+end
+
+task :ok do
+  red    = "\e[31m"
+  yellow = "\e[33m"
+  green  = "\e[32m"
+  blue   = "\e[34m"
+  purple = "\e[35m"
+  bold   = "\e[1m"
+  normal = "\e[0m"
+  puts "", "#{bold}#{red}*#{yellow}*#{green}*#{blue}*#{purple}* #{green} ALL TESTS PASSED #{purple}*#{blue}*#{green}*#{yellow}*#{red}*#{normal}"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/features/control.feature

@@ -0,0 +1,12 @@
+Feature: Controlling the simulator
+  Scenario: Attempting to reset the simulator using the wrong host
+    When we post to /reset on foo.fake.local
+    Then the response body should contain 'Simulator received mismatched request'
+    
+  Scenario: Attempting to create an expectation using the wrong host
+    When we post to /expect on foo.fake.local
+    Then the response body should contain 'Simulator received mismatched request'
+    
+  Scenario: Attempting to verify the simulator using the wrong host
+    When we get /verify on foo.fake.local
+    Then the response body should contain 'Simulator received mismatched request'

data/features/dashboard.feature

@@ -0,0 +1,38 @@
+Feature: Dashboard for debugging failures
+  Scenario: Dashboard web page served from /
+    When we get / on fakettp.local
+    Then the response should have a content type of 'text/html'
+    And /html/head/title in the response should be 'FakeTTP'
+
+  Scenario: Expectations are listed
+    Given the simulator is reset
+    And there are 3 expectations
+    When we get / on fakettp.local
+    Then there should be 3 /html/body/div elements in the response
+    
+  Scenario: Show expectation heading and contents
+    Given the simulator is reset
+    And we expect get_root
+    When we get / on fakettp.local
+    Then //h1[1] in the response should be '1'
+    And //div[1]/pre in the response should be:
+      """
+      expect "GET /" do
+        request.path_info.should == '/'
+      end
+      """
+
+  @wip
+  Scenario: Highlight passed and failed lines
+    Given the simulator is reset
+    And we expect pass_and_fail
+    And we get / on foo.fake.local
+    When we get / on fakettp.local
+    Then //div[1]/pre in the response should be:
+      """
+      <span class="pass">expect "pass and fail" do
+        (2 + 2).should == 4</span>
+      <span class="fail">  true.should be_false</span>
+        'will never get here'
+      end
+      """

data/features/expectations.feature

@@ -0,0 +1,27 @@
+Feature: Expectations
+  Scenario: Using rspec matchers
+    Given the simulator is reset
+    And we expect expect_get
+    And we get / on foo.fake.local
+    Then verifying the simulator should report success
+    
+  Scenario: Setting response headers
+    Given the simulator is reset
+    And we expect set_response
+    And we get / on foo.fake.local
+    Then the response should have a 'foo' header with a value of 'bar'
+    And verifying the simulator should report success
+    
+  Scenario: Setting response content-type
+    Given the simulator is reset
+    And we expect set_response
+    And we get / on foo.fake.local
+    Then the response should have a content type of 'application/xml'
+    And verifying the simulator should report success
+    
+  Scenario: Setting response code
+    Given the simulator is reset
+    And we expect set_response
+    And we get / on foo.fake.local
+    Then the response body should be '<foo />'
+    And verifying the simulator should report success

data/features/expectations/expect_get

@@ -0,0 +1,3 @@
+expect "GET" do
+  request.should be_get
+end

data/features/expectations/get_foo

@@ -0,0 +1,3 @@
+expect "GET /foo" do
+  request.path_info.should == '/foo'
+end

data/features/expectations/get_root

@@ -0,0 +1,3 @@
+expect "GET /" do
+  request.path_info.should == '/'
+end

data/features/expectations/pass_and_fail

@@ -0,0 +1,5 @@
+expect "pass and fail" do
+  (2 + 2).should == 4
+  true.should be_false
+  'will never get here'
+end

data/features/expectations/set_response

@@ -0,0 +1,5 @@
+expect "Set header" do
+  response['foo'] = 'bar'
+  content_type 'application/xml'
+  '<foo />'
+end

data/features/step_definitions/expectations.rb

@@ -0,0 +1,5 @@
+Given /^there are (\d*) expectations$/ do |count|
+  count.to_i.times do
+    Fakettp::Expectation.create! :contents => 'foo'
+  end
+end

data/features/step_definitions/http.rb

@@ -0,0 +1,42 @@
+require 'hpricot'
+
+When /^we get (\S*) on (\S*)$/ do |path, host|
+  req = Net::HTTP::Get.new path
+  @@response = Net::HTTP.new(host).start {|http| http.request(req) }
+end
+When /^we post to (\S*) on (\S*)$/ do |path, host|
+  req = Net::HTTP::Post.new path
+  @@response = Net::HTTP.new(host).start {|http| http.request(req) }
+end
+
+Then /^the response should have a '(.*)' header with a value of '(.*)'$/ do |name, value|
+  @@response[name].should == value
+end
+
+Then /^the response should have a content type of '(.*)'$/ do |value|
+  @@response.content_type.should == value
+end
+
+Then /^the response body should be '(.*)'$/ do |value|
+  @@response.body.should == value
+end
+
+Then /^the response body should contain '(.*)'$/ do |value|
+  @@response.body.should include(value)
+end
+
+Then /^(\S*) in the response should be '(.*)'$/ do |locator, value|
+  check_value locator, value
+end
+
+Then /^(\S*) in the response should be:$/ do |locator, value|
+  check_value locator, value
+end
+
+def check_value locator, value
+  (Hpricot(@@response.body)/locator).inner_html.should == value
+end
+
+Then /^there should be (\d*) (.*) elements in the response$/ do |count, locator|
+  Hpricot(@@response.body).search(locator).size.should == count.to_i
+end