rspec-performance 0.0.3 → 0.1.0

data/Rakefile

@@ -24,4 +24,10 @@ task :publish do
   system "gem push rspec-performance-#{Spec::Performance::VERSION::STRING}.gem"
 end
 
+desc "Runs the integration test server"
+task "integration:run" do
+  require "spec/helpers/integration_server"
+  IntegrationServer.new(8888).run
+end
+
 # Gem packaging tasks

data/lib/rspec-performance.rb

@@ -1,4 +1,5 @@
 require "spec/performance/version"
-require "spec/performance/client"
+require "spec/client/http_client"
+require "spec/client/http/matcher/transaction_matchers"
 require "spec/performance/configuration"
 require "spec/performance/example/performance_example_group"

data/lib/spec/client/http/driver/curl_driver.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'curb'
+require 'uri'
+require 'cgi'
+
+# TODO: make an abstract parent driver class, and a spec for it
+
+module Spec
+  module Client
+    module Http
+      module Driver
+        class CurlDriver
+          def url_encode_params(params)
+            return nil if params.empty?
+
+            params.inject([]) do |query, (name, value)|
+              # TODO: come up with a better way to deal with true and false parameters
+              query << [name,value].collect {|s| s.nil? ? "" : s==false ? "0" : s==true ? "1" : CGI.escape(s.to_s)}.join('=')
+            end.join("&")
+          end
+
+          def initialize()
+          end
+
+          def execute(url, method, headers, params)
+            # Workaround for potential bug in curl
+            request_url = url
+            encoded_params = url_encode_params(params)
+
+            if method == "GET"
+              request_url += "?#{encoded_params}"
+            end
+
+            response_headers = {}
+            response_body = ""
+
+            curl = Curl::Easy.new(request_url)
+            curl.headers = headers
+
+            curl.on_header do |header|
+              size = header.size; header.chomp!
+              name, value = header.split(/\: /)
+              response_headers[name] ||= []
+              response_headers[name] << value
+              size
+            end
+
+            body_content = ""
+            curl.on_body do |body|
+              body_content += body
+              body.size
+            end
+
+            case method.upcase
+            when "GET"
+              curl.http_get
+            when "POST"
+              curl.http_post(encoded_params)
+            end
+
+            response = Response.new(url)
+            response.code = curl.response_code
+            response.headers = response_headers
+            response.body = body_content
+            response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spec/client/http/matcher/transaction_matchers.rb

@@ -0,0 +1,74 @@
+module Spec
+  module Client
+    module Http
+      module Matcher
+        module TransactionMatchers
+          class VerboseHttpMatcher
+            attr_accessor :transaction
+
+            def matches?(transaction)
+              @transaction = transaction
+              return transaction.is_a?(Spec::Client::Http::Transaction)
+            end
+
+            def transaction_info
+                "Request: #{transaction.request.url} using #{transaction.request.request_method}" + "\n" +
+                "  sent headers: #{transaction.request.headers}" + "\n" +
+                "  sent params: #{transaction.request.url_encoded_params}" + "\n" +
+                "Response code: #{transaction.response.code}" + "\n" +
+                "  with cookies: #{transaction.response.cookies}" + "\n" +
+                "  with html body: #{transaction.response.body}"
+            end
+
+            def failure_message
+              transaction_info
+            end
+
+            def negative_failure_message
+              transaction_info
+            end
+          end
+
+          class BeRedirect < VerboseHttpMatcher
+            def matches?(transaction)
+              super(transaction) && transaction.redirect?
+              #(300..399).include? transaction.response.code
+            end
+
+            def failure_message
+              "expected redirect? to return true, got false" + "\n" + super
+            end
+
+            def negative_failure_message
+              "expected redirect? to return false, got true" + "\n" + super
+            end
+          end
+
+          def be_redirect
+            BeRedirect.new()
+          end
+
+          class BeSuccess < VerboseHttpMatcher
+            def matches?(transaction)
+              super(transaction) && transaction.success?
+              #(200..299).include? transaction.response.code
+            end
+
+            def failure_message
+              "expected success? to return true, got false" + "\n" + super
+            end
+
+            def negative_failure_message
+              "expected success? to return false, got true" + "\n" + super
+            end
+          end
+
+          def be_success
+            BeSuccess.new()
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/spec/client/http/request.rb

