jlind-twitter 0.9.9

data/test/twitter/geo_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class GeoTest < Test::Unit::TestCase
+  include Twitter
+
+  context "Geographic place lookup" do
+
+    should "work" do
+      stub_get 'http://api.twitter.com/1/geo/id/ea76a36c5bc2bdff.json', 'geo_place.json'
+      place = Geo.place('ea76a36c5bc2bdff')
+      place.country.should == 'The United States of America'
+      place.full_name.should == 'Ballantyne West, Charlotte'
+      place.geometry.coordinates.should be_kind_of(Array)
+    end
+
+  end
+
+  context "Geographic search" do
+
+    should "work" do
+      stub_get 'http://api.twitter.com:80/1/geo/search.json?lat=35.061161&long=-80.854568', 'geo_search.json'
+      places = Geo.search(:lat => 35.061161, :long => -80.854568)
+      places.size.should == 3
+      places[0].full_name.should eql('Ballantyne West, Charlotte')
+      places[0].name.should eql('Ballantyne West')
+    end
+
+    should "be able to search with free form text" do
+      stub_get 'http://api.twitter.com/1/geo/search.json?query=princeton%20record%20exchange', 'geo_search_query.json'
+      places = Geo.search(:query => 'princeton record exchange')
+      places.size.should == 1
+      places[0].name.should eql('Princeton Record Exchange')
+      places[0].place_type.should eql('poi')
+      places[0].attributes.street_address.should eql('20 S Tulane St')
+    end
+
+    should "be able to search by ip address" do
+      stub_get 'http://api.twitter.com/1/geo/search.json?ip=74.125.19.104', 'geo_search_ip_address.json'
+      places = Geo.search(:ip => '74.125.19.104')
+      places.size.should == 4
+      places[0].full_name.should eql("Mountain View, CA")
+      places[0].name.should eql("Mountain View")
+      places[1].full_name.should eql("Sunnyvale, CA")
+      places[1].name.should eql('Sunnyvale')
+    end
+
+  end
+
+  context "Geographic reverse_geocode" do
+
+    should "work" do
+      stub_get 'http://api.twitter.com:80/1/geo/reverse_geocode.json?lat=35.061161&long=-80.854568', 'geo_reverse_geocode.json'
+      places = Geo.reverse_geocode(:lat => 35.061161, :long => -80.854568)
+      places.size.should == 4
+      places[0].full_name.should eql('Ballantyne West, Charlotte')
+      places[0].name.should eql('Ballantyne West')
+    end
+
+    should "be able to limit the number of results returned" do
+      stub_get 'http://api.twitter.com/1/geo/reverse_geocode.json?lat=35.061161&max_results=2&long=-80.854568', 'geo_reverse_geocode_limit.json'
+      places = Geo.reverse_geocode(:lat => 35.061161, :long => -80.854568, :max_results => 2)
+      places.size.should == 2
+      places[0].full_name.should eql('Ballantyne West, Charlotte')
+      places[0].name.should eql('Ballantyne West')
+    end
+
+    should "be able to lookup with granularity" do
+      stub_get 'http://api.twitter.com/1/geo/reverse_geocode.json?lat=35.061161&long=-80.854568&granularity=city', 'geo_reverse_geocode_granularity.json'
+      places = Geo.reverse_geocode(:lat => 35.061161, :long => -80.854568, :granularity => 'city')
+      places.size.should == 3
+      places[0].full_name.should eql('Charlotte, NC')
+      places[0].name.should eql('Charlotte')
+      places[1].full_name.should eql('North Carolina, US')
+      places[1].name.should eql('North Carolina')
+    end
+
+  end
+
+end

