weary 0.7.2 → 1.0.0.rc1

data/spec/weary/client_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'rack/lobster'
+
+describe Weary::Client do
+  describe "::resource" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "defines a user resource" do
+      resource = subject.resource :show, "GET", @url
+      resource.should be_a Weary::Resource
+    end
+
+    it "allows the resource to be further modified by a block" do
+      new_url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = subject.resource :show, "GET", @url do |r|
+        r.url new_url
+      end
+      resource.url.variables.size.should eql 2
+    end
+  end
+
+  Weary::Client::REQUEST_METHODS.each do |request_method|
+    describe "::#{request_method}" do
+      before do
+        @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      end
+
+      subject { Class.new(Weary::Client) }
+
+      it "creates a class method named the same as the request method" do
+        subject.should respond_to request_method
+      end
+
+      it "is a convenience method for ::resource" do
+        upcase_method = request_method.to_s.upcase
+        subject.stub(:resource) { Weary::Resource.new upcase_method, @url }
+        subject.should_receive(:resource).with(:name, upcase_method, @url)
+        subject.send(request_method, :name, @url) {|r| r.basic_auth! }
+      end
+    end
+  end
+
+  describe "::domain" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "prepends the domain to the path when creating resources" do
+      repo = {:user => "mwunsch", :repo => "weary"}
+      subject.domain "http://github.com/api/v2/json/repos"
+      resource = subject.get :show, "/show/{user}/{repo}"
+      resource.url.expand(repo).to_s.should eql @url
+    end
+  end
+
+  describe "::optional" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "passes optional requirements to the resources" do
+      param = :username
+      subject.optional param
+      resource = subject.get :show, @url
+      resource.optional.should include param
+    end
+  end
+
+  describe "::required" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "passes optional requirements to the resources" do
+      param = :username
+      subject.required param
+      resource = subject.get :show, @url
+      resource.required.should include param
+    end
+  end
+
+  describe "::defaults" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "passes default parameters into the resources" do
+      params = { :foo => "baz" }
+      subject.defaults params
+      resource = subject.get :show, @url
+      resource.defaults.should eql params
+    end
+  end
+
+  describe "::headers" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "passes headers into the resources" do
+      header = {'User-Agent' => "RSpec"}
+      subject.headers header
+      resource = subject.get :show, @url
+      resource.headers.should eql header
+    end
+  end
+
+  describe "::use" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "adds a middleware to a stack and passes it into subsequent requests" do
+      subject.use Rack::Lobster
+      subject.get :show, @url
+      client = subject.new
+      stack = client.show.instance_variable_get :@middlewares
+      stack.flatten.should include Rack::Lobster
+    end
+  end
+
+  describe "::resources" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "is a map of all the resources of the class" do
+      action = :show
+      resource = subject.get action, @url
+      subject.resources[action].should be resource
+    end
+  end
+
+  describe "::[]=" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "stores a named Weary::Resource" do
+      action = :show
+      resource = Weary::Resource.new "GET", @url
+      subject[action] = resource
+      subject.resources[action].should be resource
+    end
+
+    it "raises an error if a resource is not passed" do
+      action = :show
+      expect { subject[action] = "not a resource" }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "::[]" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    subject { Class.new(Weary::Client) }
+
+    it "retrieves a stored resource" do
+      action = :show
+      resource = subject.get action, @url
+      subject[action].should be resource
+    end
+  end
+
+  describe "::route" do
+    before do
+      @client = Class.new(Weary::Client)
+      @client.domain "https://api.github.com"
+      @client.get(:list, "/user/repos") {|r| r.basic_auth! }
+      @client.get(:user, "/users/{user}/repos")
+      @client.post(:create, "/user/repos") {|r| r.basic_auth! }
+      @client.get(:repo, "/users/{user}/{repo}")
+      @client.patch(:edit, "/users/{user}/{repo}") {|r| r.basic_auth! }
+    end
+
+    it "returns a router for the resources" do
+      @client.route.should be_a Weary::Route
+    end
+  end
+
+  describe "::call" do
+    before do
+      @client = Class.new(Weary::Client)
+      @client.domain "https://api.github.com"
+      @client.get(:list, "/user/repos") {|r| r.basic_auth! }
+      @client.get(:user, "/users/{user}/repos")
+      @client.post(:create, "/user/repos") {|r| r.basic_auth! }
+      @client.get(:repo, "/users/{user}/{repo}")
+      @client.patch(:edit, "/users/{user}/{repo}") {|r| r.basic_auth! }
+    end
+
+    it_behaves_like "a Rack application" do
+      subject { @client }
+      let(:env) { @client.resources[:list].request.env }
+    end
+  end
+
+  describe "#initialize" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      @klass = Class.new(Weary::Client)
+    end
+
+    it "responds to a method with the name of the resource" do
+      action = :show_repo
+      @klass.get action, @url
+      client = @klass.new
+      client.should respond_to action
+    end
+
+    it "returns a Weary::Request when calling the named method" do
+      action = :show
+      @klass.get action, @url
+      client = @klass.new
+      client.send(action).should be_a Weary::Request
+    end
+
+    it "generates a method for the resource that takes a set of parameters" do
+      action = :show
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      @klass.get action, url
+      client = @klass.new
+      request = client.send(action, :user => "mwunsch", :repo => "weary")
+      request.uri.to_s.should eql @url
+    end
+
+    it "combines a @defaults instance_variable with params on method execution" do
+      action = :show
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      @klass.get action, url
+      client = @klass.new
+      client.instance_variable_set :@defaults, :user => "mwunsch", :repo => "weary"
+      expect { client.send(action) }.to_not raise_error
+    end
+  end
+
+end