@@ -0,0 +1,28 @@
+require "spec/client/http/request"
+require "spec/client/http/driver/curl_driver"
+
+module Spec
+  module Client
+    module Http
+      class Request
+        attr_accessor :url, :request_method, :params, :headers
+
+        def initialize(url, request_method, params, headers, driver=Driver::CurlDriver.new)
+          @url, @request_method, @params, @headers, @driver = url, request_method, params, headers, driver
+        end
+
+        def url_encoded_params
+          @driver.url_encode_params(params)
+        end
+
+        def execute
+          driver_execute(url,request_method,headers,params)
+        end
+
+        def driver_execute(url,request_method,headers,params)
+          @driver.execute(url,request_method,headers,params)
+        end
+      end
+    end
+  end
+end

data/lib/spec/client/http/response.rb

@@ -0,0 +1,32 @@
+require "spec/client/http/request"
+require "mechanize"
+require "uri"
+
+module Spec
+  module Client
+    module Http
+      class Response
+        attr_accessor :code, :headers, :body
+
+        def initialize(url)
+          @code = 0
+          @headers = {}
+          @body = ""
+          @url = url
+        end
+
+        def cookies
+          # TODO: can probably use ruby tricks to bind these together rather than using a temporary array...
+          tmp_cookies = []
+          (headers["Set-Cookie"]||[]).map do |raw_cookie|
+            uri = URI::parse(@url)
+            Mechanize::Cookie::parse(uri,raw_cookie) do |c|
+              tmp_cookies.push(c)
+            end
+          end
+          tmp_cookies
+        end
+      end
+    end
+  end
+end

data/lib/spec/client/http/session.rb

@@ -0,0 +1,41 @@
+require "spec/client/http/request"
+require "spec/client/http/response"
+require "spec/client/http/transaction"
+require "mechanize"
+require "uri"
+
+module Spec
+  module Client
+    module Http
+      class Session
+        attr_reader :client, :cookie_jar
+        
+        def initialize(client, options = {})
+          @client = client
+          @cookie_jar = Mechanize::CookieJar.new
+        end
+        
+        def get(url, params = {})
+          execute(Request.new(url, "GET", params, request_headers(url)))
+        end
+        
+        def post(url, params = {})
+          execute(Request.new(url, "POST", params, request_headers(url)))
+        end
+        
+        def request_headers(url)
+          { "Cookie" => @cookie_jar.cookies(URI::parse(url)) }
+        end
+
+        def execute(request)
+          transaction = Transaction.new(request)
+          transaction.execute
+          transaction.response.cookies.each do |cookie|
+            cookie_jar.add(URI::parse(transaction.request.url),cookie)
+          end
+          transaction
+        end
+      end
+    end
+  end
+end

data/lib/spec/client/http/transaction.rb

@@ -0,0 +1,29 @@
+require "spec/client/http/matcher/transaction_matchers"
+
+module Spec
+  module Client
+    module Http
+      class Transaction
+        attr_reader :request, :response
+
+        def initialize(request)
+          @request = request
+          @response = nil
+        end
+
+        def execute
+          @response = request.execute
+          self
+        end
+
+        def success?
+          (200..299).include? @response.code
+        end
+
+        def redirect?
+          (300..399).include? @response.code
+        end        
+      end
+    end
+  end
+end

data/lib/spec/client/http_client.rb

@@ -0,0 +1,32 @@
+require "uri"
+require "spec/client/http/session"
+
+module Spec
+  module Client
+    class HttpClient
+      attr_reader :session, :base_uri
+      
+      def initialize(base_uri)
+        @base_uri = base_uri
+        @session = Http::Session.new(self)
+      end
+
+      def new_session()
+        @session = Http::Session.new(self)
+      end
+      
+      def get(path, params = {})
+        session.get(full_url(path), params)
+      end
+      
+      def post(path, params = {})
+        session.post(full_url(path), params)
+      end
+      
+      def full_url(path)
+        URI.join(base_uri, path).to_s
+      end
+      
+    end
+  end
+end

data/lib/spec/performance/configuration.rb

@@ -50,7 +50,7 @@ module Spec
               :iterations => 20,
               :iterations_per_second => nil,
               :maximum_iteration_time => nil,
-              :performance_driver_class => Spec::Performance::Client::HttpClient,
+              :performance_driver_class => Spec::Client::HttpClient,
               :performance_driver_base_uri => "http://localhost/"
           }
         end

data/lib/spec/performance/example/performance_example_group_methods.rb

@@ -5,7 +5,6 @@ module Spec
     module Example
 
       module PerformanceExampleGroupMethods
-
         def perform(description, options = {}, backtrace = nil, &implementation)
           options = Spec::Performance::Configuration.configured_options.merge(options)
 

data/lib/spec/performance/example/performance_execution_builder.rb

@@ -41,6 +41,7 @@ module Spec
                 maximum_iteration_time = _calculate_average(current_iteration - 1, maximum_iteration_time, iteration_run_time)
               end
             end