data/test/twitter/httpauth_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+class HTTPAuthTest < Test::Unit::TestCase
+  context "Creating new instance" do
+    should "should take user and password" do
+      twitter = Twitter::HTTPAuth.new('username', 'password')
+      twitter.username.should == 'username'
+      twitter.password.should == 'password'
+    end
+
+    should "accept options" do
+      twitter = Twitter::HTTPAuth.new('username', 'password', :ssl => true)
+      twitter.options.should == {:ssl => true}
+    end
+
+    should "default ssl to false" do
+      twitter = Twitter::HTTPAuth.new('username', 'password')
+      twitter.options[:ssl].should be(false)
+    end
+
+    should "use https if ssl is true" do
+      Twitter::HTTPAuth.expects(:base_uri).with('https://api.twitter.com/' + Twitter::API_VERSION)
+      twitter = Twitter::HTTPAuth.new('username', 'password', :ssl => true)
+    end
+
+    should "use http if ssl is false" do
+      Twitter::HTTPAuth.expects(:base_uri).with('http://api.twitter.com/' + Twitter::API_VERSION)
+      twitter = Twitter::HTTPAuth.new('username', 'password', :ssl => false)
+    end
+
+    should "use api version if provided" do
+      Twitter::HTTPAuth.expects(:base_uri).with('http://api.twitter.com/2')
+      twitter = Twitter::HTTPAuth.new('username', 'password', {:ssl => false, :api_version => 2})
+    end
+
+    should "not use api versioning if api_version is false " do
+      Twitter::HTTPAuth.expects(:base_uri).with('http://api.twitter.com')
+      twitter = Twitter::HTTPAuth.new('username', 'password', {:ssl => false, :api_version => false})
+    end
+  end
+
+  context "Client methods" do
+    setup do
+      @twitter = Twitter::HTTPAuth.new('username', 'password')
+    end
+
+    should "not throw error when accessing response message" do
+      stub_get('http://api.twitter.com:80/1/statuses/user_timeline.json', 'user_timeline.json')
+      response = @twitter.get('/statuses/user_timeline.json')
+      response.message.should == 'OK'
+    end
+
+    should "be able to get" do
+      stub_get('http://username:password@api.twitter.com:80/1/statuses/user_timeline.json', 'user_timeline.json')
+      response = @twitter.get('/statuses/user_timeline.json')
+      response.should == fixture_file('user_timeline.json')
+    end
+
+    should "be able to get with headers" do
+      @twitter.class.expects(:get).with(
+        '/statuses/user_timeline.json', {
+          :basic_auth => {:username => 'username', :password => 'password'},
+          :headers => {'Foo' => 'Bar'}
+        }
+      ).returns(fixture_file('user_timeline.json'))
+      @twitter.get('/statuses/user_timeline.json', {'Foo' => 'Bar'})
+    end
+
+    should "be able to post" do
+      stub_post('http://username:password@api.twitter.com:80/1/statuses/update.json', 'status.json')
+      response = @twitter.post('/statuses/update.json', :text => 'My update.')
+      response.should == fixture_file('status.json')
+    end
+
+    should "be able to post with headers" do
+      @twitter.class.expects(:post).with(
+        '/statuses/update.json', {
+          :headers => {'Foo' => 'Bar'},
+          :body => {:text => 'My update.'},
+          :basic_auth => {:username => 'username', :password => 'password'}
+        }
+      ).returns(fixture_file('status.json'))
+      @twitter.post('/statuses/update.json', {:text => 'My update.'}, {'Foo' => 'Bar'})
+    end
+  end
+end