data/spec/weary/deferred_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'weary/deferred'
+
+describe Weary::Deferred do
+  before :all do
+    @struct = Struct.new "Deferred", :response
+  end
+
+  before do
+    @request = Weary::Request.new "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    adapter = Class.new { include Weary::Adapter }
+    @request.adapter adapter
+  end
+
+  describe "::new" do
+    it "creates a new deffered proxy object around a model" do
+      deferred = described_class.new @request.perform, @struct
+      deferred.should be_instance_of @struct
+    end
+
+    it "with a factory method" do
+      deferred = described_class.new @request.perform, @struct, lambda {|model, response| response.status }
+      deferred.should eq 501
+    end
+  end
+
+  describe "#complete?" do
+    it "is true when the target is ready" do
+      deferred = described_class.new @request.perform, @struct
+      deferred.inspect
+      deferred.complete?.should be_true
+    end
+  end
+
+end

data/spec/weary/env_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Weary::Env do
+  describe "#env" do
+    it_behaves_like "a Rack env" do
+      subject do
+        req = Weary::Request.new("http://github.com/api/v2/json/repos/show/mwunsch/weary")
+        described_class.new(req).env
+      end
+    end
+  end
+end

data/spec/weary/middleware/basic_auth_spec.rb

@@ -0,0 +1,23 @@
+require 'weary/middleware/basic_auth'
+require 'spec_helper'
+
+describe Weary::Middleware::BasicAuth do
+  describe "#call" do
+    before do
+      @request = Weary::Request.new("http://github.com/api/v2/json/repos/show/mwunsch/weary")
+      @url = "http://mwunsch:secret@github.com/api/v2/json/repos/show/mwunsch/weary"
+      stub_request :get, @url
+    end
+
+    it_behaves_like "a Rack application" do
+      subject { described_class.new(@request, ["mwunsch", "secret"]) }
+      let(:env) { @request.env }
+    end
+
+    it "prepares the Authorization header for the request" do
+      middleware = described_class.new(@request, ["mwunsch", "secret"])
+      middleware.call(@request.env)
+      a_request(:get, @url).should have_been_made
+    end
+  end
+end

data/spec/weary/middleware/content_type_spec.rb