+
             [example_run_time, maximum_iteration_time]
           end
 

data/lib/spec/performance/version.rb

@@ -2,8 +2,8 @@ module Spec
   module Performance
     module VERSION
       MAJOR = 0
-      MINOR = 0
-      TINY  = 3
+      MINOR = 1
+      TINY  = 0
 
       STRING = [MAJOR, MINOR, TINY].join(".")
     end

data/spec/helpers/integration_server.rb

@@ -1,5 +1,6 @@
 require "rubygems"
 require "thin"
+require "cgi"
 
 Thread.abort_on_exception = true
 
@@ -10,26 +11,44 @@ class IntegrationServer
     @running = false
   end
 
-  def self.base_url
-    "http://localhost:#{@@port}/"
-  end
+  class << self
+    def base_url
+      "http://127.0.0.1:#{@@port}/"
+    end
 
-  def self.instance
-    @@instance ||= new(@@port)
-  end
+    def instance
+      @@instance ||= new(@@port)
+    end
 
-  def self.start
-    instance.start
-  end
+    def start
+      instance.start
+    end
 
-  def self.kill
-    @@instance.kill
-  end
+    def kill
+      @@instance.kill
+    end
 
-  def self.port=(value)
-    @@port = value
+    def port=(value)
+      @@port = value
+    end
   end
 
+  def run
+    Thin::Server.start('0.0.0.0', @port) do
+      map "/hello" do
+        run HelloAdapter.new
+      end
+
+      map "/cookie_echo" do
+        run CookieEchoAdapter.new
+      end
+
+      map "/host_echo" do
+        run HostEchoAdapter.new
+      end
+    end
+  end
+  
   def running?
     @running
   end
@@ -39,19 +58,7 @@ class IntegrationServer
 
     Thin::Logging.silent = true
     @server_thread = Thread.new do
-      @server = Thin::Server.start('0.0.0.0', @port) do
-        map "/hello" do
-          run HelloAdapter.new
-        end
-
-        map "/cookie_echo" do
-          run CookieEchoAdapter.new
-        end
-
-        map "/host_echo" do
-          run HostEchoAdapter.new
-        end
-      end
+      @server = run
     end
     sleep 0.010 unless @server && @server.running?
     @running = true
@@ -73,13 +80,26 @@ class IntegrationServer
 
   class CookieEchoAdapter
     def call(env)
-      cookies = env["rack.input"].read.split(/&/).inject([]) do |acc, pair|
-        name, value = pair.split(/=/).map {|p| CGI::unescape(p) }
+      params = {}
+      params.merge!(parse_raw_params(env["rack.input"].read))
+      params.merge!(parse_raw_params(env["QUERY_STRING"]))
+      
+      cookies = params.inject([]) do |acc, (name, value)|
         acc << CGI::Cookie.new(name, value).to_s
         acc
       end
       cookie_string = cookies.join("\n")
-      [200, { "Set-Cookie" => cookie_string }, ["echo"]]
+      [200, { "Set-Cookie" => cookie_string }, ["echo: " + cookie_string]]
+    end
+    
+    def parse_raw_params(input)
+      return {} if input.empty?
+      
+      input.split(/&/).inject({}) do |parsed, pair|
+        name, value = pair.split(/\=/).map {|p| CGI::unescape(p) }
+        parsed[name] = value
+        parsed
+      end
     end
   end
 

data/spec/helpers/integration_server_spec.rb

@@ -1,20 +1,4 @@
 require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe IntegrationServer do
-  describe "HostEchoAdapter" do
-    describe "when HTTP_HOST is set by the client" do
-      it "echos the client specified value back" do
-        uri = URI.parse("http://localhost:8888/host_echo")
-        http = Net::HTTP.start(uri.host, uri.port)
-        response = http.get(uri.request_uri, { "Host" => "x.y.z.com" })
-        http.finish
-
-        response.body.should include("x.y.z.com")
-      end
-    end
-
-    describe "when HTTP_HOST is not set" do
-      it "defaults to the machine name"
-    end
-  end
 end

data/spec/lib/spec/client/http/driver/curl_driver_spec.rb