data/test/twitter/oauth_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class OAuthTest < Test::Unit::TestCase
+  should "initialize with consumer token and secret" do
+    twitter = Twitter::OAuth.new('token', 'secret')
+
+    twitter.ctoken.should == 'token'
+    twitter.csecret.should == 'secret'
+  end
+
+  should "set authorization path to '/oauth/authorize' by default" do
+    twitter = Twitter::OAuth.new('token', 'secret')
+    twitter.consumer.options[:authorize_path].should == '/oauth/authorize'
+  end
+
+  should "set authorization path to '/oauth/authenticate' if sign_in_with_twitter" do
+    twitter = Twitter::OAuth.new('token', 'secret', :sign_in => true)
+    twitter.consumer.options[:authorize_path].should == '/oauth/authenticate'
+  end
+
+  should "have a consumer" do
+    consumer = mock('oauth consumer')
+    OAuth::Consumer.expects(:new).with('token', 'secret', {:site => 'http://api.twitter.com'}).returns(consumer)
+    twitter = Twitter::OAuth.new('token', 'secret')
+
+    twitter.consumer.should == consumer
+  end
+
+  should "have a request token from the consumer" do
+    consumer = mock('oauth consumer')
+    request_token = mock('request token')
+    consumer.expects(:get_request_token).returns(request_token)
+    OAuth::Consumer.expects(:new).with('token', 'secret', {:site => 'http://api.twitter.com', :request_endpoint => 'http://api.twitter.com'}).returns(consumer)
+    twitter = Twitter::OAuth.new('token', 'secret')
+
+    twitter.request_token.should == request_token
+  end
+
+  context "set_callback_url" do
+    should "clear request token and set the callback url" do
+      consumer = mock('oauth consumer')
+      request_token = mock('request token')
+
+      OAuth::Consumer.
+        expects(:new).
+        with('token', 'secret', {:site => 'http://api.twitter.com', :request_endpoint => 'http://api.twitter.com'}).
+        returns(consumer)
+
+      twitter = Twitter::OAuth.new('token', 'secret')
+
+      consumer.
+        expects(:get_request_token).
+        with({:oauth_callback => 'http://myapp.com/oauth_callback'})
+
+      twitter.set_callback_url('http://myapp.com/oauth_callback')
+    end
+  end
+
+  should "be able to create access token from request token, request secret and verifier" do
+    twitter = Twitter::OAuth.new('token', 'secret')
+    consumer = OAuth::Consumer.new('token', 'secret', {:site => 'http://api.twitter.com'})
+    twitter.stubs(:signing_consumer).returns(consumer)
+
+    access_token  = mock('access token', :token => 'atoken', :secret => 'asecret')
+    request_token = mock('request token')
+    request_token.
+      expects(:get_access_token).
+      with(:oauth_verifier => 'verifier').
+      returns(access_token)
+
+    OAuth::RequestToken.
+      expects(:new).
+      with(consumer, 'rtoken', 'rsecret').
+      returns(request_token)
+
+    twitter.authorize_from_request('rtoken', 'rsecret', 'verifier')
+    twitter.access_token.class.should be(OAuth::AccessToken)
+    twitter.access_token.token.should == 'atoken'
+    twitter.access_token.secret.should == 'asecret'
+  end
+
+  should "be able to create access token from access token and secret" do
+    twitter = Twitter::OAuth.new('token', 'secret')
+    consumer = OAuth::Consumer.new('token', 'secret', {:site => 'http://api.twitter.com'})
+    twitter.stubs(:consumer).returns(consumer)
+
+    twitter.authorize_from_access('atoken', 'asecret')
+    twitter.access_token.class.should be(OAuth::AccessToken)
+    twitter.access_token.token.should == 'atoken'
+    twitter.access_token.secret.should == 'asecret'
+  end
+
+  should "delegate get to access token" do
+    access_token = mock('access token')
+    twitter = Twitter::OAuth.new('token', 'secret')
+    twitter.stubs(:access_token).returns(access_token)
+    access_token.expects(:get).returns(nil)
+    twitter.get('/foo')
+  end
+
+  should "delegate post to access token" do
+    access_token = mock('access token')
+    twitter = Twitter::OAuth.new('token', 'secret')
+    twitter.stubs(:access_token).returns(access_token)
+    access_token.expects(:post).returns(nil)
+    twitter.post('/foo')
+  end
+
+  [:get, :put, :post, :delete].each do |method|
+    should "#{method} with api version if provided" do
+      access_token = mock('access token')
+      twitter = Twitter::OAuth.new('token', 'secret', :api_version => 2)
+      twitter.stubs(:access_token).returns(access_token)
+      access_token.expects(method).with('/2/foo').returns(nil)
+      access_token.expects(method).with('/foo').never
+      twitter.send(method, '/foo')
+    end
+
+    should "not #{method} with api versioning if api_version is false" do
+      access_token = mock('access token')
+      twitter = Twitter::OAuth.new('token', 'secret', :api_version => false)
+      twitter.stubs(:access_token).returns(access_token)
+      access_token.expects(method).with('/foo')
+      twitter.send(method, '/foo')
+    end
+  end
+end

data/test/twitter/request_test.rb