@@ -0,0 +1,34 @@
+require 'weary/middleware/content_type'
+require 'spec_helper'
+
+describe Weary::Middleware::ContentType do
+  describe "#call" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      @request = Weary::Request.new @url, 'POST'
+      stub_request :post, @request.uri.to_s
+    end
+
+    it_behaves_like "a Rack application" do
+      subject { described_class.new(@request) }
+      let(:env) { @request.env }
+    end
+
+    it "adds a Content-Type header to the request" do
+      middleware = described_class.new(@request)
+      middleware.call(@request.env)
+      a_request(:post, @url).
+        with {|req| req.headers.has_key?("Content-Type") }.
+        should have_been_made
+    end
+
+    it "adds a Content-Length header to the request" do
+      middleware = described_class.new(@request)
+      middleware.call(@request.env)
+      a_request(:post, @url).
+        with {|req| req.headers.has_key?("Content-Length") }.
+        should have_been_made
+    end
+
+  end
+end

data/spec/weary/middleware/oauth_spec.rb

@@ -0,0 +1,27 @@
+require 'weary/middleware/oauth'
+require 'spec_helper'
+
+describe Weary::Middleware::OAuth do
+  describe "#call" do
+    before do
+      @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      @request = Weary::Request.new @url
+      stub_request :get, @request.uri.to_s
+    end
+
+    it_behaves_like "a Rack application" do
+      subject { described_class.new(@request, "consumer_key", "access_token") }
+      let(:env) { @request.env }
+    end
+
+    it "prepares the Authorization header for the request" do
+      middleware = described_class.new(@request, "consumer_key", "access_token")
+      middleware.call(@request.env)
+      signed_header = middleware.sign(@request.env)
+      a_request(:get, @url).
+        with {|req| req.headers.has_key?("Authorization") }.
+        should have_been_made
+    end
+
+  end
+end

data/spec/weary/request_spec.rb

@@ -1,344 +1,256 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'spec_helper'
 
 describe Weary::Request do