@@ -0,0 +1,46 @@
+require "#{File.dirname(__FILE__)}/../../../../../spec_helper"
+
+describe Spec::Client::Http::Driver::CurlDriver do
+  attr_reader :url, :params, :headers, :driver
+  before do
+    @url = "http://www.example.com"
+    @params = { "some[param]" => "encode me", "ok" => "done" }
+    @headers = { "Cookie", "hey=now" }
+    @driver = Spec::Client::Http::Driver::CurlDriver.new()
+  end
+
+  describe "#url_encode_params" do
+    describe "when there are params" do
+      it "creates a url encoded query string" do
+        @driver.url_encode_params(params).should include("some%5Bparam%5D=encode+me")
+        @driver.url_encode_params(params).should include("ok=done")
+        @driver.url_encode_params(params).should include("&")
+      end
+    end
+
+    describe "when there are no params" do
+      it "returns nil" do
+        @driver.url_encode_params({}).should be_nil
+      end
+    end
+  end
+
+  describe "#execute" do
+    describe "when the request is a GET" do
+      it "makes a get request" do
+        curler = mock(Curl::Easy.new(@url))
+        stub(Curl::Easy).new {curler}
+        curler.http_get
+        driver.execute(url, "GET", headers, params)
+      end
+    end
+    describe "when the request is a POST" do
+      it "makes a post request" do
+        curler = mock(Curl::Easy.new(@url))
+        stub(Curl::Easy).new {curler}
+        curler.http_post(anything)
+        driver.execute(url, "POST", headers, params)
+      end
+    end    
+  end
+end

data/spec/lib/spec/client/http/matcher/transaction_matchers_spec.rb

@@ -0,0 +1,130 @@
+require "#{File.dirname(__FILE__)}/../../../../../spec_helper"
+
+describe Spec::Client::Http::Matcher::TransactionMatchers do
+  attr_reader :transaction, :matcher
+
+  describe "DerivedVerboseHttpMatcher" do
+    before do
+      class DerivedVerboseHttpMatcher < Spec::Client::Http::Matcher::TransactionMatchers::VerboseHttpMatcher
+        def matches?(transaction)
+          super(transaction) && true
+        end
+      end
+      # make a transaction for testing
+      url = "http://www.example.com"
+      params = { "some[param]" => "encode me", "ok" => "done" }
+      headers = { "Cookie", "hey=now" }
+      driver = Spec::Client::Http::Driver::CurlDriver.new()
+      request = Spec::Client::Http::Request.new(url, "GET", params, {})
+      @transaction = Spec::Client::Http::Transaction.new(request)
+      transaction.execute
+      @matcher = DerivedVerboseHttpMatcher.new
+      matcher.matches?(transaction)
+    end
+
+    describe "#transaction_info" do
+      it "returns a string with information about the http transaction" do
+        matcher.transaction_info.include?("Request: #{transaction.request.url} using #{transaction.request.request_method}").should be_true
+        matcher.transaction_info.include?("  sent headers: #{transaction.request.headers}").should be_true
+        matcher.transaction_info.include?("Response code: #{transaction.response.code}").should be_true
+        matcher.transaction_info.include?("  with cookies: #{transaction.response.cookies}").should be_true
+      end
+    end
+
+    describe "#failure_message" do
+      it "contains the transaction info" do
+        matcher.failure_message.include?(matcher.transaction_info).should be_true
+      end
+    end
+
+    describe "#negative_failure_message" do
+      it "contains the transaction info" do
+        matcher.negative_failure_message.include?(matcher.transaction_info).should be_true
+      end
+    end
+  end
+
+  describe "BeRedirect" do
+    before do
+      # make a transaction for testing
+      url = "http://www.example.com"
+      params = { "some[param]" => "encode me", "ok" => "done" }
+      headers = { "Cookie", "hey=now" }
+      driver = Spec::Client::Http::Driver::CurlDriver.new()
+      request = Spec::Client::Http::Request.new(url, "GET", params, {})
+      @transaction = Spec::Client::Http::Transaction.new(request)
+      transaction.execute
+      @matcher = Spec::Client::Http::Matcher::TransactionMatchers::BeRedirect.new
+      matcher.matches?(transaction)
+    end
+
+    describe "#matches?" do
+      describe "transaction is a redirect" do
+        it "returns true" do
+          stub(transaction).redirect? {true}
+          matcher.matches?(transaction).should be_true
+        end
+      end
+      describe "transaction is not a redirect" do
+        it "returns false" do
+          stub(transaction).redirect? {false}
+          matcher.matches?(transaction).should be_false
+        end
+      end
+    end
+
+    describe "#failure_message" do
+      it "contains the transaction info" do
+        matcher.failure_message.include?(matcher.transaction_info).should be_true
+      end
+    end
+
+    describe "#negative_failure_message" do
+      it "contains the transaction info" do
+        matcher.negative_failure_message.include?(matcher.transaction_info).should be_true
+      end
+    end
+  end
+
+  describe "BeSuccess" do
+    before do
+      # make a transaction for testing
+      url = "http://www.example.com"
+      params = { "some[param]" => "encode me", "ok" => "done" }
+      headers = { "Cookie", "hey=now" }
+      driver = Spec::Client::Http::Driver::CurlDriver.new()
+      request = Spec::Client::Http::Request.new(url, "GET", params, {})
+      @transaction = Spec::Client::Http::Transaction.new(request)
+      transaction.execute
+      @matcher = Spec::Client::Http::Matcher::TransactionMatchers::BeSuccess.new
+      matcher.matches?(transaction)
+    end
+
+    describe "#matches?" do
+      describe "transaction is successful" do
+        it "returns true" do
+          stub(transaction).success? {true}
+          matcher.matches?(transaction).should be_true
+        end
+      end
+      describe "transaction is not successful" do
+        it "returns false" do
+          stub(transaction).success? {false}
+          matcher.matches?(transaction).should be_false
+        end
+      end
+    end
+
+    describe "#failure_message" do
+      it "contains the transaction info" do
+        matcher.failure_message.include?(matcher.transaction_info).should be_true
+      end
+    end
+
+    describe "#negative_failure_message" do
+      it "contains the transaction info" do
+        matcher.negative_failure_message.include?(matcher.transaction_info).should be_true
+      end
+    end
+  end
+end