@@ -0,0 +1,217 @@
+require 'test_helper'
+
+class RequestTest < Test::Unit::TestCase
+  context "new get request" do
+    setup do
+      @client = mock('twitter client')
+      @request = Twitter::Request.new(@client, :get, '/1/statuses/user_timeline.json', {:query => {:since_id => 1234}})
+    end
+
+    should "have client" do
+      @request.client.should == @client
+    end
+
+    should "have method" do
+      @request.method.should == :get
+    end
+
+    should "have path" do
+      @request.path.should == '/1/statuses/user_timeline.json'
+    end
+
+    should "have options" do
+      @request.options[:query].should == {:since_id => 1234}
+    end
+
+    should "have uri" do
+      @request.uri.should == '/1/statuses/user_timeline.json?since_id=1234'
+    end
+
+    context "performing request for collection" do
+      setup do
+        response = mock('response') do
+          stubs(:body).returns(fixture_file('user_timeline.json'))
+          stubs(:code).returns('200')
+        end
+
+        @client.expects(:get).returns(response)
+        @object = @request.perform
+      end
+
+      should "return array of mashes" do
+        @object.size.should == 20
+        @object.each { |obj| obj.class.should be(Hashie::Mash) }
+        @object.first.text.should == 'Colder out today than expected. Headed to the Beanery for some morning wakeup drink. Latte or coffee...hmmm...'
+      end
+    end
+
+    context "performing a request for a single object" do
+      setup do
+        response = mock('response') do
+          stubs(:body).returns(fixture_file('status.json'))
+          stubs(:code).returns('200')
+        end
+
+        @client.expects(:get).returns(response)
+        @object = @request.perform
+      end
+
+      should "return a single mash" do
+        @object.class.should be(Hashie::Mash)
+        @object.text.should == 'Rob Dyrdek is the funniest man alive. That is all.'
+      end
+    end
+
+    context "with no query string" do
+      should "not have any query string" do
+        request = Twitter::Request.new(@client, :get, '/1/statuses/user_timeline.json')
+        request.uri.should == '/1/statuses/user_timeline.json'
+      end
+    end
+
+    context "with blank query string" do
+      should "not have any query string" do
+        request = Twitter::Request.new(@client, :get, '/1/statuses/user_timeline.json', :query => {})
+        request.uri.should == '/1/statuses/user_timeline.json'
+      end
+    end
+
+    should "have get shortcut to initialize and perform all in one" do
+      Twitter::Request.any_instance.expects(:perform).returns(nil)
+      Twitter::Request.get(@client, '/foo')
+    end
+
+    should "allow setting query string and headers" do
+      response = mock('response') do
+        stubs(:body).returns('')
+        stubs(:code).returns('200')
+      end
+
+      @client.expects(:get).with('/1/statuses/friends_timeline.json?since_id=1234', {'Foo' => 'Bar'}).returns(response)
+      Twitter::Request.get(@client, '/1/statuses/friends_timeline.json?since_id=1234', :headers => {'Foo' => 'Bar'})
+    end
+  end
+
+  context "new post request" do
+    setup do
+      @client = mock('twitter client')
+      @request = Twitter::Request.new(@client, :post, '/1/statuses/update.json', {:body => {:status => 'Woohoo!'}})
+    end
+
+    should "allow setting body and headers" do
+      response = mock('response') do
+        stubs(:body).returns('')
+        stubs(:code).returns('200')
+      end
+
+      @client.expects(:post).with('/1/statuses/update.json', {:status => 'Woohoo!'}, {'Foo' => 'Bar'}).returns(response)
+      Twitter::Request.post(@client, '/1/statuses/update.json', :body => {:status => 'Woohoo!'}, :headers => {'Foo' => 'Bar'})
+    end
+
+    context "performing request" do
+      setup do
+        response = mock('response') do
+          stubs(:body).returns(fixture_file('status.json'))
+          stubs(:code).returns('200')
+        end
+
+        @client.expects(:post).returns(response)
+        @object = @request.perform
+      end
+
+      should "return a mash of the object" do
+        @object.text.should == 'Rob Dyrdek is the funniest man alive. That is all.'
+      end
+    end
+
+    should "have post shortcut to initialize and perform all in one" do
+      Twitter::Request.any_instance.expects(:perform).returns(nil)
+      Twitter::Request.post(@client, '/foo')
+    end
+  end
+
+  context "error raising" do
+    setup do
+      oauth = Twitter::OAuth.new('token', 'secret')
+      oauth.authorize_from_access('atoken', 'asecret')
+      @client = Twitter::Base.new(oauth)
+    end
+
+    should "not raise error for 200" do
+      stub_get('http://api.twitter.com:80/foo', '', ['200'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should_not raise_error
+    end
+
+    should "not raise error for 304" do
+      stub_get('http://api.twitter.com:80/foo', '', ['304'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should_not raise_error
+    end
+
+    should "raise RateLimitExceeded for 400" do
+      stub_get('http://api.twitter.com:80/foo', 'rate_limit_exceeded.json', ['400'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::RateLimitExceeded)
+    end
+
+    should "raise Unauthorized for 401" do
+      stub_get('http://api.twitter.com:80/foo', '', ['401'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::Unauthorized)
+    end
+
+    should "raise General for 403" do
+      stub_get('http://api.twitter.com:80/foo', '', ['403'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::General)
+    end
+
+    should "raise NotFound for 404" do
+      stub_get('http://api.twitter.com:80/foo', '', ['404'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::NotFound)
+    end
+
+    should "raise InformTwitter for 500" do
+      stub_get('http://api.twitter.com:80/foo', '', ['500'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::InformTwitter)
+    end
+
+    should "raise Unavailable for 502" do
+      stub_get('http://api.twitter.com:80/foo', '', ['502'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::Unavailable)
+    end
+
+    should "raise Unavailable for 503" do
+      stub_get('http://api.twitter.com:80/foo', '', ['503'])
+      lambda {
+        Twitter::Request.get(@client, '/foo')
+      }.should raise_error(Twitter::Unavailable)
+    end
+  end
+
+  context "Making request with mash option set to false" do
+    setup do
+      oauth = Twitter::OAuth.new('token', 'secret')
+      oauth.authorize_from_access('atoken', 'asecret')
+      @client = Twitter::Base.new(oauth)
+    end
+
+    should "not attempt to create mash of return object" do
+      stub_get('http://api.twitter.com:80/foo', 'friend_ids.json')
+      object = Twitter::Request.get(@client, '/foo', :mash => false)
+      object.class.should_not be(Hashie::Mash)
+    end
+  end
+end