-  
-  it 'creates a Net/HTTP connection' do
-    test = Weary::Request.new("http://google.com")
-    test.http.class.should == Net::HTTP
+  describe "#uri" do
+    subject { described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary" }
+
+    it_behaves_like "a URI" do
+      let(:uri) { subject.uri }
+    end
+
+    it "infers a port of 80" do
+      subject.uri.inferred_port.should eql 80
+    end
+
+    it "has a scheme of http" do
+      subject.uri.scheme.should eql 'http'
+    end
   end
-  
-  it 'maps to a Net/HTTPRequest class' do
-    test = Weary::Request.new("http://google.com")
-    test.connection.class.should == Net::HTTP::Get
+
+  describe "#uri=" do
+    context "given a URI string" do
+      subject { described_class.new "http://github.com/api/v2/json/user/show/mwunsch" }
+
+      it "sets the request URI" do
+        original_path = subject.uri.path
+        new_path = "/api/v2/json/repos/show/mwunsch/weary"
+        expect {
+          subject.uri = "http://github.com#{new_path}"
+        }.to change{subject.uri.path}.from(original_path).to(new_path)
+      end
+    end
+
+    context "given a URI object" do
+      subject { described_class.new "http://github.com/api/v2/json/user/show/mwunsch" }
+
+      it "sets the request URI" do
+        original_path = subject.uri.path
+        new_path = "/api/v2/json/repos/show/mwunsch/weary"
+        expect {
+          subject.uri = URI("http://github.com#{new_path}")
+        }.to change{subject.uri.path}.from(original_path).to(new_path)
+      end
+    end
   end
-  
-  describe 'Request' do
-    it 'prepares a Net/HTTP request' do
-      test = Weary::Request.new("http://google.com")
-      test.request.class.should == Net::HTTP::Get
-    end
-    
-    it 'prepares a body for POST' do
-      test = Weary::Request.new("http://foo.bar", :post)
-      test.with = {:name => "markwunsch"}
-      req = test.request
-      req.class.should == Net::HTTP::Post
-      req.body.should == test.with
-    end
-    
-    it 'sets up headers' do
-      test = Weary::Request.new("http://foo.bar")
-      test.headers = {"User-Agent" => Weary::UserAgents["Safari 4.0.2 - Mac"]}
-      req = test.request
-      req['User-Agent'].should == Weary::UserAgents["Safari 4.0.2 - Mac"]
-    end
-    
-    it 'has an authorization header when basic auth is used' do
-      test = Weary::Request.new("http://foo.bar")
-      test.credentials = {:username => "mark", :password => "secret"}
-      req = test.request
-      req.key?('Authorization').should == true
-    end
-    
-    it "prepares an oauth scheme if a token is provided" do
-      consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
-      token = OAuth::AccessToken.new(consumer, "token", "secret")
-      test = Weary::Request.new("http://foo.bar", :post)
-      test.credentials = token
-      test.request.oauth_helper.options[:token].should == token
+
+  describe "#method" do
+    before do
+      @uri = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    it "infers a GET request on initialization" do
+      r = described_class.new @uri
+      r.method.should eql "GET"
+    end
+
+    it "is a Rack-friendly token" do
+      r = described_class.new @uri, :get
+      r.method.should eql "GET"
     end
   end
-  
-  describe 'Options' do
-    it 'sets the credentials to basic authentication' do
-      basic_auth = {:username => 'mark', :password => 'secret'}
-      test = Weary::Request.new("http://foo.bar", :get, {:basic_auth => basic_auth})
-      test.credentials.should == basic_auth
+
+  describe "#method=" do
+    before do
+      uri = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      @request = described_class.new uri
     end
 
-    it 'sets the credentials to an oauth token' do
-      consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
-      token = OAuth::AccessToken.new(consumer, "token", "secret")
-      test = Weary::Request.new("http://foo.bar", :post, {:oauth => token})
-      test.credentials.should == token
+    it "transforms the http verb to a Rack-friendly token" do
+      expect {
+        @request.method = :head
+      }.to change{ @request.method }.from('GET').to('HEAD')
     end
+  end
+
+  describe "#env" do
+    let(:request) { described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary" }
 
-    it 'sets the body params' do
-      body = {:options => "something"}
-      test = Weary::Request.new("http://foo.bar", :post, {:body => body})
-      test.with.should == body.to_params
-      test2 = Weary::Request.new("http://foo.bar", :post, {:body => body.to_params})
-      test2.with.should == body.to_params
+    it_behaves_like "a Rack env" do
+      subject { request.env }
     end
 
-    it 'sets header values' do
-      head = {"User-Agent" => Weary::UserAgents["Safari 4.0.2 - Mac"]}
-      test = Weary::Request.new("http://foo.bar", :get, {:headers => head})
-      test.headers.should == head
+    it "includes the calling object in the hash" do
+      request.env["weary.request"].should be request
     end
 
-    it 'sets a following value for redirection' do
-      test = Weary::Request.new("http://foo.bar", :get, {:no_follow => true})
-      test.follows?.should == false
-      test = Weary::Request.new("http://foo.bar", :get, {:no_follow => false})
-      test.follows?.should == true
-      test = Weary::Request.new("http://foo.bar", :get)
-      test.follows?.should == true
+    it "infers a SERVER_PORT of 80" do
+      request.env["SERVER_PORT"].should eql "80"
     end
-    
-    it 'uses the #with hash to create a URI query string if the method is a GET' do
-      test = Weary::Request.new("http://foo.bar/path/to/something")
-      test.with = {:name => "markwunsch", :title => "awesome"}
-      test.uri.query.should == test.with
+
+    it "pulls the query string out of the uri" do
+      request.uri = "http://api.twitter.com/version/users/show.format?screen_name=markwunsch"
+      request.env['QUERY_STRING'].should eql 'screen_name=markwunsch'
     end
   end
-    
-  describe 'Perform' do
-    # These tests reveal tight coupling with Response API, which may or may not be a good thing
-    
-    after do
-      FakeWeb.clean_registry
-    end
-    
-    it 'performs the request and gets back a response' do
-      hello = "Hello from FakeWeb"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :body => hello)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      response = test.perform
-      response.class.should == Weary::Response
-      response.body.should == hello
-    end
-      
-    it 'follows redirection' do
-      hello = "Hello from FakeWeb"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
-      FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      response = test.perform
-      response.body.should == hello
-    end
-    
-    it 'will not follow redirection if disabled' do
-      hello = "Hello from FakeWeb"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
-      FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
-      
-      test = Weary::Request.new("http://markwunsch.com", :get, :no_follow => true)
-      response = test.perform
-      response.code.should == 301
-    end
-    
-    it 'passes the response into a callback' do
-      hello = "Hello from FakeWeb"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :body => hello)
-      response_body = ""
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      test.perform do |response|
-        response_body = response.body
-      end
-      
-      response_body.should == hello
-    end
-    
-    it 'performs the callback even when redirected' do
-      hello = "Hello from FakeWeb"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
-      FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
-      
-      response_body = ""
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      test.perform do |response|
-        response_body = response.body
-      end
-      
-      response_body.should == hello
-    end
-    
-    it 'authorizes with basic authentication' do
-      message = 'You are authorized to do that.'
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(401))
-      FakeWeb.register_uri(:get, "http://mark:secret@markwunsch.com", :body => message)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      response = test.perform
-      response.code.should == 401
-      response.body.should_not == message
-      test.credentials = {:username => 'mark', :password => 'secret'}
-      response = test.perform
-      response.code.should == 200
-      response.body.should == message
-    end
-    
-    it 'still authorizes correctly if redirected' do
-      message = 'You are authorized to do that.'
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(401))
-      FakeWeb.register_uri(:get, "http://mark:secret@markwunsch.com", :status => http_status_message(301), :Location => 'http://markwunsch.net')
-      FakeWeb.register_uri(:get, "http://markwunsch.net", :status => http_status_message(401))
-      FakeWeb.register_uri(:get, "http://mark:secret@markwunsch.net", :body => message)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      test.credentials = {:username => 'mark', :password => 'secret'}
-      response = test.perform
-      response.code.should == 200
-      response.body.should == message
-    end
-    
-    it 'converts parameters to url query strings' do
-      params = {:id => 'mark', :message => 'hello'}
-      message = "Using FakeWeb with params of #{params.to_params}"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(403))
-      FakeWeb.register_uri(:get, "http://markwunsch.com?#{params.to_params}", :body => message)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      test.with = params
-      response = test.perform
-      response.body.should == message
-    end
-    
-    it 'sends query strings correctly when redirected' do
-      params = {:id => 'mark', :message => 'hello'}
-      message = "Using FakeWeb with params of #{params.to_params}"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(403))
-      FakeWeb.register_uri(:get, "http://markwunsch.net", :status => http_status_message(403))
-      FakeWeb.register_uri(:get, "http://markwunsch.com?#{params.to_params}", :status => http_status_message(301), :Location => 'http://markwunsch.net')
-      FakeWeb.register_uri(:get, "http://markwunsch.net?#{params.to_params}", :body => message)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      test.with = params
-      response = test.perform
-      response.code.should == 200
-    end
-    
-    it 'converts parameters to request body on post' do
-      params = {:id => 'mark', :message => 'hello'}
-      message = "Using FakeWeb with params of #{params.to_params}"
-      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(403))
-      FakeWeb.register_uri(:post, "http://markwunsch.com", :body => message)
-      
-      test = Weary::Request.new("http://markwunsch.com")
-      test.via = :post
-      test.with = params
-      response = test.perform
-      response.code.should == 200
-      response.body.should == message
-      
-      # No way of testing Request bodies with FakeWeb as of 1.2.7 
-    end    
-  
-    describe 'Non-Blocking, Threaded' do
-      # Not exactly sure the best way to test these
-      
-      it 'creates a new thread to perform the request' do
-        hello = "Hello from FakeWeb"
-        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => hello)
-
-        test = Weary::Request.new("http://markwunsch.com")
-        test.perform!.value.body.should == hello
-      end
-      
-      it "sets its callback" do
-        msg = "You did it!"
-        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
-        test = Weary::Request.new("http://markwunsch.com")
-        body = ""
-
-        thread = test.perform! do |r|
-          body = r.body
-        end
-        body = thread.value.body
-        body.should == msg
-      end
+
+  describe "#headers" do
+    subject { described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary" }
+    let(:hash) { {'User-Agent' => Weary::USER_AGENTS['Lynx 2.8.4rel.1 on Linux']} }
+
+    it "sets headers for the request" do
+      subject.headers(hash)
+      subject.instance_variable_get(:@headers).should eql hash
+    end
+
+    it "gets previously set headers" do
+      subject.headers(hash)
+      subject.headers.should eql hash
+    end
+
+    it "updates the env with the Rack-friendly key" do
+      subject.headers(hash)
+      subject.env.should have_key('HTTP_USER_AGENT')
+    end
+
+    it "updates the env with its HTTP_* value" do
+      subject.headers(hash)
+      subject.env['HTTP_USER_AGENT'].should eql(hash.values.first)
     end
   end
-  
-  describe 'Callbacks' do
-    after do
-      FakeWeb.clean_registry
-    end
-    
-    describe 'on_complete' do
-      it 'stores the callback' do
-        test = Weary::Request.new("http://markwunsch.com")
-        test.on_complete do
-          'hello'
-        end
-        test.on_complete.call.should == 'hello'
-      end
-      
-      it 'accepts a block, and the block becomes the callback' do
-        msg = "You did it!"
-        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
-        test = Weary::Request.new("http://markwunsch.com")
-        body = ""
-
-        test.on_complete do |response|
-          body = response.body
-        end
 
-        test.perform
-        body.should == msg
-      end
+  describe "#user_agent" do
+    subject { described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary" }
+    let(:agent) { 'RSpec' }
 
-      it 'is overriden when a block is passed to the perform method' do
-        msg = "You did it!"
-        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
-        test = Weary::Request.new("http://markwunsch.com")
-        body = ""
+    it "updates the #headers hash with a User-Agent" do
+      subject.user_agent agent
+      subject.headers.should have_key 'User-Agent'
+    end
 
-        test.on_complete do |response|
-          body = response.body
-        end
-        test.perform
-        body.should == msg
+    it "sets the user agent for the headers" do
+      subject.user_agent agent
+      subject.headers['User-Agent'].should be agent
+    end
+  end
 
-        test.perform do |response|
-          body = 'Now it is different'
-        end
+  describe "#params" do
+    it "sets the query string for a GET request" do
+      req = described_class.new "http://api.twitter.com/version/users/show.json"
+      req.params :screen_name => 'markwunsch'
+      req.uri.query.should eql "screen_name=markwunsch"
+    end
 
-        body.should == 'Now it is different'
-      end
+    it "sets the rack input for a POST request" do
+      req = described_class.new "https://api.github.com/gists", "POST"
+      req.params :public => true,
+               :files  => { "file1.txt" => { :content => "String file contents"}}
+      req.env['rack.input'].read.should eql req.params
     end
-    
-    describe 'before_send' do
-      it 'stores the callback' do
-        test = Weary::Request.new("http://markwunsch.com")
-        test.before_send do
-          'hello'
-        end
-        test.before_send.call.should == 'hello'
-      end
-      
-      it 'accepts a block, and the block becomes the callback' do
-        msg = "You did it!"
-        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
-        test = Weary::Request.new("http://markwunsch.com")
-        body = ""
-
-        test.before_send do
-          body = msg
-        end
-        body.should_not == msg
-        test.perform
-        body.should == msg
-      end
-      
-      it 'takes the Request as an argument, so it can be manipulate before sending' do
-        hello = "Hello from FakeWeb"
-        FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
-        FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
-        
-        test = Weary::Request.new("http://markwunsch.com")
-        test.before_send do |req|
-          req.follows = false
+
+    it "adds a Middleware to the stack for the Content-Type and Length" do
+      req = described_class.new "https://api.github.com/gists", "POST"
+      req.should_receive(:use).with(Weary::Middleware::ContentType)
+      req.params :foo => "baz"
+    end
+  end
+
+  describe "#json" do
+    it "sets the request body to be a json string from a hash" do
+      hash = {:foo => 'baz'}
+      req = described_class.new "https://api.github.com/gists", "POST"
+      req.json hash
+      req.env['rack.input'].read.should eql MultiJson.encode(hash)
+    end
+  end
+
+  describe "#basic_auth" do
+    it "adds a Middleware to the stack to handle authentication" do
+      req = described_class.new "https://api.github.com/gists", "POST"
+      cred = ["mwunsch", "secret-passphrase"]
+      req.should_receive(:use).with(Weary::Middleware::BasicAuth, cred)
+      req.basic_auth *cred
+    end
+
+    it "returns true if auth has been set" do
+      req = described_class.new "https://api.github.com/gists", "POST"
+      cred = ["mwunsch", "secret-passphrase"]
+      req.basic_auth *cred
+      req.basic_auth.should be_true
+    end
+  end
+
+  describe "#oauth" do
+    it "adds a Middleware to the stack to sign the request" do
+      req = described_class.new "https://api.github.com/gists", "POST"
+      cred = ["consumer_key", "access_token"]
+      req.should_receive(:use).with(Weary::Middleware::OAuth, cred)
+      req.oauth *cred
+    end
+
+    it "returns true if auth has been set" do
+      req = described_class.new "https://api.github.com/gists", "POST"
+      cred = ["consumer_key", "access_token"]
+      req.oauth *cred
+      req.oauth.should be_true
+    end
+  end
+
+  describe "#adapter" do
+    subject { described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary" }
+
+    it "sets a new adapter to set the connection" do
+      klass = Class.new { include Weary::Adapter }
+      subject.adapter(klass)
+      subject.adapter.should be klass
+    end
+
+    it "defaults to the Net::HTTP adapter" do
+      subject.adapter.should be Weary::Adapter::NetHttp
+    end
+  end
+
+  describe "#perform" do
+    subject do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      described_class.new url
+    end
+
+    before do
+      stub_request(:get, subject.uri.to_s).
+        to_rack(lambda{|env| [200, {'Content-Type' => 'text/html'}, ['']]})
+    end
+
+    it "returns a future containing a Weary::Response" do
+      subject.perform.should be_a Weary::Response
+    end
+
+    it "accepts an optional block" do
+      code = nil
+      subject.perform {|response| code = response.status }.force
+      code.should be >= 100
+    end
+  end
+
+  describe "#use" do
+    it "adds a middleware to the stack" do
+      req = described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      req.adapter(Class.new { include Weary::Adapter })
+      # Rack::Runtime sets an "X-Runtime" response header
+      # http://rack.rubyforge.org/doc/Rack/Runtime.html
+      req.use Rack::Runtime, "RSpec"
+      code, headers, body = req.call({})
+      headers.should have_key "X-Runtime-RSpec"
+    end
+  end
+
+  describe "#call" do
+    it_behaves_like "a Rack application" do
+      subject {
+        described_class.new "http://github.com/api/v2/json/repos/show/mwunsch/weary" do |req|
+          req.adapter Class.new { include Weary::Adapter }
         end
-        
-        test.perform.code.should == 301
-      end
+      }
+      let(:env) { subject.env }
     end
   end
-  
 end