data/spec/lib/spec/client/http/request_spec.rb

@@ -0,0 +1,26 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Client::Http::Request do
+  attr_reader :url, :params, :headers, :request
+  before do
+    @url = "http://www.example.com"
+    @params = { "some[param]" => "encode me", "ok" => "done" }
+    @headers = { "Cookie", "hey=now" }
+    @request = Spec::Client::Http::Request.new(url, "GET", params, headers)
+  end
+
+  describe "#initialize" do
+    it "populates the readers" do
+      request.url == url
+      request.params == params
+      request.headers == headers
+    end
+  end
+
+  describe "#execute" do
+    it "makes an http request via the driver" do
+      mock(request).driver_execute(url, "GET", headers, params)
+      response = request.execute
+    end
+  end
+end

data/spec/lib/spec/client/http/response_spec.rb

@@ -0,0 +1,25 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Client::Http::Response do
+  describe "#cookies" do
+    attr_reader :response
+    before do
+      @response = Spec::Client::Http::Response.new("http://www.example.com")
+      response.headers = { "Set-Cookie" => ["foo=bar", "baz=bang; domain=.example.com"] }
+    end
+
+    def assert_cookies_equal(actual, expected)
+      actual.name.should == expected.name
+      actual.value.should == expected.value
+      actual.domain.should == expected.domain
+      actual.path.should == expected.path
+      actual.expires.should == expected.expires
+    end
+
+    it "returns an array of cookies" do
+      response.cookies.size.should == 2
+      assert_cookies_equal(response.cookies.first, Mechanize::Cookie::parse(URI::parse("http://www.example.com"), "foo=bar") {|c| c}.first)
+      assert_cookies_equal(response.cookies.last, Mechanize::Cookie::parse(URI::parse("http://www.example.com"), "baz=bang; domain=.example.com"){|c| c}.first)
+    end
+  end
+end

data/spec/lib/spec/client/http/session_spec.rb

@@ -0,0 +1,64 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Client::Http::Session do
+  class TestClient
+    def intialize
+    end
+
+    def get(url, params = {})
+    end
+
+    def post(url, params = {})
+    end
+  end
+
+  class TestRequest < Spec::Client::Http::Request
+    def driver_execute(url,method,headers,params)
+      Spec::Client::Http::Response.new(url)
+    end
+  end
+
+  attr_reader :client
+  before do
+    @client = TestClient.new
+  end
+
+  describe "#intialize" do
+    it "creates a new cookie jar" do
+      session = Spec::Client::Http::Session.new(client)
+      session.client.should == client
+      session.cookie_jar.should be_a(Mechanize::CookieJar)
+    end
+  end
+
+  describe "#get" do
+    it "calls execute with a new get request" do
+      session = Spec::Client::Http::Session.new(client)
+      mock(session).execute(anything) do |request|
+        request.should be_a(Spec::Client::Http::Request)
+        request.request_method.should == "GET"
+      end
+
+      session.get("http://127.0.0.1", {})
+    end
+  end
+
+  describe "#post" do
+    it "calls execute with a new post request" do
+      session = Spec::Client::Http::Session.new(client)
+      mock(session).execute(anything) do |request|
+        request.should be_a(Spec::Client::Http::Request)
+        request.request_method.should == "POST"        
+      end
+      session.post("http://127.0.0.1", {})
+    end
+  end
+
+  describe "#execute" do
+    it "makes a request and returns the Transaction" do
+#      mock.instance_of(Spec::Client::Http::Transaction).execute
+      session = Spec::Client::Http::Session.new(client)
+      transaction = session.execute(TestRequest.new("http://127.0.0.1/", "GET", {}, {}))
+    end
+  end
+end

data/spec/lib/spec/client/http/transaction_spec.rb

@@ -0,0 +1,76 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Client::Http::Transaction do
+  attr_reader :request, :response
+  before do
+    @request = Spec::Client::Http::Request.new("http://example.com", "GET", {}, {})
+    @response = Spec::Client::Http::Response.new(@request.url)
+  end
+
+  describe "#execute" do
+    it "executes the request and sets the response" do
+      mock(request).execute { "foo" }
+
+      transaction = Spec::Client::Http::Transaction.new(request)
+      transaction.execute.should == transaction
+      transaction.response.should == "foo"
+    end
+  end
+
+  describe "#success?" do
+    describe "when the response code is an http success code" do
+      before do
+        response.code = 201
+        mock(request).execute { response }
+      end
+
+      it "returns true" do
+        transaction = Spec::Client::Http::Transaction.new(request)
+        transaction.execute
+        transaction.should be_success
+      end
+    end
+
+    describe "when the response code is NOT an http success code" do
+      before do
+        response.code = 300
+        mock(request).execute { response }
+      end
+
+      it "returns false" do
+        transaction = Spec::Client::Http::Transaction.new(request)
+        transaction.execute
+        transaction.should_not be_success
+      end
+    end
+  end
+
+  describe "#redirect?" do
+     describe "when the response code is an http redirect code" do
+      before do
+        response.code = 302
+        mock(request).execute { response }
+      end
+
+      it "returns true" do
+        transaction = Spec::Client::Http::Transaction.new(request)
+        transaction.execute
+        transaction.should be_redirect
+      end
+    end
+
+    describe "when the response code is NOT an http redirect code" do
+      before do
+        response.code = 400
+        mock(request).execute { response }
+      end
+
+      it "returns false" do
+        transaction = Spec::Client::Http::Transaction.new(request)
+        transaction.execute
+        transaction.should_not be_redirect
+      end
+    end
+
+  end
+end

data/spec/lib/spec/client/http_client_spec.rb

@@ -0,0 +1,21 @@
+require "#{File.dirname(__FILE__)}/../../../spec_helper"
+
+describe Spec::Client::HttpClient do
+
+  describe "#full_url" do
+    it "creates a full url from base_uri and a path" do
+      full_url = Spec::Client::HttpClient.new("http://example.com").full_url("foo")
+      full_url.should == "http://example.com/foo"
+    end
+  end
+
+  describe "#new_session" do
+    it "empties cookies" do
+      client = Spec::Client::HttpClient.new("http://example.com")
+      client.session.cookie_jar.add(URI::parse("http://example.com"),Mechanize::Cookie::parse(URI::parse("http://example.com"), "foo=bar") {|c| c}.first)
+      client.session.cookie_jar.cookies(URI::parse("http://example.com")).should_not be_empty
+      client.new_session()
+      client.session.cookie_jar.cookies(URI::parse("http://example.com")).should be_empty
+    end
+  end
+end

data/spec/lib/spec/performance/example/performance_example_group_methods_spec.rb

@@ -84,7 +84,7 @@ describe Spec::Performance::Example::PerformanceExampleGroupMethods do
           it "reports the success" do
             example_group.perform("reports the success", spec_options) { 1.should == 1 }
             example_group.run(fake_run_options)
-            
+
             fake_run_options.reporter.example_failures.should be_empty
             example = fake_run_options.reporter.example_successes.first
             example.description.should == "reports the success" 

data/spec/lib/spec/performance/example/performance_example_group_spec.rb

@@ -33,10 +33,10 @@ describe Spec::Performance::Example::PerformanceExampleGroup do
       example_group.run(fake_run_options)
       fake_run_options.reporter.example_failures.should be_empty
 
-      driver_instance_in_first_perform_block.should be_a(Spec::Performance::Client::HttpClient)
+      driver_instance_in_first_perform_block.should be_a(Spec::Client::HttpClient)
       driver_instance_in_before_block.base_uri.should == "http://localhost/"
 
-      driver_instance_in_second_perform_block.should be_a(Spec::Performance::Client::HttpClient)
+      driver_instance_in_second_perform_block.should be_a(Spec::Client::HttpClient)
       driver_instance_in_second_perform_block.base_uri.should == "http://localhost/"
 
       driver_instance_in_first_perform_block.eql?(driver_instance_in_second_perform_block).should be_false

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ begin
   require "spec"
 rescue LoadError
   require "rubygems" unless ENV["NO_RUBYGEMS"]
-  gem "rspec"
+  gem "spec"
   require "spec"
 end
 

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-performance
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Bob Remeika
@@ -9,10 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-02 00:00:00 -08:00
+date: 2010-05-21 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
 description: rspec-performance adds a couple of utility methods for unit testing performance
 email: bob@grockit.com
 executables: []
@@ -23,9 +44,13 @@ extra_rdoc_files: []
 
 files: 
 - lib/rspec-performance.rb
-- lib/spec/performance/client/http_client.rb
-- lib/spec/performance/client/response.rb
-- lib/spec/performance/client.rb
+- lib/spec/client/http/driver/curl_driver.rb
+- lib/spec/client/http/matcher/transaction_matchers.rb
+- lib/spec/client/http/request.rb
+- lib/spec/client/http/response.rb
+- lib/spec/client/http/session.rb
+- lib/spec/client/http/transaction.rb
+- lib/spec/client/http_client.rb
 - lib/spec/performance/configuration.rb
 - lib/spec/performance/example/performance_example_group.rb
 - lib/spec/performance/example/performance_example_group_methods.rb
@@ -33,7 +58,13 @@ files:
 - lib/spec/performance/version.rb
 - spec/helpers/integration_server.rb
 - spec/helpers/integration_server_spec.rb
-- spec/lib/spec/performance/client/http_client_spec.rb
+- spec/lib/spec/client/http/driver/curl_driver_spec.rb
+- spec/lib/spec/client/http/matcher/transaction_matchers_spec.rb
+- spec/lib/spec/client/http/request_spec.rb
+- spec/lib/spec/client/http/response_spec.rb
+- spec/lib/spec/client/http/session_spec.rb
+- spec/lib/spec/client/http/transaction_spec.rb
+- spec/lib/spec/client/http_client_spec.rb
 - spec/lib/spec/performance/configuration_spec.rb
 - spec/lib/spec/performance/example/performance_example_group_methods_spec.rb
 - spec/lib/spec/performance/example/performance_example_group_spec.rb
@@ -51,21 +82,27 @@ 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"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: 
 - rspec-1.2.6
 rubyforge_project: rspec-performance
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Ruby based make-like utility.

data/lib/spec/performance/client.rb

@@ -1 +0,0 @@
-require "spec/performance/client/http_client"

data/lib/spec/performance/client/http_client.rb

@@ -1,94 +0,0 @@
-require "net/http"
-require "cgi"
-require "spec/performance/client/response"
-
-module Spec
-  module Performance
-    module Client
-      class HttpClient
-        attr_writer :recording, :cookies
-        attr_reader :base_uri, :cookies
-
-        def initialize(base_uri)
-          @base_uri = base_uri
-          @headers = {}
-          @cookies = {}
-          @recording = true
-        end
-
-        def post(uri, params = {})
-          request = Net::HTTP::Post.new(uri.path, headers)
-          request.form_data = params
-          request.basic_auth uri.user, uri.password if uri.user
-          response = Net::HTTP.new(uri.host, uri.port).start do |http|
-            http.request(request)
-          end
-          capture(response) if recording?
-          create_http_client_response(response)
-        end
-
-        def get(uri, params = {})
-          if params && params.size > 0
-            query = params2query(params)
-            uri = URI.parse("#{uri}?#{query}")
-          end
-
-          http = Net::HTTP.start(uri.host, uri.port)
-          response = http.get(uri.request_uri, headers)
-          http.finish
-
-          create_http_client_response(response)
-        end
-
-        def add_header(key, value)
-          @headers[key] = value
-        end
-
-        def remove_header(key)
-          @headers.delete(key)
-        end
-
-        def recording?
-          @recording
-        end
-
-        private
-
-        def params2query(hash)
-          q = hash.inject([]) do |acc, (k, v)|
-            acc << CGI::escape(k.to_s) + "=" + CGI::escape(v.to_s)
-          end.join("&")
-        end
-
-        def capture(response)
-          if raw_cookies = response.get_fields("Set-Cookie")
-            cookie_jar = raw_cookies.inject({}) do |parsed_cookies, raw_cookie_string|
-              CGI::Cookie.parse(raw_cookie_string).each do |name, cookie|
-                parsed_cookies[name.to_sym] = cookie
-              end
-              parsed_cookies
-            end
-            @cookies.merge!(cookie_jar)
-          end
-        end
-
-        def headers
-          @headers.merge("Cookie" => browser_cookies)
-        end
-
-        def browser_cookies
-          cookies_to_send = @cookies.values.reject {|cookie| cookie.name == "path" || cookie.name == "domain" }
-          cookies_to_send.map do |cookie|
-            CGI::escape(cookie.name) + "=" + CGI::escape(cookie.value.first)
-          end.join("; ")
-        end
-
-        def create_http_client_response(net_http_response)
-          attributes = { :code => net_http_response.code,
-                         :body => net_http_response.body  }
-          Response.new(attributes)
-        end
-      end
-    end
-  end
-end

data/lib/spec/performance/client/response.rb

@@ -1,25 +0,0 @@
-
-module Spec
-  module Performance
-    module Client
-
-      class Response
-        attr_reader :code, :body, :cookies
-
-        def initialize(attributes = {})
-          @code = attributes[:code].to_i
-          @body = attributes[:body]
-        end
-
-        def success?
-          @code == 200
-        end
-
-        def redirect?
-          @code == 301 || @code == 302
-        end
-      end
-
-    end
-  end
-end

data/spec/lib/spec/performance/client/http_client_spec.rb

@@ -1,112 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../../../spec_helper"
-
-describe Spec::Performance::Client::HttpClient do
-  attr_reader :client
-
-  before do
-    @client = Spec::Performance::Client::HttpClient.new("http://localhost")
-  end
-
-  describe "#initialize" do
-    it "initializes the cookie jar" do
-      client.cookies.should be_a(Hash)
-    end
-  end
-
-  describe "#post" do
-    attr_reader :uri, :params
-    before do
-      @uri = URI.join(IntegrationServer.base_url, "hello")
-      @params = { :foo => "bar", :baz => "quux" }
-    end
-
-    it "makes an HTTP post" do
-      mock.instance_of(Net::HTTP).request(anything) do |request|
-        request.should be_a(Net::HTTP::Post)
-        stub(Net::HTTPResponse.new(1.1, 200, nil)).body { "stubbed response body" }        
-      end
-      client.post(uri, params).should be_success
-    end
-
-    it "returns a response object" do
-      client.post(uri, params).should be_a(Spec::Performance::Client::Response)
-    end
-
-    describe "when the client is recording" do
-      before do
-        @uri = URI.join(IntegrationServer.base_url, "cookie_echo")
-        client.should be_recording
-      end
-
-      it "captures the cookie from the response" do
-        client.post(uri, params).should be_success
-        client.cookies[:foo].value.first.should == "bar"
-        client.cookies[:baz].value.first.should == "quux"
-      end
-    end
-
-    describe "when the client is not recording" do
-      before do
-        @uri = URI.join(IntegrationServer.base_url, "cookie_echo")
-        client.recording = false
-        client.should_not be_recording
-      end
-
-      it "does not capture cookies" do
-        client.post(uri, params).should be_success
-        client.cookies.should_not have_key(:foo)
-        client.cookies.should_not have_key(:baz)
-      end
-    end
-  end
-
-  describe "#get" do
-    attr_reader :uri, :params
-    before do
-      @params = { :monster_truck => "Truckasaurus", :us_president => "Grover Cleveland" }
-      @uri = URI.join(IntegrationServer.base_url, "hello")
-    end
-
-    it "sends an HTTP get request, sending the current cookies" do
-      expected_cookie  = CGI::Cookie.new("cookie-name", "cookie-value")
-      expected_headers = { "Cookie" => "cookie-name=cookie-value" }
-      client.cookies   = { "cookie-name".to_sym => expected_cookie }
-
-      mock_http = Object.new
-      mock(Net::HTTP).start("localhost", 8888) { mock_http }
-      mock(mock_http).get(anything, expected_headers) do |request_uri, headers|
-        request_uri.index("/hello?").should == 0
-        request_uri.should include("monster_truck=Truckasaurus")
-        request_uri.should include("us_president=Grover+Cleveland")
-        request_uri.should include("&")
-
-        stub(Net::HTTPResponse.new(1.1, 200, nil)).body { "stubbed response body" }
-      end
-      mock(mock_http).finish
-
-      response = client.get(uri, params)
-    end
-
-    it "returns a response object" do
-      response = client.get(uri, params)
-      response.should be_a(Spec::Performance::Client::Response)
-      response.should be_success
-    end
-
-    describe "when the client is recording" do
-      it "captures the cookie from the response" do
-      end
-    end
-
-    describe "when the client is not recording" do
-      it "does not capture" do
-      end
-    end
-  end
-
-  describe "#restore" do
-    it "resets after each run" do
-    end
-  end
-
-end